slate/dist/interfaces/editor.d.ts

A completely customizable framework for building rich text editors.

import { Ancestor, Descendant, Element, ExtendedType, Location, Node, NodeEntry, Operation, Path, PathRef, Point, PointRef, Range, RangeRef, Span, Text, Transforms } from '..';
import { LeafEdge, MaximizeMode, RangeDirection, SelectionMode, TextDirection, TextUnit, TextUnitAdjustment } from '../types/types';
import { OmitFirstArg } from '../utils/types';
import { TextInsertFragmentOptions, TextInsertTextOptions } from './transforms/text';
import { NodeInsertNodesOptions } from './transforms/node';
/**
 * 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 BaseEditor {
    children: Descendant[];
    selection: Selection;
    operations: Operation[];
    marks: EditorMarks | null;
    apply: (operation: Operation) => void;
    getDirtyPaths: (operation: Operation) => Path[];
    getFragment: () => Descendant[];
    isElementReadOnly: (element: Element) => boolean;
    isSelectable: (element: Element) => boolean;
    markableVoid: (element: Element) => boolean;
    normalizeNode: (entry: NodeEntry, options?: {
        operation?: Operation;
    }) => void;
    onChange: (options?: {
        operation?: Operation;
    }) => void;
    shouldNormalize: ({ iteration, dirtyPaths, operation, }: {
        iteration: number;
        initialDirtyPathsLength: number;
        dirtyPaths: Path[];
        operation?: Operation;
    }) => boolean;
    addMark: OmitFirstArg<typeof Editor.addMark>;
    collapse: OmitFirstArg<typeof Transforms.collapse>;
    delete: OmitFirstArg<typeof Transforms.delete>;
    deleteBackward: (unit: TextUnit) => void;
    deleteForward: (unit: TextUnit) => void;
    deleteFragment: OmitFirstArg<typeof Editor.deleteFragment>;
    deselect: OmitFirstArg<typeof Transforms.deselect>;
    insertBreak: OmitFirstArg<typeof Editor.insertBreak>;
    insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;
    insertNode: OmitFirstArg<typeof Editor.insertNode>;
    insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;
    insertSoftBreak: OmitFirstArg<typeof Editor.insertSoftBreak>;
    insertText: OmitFirstArg<typeof Transforms.insertText>;
    liftNodes: OmitFirstArg<typeof Transforms.liftNodes>;
    mergeNodes: OmitFirstArg<typeof Transforms.mergeNodes>;
    move: OmitFirstArg<typeof Transforms.move>;
    moveNodes: OmitFirstArg<typeof Transforms.moveNodes>;
    normalize: OmitFirstArg<typeof Editor.normalize>;
    removeMark: OmitFirstArg<typeof Editor.removeMark>;
    removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;
    select: OmitFirstArg<typeof Transforms.select>;
    setNodes: <T extends Node>(props: Partial<T>, options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        hanging?: boolean;
        split?: boolean;
        voids?: boolean;
        compare?: PropsCompare;
        merge?: PropsMerge;
    }) => void;
    setNormalizing: OmitFirstArg<typeof Editor.setNormalizing>;
    setPoint: OmitFirstArg<typeof Transforms.setPoint>;
    setSelection: OmitFirstArg<typeof Transforms.setSelection>;
    splitNodes: OmitFirstArg<typeof Transforms.splitNodes>;
    unsetNodes: OmitFirstArg<typeof Transforms.unsetNodes>;
    unwrapNodes: OmitFirstArg<typeof Transforms.unwrapNodes>;
    withoutNormalizing: OmitFirstArg<typeof Editor.withoutNormalizing>;
    wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;
    above: <T extends Ancestor>(options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
    after: OmitFirstArg<typeof Editor.after>;
    before: OmitFirstArg<typeof Editor.before>;
    edges: OmitFirstArg<typeof Editor.edges>;
    elementReadOnly: OmitFirstArg<typeof Editor.elementReadOnly>;
    end: OmitFirstArg<typeof Editor.end>;
    first: OmitFirstArg<typeof Editor.first>;
    fragment: OmitFirstArg<typeof Editor.fragment>;
    getMarks: OmitFirstArg<typeof Editor.marks>;
    hasBlocks: OmitFirstArg<typeof Editor.hasBlocks>;
    hasInlines: OmitFirstArg<typeof Editor.hasInlines>;
    hasPath: OmitFirstArg<typeof Editor.hasPath>;
    hasTexts: OmitFirstArg<typeof Editor.hasTexts>;
    isBlock: OmitFirstArg<typeof Editor.isBlock>;
    isEdge: OmitFirstArg<typeof Editor.isEdge>;
    isEmpty: OmitFirstArg<typeof Editor.isEmpty>;
    isEnd: OmitFirstArg<typeof Editor.isEnd>;
    isInline: OmitFirstArg<typeof Editor.isInline>;
    isNormalizing: OmitFirstArg<typeof Editor.isNormalizing>;
    isStart: OmitFirstArg<typeof Editor.isStart>;
    isVoid: OmitFirstArg<typeof Editor.isVoid>;
    last: OmitFirstArg<typeof Editor.last>;
    leaf: OmitFirstArg<typeof Editor.leaf>;
    levels: <T extends Node>(options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
    next: <T extends Descendant>(options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
    node: OmitFirstArg<typeof Editor.node>;
    nodes: <T extends Node>(options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
    parent: OmitFirstArg<typeof Editor.parent>;
    path: OmitFirstArg<typeof Editor.path>;
    pathRef: OmitFirstArg<typeof Editor.pathRef>;
    pathRefs: OmitFirstArg<typeof Editor.pathRefs>;
    point: OmitFirstArg<typeof Editor.point>;
    pointRef: OmitFirstArg<typeof Editor.pointRef>;
    pointRefs: OmitFirstArg<typeof Editor.pointRefs>;
    positions: OmitFirstArg<typeof Editor.positions>;
    previous: <T extends Node>(options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
    range: OmitFirstArg<typeof Editor.range>;
    rangeRef: OmitFirstArg<typeof Editor.rangeRef>;
    rangeRefs: OmitFirstArg<typeof Editor.rangeRefs>;
    start: OmitFirstArg<typeof Editor.start>;
    string: OmitFirstArg<typeof Editor.string>;
    unhangRange: OmitFirstArg<typeof Editor.unhangRange>;
    void: OmitFirstArg<typeof Editor.void>;
    shouldMergeNodesRemovePrevNode: OmitFirstArg<typeof Editor.shouldMergeNodesRemovePrevNode>;
}
export type Editor = ExtendedType<'Editor', BaseEditor>;
export type BaseSelection = Range | null;
export type Selection = ExtendedType<'Selection', BaseSelection>;
export type EditorMarks = Omit<Text, 'text'>;
export interface EditorAboveOptions<T extends Ancestor> {
    at?: Location;
    match?: NodeMatch<T>;
    mode?: MaximizeMode;
    voids?: boolean;
}
export interface EditorAfterOptions {
    distance?: number;
    unit?: TextUnitAdjustment;
    voids?: boolean;
}
export interface EditorBeforeOptions {
    distance?: number;
    unit?: TextUnitAdjustment;
    voids?: boolean;
}
export interface EditorDirectedDeletionOptions {
    unit?: TextUnit;
}
export interface EditorElementReadOnlyOptions {
    at?: Location;
    mode?: MaximizeMode;
    voids?: boolean;
}
export interface EditorFragmentDeletionOptions {
    direction?: TextDirection;
}
export interface EditorLeafOptions {
    depth?: number;
    edge?: LeafEdge;
}
export interface EditorLevelsOptions<T extends Node> {
    at?: Location;
    match?: NodeMatch<T>;
    reverse?: boolean;
    voids?: boolean;
}
export interface EditorNextOptions<T extends Descendant> {
    at?: Location;
    match?: NodeMatch<T>;
    mode?: SelectionMode;
    voids?: boolean;
}
export interface EditorNodeOptions {
    depth?: number;
    edge?: LeafEdge;
}
export interface EditorNodesOptions<T extends Node> {
    at?: Location | Span;
    match?: NodeMatch<T>;
    mode?: SelectionMode;
    universal?: boolean;
    reverse?: boolean;
    voids?: boolean;
    ignoreNonSelectable?: boolean;
}
export interface EditorNormalizeOptions {
    force?: boolean;
    operation?: Operation;
}
export interface EditorParentOptions {
    depth?: number;
    edge?: LeafEdge;
}
export interface EditorPathOptions {
    depth?: number;
    edge?: LeafEdge;
}
export interface EditorPathRefOptions {
    affinity?: TextDirection | null;
}
export interface EditorPointOptions {
    edge?: LeafEdge;
}
export interface EditorPointRefOptions {
    affinity?: TextDirection | null;
}
export interface EditorPositionsOptions {
    at?: Location;
    unit?: TextUnitAdjustment;
    reverse?: boolean;
    voids?: boolean;
    ignoreNonSelectable?: boolean;
}
export interface EditorPreviousOptions<T extends Node> {
    at?: Location;
    match?: NodeMatch<T>;
    mode?: SelectionMode;
    voids?: boolean;
}
export interface EditorRangeRefOptions {
    affinity?: RangeDirection | null;
}
export interface EditorStringOptions {
    voids?: boolean;
}
export interface EditorUnhangRangeOptions {
    voids?: boolean;
}
export interface EditorVoidOptions {
    at?: Location;
    mode?: MaximizeMode;
    voids?: boolean;
}
export interface EditorInterface {
    /**
     * Get the ancestor above a location in the document.
     */
    above: <T extends Ancestor>(editor: Editor, options?: EditorAboveOptions<T>) => 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?: EditorAfterOptions) => Point | undefined;
    /**
     * Get the point before a location.
     */
    before: (editor: Editor, at: Location, options?: EditorBeforeOptions) => Point | undefined;
    /**
     * Delete content in the editor backward from the current selection.
     */
    deleteBackward: (editor: Editor, options?: EditorDirectedDeletionOptions) => void;
    /**
     * Delete content in the editor forward from the current selection.
     */
    deleteForward: (editor: Editor, options?: EditorDirectedDeletionOptions) => void;
    /**
     * Delete the content in the current selection.
     */
    deleteFragment: (editor: Editor, options?: EditorFragmentDeletionOptions) => void;
    /**
     * Get the start and end points of a location.
     */
    edges: (editor: Editor, at: Location) => [Point, Point];
    /**
     * Match a read-only element in the current branch of the editor.
     */
    elementReadOnly: (editor: Editor, options?: EditorElementReadOnlyOptions) => NodeEntry<Element> | undefined;
    /**
     * 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;
    /**
     * 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;
    hasPath: (editor: Editor, path: Path) => 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;
    /**
     * Inserts a fragment
     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
     */
    insertFragment: (editor: Editor, fragment: Node[], options?: TextInsertFragmentOptions) => void;
    /**
     * Atomically inserts `nodes`
     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
     */
    insertNode: <T extends Node>(editor: Editor, node: Node, options?: NodeInsertNodesOptions<T>) => void;
    /**
     * Insert a soft break at the current selection.
     *
     * If the selection is currently expanded, it will be deleted first.
     */
    insertSoftBreak: (editor: Editor) => void;
    /**
     * Insert a string of text
     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
     */
    insertText: (editor: Editor, text: string, options?: TextInsertTextOptions) => void;
    /**
     * Check if a value is a block `Element` object.
     */
    isBlock: (editor: Editor, value: Element) => boolean;
    /**
     * Check if a point is an edge of a location.
     */
    isEdge: (editor: Editor, point: Point, at: Location) => boolean;
    /**
     * Check if a value is an `Editor` object.
     */
    isEditor: (value: any) => value is Editor;
    /**
     * Check if a value is a read-only `Element` object.
     */
    isElementReadOnly: (editor: Editor, element: Element) => boolean;
    /**
     * Check if an element is empty, accounting for void nodes.
     */
    isEmpty: (editor: Editor, element: Element) => boolean;
    /**
     * Check if a point is the end point of a location.
     */
    isEnd: (editor: Editor, point: Point, at: Location) => boolean;
    /**
     * Check if a value is an inline `Element` object.
     */
    isInline: (editor: Editor, value: Element) => boolean;
    /**
     * Check if the editor is currently normalizing after each operation.
     */
    isNormalizing: (editor: Editor) => boolean;
    /**
     * Check if a value is a selectable `Element` object.
     */
    isSelectable: (editor: Editor, element: Element) => 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: Element) => boolean;
    /**
     * Get the last node at a location.
     */
    last: (editor: Editor, at: Location) => NodeEntry;
    /**
     * Get the leaf text node at a location.
     */
    leaf: (editor: Editor, at: Location, options?: EditorLeafOptions) => NodeEntry<Text>;
    /**
     * Iterate through all of the levels at a location.
     */
    levels: <T extends Node>(editor: Editor, options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
    /**
     * Get the marks that would be added to text at the current selection.
     */
    marks: (editor: Editor) => Omit<Text, 'text'> | null;
    /**
     * Get the matching node in the branch of the document after a location.
     */
    next: <T extends Descendant>(editor: Editor, options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
    /**
     * Get the node at a location.
     */
    node: (editor: Editor, at: Location, options?: EditorNodeOptions) => NodeEntry;
    /**
     * Iterate through all of the nodes in the Editor.
     */
    nodes: <T extends Node>(editor: Editor, options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
    /**
     * Normalize any dirty objects in the editor.
     */
    normalize: (editor: Editor, options?: EditorNormalizeOptions) => void;
    /**
     * Get the parent node of a location.
     */
    parent: (editor: Editor, at: Location, options?: EditorParentOptions) => NodeEntry<Ancestor>;
    /**
     * Get the path of a location.
     */
    path: (editor: Editor, at: Location, options?: EditorPathOptions) => 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?: EditorPathRefOptions) => 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?: EditorPointOptions) => 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?: EditorPointRefOptions) => PointRef;
    /**
     * Get the set of currently tracked point refs of the editor.
     */
    pointRefs: (editor: Editor) => Set<PointRef>;
    /**
     * Return all the positions in `at` range where a `Point` can be placed.
     *
     * By default, moves forward by individual offsets at a time, but
     * the `unit` option can be used to to move by character, word, line, or block.
     *
     * The `reverse` option can be used to change iteration direction.
     *
     * Note: By default void nodes are treated as a single point and iteration
     * will not happen inside their content unless you pass in true for the
     * `voids` option, then iteration will occur.
     */
    positions: (editor: Editor, options?: EditorPositionsOptions) => Generator<Point, void, undefined>;
    /**
     * Get the matching node in the branch of the document before a location.
     */
    previous: <T extends Node>(editor: Editor, options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
    /**
     * Get a range of a location.
     */
    range: (editor: Editor, at: Location, to?: Location) => 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?: EditorRangeRefOptions) => 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;
    /**
     * Manually set if the editor should currently be normalizing.
     *
     * Note: Using this incorrectly can leave the editor in an invalid state.
     *
     */
    setNormalizing: (editor: Editor, isNormalizing: boolean) => void;
    /**
     * Get the start point of a location.
     */
    start: (editor: Editor, at: Location) => Point;
    /**
     * Get the text string content of a location.
     *
     * Note: by default the text of void nodes is considered to be an empty
     * string, regardless of content, unless you pass in true for the voids option
     */
    string: (editor: Editor, at: Location, options?: EditorStringOptions) => string;
    /**
     * Convert a range into a non-hanging one.
     */
    unhangRange: (editor: Editor, range: Range, options?: EditorUnhangRangeOptions) => Range;
    /**
     * Match a void node in the current branch of the editor.
     */
    void: (editor: Editor, options?: EditorVoidOptions) => NodeEntry<Element> | undefined;
    /**
     * Call a function, deferring normalization until after it completes.
     */
    withoutNormalizing: (editor: Editor, fn: () => void) => void;
    /**
     *  Call a function, Determine whether or not remove the previous node when merge.
     */
    shouldMergeNodesRemovePrevNode: (editor: Editor, prevNodeEntry: NodeEntry, curNodeEntry: NodeEntry) => boolean;
}
export declare const Editor: EditorInterface;
/**
 * A helper type for narrowing matched nodes with a predicate.
 */
export type NodeMatch<T extends Node> = ((node: Node, path: Path) => node is T) | ((node: Node, path: Path) => boolean);
export type PropsCompare = (prop: Partial<Node>, node: Partial<Node>) => boolean;
export type PropsMerge = (prop: Partial<Node>, node: Partial<Node>) => object;
//# sourceMappingURL=editor.d.ts.map