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

package/dist/esm/RichTextEditor.js

@@ -1,20 +1,20 @@
-import React, { useCallback, useState, useEffect } from 'react';
+import * as React from 'react';
 import { EntityProvider } from '@contentful/field-editor-reference';
 import { FieldConnector } from '@contentful/field-editor-shared';
 import * as Contentful from '@contentful/rich-text-types';
-import { Plate, getPlateActions } from '@udecode/plate-core';
+import { Plate, PlateProvider } from '@udecode/plate-core';
 import { css, cx } from 'emotion';
 import deepEquals from 'fast-deep-equal';
 import noop from 'lodash/noop';
 import { ContentfulEditorIdProvider, getContentfulEditorId } from './ContentfulEditorProvider';
-import { getPlateSelectors } from './internal/misc';
+import { createOnChangeCallback } from './helpers/callbacks';
+import { toSlateValue } from './helpers/toSlateValue';
 import { getPlugins, disableCorePlugins } from './plugins';
-import { documentToEditorValue, normalizeEditorValue, setEditorContent } from './prepareDocument';
 import { styles } from './RichTextEditor.styles';
 import { SdkProvider } from './SdkProvider';
+import { SyncEditorValue } from './SyncEditorValue';
 import Toolbar from './Toolbar';
 import StickyToolbarWrapper from './Toolbar/components/StickyToolbarWrapper';
-import { useOnValueChanged } from './useOnValueChanged';
 export const ConnectedRichTextEditor = (props)=>{
     const id = getContentfulEditorId(props.sdk);
     const plugins = React.useMemo(()=>getPlugins(props.sdk, props.onAction ?? noop, props.restrictedMarks), [
@@ -22,43 +22,24 @@ export const ConnectedRichTextEditor = (props)=>{
         props.onAction,
         props.restrictedMarks
     ]);
-    const [isFirstRender, setIsFirstRender] = useState(true);
-    const [pendingExternalUpdate, setPendingExternalUpdate] = useState(false);
-    const onValueChanged = useOnValueChanged({
-        editorId: id,
-        handler: props.onChange,
-        skip: pendingExternalUpdate || isFirstRender,
-        onSkip: ()=>setPendingExternalUpdate(false)
-    });
-    useEffect(()=>{
-        setIsFirstRender(false);
-        const editor = getPlateSelectors(id).editor();
-        if (!editor) {
-            return;
-        }
-        setPendingExternalUpdate(true);
-        setEditorContent(editor, documentToEditorValue(props.value));
+    const handleChange = props.onChange;
+    const isFirstRender = React.useRef(true);
+    const value = toSlateValue(props.value);
+    const onChange = React.useMemo(()=>createOnChangeCallback((document)=>{
+            if (!isFirstRender.current && handleChange) {
+                handleChange(document);
+            }
+        }), [
+        handleChange
+    ]);
+    const firstInteractionHandler = React.useCallback(()=>{
+        isFirstRender.current = false;
     }, [
-        props.value,
-        id
+        isFirstRender
     ]);
     const classNames = cx(styles.editor, props.minHeight !== undefined ? css({
         minHeight: props.minHeight
     }) : undefined, props.isDisabled ? styles.disabled : styles.enabled, props.isToolbarHidden && styles.hiddenToolbar);
-    useEffect(()=>{
-        if (!isFirstRender) {
-            return;
-        }
-        getPlateActions(id).value(normalizeEditorValue(documentToEditorValue(props.value), {
-            plugins,
-            disableCorePlugins
-        }));
-    }, [
-        isFirstRender,
-        plugins,
-        id,
-        props.value
-    ]);
     return React.createElement(SdkProvider, {
         sdk: props.sdk
     }, React.createElement(ContentfulEditorIdProvider, {
@@ -66,25 +47,33 @@ export const ConnectedRichTextEditor = (props)=>{
     }, React.createElement("div", {
         className: styles.root,
         "data-test-id": "rich-text-editor"
-    }, React.createElement(Plate, {
+    }, React.createElement(PlateProvider, {
         id: id,
+        initialValue: value,
+        normalizeInitialValue: true,
         plugins: plugins,
         disableCorePlugins: disableCorePlugins,
+        onChange: onChange
+    }, !props.isToolbarHidden && React.createElement(StickyToolbarWrapper, {
+        isDisabled: props.isDisabled
+    }, React.createElement(Toolbar, {
+        isDisabled: props.isDisabled
+    })), React.createElement(SyncEditorValue, {
+        incomingValue: value
+    }), React.createElement(Plate, {
+        id: id,
         editableProps: {
             className: classNames,
-            readOnly: props.isDisabled
-        },
-        onChange: onValueChanged,
-        firstChildren: !props.isToolbarHidden && React.createElement(StickyToolbarWrapper, {
-            isDisabled: props.isDisabled
-        }, React.createElement(Toolbar, {
-            isDisabled: props.isDisabled
-        }))
-    }))));
+            readOnly: props.isDisabled,
+            onKeyDown: firstInteractionHandler,
+            onChange: firstInteractionHandler,
+            onClick: firstInteractionHandler
+        }
+    })))));
 };
 const RichTextEditor = (props)=>{
     const { sdk , isInitiallyDisabled , onAction , restrictedMarks , ...otherProps } = props;
-    const isEmptyValue = useCallback((value)=>!value || deepEquals(value, Contentful.EMPTY_DOCUMENT), []);
+    const isEmptyValue = React.useCallback((value)=>!value || deepEquals(value, Contentful.EMPTY_DOCUMENT), []);
     const id = getContentfulEditorId(props.sdk);
     return React.createElement(EntityProvider, {
         sdk: sdk

package/dist/esm/SyncEditorValue.js

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import equal from 'fast-deep-equal';
+import { usePlateSelectors } from './internal/hooks';
+import { withoutNormalizing } from './internal/misc';
+import { isNode, getEndPoint } from './internal/queries';
+import { select } from './internal/transforms';
+const setEditorContent = (editor, nodes)=>{
+    withoutNormalizing(editor, ()=>{
+        const children = [
+            ...editor.children
+        ];
+        children.forEach((node)=>editor.apply({
+                type: 'remove_node',
+                path: [
+                    0
+                ],
+                node
+            }));
+        if (nodes) {
+            const nodesArray = isNode(nodes) ? [
+                nodes
+            ] : nodes;
+            nodesArray.forEach((node, i)=>{
+                editor.apply({
+                    type: 'insert_node',
+                    path: [
+                        i
+                    ],
+                    node
+                });
+            });
+        }
+        const point = getEndPoint(editor, []);
+        if (point) {
+            select(editor, point);
+        }
+    });
+};
+export const SyncEditorValue = ({ incomingValue  })=>{
+    const editor = usePlateSelectors().editor();
+    const lastIncomingValue = React.useRef(incomingValue);
+    React.useEffect(()=>{
+        if (equal(lastIncomingValue.current, incomingValue)) {
+            return;
+        }
+        lastIncomingValue.current = incomingValue;
+        setEditorContent(editor, incomingValue);
+    }, [
+        editor,
+        incomingValue
+    ]);
+    return null;
+};

package/dist/esm/helpers/callbacks.js

@@ -0,0 +1,20 @@
+import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
+import equal from 'fast-deep-equal';
+import debounce from 'lodash/debounce';
+import schema from '../constants/Schema';
+import { removeInternalMarks } from './removeInternalMarks';
+export const createOnChangeCallback = (handler)=>{
+    let cache = null;
+    return debounce((document)=>{
+        if (equal(document, cache)) {
+            return;
+        }
+        cache = document;
+        const doc = removeInternalMarks(toContentfulDocument({
+            document: document,
+            schema: schema
+        }));
+        const cleanedDocument = removeInternalMarks(doc);
+        handler?.(cleanedDocument);
+    }, 500);
+};

package/dist/{cjs/helpers/sanitizeIncomingSlateDoc.js → esm/helpers/toSlateValue.js}

@@ -1,13 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "sanitizeIncomingSlateDoc", {
-    enumerable: true,
-    get: function() {
-        return sanitizeIncomingSlateDoc;
-    }
-});
+import { toSlatejsDocument } from '@contentful/contentful-slatejs-adapter';
+import { EMPTY_DOCUMENT } from '@contentful/rich-text-types';
+import schema from '../constants/Schema';
 const isTextElement = (node)=>'text' in node;
 function sanitizeIncomingSlateDoc(nodes = []) {
     return nodes.map((node)=>{
@@ -31,3 +24,13 @@ function sanitizeIncomingSlateDoc(nodes = []) {
         };
     });
 }
+export const toSlateValue = (doc)=>{
+    const hasContent = (doc)=>{
+        return (doc?.content || []).length > 0;
+    };
+    const slateDoc = toSlatejsDocument({
+        document: doc && hasContent(doc) ? doc : EMPTY_DOCUMENT,
+        schema
+    });
+    return sanitizeIncomingSlateDoc(slateDoc);
+};

package/dist/esm/internal/hooks.js

@@ -1,5 +1,12 @@
 import * as p from '@udecode/plate-core';
 import * as sr from 'slate-react';
 export const useReadOnly = sr.useReadOnly;
-export const usePlateEditorRef = p.usePlateEditorRef;
-export const usePlateEditorState = p.usePlateEditorState;
+export const usePlateEditorRef = (id)=>{
+    return p.usePlateEditorRef(id);
+};
+export const usePlateEditorState = (id)=>{
+    return p.usePlateEditorState(id);
+};
+export const usePlateSelectors = (id)=>{
+    return p.usePlateSelectors(id);
+};

package/dist/esm/internal/misc.js

@@ -23,6 +23,3 @@ export const fromDOMPoint = (editor, domPoint, opts = {
 export const mockPlugin = (plugin)=>{
     return p.mockPlugin(plugin);
 };
-export const getPlateSelectors = (id)=>{
-    return p.getPlateSelectors(id);
-};

package/dist/esm/plugins/Table/onKeyDownTable.js

@@ -2,7 +2,7 @@ import { BLOCKS } from '@contentful/rich-text-types';
 import { getTableEntries, onKeyDownTable as defaultKeyDownTable } from '@udecode/plate-table';
 import { insertEmptyParagraph } from '../../helpers/editor';
 import { blurEditor } from '../../internal/misc';
-import { getAboveNode, isLastChildPath } from '../../internal/queries';
+import { getAboveNode, isLastChildPath, getText, isFirstChild } from '../../internal/queries';
 import { addRowBelow } from './actions';
 export const onKeyDownTable = (editor, plugin)=>{
     const defaultHandler = defaultKeyDownTable(editor, plugin);
@@ -30,6 +30,20 @@ export const onKeyDownTable = (editor, plugin)=>{
                 return;
             }
         }
+        if (event.key === 'Backspace') {
+            const entry = getTableEntries(editor, {});
+            if (entry) {
+                const { table , row , cell  } = entry;
+                const cellText = getText(editor, cell[1]);
+                const isFirstCell = isFirstChild(row[1]);
+                const isFirstRow = isFirstChild(table[1]);
+                if (isFirstCell && isFirstRow && !cellText) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+            }
+        }
         if (event.key === 'Tab' && !event.shiftKey) {
             event.preventDefault();
             const entry = getTableEntries(editor, {});

package/dist/esm/plugins/Text/__tests__/createTextPlugin.test.js

@@ -7,19 +7,9 @@ describe('delete backward', ()=>{
             expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p", jsx("cursor", null))))
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            title: 'does not delete the very first paragraph',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text")),
-            expected: jsx("hp", null, jsx("cursor", null), "text")
-        },
-        {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
-            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1")))),
-            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1")))
-        },
-        {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
-            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hquote", null, jsx("hp", null, "p1"))),
-            expected: jsx("hquote", null, jsx("hp", null, jsx("cursor", null), "p1"))
+            expected: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text"))
         }
     ];
     const render = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
@@ -44,17 +34,17 @@ describe('delete forward', ()=>{
             expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "1")))
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            title: 'deletes the first paragraph when followed by another paragraph',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text")),
             expected: jsx("hp", null, jsx("cursor", null), "text")
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
+            title: 'deletes the first paragraph when followed by li',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1")))),
             expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1")))
         },
         {
-            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
+            title: 'deletes the first paragraph when followed by a blockquote',
             input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hquote", null, jsx("hp", null, "p1"))),
             expected: jsx("hquote", null, jsx("hp", null, jsx("cursor", null), "p1"))
         }

package/dist/esm/plugins/index.js

@@ -1,4 +1,3 @@
-import { createDeserializeAstPlugin, createDeserializeHtmlPlugin } from '@udecode/plate-core';
 import { createDeserializeDocxPlugin } from '@udecode/plate-serializer-docx';
 import { createSoftBreakPlugin, createExitBreakPlugin, createResetNodePlugin } from './Break';
 import { createCommandPalettePlugin } from './CommandPalette';
@@ -23,8 +22,6 @@ import { createTrackingPlugin } from './Tracking';
 import { createTrailingParagraphPlugin } from './TrailingParagraph';
 import { createVoidsPlugin } from './Voids';
 export const getPlugins = (sdk, onAction, restrictedMarks)=>[
-        createDeserializeHtmlPlugin(),
-        createDeserializeAstPlugin(),
         createDeserializeDocxPlugin(),
         createTrackingPlugin(onAction),
         createDragAndDropPlugin(),
@@ -54,7 +51,5 @@ export const getPlugins = (sdk, onAction, restrictedMarks)=>[
         createNormalizerPlugin()
     ];
 export const disableCorePlugins = {
-    deserializeAst: true,
-    deserializeHtml: true,
     eventEditor: true
 };

package/dist/esm/plugins/shared/FetchingWrappedResourceCard.js

@@ -1,20 +1,13 @@
 import * as React from 'react';
 import { EntryCard } from '@contentful/f36-components';
-import { MissingEntityCard, WrappedEntryCard, useResource } from '@contentful/field-editor-reference';
+import { ResourceEntityErrorCard, WrappedEntryCard, useResource } from '@contentful/field-editor-reference';
 import areEqual from 'fast-deep-equal';
 const InternalEntryCard = React.memo((props)=>{
-    if (props.status === 'loading') {
+    if (props.data === undefined || props.status === 'loading') {
         return React.createElement(EntryCard, {
             isLoading: true
         });
     }
-    if (!props.data || props.status === 'error') {
-        return React.createElement(MissingEntityCard, {
-            entityType: "Entry",
-            isDisabled: props.isDisabled,
-            onRemove: props.onRemove
-        });
-    }
     const { contentType , resource: entry , space  } = props.data;
     return React.createElement(WrappedEntryCard, {
         size: "default",
@@ -35,7 +28,7 @@ const InternalEntryCard = React.memo((props)=>{
 InternalEntryCard.displayName = 'ReferenceCard';
 export const FetchingWrappedResourceCard = (props)=>{
     const { link , onEntityFetchComplete  } = props;
-    const { data , status  } = useResource(link.linkType, link.urn);
+    const { data , status , error  } = useResource(link.linkType, link.urn);
     React.useEffect(()=>{
         if (status === 'success') {
             onEntityFetchComplete?.();
@@ -44,6 +37,15 @@ export const FetchingWrappedResourceCard = (props)=>{
         onEntityFetchComplete,
         status
     ]);
+    if (status === 'error') {
+        return React.createElement(ResourceEntityErrorCard, {
+            error: error,
+            linkType: link.linkType,
+            isSelected: props.isSelected,
+            isDisabled: props.isDisabled,
+            onRemove: props.onRemove
+        });
+    }
     return React.createElement(InternalEntryCard, {
         data: data,
         status: status,

package/dist/esm/plugins/shared/__tests__/FetchingWrappedResourceCard.test.js

@@ -0,0 +1,98 @@
+import * as React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+import { EntityProvider } from '@contentful/field-editor-reference';
+import { createFakeCMAAdapter } from '@contentful/field-editor-test-utils';
+import { configure, render, waitFor } from '@testing-library/react';
+import publishedCT from '../__fixtures__/published_content_type.json';
+import publishedEntry from '../__fixtures__/published_entry.json';
+import space from '../__fixtures__/space.json';
+import { FetchingWrappedResourceCard } from '../FetchingWrappedResourceCard';
+configure({
+    testIdAttribute: 'data-test-id'
+});
+let sdk;
+const resolvableEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/linked-entry-urn';
+const unknownEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/unknown-entry-urn';
+beforeEach(()=>{
+    sdk = {
+        locales: {
+            default: 'en-US'
+        },
+        cmaAdapter: createFakeCMAAdapter({
+            ContentType: {
+                get: jest.fn().mockReturnValue(publishedCT)
+            },
+            Entry: {
+                get: jest.fn().mockImplementation(({ entryId  })=>{
+                    if (entryId === 'linked-entry-urn') {
+                        return Promise.resolve(publishedEntry);
+                    }
+                    return Promise.reject(new Error());
+                })
+            },
+            Locale: {
+                getMany: jest.fn().mockResolvedValue({
+                    items: [
+                        {
+                            default: true,
+                            code: 'en'
+                        }
+                    ]
+                })
+            },
+            ScheduledAction: {
+                getMany: jest.fn().mockResolvedValue({
+                    items: [],
+                    total: 0
+                })
+            },
+            Space: {
+                get: jest.fn().mockResolvedValue(space)
+            }
+        }),
+        space: {
+            onEntityChanged: jest.fn()
+        },
+        navigator: {},
+        ids: {
+            space: 'space-id',
+            environment: 'environment-id'
+        }
+    };
+});
+function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
+    return render(React.createElement(EntityProvider, {
+        sdk: sdk
+    }, React.createElement(FetchingWrappedResourceCard, {
+        isDisabled: false,
+        isSelected: false,
+        sdk: sdk,
+        link: {
+            type: 'ResourceLink',
+            linkType: linkType,
+            urn: entryUrn
+        }
+    })));
+}
+test('renders entry card', async ()=>{
+    const { getByTestId , getByText  } = renderResourceCard();
+    await waitFor(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
+    expect(getByText(publishedEntry.fields.exField.en)).toBeDefined();
+    expect(getByText(space.name)).toBeDefined();
+});
+test('renders skeleton when no data is provided', ()=>{
+    const { getByTestId  } = renderResourceCard();
+    expect(getByTestId('cf-ui-skeleton-form')).toBeDefined();
+});
+test('renders unsupported entity card when unsupported link is passed', async ()=>{
+    const { getByText  } = renderResourceCard({
+        linkType: 'Contentful:UnsupportedLink'
+    });
+    await waitFor(()=>expect(getByText('Resource type Contentful:UnsupportedLink is currently not supported')).toBeDefined());
+});
+test('renders missing entity card when unknown error is returned', async ()=>{
+    const { getByTestId  } = renderResourceCard({
+        entryUrn: unknownEntryUrn
+    });
+    await waitFor(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
+});

package/dist/types/ContentfulEditorProvider.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="react" />
 import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { PlateEditor } from './internal/types';
 export declare function getContentfulEditorId(sdk: FieldExtensionSDK): string;
 export declare const editorContext: import("react").Context<string>;
 export declare const ContentfulEditorIdProvider: import("react").Provider<string>;
 export declare function useContentfulEditorId(id?: string): string;
-export declare function useContentfulEditor(id?: string): PlateEditor | null;
-export declare function useContentfulEditorRef(id?: string): PlateEditor | null;
+export declare function useContentfulEditor(id?: string): import("./internal").PlateEditor;
+export declare function useContentfulEditorRef(id?: string): import("./internal").PlateEditor;

package/dist/types/RichTextEditor.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import * as React from 'react';
 import { FieldExtensionSDK } from '@contentful/app-sdk';
 import * as Contentful from '@contentful/rich-text-types';
 import { RichTextTrackingActionHandler } from './plugins/Tracking';
@@ -6,7 +6,7 @@ type ConnectedProps = {
     sdk: FieldExtensionSDK;
     onAction?: RichTextTrackingActionHandler;
     minHeight?: string | number;
-    value?: object;
+    value?: Contentful.Document;
     isDisabled?: boolean;
     onChange?: (doc: Contentful.Document) => unknown;
     isToolbarHidden?: boolean;

package/dist/types/SyncEditorValue.d.ts

@@ -0,0 +1,13 @@
+import { Value } from './internal/types';
+export type SyncEditorStateProps = {
+    incomingValue?: Value;
+};
+/**
+ * A void component that's responsible for keeping the editor
+ * state in sync with incoming changes (aka. external updates)
+ *
+ * This component is a hack to workaround the limitation of Plate v17+
+ * where we can no longer access the editor instance outside the Plate
+ * provider.
+ */
+export declare const SyncEditorValue: ({ incomingValue }: SyncEditorStateProps) => null;

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

@@ -0,0 +1,3 @@
+/// <reference types="lodash" />
+import { Document } from '@contentful/rich-text-types';
+export declare const createOnChangeCallback: (handler?: ((value: Document) => void) | undefined) => import("lodash").DebouncedFunc<(document: unknown) => void>;

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

@@ -0,0 +1,7 @@
+import { Document } from '@contentful/rich-text-types';
+import { Element } from '../internal/types';
+/**
+ * Converts a Contentful rich text document to the corresponding slate editor
+ * value
+ */
+export declare const toSlateValue: (doc?: Document) => Element[];

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

@@ -1,4 +1,6 @@
 import * as p from '@udecode/plate-core';
+import { PlateEditor, Value } from './types';
 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;
+export declare const usePlateEditorRef: (id?: string) => PlateEditor;
+export declare const usePlateEditorState: (id?: string) => PlateEditor;
+export declare const usePlateSelectors: (id?: string) => p.GetRecord<p.PlateStoreState<Value, PlateEditor>>;

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

@@ -1,6 +1,5 @@
 /// <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'> & {
@@ -23,6 +22,8 @@ export declare const createPlateEditor: (options?: CreatePlateEditorOptions) =>
     plugins: p.WithPlatePlugin<{}, Value, p.PlateEditor<Value>>[];
     pluginsByKey: Record<string, p.WithPlatePlugin<{}, Value, p.PlateEditor<Value>>>;
     prevSelection: s.BaseRange | null;
+    blockFactory: (node?: Partial<p.TElement> | undefined, path?: s.Path | undefined) => p.TElement;
+    childrenFactory: () => Value;
     currentKeyboardEvent: import("react").KeyboardEvent<Element> | null;
 };
 export declare const withoutNormalizing: (editor: PlateEditor, fn: () => boolean | void) => boolean;
@@ -34,4 +35,3 @@ export declare const fromDOMPoint: (editor: PlateEditor, domPoint: [Node, number
     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/types/plugins/shared/__tests__/FetchingWrappedResourceCard.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/types/test-utils/createEditor.d.ts

@@ -25,6 +25,8 @@ export declare const createTestEditor: (options: {
         plugins: import("@udecode/plate-core").WithPlatePlugin<{}, Value, import("@udecode/plate-core").PlateEditor<Value>>[];
         pluginsByKey: Record<string, import("@udecode/plate-core").WithPlatePlugin<{}, Value, import("@udecode/plate-core").PlateEditor<Value>>>;
         prevSelection: import("slate").BaseRange | null;
+        blockFactory: (node?: Partial<import("@udecode/plate-core").TElement> | undefined, path?: import("slate").Path | undefined) => import("@udecode/plate-core").TElement;
+        childrenFactory: () => Value;
         currentKeyboardEvent: import("react").KeyboardEvent<Element> | null;
     };
     normalize: () => void;