@examind/block-types 0.1.18

package/types/lexical/list/index.ts

@@ -0,0 +1,11 @@
+// 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 './LexicalListItemNode';
+export * from './LexicalListNode';
+export * from './checkList';
+export * from './formatList';
+export * from './utils';

package/types/lexical/list/utils.ts

@@ -0,0 +1,64 @@
+// 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 { LexicalNode, Spread } from './../';
+import { ListItemNode, ListNode } from './';
+/**
+ * Checks the depth of listNode from the root node.
+ * @param listNode - The ListNode to be checked.
+ * @returns The depth of the ListNode.
+ */
+export declare function $getListDepth(listNode: ListNode): number;
+/**
+ * Finds the nearest ancestral ListNode and returns it, throws an invariant if listItem is not a ListItemNode.
+ * @param listItem - The node to be checked.
+ * @returns The ListNode found.
+ */
+export declare function $getTopListNode(listItem: LexicalNode): ListNode;
+/**
+ * Checks if listItem has no child ListNodes and has no ListItemNode ancestors with siblings.
+ * @param listItem - the ListItemNode to be checked.
+ * @returns true if listItem has no child ListNode and no ListItemNode ancestors with siblings, false otherwise.
+ */
+export declare function $isLastItemInList(listItem: ListItemNode): boolean;
+/**
+ * A recursive Depth-First Search (Postorder Traversal) that finds all of a node's children
+ * that are of type ListItemNode and returns them in an array.
+ * @param node - The ListNode to start the search.
+ * @returns An array containing all nodes of type ListItemNode found.
+ */
+export declare function $getAllListItems(node: ListNode): Array<ListItemNode>;
+declare const NestedListNodeBrand: unique symbol;
+/**
+ * Checks to see if the passed node is a ListItemNode and has a ListNode as a child.
+ * @param node - The node to be checked.
+ * @returns true if the node is a ListItemNode and has a ListNode child, false otherwise.
+ */
+export declare function isNestedListNode(node: LexicalNode | null | undefined): node is Spread<{
+    getFirstChild(): ListNode;
+    [NestedListNodeBrand]: never;
+}, ListItemNode>;
+/**
+ * Traverses up the tree and returns the first ListItemNode found.
+ * @param node - Node to start the search.
+ * @returns The first ListItemNode found, or null if none exist.
+ */
+export declare function $findNearestListItemNode(node: LexicalNode): ListItemNode | null;
+/**
+ * Takes a deeply nested ListNode or ListItemNode and traverses up the branch to delete the first
+ * ancestral ListNode (which could be the root ListNode) or ListItemNode with siblings, essentially
+ * bringing the deeply nested node up the branch once. Would remove sublist if it has siblings.
+ * Should not break ListItem -> List -> ListItem chain as empty List/ItemNodes should be removed on .remove().
+ * @param sublist - The nested ListNode or ListItemNode to be brought up the branch.
+ */
+export declare function $removeHighestEmptyListParent(sublist: ListItemNode | ListNode): void;
+/**
+ * Wraps a node into a ListItemNode.
+ * @param node - The node to be wrapped into a ListItemNode
+ * @returns The ListItemNode which the passed node is wrapped in.
+ */
+export declare function $wrapInListItem(node: LexicalNode): ListItemNode;
+export {};

package/types/lexical/nodes/ArtificialNode.ts

@@ -0,0 +1,12 @@
+// 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 { EditorConfig } from '../';
+import { ElementNode } from './LexicalElementNode';
+export declare class ArtificialNode__DO_NOT_USE extends ElementNode {
+    static getType(): string;
+    createDOM(config: EditorConfig): HTMLElement;
+}

package/types/lexical/nodes/LexicalDecoratorNode.ts

@@ -0,0 +1,26 @@
+// 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 { KlassConstructor, LexicalEditor } from '../LexicalEditor';
+import type { ElementNode } from './LexicalElementNode';
+import type { EditorConfig } from '../';
+import { LexicalNode } from '../LexicalNode';
+export interface DecoratorNode<T> {
+    getTopLevelElement(): ElementNode | this | null;
+    getTopLevelElementOrThrow(): ElementNode | this;
+}
+/** @noInheritDoc */
+export declare class DecoratorNode<T> extends LexicalNode {
+    ['constructor']: KlassConstructor<typeof DecoratorNode<T>>;
+    /**
+     * The returned value is added to the LexicalEditor._decorators
+     */
+    decorate(editor: LexicalEditor, config: EditorConfig): T;
+    isIsolated(): boolean;
+    isInline(): boolean;
+    isKeyboardSelectable(): boolean;
+}
+export declare function $isDecoratorNode<T>(node: LexicalNode | null | undefined): node is DecoratorNode<T>;

package/types/lexical/nodes/LexicalElementNode.ts

@@ -0,0 +1,207 @@
+// 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 { DOMExportOutput, LexicalPrivateDOM, NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import type { BaseSelection, RangeSelection } from '../LexicalSelection';
+import type { KlassConstructor, LexicalEditor, LexicalUpdateJSON, Spread, TextFormatType } from '../';
+import { TextNode } from '../index';
+import { LexicalNode } from '../LexicalNode';
+export type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<{
+    children: Array<T>;
+    direction: 'ltr' | 'rtl' | null;
+    format: ElementFormatType;
+    indent: number;
+    textFormat?: number;
+    textStyle?: string;
+}, SerializedLexicalNode>;
+export type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
+export interface ElementNode {
+    getTopLevelElement(): ElementNode | null;
+    getTopLevelElementOrThrow(): ElementNode;
+}
+/**
+ * A utility class for managing the DOM children of an ElementNode
+ */
+export declare class ElementDOMSlot<T extends HTMLElement = HTMLElement> {
+    readonly element: T;
+    readonly before: Node | null;
+    readonly after: Node | null;
+    constructor(
+    /** The element returned by createDOM */
+    element: T, 
+    /** All managed children will be inserted before this node, if defined */
+    before?: Node | undefined | null, 
+    /** All managed children will be inserted after this node, if defined */
+    after?: Node | undefined | null);
+    /**
+     * Return a new ElementDOMSlot where all managed children will be inserted before this node
+     */
+    withBefore(before: Node | undefined | null): ElementDOMSlot<T>;
+    /**
+     * Return a new ElementDOMSlot where all managed children will be inserted after this node
+     */
+    withAfter(after: Node | undefined | null): ElementDOMSlot<T>;
+    /**
+     * Return a new ElementDOMSlot with an updated root element
+     */
+    withElement<ElementType extends HTMLElement>(element: ElementType): ElementDOMSlot<ElementType>;
+    /**
+     * Insert the given child before this.before and any reconciler managed line break node,
+     * or append it if this.before is not defined
+     */
+    insertChild(dom: Node): this;
+    /**
+     * Remove the managed child from this container, will throw if it was not already there
+     */
+    removeChild(dom: Node): this;
+    /**
+     * Replace managed child prevDom with dom. Will throw if prevDom is not a child
+     *
+     * @param dom The new node to replace prevDom
+     * @param prevDom the node that will be replaced
+     */
+    replaceChild(dom: Node, prevDom: Node): this;
+    /**
+     * Returns the first managed child of this node,
+     * which will either be this.after.nextSibling or this.element.firstChild,
+     * and will never be this.before if it is defined.
+     */
+    getFirstChild(): ChildNode | null;
+    /**
+     * @internal
+     */
+    getManagedLineBreak(): Exclude<LexicalPrivateDOM['__lexicalLineBreak'], undefined>;
+    /** @internal */
+    setManagedLineBreak(lineBreakType: null | 'empty' | 'line-break' | 'decorator'): void;
+    /** @internal */
+    removeManagedLineBreak(): void;
+    /** @internal */
+    insertManagedLineBreak(webkitHack: boolean): void;
+    /**
+     * @internal
+     *
+     * Returns the offset of the first child
+     */
+    getFirstChildOffset(): number;
+    /**
+     * @internal
+     */
+    resolveChildIndex(element: ElementNode, elementDOM: HTMLElement, initialDOM: Node, initialOffset: number): [node: ElementNode, idx: number];
+}
+export declare function indexPath(root: HTMLElement, child: Node): number[];
+/** @noInheritDoc */
+export declare class ElementNode extends LexicalNode {
+    ['constructor']: KlassConstructor<typeof ElementNode>;
+    /** @internal */
+    __first: null | NodeKey;
+    /** @internal */
+    __last: null | NodeKey;
+    /** @internal */
+    __size: number;
+    /** @internal */
+    __format: number;
+    /** @internal */
+    __style: string;
+    /** @internal */
+    __indent: number;
+    /** @internal */
+    __dir: 'ltr' | 'rtl' | null;
+    /** @internal */
+    __textFormat: number;
+    /** @internal */
+    __textStyle: string;
+    constructor(key?: NodeKey);
+    afterCloneFrom(prevNode: this): void;
+    getFormat(): number;
+    getFormatType(): ElementFormatType;
+    getStyle(): string;
+    getIndent(): number;
+    getChildren<T extends LexicalNode>(): Array<T>;
+    getChildrenKeys(): Array<NodeKey>;
+    getChildrenSize(): number;
+    isEmpty(): boolean;
+    isDirty(): boolean;
+    isLastChild(): boolean;
+    getAllTextNodes(): Array<TextNode>;
+    getFirstDescendant<T extends LexicalNode>(): null | T;
+    getLastDescendant<T extends LexicalNode>(): null | T;
+    getDescendantByIndex<T extends LexicalNode>(index: number): null | T;
+    getFirstChild<T extends LexicalNode>(): null | T;
+    getFirstChildOrThrow<T extends LexicalNode>(): T;
+    getLastChild<T extends LexicalNode>(): null | T;
+    getLastChildOrThrow<T extends LexicalNode>(): T;
+    getChildAtIndex<T extends LexicalNode>(index: number): null | T;
+    getTextContent(): string;
+    getTextContentSize(): number;
+    getDirection(): 'ltr' | 'rtl' | null;
+    getTextFormat(): number;
+    hasFormat(type: ElementFormatType): boolean;
+    hasTextFormat(type: TextFormatType): boolean;
+    /**
+     * Returns the format flags applied to the node as a 32-bit integer.
+     *
+     * @returns a number representing the TextFormatTypes applied to the node.
+     */
+    getFormatFlags(type: TextFormatType, alignWithFormat: null | number): number;
+    getTextStyle(): string;
+    select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+    selectStart(): RangeSelection;
+    selectEnd(): RangeSelection;
+    clear(): this;
+    append(...nodesToAppend: LexicalNode[]): this;
+    setDirection(direction: 'ltr' | 'rtl' | null): this;
+    setFormat(type: ElementFormatType): this;
+    setStyle(style: string): this;
+    setTextFormat(type: number): this;
+    setTextStyle(style: string): this;
+    setIndent(indentLevel: number): this;
+    splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): this;
+    /**
+     * @internal
+     *
+     * An experimental API that an ElementNode can override to control where its
+     * children are inserted into the DOM, this is useful to add a wrapping node
+     * or accessory nodes before or after the children. The root of the node returned
+     * by createDOM must still be exactly one HTMLElement.
+     */
+    getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLElement>;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedElementNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedElementNode>): this;
+    insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): null | LexicalNode;
+    canIndent(): boolean;
+    collapseAtStart(selection: RangeSelection): boolean;
+    excludeFromCopy(destination?: 'clone' | 'html'): boolean;
+    /** @deprecated @internal */
+    canReplaceWith(replacement: LexicalNode): boolean;
+    /** @deprecated @internal */
+    canInsertAfter(node: LexicalNode): boolean;
+    canBeEmpty(): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    isInline(): boolean;
+    isShadowRoot(): boolean;
+    /** @deprecated @internal */
+    canMergeWith(node: ElementNode): boolean;
+    extractWithChild(child: LexicalNode, selection: BaseSelection | null, destination: 'clone' | 'html'): boolean;
+    /**
+     * Determines whether this node, when empty, can merge with a first block
+     * of nodes being inserted.
+     *
+     * This method is specifically called in {@link RangeSelection.insertNodes}
+     * to determine merging behavior during nodes insertion.
+     *
+     * @example
+     * // In a ListItemNode or QuoteNode implementation:
+     * canMergeWhenEmpty(): true {
+     *  return true;
+     * }
+     */
+    canMergeWhenEmpty(): boolean;
+    /** @internal */
+    reconcileObservedMutation(dom: HTMLElement, editor: LexicalEditor): void;
+}
+export declare function $isElementNode(node: LexicalNode | null | undefined): node is ElementNode;

package/types/lexical/nodes/LexicalLineBreakNode.ts

@@ -0,0 +1,25 @@
+// 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 { KlassConstructor } from '../LexicalEditor';
+import type { DOMConversionMap, NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import { LexicalNode } from '../LexicalNode';
+export type SerializedLineBreakNode = SerializedLexicalNode;
+/** @noInheritDoc */
+export declare class LineBreakNode extends LexicalNode {
+    ['constructor']: KlassConstructor<typeof LineBreakNode>;
+    static getType(): string;
+    static clone(node: LineBreakNode): LineBreakNode;
+    constructor(key?: NodeKey);
+    getTextContent(): '\n';
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    isInline(): true;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedLineBreakNode: SerializedLineBreakNode): LineBreakNode;
+}
+export declare function $createLineBreakNode(): LineBreakNode;
+export declare function $isLineBreakNode(node: LexicalNode | null | undefined): node is LineBreakNode;

package/types/lexical/nodes/LexicalParagraphNode.ts

@@ -0,0 +1,31 @@
+// 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 { EditorConfig, KlassConstructor, LexicalEditor, Spread } from '../LexicalEditor';
+import type { DOMConversionMap, DOMExportOutput, LexicalNode } from '../LexicalNode';
+import type { RangeSelection } from '../LexicalSelection';
+import type { SerializedElementNode } from './LexicalElementNode';
+import { ElementNode } from './LexicalElementNode';
+export type SerializedParagraphNode = Spread<{
+    textFormat: number;
+    textStyle: string;
+}, SerializedElementNode>;
+/** @noInheritDoc */
+export declare class ParagraphNode extends ElementNode {
+    ['constructor']: KlassConstructor<typeof ParagraphNode>;
+    static getType(): string;
+    static clone(node: ParagraphNode): ParagraphNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: ParagraphNode, dom: HTMLElement, config: EditorConfig): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    static importJSON(serializedNode: SerializedParagraphNode): ParagraphNode;
+    exportJSON(): SerializedParagraphNode;
+    insertNewAfter(rangeSelection: RangeSelection, restoreSelection: boolean): ParagraphNode;
+    collapseAtStart(): boolean;
+}
+export declare function $createParagraphNode(): ParagraphNode;
+export declare function $isParagraphNode(node: LexicalNode | null | undefined): node is ParagraphNode;

package/types/lexical/nodes/LexicalRootNode.ts

@@ -0,0 +1,30 @@
+// 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 { LexicalNode, SerializedLexicalNode } from '../LexicalNode';
+import type { SerializedElementNode } from './LexicalElementNode';
+import { ElementNode } from './LexicalElementNode';
+export type SerializedRootNode<T extends SerializedLexicalNode = SerializedLexicalNode> = SerializedElementNode<T>;
+/** @noInheritDoc */
+export declare class RootNode extends ElementNode {
+    /** @internal */
+    __cachedText: null | string;
+    static getType(): string;
+    static clone(): RootNode;
+    constructor();
+    getTopLevelElementOrThrow(): never;
+    getTextContent(): string;
+    remove(): never;
+    replace<N = LexicalNode>(node: N): never;
+    insertBefore(nodeToInsert: LexicalNode): LexicalNode;
+    insertAfter(nodeToInsert: LexicalNode): LexicalNode;
+    updateDOM(prevNode: this, dom: HTMLElement): false;
+    splice(start: number, deleteCount: number, nodesToInsert: LexicalNode[]): this;
+    static importJSON(serializedNode: SerializedRootNode): RootNode;
+    collapseAtStart(): true;
+}
+export declare function $createRootNode(): RootNode;
+export declare function $isRootNode(node: RootNode | LexicalNode | null | undefined): node is RootNode;

package/types/lexical/nodes/LexicalTabNode.ts

@@ -0,0 +1,28 @@
+// 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 { DOMConversionMap, NodeKey } from '../LexicalNode';
+import { EditorConfig } from '../LexicalEditor';
+import { LexicalNode } from '../LexicalNode';
+import { SerializedTextNode, TextDetailType, TextModeType, TextNode } from './LexicalTextNode';
+export type SerializedTabNode = SerializedTextNode;
+/** @noInheritDoc */
+export declare class TabNode extends TextNode {
+    static getType(): string;
+    static clone(node: TabNode): TabNode;
+    constructor(key?: NodeKey);
+    static importDOM(): DOMConversionMap | null;
+    createDOM(config: EditorConfig): HTMLElement;
+    static importJSON(serializedTabNode: SerializedTabNode): TabNode;
+    setTextContent(text: string): this;
+    spliceText(offset: number, delCount: number, newText: string, moveSelection?: boolean): TextNode;
+    setDetail(detail: TextDetailType | number): this;
+    setMode(type: TextModeType): this;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+}
+export declare function $createTabNode(): TabNode;
+export declare function $isTabNode(node: LexicalNode | null | undefined): node is TabNode;