@contentful/field-editor-rich-text 3.4.21 → 3.5.0

package/dist/{internal → types/internal}/queries.d.ts

@@ -1,78 +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;
+/**
+ * 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, Path } from './types';
+/**
+ * Get text content at location
+ */
+export declare const getText: (editor: PlateEditor, at?: Location) => 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>) => boolean;
+export declare const isSelectionAtBlockStart: (editor: PlateEditor, options?: p.GetAboveNodeOptions<Value>) => boolean;
+export declare const getBlockAbove: (editor: PlateEditor, options?: p.GetAboveNodeOptions<p.Value>) => p.TNodeEntry<p.TElement | p.TEditor> | undefined;
+export declare const getNodeEntry: (editor: PlateEditor, at: Location, options?: s.EditorNodeOptions) => p.TNodeEntry<p.ENode<Value>>;
+export declare const getNodeEntries: (editor: PlateEditor, options?: p.GetNodeEntriesOptions) => 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) => NodeEntry | undefined;
+export declare const someNode: (editor: PlateEditor, options: p.FindNodeOptions) => boolean;
+export declare const getChildren: (entry: NodeEntry) => NodeEntry[];
+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) => Generator<p.TNodeEntry<p.TText | Element | p.TElement>, void, undefined>;
+export declare const isRangeCollapsed: (range?: BaseRange) => 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?: BaseRange) => boolean;
+export declare const getRange: (editor: PlateEditor, at: Location, to?: Location) => 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>) => NodeEntry | undefined;
+export declare const getNextNode: (editor: PlateEditor, opts?: p.GetNextNodeOptions<Value>) => NodeEntry | undefined;
+export declare const getCommonNode: (root: PlateEditor | Node, path: s.Path, another: s.Path) => NodeEntry;
+export declare const getNodeTexts: (root: Node, opts?: {
+    from?: s.Path | undefined;
+    to?: s.Path | undefined;
+    pass?: ((ne: NodeEntry) => 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) => s.Path;
+export declare const getPathLevels: (path: s.Path, options?: s.PathLevelsOptions) => 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, 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) => s.BasePoint | undefined;
+export declare const getPointAfter: (editor: PlateEditor, at: Location, options?: s.EditorAfterOptions) => 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, options?: p.QueryNodeOptions) => 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 → types/internal}/transforms.d.ts

@@ -1,33 +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;
+import * as p from '@udecode/plate-core';
+import * as s from 'slate';
+import { Except } from 'type-fest';
+import { PlateEditor, Node, ToggleNodeTypeOptions, EditorNodesOptions, BaseRange, Value, SelectionMoveOptions, TextInsertTextOptions, Element, SelectionCollapseOptions, 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?: SelectionMoveOptions) => void;
+export declare const moveChildren: (editor: PlateEditor, options: p.MoveChildrenOptions<Value>) => number;
+export declare const collapseSelection: (editor: PlateEditor, options?: SelectionCollapseOptions) => void;
+export declare const setNodes: (editor: PlateEditor, attrs: Partial<Except<Node, 'children' | 'text'>>, opts?: p.SetNodesOptions<Value>) => 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) => void;
+export declare const splitNodes: (editor: PlateEditor, options?: p.SplitNodesOptions<Value>) => void;
+export declare const liftNodes: (editor: PlateEditor, options?: p.LiftNodesOptions<Value> | undefined) => void;
+export declare const unwrapNodes: (editor: PlateEditor, options?: p.UnwrapNodesOptions<Value>) => void;
+export declare const wrapNodes: (editor: PlateEditor, element: Element, options?: p.WrapNodesOptions<Value>) => void;
+export declare const toggleNodeType: (editor: PlateEditor, options: ToggleNodeTypeOptions, editorOptions?: Omit<EditorNodesOptions, 'match'>) => 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?: TextInsertTextOptions) => void;
+export declare const deleteText: (editor: PlateEditor, opts?: Parameters<typeof p.deleteText>['1']) => void;
+export declare const removeNodes: (editor: PlateEditor, opts?: p.RemoveNodesOptions<Value>) => void;
+export declare const moveNodes: (editor: PlateEditor, opts?: p.MoveNodesOptions<Value>) => void;
+export declare const deleteFragment: (editor: PlateEditor, options?: s.EditorFragmentDeletionOptions | undefined) => void;

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

@@ -0,0 +1,51 @@
+/**
+ * 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 type Value = Element[];
+export type ReactEditor = p.TReactEditor<Value>;
+export interface PlateEditor extends p.PlateEditor<Value> {
+    tracking: TrackingPluginActions;
+}
+export type Node = p.ElementOf<PlateEditor> | p.TextOf<PlateEditor>;
+export type Path = p.TPath;
+export type NodeEntry<T extends Node = Node> = p.TNodeEntry<T>;
+export type NodeMatch = p.ENodeMatch<Node>;
+export type Ancestor = p.AncestorOf<PlateEditor>;
+export type Descendant = p.DescendantOf<PlateEditor>;
+export type Operation = p.TOperation<Descendant>;
+export type Location = p.TLocation;
+export type BaseRange = p.TRange;
+export type ToggleNodeTypeOptions = p.ToggleNodeTypeOptions;
+export type EditorNodesOptions = Omit<p.GetNodeEntriesOptions<Value>, 'match'>;
+export type WithOverride<P = p.AnyObject> = p.WithOverride<P, Value, PlateEditor>;
+export type SelectionMoveOptions = SlateSelectionMoveOptions;
+export type TextInsertTextOptions = SlateTextInsertTextOptions;
+export type SelectionCollapseOptions = SlateSelectionCollapseOptions;
+export type HotkeyPlugin = p.HotkeyPlugin;
+export type RenderLeafProps = sr.RenderLeafProps;
+export type RenderElementProps = sr.RenderElementProps;
+export type Span = p.TSpan;
+export type BasePoint = s.BasePoint;
+export type BaseSelection = s.BaseSelection;
+export type PathRef = s.PathRef;

package/dist/{internal → types/internal}/types/index.d.ts

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

package/dist/{internal → types/internal}/types/plugins.d.ts

@@ -1,12 +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[];
-}
+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 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 → types/plugins}/Break/createExitBreakPlugin.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/dist/{plugins → types/plugins}/Break/createResetNodePlugin.d.ts

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

package/dist/{plugins → types/plugins}/Break/createSoftBreakPlugin.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/dist/{plugins → types/plugins}/Break/index.d.ts

@@ -1,5 +1,5 @@
-export type { SoftBreakRule, ExitBreakRule } from '@udecode/plate-break';
-export type { ResetNodePluginRule } from '@udecode/plate-reset-node';
-export * from './createSoftBreakPlugin';
-export * from './createExitBreakPlugin';
-export * from './createResetNodePlugin';
+export type { SoftBreakRule, ExitBreakRule } from '@udecode/plate-break';
+export type { ResetNodePluginRule } from '@udecode/plate-reset-node';
+export * from './createSoftBreakPlugin';
+export * from './createExitBreakPlugin';
+export * from './createResetNodePlugin';

package/dist/{plugins → types/plugins}/CommandPalette/components/CommandList.d.ts

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

package/dist/{plugins → types/plugins}/CommandPalette/components/CommandList.styles.d.ts

@@ -1,14 +1,14 @@
-declare const styles: {
-    container: string;
-    menuPoper: string;
-    menuContent: string;
-    menuList: string;
-    menuItem: string;
-    menuItemSelected: string;
-    menuDivider: string;
-    menuHeader: string;
-    menuFooter: string;
-    footerList: string;
-    thumbnail: string;
-};
-export default styles;
+declare const styles: {
+    container: string;
+    menuPoper: string;
+    menuContent: string;
+    menuList: string;
+    menuItem: string;
+    menuItemSelected: string;
+    menuDivider: string;
+    menuHeader: string;
+    menuFooter: string;
+    footerList: string;
+    thumbnail: string;
+};
+export default styles;

package/dist/{plugins → types/plugins}/CommandPalette/components/CommandPrompt.d.ts

@@ -1,4 +1,5 @@
-import { PlateEditor, RenderLeafProps } from '../../../internal/types';
-export declare const CommandPrompt: (props: RenderLeafProps & {
-    editor: PlateEditor;
-}) => JSX.Element;
+import * as React from 'react';
+import { PlateEditor, RenderLeafProps } from '../../../internal/types';
+export declare const CommandPrompt: (props: RenderLeafProps & {
+    editor: PlateEditor;
+}) => React.JSX.Element;

package/dist/{plugins → types/plugins}/CommandPalette/constants.d.ts

@@ -1 +1 @@
-export declare const COMMAND_PROMPT = "command-prompt";
+export declare const COMMAND_PROMPT = "command-prompt";

package/dist/{plugins → types/plugins}/CommandPalette/createCommandPalettePlugin.d.ts

@@ -1,13 +1,13 @@
-import { PlatePlugin } from '../../internal/types';
-/**
- * A command palette plugin (aka slash commands)
- *
- * How does it work?
- * * When the user presses the slash key, the editor will show a command palette
- * * When the user presses a key, the command palette will show the command suggestions
- * * When the user presses enter, the command palette will execute the command
- * * When the user presses escape, the command palette will hide
- * * 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: () => PlatePlugin;
+import { PlatePlugin } from '../../internal/types';
+/**
+ * A command palette plugin (aka slash commands)
+ *
+ * How does it work?
+ * * When the user presses the slash key, the editor will show a command palette
+ * * When the user presses a key, the command palette will show the command suggestions
+ * * When the user presses enter, the command palette will execute the command
+ * * When the user presses escape, the command palette will hide
+ * * 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: () => PlatePlugin;

package/dist/{plugins → types/plugins}/CommandPalette/hooks/useCommandList.d.ts

@@ -1,4 +1,4 @@
-export declare const useCommandList: (commandItems: any, container: any) => {
-    selectedItem: string;
-    isOpen: boolean;
-};
+export declare const useCommandList: (commandItems: any, container: any) => {
+    selectedItem: string;
+    isOpen: boolean;
+};

package/dist/{plugins → types/plugins}/CommandPalette/index.d.ts

@@ -1 +1 @@
-export { createCommandPalettePlugin } from './createCommandPalettePlugin';
+export { createCommandPalettePlugin } from './createCommandPalettePlugin';

package/dist/{plugins → types/plugins}/CommandPalette/onKeyDown.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/dist/{plugins → types/plugins}/CommandPalette/useCommands.d.ts

@@ -1,19 +1,19 @@
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { PlateEditor } from '../../internal/types';
-export interface Command {
-    id: string;
-    thumbnail?: string;
-    label: string;
-    callback?: () => void;
-}
-export interface CommandGroup {
-    group: string;
-    commands: Command[];
-}
-export declare type CommandList = (Command | CommandGroup)[];
-export declare function isCommandPromptPluginEnabled(sdk: FieldExtensionSDK): {
-    inlineAllowed: boolean;
-    entriesAllowed: boolean;
-    assetsAllowed: boolean;
-};
-export declare const useCommands: (sdk: FieldExtensionSDK, query: string, editor: PlateEditor) => CommandList;
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import { PlateEditor } from '../../internal/types';
+export interface Command {
+    id: string;
+    thumbnail?: string;
+    label: string;
+    callback?: () => void;
+}
+export interface CommandGroup {
+    group: string;
+    commands: Command[];
+}
+export type CommandList = (Command | CommandGroup)[];
+export declare function isCommandPromptPluginEnabled(sdk: FieldExtensionSDK): {
+    inlineAllowed: boolean;
+    entriesAllowed: boolean;
+    assetsAllowed: boolean;
+};
+export declare const useCommands: (sdk: FieldExtensionSDK, query: string, editor: PlateEditor) => CommandList;

package/dist/{plugins → types/plugins}/CommandPalette/utils/createInlineEntryNode.d.ts

@@ -1,16 +1,16 @@
-import { INLINES } from '@contentful/rich-text-types';
-export declare function createInlineEntryNode(id: string): {
-    type: INLINES;
-    children: {
-        text: string;
-    }[];
-    data: {
-        target: {
-            sys: {
-                id: string;
-                type: string;
-                linkType: string;
-            };
-        };
-    };
-};
+import { INLINES } from '@contentful/rich-text-types';
+export declare function createInlineEntryNode(id: string): {
+    type: INLINES;
+    children: {
+        text: string;
+    }[];
+    data: {
+        target: {
+            sys: {
+                id: string;
+                type: string;
+                linkType: string;
+            };
+        };
+    };
+};

package/dist/{plugins → types/plugins}/CommandPalette/utils/fetchAssets.d.ts

@@ -1,8 +1,8 @@
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-export declare function fetchAssets(sdk: FieldExtensionSDK, query: string): Promise<{
-    contentTypeName: string;
-    displayTitle: string;
-    id: string;
-    entity: import("@contentful/app-sdk").Asset;
-    thumbnail: string;
-}[]>;
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+export declare function fetchAssets(sdk: FieldExtensionSDK, query: string): Promise<{
+    contentTypeName: string;
+    displayTitle: string;
+    id: string;
+    entity: import("@contentful/app-sdk").Asset;
+    thumbnail: string;
+}[]>;

package/dist/{plugins → types/plugins}/CommandPalette/utils/fetchEntries.d.ts

@@ -1,9 +1,9 @@
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { ContentTypeProps } from 'contentful-management/types';
-export declare function fetchEntries(sdk: FieldExtensionSDK, contentType: ContentTypeProps, query: string): Promise<{
-    contentTypeName: string;
-    displayTitle: string;
-    id: string;
-    description: string;
-    entry: import("@contentful/app-sdk").Entry<unknown>;
-}[]>;
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import { ContentTypeProps } from 'contentful-management/types';
+export declare function fetchEntries(sdk: FieldExtensionSDK, contentType: ContentTypeProps, query: string): Promise<{
+    contentTypeName: string;
+    displayTitle: string;
+    id: string;
+    description: string;
+    entry: import("@contentful/app-sdk").Entry<unknown>;
+}[]>;

package/dist/{plugins → types/plugins}/CommandPalette/utils/insertBlock.d.ts

@@ -1 +1 @@
-export declare function insertBlock(editor: any, nodeType: any, entity: any): void;
+export declare function insertBlock(editor: any, nodeType: any, entity: any): void;

package/dist/{plugins → types/plugins}/CommandPalette/utils/trimLeadingSlash.d.ts

@@ -1,7 +1,7 @@
-/**
- * Trim leading slash character if found. Bails otherwise.
- *
- * @example
- * trimLeadingSlash("/my query") // --> "my query"
- */
-export declare function trimLeadingSlash(text: string): string;
+/**
+ * Trim leading slash character if found. Bails otherwise.
+ *
+ * @example
+ * trimLeadingSlash("/my query") // --> "my query"
+ */
+export declare function trimLeadingSlash(text: string): string;

package/dist/{plugins → types/plugins}/DragAndDrop/index.d.ts

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