@types/slate

Version 0.47.16
Published 18 days ago
120 kB
2 dependencies
MIT license

Install

npm i @types/slate

yarn add @types/slate

pnpm add @types/slate

Overview

TypeScript definitions for slate

Index

Classes

class AddAnnotationOperation

class AddAnnotationOperation extends BaseOperation {}

property annotation

annotation: Annotation;

property data

data: Data;

property type

type: string;

class AddMarkOperation

class AddMarkOperation extends BaseOperation {}

property data

data: Data;

property mark

mark: Mark;

property path

path: Immutable.List<number>;

property type

type: string;

class Annotation

class Annotation extends BaseRange {}

property anchor

anchor: Point;

property data

data: Data;

property focus

focus: Point;

property key

key: string;

property object

object: string;

property type

type: string;

method create

static create: (
    properties: Annotation | AnnotationProperties | AnnotationJSON
) => Annotation;

method createMap

static createMap: (elements?: any) => Immutable.Map<string, Annotation>;

method createProperties

static createProperties: (
    attrs: AnnotationProperties | AnnotationJSON | Annotation
) => AnnotationProperties;

method fromJS

static fromJS: (properties: AnnotationProperties | AnnotationJSON) => Annotation;

method fromJSON

static fromJSON: (
    properties: AnnotationProperties | AnnotationJSON
) => Annotation;

method isAnnotation

static isAnnotation: (maybeAnnotation: any) => maybeAnnotation is Annotation;

method setProperties

setProperties: (
    properties: AnnotationProperties | AnnotationJSON | Annotation
) => Annotation;

method toJS

toJS: () => AnnotationJSON;

method toJSON

toJSON: () => AnnotationJSON;

class BaseOperation

class BaseOperation extends Immutable.Record({}) {}

property object

object: string;

property type

type: string;

method apply

apply: (value: Value) => Value;

method create

static create: (
    attrs?: Operation | OperationProperties | OperationJSON
) => Operation;

method createList

static createList: () =>
    | Immutable.List<Operation | OperationProperties | OperationJSON>
    | Array<Operation | OperationProperties | OperationJSON>;

method fromJS

static fromJS: (object: OperationProperties | OperationJSON) => Operation;

method fromJSON

static fromJSON: (object: OperationProperties | OperationJSON) => Operation;

method invert

invert: () => this;

method isOperation

static isOperation: (maybeOperation: any) => maybeOperation is Operation;

method isOperationList

static isOperationList: (
    maybeOperationList: any
) => maybeOperationList is Immutable.List<Operation>;

method toJSON

toJSON: () => OperationJSON;

class Block

class Block extends BaseNode {}

property nodes

nodes: Immutable.List<Block | Inline | Text>;

property object

object: string;

method create

static create: (
    properties: BlockProperties | BlockJSON | Block | string
) => Block;

method createList

static createList: (
    array?:
        | Array<BlockProperties | BlockJSON | Block | string>
        | Immutable.List<BlockProperties | BlockJSON | Block | string>
) => Immutable.List<Block>;

method fromJS

static fromJS: (properties: BlockJSON | BlockProperties | Block) => Block;

method fromJSON

static fromJSON: (properties: BlockJSON | BlockProperties | Block) => Block;

method isBlock

static isBlock: (maybeBlock: any) => maybeBlock is Block;

method isBlockList

static isBlockList: (
    maybeBlockList: any
) => maybeBlockList is Immutable.List<Block>;

method toJS

toJS: () => BlockJSON;

method toJSON

toJSON: () => BlockJSON;

class Decoration

class Decoration extends BaseRange {}

property anchor

anchor: Point;

property data

data: Data;

property focus

focus: Point;

property object

object: string;

property type

type: string;

method create

static create: (
    properties: RangeTypeProperties | RangeTypeJSON | RangeType
) => Decoration;

method createList

static createList: (
    elements?:
        | Array<RangeTypeProperties | RangeTypeJSON | RangeType>
        | Immutable.List<RangeTypeProperties | RangeTypeJSON | RangeType>
) => Immutable.List<Decoration>;

method createProperties

static createProperties: (
    attrs: RangeTypeProperties | RangeTypeJSON | RangeType
) => DecorationProperties;

method fromJSON

static fromJSON: {
    (properties: DecorationJSON & { mark?: MarkJSON | undefined }): Decoration;
    (properties: DecorationJSON & { mark?: MarkJSON }): Decoration;
};

method isDecoration

static isDecoration: (maybeDecoration: any) => maybeDecoration is Decoration;

method setProperties

setProperties: (
    properties: RangeTypeProperties | RangeTypeJSON | RangeType
) => Decoration;

method toJS

toJS: () => DecorationJSON;

method toJSON

toJSON: () => DecorationJSON;

class Document

class Document extends BaseNode {}

property object

object: string;

method create

static create: (
    properties:
        | DocumentProperties
        | DocumentJSON
        | Document
        | Array<NodeJSON | NodeProperties | Node>
        | Immutable.List<NodeJSON | NodeProperties | Node>
) => Document;

method fromJS

static fromJS: (
    properties: DocumentJSON | DocumentProperties | Document
) => Document;

method fromJSON

static fromJSON: (
    properties: DocumentJSON | DocumentProperties | Document
) => Document;

method isDocument

static isDocument: (maybeDocument: any) => maybeDocument is Document;

method toJS

toJS: () => DocumentJSON;

method toJSON

toJSON: () => DocumentJSON;

class Editor

class Editor implements Controller {}

constructor

constructor(attributes: EditorProperties<Editor>, options?: EditorOptions);

property controller

controller: Controller;

property middleware

middleware: {};

property object

object: string;

property onChange

onChange: (change: {
    operations: Immutable.List<Operation>;
    value: Value;
}) => void;

property operations

operations: Immutable.List<Operation>;

property plugins

plugins: Plugin<Editor>[];

property readOnly

readOnly: boolean;

property value

value: Value;

method addAnnotation

addAnnotation: (
    annotation: AnnotationProperties | AnnotationJSON | Annotation
) => Editor;

method addMark

addMark: (mark: string | MarkProperties | MarkJSON | Mark) => Editor;

method addMarkAtRange

addMarkAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    mark: string | MarkProperties | Mark
) => Editor;

method addMarkByKey

addMarkByKey: (
    key: string,
    offset: number,
    length: number,
    mark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method addMarkByPath

addMarkByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number,
    mark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method addMarks

addMarks: (
    mark:
        | Set<string | MarkProperties | MarkJSON | Mark>
        | Array<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method addMarksAtRange

addMarksAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    marks:
        | Array<string | MarkProperties | MarkJSON | Mark>
        | Immutable.Set<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method addMarksByPath

addMarksByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number,
    marks:
        | Array<string | MarkProperties | MarkJSON | Mark>
        | Immutable.Set<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method applyOperation

applyOperation: (
    operation: Operation | OperationJSON | OperationProperties
) => Editor;

method blur

blur: () => Editor;

method command

command: (type: string | ((...args: any[]) => any), ...args: any[]) => Editor;

method delete

delete: () => Editor;

method deleteAtRange

deleteAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deleteBackward

deleteBackward: (n?: number) => Editor;

method deleteBackwardAtRange

deleteBackwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    n?: number
) => Editor;

method deleteCharBackward

deleteCharBackward: () => Editor;

method deleteCharBackwardAtRange

deleteCharBackwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deleteCharForward

deleteCharForward: () => Editor;

method deleteCharForwardAtRange

deleteCharForwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deleteForward

deleteForward: (n?: number) => Editor;

method deleteForwardAtRange

deleteForwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    n?: number
) => Editor;

method deleteLineBackward

deleteLineBackward: () => Editor;

method deleteLineBackwardAtRange

deleteLineBackwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deleteLineForward

deleteLineForward: () => Editor;

method deleteLineForwardAtRange

deleteLineForwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deleteWordBackward

deleteWordBackward: () => Editor;

method deleteWordBackwardAtRange

deleteWordBackwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deleteWordForward

deleteWordForward: () => Editor;

method deleteWordForwardAtRange

deleteWordForwardAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType
) => Editor;

method deselect

deselect: () => Editor;

method flip

flip: () => Editor;

method flush

flush: () => Editor;

Synchronously flush the current changes to editor, calling onChange. In normal operation you never need to use this method! Reserved for testing.

method focus

focus: () => Editor;

method hasCommand

hasCommand: (type: string) => boolean;

method hasQuery

hasQuery: (type: string) => boolean;

method insertBlock

insertBlock: (block: string | Block | BlockProperties | BlockJSON) => Editor;

method insertBlockAtRange

insertBlockAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    block: string | Block | BlockProperties | BlockJSON
) => Editor;

method insertFragment

insertFragment: (fragment: Document) => Editor;

method insertFragmentAtRange

insertFragmentAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    fragment: Document
) => Editor;

method insertFragmentByKey

insertFragmentByKey: (key: string, index: number, fragment: Document) => Editor;

method insertFragmentByPath

insertFragmentByPath: (
    path: Immutable.List<number>,
    index: number,
    fragment: Document
) => Editor;

method insertInline

insertInline: (
    inline: string | Inline | InlineProperties | InlineJSON
) => Editor;

method insertInlineAtRange

insertInlineAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    inline: Inline | InlineProperties | InlineJSON
) => Editor;

method insertNodeByKey

insertNodeByKey: (
    key: string,
    index: number,
    node: Block | Document | Inline | Text
) => Editor;

method insertNodeByPath

insertNodeByPath: (
    path: Immutable.List<number>,
    index: number,
    node: Block | Document | Inline | Text
) => Editor;

method insertText

insertText: (
    text: string,
    marks?:
        | Immutable.Set<string | MarkProperties | MarkJSON | Mark>
        | Array<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method insertTextAtRange

insertTextAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    text: string
) => Editor;

method insertTextByKey

insertTextByKey: (
    key: string,
    offset: number,
    text: string,
    marks?:
        | Array<string | MarkProperties | MarkJSON | Mark>
        | Immutable.Set<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method insertTextByPath

insertTextByPath: (
    path: Immutable.List<number>,
    offset: number,
    text: string,
    marks?:
        | Array<string | MarkProperties | MarkJSON | Mark>
        | Immutable.Set<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method isEditor

isEditor: (maybeEditor: any) => maybeEditor is Editor;

method mergeNodeByKey

mergeNodeByKey: (key: string) => Editor;

method mergeNodeByPath

mergeNodeByPath: (path: Immutable.List<number>) => Editor;

method moveAnchorBackward

moveAnchorBackward: (n?: number) => Editor;

method moveAnchorForward

moveAnchorForward: (n?: number) => Editor;

method moveAnchorTo

moveAnchorTo: (
    path: string | number | Immutable.List<number>,
    offset?: number
) => Editor;

method moveAnchorToEndOfBlock

moveAnchorToEndOfBlock: () => Editor;

method moveAnchorToEndOfDocument

moveAnchorToEndOfDocument: () => Editor;

method moveAnchorToEndOfInline

moveAnchorToEndOfInline: () => Editor;

method moveAnchorToEndOfNextBlock

moveAnchorToEndOfNextBlock: () => Editor;

method moveAnchorToEndOfNextInline

moveAnchorToEndOfNextInline: () => Editor;

method moveAnchorToEndOfNextText

moveAnchorToEndOfNextText: () => Editor;

method moveAnchorToEndOfNode

moveAnchorToEndOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveAnchorToEndOfPreviousBlock

moveAnchorToEndOfPreviousBlock: () => Editor;

method moveAnchorToEndOfPreviousInline

moveAnchorToEndOfPreviousInline: () => Editor;

method moveAnchorToEndOfPreviousText

moveAnchorToEndOfPreviousText: () => Editor;

method moveAnchorToEndOfText

moveAnchorToEndOfText: () => Editor;

method moveAnchorToStartOfBlock

moveAnchorToStartOfBlock: () => Editor;

method moveAnchorToStartOfDocument

moveAnchorToStartOfDocument: () => Editor;

method moveAnchorToStartOfInline

moveAnchorToStartOfInline: () => Editor;

method moveAnchorToStartOfNextBlock

moveAnchorToStartOfNextBlock: () => Editor;

method moveAnchorToStartOfNextInline

moveAnchorToStartOfNextInline: () => Editor;

method moveAnchorToStartOfNextText

moveAnchorToStartOfNextText: () => Editor;

method moveAnchorToStartOfNode

moveAnchorToStartOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveAnchorToStartOfPreviousBlock

moveAnchorToStartOfPreviousBlock: () => Editor;

method moveAnchorToStartOfPreviousInline

moveAnchorToStartOfPreviousInline: () => Editor;

method moveAnchorToStartOfPreviousText

moveAnchorToStartOfPreviousText: () => Editor;

method moveAnchorToStartOfText

moveAnchorToStartOfText: () => Editor;

method moveAnchorWordBackward

moveAnchorWordBackward: () => Editor;

method moveAnchorWordForward

moveAnchorWordForward: () => Editor;

method moveBackward

moveBackward: (n?: number) => Editor;

method moveEndBackward

moveEndBackward: (n?: number) => Editor;

method moveEndForward

moveEndForward: (n?: number) => Editor;

method moveEndTo

moveEndTo: (
    path: string | number | Immutable.List<number>,
    offset?: number
) => Editor;

method moveEndToEndOfBlock

moveEndToEndOfBlock: () => Editor;

method moveEndToEndOfDocument

moveEndToEndOfDocument: () => Editor;

method moveEndToEndOfInline

moveEndToEndOfInline: () => Editor;

method moveEndToEndOfNextBlock

moveEndToEndOfNextBlock: () => Editor;

method moveEndToEndOfNextInline

moveEndToEndOfNextInline: () => Editor;

method moveEndToEndOfNextText

moveEndToEndOfNextText: () => Editor;

method moveEndToEndOfNode

moveEndToEndOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveEndToEndOfPreviousBlock

moveEndToEndOfPreviousBlock: () => Editor;

method moveEndToEndOfPreviousInline

moveEndToEndOfPreviousInline: () => Editor;

method moveEndToEndOfPreviousText

moveEndToEndOfPreviousText: () => Editor;

method moveEndToEndOfText

moveEndToEndOfText: () => Editor;

method moveEndToStartOfBlock

moveEndToStartOfBlock: () => Editor;

method moveEndToStartOfDocument

moveEndToStartOfDocument: () => Editor;

method moveEndToStartOfInline

moveEndToStartOfInline: () => Editor;

method moveEndToStartOfNextBlock

moveEndToStartOfNextBlock: () => Editor;

method moveEndToStartOfNextInline

moveEndToStartOfNextInline: () => Editor;

method moveEndToStartOfNextText

moveEndToStartOfNextText: () => Editor;

method moveEndToStartOfNode

moveEndToStartOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveEndToStartOfPreviousBlock

moveEndToStartOfPreviousBlock: () => Editor;

method moveEndToStartOfPreviousInline

moveEndToStartOfPreviousInline: () => Editor;

method moveEndToStartOfPreviousText

moveEndToStartOfPreviousText: () => Editor;

method moveEndToStartOfText

moveEndToStartOfText: () => Editor;

method moveEndWordBackward

moveEndWordBackward: () => Editor;

method moveEndWordForward

moveEndWordForward: () => Editor;

method moveFocusBackward

moveFocusBackward: (n?: number) => Editor;

method moveFocusForward

moveFocusForward: (n?: number) => Editor;

method moveFocusTo

moveFocusTo: (
    path: string | number | Immutable.List<number>,
    offset?: number
) => Editor;

method moveFocusToEndOfBlock

moveFocusToEndOfBlock: () => Editor;

method moveFocusToEndOfDocument

moveFocusToEndOfDocument: () => Editor;

method moveFocusToEndOfInline

moveFocusToEndOfInline: () => Editor;

method moveFocusToEndOfNextBlock

moveFocusToEndOfNextBlock: () => Editor;

method moveFocusToEndOfNextInline

moveFocusToEndOfNextInline: () => Editor;

method moveFocusToEndOfNextText

moveFocusToEndOfNextText: () => Editor;

method moveFocusToEndOfNode

moveFocusToEndOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveFocusToEndOfPreviousBlock

moveFocusToEndOfPreviousBlock: () => Editor;

method moveFocusToEndOfPreviousInline

moveFocusToEndOfPreviousInline: () => Editor;

method moveFocusToEndOfPreviousText

moveFocusToEndOfPreviousText: () => Editor;

method moveFocusToEndOfText

moveFocusToEndOfText: () => Editor;

method moveFocusToStartOfBlock

moveFocusToStartOfBlock: () => Editor;

method moveFocusToStartOfDocument

moveFocusToStartOfDocument: () => Editor;

method moveFocusToStartOfInline

moveFocusToStartOfInline: () => Editor;

method moveFocusToStartOfNextBlock

moveFocusToStartOfNextBlock: () => Editor;

method moveFocusToStartOfNextInline

moveFocusToStartOfNextInline: () => Editor;

method moveFocusToStartOfNextText

moveFocusToStartOfNextText: () => Editor;

method moveFocusToStartOfNode

moveFocusToStartOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveFocusToStartOfPreviousBlock

moveFocusToStartOfPreviousBlock: () => Editor;

method moveFocusToStartOfPreviousInline

moveFocusToStartOfPreviousInline: () => Editor;

method moveFocusToStartOfPreviousText

moveFocusToStartOfPreviousText: () => Editor;

method moveFocusToStartOfText

moveFocusToStartOfText: () => Editor;

method moveFocusWordBackward

moveFocusWordBackward: () => Editor;

method moveFocusWordForward

moveFocusWordForward: () => Editor;

method moveForward

moveForward: (n?: number) => Editor;

method moveNodeByKey

moveNodeByKey: (key: string, newKey: string, newIndex: number) => Editor;

method moveNodeByPath

moveNodeByPath: (
    path: Immutable.List<number>,
    newPath: Immutable.List<number>,
    newIndex: number
) => Editor;

method moveStartBackward

moveStartBackward: (n?: number) => Editor;

method moveStartForward

moveStartForward: (n?: number) => Editor;

method moveStartTo

moveStartTo: (
    path: string | number | Immutable.List<number>,
    n?: number
) => Editor;

method moveStartToEndOfBlock

moveStartToEndOfBlock: () => Editor;

method moveStartToEndOfDocument

moveStartToEndOfDocument: () => Editor;

method moveStartToEndOfInline

moveStartToEndOfInline: () => Editor;

method moveStartToEndOfNextBlock

moveStartToEndOfNextBlock: () => Editor;

method moveStartToEndOfNextInline

moveStartToEndOfNextInline: () => Editor;

method moveStartToEndOfNextText

moveStartToEndOfNextText: () => Editor;

method moveStartToEndOfNode

moveStartToEndOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveStartToEndOfPreviousBlock

moveStartToEndOfPreviousBlock: () => Editor;

method moveStartToEndOfPreviousInline

moveStartToEndOfPreviousInline: () => Editor;

method moveStartToEndOfPreviousText

moveStartToEndOfPreviousText: () => Editor;

method moveStartToEndOfText

moveStartToEndOfText: () => Editor;

method moveStartToStartOfBlock

moveStartToStartOfBlock: () => Editor;

method moveStartToStartOfDocument

moveStartToStartOfDocument: () => Editor;

method moveStartToStartOfInline

moveStartToStartOfInline: () => Editor;

method moveStartToStartOfNextBlock

moveStartToStartOfNextBlock: () => Editor;

method moveStartToStartOfNextInline

moveStartToStartOfNextInline: () => Editor;

method moveStartToStartOfNextText

moveStartToStartOfNextText: () => Editor;

method moveStartToStartOfNode

moveStartToStartOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveStartToStartOfPreviousBlock

moveStartToStartOfPreviousBlock: () => Editor;

method moveStartToStartOfPreviousInline

moveStartToStartOfPreviousInline: () => Editor;

method moveStartToStartOfPreviousText

moveStartToStartOfPreviousText: () => Editor;

method moveStartToStartOfText

moveStartToStartOfText: () => Editor;

method moveStartWordBackward

moveStartWordBackward: () => Editor;

method moveStartWordForward

moveStartWordForward: () => Editor;

method moveTo

moveTo: (
    path: string | number | Immutable.List<number>,
    offset?: number
) => Editor;

method moveToAnchor

moveToAnchor: () => Editor;

method moveToEnd

moveToEnd: () => Editor;

method moveToEndOfBlock

moveToEndOfBlock: () => Editor;

method moveToEndOfDocument

moveToEndOfDocument: () => Editor;

method moveToEndOfInline

moveToEndOfInline: () => Editor;

method moveToEndOfNextBlock

moveToEndOfNextBlock: () => Editor;

method moveToEndOfNextInline

moveToEndOfNextInline: () => Editor;

method moveToEndOfNextText

moveToEndOfNextText: () => Editor;

method moveToEndOfNode

moveToEndOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveToEndOfPreviousBlock

moveToEndOfPreviousBlock: () => Editor;

method moveToEndOfPreviousInline

moveToEndOfPreviousInline: () => Editor;

method moveToEndOfPreviousText

moveToEndOfPreviousText: () => Editor;

method moveToEndOfText

moveToEndOfText: () => Editor;

method moveToFocus

moveToFocus: () => Editor;

method moveToRangeOfDocument

moveToRangeOfDocument: () => Editor;

method moveToRangeOfNode

moveToRangeOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveToStart

moveToStart: () => Editor;

method moveToStartOfBlock

moveToStartOfBlock: () => Editor;

method moveToStartOfDocument

moveToStartOfDocument: () => Editor;

method moveToStartOfInline

moveToStartOfInline: () => Editor;

method moveToStartOfNextBlock

moveToStartOfNextBlock: () => Editor;

method moveToStartOfNextInline

moveToStartOfNextInline: () => Editor;

method moveToStartOfNextText

moveToStartOfNextText: () => Editor;

method moveToStartOfNode

moveToStartOfNode: (node: Block | Document | Inline | Text) => Editor;

method moveToStartOfPreviousBlock

moveToStartOfPreviousBlock: () => Editor;

method moveToStartOfPreviousInline

moveToStartOfPreviousInline: () => Editor;

method moveToStartOfPreviousText

moveToStartOfPreviousText: () => Editor;

method moveToStartOfText

moveToStartOfText: () => Editor;

method moveWordBackward

moveWordBackward: () => Editor;

method moveWordForward

moveWordForward: () => Editor;

method normalize

normalize: () => Editor;

method query

query: (query: string | ((...args: any[]) => any), ...args: any[]) => any;

method redo

redo: () => Editor;

method registerCommand

registerCommand: (command: string) => Editor;

method registerQuery

registerQuery: (query: string) => Editor;

method removeAllMarksByKey

removeAllMarksByKey: (key: string) => Editor;

method removeAllMarksByPath

removeAllMarksByPath: (path: Immutable.List<number>) => Editor;

method removeAnnotation

removeAnnotation: (
    annotation: AnnotationProperties | AnnotationJSON | Annotation
) => Editor;

method removeMark

removeMark: (mark: string | MarkProperties | MarkJSON | Mark) => Editor;

method removeMarkAtRange

removeMarkAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    mark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method removeMarkByKey

removeMarkByKey: (
    key: string,
    offset: number,
    length: number,
    mark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method removeMarkByPath

removeMarkByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number,
    mark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method removeMarksByPath

removeMarksByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number,
    marks:
        | Array<string | MarkProperties | MarkJSON | Mark>
        | Immutable.Set<string | MarkProperties | MarkJSON | Mark>
) => Editor;

method removeNodeByKey

removeNodeByKey: (key: string) => Editor;

method removeNodeByPath

removeNodeByPath: (path: Immutable.List<number>) => Editor;

method removeTextByKey

removeTextByKey: (key: string, offset: number, length: number) => Editor;

method removeTextByPath

removeTextByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number
) => Editor;

method replaceMark

replaceMark: (
    mark: string | MarkProperties | MarkJSON | Mark,
    newMark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method replaceNodeByKey

replaceNodeByKey: (
    key: string,
    node: Block | Document | Inline | Text
) => Editor;

method replaceNodeByPath

replaceNodeByPath: (
    path: Immutable.List<number>,
    newNode: Block | Document | Inline | Text
) => Editor;

method replaceTextByKey

replaceTextByKey: (
    key: string,
    node: Block | Document | Inline | Text
) => Editor;

method replaceTextByPath

replaceTextByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number,
    text: string,
    marks?: Immutable.Set<Mark> | Mark[]
) => Editor;

method run

run: (key: string, ...args: any[]) => Editor;

method save

save: (operation: Operation) => void;

method select

select: (
    properties: string | RangeTypeProperties | RangeTypeJSON | RangeType,
    options?: { snapshot?: boolean | undefined }
) => Editor;

method setAnchor

setAnchor: (point: Point) => void;

method setAnnotation

setAnnotation: (
    annotation: Annotation,
    newProperties: AnnotationProperties | AnnotationJSON | Annotation
) => Editor;

method setBlocks

setBlocks: (properties: string | Block | BlockProperties | BlockJSON) => Editor;

method setBlocksAtRange

setBlocksAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    properties: string | Block | BlockProperties | BlockJSON
) => Editor;

method setData

setData: (data: Data) => Editor;

method setEnd

setEnd: (point: Point) => void;

method setFocus

setFocus: (point: Point) => void;

method setInlines

setInlines: (properties: string | Inline | InlineProperties) => Editor;

method setInlinesAtRange

setInlinesAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    properties: string | Inline | InlineProperties | InlineJSON
) => Editor;

method setMarkByKey

setMarkByKey: (
    key: string,
    offset: number,
    length: number,
    properties: string | MarkProperties | MarkJSON | Mark,
    newProperties:
        | string
        | Partial<MarkProperties>
        | Partial<MarkJSON>
        | Partial<Mark>
) => Editor;

method setMarkByPath

setMarkByPath: (
    path: Immutable.List<number>,
    offset: number,
    length: number,
    properties: string | MarkProperties | MarkJSON | Mark,
    newProperties:
        | string
        | Partial<MarkProperties>
        | Partial<MarkJSON>
        | Partial<Mark>
) => Editor;

method setNodeByKey

setNodeByKey: (
    key: string,
    properties: string | Partial<BlockProperties> | Partial<InlineProperties>
) => Editor;

method setNodeByPath

setNodeByPath: (
    path: Immutable.List<number>,
    newProperties: string | NodeProperties
) => Editor;

method setReadOnly

setReadOnly: (readOnly: boolean) => Editor;

method setStart

setStart: (point: Point) => void;

method setTextByKey

setTextByKey: (key: string, text: string, marks: Immutable.Set<Mark>) => Editor;

method setTextByPath

setTextByPath: (
    path: Immutable.List<number>,
    text: string,
    marks: Immutable.Set<Mark>
) => Editor;

method setValue

setValue: (value: Value, options?: { normalize: boolean }) => Editor;

Set the editor's value state. You can optionally provide a normalize option to either for the editor to completely re-normalize the new value based on its schema or not. By default, the editor will re-normalize only if the value is not equal to its previously seen value (which it knows was normalized).

method snapshotSelection

snapshotSelection: () => Editor;

method splitBlock

splitBlock: (depth?: number) => Editor;

method splitBlockAtRange

splitBlockAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    height?: number
) => Editor;

method splitDescendantsByKey

splitDescendantsByKey: (
    key: string,
    textKey: string,
    textOffset: number
) => Editor;

method splitDescendantsByPath

splitDescendantsByPath: (
    path: Immutable.List<number>,
    textPath: Immutable.List<number>,
    textOffset: number
) => Editor;

method splitInline

splitInline: (depth: number) => Editor;

method splitInlineAtRange

splitInlineAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    height?: number
) => Editor;

method splitNodeByKey

splitNodeByKey: (key: string, offset: number) => Editor;

method splitNodeByPath

splitNodeByPath: (
    path: Immutable.List<number>,
    position: number,
    options?: { target?: number | undefined }
) => Editor;

method toggleMark

toggleMark: (mark: string | MarkProperties | MarkJSON | Mark) => Editor;

method toggleMarkAtRange

toggleMarkAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    mark: string | MarkProperties | MarkJSON | Mark
) => Editor;

method undo

undo: () => Editor;

method unwrapBlock

unwrapBlock: (
    properties: string | Block | BlockProperties | BlockJSON
) => Editor;

method unwrapBlockAtRange

unwrapBlockAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    properties: string | Block | BlockProperties | BlockJSON
) => Editor;

method unwrapBlockByKey

unwrapBlockByKey: (key: string, properties: string | BlockProperties) => Editor;

method unwrapBlockByPath

unwrapBlockByPath: (path: Path, properties: string | BlockProperties) => Editor;

method unwrapChildrenByKey

unwrapChildrenByKey: (key: string) => Editor;

method unwrapChildrenByPath

unwrapChildrenByPath: (path: Immutable.List<number> | number[]) => Editor;

method unwrapInline

unwrapInline: (
    properties: string | Inline | InlineProperties | InlineJSON
) => Editor;

method unwrapInlineAtRange

unwrapInlineAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    properties: string | Inline | InlineProperties | InlineJSON
) => Editor;

method unwrapInlineByKey

unwrapInlineByKey: (
    key: string,
    properties: string | InlineProperties
) => Editor;

method unwrapInlineByPath

unwrapInlineByPath: (
    path: Path,
    properties: string | InlineProperties
) => Editor;

method unwrapNodeByKey

unwrapNodeByKey: (key: string) => Editor;

method unwrapNodeByPath

unwrapNodeByPath: (path: Immutable.List<number>) => Editor;

method withoutMerging

withoutMerging: (fn: () => void) => Editor;

method withoutNormalizing

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

method withoutSaving

withoutSaving: (fn: () => void) => Editor;

method wrapBlock

wrapBlock: (properties: string | Block | BlockProperties | BlockJSON) => Editor;

method wrapBlockAtRange

wrapBlockAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    properties: string | Block | BlockProperties | BlockJSON
) => Editor;

method wrapBlockByKey

wrapBlockByKey: (key: string, properties: string | BlockProperties) => Editor;

method wrapBlockByPath

wrapBlockByPath: (path: Immutable.List<number>, block: string | Block) => Editor;

method wrapInline

wrapInline: (
    properties: string | Inline | InlineProperties | InlineJSON
) => Editor;

method wrapInlineAtRange

wrapInlineAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    properties: string | Inline | InlineProperties | InlineJSON
) => Editor;

method wrapInlineByKey

wrapInlineByKey: (key: string, properties: string | InlineProperties) => Editor;

method wrapInlineByPath

wrapInlineByPath: (path: Path, properties: string | InlineProperties) => Editor;

method wrapNodeByKey

wrapNodeByKey: (key: string, parent: Block | Document | Inline | Text) => Editor;

method wrapNodeByPath

wrapNodeByPath: (
    path: Immutable.List<number>,
    parent: Block | Document | Inline | Text
) => Editor;

method wrapText

wrapText: (prefix: string, suffix?: string) => Editor;

method wrapTextAtRange

wrapTextAtRange: (
    range: RangeTypeProperties | RangeTypeJSON | RangeType,
    prefix: string,
    suffix?: string
) => Editor;

class Inline

class Inline extends BaseNode {}

property nodes

nodes: Immutable.List<Inline | Text>;

property object

object: string;

method create

static create: (
    properties: InlineProperties | InlineJSON | Inline | string
) => Inline;

method createList

static createList: (
    elements?:
        | Immutable.List<InlineProperties | InlineJSON | Inline | string>
        | Array<InlineProperties | InlineJSON | Inline | string>
) => Immutable.List<Inline>;

method fromJS

static fromJS: (properties: InlineProperties | InlineJSON | Inline) => Inline;

method fromJSON

static fromJSON: (properties: InlineProperties | InlineJSON | Inline) => Inline;

method isInline

static isInline: (maybeInline: any) => maybeInline is Inline;

method isInlineList

static isInlineList: (
    maybeInlineList: any
) => maybeInlineList is Immutable.List<Inline>;

method toJS

toJS: () => InlineJSON;

method toJSON

toJSON: () => InlineJSON;

class InsertNodeOperation

class InsertNodeOperation extends BaseOperation {}

property data

data: Data;

property node

node: Node;

property path

path: Immutable.List<number>;

property type

type: string;

class InsertTextOperation

class InsertTextOperation extends BaseOperation {}

property data

data: Data;

property offset

offset: number;

property path

path: Immutable.List<number>;

property text

text: string;

property type

type: string;

class Leaf

class Leaf extends Immutable.Record({}) {}

property marks

marks: any;

property object

object: string;

property text

text: string;

method addMark

addMark: (mark: Mark) => Leaf;

method addMarks

addMarks: (marks: Immutable.Set<Mark>) => Leaf;

method create

static create: (properties: LeafProperties | LeafJSON | Leaf) => Leaf;

method createLeaves

static createLeaves: (leaves: Immutable.List<Leaf>) => Immutable.List<Leaf>;

method createList

static createList: (
    attrs?:
        | Array<LeafProperties | LeafJSON | Leaf>
        | Immutable.List<LeafProperties | LeafJSON | Leaf>
) => Immutable.List<Leaf>;

method fromJS

static fromJS: (properties: LeafJSON | LeafProperties) => Leaf;

method fromJSON

static fromJSON: (properties: LeafJSON | LeafProperties) => Leaf;

method insertText

insertText: (offset: number, string: string) => Leaf;

method isLeaf

static isLeaf: (maybeLeaf: any) => maybeLeaf is Leaf;

method isLeafList

static isLeafList: (maybeLeafList: any) => maybeLeafList is Immutable.List<Leaf>;

method removeMark

removeMark: (mark: Mark) => Leaf;

method splitLeaves

static splitLeaves: (
    leaves: Immutable.List<Leaf>,
    offset: number
) => Array<Immutable.List<Leaf>>;

method toJS

toJS: () => LeafJSON;

method toJSON

toJSON: () => LeafJSON;

method updateMark

updateMark: (mark: Mark, newMark: Mark) => Leaf;

class Mark

class Mark extends Immutable.Record({}) {}

property data

data: Data;

property object

object: string;

property type

type: string;

method create

static create: (properties: MarkProperties | MarkJSON | Mark | string) => Mark;

method createProperties

static createProperties: (
    attrs: Partial<MarkProperties | MarkJSON | Mark | string>
) => MarkProperties;

method createSet

static createSet: (
    element?:
        | Array<MarkProperties | MarkJSON | Mark | string>
        | Immutable.Set<MarkProperties | MarkJSON | Mark | string>
) => Immutable.Set<Mark>;

method fromJS

static fromJS: (properties: MarkProperties | MarkJSON | Mark) => Mark;

method fromJSON

static fromJSON: (properties: MarkProperties | MarkJSON | Mark) => Mark;

method isMark

static isMark: (maybeMark: any) => maybeMark is Mark;

method isMarkSet

static isMarkSet: (maybeMarkSet: any) => maybeMarkSet is Immutable.Set<Mark>;

method toJS

toJS: () => MarkJSON;

method toJSON

toJSON: () => MarkJSON;

class MergeNodeOperation

class MergeNodeOperation extends BaseOperation {}

property data

data: Data;

property path

path: Immutable.List<number>;

property position

position: number;

property properties

properties: NodeProperties;

property type

type: string;

class MoveNodeOperation

class MoveNodeOperation extends BaseOperation {}

property data

data: Data;

property newPath

newPath: Immutable.List<number>;

property path

path: Immutable.List<number>;

property type

type: string;

class Point

class Point extends Immutable.Record({}) {}

property isSet

readonly isSet: boolean;

property isUnset

readonly isUnset: boolean;

property key

key: string;

property object

object: string;

property offset

offset: number;

property path

path: Immutable.List<number>;

method create

static create: (properties: PointProperties | PointJSON | Point) => Point;

method createProperties

static createProperties: (
    properties: PointProperties | PointJSON | Point
) => Point;

method fromJS

static fromJS: (properties: PointJSON | PointProperties) => Point;

method fromJSON

static fromJSON: (properties: PointJSON | PointProperties) => Point;

method isAfterPoint

isAfterPoint: (point: Point) => boolean;

method isAfterRange

isAfterRange: (range: RangeType) => boolean;

method isAtEndOfNode

isAtEndOfNode: (node: Node) => boolean;

method isAtEndofRange

isAtEndofRange: (range: RangeType) => boolean;

method isAtStartOfNode

isAtStartOfNode: (node: Node) => boolean;

method isAtStartOfRange

isAtStartOfRange: (range: RangeType) => boolean;

method isBeforePoint

isBeforePoint: (point: Point) => boolean;

method isBeforeRange

isBeforeRange: (range: RangeType) => boolean;

method isInNode

isInNode: (node: Node) => boolean;

method isInRange

isInRange: (range: RangeType) => boolean;

method isPoint

static isPoint: (maybePoint: any) => maybePoint is Point;

method moveBackward

moveBackward: (n?: number) => this;

method moveForward

moveForward: (n?: number) => this;

method moveTo

moveTo: (
    path: string | number | Immutable.List<number>,
    offset?: number
) => this;

method moveToEndOfNode

moveToEndOfNode: (node: Node) => this;

method moveToStartOfNode

moveToStartOfNode: (node: Node) => this;

method normalize

normalize: (node: Node) => this;

method setKey

setKey: (key: string) => this;

method setOffset

setOffset: (offset: number) => this;

method setPath

setPath: (path: Immutable.List<number> | number[]) => this;

method toJS

toJS: (options?: { preserveKeys?: boolean | undefined }) => PointJSON;

method toJSON

toJSON: (options?: { preserveKeys?: boolean | undefined }) => PointJSON;

method unset

unset: () => this;

class Range

class Range extends BaseRange {}

property anchor

anchor: Point;

property focus

focus: Point;

property object

object: string;

method create

static create: (
    properties: RangeTypeProperties | RangeTypeJSON | RangeType
) => Range;

method createList

static createList: (
    elements?:
        | Array<RangeTypeProperties | RangeTypeJSON | RangeType>
        | Immutable.List<RangeTypeProperties | RangeTypeJSON | RangeType>
) => Immutable.List<Range>;

method createProperties

static createProperties: (
    attrs: RangeTypeProperties | RangeTypeJSON | RangeType
) => RangeProperties;

method fromJS

static fromJS: (properties: RangeTypeJSON) => Range;

method fromJSON

static fromJSON: (properties: RangeTypeJSON) => Range;

method isRange

static isRange: (maybeRange: any) => maybeRange is RangeType;

method toJS

toJS: (options?: { preserveKeys?: boolean | undefined }) => RangeJSON;

method toJSON

toJSON: (options?: { preserveKeys?: boolean | undefined }) => RangeJSON;

class RemoveAnnotationOperation

class RemoveAnnotationOperation extends BaseOperation {}

property annotation

annotation: Annotation;

property data

data: Data;

property type

type: string;

class RemoveMarkOperation

class RemoveMarkOperation extends BaseOperation {}

property data

data: Data;

property mark

mark: Mark;

property path

path: Immutable.List<number>;

property type

type: string;

class RemoveNodeOperation

class RemoveNodeOperation extends BaseOperation {}

property data

data: Data;

property node

node: Node;

property path

path: Immutable.List<number>;

property type

type: string;

class RemoveTextOperation

class RemoveTextOperation extends BaseOperation {}

property data

data: Data;

property offset

offset: number;

property path

path: Immutable.List<number>;

property text

text: string;

property type

type: string;

class Selection

class Selection extends BaseRange {}

property anchor

anchor: Point;

property focus

focus: Point;

property isBlurred

readonly isBlurred: boolean;

property isFocused

isFocused: boolean;

property marks

marks: Immutable.Set<Mark>;

property object

object: string;

method create

static create: (
    properties: RangeTypeProperties | RangeTypeJSON | RangeType
) => Selection;

method createProperties

static createProperties: (
    attrs: RangeTypeProperties | RangeTypeJSON | RangeType | string
) => SelectionProperties;

method fromJS

static fromJS: (properties: RangeTypeProperties | RangeTypeJSON) => Selection;

method fromJSON

static fromJSON: (properties: RangeTypeProperties | RangeTypeJSON) => Selection;

method isSelection

isSelection: (maybeSelection: any) => maybeSelection is Selection;

method setIsFocused

setIsFocused: (value: boolean) => Selection;

method setMarks

setMarks: (marks: Immutable.Set<Mark>) => Selection;

method setProperties

setProperties: (
    properties: RangeTypeProperties | RangeTypeJSON | RangeType | string
) => Selection;

method toJS

toJS: () => SelectionJSON;

method toJSON

toJSON: () => SelectionJSON;

class SetAnnotationOperation

class SetAnnotationOperation extends BaseOperation {}

@types/slate

Install

Overview

Index

Classes

Interfaces

Type Aliases

Namespaces

Classes

class AddAnnotationOperation

property annotation

property data

property type

class AddMarkOperation

property data

property mark

property path

property type

class Annotation

property anchor

property data

property focus

property key

property object

property type

method create

method createMap

method createProperties

method fromJS

method fromJSON

method isAnnotation

method setProperties

method toJS

method toJSON

class BaseOperation

property object

property type

method apply

method create

method createList

method fromJS

method fromJSON

method invert

method isOperation

method isOperationList

method toJSON

class Block

property nodes

property object

method create

method createList

method fromJS

method fromJSON

method isBlock

method isBlockList

method toJS

method toJSON

class Decoration

property anchor

property data

property focus

property object

property type

method create

method createList

method createProperties

method fromJSON

method isDecoration

method setProperties

method toJS

method toJSON

class Document

property object

method create

method fromJS

method fromJSON

method isDocument

method toJS

method toJSON

class Editor