slate 0.56.1 → 0.57.3

package/dist/interfaces/editor.d.ts

@@ -0,0 +1,344 @@
+import { Ancestor, Descendant, Element, Location, Node, NodeEntry, Operation, Path, PathRef, Point, PointRef, Range, RangeRef, Span, Text } from '..';
+/**
+ * The `Editor` interface stores all the state of a Slate editor. It is extended
+ * by plugins that wish to add their own helpers and implement new behaviors.
+ */
+export interface Editor {
+    children: Node[];
+    selection: Range | null;
+    operations: Operation[];
+    marks: Record<string, any> | null;
+    [key: string]: any;
+    isInline: (element: Element) => boolean;
+    isVoid: (element: Element) => boolean;
+    normalizeNode: (entry: NodeEntry) => void;
+    onChange: () => void;
+    addMark: (key: string, value: any) => void;
+    apply: (operation: Operation) => void;
+    deleteBackward: (unit: 'character' | 'word' | 'line' | 'block') => void;
+    deleteForward: (unit: 'character' | 'word' | 'line' | 'block') => void;
+    deleteFragment: () => void;
+    getFragment: () => Descendant[];
+    insertBreak: () => void;
+    insertFragment: (fragment: Node[]) => void;
+    insertNode: (node: Node) => void;
+    insertText: (text: string) => void;
+    removeMark: (key: string) => void;
+}
+export declare const Editor: {
+    /**
+     * Get the ancestor above a location in the document.
+     */
+    above<T extends Ancestor>(editor: Editor, options?: {
+        at?: Range | Path | Point | undefined;
+        match?: ((node: Node) => boolean) | ((node: Node) => node is T) | undefined;
+        mode?: "highest" | "lowest" | undefined;
+        voids?: boolean | undefined;
+    }): NodeEntry<T> | undefined;
+    /**
+     * Add a custom property to the leaf text nodes in the current selection.
+     *
+     * If the selection is currently collapsed, the marks will be added to the
+     * `editor.marks` property instead, and applied when text is inserted next.
+     */
+    addMark(editor: Editor, key: string, value: any): void;
+    /**
+     * Get the point after a location.
+     */
+    after(editor: Editor, at: Location, options?: {
+        distance?: number | undefined;
+        unit?: "character" | "word" | "line" | "block" | "offset" | undefined;
+    }): Point | undefined;
+    /**
+     * Get the point before a location.
+     */
+    before(editor: Editor, at: Location, options?: {
+        distance?: number | undefined;
+        unit?: "character" | "word" | "line" | "block" | "offset" | undefined;
+    }): Point | undefined;
+    /**
+     * Delete content in the editor backward from the current selection.
+     */
+    deleteBackward(editor: Editor, options?: {
+        unit?: "character" | "word" | "line" | "block" | undefined;
+    }): void;
+    /**
+     * Delete content in the editor forward from the current selection.
+     */
+    deleteForward(editor: Editor, options?: {
+        unit?: "character" | "word" | "line" | "block" | undefined;
+    }): void;
+    /**
+     * Delete the content in the current selection.
+     */
+    deleteFragment(editor: Editor): void;
+    /**
+     * Get the start and end points of a location.
+     */
+    edges(editor: Editor, at: Location): [Point, Point];
+    /**
+     * Get the end point of a location.
+     */
+    end(editor: Editor, at: Location): Point;
+    /**
+     * Get the first node at a location.
+     */
+    first(editor: Editor, at: Location): NodeEntry<Node>;
+    /**
+     * Get the fragment at a location.
+     */
+    fragment(editor: Editor, at: Location): Descendant[];
+    /**
+     * Check if a node has block children.
+     */
+    hasBlocks(editor: Editor, element: Element): boolean;
+    /**
+     * Check if a node has inline and text children.
+     */
+    hasInlines(editor: Editor, element: Element): boolean;
+    /**
+     * Check if a node has text children.
+     */
+    hasTexts(editor: Editor, element: Element): boolean;
+    /**
+     * Insert a block break at the current selection.
+     *
+     * If the selection is currently expanded, it will be deleted first.
+     */
+    insertBreak(editor: Editor): void;
+    /**
+     * Insert a fragment at the current selection.
+     *
+     * If the selection is currently expanded, it will be deleted first.
+     */
+    insertFragment(editor: Editor, fragment: Node[]): void;
+    /**
+     * Insert a node at the current selection.
+     *
+     * If the selection is currently expanded, it will be deleted first.
+     */
+    insertNode(editor: Editor, node: Node): void;
+    /**
+     * Insert text at the current selection.
+     *
+     * If the selection is currently expanded, it will be deleted first.
+     */
+    insertText(editor: Editor, text: string): void;
+    /**
+     * Check if a value is a block `Element` object.
+     */
+    isBlock(editor: Editor, value: any): value is Element;
+    /**
+     * Check if a value is an `Editor` object.
+     */
+    isEditor(value: any): value is Editor;
+    /**
+     * Check if a point is the end point of a location.
+     */
+    isEnd(editor: Editor, point: Point, at: Location): boolean;
+    /**
+     * Check if a point is an edge of a location.
+     */
+    isEdge(editor: Editor, point: Point, at: Location): boolean;
+    /**
+     * Check if an element is empty, accounting for void nodes.
+     */
+    isEmpty(editor: Editor, element: Element): boolean;
+    /**
+     * Check if a value is an inline `Element` object.
+     */
+    isInline(editor: Editor, value: any): value is Element;
+    /**
+     * Check if the editor is currently normalizing after each operation.
+     */
+    isNormalizing(editor: Editor): boolean;
+    /**
+     * Check if a point is the start point of a location.
+     */
+    isStart(editor: Editor, point: Point, at: Location): boolean;
+    /**
+     * Check if a value is a void `Element` object.
+     */
+    isVoid(editor: Editor, value: any): value is Element;
+    /**
+     * Get the last node at a location.
+     */
+    last(editor: Editor, at: Location): NodeEntry<Node>;
+    /**
+     * Get the leaf text node at a location.
+     */
+    leaf(editor: Editor, at: Location, options?: {
+        depth?: number | undefined;
+        edge?: "start" | "end" | undefined;
+    }): NodeEntry<Text>;
+    /**
+     * Iterate through all of the levels at a location.
+     */
+    levels<T_1 extends Node>(editor: Editor, options?: {
+        at?: Range | Path | Point | undefined;
+        match?: ((node: Node) => boolean) | ((node: Node) => node is T_1) | undefined;
+        reverse?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): Iterable<NodeEntry<T_1>>;
+    /**
+     * Get the marks that would be added to text at the current selection.
+     */
+    marks(editor: Editor): Record<string, any> | null;
+    /**
+     * Get the matching node in the branch of the document after a location.
+     */
+    next<T_2 extends Node>(editor: Editor, options?: {
+        at?: Range | Path | Point | undefined;
+        match?: ((node: Node) => boolean) | ((node: Node) => node is T_2) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        voids?: boolean | undefined;
+    }): NodeEntry<T_2> | undefined;
+    /**
+     * Get the node at a location.
+     */
+    node(editor: Editor, at: Location, options?: {
+        depth?: number | undefined;
+        edge?: "start" | "end" | undefined;
+    }): NodeEntry<Node>;
+    /**
+     * Iterate through all of the nodes in the Editor.
+     */
+    nodes<T_3 extends Node>(editor: Editor, options?: {
+        at?: Range | Path | Point | Span | undefined;
+        match?: ((node: Node) => boolean) | ((node: Node) => node is T_3) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        universal?: boolean | undefined;
+        reverse?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): Iterable<NodeEntry<T_3>>;
+    /**
+     * Normalize any dirty objects in the editor.
+     */
+    normalize(editor: Editor, options?: {
+        force?: boolean | undefined;
+    }): void;
+    /**
+     * Get the parent node of a location.
+     */
+    parent(editor: Editor, at: Location, options?: {
+        depth?: number | undefined;
+        edge?: "start" | "end" | undefined;
+    }): NodeEntry<Ancestor>;
+    /**
+     * Get the path of a location.
+     */
+    path(editor: Editor, at: Location, options?: {
+        depth?: number | undefined;
+        edge?: "start" | "end" | undefined;
+    }): Path;
+    /**
+     * Create a mutable ref for a `Path` object, which will stay in sync as new
+     * operations are applied to the editor.
+     */
+    pathRef(editor: Editor, path: Path, options?: {
+        affinity?: "backward" | "forward" | null | undefined;
+    }): PathRef;
+    /**
+     * Get the set of currently tracked path refs of the editor.
+     */
+    pathRefs(editor: Editor): Set<PathRef>;
+    /**
+     * Get the start or end point of a location.
+     */
+    point(editor: Editor, at: Location, options?: {
+        edge?: "start" | "end" | undefined;
+    }): Point;
+    /**
+     * Create a mutable ref for a `Point` object, which will stay in sync as new
+     * operations are applied to the editor.
+     */
+    pointRef(editor: Editor, point: Point, options?: {
+        affinity?: "backward" | "forward" | null | undefined;
+    }): PointRef;
+    /**
+     * Get the set of currently tracked point refs of the editor.
+     */
+    pointRefs(editor: Editor): Set<PointRef>;
+    /**
+     * Iterate through all of the positions in the document where a `Point` can be
+     * placed.
+     *
+     * By default it will move forward by individual offsets at a time,  but you
+     * can pass the `unit: 'character'` option to moved forward one character, word,
+     * or line at at time.
+     *
+     * Note: void nodes are treated as a single point, and iteration will not
+     * happen inside their content.
+     */
+    positions(editor: Editor, options?: {
+        at?: Range | Path | Point | undefined;
+        unit?: "character" | "word" | "line" | "block" | "offset" | undefined;
+        reverse?: boolean | undefined;
+    }): Iterable<Point>;
+    /**
+     * Get the matching node in the branch of the document before a location.
+     */
+    previous<T_4 extends Node>(editor: Editor, options?: {
+        at?: Range | Path | Point | undefined;
+        match?: ((node: Node) => boolean) | ((node: Node) => node is T_4) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        voids?: boolean | undefined;
+    }): NodeEntry<T_4> | undefined;
+    /**
+     * Get a range of a location.
+     */
+    range(editor: Editor, at: Location, to?: Range | Path | Point | undefined): Range;
+    /**
+     * Create a mutable ref for a `Range` object, which will stay in sync as new
+     * operations are applied to the editor.
+     */
+    rangeRef(editor: Editor, range: Range, options?: {
+        affinity?: "backward" | "forward" | "outward" | "inward" | null | undefined;
+    }): RangeRef;
+    /**
+     * Get the set of currently tracked range refs of the editor.
+     */
+    rangeRefs(editor: Editor): Set<RangeRef>;
+    /**
+     * Remove a custom property from all of the leaf text nodes in the current
+     * selection.
+     *
+     * If the selection is currently collapsed, the removal will be stored on
+     * `editor.marks` and applied to the text inserted next.
+     */
+    removeMark(editor: Editor, key: string): void;
+    /**
+     * Get the start point of a location.
+     */
+    start(editor: Editor, at: Location): Point;
+    /**
+     * Get the text string content of a location.
+     *
+     * Note: the text of void nodes is presumed to be an empty string, regardless
+     * of what their actual content is.
+     */
+    string(editor: Editor, at: Location): string;
+    /**
+     * Transform the editor by an operation.
+     */
+    transform(editor: Editor, op: Operation): void;
+    /**
+     * Convert a range into a non-hanging one.
+     */
+    unhangRange(editor: Editor, range: Range, options?: {
+        voids?: boolean | undefined;
+    }): Range;
+    /**
+     * Match a void node in the current branch of the editor.
+     */
+    void(editor: Editor, options?: {
+        at?: Range | Path | Point | undefined;
+        mode?: "highest" | "lowest" | undefined;
+        voids?: boolean | undefined;
+    }): NodeEntry<Element> | undefined;
+    /**
+     * Call a function, deferring normalization until after it completes.
+     */
+    withoutNormalizing(editor: Editor, fn: () => void): void;
+};
+//# sourceMappingURL=editor.d.ts.map

package/dist/interfaces/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../packages/slate/src/interfaces/editor.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EACR,UAAU,EACV,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,SAAS,EACT,IAAI,EACJ,OAAO,EACP,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,IAAI,EACJ,IAAI,EACL,MAAM,IAAI,CAAA;AAUX;;;GAGG;AAEH,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,IAAI,EAAE,CAAA;IAChB,SAAS,EAAE,KAAK,GAAG,IAAI,CAAA;IACvB,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAA;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAGlB,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;IACvC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IACzC,QAAQ,EAAE,MAAM,IAAI,CAAA;IAGpB,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IAC1C,KAAK,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,CAAA;IACrC,cAAc,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAA;IACvE,aAAa,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAA;IACtE,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,WAAW,EAAE,MAAM,UAAU,EAAE,CAAA;IAC/B,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,cAAc,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,IAAI,CAAA;IAC1C,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAChC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC;AAED,eAAO,MAAM,MAAM;IACjB;;OAEG;;;;;;;IAqCH;;;;;OAKG;;IAMH;;OAEG;;;;;IAgCH;;OAEG;;;;;IAoCH;;OAEG;;;;IAYH;;OAEG;;;;IAYH;;OAEG;;IAMH;;OAEG;;IAMH;;OAEG;;IAMH;;OAEG;;IAOH;;OAEG;;IAOH;;OAEG;;IAMH;;OAEG;;IAQH;;OAEG;;IAMH;;;;OAIG;;IAMH;;;;OAIG;;IAMH;;;;OAIG;;IAMH;;;;OAIG;;IAMH;;OAEG;;IAMH;;OAEG;;IA0BH;;OAEG;;IAOH;;OAEG;;IAMH;;OAEG;;IAcH;;OAEG;;IAMH;;OAEG;;IAOH;;OAEG;;IAYH;;OAEG;;IAMH;;OAEG;;IAOH;;OAEG;;;;;IAeH;;OAEG;;;;;;;IA4CH;;OAEG;;IAiDH;;OAEG;;;;;;;IAuCH;;OAEG;;;;;IAeH;;OAEG;;;;;;;;;IA4GH;;OAEG;;;;IA6CH;;OAEG;;;;;IAgBH;;OAEG;;;;;IA2CH;;;OAGG;;;;IA2BH;;OAEG;;IAaH;;OAEG;;;;IAyCH;;;OAGG;;;;IA2BH;;OAEG;;IAaH;;;;;;;;;;OAUG;;;;;;IAgHH;;OAEG;;;;;;;IA8CH;;OAEG;;IAYH;;;OAGG;;;;IA2BH;;OAEG;;IAaH;;;;;;OAMG;;IAMH;;OAEG;;IAMH;;;;;OAKG;;IA2BH;;OAEG;;IA2QH;;OAEG;;;;IA8CH;;OAEG;;;;;;IAgBH;;OAEG;;CASJ,CAAA"}

package/dist/interfaces/text.d.ts

@@ -1,3 +1,4 @@
+import { Range } from '..';
 /**
  * `Text` objects represent the nodes that contain the actual text content of a
  * Slate document along with any formatting properties. They are always leaf
@@ -29,5 +30,9 @@ export declare const Text: {
      * the `text` property are two nodes equal.
      */
     matches(text: Text, props: Partial<Text>): boolean;
+    /**
+     * Get the leaves for a text node given decorations.
+     */
+    decorations(node: Text, decorations: Range[]): Text[];
 };
 //# sourceMappingURL=text.d.ts.map

package/dist/interfaces/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../packages/slate/src/interfaces/text.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,eAAO,MAAM,IAAI;IACf;;OAEG;;;;IAgCH;;OAEG;;IAMH;;OAEG;;IAMH;;;;;OAKG;;CAeJ,CAAA"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../packages/slate/src/interfaces/text.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,CAAA;AAE1B;;;;GAIG;AAEH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,eAAO,MAAM,IAAI;IACf;;OAEG;;;;IAgCH;;OAEG;;IAMH;;OAEG;;IAMH;;;;;OAKG;;IAgBH;;OAEG;;CAsEJ,CAAA"}