slate

slate

Version 0.117.0
Published 3 days ago
2.15 MB
2 dependencies
MIT license

Install

npm i slate

yarn add slate

pnpm add slate

Overview

A completely customizable framework for building rich text editors.

Index

Functions

createEditor()
isObject()
levels()
nodes()
positions()

Interfaces

BaseEditor
BaseElement
- children
BasePoint
- offset
- path
BaseRange
- anchor
- focus
BaseText
- text
CustomTypes
EditorAboveOptions
- at
- match
- mode
- voids
EditorAfterOptions
EditorBeforeOptions
EditorDirectedDeletionOptions
- unit
EditorElementReadOnlyOptions
- at
- mode
- voids
EditorFragmentDeletionOptions
- direction
EditorInterface
EditorIsEditorOptions
- deep
EditorLeafOptions
- depth
- edge
EditorLevelsOptions
EditorNextOptions
- at
- match
- mode
- voids
EditorNodeOptions
- depth
- edge
EditorNodesOptions
EditorNormalizeOptions
- force
- operation
EditorParentOptions
- depth
- edge
EditorPathOptions
- depth
- edge
EditorPathRefOptions
- affinity
EditorPointOptions
- edge
EditorPointRefOptions
- affinity
EditorPositionsOptions
EditorPreviousOptions
- at
- match
- mode
- voids
EditorRangeRefOptions
- affinity
EditorStringOptions
- voids
EditorUnhangRangeOptions
- voids
EditorVoidOptions
- at
- mode
- voids
ElementInterface
ElementIsElementOptions
- deep
LeafPosition
LocationInterface
- isLocation
NodeAncestorsOptions
- reverse
NodeChildrenOptions
- reverse
NodeDescendantsOptions
- from
- pass
- reverse
- to
NodeElementsOptions
- from
- pass
- reverse
- to
NodeInterface
NodeIsNodeOptions
- deep
NodeLevelsOptions
- reverse
NodeNodesOptions
- from
- pass
- reverse
- to
NodeTextsOptions
- from
- pass
- reverse
- to
OperationInterface
PathAncestorsOptions
- reverse
PathInterface
PathLevelsOptions
- reverse
PathRef
PathRefInterface
- transform
PathTransformOptions
- affinity
PointInterface
PointRef
PointRefInterface
- transform
PointTransformOptions
- affinity
RangeEdgesOptions
- reverse
RangeInterface
RangeRef
RangeRefInterface
- transform
RangeTransformOptions
- affinity
ScrubberInterface
- setScrubber()
- stringify()
SpanInterface
- isSpan
TextEqualsOptions
- loose
TextInterface

Variables

variable above

const above: <T extends Ancestor>(
    editor: BaseEditor,
    options?: EditorAboveOptions<T>
) => NodeEntry<T>;

variable addMark

const addMark: (editor: BaseEditor, key: string, value: any) => void;

variable after

const after: (
    editor: BaseEditor,
    at: Location,
    options?: EditorAfterOptions
) => BasePoint;

variable apply

const apply: WithEditorFirstArg<(operation: BaseOperation) => void>;

variable before

const before: (
    editor: BaseEditor,
    at: Location,
    options?: EditorBeforeOptions
) => BasePoint;

variable collapse

const collapse: (editor: BaseEditor, options?: SelectionCollapseOptions) => void;

variable deleteBackward

const deleteBackward: WithEditorFirstArg<(unit: TextUnit) => void>;

variable deleteForward

const deleteForward: WithEditorFirstArg<(unit: TextUnit) => void>;

variable deleteFragment

const deleteFragment: (
    editor: BaseEditor,
    options?: EditorFragmentDeletionOptions
) => void;

variable deleteText

const deleteText: (editor: BaseEditor, options?: TextDeleteOptions) => void;

variable deselect

const deselect: (editor: BaseEditor) => void;

variable edges

const edges: (editor: BaseEditor, at: Location) => [BasePoint, BasePoint];

variable Editor

const Editor: EditorInterface;

variable Element

const Element: ElementInterface;

variable elementReadOnly

const elementReadOnly: (
    editor: BaseEditor,
    options?: EditorElementReadOnlyOptions
) => NodeEntry<BaseElement>;

variable end

const end: (editor: BaseEditor, at: Location) => BasePoint;

variable first

const first: (editor: BaseEditor, at: Location) => NodeEntry<Node>;

variable fragment

const fragment: (editor: BaseEditor, at: Location) => Descendant[];

variable getDirtyPaths

const getDirtyPaths: WithEditorFirstArg<(operation: BaseOperation) => Path[]>;

Get the "dirty" paths generated from an operation.

variable getFragment

const getFragment: WithEditorFirstArg<() => Descendant[]>;

variable getVoid

const getVoid: (
    editor: BaseEditor,
    options?: EditorVoidOptions
) => NodeEntry<BaseElement>;

variable hasBlocks

const hasBlocks: (editor: BaseEditor, element: BaseElement) => boolean;

variable hasInlines

const hasInlines: (editor: BaseEditor, element: BaseElement) => boolean;

variable hasPath

const hasPath: (editor: BaseEditor, path: Path) => boolean;

variable hasTexts

const hasTexts: (editor: BaseEditor, element: BaseElement) => boolean;

variable insertBreak

const insertBreak: (editor: BaseEditor) => void;

variable insertFragment

const insertFragment: (
    editor: BaseEditor,
    fragment: Node[],
    options?: TextInsertFragmentOptions
) => void;

variable insertNode

const insertNode: <T extends Node>(
    editor: BaseEditor,
    node: Node,
    options?: NodeInsertNodesOptions<T>
) => void;

variable insertNodes

const insertNodes: <T extends Node>(
    editor: BaseEditor,
    nodes: Node | Node[],
    options?: NodeInsertNodesOptions<T>
) => void;

variable insertSoftBreak

const insertSoftBreak: (editor: BaseEditor) => void;

variable insertText

const insertText: (
    editor: BaseEditor,
    text: string,
    options?: TextInsertTextOptions
) => void;

variable isBlock

const isBlock: (editor: BaseEditor, value: BaseElement) => boolean;

variable isEdge

const isEdge: (editor: BaseEditor, point: BasePoint, at: Location) => boolean;

variable isEditor

const isEditor: (value: any, options?: EditorIsEditorOptions) => value is BaseEditor;

variable isEmpty

const isEmpty: (editor: BaseEditor, element: BaseElement) => boolean;

variable isEnd

const isEnd: (editor: BaseEditor, point: BasePoint, at: Location) => boolean;

variable isNormalizing

const isNormalizing: (editor: BaseEditor) => boolean;

variable isStart

const isStart: (editor: BaseEditor, point: BasePoint, at: Location) => boolean;

variable last

const last: (editor: BaseEditor, at: Location) => NodeEntry<Node>;

variable leaf

const leaf: (
    editor: BaseEditor,
    at: Location,
    options?: EditorLeafOptions
) => NodeEntry<BaseText>;

variable liftNodes

const liftNodes: <T extends Node>(
    editor: BaseEditor,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        voids?: boolean;
    }
) => void;

variable Location

const Location: LocationInterface;

variable marks

const marks: (editor: BaseEditor) => Omit<BaseText, 'text'>;

variable mergeNodes

const mergeNodes: <T extends Node>(
    editor: BaseEditor,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: RangeMode;
        hanging?: boolean;
        voids?: boolean;
    }
) => void;

variable move

const move: (editor: BaseEditor, options?: SelectionMoveOptions) => void;

variable moveNodes

const moveNodes: <T extends Node>(
    editor: BaseEditor,
    options: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        to: Path;
        voids?: boolean;
    }
) => void;

variable next

const next: <T extends Descendant>(
    editor: BaseEditor,
    options?: EditorNextOptions<T>
) => NodeEntry<T>;

variable node

const node: (
    editor: BaseEditor,
    at: Location,
    options?: EditorNodeOptions
) => NodeEntry<Node>;

variable Node

const Node: NodeInterface;

variable normalize

const normalize: (editor: BaseEditor, options?: EditorNormalizeOptions) => void;

variable normalizeNode

const normalizeNode: WithEditorFirstArg<
    (
        entry: NodeEntry<Node>,
        options?: { operation?: BaseOperation; fallbackElement?: () => BaseElement }
    ) => void
>;

variable Operation

const Operation: OperationInterface;

variable parent

const parent: (
    editor: BaseEditor,
    at: Location,
    options?: EditorParentOptions
) => NodeEntry<Ancestor>;

variable path

const path: (editor: BaseEditor, at: Location, options?: EditorPathOptions) => Path;

variable Path

const Path: PathInterface;

variable pathRef

const pathRef: (
    editor: BaseEditor,
    path: Path,
    options?: EditorPathRefOptions
) => PathRef;

variable PathRef

const PathRef: PathRefInterface;

variable pathRefs

const pathRefs: (editor: BaseEditor) => Set<PathRef>;

variable point

const point: (
    editor: BaseEditor,
    at: Location,
    options?: EditorPointOptions
) => BasePoint;

variable Point

const Point: PointInterface;

variable pointRef

const pointRef: (
    editor: BaseEditor,
    point: BasePoint,
    options?: EditorPointRefOptions
) => PointRef;

variable PointRef

const PointRef: PointRefInterface;

variable pointRefs

const pointRefs: (editor: BaseEditor) => Set<PointRef>;

variable previous

const previous: <T extends Node>(
    editor: BaseEditor,
    options?: EditorPreviousOptions<T>
) => NodeEntry<T>;

variable range

const range: (editor: BaseEditor, at: Location, to?: Location) => BaseRange;

variable Range

const Range: RangeInterface;

variable rangeRef

const rangeRef: (
    editor: BaseEditor,
    range: BaseRange,
    options?: EditorRangeRefOptions
) => RangeRef;

variable RangeRef

const RangeRef: RangeRefInterface;

variable rangeRefs

const rangeRefs: (editor: BaseEditor) => Set<RangeRef>;

variable removeMark

const removeMark: (editor: BaseEditor, key: string) => void;

variable removeNodes

const removeNodes: <T extends Node>(
    editor: BaseEditor,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: RangeMode;
        hanging?: boolean;
        voids?: boolean;
    }
) => void;

variable Scrubber

const Scrubber: ScrubberInterface;

This interface implements a stringify() function, which is used by Slate internally when generating exceptions containing end user data. Developers using Slate may call Scrubber.setScrubber() to alter the behavior of this stringify() function.
For example, to prevent the cleartext logging of 'text' fields within Nodes:
import { Scrubber } from 'slate'; Scrubber.setScrubber((key, val) => { if (key === 'text') return '...scrubbed...' return val });

variable select

const select: (editor: BaseEditor, target: Location) => void;

variable setNodes

const setNodes: <T extends Node>(
    editor: BaseEditor,
    props: Partial<T>,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        hanging?: boolean;
        split?: boolean;
        voids?: boolean;
        compare?: PropsCompare;
        merge?: PropsMerge;
    }
) => void;

variable setNormalizing

const setNormalizing: (editor: BaseEditor, isNormalizing: boolean) => void;

variable setPoint

const setPoint: (
    editor: BaseEditor,
    props: Partial<BasePoint>,
    options?: SelectionSetPointOptions
) => void;

variable setSelection

const setSelection: (editor: BaseEditor, props: Partial<BaseRange>) => void;

variable shouldMergeNodesRemovePrevNode

const shouldMergeNodesRemovePrevNode: (
    editor: BaseEditor,
    prevNodeEntry: NodeEntry<Node>,
    curNodeEntry: NodeEntry<Node>
) => boolean;

variable shouldNormalize

const shouldNormalize: WithEditorFirstArg<
    ({
        iteration,
        dirtyPaths,
        operation,
    }: {
        iteration: number;
        initialDirtyPathsLength: number;
        dirtyPaths: Path[];
        operation?: BaseOperation;
    }) => boolean
>;

variable Span

const Span: SpanInterface;

variable splitNodes

const splitNodes: <T extends Node>(
    editor: BaseEditor,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: RangeMode;
        always?: boolean;
        height?: number;
        voids?: boolean;
    }
) => void;

variable start

const start: (editor: BaseEditor, at: Location) => BasePoint;

variable string

const string: (
    editor: BaseEditor,
    at: Location,
    options?: EditorStringOptions
) => string;

variable Text

const Text: TextInterface;

variable Transforms

const Transforms: GeneralTransforms &
    NodeTransforms &
    SelectionTransforms &
    TextTransforms;

variable unhangRange

const unhangRange: (
    editor: BaseEditor,
    range: BaseRange,
    options?: EditorUnhangRangeOptions
) => BaseRange;

variable unsetNodes

const unsetNodes: <T extends Node>(
    editor: BaseEditor,
    props: string | string[],
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        hanging?: boolean;
        split?: boolean;
        voids?: boolean;
    }
) => void;

variable unwrapNodes

const unwrapNodes: <T extends Node>(
    editor: BaseEditor,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        split?: boolean;
        voids?: boolean;
    }
) => void;

variable withoutNormalizing

const withoutNormalizing: (editor: BaseEditor, fn: () => void) => void;

variable wrapNodes

const wrapNodes: <T extends Node>(
    editor: BaseEditor,
    element: BaseElement,
    options?: {
        at?: Location;
        match?: NodeMatch<T>;
        mode?: MaximizeMode;
        split?: boolean;
        voids?: boolean;
    }
) => void;

Functions

function createEditor

createEditor: () => Editor;

Create a new Slate Editor object.

function isObject

isObject: (value: any) => boolean;

function levels

levels: <T extends Node>(
    editor: Editor,
    options?: EditorLevelsOptions<T>
) => Generator<NodeEntry<T>, void, undefined>;

function nodes

nodes: <T extends Node>(
    editor: Editor,
    options?: EditorNodesOptions<T>
) => Generator<NodeEntry<T>, void, undefined>;

function positions

positions: (
    editor: Editor,
    options?: EditorPositionsOptions
) => Generator<Point, void, undefined>;

Interfaces

interface BaseEditor

interface BaseEditor {}

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.

property above

above: <T extends Ancestor>(
    options?: EditorAboveOptions<T>
) => NodeEntry<T> | undefined;

property addMark

addMark: OmitFirstArg<typeof Editor.addMark>;

property after

after: OmitFirstArg<typeof Editor.after>;

property apply

apply: (operation: Operation) => void;

property before

before: OmitFirstArg<typeof Editor.before>;

property children

children: Descendant[];

property collapse

collapse: OmitFirstArg<typeof Transforms.collapse>;

property delete

delete: OmitFirstArg<typeof Transforms.delete>;

property deleteBackward

deleteBackward: (unit: TextUnit) => void;

property deleteForward

deleteForward: (unit: TextUnit) => void;

property deleteFragment

deleteFragment: OmitFirstArg<typeof Editor.deleteFragment>;

property deselect

deselect: OmitFirstArg<typeof Transforms.deselect>;

property edges

edges: OmitFirstArg<typeof Editor.edges>;

property elementReadOnly

elementReadOnly: OmitFirstArg<typeof Editor.elementReadOnly>;

property end

end: OmitFirstArg<typeof Editor.end>;

property first

first: OmitFirstArg<typeof Editor.first>;

property fragment

fragment: OmitFirstArg<typeof Editor.fragment>;

property getDirtyPaths

getDirtyPaths: (operation: Operation) => Path[];

property getFragment

getFragment: () => Descendant[];

property getMarks

getMarks: OmitFirstArg<typeof Editor.marks>;

property hasBlocks

hasBlocks: OmitFirstArg<typeof Editor.hasBlocks>;

property hasInlines

hasInlines: OmitFirstArg<typeof Editor.hasInlines>;

property hasPath

hasPath: OmitFirstArg<typeof Editor.hasPath>;

property hasTexts

hasTexts: OmitFirstArg<typeof Editor.hasTexts>;

property insertBreak

insertBreak: OmitFirstArg<typeof Editor.insertBreak>;

property insertFragment

insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;

property insertNode

insertNode: OmitFirstArg<typeof Editor.insertNode>;

property insertNodes

insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;

property insertSoftBreak

insertSoftBreak: OmitFirstArg<typeof Editor.insertSoftBreak>;

property insertText

insertText: OmitFirstArg<typeof Transforms.insertText>;

property isBlock

isBlock: OmitFirstArg<typeof Editor.isBlock>;

property isEdge

isEdge: OmitFirstArg<typeof Editor.isEdge>;

property isElementReadOnly

isElementReadOnly: (element: Element) => boolean;

property isEmpty

isEmpty: OmitFirstArg<typeof Editor.isEmpty>;

property isEnd

isEnd: OmitFirstArg<typeof Editor.isEnd>;

property isInline

isInline: OmitFirstArg<typeof Editor.isInline>;

property isNormalizing

isNormalizing: OmitFirstArg<typeof Editor.isNormalizing>;

property isSelectable

isSelectable: (element: Element) => boolean;

property isStart

isStart: OmitFirstArg<typeof Editor.isStart>;

property isVoid

isVoid: OmitFirstArg<typeof Editor.isVoid>;

property last

last: OmitFirstArg<typeof Editor.last>;

property leaf

leaf: OmitFirstArg<typeof Editor.leaf>;

property levels

levels: <T extends Node>(
    options?: EditorLevelsOptions<T>
) => Generator<NodeEntry<T>, void, undefined>;

property liftNodes

liftNodes: OmitFirstArg<typeof Transforms.liftNodes>;

property markableVoid

markableVoid: (element: Element) => boolean;

property marks

marks: EditorMarks | null;

property mergeNodes

mergeNodes: OmitFirstArg<typeof Transforms.mergeNodes>;

property move

move: OmitFirstArg<typeof Transforms.move>;

property moveNodes

moveNodes: OmitFirstArg<typeof Transforms.moveNodes>;

property next

next: <T extends Descendant>(
    options?: EditorNextOptions<T>
) => NodeEntry<T> | undefined;

property node

node: OmitFirstArg<typeof Editor.node>;

property nodes

nodes: <T extends Node>(
    options?: EditorNodesOptions<T>
) => Generator<NodeEntry<T>, void, undefined>;

property normalize

normalize: OmitFirstArg<typeof Editor.normalize>;

property normalizeNode

normalizeNode: (
    entry: NodeEntry,
    options?: {
        operation?: Operation;
        fallbackElement?: () => Element;
    }
) => void;

property onChange

onChange: (options?: { operation?: Operation }) => void;

property operations

operations: Operation[];

property parent

parent: OmitFirstArg<typeof Editor.parent>;

property path

path: OmitFirstArg<typeof Editor.path>;

property pathRef

pathRef: OmitFirstArg<typeof Editor.pathRef>;

property pathRefs

pathRefs: OmitFirstArg<typeof Editor.pathRefs>;

property point

point: OmitFirstArg<typeof Editor.point>;

property pointRef

pointRef: OmitFirstArg<typeof Editor.pointRef>;

property pointRefs

pointRefs: OmitFirstArg<typeof Editor.pointRefs>;

property positions

positions: OmitFirstArg<typeof Editor.positions>;

property previous

previous: <T extends Node>(
    options?: EditorPreviousOptions<T>
) => NodeEntry<T> | undefined;

property range

range: OmitFirstArg<typeof Editor.range>;

property rangeRef

rangeRef: OmitFirstArg<typeof Editor.rangeRef>;

property rangeRefs

rangeRefs: OmitFirstArg<typeof Editor.rangeRefs>;

property removeMark

removeMark: OmitFirstArg<typeof Editor.removeMark>;

property removeNodes

removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;

property select

select: OmitFirstArg<typeof Transforms.select>;

property selection

selection: Selection;

property setNodes

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;

property setNormalizing

setNormalizing: OmitFirstArg<typeof Editor.setNormalizing>;

property setPoint

setPoint: OmitFirstArg<typeof Transforms.setPoint>;

property setSelection

setSelection: OmitFirstArg<typeof Transforms.setSelection>;

property shouldMergeNodesRemovePrevNode

shouldMergeNodesRemovePrevNode: OmitFirstArg<
    typeof Editor.shouldMergeNodesRemovePrevNode
>;

property shouldNormalize

shouldNormalize: ({
    iteration,
    dirtyPaths,
    operation,
}: {
    iteration: number;
    initialDirtyPathsLength: number;
    dirtyPaths: Path[];
    operation?: Operation;
}) => boolean;

property splitNodes

splitNodes: OmitFirstArg<typeof Transforms.splitNodes>;

property start

start: OmitFirstArg<typeof Editor.start>;

property string

string: OmitFirstArg<typeof Editor.string>;

property unhangRange

unhangRange: OmitFirstArg<typeof Editor.unhangRange>;

property unsetNodes

unsetNodes: OmitFirstArg<typeof Transforms.unsetNodes>;

property unwrapNodes

unwrapNodes: OmitFirstArg<typeof Transforms.unwrapNodes>;

property void

void: OmitFirstArg<typeof Editor.void>;

property withoutNormalizing

withoutNormalizing: OmitFirstArg<typeof Editor.withoutNormalizing>;

property wrapNodes

wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;

interface BaseElement

interface BaseElement {}

Element objects are a type of node in a Slate document that contain other element nodes or text nodes. They can be either "blocks" or "inlines" depending on the Slate editor's configuration.

property children

children: Descendant[];

interface BasePoint

interface BasePoint {}

Point objects refer to a specific location in a text node in a Slate document. Its path refers to the location of the node in the tree, and its offset refers to the distance into the node's string of text. Points can only refer to Text nodes.

property offset

offset: number;

property path

path: Path;

interface BaseRange

interface BaseRange {}

Range objects are a set of points that refer to a specific span of a Slate document. They can define a span inside a single node or a can span across multiple nodes.

property anchor

anchor: Point;

property focus

focus: Point;

interface BaseText

interface BaseText {}

Text objects represent the nodes that contain the actual text content of a Slate document along with any formatting properties. They are always leaf nodes in the document tree as they cannot contain any children.

property text

text: string;

interface CustomTypes

interface CustomTypes {}

index signature

[key: string]: unknown;

interface EditorAboveOptions

interface EditorAboveOptions<T extends Ancestor> {}

property at

at?: Location;

property match

match?: NodeMatch<T>;

property mode

mode?: MaximizeMode;

property voids

voids?: boolean;

interface EditorAfterOptions

interface EditorAfterOptions {}

property distance

distance?: number;

property unit

unit?: TextUnitAdjustment;

property voids

voids?: boolean;

interface EditorBeforeOptions

interface EditorBeforeOptions {}

property distance

distance?: number;

property unit

unit?: TextUnitAdjustment;

property voids

voids?: boolean;

interface EditorDirectedDeletionOptions

interface EditorDirectedDeletionOptions {}

property unit

unit?: TextUnit;

interface EditorElementReadOnlyOptions

interface EditorElementReadOnlyOptions {}

property at

at?: Location;

property mode

mode?: MaximizeMode;

property voids

voids?: boolean;

interface EditorFragmentDeletionOptions

interface EditorFragmentDeletionOptions {}

property direction

direction?: TextDirection;

interface EditorInterface

interface EditorInterface {}

property above

above: <T extends Ancestor>(
    editor: Editor,
    options?: EditorAboveOptions<T>
) => NodeEntry<T> | undefined;

Get the ancestor above a location in the document.

property addMark

addMark: (editor: Editor, key: string, value: any) => void;

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.

property after

after: (
    editor: Editor,
    at: Location,
    options?: EditorAfterOptions
) => Point | undefined;

Get the point after a location.

property before

before: (
    editor: Editor,
    at: Location,
    options?: EditorBeforeOptions
) => Point | undefined;

Get the point before a location.

property deleteBackward

deleteBackward: (
    editor: Editor,
    options?: EditorDirectedDeletionOptions
) => void;

Delete content in the editor backward from the current selection.

property deleteForward

deleteForward: (editor: Editor, options?: EditorDirectedDeletionOptions) => void;

Delete content in the editor forward from the current selection.

property deleteFragment

deleteFragment: (
    editor: Editor,
    options?: EditorFragmentDeletionOptions
) => void;

Delete the content in the current selection.

property edges

edges: (editor: Editor, at: Location) => [Point, Point];

Get the start and end points of a location.

property elementReadOnly

elementReadOnly: (
    editor: Editor,
    options?: EditorElementReadOnlyOptions
) => NodeEntry<Element> | undefined;

Match a read-only element in the current branch of the editor.

property end

end: (editor: Editor, at: Location) => Point;

Get the end point of a location.

property first

first: (editor: Editor, at: Location) => NodeEntry;

Get the first node at a location.

property fragment

fragment: (editor: Editor, at: Location) => Descendant[];

Get the fragment at a location.

property hasBlocks

hasBlocks: (editor: Editor, element: Element) => boolean;

Check if a node has block children.

property hasInlines

hasInlines: (editor: Editor, element: Element) => boolean;

Check if a node has inline and text children.

property hasPath

hasPath: (editor: Editor, path: Path) => boolean;

property hasTexts

hasTexts: (editor: Editor, element: Element) => boolean;

Check if a node has text children.

property insertBreak

insertBreak: (editor: Editor) => void;

Insert a block break at the current selection.
If the selection is currently expanded, it will be deleted first.

property insertFragment

insertFragment: (
    editor: Editor,
    fragment: Node[],
    options?: TextInsertFragmentOptions
) => void;

Inserts a fragment at the specified location or (if not defined) the current selection or (if not defined) the end of the document.

property insertNode

insertNode: <T extends Node>(
    editor: Editor,
    node: Node,
    options?: NodeInsertNodesOptions<T>
) => void;

Atomically inserts nodes at the specified location or (if not defined) the current selection or (if not defined) the end of the document.

property insertSoftBreak

insertSoftBreak: (editor: Editor) => void;

Insert a soft break at the current selection.
If the selection is currently expanded, it will be deleted first.

property insertText

insertText: (
    editor: Editor,
    text: string,
    options?: TextInsertTextOptions
) => 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.

property isBlock

isBlock: (editor: Editor, value: Element) => boolean;

Check if a value is a block Element object.

property isEdge

isEdge: (editor: Editor, point: Point, at: Location) => boolean;

Check if a point is an edge of a location.

property isEditor

isEditor: (value: any, options?: EditorIsEditorOptions) => value is Editor;

Check if a value is an Editor object.

property isElementReadOnly

isElementReadOnly: (editor: Editor, element: Element) => boolean;

Check if a value is a read-only Element object.

property isEmpty

isEmpty: (editor: Editor, element: Element) => boolean;

Check if an element is empty, accounting for void nodes.

property isEnd

isEnd: (editor: Editor, point: Point, at: Location) => boolean;

Check if a point is the end point of a location.

property isInline

isInline: (editor: Editor, value: Element) => boolean;

Check if a value is an inline Element object.

property isNormalizing

isNormalizing: (editor: Editor) => boolean;

Check if the editor is currently normalizing after each operation.

property isSelectable

isSelectable: (editor: Editor, element: Element) => boolean;

Check if a value is a selectable Element object.

property isStart

isStart: (editor: Editor, point: Point, at: Location) => boolean;

Check if a point is the start point of a location.

property isVoid

isVoid: (editor: Editor, value: Element) => boolean;

Check if a value is a void Element object.

property last

last: (editor: Editor, at: Location) => NodeEntry;

Get the last node at a location.

property leaf

leaf: (
    editor: Editor,
    at: Location,
    options?: EditorLeafOptions
) => NodeEntry<Text>;

Get the leaf text node at a location.

property levels

levels: <T extends Node>(
    editor: Editor,
    options?: EditorLevelsOptions<T>
) => Generator<NodeEntry<T>, void, undefined>;

Iterate through all of the levels at a location.

property marks

marks: (editor: Editor) => Omit<Text, 'text'> | null;

Get the marks that would be added to text at the current selection.

property next

next: <T extends Descendant>(
    editor: Editor,
    options?: EditorNextOptions<T>
) => NodeEntry<T> | undefined;

Get the matching node in the branch of the document after a location.

property node

node: (editor: Editor, at: Location, options?: EditorNodeOptions) => NodeEntry;

Get the node at a location.

property nodes

nodes: <T extends Node>(
    editor: Editor,
    options?: EditorNodesOptions<T>
) => Generator<NodeEntry<T>, void, undefined>;

Iterate through all of the nodes in the Editor.

property normalize

normalize: (editor: Editor, options?: EditorNormalizeOptions) => void;

Normalize any dirty objects in the editor.

property parent

parent: (
    editor: Editor,
    at: Location,
    options?: EditorParentOptions
) => NodeEntry<Ancestor>;

Get the parent node of a location.

property path

path: (editor: Editor, at: Location, options?: EditorPathOptions) => Path;

Get the path of a location.

property pathRef

pathRef: (editor: Editor, path: Path, options?: EditorPathRefOptions) => PathRef;

Create a mutable ref for a Path object, which will stay in sync as new operations are applied to the editor.

property pathRefs

pathRefs: (editor: Editor) => Set<PathRef>;

Get the set of currently tracked path refs of the editor.

property point

point: (editor: Editor, at: Location, options?: EditorPointOptions) => Point;

Get the start or end point of a location.

property pointRef

pointRef: (
    editor: Editor,
    point: Point,
    options?: EditorPointRefOptions
) => PointRef;

Create a mutable ref for a Point object, which will stay in sync as new operations are applied to the editor.

property pointRefs

pointRefs: (editor: Editor) => Set<PointRef>;

Get the set of currently tracked point refs of the editor.

property positions

positions: (
    editor: Editor,
    options?: EditorPositionsOptions
) => Generator<Point, void, undefined>;

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.

property previous

previous: <T extends Node>(
    editor: Editor,
    options?: EditorPreviousOptions<T>
) => NodeEntry<T> | undefined;

Get the matching node in the branch of the document before a location.

property range

range: (editor: Editor, at: Location, to?: Location) => Range;

Get a range of a location.

property rangeRef

rangeRef: (
    editor: Editor,
    range: Range,
    options?: EditorRangeRefOptions
) => RangeRef;

Create a mutable ref for a Range object, which will stay in sync as new operations are applied to the editor.

property rangeRefs

rangeRefs: (editor: Editor) => Set<RangeRef>;

Get the set of currently tracked range refs of the editor.

property removeMark

removeMark: (editor: Editor, key: string) => void;

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.

property setNormalizing

setNormalizing: (editor: Editor, isNormalizing: boolean) => void;

Manually set if the editor should currently be normalizing.
Note: Using this incorrectly can leave the editor in an invalid state.

property shouldMergeNodesRemovePrevNode

shouldMergeNodesRemovePrevNode: (
    editor: Editor,
    prevNodeEntry: NodeEntry,
    curNodeEntry: NodeEntry
) => boolean;

Call a function, Determine whether or not remove the previous node when merge.

property start

start: (editor: Editor, at: Location) => Point;

Get the start point of a location.

property string

string: (editor: Editor, at: Location, options?: EditorStringOptions) => string;

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

property unhangRange

unhangRange: (
    editor: Editor,
    range: Range,
    options?: EditorUnhangRangeOptions
) => Range;

Convert a range into a non-hanging one.

property void

void: (
    editor: Editor,
    options?: EditorVoidOptions
) => NodeEntry<Element> | undefined;

Match a void node in the current branch of the editor.

property withoutNormalizing

withoutNormalizing: (editor: Editor, fn: () => void) => void;

Call a function, deferring normalization until after it completes.

interface EditorIsEditorOptions

interface EditorIsEditorOptions {}

property deep

deep?: boolean;

interface EditorLeafOptions

interface EditorLeafOptions {}

property depth

depth?: number;

property edge

edge?: LeafEdge;

interface EditorLevelsOptions

interface EditorLevelsOptions<T extends Node> {}

property at

at?: Location;

property match

match?: NodeMatch<T>;

property reverse

reverse?: boolean;

property voids

voids?: boolean;

interface EditorNextOptions

interface EditorNextOptions<T extends Descendant> {}

property at

at?: Location;

property match

match?: NodeMatch<T>;

property mode

mode?: SelectionMode;

property voids

voids?: boolean;

interface EditorNodeOptions

interface EditorNodeOptions {}

property depth

depth?: number;

property edge

edge?: LeafEdge;

interface EditorNodesOptions

interface EditorNodesOptions<T extends Node> {}

property at

at?: Location | Span;

property match

match?: NodeMatch<T>;

property mode

mode?: SelectionMode;

property pass

pass?: (entry: NodeEntry) => boolean;

property reverse

reverse?: boolean;

property universal

universal?: boolean;

property voids

voids?: boolean;

interface EditorNormalizeOptions

interface EditorNormalizeOptions {}

property force

force?: boolean;

property operation

operation?: Operation;

interface EditorParentOptions

interface EditorParentOptions {}

property depth

depth?: number;

property edge

edge?: LeafEdge;

interface EditorPathOptions

interface EditorPathOptions {}

property depth

depth?: number;

property edge

edge?: LeafEdge;

interface EditorPathRefOptions

interface EditorPathRefOptions {}

property affinity

affinity?: TextDirection | null;

interface EditorPointOptions

interface EditorPointOptions {}

property edge

edge?: LeafEdge;

interface EditorPointRefOptions

interface EditorPointRefOptions {}

property affinity

affinity?: TextDirection | null;

interface EditorPositionsOptions

interface EditorPositionsOptions {}

property at

at?: Location;

property reverse

reverse?: boolean;

property unit

unit?: TextUnitAdjustment;

property voids

voids?: boolean;

interface EditorPreviousOptions

interface EditorPreviousOptions<T extends Node> {}

property at

at?: Location;

property match

match?: NodeMatch<T>;

property mode

mode?: SelectionMode;

property voids

voids?: boolean;

interface EditorRangeRefOptions

interface EditorRangeRefOptions {}

property affinity

affinity?: RangeDirection | null;

interface EditorStringOptions

interface EditorStringOptions {}

property voids

voids?: boolean;

interface EditorUnhangRangeOptions

interface EditorUnhangRangeOptions {}

property voids

voids?: boolean;

interface EditorVoidOptions

interface EditorVoidOptions {}

property at

at?: Location;

property mode

mode?: MaximizeMode;

property voids

voids?: boolean;

interface ElementInterface

interface ElementInterface {}

property isAncestor

isAncestor: (value: any, options?: ElementIsElementOptions) => value is Ancestor;

Check if a value implements the 'Ancestor' interface.

property isElement

isElement: (value: any, options?: ElementIsElementOptions) => value is Element;

Check if a value implements the Element interface.

property isElementList

isElementList: (
    value: any,
    options?: ElementIsElementOptions
) => value is Element[];

Check if a value is an array of Element objects.

property isElementProps

isElementProps: (props: any) => props is Partial<Element>;

Check if a set of props is a partial of Element.

property isElementType

isElementType: <T extends Element>(
    value: any,
    elementVal: string,
    elementKey?: string
) => value is T;

Check if a value implements the Element interface and has elementKey with selected value. Default it check to type key value

property matches

matches: (element: Element, props: Partial<Element>) => boolean;

Check if an element matches set of properties.
Note: this checks custom properties, and it does not ensure that any children are equivalent.

interface ElementIsElementOptions

interface ElementIsElementOptions {}

property deep

deep?: boolean;

interface LeafPosition

interface LeafPosition {}

property end

end: number;

property isFirst

isFirst?: true;

property isLast

isLast?: true;

property start

start: number;

interface LocationInterface

interface LocationInterface {}

property isLocation

isLocation: (value: any) => value is Location;

Check if a value implements the Location interface.

interface NodeAncestorsOptions

interface NodeAncestorsOptions {}

property reverse

reverse?: boolean;

interface NodeChildrenOptions

interface NodeChildrenOptions {}

property reverse

reverse?: boolean;

interface NodeDescendantsOptions

interface NodeDescendantsOptions {}

property from

from?: Path;

property pass

pass?: (node: NodeEntry) => boolean;

property reverse

reverse?: boolean;

property to

to?: Path;

interface NodeElementsOptions

interface NodeElementsOptions {}

property from

from?: Path;

property pass

pass?: (node: NodeEntry) => boolean;

property reverse

reverse?: boolean;

property to

to?: Path;

interface NodeInterface

interface NodeInterface {}

property ancestor

ancestor: (root: Node, path: Path) => Ancestor;

Get the node at a specific path, asserting that it's an ancestor node.

property ancestors

ancestors: (
    root: Node,
    path: Path,
    options?: NodeAncestorsOptions
) => Generator<NodeEntry<Ancestor>, void, undefined>;

Return a generator of all the ancestor nodes above a specific path.
By default the order is top-down, from highest to lowest ancestor in the tree, but you can pass the reverse: true option to go bottom-up.

property child

child: (root: Node, index: number) => Descendant;

Get the child of a node at a specific index.

property children

children: (
    root: Node,
    path: Path,
    options?: NodeChildrenOptions
) => Generator<NodeEntry<Descendant>, void, undefined>;

Iterate over the children of a node at a specific path.

property common

common: (root: Node, path: Path, another: Path) => NodeEntry;

Get an entry for the common ancesetor node of two paths.

property descendant

descendant: (root: Node, path: Path) => Descendant;

Get the node at a specific path, asserting that it's a descendant node.

property descendants

descendants: (
    root: Node,
    options?: NodeDescendantsOptions
) => Generator<NodeEntry<Descendant>, void, undefined>;

Return a generator of all the descendant node entries inside a root node.

property elements

elements: (
    root: Node,
    options?: NodeElementsOptions
) => Generator<ElementEntry, void, undefined>;

Return a generator of all the element nodes inside a root node. Each iteration will return an ElementEntry tuple consisting of [Element, Path]. If the root node is an element it will be included in the iteration as well.

property extractProps

extractProps: (node: Node) => NodeProps;

Extract props from a Node.

property first

first: (root: Node, path: Path) => NodeEntry;

Get the first leaf node entry in a root node from a path.

property fragment

fragment: (root: Node, range: Range) => Descendant[];

Get the sliced fragment represented by a range inside a root node.

property get

get: (root: Node, path: Path) => Node;

Get the descendant node referred to by a specific path. If the path is an empty array, it refers to the root node itself.

property getIf

getIf: (root: Node, path: Path) => Node | undefined;

Similar to get, but returns undefined if the node does not exist.

property has

has: (root: Node, path: Path) => boolean;

Check if a descendant node exists at a specific path.

property isNode

isNode: (value: any, options?: NodeIsNodeOptions) => value is Node;

Check if a value implements the Node interface.

property isNodeList

isNodeList: (value: any, options?: NodeIsNodeOptions) => value is Node[];

Check if a value is a list of Node objects.

property last

last: (root: Node, path: Path) => NodeEntry;

Get the last leaf node entry in a root node from a path.

property leaf

leaf: (root: Node, path: Path) => Text;

Get the node at a specific path, ensuring it's a leaf text node.

property levels

levels: (
    root: Node,
    path: Path,
    options?: NodeLevelsOptions
) => Generator<NodeEntry, void, undefined>;

Return a generator of the in a branch of the tree, from a specific path.
By default the order is top-down, from highest to lowest node in the tree, but you can pass the reverse: true option to go bottom-up.

property matches

matches: (node: Node, props: Partial<Node>) => boolean;

Check if a node matches a set of props.

property nodes

nodes: (
    root: Node,
    options?: NodeNodesOptions
) => Generator<NodeEntry, void, undefined>;

Return a generator of all the node entries of a root node. Each entry is returned as a [Node, Path] tuple, with the path referring to the node's position inside the root node.

property parent

parent: (root: Node, path: Path) => Ancestor;

Get the parent of a node at a specific path.

property string

string: (node: Node) => string;

Get the concatenated text string of a node's content.
Note that this will not include spaces or line breaks between block nodes. It is not a user-facing string, but a string for performing offset-related computations for a node.

property texts

texts: (
    root: Node,
    options?: NodeTextsOptions
) => Generator<NodeEntry<Text>, void, undefined>;

Return a generator of all leaf text nodes in a root node.

interface NodeIsNodeOptions

interface NodeIsNodeOptions {}

property deep

deep?: boolean;

interface NodeLevelsOptions

interface NodeLevelsOptions {}

property reverse

reverse?: boolean;

interface NodeNodesOptions

interface NodeNodesOptions {}

property from

from?: Path;

property pass

pass?: (entry: NodeEntry) => boolean;

property reverse

reverse?: boolean;

property to

to?: Path;

interface NodeTextsOptions

interface NodeTextsOptions {}

property from

from?: Path;

property pass

pass?: (node: NodeEntry) => boolean;

property reverse

reverse?: boolean;

property to

to?: Path;

interface OperationInterface

interface OperationInterface {}

property inverse

inverse: (op: Operation) => Operation;

Invert an operation, returning a new operation that will exactly undo the original when applied.

property isNodeOperation

isNodeOperation: (value: any) => value is NodeOperation;

Check if a value is a NodeOperation object.

property isOperation

isOperation: (value: any) => value is Operation;

Check if a value is an Operation object.

property isOperationList

isOperationList: (value: any) => value is Operation[];

Check if a value is a list of Operation objects.

property isSelectionOperation

isSelectionOperation: (value: any) => value is SelectionOperation;

Check if a value is a SelectionOperation object.

property isTextOperation

isTextOperation: (value: any) => value is TextOperation;

Check if a value is a TextOperation object.

interface PathAncestorsOptions

interface PathAncestorsOptions {}

property reverse

reverse?: boolean;

interface PathInterface

interface PathInterface {}

property ancestors

ancestors: (path: Path, options?: PathAncestorsOptions) => Path[];

Get a list of ancestor paths for a given path.
The paths are sorted from shallowest to deepest ancestor. However, if the reverse: true option is passed, they are reversed.

property common

common: (path: Path, another: Path) => Path;

Get the common ancestor path of two paths.

property compare

compare: (path: Path, another: Path) => -1 | 0 | 1;

Compare a path to another, returning an integer indicating whether the path was before, at, or after the other.
Note: Two paths of unequal length can still receive a 0 result if one is directly above or below the other. If you want exact matching, use [[Path.equals]] instead.

property endsAfter

endsAfter: (path: Path, another: Path) => boolean;

Check if a path ends after one of the indexes in another.

property endsAt

endsAt: (path: Path, another: Path) => boolean;

Check if a path ends at one of the indexes in another.

property endsBefore

endsBefore: (path: Path, another: Path) => boolean;

Check if a path ends before one of the indexes in another.

property equals

equals: (path: Path, another: Path) => boolean;

Check if a path is exactly equal to another.

property hasPrevious

hasPrevious: (path: Path) => boolean;

Check if the path of previous sibling node exists

property isAfter

isAfter: (path: Path, another: Path) => boolean;

Check if a path is after another.

property isAncestor

isAncestor: (path: Path, another: Path) => boolean;

Check if a path is an ancestor of another.

property isBefore

isBefore: (path: Path, another: Path) => boolean;

Check if a path is before another.

property isChild

isChild: (path: Path, another: Path) => boolean;

Check if a path is a child of another.

property isCommon

isCommon: (path: Path, another: Path) => boolean;

Check if a path is equal to or an ancestor of another.

property isDescendant

isDescendant: (path: Path, another: Path) => boolean;

Check if a path is a descendant of another.

property isParent

isParent: (path: Path, another: Path) => boolean;

Check if a path is the parent of another.

property isPath

isPath: (value: any) => value is Path;

Check is a value implements the Path interface.

property isSibling

isSibling: (path: Path, another: Path) => boolean;

Check if a path is a sibling of another.

property levels

levels: (path: Path, options?: PathLevelsOptions) => Path[];

Get a list of paths at every level down to a path. Note: this is the same as Path.ancestors, but including the path itself.
The paths are sorted from shallowest to deepest. However, if the `reverse: true` option is passed, they are reversed.

property next

next: (path: Path) => Path;

Given a path, get the path to the next sibling node.

property operationCanTransformPath

operationCanTransformPath: (
    operation: Operation
) => operation is
    | InsertNodeOperation
    | RemoveNodeOperation
    | MergeNodeOperation
    | SplitNodeOperation
    | MoveNodeOperation;

Returns whether this operation can affect paths or not. Used as an optimization when updating dirty paths during normalization
NOTE: This *must* be kept in sync with the implementation of 'transform' below

property parent

parent: (path: Path) => Path;

Given a path, return a new path referring to the parent node above it.

property previous

previous: (path: Path) => Path;

Given a path, get the path to the previous sibling node.

property relative

relative: (path: Path, ancestor: Path) => Path;

Get a path relative to an ancestor.

property transform

transform: (
    path: Path,
    operation: Operation,
    options?: PathTransformOptions
) => Path | null;

Transform a path by an operation.

interface PathLevelsOptions

interface PathLevelsOptions {}

property reverse

reverse?: boolean;

interface PathRef

interface PathRef {}

PathRef objects keep a specific path in a document synced over time as new operations are applied to the editor. You can access their current property at any time for the up-to-date path value.

property affinity

affinity: 'forward' | 'backward' | null;

property current

current: Path | null;

method unref

unref: () => Path | null;

interface PathRefInterface

interface PathRefInterface {}

property transform

transform: (ref: PathRef, op: Operation) => void;

Transform the path ref's current value by an operation.

interface PathTransformOptions

interface PathTransformOptions {}

property affinity

affinity?: TextDirection | null;

interface PointInterface

interface PointInterface {}

property compare

compare: (point: Point, another: Point) => -1 | 0 | 1;

Compare a point to another, returning an integer indicating whether the point was before, at, or after the other.

property equals

equals: (point: Point, another: Point) => boolean;

Check if a point is exactly equal to another.

property isAfter

isAfter: (point: Point, another: Point) => boolean;

Check if a point is after another.

property isBefore

isBefore: (point: Point, another: Point) => boolean;

Check if a point is before another.

property isPoint

isPoint: (value: any) => value is Point;

Check if a value implements the Point interface.

property transform

transform: (
    point: Point,
    op: Operation,
    options?: PointTransformOptions
) => Point | null;

Transform a point by an operation.

interface PointRef

interface PointRef {}

PointRef objects keep a specific point in a document synced over time as new operations are applied to the editor. You can access their current property at any time for the up-to-date point value.

property affinity

affinity: TextDirection | null;

property current

current: Point | null;

method unref

unref: () => Point | null;

interface PointRefInterface

interface PointRefInterface {}

property transform

transform: (ref: PointRef, op: Operation) => void;

Transform the point ref's current value by an operation.

interface PointTransformOptions

interface PointTransformOptions {}

property affinity

affinity?: TextDirection | null;

interface RangeEdgesOptions

interface RangeEdgesOptions {}

property reverse

reverse?: boolean;

interface RangeInterface

interface RangeInterface {}

property edges

edges: (range: Range, options?: RangeEdgesOptions) => [Point, Point];

Get the start and end points of a range, in the order in which they appear in the document.

property end

end: (range: Range) => Point;

Get the end point of a range.

property equals

equals: (range: Range, another: Range) => boolean;

Check if a range is exactly equal to another.

property includes

includes: (range: Range, target: Path | Point | Range) => boolean;

Check if a range includes a path, a point or part of another range.

property intersection

intersection: (range: Range, another: Range) => Range | null;

Get the intersection of a range with another.

property isBackward

isBackward: (range: Range) => boolean;

Check if a range is backward, meaning that its anchor point appears in the document _after_ its focus point.

property isCollapsed

isCollapsed: (range: Range) => boolean;

Check if a range is collapsed, meaning that both its anchor and focus points refer to the exact same position in the document.

property isExpanded

isExpanded: (range: Range) => boolean;

Check if a range is expanded.
This is the opposite of [[Range.isCollapsed]] and is provided for legibility.

property isForward

isForward: (range: Range) => boolean;

Check if a range is forward.
This is the opposite of [[Range.isBackward]] and is provided for legibility.

property isRange

isRange: (value: any) => value is Range;

Check if a value implements the [[Range]] interface.

property points

points: (range: Range) => Generator<PointEntry, void, undefined>;

Iterate through all of the point entries in a range.

property start

start: (range: Range) => Point;

Get the start point of a range.

property surrounds

surrounds: (range: Range, target: Range) => boolean;

Check if a range includes another range.

property transform

transform: (
    range: Range,
    op: Operation,
    options?: RangeTransformOptions
) => Range | null;

Transform a range by an operation.

interface RangeRef

interface RangeRef {}

RangeRef objects keep a specific range in a document synced over time as new operations are applied to the editor. You can access their current property at any time for the up-to-date range value.

property affinity

affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;

property current

current: Range | null;

method unref

unref: () => Range | null;

interface RangeRefInterface

interface RangeRefInterface {}

property transform

transform: (ref: RangeRef, op: Operation) => void;

Transform the range ref's current value by an operation.

interface RangeTransformOptions

interface RangeTransformOptions {}

property affinity

affinity?: RangeDirection | null;

interface ScrubberInterface

interface ScrubberInterface {}

method setScrubber

setScrubber: (scrubber: Scrubber | undefined) => void;

method stringify

stringify: (value: any) => string;

interface SpanInterface

interface SpanInterface {}

property isSpan

isSpan: (value: any) => value is Span;

Check if a value implements the Span interface.

interface TextEqualsOptions

interface TextEqualsOptions {}

property loose

loose?: boolean;

interface TextInterface

interface TextInterface {}

property decorations

decorations: (
    node: Text,
    decorations: DecoratedRange[]
) => {
    leaf: Text;
    position?: LeafPosition;
}[];

Get the leaves for a text node given decorations.

property equals

equals: (text: Text, another: Text, options?: TextEqualsOptions) => boolean;

Check if two text nodes are equal.
When loose is set, the text is not compared. This is used to check whether sibling text nodes can be merged.

property isText

isText: (value: any) => value is Text;

Check if a value implements the Text interface.

property isTextList

isTextList: (value: any) => value is Text[];

Check if a value is a list of Text objects.

property isTextProps

isTextProps: (props: any) => props is Partial<Text>;

Check if some props are a partial of Text.

property matches

matches: (text: Text, props: Partial<Text>) => boolean;

Check if an text matches set of properties.
Note: this is for matching custom properties, and it does not ensure that the text property are two nodes equal.

Type Aliases

type Ancestor

type Ancestor = Editor | Element;

The Ancestor union type represents nodes that are ancestors in the tree. It is returned as a convenience in certain cases to narrow a value further than the more generic Node union.

type BaseInsertNodeOperation

type BaseInsertNodeOperation = {
    type: 'insert_node';
    path: Path;
    node: Node;
};

type BaseInsertTextOperation

type BaseInsertTextOperation = {
    type: 'insert_text';
    path: Path;
    offset: number;
    text: string;
};

type BaseMergeNodeOperation

type BaseMergeNodeOperation = {
    type: 'merge_node';
    path: Path;
    position: number;
    properties: Partial<Node>;
};

type BaseMoveNodeOperation

type BaseMoveNodeOperation = {
    type: 'move_node';
    path: Path;
    newPath: Path;
};

type BaseNode

type BaseNode = Editor | Element | Text;

The Node union type represents all of the different types of nodes that occur in a Slate document tree.

type BaseOperation

type BaseOperation = NodeOperation | SelectionOperation | TextOperation;

Operation objects define the low-level instructions that Slate editors use to apply changes to their internal state. Representing all changes as operations is what allows Slate editors to easily implement history, collaboration, and other features.

type BaseRemoveNodeOperation

type BaseRemoveNodeOperation = {
    type: 'remove_node';
    path: Path;
    node: Node;
};

type BaseRemoveTextOperation

type BaseRemoveTextOperation = {
    type: 'remove_text';
    path: Path;
    offset: number;
    text: string;
};

type BaseSelection

type BaseSelection = Range | null;

type BaseSetNodeOperation

type BaseSetNodeOperation = {
    type: 'set_node';
    path: Path;
    properties: Partial<Node>;
    newProperties: Partial<Node>;
};

type BaseSetSelectionOperation

type BaseSetSelectionOperation =
    | {
          type: 'set_selection';
          properties: null;
          newProperties: Range;
      }
    | {
          type: 'set_selection';
          properties: Partial<Range>;
          newProperties: Partial<Range>;
      }
    | {
          type: 'set_selection';
          properties: Range;
          newProperties: null;
      };

type BaseSplitNodeOperation

type BaseSplitNodeOperation = {
    type: 'split_node';
    path: Path;
    position: number;
    properties: Partial<Node>;
};

type DecoratedRange

type DecoratedRange = Range & {
    /**
     * Customize how another decoration is merged into a text node. If not specified, `Object.assign` would be used.
     * It is useful for overlapping decorations with the same key but different values.
     */
    merge?: (leaf: Text, decoration: object) => void;
};

type Descendant

type Descendant = Element | Text;

The Descendant union type represents nodes that are descendants in the tree. It is returned as a convenience in certain cases to narrow a value further than the more generic Node union.

type Editor

type Editor = ExtendedType<'Editor', BaseEditor>;

type EditorMarks

type EditorMarks = Omit<Text, 'text'>;

type Element

type Element = ExtendedType<'Element', BaseElement>;

type ElementEntry

type ElementEntry = [Element, Path];

ElementEntry objects refer to an Element and the Path where it can be found inside a root node.

type ExtendedType

type ExtendedType<K extends ExtendableTypes, B> = unknown extends CustomTypes[K]
    ? B
    : CustomTypes[K];

type InsertNodeOperation

type InsertNodeOperation = ExtendedType<
    'InsertNodeOperation',
    BaseInsertNodeOperation
>;

type InsertTextOperation

type InsertTextOperation = ExtendedType<
    'InsertTextOperation',
    BaseInsertTextOperation
>;

type LeafEdge

type LeafEdge = 'start' | 'end';

type Location

type Location = Path | Point | Range;

The Location interface is a union of the ways to refer to a specific location in a Slate document: paths, points or ranges.
Methods will often accept a Location instead of requiring only a Path, Point or Range. This eliminates the need for developers to manage converting between the different interfaces in their own code base.

type MaximizeMode

type MaximizeMode = RangeMode | 'all';

type MergeNodeOperation

type MergeNodeOperation = ExtendedType<'MergeNodeOperation', BaseMergeNodeOperation>;

type MoveNodeOperation

type MoveNodeOperation = ExtendedType<'MoveNodeOperation', BaseMoveNodeOperation>;

type MoveUnit

type MoveUnit = 'offset' | 'character' | 'word' | 'line';

type Node

type Node = Editor | Element | Text;

type NodeEntry

type NodeEntry<T extends Node = Node> = [T, Path];

NodeEntry objects are returned when iterating over the nodes in a Slate document tree. They consist of the node and its Path relative to the root node in the document.

type NodeMatch

type NodeMatch<T extends Node> =
    | ((node: Node, path: Path) => node is T)
    | ((node: Node, path: Path) => boolean);

A helper type for narrowing matched nodes with a predicate.

type NodeOperation

type NodeOperation =
    | InsertNodeOperation
    | MergeNodeOperation
    | MoveNodeOperation
    | RemoveNodeOperation
    | SetNodeOperation
    | SplitNodeOperation;

type NodeProps

type NodeProps =
    | Omit<Editor, 'children'>
    | Omit<Element, 'children'>
    | Omit<Text, 'text'>;

Convenience type for returning the props of a node.

type Operation

type Operation = ExtendedType<'Operation', BaseOperation>;

type Path

type Path = number[];

Path arrays are a list of indexes that describe a node's exact position in a Slate node tree. Although they are usually relative to the root Editor object, they can be relative to any Node object.

type Point

type Point = ExtendedType<'Point', BasePoint>;

type PointEntry

type PointEntry = [Point, 'anchor' | 'focus'];

PointEntry objects are returned when iterating over Point objects that belong to a range.

type PropsCompare

type PropsCompare = (prop: Partial<Node>, node: Partial<Node>) => boolean;

type PropsMerge

type PropsMerge = (prop: Partial<Node>, node: Partial<Node>) => object;

type Range

type Range = ExtendedType<'Range', BaseRange>;

type RangeDirection

type RangeDirection = TextDirection | 'outward' | 'inward';

type RangeMode

type RangeMode = 'highest' | 'lowest';

type RemoveNodeOperation

type RemoveNodeOperation = ExtendedType<
    'RemoveNodeOperation',
    BaseRemoveNodeOperation
>;

type RemoveTextOperation

type RemoveTextOperation = ExtendedType<
    'RemoveTextOperation',
    BaseRemoveTextOperation
>;

type Scrubber

type Scrubber = (key: string, value: unknown) => unknown;

type Selection

type Selection = ExtendedType<'Selection', BaseSelection>;

type SelectionEdge

type SelectionEdge = 'anchor' | 'focus' | 'start' | 'end';

type SelectionMode

type SelectionMode = 'all' | 'highest' | 'lowest';

type SelectionOperation

type SelectionOperation = SetSelectionOperation;

type SetNodeOperation

type SetNodeOperation = ExtendedType<'SetNodeOperation', BaseSetNodeOperation>;

type SetSelectionOperation

type SetSelectionOperation = ExtendedType<
    'SetSelectionOperation',
    BaseSetSelectionOperation
>;

type Span

type Span = [Path, Path];

The Span interface is a low-level way to refer to locations in nodes without using Point which requires leaf text nodes to be present.

type SplitNodeOperation

type SplitNodeOperation = ExtendedType<'SplitNodeOperation', BaseSplitNodeOperation>;

type Text

type Text = ExtendedType<'Text', BaseText>;

type TextDirection

type TextDirection = 'forward' | 'backward';

type TextOperation

type TextOperation = InsertTextOperation | RemoveTextOperation;

type TextUnit

type TextUnit = 'character' | 'word' | 'line' | 'block';

type TextUnitAdjustment

type TextUnitAdjustment = TextUnit | 'offset';

Package Files (97)

Dependencies (2)

Dev Dependencies (4)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/slate.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/slate)

HTML

<a href="https://www.jsdocs.io/package/slate"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 days ago.
Package analyzed in 8889 ms.
Missing or incorrect documentation? Open an issue for this package.