@contentful/field-editor-rich-text 3.3.5 → 3.4.1

package/dist/helpers/editor.d.ts

@@ -1,20 +1,19 @@
 import { Link } from '@contentful/field-editor-reference/dist/types';
 import { BLOCKS, INLINES } from '@contentful/rich-text-types';
-import { EditorNodesOptions, PlateEditor, ToggleNodeTypeOptions } from '@udecode/plate-core';
-import { Path, Node } from 'slate';
-import { CustomElement, RichTextEditor } from '../types';
+import { EditorNodesOptions, ToggleNodeTypeOptions, Node, Path } from '../internal/types';
+import { CustomElement, PlateEditor } from '../internal/types';
 export declare const LINK_TYPES: INLINES[];
 export declare function isBlockSelected(editor: PlateEditor, type: string): boolean;
 export declare function isRootLevel(path: Path): boolean;
 declare type NodeEntry = [CustomElement, Path];
 declare type NodeType = BLOCKS | INLINES;
-export declare function getNodeEntryFromSelection(editor: RichTextEditor, nodeTypeOrTypes: NodeType | NodeType[], path?: Path): NodeEntry | [];
-export declare function isNodeTypeSelected(editor: RichTextEditor, nodeType: BLOCKS | INLINES): boolean;
-export declare function moveToTheNextLine(editor: RichTextEditor): void;
-export declare function moveToTheNextChar(editor: RichTextEditor): void;
-export declare function insertEmptyParagraph(editor: RichTextEditor, options?: any): void;
-export declare function getElementFromCurrentSelection(editor: RichTextEditor): (Node | Path)[];
-export declare function isList(editor?: RichTextEditor): boolean;
+export declare function getNodeEntryFromSelection(editor: PlateEditor, nodeTypeOrTypes: NodeType | NodeType[], path?: Path): NodeEntry | [];
+export declare function isNodeTypeSelected(editor: PlateEditor | null, nodeType: BLOCKS | INLINES): boolean;
+export declare function moveToTheNextLine(editor: PlateEditor): void;
+export declare function moveToTheNextChar(editor: PlateEditor): void;
+export declare function insertEmptyParagraph(editor: PlateEditor, options?: any): void;
+export declare function getElementFromCurrentSelection(editor: PlateEditor): (import("@udecode/plate-core").ENode<import("@udecode/plate-core").Value> | import("slate").Path)[];
+export declare function isList(editor?: PlateEditor): boolean;
 export declare function getTableSize(table: CustomElement): Record<'numRows' | 'numColumns', number> | null;
 interface InsertLinkOptions {
     text: string;
@@ -24,18 +23,18 @@ interface InsertLinkOptions {
     path?: Path;
 }
 export declare function insertLink(editor: any, options: InsertLinkOptions): void;
-export declare function isLinkActive(editor?: RichTextEditor): boolean;
+export declare function isLinkActive(editor?: PlateEditor | null): boolean;
 export declare function unwrapLink(editor: any): void;
 export declare function wrapLink(editor: any, { text, url, target, type, path }: InsertLinkOptions): void;
-export declare function getAncestorPathFromSelection(editor: RichTextEditor): Path | undefined;
-export declare const isAtEndOfTextSelection: (editor: RichTextEditor) => boolean;
+export declare function getAncestorPathFromSelection(editor: PlateEditor): import("slate").Path | undefined;
+export declare const isAtEndOfTextSelection: (editor: PlateEditor) => boolean;
 /**
  * This traversal strategy is unfortunately necessary because Slate doesn't
  * expose something like Node.next(editor).
  */
-export declare function getNextNode(editor: RichTextEditor): CustomElement | null;
+export declare function getNextNode(editor: PlateEditor): CustomElement | null;
 export declare const INLINE_TYPES: string[];
 export declare const isInlineOrText: (node: Node) => boolean;
-export declare const focus: (editor: RichTextEditor) => void;
-export declare function toggleElement(editor: RichTextEditor, options: ToggleNodeTypeOptions, editorOptions?: Omit<EditorNodesOptions, 'match'>): void;
+export declare const focus: (editor: PlateEditor) => void;
+export declare function toggleElement(editor: PlateEditor, options: ToggleNodeTypeOptions, editorOptions?: EditorNodesOptions): void;
 export {};

package/dist/helpers/extractNodes.d.ts

@@ -1,6 +1,5 @@
-import { Path } from 'slate';
-import { CustomElement, RichTextEditor } from '../types';
+import { PlateEditor, Node, Path } from '../internal/types';
 /**
  * It filters out all paragraphs and headings from a path and convert them into paragraphs.
  */
-export declare function extractParagraphs(editor: RichTextEditor, path: Path): CustomElement[];
+export declare function extractParagraphs(editor: PlateEditor, path: Path): Node[];

package/dist/helpers/sanitizeIncomingSlateDoc.d.ts

@@ -1,4 +1,4 @@
-import { TextOrCustomElement } from '../types';
+import { TextOrCustomElement } from '../internal/types';
 /**
  * Ensures all nodes have a child leaf text element. This should be handled by
  * Slate but its behavior has proven to be buggy and unpredictable.

package/dist/helpers/transformers.d.ts

@@ -1,8 +1,7 @@
 import { BLOCKS, INLINES } from '@contentful/rich-text-types';
-import { NodeEntry } from 'slate';
-import { RichTextEditor } from '../types';
-export declare const transformRemove: (editor: RichTextEditor, [, path]: NodeEntry<import("slate").Node>) => void;
-export declare const transformParagraphs: (editor: RichTextEditor, entry: NodeEntry<import("slate").Node>) => void;
-export declare const transformUnwrap: (editor: RichTextEditor, [, path]: NodeEntry<import("slate").Node>) => void;
-export declare const transformWrapIn: (type: BLOCKS | INLINES) => (editor: RichTextEditor, [, path]: NodeEntry<import("slate").Node>) => void;
-export declare const transformLift: (editor: RichTextEditor, [, path]: NodeEntry<import("slate").Node>) => void;
+import { PlateEditor, NodeEntry } from '../internal/types';
+export declare const transformRemove: (editor: PlateEditor, [, path]: NodeEntry<import("../internal/types").Node>) => void;
+export declare const transformParagraphs: (editor: PlateEditor, entry: NodeEntry<import("../internal/types").Node>) => void;
+export declare const transformUnwrap: (editor: PlateEditor, [, path]: NodeEntry<import("../internal/types").Node>) => void;
+export declare const transformWrapIn: (type: BLOCKS | INLINES) => (editor: PlateEditor, [, path]: NodeEntry<import("../internal/types").Node>) => void;
+export declare const transformLift: (editor: PlateEditor, [, path]: NodeEntry<import("../internal/types").Node>) => void;

package/dist/internal/constants.d.ts

@@ -0,0 +1 @@
+export declare const ELEMENT_DEFAULT = "p";

package/dist/internal/hooks.d.ts

@@ -0,0 +1 @@
+export declare const useReadOnly: () => boolean;

package/dist/internal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './queries';
+export * from './types';
+export * from './misc';
+export * from './transforms';

package/dist/internal/misc.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="react" />
+import * as p from '@udecode/plate-core';
+import { StoreApiGet } from '@udecode/zustood';
+import * as s from 'slate';
+import type { Value, PlateEditor, PlatePlugin } from './types';
+export declare type CreatePlateEditorOptions = p.CreatePlateEditorOptions<Value, PlateEditor>;
+export declare const createPlateEditor: (options?: CreatePlateEditorOptions) => PlateEditor & Omit<s.BaseEditor, "children" | "operations" | "marks" | "isInline" | "isVoid" | "normalizeNode" | "apply" | "getFragment" | "insertFragment" | "insertNode"> & {
+    children: Value;
+    operations: p.TOperation<p.TDescendant>[];
+    marks: Record<string, any> | null;
+    isInline: <N extends p.TElement>(element: N) => boolean;
+    isVoid: <N_1 extends p.TElement>(element: N_1) => boolean;
+    normalizeNode: <N_2 extends p.TNode>(entry: p.TNodeEntry<N_2>) => void;
+    apply: <N_3 extends p.TDescendant>(operation: p.TOperation<N_3>) => void;
+    getFragment: <N_4 extends p.TDescendant>() => N_4[];
+    insertFragment: <N_5 extends p.TDescendant>(fragment: N_5[]) => void;
+    insertNode: <N_6 extends p.TDescendant>(node: N_6 | N_6[]) => void;
+} & p.UnknownObject & Pick<import("slate-history").HistoryEditor, "history" | "undo" | "redo"> & Pick<import("slate-react").ReactEditor, "insertData" | "insertFragmentData" | "setFragmentData" | "insertTextData" | "hasRange"> & {
+    key: any;
+    id: string;
+    plugins: p.WithPlatePlugin<{}, Value, p.PlateEditor<Value>>[];
+    pluginsByKey: Record<string, p.WithPlatePlugin<{}, Value, p.PlateEditor<Value>>>;
+    prevSelection: s.BaseRange | null;
+    currentKeyboardEvent: import("react").KeyboardEvent<Element> | null;
+};
+export declare const withoutNormalizing: (editor: PlateEditor, fn: () => boolean | void) => boolean;
+export declare const focusEditor: (editor: PlateEditor, target?: s.Location | undefined) => void;
+export declare const blurEditor: (editor: PlateEditor) => void;
+export declare const selectEditor: (editor: PlateEditor, opts: p.SelectEditorOptions) => void;
+export declare const fromDOMPoint: (editor: PlateEditor, domPoint: [Node, number], opts?: {
+    exactMatch: boolean;
+    suppressThrow: boolean;
+}) => s.BasePoint | null | undefined;
+export declare const mockPlugin: (plugin?: Partial<PlatePlugin> | undefined) => p.WithPlatePlugin<p.AnyObject, p.Value, p.PlateEditor<p.Value>>;
+export declare const getPlateSelectors: (id?: string | undefined) => StoreApiGet<p.PlateStoreState<Value, PlateEditor>, {}>;

package/dist/internal/queries.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Re-exporting Plate/Slate queries (aka selectors) to reduce
+ * the blast radius of version upgrades
+ */
+import * as p from '@udecode/plate-core';
+import * as s from 'slate';
+import type { Value, PlateEditor, Location, Node, NodeEntry, BaseRange, Element, Text, Ancestor, BasePoint } from './types';
+/**
+ * Get text content at location
+ */
+export declare const getText: (editor: PlateEditor, at?: s.Location | undefined) => string;
+export declare const isText: (value: unknown) => value is Text;
+export declare const getEndPoint: (editor: PlateEditor, at: Location) => s.BasePoint;
+export declare const getStartPoint: (editor: PlateEditor, at: Location) => s.BasePoint;
+export declare const isNode: (value: unknown) => value is Node;
+export declare const isSelectionAtBlockEnd: (editor: PlateEditor, options?: p.GetAboveNodeOptions<Value> | undefined) => boolean;
+export declare const isSelectionAtBlockStart: (editor: PlateEditor, options?: p.GetAboveNodeOptions<Value> | undefined) => boolean;
+export declare const getBlockAbove: (editor: PlateEditor, options?: p.GetAboveNodeOptions<p.Value> | undefined) => p.TNodeEntry<p.TEditor<p.Value> | p.TElement> | undefined;
+export declare const getNodeEntry: (editor: PlateEditor, at: Location, options?: s.EditorNodeOptions | undefined) => p.TNodeEntry<p.ENode<Value>>;
+export declare const getNodeEntries: (editor: PlateEditor, options?: p.GetNodeEntriesOptions<p.Value> | undefined) => Generator<p.TNodeEntry<p.ENode<p.Value>>, void, undefined>;
+export declare const getNodeChildren: (root: Ancestor, path: s.Path, options?: s.NodeChildrenOptions | undefined) => Generator<p.TNodeEntry<Text | Element | p.TDescendant>, void, undefined>;
+export declare const getParentNode: (editor: PlateEditor, at: Location, options?: s.EditorParentOptions | undefined) => NodeEntry<Node> | undefined;
+export declare const someNode: (editor: PlateEditor, options: p.FindNodeOptions) => boolean;
+export declare const getChildren: (entry: NodeEntry<Node>) => NodeEntry<Node>[];
+export declare const isFirstChild: (path: s.Path) => boolean;
+export declare const getDescendantNodeByPath: (root: Node, path: s.Path) => Node;
+export declare const getNodeDescendants: (root: PlateEditor | Node, options?: s.NodeDescendantsOptions | undefined) => Generator<p.TNodeEntry<p.TText | p.TElement | Element>, void, undefined>;
+export declare const isRangeCollapsed: (range?: s.BaseRange | undefined) => boolean;
+export declare const isRangeAcrossBlocks: (editor: p.TEditor<p.Value>, options?: (Omit<p.GetAboveNodeOptions<p.Value>, 'at'> & {
+    at?: s.BaseRange | null | undefined;
+}) | undefined) => boolean | undefined;
+export declare const isRangeExpanded: (range?: s.BaseRange | undefined) => boolean;
+export declare const getRange: (editor: PlateEditor, at: Location, to?: s.Location | undefined) => s.BaseRange;
+export declare const getRangeEdges: (range: BaseRange) => [s.BasePoint, s.BasePoint];
+export declare const getRangeStart: (range: BaseRange) => s.BasePoint;
+export declare const getRangeEnd: (range: BaseRange) => s.BasePoint;
+export declare const getAboveNode: (editor: PlateEditor, opts?: p.GetAboveNodeOptions<Value> | undefined) => NodeEntry<Node> | undefined;
+export declare const getNextNode: (editor: PlateEditor, opts?: p.GetNextNodeOptions<Value> | undefined) => NodeEntry<Node> | undefined;
+export declare const getCommonNode: (root: PlateEditor | Node, path: s.Path, another: s.Path) => NodeEntry<Node>;
+export declare const getNodeTexts: (root: Node, opts?: {
+    from?: s.Path | undefined;
+    to?: s.Path | undefined;
+    pass?: ((ne: NodeEntry<Node>) => boolean) | undefined;
+    reverse?: boolean | undefined;
+} | undefined) => Generator<p.TNodeEntry<p.TText>, void, undefined>;
+export declare const findNode: (editor: PlateEditor, options?: p.FindNodeOptions<p.Value> | undefined) => p.TNodeEntry<p.ENode<p.Value>> | undefined;
+export declare const isMarkActive: (editor: PlateEditor, type: string) => boolean;
+export declare const getMarks: (editor: PlateEditor) => Partial<{
+    [x: string]: unknown;
+    [x: number]: unknown;
+}> | null;
+export declare const isEditor: (value: unknown) => value is PlateEditor;
+export declare const isEditorReadOnly: (editor: PlateEditor) => boolean;
+export declare const isElement: (value: unknown) => value is Element;
+export declare const isBlockNode: (editor: PlateEditor, value: unknown) => value is Element;
+export declare const findNodePath: (editor: PlateEditor, node: Node) => s.Path | undefined;
+export declare const isAncestorPath: (path: s.Path, another: s.Path) => boolean;
+export declare const isAncestorEmpty: (editor: PlateEditor, node: Ancestor) => boolean;
+export declare const getParentPath: (path: s.Path) => s.Path;
+export declare const getNextPath: (path: s.Path) => s.Path;
+export declare const getPreviousPath: (path: s.Path) => s.Path;
+export declare const getLastChildPath: (nodeEntry: NodeEntry<Node>) => s.Path;
+export declare const getPathLevels: (path: s.Path, options?: s.PathLevelsOptions | undefined) => s.Path[];
+export declare const isCommonPath: (path: s.Path, anotherPath: s.Path) => boolean;
+export declare const isFirstChildPath: (path: s.Path) => boolean;
+export declare const isLastChildPath: (entry: NodeEntry<Node>, childPath: s.Path) => boolean;
+export declare const isChildPath: (path: s.Path, another: s.Path) => boolean;
+export declare const matchNode: (node: Node, path: s.Path, fn: p.Predicate<PlateEditor | Node>) => boolean;
+export declare const someHtmlElement: (rootNode: globalThis.Node, predicate: (node: HTMLElement) => boolean) => boolean;
+export declare const getPointBefore: (editor: PlateEditor, at: Location, options?: s.EditorBeforeOptions | undefined) => s.BasePoint | undefined;
+export declare const getPointAfter: (editor: PlateEditor, at: Location, options?: s.EditorAfterOptions | undefined) => s.BasePoint | undefined;
+export declare const isEndPoint: (editor: PlateEditor, point: BasePoint | null | undefined, at: Location) => boolean;
+export declare const isInline: (editor: PlateEditor, value: unknown) => boolean;
+export declare const queryNode: (entry?: NodeEntry<Node> | undefined, options?: p.QueryNodeOptions | undefined) => boolean;
+export declare const getPluginType: (editor: PlateEditor, key: string) => string;
+export declare const createPathRef: (editor: PlateEditor, at: s.Path) => s.PathRef;
+export declare const match: (obj: Node, path: s.Path, predicate?: p.Predicate<Node> | undefined) => boolean;
+export declare const getLastNodeByLevel: (editor: PlateEditor, level: number) => NodeEntry | undefined;

package/dist/internal/transforms.d.ts

@@ -0,0 +1,33 @@
+import * as p from '@udecode/plate-core';
+import * as s from 'slate';
+import { Except } from 'type-fest';
+import { PlateEditor, Node, ToggleNodeTypeOptions, EditorNodesOptions, BaseRange, Value, Element, Path, Span, BasePoint, Location } from './types';
+/**
+ * Apply editor normalization rules
+ */
+export declare const normalize: (editor: PlateEditor, options?: s.EditorNormalizeOptions) => void;
+/**
+ * Set the selection to a location
+ */
+export declare const setSelection: (editor: PlateEditor, props: Partial<BaseRange>) => void;
+export declare const select: (editor: PlateEditor, location: Location) => void;
+export declare const moveSelection: (editor: PlateEditor, options?: import("slate/dist/transforms/selection").SelectionMoveOptions | undefined) => void;
+export declare const moveChildren: (editor: PlateEditor, options: p.MoveChildrenOptions<Value>) => number;
+export declare const collapseSelection: (editor: PlateEditor, options?: import("slate/dist/transforms/selection").SelectionCollapseOptions | undefined) => void;
+export declare const setNodes: (editor: PlateEditor, attrs: Partial<Except<Node, 'children' | 'text'>>, opts?: p.SetNodesOptions<Value> | undefined) => void;
+export declare const unsetNodes: (editor: PlateEditor, props: string | number | (string | number)[], options?: p.UnsetNodesOptions<Value> | undefined) => void;
+export declare const insertNodes: (editor: PlateEditor, nodes: Node | Node[], opts?: p.InsertNodesOptions<p.Value> | undefined) => void;
+export declare const splitNodes: (editor: PlateEditor, options?: p.SplitNodesOptions<Value> | undefined) => void;
+export declare const liftNodes: (editor: PlateEditor, options?: p.LiftNodesOptions<Value> | undefined) => void;
+export declare const unwrapNodes: (editor: PlateEditor, options?: p.UnwrapNodesOptions<Value> | undefined) => void;
+export declare const wrapNodes: (editor: PlateEditor, element: Element, options?: p.WrapNodesOptions<Value> | undefined) => void;
+export declare const toggleNodeType: (editor: PlateEditor, options: ToggleNodeTypeOptions, editorOptions?: Omit<EditorNodesOptions, "match"> | undefined) => void;
+export declare const removeMark: (editor: PlateEditor, type: string, at: BaseRange) => void;
+export declare const unhangRange: (editor: PlateEditor, range?: Path | BasePoint | BaseRange | Span | null | undefined, options?: p.UnhangRangeOptions | undefined) => s.BaseRange | undefined;
+export declare const toggleMark: (editor: PlateEditor, options: p.ToggleMarkOptions<Value, keyof p.TText>) => void;
+export declare const addMark: (editor: PlateEditor, type: string, value?: unknown) => void;
+export declare const insertText: (editor: PlateEditor, text: string, options?: import("slate/dist/transforms/text").TextInsertTextOptions | undefined) => void;
+export declare const deleteText: (editor: PlateEditor, opts?: Parameters<typeof p.deleteText>['1']) => void;
+export declare const removeNodes: (editor: PlateEditor, opts?: p.RemoveNodesOptions<Value> | undefined) => void;
+export declare const moveNodes: (editor: PlateEditor, opts?: p.MoveNodesOptions<Value> | undefined) => void;
+export declare const deleteFragment: (editor: PlateEditor, options?: s.EditorFragmentDeletionOptions | undefined) => void;

package/dist/internal/types/editor.d.ts

@@ -0,0 +1,70 @@
+/**
+ * https://plate.udecode.io/docs/typescript
+ */
+import { MARKS } from '@contentful/rich-text-types';
+import * as p from '@udecode/plate-core';
+import * as s from 'slate';
+import * as sr from 'slate-react';
+import { SelectionMoveOptions as SlateSelectionMoveOptions, SelectionCollapseOptions as SlateSelectionCollapseOptions } from 'slate/dist/transforms/selection';
+import { TextInsertTextOptions as SlateTextInsertTextOptions } from 'slate/dist/transforms/text';
+import { TrackingPluginActions } from '../../plugins/Tracking';
+export interface Text extends p.TText {
+    [MARKS.BOLD]?: boolean;
+    [MARKS.CODE]?: boolean;
+    [MARKS.ITALIC]?: boolean;
+    [MARKS.UNDERLINE]?: boolean;
+    [MARKS.SUPERSCRIPT]?: boolean;
+    [MARKS.SUBSCRIPT]?: boolean;
+}
+export interface Element extends p.TElement {
+    type: string;
+    data?: Record<string, unknown>;
+    isVoid?: boolean;
+    children: (Text | Element)[];
+}
+export declare type Value = Element[];
+export declare type ReactEditor = p.TReactEditor<Value>;
+export interface PlateEditor extends p.PlateEditor<Value> {
+    tracking: TrackingPluginActions;
+}
+export declare type CustomText = {
+    text: string;
+    [MARKS.BOLD]?: boolean;
+    [MARKS.CODE]?: boolean;
+    [MARKS.ITALIC]?: boolean;
+    [MARKS.UNDERLINE]?: boolean;
+    [MARKS.SUPERSCRIPT]?: boolean;
+    [MARKS.SUBSCRIPT]?: boolean;
+};
+export declare type TextOrCustomElement = CustomElement | CustomText;
+export declare type CustomElement<T = unknown> = {
+    type: string;
+    children: TextOrCustomElement[];
+    data: T;
+    isVoid?: boolean;
+};
+export declare type CustomRenderElementProps<T = any, O = any> = Omit<RenderElementProps, 'element'> & {
+    element: CustomElement<T>;
+} & O;
+export declare type Node = p.ElementOf<PlateEditor> | p.TextOf<PlateEditor>;
+export declare type Path = p.TPath;
+export declare type NodeEntry<T extends Node = Node> = p.TNodeEntry<T>;
+export declare type NodeMatch = p.ENodeMatch<Node>;
+export declare type Ancestor = p.AncestorOf<PlateEditor>;
+export declare type Descendant = p.DescendantOf<PlateEditor>;
+export declare type Operation = p.TOperation<Descendant>;
+export declare type Location = p.TLocation;
+export declare type BaseRange = p.TRange;
+export declare type ToggleNodeTypeOptions = p.ToggleNodeTypeOptions;
+export declare type EditorNodesOptions = Omit<p.GetNodeEntriesOptions<Value>, 'match'>;
+export declare type WithOverride<P = p.AnyObject> = p.WithOverride<P, Value, PlateEditor>;
+export declare type SelectionMoveOptions = SlateSelectionMoveOptions;
+export declare type TextInsertTextOptions = SlateTextInsertTextOptions;
+export declare type SelectionCollapseOptions = SlateSelectionCollapseOptions;
+export declare type HotkeyPlugin = p.HotkeyPlugin;
+export declare type RenderLeafProps = sr.RenderLeafProps;
+export declare type RenderElementProps = sr.RenderElementProps;
+export declare type Span = p.TSpan;
+export declare type BasePoint = s.BasePoint;
+export declare type BaseSelection = s.BaseSelection;
+export declare type PathRef = s.PathRef;

package/dist/internal/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './editor';
+export * from './plugins';

package/dist/internal/types/plugins.d.ts

@@ -0,0 +1,12 @@
+import { SoftBreakRule, ExitBreakRule } from '@udecode/plate-break';
+import * as p from '@udecode/plate-core';
+import { ResetNodePluginRule } from '@udecode/plate-reset-node';
+import type { NormalizerRule } from '../../plugins/Normalizer';
+import { Value, PlateEditor } from './editor';
+export declare type KeyboardHandler<P = p.PluginOptions> = p.KeyboardHandler<P, Value, PlateEditor>;
+export interface PlatePlugin extends p.PlatePlugin<p.AnyObject, Value, PlateEditor> {
+    softBreak?: SoftBreakRule[];
+    exitBreak?: ExitBreakRule[];
+    resetNode?: ResetNodePluginRule<Value, PlateEditor>[];
+    normalizer?: NormalizerRule[];
+}

package/dist/plugins/Break/createExitBreakPlugin.d.ts

@@ -1,2 +1,2 @@
-import { RichTextPlugin } from '../../types';
-export declare const createExitBreakPlugin: () => RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare const createExitBreakPlugin: () => PlatePlugin;

package/dist/plugins/Break/createResetNodePlugin.d.ts

@@ -1,2 +1,2 @@
-import { RichTextPlugin } from '../../types';
-export declare const createResetNodePlugin: () => RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare const createResetNodePlugin: () => PlatePlugin;

package/dist/plugins/Break/createSoftBreakPlugin.d.ts

@@ -1,2 +1,2 @@
-import { RichTextPlugin } from '../../types';
-export declare const createSoftBreakPlugin: () => RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare const createSoftBreakPlugin: () => PlatePlugin;

package/dist/plugins/CommandPalette/components/CommandList.d.ts

@@ -1,7 +1,7 @@
-import { RichTextEditor } from '../../../types';
+import { PlateEditor } from '../../../internal/types';
 export interface CommandListProps {
     query: string;
-    editor: RichTextEditor;
+    editor: PlateEditor;
     textContainer?: HTMLSpanElement;
 }
 export declare const CommandList: ({ query, editor, textContainer }: CommandListProps) => JSX.Element | null;

package/dist/plugins/CommandPalette/components/CommandList.styles.d.ts

@@ -1,5 +1,6 @@
 declare const styles: {
     container: string;
+    menuPoper: string;
     menuContent: string;
     menuList: string;
     menuItem: string;

package/dist/plugins/CommandPalette/components/CommandPrompt.d.ts

@@ -1,2 +1,4 @@
-import { PlateRenderLeafProps } from '@udecode/plate-core';
-export declare const CommandPrompt: (props: PlateRenderLeafProps) => JSX.Element;
+import { PlateEditor, RenderLeafProps } from '../../../internal/types';
+export declare const CommandPrompt: (props: RenderLeafProps & {
+    editor: PlateEditor;
+}) => JSX.Element;

package/dist/plugins/CommandPalette/createCommandPalettePlugin.d.ts

@@ -1,4 +1,4 @@
-import { RichTextPlugin } from '../../types';
+import { PlatePlugin } from '../../internal/types';
 /**
  * A command palette plugin (aka slash commands)
  *
@@ -10,4 +10,4 @@ import { RichTextPlugin } from '../../types';
  * * When the user presses a letter, number, or space, the command palette will show the command suggestions
  * * When the user presses backspace, the command palette will remove the last character from the command string
  */
-export declare const createCommandPalettePlugin: () => RichTextPlugin;
+export declare const createCommandPalettePlugin: () => PlatePlugin;

package/dist/plugins/CommandPalette/onKeyDown.d.ts

@@ -1,3 +1,2 @@
-import { KeyboardHandler } from '@udecode/plate-core';
-import { RichTextEditor } from '../../types';
-export declare const createOnKeyDown: () => KeyboardHandler<RichTextEditor>;
+import { KeyboardHandler } from '../../internal/types';
+export declare const createOnKeyDown: () => KeyboardHandler;

package/dist/plugins/CommandPalette/useCommands.d.ts

@@ -1,5 +1,5 @@
 import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { RichTextEditor } from 'types';
+import { PlateEditor } from '../../internal/types';
 export interface Command {
     id: string;
     thumbnail?: string;
@@ -11,4 +11,4 @@ export interface CommandGroup {
     commands: Command[];
 }
 export declare type CommandList = (Command | CommandGroup)[];
-export declare const useCommands: (sdk: FieldExtensionSDK, query: string, editor: RichTextEditor) => CommandList;
+export declare const useCommands: (sdk: FieldExtensionSDK, query: string, editor: PlateEditor) => CommandList;

package/dist/plugins/DragAndDrop/index.d.ts

@@ -1,2 +1,2 @@
-import { RichTextPlugin } from '../../types';
-export declare function createDragAndDropPlugin(): RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare function createDragAndDropPlugin(): PlatePlugin;

package/dist/plugins/EmbeddedEntityBlock/LinkedEntityBlock.d.ts

@@ -1,4 +1,4 @@
-import { CustomRenderElementProps } from '../../types';
+import { CustomRenderElementProps } from '../../internal/types';
 declare type LinkedEntityBlockProps = CustomRenderElementProps<{
     target: {
         sys: {

package/dist/plugins/EmbeddedEntityBlock/Util.d.ts

@@ -1,3 +1,4 @@
+import { PlateEditor } from '../../internal/types';
 import { TrackingPluginActions } from '../../plugins/Tracking';
 export declare function selectEntityAndInsert(nodeType: any, sdk: any, editor: any, logAction: TrackingPluginActions['onToolbarAction'] | TrackingPluginActions['onShortcutAction']): Promise<void>;
-export declare function insertBlock(editor: any, nodeType: any, entity: any): void;
+export declare function insertBlock(editor: PlateEditor, nodeType: string, entity: any): void;

package/dist/plugins/EmbeddedEntityBlock/index.d.ts

@@ -1,5 +1,5 @@
 import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { RichTextPlugin } from '../../types';
+import { PlatePlugin } from '../../internal/types';
 export { EmbeddedEntityBlockToolbarIcon as ToolbarIcon } from './ToolbarIcon';
-export declare const createEmbeddedEntryBlockPlugin: (sdk: FieldExtensionSDK) => RichTextPlugin;
-export declare const createEmbeddedAssetBlockPlugin: (sdk: FieldExtensionSDK) => RichTextPlugin;
+export declare const createEmbeddedEntryBlockPlugin: (sdk: FieldExtensionSDK) => PlatePlugin;
+export declare const createEmbeddedAssetBlockPlugin: (sdk: FieldExtensionSDK) => PlatePlugin;

package/dist/plugins/EmbeddedEntityInline/index.d.ts

@@ -1,9 +1,9 @@
 import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { RichTextPlugin } from '../../types';
+import { PlatePlugin } from '../../internal/types';
 interface ToolbarEmbeddedEntityInlineButtonProps {
     onClose: () => void;
     isDisabled: boolean;
 }
 export declare function ToolbarEmbeddedEntityInlineButton(props: ToolbarEmbeddedEntityInlineButtonProps): JSX.Element;
-export declare function createEmbeddedEntityInlinePlugin(sdk: FieldExtensionSDK): RichTextPlugin;
+export declare function createEmbeddedEntityInlinePlugin(sdk: FieldExtensionSDK): PlatePlugin;
 export {};

package/dist/plugins/Heading/createHeadingPlugin.d.ts

@@ -1,2 +1,2 @@
-import { RichTextPlugin } from '../../types';
-export declare const createHeadingPlugin: () => RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare const createHeadingPlugin: () => PlatePlugin;

package/dist/plugins/Hr/index.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import * as Slate from 'slate-react';
-import { RichTextEditor, RichTextPlugin } from '../../types';
+import { PlatePlugin, PlateEditor } from '../../internal/types';
 interface ToolbarHrButtonProps {
     isDisabled?: boolean;
 }
-export declare function withHrEvents(editor: RichTextEditor): (event: React.KeyboardEvent) => void;
+export declare function withHrEvents(editor: PlateEditor): (event: React.KeyboardEvent) => void;
 export declare function ToolbarHrButton(props: ToolbarHrButtonProps): JSX.Element | null;
 export declare function Hr(props: Slate.RenderLeafProps): JSX.Element;
-export declare const createHrPlugin: () => RichTextPlugin;
+export declare const createHrPlugin: () => PlatePlugin;
 export {};

package/dist/plugins/Hyperlink/HyperlinkModal.d.ts

@@ -1,8 +1,7 @@
 import { Link } from '@contentful/field-editor-reference/dist/types';
 import { FieldExtensionSDK } from '@contentful/field-editor-shared';
-import { Path } from 'slate';
+import { PlateEditor, Path } from '../../internal/types';
 import { TrackingPluginActions } from '../../plugins/Tracking';
-import { RichTextEditor } from '../../types';
 interface HyperlinkModalProps {
     linkText?: string;
     linkType?: string;
@@ -13,5 +12,5 @@ interface HyperlinkModalProps {
     readonly: boolean;
 }
 export declare function HyperlinkModal(props: HyperlinkModalProps): JSX.Element;
-export declare function addOrEditLink(editor: RichTextEditor, sdk: FieldExtensionSDK, logAction: TrackingPluginActions['onToolbarAction'] | TrackingPluginActions['onShortcutAction'] | TrackingPluginActions['onViewportAction'], targetPath?: Path): Promise<void>;
+export declare function addOrEditLink(editor: PlateEditor, sdk: FieldExtensionSDK, logAction: TrackingPluginActions['onToolbarAction'] | TrackingPluginActions['onShortcutAction'] | TrackingPluginActions['onViewportAction'], targetPath?: Path): Promise<void>;
 export {};

package/dist/plugins/Hyperlink/components/EntityHyperlink.d.ts

@@ -1,5 +1,5 @@
 import { Link } from '@contentful/app-sdk';
-import { CustomRenderElementProps } from '../../../types';
+import { CustomRenderElementProps } from '../../../internal/types';
 declare type HyperlinkElementProps = CustomRenderElementProps<{
     uri?: string;
     target?: Link;

package/dist/plugins/Hyperlink/components/UrlHyperlink.d.ts

@@ -1,5 +1,5 @@
 import { Link } from '@contentful/app-sdk';
-import { CustomRenderElementProps } from '../../../types';
+import { CustomRenderElementProps } from '../../../internal/types';
 declare type HyperlinkElementProps = CustomRenderElementProps<{
     uri?: string;
     target?: Link;

package/dist/plugins/Hyperlink/createHyperlinkPlugin.d.ts

@@ -1,3 +1,3 @@
 import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { RichTextPlugin } from '../../types';
-export declare const createHyperlinkPlugin: (sdk: FieldExtensionSDK) => RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare const createHyperlinkPlugin: (sdk: FieldExtensionSDK) => PlatePlugin;

package/dist/plugins/Hyperlink/utils.d.ts

@@ -1,5 +1,5 @@
-import { NodeEntry, Node } from 'slate';
-import { RichTextEditor } from '../../types';
+import { NodeEntry } from '../../internal/types';
+import { PlateEditor } from '../../internal/types';
 import { FetchedEntityData } from './useEntityInfo';
-export declare const hasText: (editor: RichTextEditor, entry: NodeEntry<Node>) => boolean;
+export declare const hasText: (editor: PlateEditor, entry: NodeEntry<import("../../internal/types").Node>) => boolean;
 export declare function getEntityInfo(data?: FetchedEntityData): string;

package/dist/plugins/List/createListPlugin.d.ts

@@ -1,2 +1,2 @@
-import { RichTextPlugin } from '../../types';
-export declare const createListPlugin: () => RichTextPlugin;
+import { PlatePlugin } from '../../internal/types';
+export declare const createListPlugin: () => PlatePlugin;

package/dist/plugins/List/insertListBreak.d.ts

@@ -1,2 +1,2 @@
-import { RichTextEditor } from '../../types';
-export declare const insertListBreak: (editor: RichTextEditor) => () => void;
+import { PlateEditor } from '../../internal/types';
+export declare const insertListBreak: (editor: PlateEditor) => () => void;

package/dist/plugins/List/insertListFragment.d.ts

@@ -1,3 +1,2 @@
-import { TDescendant } from '@udecode/plate-core';
-import { RichTextEditor } from '../../types';
-export declare const insertListFragment: (editor: RichTextEditor) => (fragment: TDescendant[]) => void;
+import { PlateEditor, Node } from '../../internal/types';
+export declare const insertListFragment: (editor: PlateEditor) => (fragment: Node[]) => void;

package/dist/plugins/List/onKeyDownList.d.ts

@@ -2,6 +2,6 @@
  * Credit: Modified version of Plate's list plugin
  * See: https://github.com/udecode/plate/blob/main/packages/nodes/list
  */
-import { HotkeyPlugin, KeyboardHandler } from '@udecode/plate-core';
-import { RichTextEditor } from '../../types';
-export declare const onKeyDownList: KeyboardHandler<RichTextEditor, HotkeyPlugin>;
+import { HotkeyPlugin } from '@udecode/plate-core';
+import { KeyboardHandler } from '../../internal/types';
+export declare const onKeyDownList: KeyboardHandler<HotkeyPlugin>;

package/dist/plugins/List/transforms/deleteBackwardList.d.ts

@@ -1,2 +1,2 @@
-import { RichTextEditor } from '../../../types';
-export declare const deleteBackwardList: (editor: RichTextEditor, unit: 'character' | 'word' | 'line' | 'block') => boolean;
+import { PlateEditor } from '../../../internal/types';
+export declare const deleteBackwardList: (editor: PlateEditor, unit: 'character' | 'word' | 'line' | 'block') => boolean;

package/dist/plugins/List/transforms/insertListItem.d.ts

@@ -1,5 +1,5 @@
-import { RichTextEditor } from '../../../types';
+import { PlateEditor } from '../../../internal/types';
 /**
  * Insert list item if selection is in li>p.
  */
-export declare const insertListItem: (editor: RichTextEditor) => boolean;
+export declare const insertListItem: (editor: PlateEditor) => boolean;

package/dist/plugins/List/transforms/moveListItemDown.d.ts

@@ -1,11 +1,6 @@
-/**
- * Credit: Modified version of Plate's list plugin
- * See: https://github.com/udecode/plate/blob/main/packages/nodes/list
- */
-import { PlateEditor, TElement } from '@udecode/plate-core';
-import { NodeEntry } from 'slate';
+import { NodeEntry, PlateEditor } from '../../../internal/types';
 export interface MoveListItemDownOptions {
-    list: NodeEntry<TElement>;
-    listItem: NodeEntry<TElement>;
+    list: NodeEntry;
+    listItem: NodeEntry;
 }
 export declare const moveListItemDown: (editor: PlateEditor, { list, listItem }: MoveListItemDownOptions) => void;