@contentful/field-editor-rich-text 3.4.22 → 3.6.0

package/dist/types/helpers/newResourceEntitySelectorConfigFromRichTextField.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a config for the entity selector based on a given rich text field and a
+ * rich text node type that the entity should be picked for. Takes the field
+ * validations for the given node type into account.
+ *
+ * @param {object} field
+ * @param {string} nodeType
+ * @returns {object}
+ */
+export default function newResourceEntitySelectorConfigFromRichTextField(field: any, nodeType: any): {
+    allowedResources: {
+        type: "Contentful:Entry";
+        source: string;
+        contentTypes: string[];
+    }[];
+};

package/dist/{helpers → types/helpers}/nodeFactory.d.ts

@@ -1,24 +1,24 @@
-export function document(...content: any[]): {
-    nodeType: string;
-    content: any[];
-    data: {};
-};
-export function block(nodeType: any, data: any, ...content: any[]): {
-    nodeType: any;
-    content: any[];
-    data: any;
-};
-export function inline(nodeType: any, data: any, ...content: any[]): {
-    nodeType: any;
-    content: any[];
-    data: any;
-};
-export function text(value?: string, marks?: any[]): {
-    nodeType: string;
-    value: string;
-    marks: any[];
-    data: {};
-};
-export function mark(type: any): {
-    type: any;
-};
+export function document(...content: any[]): {
+    nodeType: string;
+    content: any[];
+    data: {};
+};
+export function block(nodeType: any, data: any, ...content: any[]): {
+    nodeType: any;
+    content: any[];
+    data: any;
+};
+export function inline(nodeType: any, data: any, ...content: any[]): {
+    nodeType: any;
+    content: any[];
+    data: any;
+};
+export function text(value?: string, marks?: any[]): {
+    nodeType: string;
+    value: string;
+    marks: any[];
+    data: {};
+};
+export function mark(type: any): {
+    type: any;
+};

package/dist/{helpers → types/helpers}/removeInternalMarks.d.ts

@@ -1 +1 @@
-export declare const removeInternalMarks: (document: Record<string, unknown>) => any;
+export declare const removeInternalMarks: (document: Record<string, unknown>) => any;

package/dist/{helpers → types/helpers}/sanitizeIncomingSlateDoc.d.ts

@@ -1,6 +1,6 @@
-import { Node } 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.
- */
-export declare function sanitizeIncomingSlateDoc(nodes?: Node[]): Node[];
+import { Node } 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.
+ */
+export declare function sanitizeIncomingSlateDoc(nodes?: Node[]): Node[];

package/dist/{helpers → types/helpers}/sdkNavigatorSlideIn.d.ts

@@ -1,16 +1,16 @@
-import { NavigatorAPI } from '@contentful/app-sdk';
-/**
- * Allows to observe when the current slide-in navigation slide gets e.g.
- * re-activated after opening another slide on top. This is useful as the sdk
- * does not give full insights into e.g. whether sdk.dialogs.selectSingleEntry()
- * with `withCreate: true` option opens the slide-in navigation to edit the
- * created entry after returning it.
- */
-export declare function watchCurrentSlide(navigator: NavigatorAPI): {
-    status: () => {
-        wasClosed: boolean;
-        isActive: boolean;
-    };
-    onActive: (cb: Function) => (...args: any[]) => void;
-    unwatch: () => void;
-};
+import { NavigatorAPI } from '@contentful/app-sdk';
+/**
+ * Allows to observe when the current slide-in navigation slide gets e.g.
+ * re-activated after opening another slide on top. This is useful as the sdk
+ * does not give full insights into e.g. whether sdk.dialogs.selectSingleEntry()
+ * with `withCreate: true` option opens the slide-in navigation to edit the
+ * created entry after returning it.
+ */
+export declare function watchCurrentSlide(navigator: NavigatorAPI): {
+    status: () => {
+        wasClosed: boolean;
+        isActive: boolean;
+    };
+    onActive: (cb: Function) => (...args: any[]) => void;
+    unwatch: () => void;
+};

package/dist/types/helpers/sdkNavigatorSlideIn.spec.d.ts

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

package/dist/{helpers → types/helpers}/transformers.d.ts

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

package/dist/{helpers → types/helpers}/validations.d.ts

@@ -1,10 +1,10 @@
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { BLOCKS, INLINES } from '@contentful/rich-text-types';
-export declare const VALIDATIONS: {
-    ENABLED_MARKS: string;
-    ENABLED_NODE_TYPES: string;
-};
-export declare const DEFAULT_ENABLED_NODE_TYPES: string[];
-export declare const VALIDATABLE_NODE_TYPES: (BLOCKS | INLINES)[];
-export declare const isNodeTypeEnabled: (field: FieldExtensionSDK['field'], nodeType: any) => boolean;
-export declare const isMarkEnabled: (field: FieldExtensionSDK['field'], mark: any) => boolean;
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import { BLOCKS, INLINES } from '@contentful/rich-text-types';
+export declare const VALIDATIONS: {
+    ENABLED_MARKS: string;
+    ENABLED_NODE_TYPES: string;
+};
+export declare const DEFAULT_ENABLED_NODE_TYPES: string[];
+export declare const VALIDATABLE_NODE_TYPES: (INLINES | BLOCKS)[];
+export declare const isNodeTypeEnabled: (field: FieldExtensionSDK['field'], nodeType: any) => boolean;
+export declare const isMarkEnabled: (field: FieldExtensionSDK['field'], mark: any) => boolean;

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

@@ -1,4 +1,4 @@
-export { default as RichTextEditor } from './RichTextEditor';
-export { ConnectedRichTextEditor } from './RichTextEditor';
-export { openRichTextDialog } from './dialogs/openRichTextDialog';
-export { renderRichTextDialog } from './dialogs/renderRichTextDialog';
+export { default as RichTextEditor } from './RichTextEditor';
+export { ConnectedRichTextEditor } from './RichTextEditor';
+export { openRichTextDialog } from './dialogs/openRichTextDialog';
+export { renderRichTextDialog } from './dialogs/renderRichTextDialog';

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

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

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

@@ -1,4 +1,4 @@
-import * as p from '@udecode/plate-core';
-export declare const useReadOnly: () => boolean;
-export declare const usePlateEditorRef: <V extends p.Value = p.Value, E extends p.PlateEditor<V> = p.PlateEditor<V>>(id?: string | undefined) => E | null;
-export declare const usePlateEditorState: <V extends p.Value = p.Value, E extends p.PlateEditor<V> = p.PlateEditor<V>>(id?: string | undefined) => E | null;
+import * as p from '@udecode/plate-core';
+export declare const useReadOnly: () => boolean;
+export declare const usePlateEditorRef: <V extends p.Value = p.Value, E extends p.PlateEditor<V> = p.PlateEditor<V>>(id?: string | undefined) => E | null;
+export declare const usePlateEditorState: <V extends p.Value = p.Value, E extends p.PlateEditor<V> = p.PlateEditor<V>>(id?: string | undefined) => E | null;

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

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

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

@@ -1,37 +1,37 @@
-/// <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 = Omit<p.CreatePlateEditorOptions<Value, PlateEditor>, 'plugins'> & {
-    plugins?: PlatePlugin[];
-};
-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>, {}>;
+/// <reference types="react" />
+import * as p from '@udecode/plate-core';
+import { StoreApiGet } from '@udecode/zustood';
+import * as s from 'slate';
+import type { Value, PlateEditor, Location, PlatePlugin } from './types';
+export type CreatePlateEditorOptions = Omit<p.CreatePlateEditorOptions<Value, PlateEditor>, 'plugins'> & {
+    plugins?: PlatePlugin[];
+};
+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?: Location) => 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 → 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 {};