List Transforms

/**
 * Toggles list formatting on selected blocks
 * @param editor - The Slate editor instance
 * @param options - Options for list configuration
 * @param getSiblingListOptions - Options for sibling list queries
 */
function toggleList<N extends ElementOf<E>, E extends SlateEditor = SlateEditor>(
  editor: E,
  options: ListOptions,
  getSiblingListOptions?: GetSiblingListOptions<N, E>
): void;

import { toggleList, ListStyleType } from "@udecode/plate-list";

// Toggle bullet list
toggleList(editor, {
  listStyleType: ListStyleType.Disc,
});

// Toggle numbered list
toggleList(editor, {
  listStyleType: ListStyleType.Decimal,
});

// Toggle list with custom restart number
toggleList(editor, {
  listStyleType: ListStyleType.Decimal,
  listRestart: 5, // Start numbering from 5
});

/**
 * Increases the indentation of selected blocks
 * @param editor - The Slate editor instance
 * @param options - Options for list configuration
 */
function indentList(
  editor: SlateEditor, 
  options?: { listStyleType?: ListStyleType | string } & ListOptions
): void;

import { indentList, ListStyleType } from "@udecode/plate-list";

// Simple indentation
indentList(editor);

// Indent with specific list style
indentList(editor, {
  listStyleType: ListStyleType.Circle,
});

/**
 * Decreases the indentation of selected blocks
 * @param editor - The Slate editor instance
 * @param options - Options for list configuration
 */
function outdentList(editor: SlateEditor, options: ListOptions = {}): void;

import { outdentList } from "@udecode/plate-list";

// Simple outdentation
outdentList(editor);

// Outdent with options
outdentList(editor, {
  at: specificPath, // Target specific location
});

/**
 * Increases indentation and converts to todo list
 * @param editor - The Slate editor instance
 * @param options - Options for list configuration
 */
function indentTodo(
  editor: SlateEditor, 
  options: ListOptions = {}
): void;

import { indentTodo } from "@udecode/plate-list";

// Convert to todo list with indentation
indentTodo(editor);

/**
 * Sets a single node as a list item
 * @param editor - The Slate editor instance
 * @param options - Options including path, indent, and list style type
 */
function setListNode(
  editor: Editor,
  options: {
    at: Path;
    indent?: number;
    listStyleType?: string;
  }
): void;

/**
 * Sets a single node as a todo list item with checkbox functionality
 * @param editor - The Slate editor instance
 * @param options - Options including path, indent, and list style type
 */
function setIndentTodoNode(
  editor: Editor,
  options: {
    at: Path;
    indent?: number;
    listStyleType?: string;
  }
): void;

import { setIndentTodoNode } from "@udecode/plate-list";

// Convert specific node to todo list item
setIndentTodoNode(editor, {
  at: [0, 1], // Path to target node
  indent: 2,
  listStyleType: 'todo'
});

/**
 * Sets multiple nodes as list items
 * @param editor - The Slate editor instance
 * @param entries - Array of node entries to convert
 * @param options - Options including list style type
 */
function setListNodes(
  editor: Editor,
  entries: NodeEntry[],
  options: { listStyleType?: string }
): void;

import { setListNodes, ListStyleType } from "@udecode/plate-list";

// Get selected nodes
const entries = Array.from(Editor.nodes(editor, {
  match: n => Element.isElement(n) && !n.listStyleType
}));

// Convert all to bullet lists
setListNodes(editor, entries, {
  listStyleType: ListStyleType.Disc
});

/**
 * Sets list properties on entry and its siblings
 * @param editor - The Slate editor instance
 * @param entry - The reference entry
 * @param options - Options for sibling detection and list style type
 */
function setListSiblingNodes<N extends ElementOf<E>, E extends Editor = Editor>(
  editor: E,
  entry: ElementEntryOf<E>,
  options: {
    getSiblingListOptions?: GetSiblingListOptions<N, E>;
    listStyleType?: string;
  }
): void;

/**
 * Toggles list formatting at a specific path
 * @param editor - The Slate editor instance
 * @param entry - The node entry to toggle
 * @param listStyleType - The list style type to apply
 */
function toggleListByPath(
  editor: SlateEditor,
  entry: NodeEntry,
  listStyleType: string
): void;

/**
 * Removes list formatting at a specific path
 * @param editor - The Slate editor instance
 * @param entry - The node entry to unformat
 */
function toggleListByPathUnSet(
  editor: SlateEditor,
  entry: NodeEntry
): void;

/**
 * Sets list formatting if not already set
 * @param editor - The Slate editor instance
 * @param entry - The node entry to format
 * @param options - Options for list configuration
 * @returns Boolean indicating if formatting was applied, undefined if no change
 */
function toggleListSet(
  editor: Editor,
  entry: NodeEntry,
  options: ListOptions
): boolean | undefined;

/**
 * Removes list formatting if already set
 * @param editor - The Slate editor instance
 * @param entry - The node entry to unformat
 * @param options - Options including list style type
 * @returns Boolean indicating if formatting was removed, undefined if no change
 */
function toggleListUnset(
  editor: Editor,
  entry: NodeEntry,
  options: { listStyleType?: string }
): boolean | undefined;

/**
 * Options for list transformation operations
 */
interface ListOptions {
  /** Specific location to apply transform (defaults to selection) */
  at?: TLocation;
  /** Restart list numbering from this value */
  listRestart?: number;
  /** Politely restart list numbering (only at list start) */
  listRestartPolite?: number;
  /** List style type to apply */
  listStyleType?: ListStyleType | string;
}

import { toggleList, indentList, outdentList, ListStyleType } from "@udecode/plate-list";

// Create bullet list
toggleList(editor, { listStyleType: ListStyleType.Disc });

// Create numbered list
toggleList(editor, { listStyleType: ListStyleType.Decimal });

// Increase indentation
indentList(editor);

// Decrease indentation
outdentList(editor);

import { 
  toggleList, 
  setListNodes, 
  setListSiblingNodes,
  ListStyleType 
} from "@udecode/plate-list";

// Apply consistent formatting to multiple nodes
const entries = Array.from(Editor.nodes(editor, {
  match: n => Element.isElement(n)
}));

setListNodes(editor, entries, {
  listStyleType: ListStyleType.Decimal
});

// Restart numbering at 10
toggleList(editor, {
  listStyleType: ListStyleType.Decimal,
  listRestart: 10
});

import { indentTodo, toggleList, ListStyleType } from "@udecode/plate-list";

// Convert to todo list
indentTodo(editor);

// Or use toggleList for todo formatting
toggleList(editor, {
  listStyleType: ListStyleType.Disc, // Style for todo items
});

import { 
  indentList, 
  outdentList, 
  getSiblingListStyleType,
  getListAbove 
} from "@udecode/plate-list";

// Smart indentation that matches sibling style
const currentList = getListAbove(editor);
if (currentList) {
  const siblingStyle = getSiblingListStyleType(editor, {
    entry: currentList,
    indent: 2, // Target indent level
    previous: true
  });
  
  indentList(editor, {
    listStyleType: siblingStyle
  });
}

toggleList(editor, {
  listStyleType: ListStyleType.Decimal,
  listRestart: 1 // Force restart at 1
});

toggleList(editor, {
  listStyleType: ListStyleType.Decimal,
  listRestartPolite: 1 // Only restart if at list start
});