@examind/block-types 0.1.18

package/types/lexical/LexicalUtils.ts

@@ -0,0 +1,304 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { CommandPayloadType, EditorThemeClasses, Klass, LexicalCommand, MutatedNodes, MutationListeners, NodeMutation, RegisteredNode, RegisteredNodes, Spread } from './LexicalEditor';
+import type { EditorState } from './LexicalEditorState';
+import type { LexicalNode, NodeKey, NodeMap } from './LexicalNode';
+import type { BaseSelection, PointType, RangeSelection } from './LexicalSelection';
+import type { RootNode } from './nodes/LexicalRootNode';
+import type { TextFormatType, TextNode } from './nodes/LexicalTextNode';
+import { DecoratorNode, ElementNode, LineBreakNode, UpdateTag } from '.';
+import { LexicalEditor } from './LexicalEditor';
+export declare const emptyFunction: () => void;
+export declare function resetRandomKey(): void;
+export declare function generateRandomKey(): string;
+export declare function getRegisteredNodeOrThrow(editor: LexicalEditor, nodeType: string): RegisteredNode;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const scheduleMicroTask: (fn: () => void) => void;
+export declare function $isSelectionCapturedInDecorator(node: Node): boolean;
+export declare function isSelectionCapturedInDecoratorInput(anchorDOM: Node): boolean;
+export declare function isSelectionWithinEditor(editor: LexicalEditor, anchorDOM: null | Node, focusDOM: null | Node): boolean;
+/**
+ * @returns true if the given argument is a LexicalEditor instance from this build of Lexical
+ */
+export declare function isLexicalEditor(editor: unknown): editor is LexicalEditor;
+export declare function getNearestEditorFromDOMNode(node: Node | null): LexicalEditor | null;
+/** @internal */
+export declare function getEditorPropertyFromDOMNode(node: Node | null): unknown;
+export declare function getTextDirection(text: string): 'ltr' | 'rtl' | null;
+/**
+ * Return true if the TextNode is a TabNode or is in token mode.
+ */
+export declare function $isTokenOrTab(node: TextNode): boolean;
+/**
+ * Return true if the TextNode is a TabNode, or is in token or segmented mode.
+ */
+export declare function $isTokenOrSegmented(node: TextNode): boolean;
+/**
+ * @param node - The element being tested
+ * @returns Returns true if node is an DOM Text node, false otherwise.
+ */
+export declare function isDOMTextNode(node: unknown): node is Text;
+/**
+ * @param node - The element being tested
+ * @returns Returns true if node is an DOM Document node, false otherwise.
+ */
+export declare function isDOMDocumentNode(node: unknown): node is Document;
+export declare function getDOMTextNode(element: Node | null): Text | null;
+export declare function toggleTextFormatType(format: number, type: TextFormatType, alignWithFormat: null | number): number;
+export declare function $isLeafNode(node: LexicalNode | null | undefined): node is TextNode | LineBreakNode | DecoratorNode<unknown>;
+export declare function $setNodeKey(node: LexicalNode, existingKey: NodeKey | null | undefined): void;
+/**
+ * Removes a node from its parent, updating all necessary pointers and links.
+ * @internal
+ *
+ * This function is for internal use of the library.
+ * Please do not use it as it may change in the future.
+ */
+export declare function removeFromParent(node: LexicalNode): void;
+export declare function internalMarkNodeAsDirty(node: LexicalNode): void;
+export declare function internalMarkSiblingsAsDirty(node: LexicalNode): void;
+export declare function $setCompositionKey(compositionKey: null | NodeKey): void;
+export declare function $getCompositionKey(): null | NodeKey;
+export declare function $getNodeByKey<T extends LexicalNode>(key: NodeKey, _editorState?: EditorState): T | null;
+export declare function $getNodeFromDOMNode(dom: Node, editorState?: EditorState): LexicalNode | null;
+export declare function setNodeKeyOnDOMNode(dom: Node, editor: LexicalEditor, key: NodeKey): void;
+export declare function getNodeKeyFromDOMNode(dom: Node, editor: LexicalEditor): NodeKey | undefined;
+export declare function $getNearestNodeFromDOMNode(startingDOM: Node, editorState?: EditorState): LexicalNode | null;
+export declare function cloneDecorators(editor: LexicalEditor): Record<NodeKey, unknown>;
+export declare function getEditorStateTextContent(editorState: EditorState): string;
+export declare function markNodesWithTypesAsDirty(editor: LexicalEditor, types: string[]): void;
+export declare function $getRoot(): RootNode;
+export declare function internalGetRoot(editorState: EditorState): RootNode;
+export declare function $setSelection(selection: null | BaseSelection): void;
+export declare function $flushMutations(): void;
+export declare function $getNodeFromDOM(dom: Node): null | LexicalNode;
+export declare function getTextNodeOffset(node: TextNode, moveSelectionToEnd: boolean): number;
+/**
+ * Return true if `str` contains any valid surrogate pair.
+ *
+ * See also $updateCaretSelectionForUnicodeCharacter for
+ * a discussion on when and why this is useful.
+ */
+export declare function doesContainSurrogatePair(str: string): boolean;
+export declare function getEditorsToPropagate(editor: LexicalEditor): Array<LexicalEditor>;
+export declare function createUID(): string;
+export declare function getAnchorTextFromDOM(anchorNode: Node): null | string;
+export declare function $updateSelectedTextFromDOM(isCompositionEnd: boolean, editor: LexicalEditor, data?: string): void;
+export declare function $updateTextNodeFromDOMContent(textNode: TextNode, textContent: string, anchorOffset: null | number, focusOffset: null | number, compositionEnd: boolean): void;
+export declare function $shouldInsertTextAfterOrBeforeTextNode(selection: RangeSelection, node: TextNode): boolean;
+/**
+ * A KeyboardEvent or structurally similar object with a string `key` as well
+ * as `altKey`, `ctrlKey`, `metaKey`, and `shiftKey` boolean properties.
+ */
+export type KeyboardEventModifiers = Pick<KeyboardEvent, 'key' | 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey'>;
+/**
+ * A record of keyboard modifiers that must be enabled.
+ * If the value is `'any'` then the modifier key's state is ignored.
+ * If the value is `true` then the modifier key must be pressed.
+ * If the value is `false` or the property is omitted then the modifier key must
+ * not be pressed.
+ */
+export type KeyboardEventModifierMask = {
+    [K in Exclude<keyof KeyboardEventModifiers, 'key'>]?: boolean | undefined | 'any';
+};
+/**
+ * Match a KeyboardEvent with its expected modifier state
+ *
+ * @param event A KeyboardEvent, or structurally similar object
+ * @param mask An object specifying the expected state of the modifiers
+ * @returns true if the event matches
+ */
+export declare function isModifierMatch(event: KeyboardEventModifiers, mask: KeyboardEventModifierMask): boolean;
+/**
+ * Match a KeyboardEvent with its expected state
+ *
+ * @param event A KeyboardEvent, or structurally similar object
+ * @param expectedKey The string to compare with event.key (case insensitive)
+ * @param mask An object specifying the expected state of the modifiers
+ * @returns true if the event matches
+ */
+export declare function isExactShortcutMatch(event: KeyboardEventModifiers, expectedKey: string, mask: KeyboardEventModifierMask): boolean;
+export declare function isTab(event: KeyboardEventModifiers): boolean;
+export declare function isBold(event: KeyboardEventModifiers): boolean;
+export declare function isItalic(event: KeyboardEventModifiers): boolean;
+export declare function isUnderline(event: KeyboardEventModifiers): boolean;
+export declare function isParagraph(event: KeyboardEventModifiers): boolean;
+export declare function isLineBreak(event: KeyboardEventModifiers): boolean;
+export declare function isOpenLineBreak(event: KeyboardEventModifiers): boolean;
+export declare function isDeleteWordBackward(event: KeyboardEventModifiers): boolean;
+export declare function isDeleteWordForward(event: KeyboardEventModifiers): boolean;
+export declare function isDeleteLineBackward(event: KeyboardEventModifiers): boolean;
+export declare function isDeleteLineForward(event: KeyboardEventModifiers): boolean;
+export declare function isDeleteBackward(event: KeyboardEventModifiers): boolean;
+export declare function isDeleteForward(event: KeyboardEventModifiers): boolean;
+export declare function isUndo(event: KeyboardEventModifiers): boolean;
+export declare function isRedo(event: KeyboardEventModifiers): boolean;
+export declare function isCopy(event: KeyboardEventModifiers): boolean;
+export declare function isCut(event: KeyboardEventModifiers): boolean;
+export declare function isMoveBackward(event: KeyboardEventModifiers): boolean;
+export declare function isMoveToStart(event: KeyboardEventModifiers): boolean;
+export declare function isMoveForward(event: KeyboardEventModifiers): boolean;
+export declare function isMoveToEnd(event: KeyboardEventModifiers): boolean;
+export declare function isMoveUp(event: KeyboardEventModifiers): boolean;
+export declare function isMoveDown(event: KeyboardEventModifiers): boolean;
+export declare function isModifier(event: KeyboardEventModifiers): boolean;
+export declare function isSpace(event: KeyboardEventModifiers): boolean;
+export declare function controlOrMeta(metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isBackspace(event: KeyboardEventModifiers): boolean;
+export declare function isEscape(event: KeyboardEventModifiers): boolean;
+export declare function isDelete(event: KeyboardEventModifiers): boolean;
+export declare function isSelectAll(event: KeyboardEventModifiers): boolean;
+export declare function $selectAll(selection?: RangeSelection | null): RangeSelection;
+export declare function getCachedClassNameArray(classNamesTheme: EditorThemeClasses, classNameThemeType: string): Array<string>;
+export declare function setMutatedNode(mutatedNodes: MutatedNodes, registeredNodes: RegisteredNodes, mutationListeners: MutationListeners, node: LexicalNode, mutation: NodeMutation): void;
+/**
+ * @deprecated Use {@link LexicalEditor.registerMutationListener} with `skipInitialization: false` instead.
+ */
+export declare function $nodesOfType<T extends LexicalNode>(klass: Klass<T>): Array<T>;
+export declare function $getAdjacentNode(focus: PointType, isBackward: boolean): null | LexicalNode;
+export declare function isFirefoxClipboardEvents(editor: LexicalEditor): boolean;
+export declare function dispatchCommand<TCommand extends LexicalCommand<unknown>>(editor: LexicalEditor, command: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+export declare function $textContentRequiresDoubleLinebreakAtEnd(node: ElementNode): boolean;
+export declare function getElementByKeyOrThrow(editor: LexicalEditor, key: NodeKey): HTMLElement;
+export declare function getParentElement(node: Node): HTMLElement | null;
+export declare function getDOMOwnerDocument(target: EventTarget | null): Document | null;
+export declare function scrollIntoViewIfNeeded(editor: LexicalEditor, selectionRect: DOMRect, rootElement: HTMLElement): void;
+export declare function $hasUpdateTag(tag: UpdateTag): boolean;
+export declare function $addUpdateTag(tag: UpdateTag): void;
+/**
+ * Add a function to run after the current update. This will run after any
+ * `onUpdate` function already supplied to `editor.update()`, as well as any
+ * functions added with previous calls to `$onUpdate`.
+ *
+ * @param updateFn The function to run after the current update.
+ */
+export declare function $onUpdate(updateFn: () => void): void;
+export declare function $maybeMoveChildrenSelectionToParent(parentNode: LexicalNode): BaseSelection | null;
+export declare function $hasAncestor(child: LexicalNode, targetNode: LexicalNode): boolean;
+export declare function getDefaultView(domElem: EventTarget | null): Window | null;
+export declare function getWindow(editor: LexicalEditor): Window;
+export declare function $isInlineElementOrDecoratorNode(node: LexicalNode): boolean;
+export declare function $getNearestRootOrShadowRoot(node: LexicalNode): RootNode | ElementNode;
+declare const ShadowRootNodeBrand: unique symbol;
+type ShadowRootNode = Spread<{
+    isShadowRoot(): true;
+    [ShadowRootNodeBrand]: never;
+}, ElementNode>;
+export declare function $isRootOrShadowRoot(node: null | LexicalNode): node is RootNode | ShadowRootNode;
+/**
+ * Returns a shallow clone of node with a new key
+ *
+ * @param node - The node to be copied.
+ * @returns The copy of the node.
+ */
+export declare function $copyNode<T extends LexicalNode>(node: T): T;
+export declare function $applyNodeReplacement<N extends LexicalNode>(node: N): N;
+export declare function errorOnInsertTextNodeOnRoot(node: LexicalNode, insertNode: LexicalNode): void;
+export declare function $getNodeByKeyOrThrow<N extends LexicalNode>(key: NodeKey): N;
+export declare function removeDOMBlockCursorElement(blockCursorElement: HTMLElement, editor: LexicalEditor, rootElement: HTMLElement): void;
+export declare function updateDOMBlockCursorElement(editor: LexicalEditor, rootElement: HTMLElement, nextSelection: null | BaseSelection): void;
+/**
+ * Returns the selection for the given window, or the global window if null.
+ * Will return null if {@link CAN_USE_DOM} is false.
+ *
+ * @param targetWindow The window to get the selection from
+ * @returns a Selection or null
+ */
+export declare function getDOMSelection(targetWindow: null | Window): null | Selection;
+/**
+ * Returns the selection for the defaultView of the ownerDocument of given EventTarget.
+ *
+ * @param eventTarget The node to get the selection from
+ * @returns a Selection or null
+ */
+export declare function getDOMSelectionFromTarget(eventTarget: null | EventTarget): null | Selection;
+export declare function $splitNode(node: ElementNode, offset: number): [ElementNode | null, ElementNode];
+export declare function $findMatchingParent(startingNode: LexicalNode, findFn: (node: LexicalNode) => boolean): LexicalNode | null;
+/**
+ * @param x - The element being tested
+ * @returns Returns true if x is an HTML anchor tag, false otherwise
+ */
+export declare function isHTMLAnchorElement(x: unknown): x is HTMLAnchorElement;
+/**
+ * @param x - The element being tested
+ * @returns Returns true if x is an HTML element, false otherwise.
+ */
+export declare function isHTMLElement(x: unknown): x is HTMLElement;
+/**
+ * @param x - The element being tested
+ * @returns Returns true if x is a DOM Node, false otherwise.
+ */
+export declare function isDOMNode(x: unknown): x is Node;
+/**
+ * @param x - The element being testing
+ * @returns Returns true if x is a document fragment, false otherwise.
+ */
+export declare function isDocumentFragment(x: unknown): x is DocumentFragment;
+/**
+ *
+ * @param node - the Dom Node to check
+ * @returns if the Dom Node is an inline node
+ */
+export declare function isInlineDomNode(node: Node): boolean;
+/**
+ *
+ * @param node - the Dom Node to check
+ * @returns if the Dom Node is a block node
+ */
+export declare function isBlockDomNode(node: Node): boolean;
+/**
+ * @internal
+ *
+ * This function is for internal use of the library.
+ * Please do not use it as it may change in the future.
+ *
+ * This function returns true for a DecoratorNode that is not inline OR
+ * an ElementNode that is:
+ * - not a root or shadow root
+ * - not inline
+ * - can't be empty
+ * - has no children or an inline first child
+ */
+export declare function INTERNAL_$isBlock(node: LexicalNode): node is ElementNode | DecoratorNode<unknown>;
+export declare function $getAncestor<NodeType extends LexicalNode = LexicalNode>(node: LexicalNode, predicate: (ancestor: LexicalNode) => ancestor is NodeType): NodeType | null;
+/**
+ * Utility function for accessing current active editor instance.
+ * @returns Current active editor
+ */
+export declare function $getEditor(): LexicalEditor;
+/** @internal */
+export type TypeToNodeMap = Map<string, NodeMap>;
+export declare function getCachedTypeToNodeMap(editorState: EditorState): TypeToNodeMap;
+/**
+ * Returns a clone of a node using `node.constructor.clone()` followed by
+ * `clone.afterCloneFrom(node)`. The resulting clone must have the same key,
+ * parent/next/prev pointers, and other properties that are not set by
+ * `node.constructor.clone` (format, style, etc.). This is primarily used by
+ * {@link LexicalNode.getWritable} to create a writable version of an
+ * existing node. The clone is the same logical node as the original node,
+ * do not try and use this function to duplicate or copy an existing node.
+ *
+ * Does not mutate the EditorState.
+ * @param node - The node to be cloned.
+ * @returns The clone of the node.
+ */
+export declare function $cloneWithProperties<T extends LexicalNode>(latestNode: T): T;
+export declare function setNodeIndentFromDOM(elementDom: HTMLElement, elementNode: ElementNode): void;
+/**
+ * @internal
+ *
+ * Mark this node as unmanaged by lexical's mutation observer like
+ * decorator nodes
+ */
+export declare function setDOMUnmanaged(elementDom: HTMLElement): void;
+/**
+ * @internal
+ *
+ * True if this DOM node was marked with {@link setDOMUnmanaged}
+ */
+export declare function isDOMUnmanaged(elementDom: Node): boolean;
+export {};

package/types/lexical/index.ts

@@ -0,0 +1,35 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+export * from './LexicalCommands';
+export * from './LexicalConstants';
+export * from './LexicalEditor';
+export * from './LexicalEditorState';
+export * from './LexicalEvents';
+export * from './LexicalGC';
+export * from './LexicalMutations';
+export * from './LexicalNode';
+export * from './LexicalNodeState';
+export * from './LexicalNormalization';
+export * from './LexicalReconciler';
+export * from './LexicalSelection';
+export * from './LexicalUpdateTags';
+export * from './LexicalUpdates';
+export * from './LexicalUtils';
+export * from './nodes/ArtificialNode';
+export * from './nodes/LexicalDecoratorNode';
+export * from './nodes/LexicalElementNode';
+export * from './nodes/LexicalLineBreakNode';
+export * from './nodes/LexicalParagraphNode';
+export * from './nodes/LexicalRootNode';
+export * from './nodes/LexicalTabNode';
+export * from './nodes/LexicalTextNode';
+
+// Plugin exports
+export * from './link';
+export * from './list';
+export * from './rich-text';
+export * from './table';

package/types/lexical/link/index.ts

@@ -0,0 +1,125 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { BaseSelection, DOMConversionMap, EditorConfig, LexicalCommand, LexicalNode, LexicalUpdateJSON, NodeKey, RangeSelection, SerializedElementNode } from './../';
+import { ElementNode, Spread } from './../';
+export type LinkAttributes = {
+    rel?: null | string;
+    target?: null | string;
+    title?: null | string;
+};
+export type AutoLinkAttributes = Partial<Spread<LinkAttributes, {
+    isUnlinked?: boolean;
+}>>;
+export type SerializedLinkNode = Spread<{
+    url: string;
+}, Spread<LinkAttributes, SerializedElementNode>>;
+type LinkHTMLElementType = HTMLAnchorElement | HTMLSpanElement;
+/** @noInheritDoc */
+export declare class LinkNode extends ElementNode {
+    /** @internal */
+    __url: string;
+    /** @internal */
+    __target: null | string;
+    /** @internal */
+    __rel: null | string;
+    /** @internal */
+    __title: null | string;
+    static getType(): string;
+    static clone(node: LinkNode): LinkNode;
+    constructor(url?: string, attributes?: LinkAttributes, key?: NodeKey);
+    createDOM(config: EditorConfig): LinkHTMLElementType;
+    updateLinkDOM(prevNode: this | null, anchor: LinkHTMLElementType, config: EditorConfig): void;
+    updateDOM(prevNode: this, anchor: LinkHTMLElementType, config: EditorConfig): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedLinkNode): LinkNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedLinkNode>): this;
+    sanitizeUrl(url: string): string;
+    exportJSON(): SerializedLinkNode | SerializedAutoLinkNode;
+    getURL(): string;
+    setURL(url: string): this;
+    getTarget(): null | string;
+    setTarget(target: null | string): this;
+    getRel(): null | string;
+    setRel(rel: null | string): this;
+    getTitle(): null | string;
+    setTitle(title: null | string): this;
+    insertNewAfter(_: RangeSelection, restoreSelection?: boolean): null | ElementNode;
+    canInsertTextBefore(): false;
+    canInsertTextAfter(): false;
+    canBeEmpty(): false;
+    isInline(): true;
+    extractWithChild(child: LexicalNode, selection: BaseSelection, destination: 'clone' | 'html'): boolean;
+    isEmailURI(): boolean;
+    isWebSiteURI(): boolean;
+}
+/**
+ * Takes a URL and creates a LinkNode.
+ * @param url - The URL the LinkNode should direct to.
+ * @param attributes - Optional HTML a tag attributes \\{ target, rel, title \\}
+ * @returns The LinkNode.
+ */
+export declare function $createLinkNode(url?: string, attributes?: LinkAttributes): LinkNode;
+/**
+ * Determines if node is a LinkNode.
+ * @param node - The node to be checked.
+ * @returns true if node is a LinkNode, false otherwise.
+ */
+export declare function $isLinkNode(node: LexicalNode | null | undefined): node is LinkNode;
+export type SerializedAutoLinkNode = Spread<{
+    isUnlinked: boolean;
+}, SerializedLinkNode>;
+export declare class AutoLinkNode extends LinkNode {
+    /** @internal */
+    /** Indicates whether the autolink was ever unlinked. **/
+    __isUnlinked: boolean;
+    constructor(url?: string, attributes?: AutoLinkAttributes, key?: NodeKey);
+    static getType(): string;
+    static clone(node: AutoLinkNode): AutoLinkNode;
+    getIsUnlinked(): boolean;
+    setIsUnlinked(value: boolean): this;
+    createDOM(config: EditorConfig): LinkHTMLElementType;
+    updateDOM(prevNode: this, anchor: LinkHTMLElementType, config: EditorConfig): boolean;
+    static importJSON(serializedNode: SerializedAutoLinkNode): AutoLinkNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedAutoLinkNode>): this;
+    static importDOM(): null;
+    exportJSON(): SerializedAutoLinkNode;
+    insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): null | ElementNode;
+}
+/**
+ * Takes a URL and creates an AutoLinkNode. AutoLinkNodes are generally automatically generated
+ * during typing, which is especially useful when a button to generate a LinkNode is not practical.
+ * @param url - The URL the LinkNode should direct to.
+ * @param attributes - Optional HTML a tag attributes. \\{ target, rel, title \\}
+ * @returns The LinkNode.
+ */
+export declare function $createAutoLinkNode(url?: string, attributes?: AutoLinkAttributes): AutoLinkNode;
+/**
+ * Determines if node is an AutoLinkNode.
+ * @param node - The node to be checked.
+ * @returns true if node is an AutoLinkNode, false otherwise.
+ */
+export declare function $isAutoLinkNode(node: LexicalNode | null | undefined): node is AutoLinkNode;
+export declare const TOGGLE_LINK_COMMAND: LexicalCommand<string | ({
+    url: string;
+} & LinkAttributes) | null>;
+/**
+ * Generates or updates a LinkNode. It can also delete a LinkNode if the URL is null,
+ * but saves any children and brings them up to the parent node.
+ * @param url - The URL the link directs to.
+ * @param attributes - Optional HTML a tag attributes. \\{ target, rel, title \\}
+ */
+export declare function $toggleLink(url: null | string, attributes?: LinkAttributes): void;
+/** @deprecated renamed to {@link $toggleLink} by @lexical/eslint-plugin rules-of-lexical */
+export declare const toggleLink: typeof $toggleLink;
+/**
+ * Formats a URL string by adding appropriate protocol if missing
+ *
+ * @param url - URL to format
+ * @returns Formatted URL with appropriate protocol
+ */
+export declare function formatUrl(url: string): string;
+export {};

package/types/lexical/list/LexicalListItemNode.ts

@@ -0,0 +1,65 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { BaseSelection, DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, LexicalUpdateJSON, NodeKey, ParagraphNode, RangeSelection, SerializedElementNode, Spread } from './../';
+import { ElementNode, LexicalEditor } from './../';
+export type SerializedListItemNode = Spread<{
+    checked: boolean | undefined;
+    value: number;
+}, SerializedElementNode>;
+/** @noInheritDoc */
+export declare class ListItemNode extends ElementNode {
+    /** @internal */
+    __value: number;
+    /** @internal */
+    __checked?: boolean;
+    static getType(): string;
+    static clone(node: ListItemNode): ListItemNode;
+    constructor(value?: number, checked?: boolean, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLElement;
+    updateListItemDOM(prevNode: ListItemNode | null, dom: HTMLLIElement, config: EditorConfig): void;
+    updateDOM(prevNode: ListItemNode, dom: HTMLElement, config: EditorConfig): boolean;
+    static transform(): (node: LexicalNode) => void;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedListItemNode): ListItemNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedListItemNode>): this;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedListItemNode;
+    append(...nodes: LexicalNode[]): this;
+    replace<N extends LexicalNode>(replaceWithNode: N, includeChildren?: boolean): N;
+    insertAfter(node: LexicalNode, restoreSelection?: boolean): LexicalNode;
+    remove(preserveEmptyParent?: boolean): void;
+    insertNewAfter(_: RangeSelection, restoreSelection?: boolean): ListItemNode | ParagraphNode;
+    collapseAtStart(selection: RangeSelection): true;
+    getValue(): number;
+    setValue(value: number): this;
+    getChecked(): boolean | undefined;
+    setChecked(checked?: boolean): this;
+    toggleChecked(): this;
+    getIndent(): number;
+    setIndent(indent: number): this;
+    /** @deprecated @internal */
+    canInsertAfter(node: LexicalNode): boolean;
+    /** @deprecated @internal */
+    canReplaceWith(replacement: LexicalNode): boolean;
+    canMergeWith(node: LexicalNode): boolean;
+    extractWithChild(child: LexicalNode, selection: BaseSelection): boolean;
+    isParentRequired(): true;
+    createParentElementNode(): ElementNode;
+    canMergeWhenEmpty(): true;
+}
+/**
+ * Creates a new List Item node, passing true/false will convert it to a checkbox input.
+ * @param checked - Is the List Item a checkbox and, if so, is it checked? undefined/null: not a checkbox, true/false is a checkbox and checked/unchecked, respectively.
+ * @returns The new List Item.
+ */
+export declare function $createListItemNode(checked?: boolean): ListItemNode;
+/**
+ * Checks to see if the node is a ListItemNode.
+ * @param node - The node to be checked.
+ * @returns true if the node is a ListItemNode, false otherwise.
+ */
+export declare function $isListItemNode(node: LexicalNode | null | undefined): node is ListItemNode;

package/types/lexical/list/LexicalListNode.ts

@@ -0,0 +1,56 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedElementNode, Spread } from './../';
+export type SerializedListNode = Spread<{
+    listType: ListType;
+    start: number;
+    tag: ListNodeTagType;
+}, SerializedElementNode>;
+export type ListType = 'number' | 'bullet' | 'check';
+export type ListNodeTagType = 'ul' | 'ol';
+/** @noInheritDoc */
+export declare class ListNode extends ElementNode {
+    /** @internal */
+    __tag: ListNodeTagType;
+    /** @internal */
+    __start: number;
+    /** @internal */
+    __listType: ListType;
+    static getType(): string;
+    static clone(node: ListNode): ListNode;
+    constructor(listType?: ListType, start?: number, key?: NodeKey);
+    getTag(): ListNodeTagType;
+    setListType(type: ListType): this;
+    getListType(): ListType;
+    getStart(): number;
+    setStart(start: number): this;
+    createDOM(config: EditorConfig, _editor?: LexicalEditor): HTMLElement;
+    updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
+    static transform(): (node: LexicalNode) => void;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedListNode): ListNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedListNode>): this;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedListNode;
+    canBeEmpty(): false;
+    canIndent(): false;
+    splice(start: number, deleteCount: number, nodesToInsert: LexicalNode[]): this;
+    extractWithChild(child: LexicalNode): boolean;
+}
+/**
+ * Creates a ListNode of listType.
+ * @param listType - The type of list to be created. Can be 'number', 'bullet', or 'check'.
+ * @param start - Where an ordered list starts its count, start = 1 if left undefined.
+ * @returns The new ListNode
+ */
+export declare function $createListNode(listType?: ListType, start?: number): ListNode;
+/**
+ * Checks to see if the node is a ListNode.
+ * @param node - The node to be checked.
+ * @returns true if the node is a ListNode, false otherwise.
+ */
+export declare function $isListNode(node: LexicalNode | null | undefined): node is ListNode;

package/types/lexical/list/checkList.ts

@@ -0,0 +1,9 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { LexicalCommand, LexicalEditor } from './../';
+export declare const INSERT_CHECK_LIST_COMMAND: LexicalCommand<void>;
+export declare function registerCheckList(editor: LexicalEditor): () => void;

package/types/lexical/list/formatList.ts

@@ -0,0 +1,69 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import { ListItemNode, ListNode } from './';
+import { ListType } from './LexicalListNode';
+/**
+ * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of
+ * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.
+ * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.
+ * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,
+ * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with
+ * a new ListNode, or create a new ListNode at the nearest root/shadow root.
+ * @param listType - The type of list, "number" | "bullet" | "check".
+ */
+export declare function $insertList(listType: ListType): void;
+/**
+ * A recursive function that goes through each list and their children, including nested lists,
+ * appending list2 children after list1 children and updating ListItemNode values.
+ * @param list1 - The first list to be merged.
+ * @param list2 - The second list to be merged.
+ */
+export declare function mergeLists(list1: ListNode, list2: ListNode): void;
+/**
+ * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode
+ * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,
+ * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node
+ * inside a ListItemNode will be appended to the new ParagraphNodes.
+ */
+export declare function $removeList(): void;
+/**
+ * Takes the value of a child ListItemNode and makes it the value the ListItemNode
+ * should be if it isn't already. Also ensures that checked is undefined if the
+ * parent does not have a list type of 'check'.
+ * @param list - The list whose children are updated.
+ */
+export declare function updateChildrenListItemValue(list: ListNode): void;
+/**
+ * Merge the next sibling list if same type.
+ * <ul> will merge with <ul>, but NOT <ul> with <ol>.
+ * @param list - The list whose next sibling should be potentially merged
+ */
+export declare function mergeNextSiblingListIfSameType(list: ListNode): void;
+/**
+ * Adds an empty ListNode/ListItemNode chain at listItemNode, so as to
+ * create an indent effect. Won't indent ListItemNodes that have a ListNode as
+ * a child, but does merge sibling ListItemNodes if one has a nested ListNode.
+ * @param listItemNode - The ListItemNode to be indented.
+ */
+export declare function $handleIndent(listItemNode: ListItemNode): void;
+/**
+ * Removes an indent by removing an empty ListNode/ListItemNode chain. An indented ListItemNode
+ * has a great grandparent node of type ListNode, which is where the ListItemNode will reside
+ * within as a child.
+ * @param listItemNode - The ListItemNode to remove the indent (outdent).
+ */
+export declare function $handleOutdent(listItemNode: ListItemNode): void;
+/**
+ * Attempts to insert a ParagraphNode at selection and selects the new node. The selection must contain a ListItemNode
+ * or a node that does not already contain text. If its grandparent is the root/shadow root, it will get the ListNode
+ * (which should be the parent node) and insert the ParagraphNode as a sibling to the ListNode. If the ListNode is
+ * nested in a ListItemNode instead, it will add the ParagraphNode after the grandparent ListItemNode.
+ * Throws an invariant if the selection is not a child of a ListNode.
+ * @returns true if a ParagraphNode was inserted successfully, false if there is no selection
+ * or the selection does not contain a ListItemNode or the node already holds text.
+ */
+export declare function $handleListInsertParagraph(): boolean;