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

package/dist/cjs/prepareDocument.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hasContent: function() {
+        return hasContent;
+    },
+    setEditorContent: function() {
+        return setEditorContent;
+    },
+    documentToEditorValue: function() {
+        return documentToEditorValue;
+    },
+    normalizeEditorValue: function() {
+        return normalizeEditorValue;
+    }
+});
+const _contentfulslatejsadapter = require("@contentful/contentful-slatejs-adapter");
+const _richtexttypes = require("@contentful/rich-text-types");
+const _Schema = _interop_require_default(require("./constants/Schema"));
+const _sanitizeIncomingSlateDoc = require("./helpers/sanitizeIncomingSlateDoc");
+const _internal = require("./internal");
+const _queries = require("./internal/queries");
+const _transforms = require("./internal/transforms");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const hasContent = (doc)=>{
+    return (doc?.content || []).length > 0;
+};
+const setEditorContent = (editor, nodes)=>{
+    (0, _internal.withoutNormalizing)(editor, ()=>{
+        const children = [
+            ...editor.children
+        ];
+        children.forEach((node)=>editor.apply({
+                type: 'remove_node',
+                path: [
+                    0
+                ],
+                node
+            }));
+        if (nodes) {
+            const nodesArray = (0, _queries.isNode)(nodes) ? [
+                nodes
+            ] : nodes;
+            nodesArray.forEach((node, i)=>{
+                editor.apply({
+                    type: 'insert_node',
+                    path: [
+                        i
+                    ],
+                    node
+                });
+            });
+        }
+        const point = (0, _queries.getEndPoint)(editor, []);
+        if (point) {
+            (0, _transforms.select)(editor, point);
+        }
+    });
+};
+const documentToEditorValue = (doc)=>{
+    const slateDoc = (0, _contentfulslatejsadapter.toSlatejsDocument)({
+        document: hasContent(doc) ? doc : _richtexttypes.EMPTY_DOCUMENT,
+        schema: _Schema.default
+    });
+    return (0, _sanitizeIncomingSlateDoc.sanitizeIncomingSlateDoc)(slateDoc);
+};
+const normalizeEditorValue = (value, options)=>{
+    const editor = (0, _internal.createPlateEditor)(options);
+    editor.children = value;
+    (0, _transforms.normalize)(editor, {
+        force: true
+    });
+    return editor.children;
+};

package/dist/cjs/test-utils/assertOutput.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "assertOutput", {
+    enumerable: true,
+    get: function() {
+        return assertOutput;
+    }
+});
+const _internal = require("../internal");
+const _createEditor = require("./createEditor");
+const _setEmptyDataAttribute = require("./setEmptyDataAttribute");
+const assertOutput = (options)=>{
+    const editor = options.editor ?? (0, _createEditor.createTestEditor)({
+        input: options.input
+    }).editor;
+    (0, _internal.normalize)(editor);
+    (0, _setEmptyDataAttribute.setEmptyDataAttribute)(editor);
+    if (options.log) {
+        console.log(JSON.stringify({
+            expected: options.expected,
+            actual: editor.children,
+            actualSelection: editor.selection
+        }, null, 2));
+    }
+    expect(editor.children).toEqual(options.expected.children);
+    if (options.expected.selection !== null) {
+        expect(editor.selection).toEqual(options.expected.selection);
+    }
+};

package/dist/cjs/test-utils/createEditor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTestEditor", {
+    enumerable: true,
+    get: function() {
+        return createTestEditor;
+    }
+});
+const _platecore = require("@udecode/plate-core");
+const _internal = require("../internal");
+const _plugins = require("../plugins");
+const _randomId = require("./randomId");
+const createTestEditor = (options)=>{
+    const trackingHandler = options.trackingHandler ?? jest.fn();
+    const sdk = options.sdk ?? {
+        field: {
+            validation: []
+        }
+    };
+    const editor = (0, _platecore.createPlateEditor)({
+        id: (0, _randomId.randomId)('editor'),
+        editor: options.input,
+        plugins: options.plugins || (0, _plugins.getPlugins)(sdk, trackingHandler)
+    });
+    return {
+        editor,
+        normalize: ()=>(0, _internal.normalize)(editor)
+    };
+};

package/dist/cjs/test-utils/hyperscript.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/test-utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./jsx"), exports);
+_export_star(require("./createEditor"), exports);
+_export_star(require("./mockPlugin"), exports);
+_export_star(require("./assertOutput"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/test-utils/jsx.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "jsx", {
+    enumerable: true,
+    get: function() {
+        return jsx;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetestutils = require("@udecode/plate-test-utils");
+const _slatehyperscript = require("slate-hyperscript");
+const voidChildren = [
+    {
+        text: ''
+    }
+];
+const createCode = (_, attrs, children)=>{
+    return (0, _platetestutils.createText)('text', {
+        code: true,
+        ...attrs
+    }, children);
+};
+const createSysLink = (linkType, id)=>({
+        sys: {
+            id,
+            type: 'Link',
+            linkType
+        }
+    });
+const createHyperlink = (_, attrs, children)=>{
+    const data = {};
+    let type = _richtexttypes.INLINES.HYPERLINK;
+    if (attrs.uri) {
+        data.uri = attrs.uri;
+        type = _richtexttypes.INLINES.HYPERLINK;
+    }
+    if (attrs.asset) {
+        type = _richtexttypes.INLINES.ASSET_HYPERLINK;
+        data.target = createSysLink('Asset', attrs.asset);
+    }
+    if (attrs.entry) {
+        type = _richtexttypes.INLINES.ENTRY_HYPERLINK;
+        data.target = createSysLink('Entry', attrs.entry);
+    }
+    children = children.map((child)=>typeof child === 'string' ? {
+            text: child
+        } : child);
+    return {
+        type,
+        data,
+        children
+    };
+};
+const createInline = (_, attrs, children)=>{
+    return {
+        type: _richtexttypes.INLINES.EMBEDDED_ENTRY,
+        data: {
+            target: createSysLink('Entry', attrs.id)
+        },
+        isVoid: true,
+        children: children.length > 0 ? children : voidChildren
+    };
+};
+const createEmbeddedBlock = (_, attrs, children)=>{
+    return {
+        type: attrs.type === 'Entry' ? _richtexttypes.BLOCKS.EMBEDDED_ENTRY : _richtexttypes.BLOCKS.EMBEDDED_ASSET,
+        data: {
+            target: createSysLink(attrs.type, attrs.id)
+        },
+        isVoid: true,
+        children: children.length > 0 ? children : voidChildren
+    };
+};
+const createHR = (_, __, children)=>{
+    return {
+        type: _richtexttypes.BLOCKS.HR,
+        data: {},
+        isVoid: true,
+        children: children.length > 0 ? children : voidChildren
+    };
+};
+const createFragment = (_, __, children)=>{
+    return children;
+};
+const jsx = (0, _slatehyperscript.createHyperscript)({
+    elements: {
+        hquote: {
+            type: _richtexttypes.BLOCKS.QUOTE,
+            data: {}
+        },
+        hh1: {
+            type: _richtexttypes.BLOCKS.HEADING_1,
+            data: {}
+        },
+        hh2: {
+            type: _richtexttypes.BLOCKS.HEADING_2,
+            data: {}
+        },
+        hh3: {
+            type: _richtexttypes.BLOCKS.HEADING_3,
+            data: {}
+        },
+        hh4: {
+            type: _richtexttypes.BLOCKS.HEADING_4,
+            data: {}
+        },
+        hh5: {
+            type: _richtexttypes.BLOCKS.HEADING_5,
+            data: {}
+        },
+        hh6: {
+            type: _richtexttypes.BLOCKS.HEADING_6,
+            data: {}
+        },
+        hli: {
+            type: _richtexttypes.BLOCKS.LIST_ITEM,
+            data: {}
+        },
+        hol: {
+            type: _richtexttypes.BLOCKS.OL_LIST,
+            data: {}
+        },
+        hp: {
+            type: _richtexttypes.BLOCKS.PARAGRAPH,
+            data: {}
+        },
+        htable: {
+            type: _richtexttypes.BLOCKS.TABLE,
+            data: {}
+        },
+        htd: {
+            type: _richtexttypes.BLOCKS.TABLE_CELL,
+            data: {}
+        },
+        hth: {
+            type: _richtexttypes.BLOCKS.TABLE_HEADER_CELL,
+            data: {}
+        },
+        htr: {
+            type: _richtexttypes.BLOCKS.TABLE_ROW,
+            data: {}
+        },
+        hul: {
+            type: _richtexttypes.BLOCKS.UL_LIST,
+            data: {}
+        }
+    },
+    creators: {
+        hlink: createHyperlink,
+        hhr: createHR,
+        htext: _platetestutils.createText,
+        hcode: createCode,
+        hinline: createInline,
+        hembed: createEmbeddedBlock,
+        hfragment: createFragment
+    }
+});

package/dist/cjs/test-utils/mockPlugin.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mockPlugin", {
+    enumerable: true,
+    get: function() {
+        return mockPlugin;
+    }
+});
+const _platecore = require("@udecode/plate-core");
+const _randomId = require("./randomId");
+const mockPlugin = (p)=>(0, _platecore.mockPlugin)({
+        ...p,
+        key: p.key || (0, _randomId.randomId)('plugin')
+    });

package/dist/cjs/test-utils/randomId.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "randomId", {
+    enumerable: true,
+    get: function() {
+        return randomId;
+    }
+});
+const randomId = (prefix = '')=>{
+    return `${prefix}-${(Math.random() + 1).toString(36).substring(10)}`;
+};

package/dist/cjs/test-utils/setEmptyDataAttribute.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "setEmptyDataAttribute", {
+    enumerable: true,
+    get: function() {
+        return setEmptyDataAttribute;
+    }
+});
+const _platecore = require("@udecode/plate-core");
+const _slate = require("slate");
+const setEmptyDataAttribute = (root)=>{
+    (0, _platecore.setNodes)(root, {
+        data: {}
+    }, {
+        at: [],
+        match: (node)=>_slate.Element.isElement(node) && !node.data,
+        mode: 'all'
+    });
+};

package/dist/cjs/test-utils/validation.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateRichTextDocument", {
+    enumerable: true,
+    get: function() {
+        return validateRichTextDocument;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _schemas = require("@contentful/rich-text-types/dist/schemas");
+const _ajv = _interop_require_default(require("ajv"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ajv = new _ajv.default({
+    allErrors: true,
+    verbose: true
+});
+function validateRichTextDocument(document) {
+    const validateRootNode = getValidator(_richtexttypes.BLOCKS.DOCUMENT);
+    const rootNodeIsValid = validateRootNode(removeGrandChildNodes(document));
+    const errors = [];
+    if (rootNodeIsValid) {
+        validateChildNodes(document, [
+            'content'
+        ], errors);
+    } else {
+        buildSchemaErrors(validateRootNode, [], errors);
+    }
+    return errors;
+}
+function validateChildNodes(node, path, errors) {
+    for(let i = 0; i < node.content.length; i++){
+        validateNode(node.content[i], [
+            ...path,
+            i
+        ], errors);
+    }
+}
+function validateNode(node, path, errors) {
+    const validateSchema = getValidator(node.nodeType);
+    const isValid = validateSchema(removeGrandChildNodes(resetChildNodes(node)));
+    if (!isValid) {
+        buildSchemaErrors(validateSchema, path, errors);
+        return;
+    }
+    if (!isLeafNode(node)) {
+        validateChildNodes(node, [
+            ...path,
+            'content'
+        ], errors);
+    }
+}
+function getValidator(nodeType) {
+    const schema = (0, _schemas.getSchemaWithNodeType)(nodeType);
+    const validate = ajv.compile(schema);
+    const validator = (data)=>{
+        validate(data);
+        validator.errors = removeGrandChildrenMinItemsErrors(validate.errors ?? []);
+        return validator.errors.length === 0;
+    };
+    return validator;
+}
+function buildSchemaErrors(validateSchema, _, errors) {
+    const schemaErrors = validateSchema.errors;
+    const constraintError = schemaErrors.find((e)=>e.keyword === 'enum' || e.keyword === 'anyOf');
+    if (constraintError) {
+        errors.push(constraintError);
+        return;
+    }
+    errors.push(...schemaErrors);
+}
+function resetChildNodes(node) {
+    const { content  } = node;
+    if (isLeafNode(node)) {
+        return node;
+    }
+    return Object.assign({}, node, {
+        content: content.map(resetNode)
+    });
+}
+function resetNode(node) {
+    const { nodeType  } = node;
+    if (_richtexttypes.helpers.isText(node)) {
+        return {
+            nodeType,
+            data: {},
+            value: '',
+            marks: []
+        };
+    }
+    return {
+        nodeType,
+        data: {},
+        content: []
+    };
+}
+function removeGrandChildNodes(node) {
+    const { content  } = node;
+    if (isLeafNode(node)) {
+        return node;
+    }
+    return Object.assign({}, node, {
+        content: content.map(removeChildNodes)
+    });
+}
+function removeChildNodes(node) {
+    if (_richtexttypes.helpers.isText(node)) {
+        return node;
+    }
+    return Object.assign({}, node, {
+        content: []
+    });
+}
+function isLeafNode(node) {
+    return _richtexttypes.helpers.isText(node) || !Array.isArray(node.content);
+}
+function removeGrandChildrenMinItemsErrors(errors) {
+    return errors.filter((error)=>{
+        const level = error.instancePath.split('/').length;
+        return !(level > 3 && error.keyword === 'minItems');
+    });
+}

package/dist/cjs/useOnValueChanged.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useOnValueChanged", {
+    enumerable: true,
+    get: function() {
+        return useOnValueChanged;
+    }
+});
+const _react = require("react");
+const _contentfulslatejsadapter = require("@contentful/contentful-slatejs-adapter");
+const _platecore = require("@udecode/plate-core");
+const _debounce = _interop_require_default(require("lodash/debounce"));
+const _Schema = _interop_require_default(require("./constants/Schema"));
+const _removeInternalMarks = require("./helpers/removeInternalMarks");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const isRelevantOperation = (op)=>{
+    if (op.type === 'set_selection') {
+        return false;
+    }
+    return true;
+};
+const useOnValueChanged = ({ editorId , handler , skip , onSkip  })=>{
+    const onChange = (0, _react.useMemo)(()=>(0, _debounce.default)((document)=>{
+            const contentfulDocument = (0, _contentfulslatejsadapter.toContentfulDocument)({
+                document,
+                schema: _Schema.default
+            });
+            const cleanedDocument = (0, _removeInternalMarks.removeInternalMarks)(contentfulDocument);
+            handler?.(cleanedDocument);
+        }, 500), [
+        handler
+    ]);
+    return (0, _react.useCallback)((value)=>{
+        const editor = (0, _platecore.getPlateSelectors)(editorId).editor();
+        if (!editor) {
+            throw new Error('Editor change callback called but editor not defined. Editor id: ' + editorId);
+        }
+        const operations = editor?.operations.filter(isRelevantOperation);
+        if (operations.length > 0) {
+            if (skip) {
+                onSkip?.();
+                return;
+            }
+            onChange(value);
+        }
+    }, [
+        editorId,
+        onChange,
+        skip,
+        onSkip
+    ]);
+};

package/dist/esm/ContentfulEditorProvider.js

@@ -0,0 +1,29 @@
+import { createContext, useContext } from 'react';
+import { usePlateEditorRef, usePlateEditorState } from './internal/hooks';
+export function getContentfulEditorId(sdk) {
+    const { entry , field  } = sdk;
+    const sys = entry.getSys();
+    return `rich-text-editor-${sys.id}-${field.id}-${field.locale}`;
+}
+export const editorContext = createContext('');
+export const ContentfulEditorIdProvider = editorContext.Provider;
+export function useContentfulEditorId(id) {
+    const contextId = useContext(editorContext);
+    if (id) {
+        return id;
+    }
+    if (!contextId) {
+        throw new Error('could not find editor id. Please ensure the component is wrapped in <ContentfulEditorIdProvider> ');
+    }
+    return contextId;
+}
+export function useContentfulEditor(id) {
+    const editorId = useContentfulEditorId(id);
+    const editor = usePlateEditorState(editorId);
+    return editor;
+}
+export function useContentfulEditorRef(id) {
+    const editorId = useContentfulEditorId(id);
+    const editor = usePlateEditorRef(editorId);
+    return editor;
+}