slate-react

  • Version 0.147.6
  • Published
  • 1.95 MB
  • 6 dependencies
  • MIT license

Install

npm i slate-react
yarn add slate-react
pnpm add slate-react

Overview

Tools for building completely customizable richtext editors with React.

Index

Variables

variable Editable

const Editable: React.ForwardRefExoticComponent<any>;
  • Editable.

variable ReactEditor

const ReactEditor: ReactEditorInterface;

    Functions

    function DefaultElement

    DefaultElement: (props: RenderElementProps) => JSX.Element;
    • The default element renderer.

    function DefaultLeaf

    DefaultLeaf: (props: RenderLeafProps) => JSX.Element;

      function DefaultPlaceholder

      DefaultPlaceholder: ({
      attributes,
      children,
      }: RenderPlaceholderProps) => JSX.Element;

        function defaultScrollSelectionIntoView

        defaultScrollSelectionIntoView: (
        editor: ReactEditor,
        domRange: DOMRange
        ) => void;
        • A default implement to scroll dom range into view.

        function DefaultText

        DefaultText: (props: RenderTextProps) => React.JSX.Element;

          function Slate

          Slate: (props: {
          editor: ReactEditor;
          initialValue?: Descendant[] | undefined;
          value?: Descendant[] | undefined;
          children: React.ReactNode;
          onChange?: (value: Descendant[]) => void;
          onSelectionChange?: (selection: Selection) => void;
          onValueChange?: (value: Descendant[]) => void;
          }) => React.JSX.Element;
          • A wrapper around the provider to handle onChange events, because the editor is a mutable singleton so it won't ever register as "changed" otherwise.

          function useComposing

          useComposing: () => boolean;
          • Get the current composing state of the editor.

          function useEditor

          useEditor: () => import('..').ReactEditor;
          • Get the current editor object from the React context.

            Deprecated

            Use useSlateStatic instead.

          function useElement

          useElement: () => Element;
          • Get the current element.

          function useElementIf

          useElementIf: () => import('slate').BaseElement | null;
          • Get the current element, or return null if not inside renderElement.

          function useFocused

          useFocused: () => boolean;
          • Get the current focused state of the editor.

          function useReadOnly

          useReadOnly: () => boolean;
          • Get the current readOnly state of the editor.

          function useSelected

          useSelected: ({
          suppressThrow,
          }?: {
          suppressThrow?: boolean | undefined;
          }) => boolean;
          • Get the current selected state of an element.

            Set suppressThrow to return false instead of throwing when the element can no longer be found in the editor.

          function useSlate

          useSlate: () => Editor;
          • Get the current editor object and re-render whenever it changes.

          function useSlateSelection

          useSlateSelection: () => BaseSelection;
          • Get the current slate selection. Only triggers a rerender when the selection actually changes

          function useSlateSelector

          useSlateSelector: <T>(
          selector: (editor: Editor) => T,
          equalityFn?: (a: T | null, b: T) => boolean,
          { deferred }?: SlateSelectorOptions
          ) => T;
          • Use redux style selectors to prevent re-rendering on every keystroke.

            Bear in mind re-rendering can only prevented if the returned value is a value type or for reference types (e.g. objects and arrays) add a custom equality function.

            If selector is memoized using useCallback, then it will only be called when it or the editor state changes. Otherwise, selector will be called every time the component renders.

            Example 1

            const isSelectionActive = useSlateSelector(editor => Boolean(editor.selection))

          function useSlateStatic

          useSlateStatic: () => Editor;
          • Get the current editor object from the React context.

          function useSlateWithV

          useSlateWithV: () => { editor: Editor; v: number };
          • Get the current editor object and its version, which increments on every change.

            Deprecated

            The v counter is no longer used except for this hook, and may be removed in a future version.

          function withReact

          withReact: <T extends BaseEditor>(
          editor: T,
          clipboardFormatKey?: string
          ) => T & ReactEditor;
          • withReact adds React and DOM specific behaviors to the editor.

            If you are using TypeScript, you must extend Slate's CustomTypes to use this plugin.

            See https://docs.slatejs.org/concepts/11-typescript to learn how.

          Interfaces

          interface ReactEditor

          interface ReactEditor extends DOMEditor {}
          • A React and DOM-specific version of the Editor interface.

          property getChunkSize

          getChunkSize: (node: Ancestor) => number | null;
          • Determines the chunk size used by the children chunking optimization. If null is returned (which is the default), the chunking optimization is disabled.

          interface RenderChunkProps

          interface RenderChunkProps {}
          • RenderChunkProps are passed to the renderChunk handler

          property attributes

          attributes: {
          'data-slate-chunk': true;
          };

            property children

            children: any;

              property highest

              highest: boolean;

                property lowest

                lowest: boolean;

                  interface RenderElementProps

                  interface RenderElementProps {}
                  • RenderElementProps are passed to the renderElement handler.

                  property attributes

                  attributes: {
                  'data-slate-node': 'element';
                  'data-slate-inline'?: true;
                  'data-slate-void'?: true;
                  dir?: 'rtl';
                  ref: any;
                  };

                    property children

                    children: any;

                      property element

                      element: Element;

                        interface RenderLeafProps

                        interface RenderLeafProps {}
                        • RenderLeafProps are passed to the renderLeaf handler.

                        property attributes

                        attributes: {
                        'data-slate-leaf': true;
                        };

                          property children

                          children: any;

                            property leaf

                            leaf: Text;
                            • The leaf node with any applied decorations. If no decorations are applied, it will be identical to the text property.

                            property leafPosition

                            leafPosition?: LeafPosition;
                            • The position of the leaf within the Text node, only present when the text node is split by decorations.

                            property text

                            text: Text;

                              interface RenderTextProps

                              interface RenderTextProps {}
                              • RenderTextProps are passed to the renderText handler.

                              property attributes

                              attributes: {
                              'data-slate-node': 'text';
                              ref: any;
                              };

                                property children

                                children: any;

                                  property text

                                  text: Text;

                                    Type Aliases

                                    type RenderPlaceholderProps

                                    type RenderPlaceholderProps = {
                                    children: any;
                                    attributes: {
                                    'data-slate-placeholder': boolean;
                                    'aria-hidden': boolean;
                                    dir?: 'rtl';
                                    contentEditable: boolean;
                                    ref: React.RefCallback<any>;
                                    style: React.CSSProperties;
                                    };
                                    };
                                    • The props that get passed to renderPlaceholder

                                    Package Files (18)

                                    Dependencies (6)

                                    Dev Dependencies (18)

                                    Peer Dependencies (6)

                                    Badge

                                    To add a badge like this onejsDocs.io badgeto 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-react.

                                    • Markdown
                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/slate-react)
                                    • HTML
                                      <a href="https://www.jsdocs.io/package/slate-react"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>