@contentful/field-editor-rich-text 4.18.0 → 4.19.1

package/dist/esm/helpers/toSlateDoc.js

@@ -0,0 +1,183 @@
+import { INLINES, BLOCKS, VOID_BLOCKS } from '@contentful/rich-text-types';
+import { Text as TextInterface, Element as ElementInterface } from 'slate';
+import { isText } from '../internal';
+const inlineTypes = new Set(Object.values(INLINES));
+const voidTypes = new Set([
+    ...VOID_BLOCKS,
+    INLINES.EMBEDDED_ENTRY,
+    INLINES.EMBEDDED_RESOURCE
+]);
+function isEmptyHyperlink(node) {
+    if (node.nodeType !== INLINES.HYPERLINK) {
+        return false;
+    }
+    const link = node;
+    if (!link.content?.length) {
+        return true;
+    }
+    return link.content.length === 1 && link.content.at(0)?.value.length === 0;
+}
+function maybeFixUnevenTableRows(el) {
+    const rows = el.children;
+    const rowSize = Math.max(...rows.map((row)=>row.children?.length ?? 0));
+    const fixedRows = [];
+    for (const row of rows){
+        const missingCells = rowSize - row.children.length;
+        if (missingCells === 0) {
+            fixedRows.push(row);
+            continue;
+        }
+        const cellType = row.children.at(-1)?.type === BLOCKS.TABLE_HEADER_CELL ? BLOCKS.TABLE_HEADER_CELL : BLOCKS.TABLE_CELL;
+        const paddedRow = {
+            ...row,
+            children: [
+                ...row.children
+            ]
+        };
+        for(let i = 0; i < missingCells; i++){
+            paddedRow.children.push({
+                type: cellType,
+                data: {},
+                children: [
+                    {
+                        type: BLOCKS.PARAGRAPH,
+                        data: {},
+                        children: [
+                            {
+                                text: ''
+                            }
+                        ],
+                        isVoid: false
+                    }
+                ],
+                isVoid: false
+            });
+        }
+        fixedRows.push(paddedRow);
+    }
+    return fixedRows;
+}
+function transformText(node) {
+    const text = {
+        text: node.value,
+        data: node.data ?? {}
+    };
+    for (const mark of node.marks){
+        text[mark.type] = true;
+    }
+    return text;
+}
+function transformNode(node) {
+    const el = {
+        type: node.nodeType,
+        children: [],
+        data: node.data ?? {},
+        isVoid: voidTypes.has(node.nodeType)
+    };
+    for (const child of node.content){
+        const lastChild = el.children.at(-1);
+        if (child.nodeType === 'text') {
+            const text = transformText(child);
+            if (isText(lastChild) && TextInterface.equals(lastChild, text, {
+                loose: true
+            })) {
+                lastChild.text += child.value;
+            } else {
+                el.children.push(text);
+            }
+            continue;
+        }
+        if (isEmptyHyperlink(child)) {
+            continue;
+        }
+        if (inlineTypes.has(child.nodeType) && !isText(lastChild)) {
+            el.children.push({
+                text: ''
+            });
+        }
+        el.children.push(transformNode(child));
+    }
+    if (el.children.length === 0) {
+        switch(el.type){
+            case BLOCKS.QUOTE:
+            case BLOCKS.LIST_ITEM:
+                el.children.push({
+                    type: BLOCKS.PARAGRAPH,
+                    data: {},
+                    children: [
+                        {
+                            text: ''
+                        }
+                    ],
+                    isVoid: false
+                });
+                break;
+            case BLOCKS.UL_LIST:
+            case BLOCKS.OL_LIST:
+                el.children.push({
+                    type: BLOCKS.LIST_ITEM,
+                    data: {},
+                    children: [
+                        {
+                            type: BLOCKS.PARAGRAPH,
+                            data: {},
+                            children: [
+                                {
+                                    text: ''
+                                }
+                            ],
+                            isVoid: false
+                        }
+                    ],
+                    isVoid: false
+                });
+                break;
+            default:
+                el.children.push({
+                    text: ''
+                });
+                break;
+        }
+    }
+    const lastChildElement = el.children.at(-1);
+    if (ElementInterface.isElement(lastChildElement) && inlineTypes.has(lastChildElement.type)) {
+        el.children.push({
+            text: ''
+        });
+    }
+    if (el.type === BLOCKS.TABLE) {
+        el.children = maybeFixUnevenTableRows(el);
+    }
+    return el;
+}
+export function toSlateDoc(doc) {
+    if (!doc || !doc?.content?.length) {
+        return [
+            {
+                type: 'paragraph',
+                children: [
+                    {
+                        text: ''
+                    }
+                ],
+                data: {},
+                isVoid: false
+            }
+        ];
+    }
+    const elements = doc.content.map(transformNode);
+    const lastElement = elements.at(-1);
+    if (lastElement?.type !== BLOCKS.PARAGRAPH) {
+        elements.push({
+            type: BLOCKS.PARAGRAPH,
+            children: [
+                {
+                    text: ''
+                }
+            ],
+            data: {},
+            isVoid: false
+        });
+    }
+    return elements;
+}

package/dist/types/helpers/__tests__/toSlateDoc.test.d.ts

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

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

@@ -0,0 +1,3 @@
+import { Document as CfDocument } from '@contentful/rich-text-types';
+import type { Element } from '../internal';
+export declare function toSlateDoc(doc?: CfDocument): Element[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/field-editor-rich-text",
-  "version": "4.18.0",
+  "version": "4.19.1",
   "source": "./src/index.tsx",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -71,7 +71,8 @@
     "slate": "0.94.1",
     "slate-history": "0.100.0",
     "slate-hyperscript": "0.77.0",
-    "slate-react": "0.102.0"
+    "slate-react": "0.102.0",
+    "use-deep-compare": "^1.3.0"
   },
   "peerDependencies": {
     "@lingui/core": "^5.3.0",
@@ -90,5 +91,5 @@
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
   },
-  "gitHead": "67068016b57ce3057ddddfb8dd3a53ef86499a02"
+  "gitHead": "25039e978332b8efc8511a3e2ee2a6398f334a7f"
 }

package/dist/cjs/helpers/toSlateValue.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "toSlateValue", {
-    enumerable: true,
-    get: function() {
-        return toSlateValue;
-    }
-});
-const _contentfulslatejsadapter = require("@contentful/contentful-slatejs-adapter");
-const _richtexttypes = require("@contentful/rich-text-types");
-const _Schema = /*#__PURE__*/ _interop_require_default(require("../constants/Schema"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const isTextElement = (node)=>'text' in node;
-function sanitizeIncomingSlateDoc(nodes = []) {
-    return nodes.map((node)=>{
-        if (isTextElement(node)) {
-            return node;
-        }
-        if (node.children?.length === 0) {
-            return {
-                ...node,
-                children: [
-                    {
-                        text: '',
-                        data: {}
-                    }
-                ]
-            };
-        }
-        return {
-            ...node,
-            children: sanitizeIncomingSlateDoc(node?.children)
-        };
-    });
-}
-const toSlateValue = (doc)=>{
-    const hasContent = (doc)=>{
-        return (doc?.content || []).length > 0;
-    };
-    const slateDoc = (0, _contentfulslatejsadapter.toSlatejsDocument)({
-        document: doc && hasContent(doc) ? doc : _richtexttypes.EMPTY_DOCUMENT,
-        schema: _Schema.default
-    });
-    return sanitizeIncomingSlateDoc(slateDoc);
-};

package/dist/esm/helpers/toSlateValue.js

@@ -1,36 +0,0 @@
-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)=>{
-        if (isTextElement(node)) {
-            return node;
-        }
-        if (node.children?.length === 0) {
-            return {
-                ...node,
-                children: [
-                    {
-                        text: '',
-                        data: {}
-                    }
-                ]
-            };
-        }
-        return {
-            ...node,
-            children: sanitizeIncomingSlateDoc(node?.children)
-        };
-    });
-}
-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/types/helpers/toSlateValue.d.ts

@@ -1,7 +0,0 @@
-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[];