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

package/dist/cjs/helpers/environment.js

@@ -0,0 +1,20 @@
+"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, {
+    IS_SAFARI: function() {
+        return IS_SAFARI;
+    },
+    IS_CHROME: function() {
+        return IS_CHROME;
+    }
+});
+const IS_SAFARI = typeof navigator !== 'undefined' && /Version\/[\d.]+.*Safari/.test(navigator.userAgent);
+const IS_CHROME = /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9.]+)(:?\s|$)/.test(navigator.userAgent);

package/dist/cjs/helpers/extractNodes.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "extractParagraphs", {
+    enumerable: true,
+    get: function() {
+        return extractParagraphs;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _queries = require("../internal/queries");
+function extractNodes(editor, path, match) {
+    return Array.from((0, _queries.getNodeEntries)(editor, {
+        match,
+        at: path,
+        mode: 'lowest'
+    })).map(([node])=>node);
+}
+function extractParagraphs(editor, path) {
+    return extractNodes(editor, path, {
+        type: _richtexttypes.TEXT_CONTAINERS
+    }).map((node)=>({
+            ...node,
+            type: _richtexttypes.BLOCKS.PARAGRAPH
+        }));
+}

package/dist/cjs/helpers/formatDateAndTime.js

@@ -0,0 +1,45 @@
+"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, {
+    formatDate: function() {
+        return formatDate;
+    },
+    formatTime: function() {
+        return formatTime;
+    },
+    formatDateAndTime: function() {
+        return formatDateAndTime;
+    }
+});
+const _moment = _interop_require_default(require("moment"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const formatDate = (date, short)=>{
+    switch((0, _moment.default)().startOf('day').diff((0, _moment.default)(date).startOf('day'), 'days')){
+        case 0:
+            return short ? 'Today' : `Today, ${(0, _moment.default)(date).format('DD MMM YYYY')}`;
+        case -1:
+            return short ? 'Tomorrow' : `Tomorrow, ${(0, _moment.default)(date).format('DD MMM YYYY')}`;
+        case 1:
+            return short ? 'Yesterday' : `Yesterday, ${(0, _moment.default)(date).format('DD MMM YYYY')}`;
+        default:
+            return (0, _moment.default)(date).format('ddd, DD MMM YYYY');
+    }
+};
+const formatTime = (date)=>{
+    return _moment.default.utc(date).local().format('h:mm A');
+};
+const formatDateAndTime = (date, short)=>{
+    return `${formatDate(date, short)} at ${formatTime(date)}`;
+};

package/dist/cjs/helpers/getAllowedResourcesForNodeType.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getAllowedResourcesForNodeType;
+    }
+});
+const _find = _interop_require_default(require("lodash/find"));
+const _flow = _interop_require_default(require("lodash/flow"));
+const _get = _interop_require_default(require("lodash/get"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getAllowedResourcesForNodeType(field, nodeType) {
+    return (0, _flow.default)((validations)=>(0, _find.default)(validations, 'nodes'), (validations)=>(0, _get.default)(validations, [
+            'nodes',
+            nodeType,
+            'allowedResources'
+        ], []))(field.validations);
+}

package/dist/cjs/helpers/getLinkedContentTypeIdsForNodeType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getLinkedContentTypeIdsForNodeType;
+    }
+});
+const _find = _interop_require_default(require("lodash/find"));
+const _flow = _interop_require_default(require("lodash/flow"));
+const _get = _interop_require_default(require("lodash/get"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getLinkedContentTypeIdsForNodeType(field, nodeType) {
+    return (0, _flow.default)((v)=>(0, _find.default)(v, 'nodes'), (v)=>(0, _get.default)(v, [
+            'nodes',
+            nodeType
+        ]), (v)=>(0, _find.default)(v, 'linkContentType'), (v)=>(0, _get.default)(v, 'linkContentType', []))(field.validations);
+}

package/dist/cjs/helpers/newEntitySelectorConfigFromRichTextField.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return newEntitySelectorConfigFromRichTextField;
+    }
+});
+const _getLinkedContentTypeIdsForNodeType = _interop_require_default(require("./getLinkedContentTypeIdsForNodeType"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function newEntitySelectorConfigFromRichTextField(field, nodeType) {
+    return {
+        entityType: getEntityTypeFromRichTextNode(nodeType),
+        locale: field.locale || null,
+        contentTypes: (0, _getLinkedContentTypeIdsForNodeType.default)(field, nodeType)
+    };
+}
+function getEntityTypeFromRichTextNode(nodeType) {
+    const words = nodeType.split('-');
+    if (words.indexOf('entry') !== -1) {
+        return 'Entry';
+    }
+    if (words.indexOf('asset') !== -1) {
+        return 'Asset';
+    }
+    throw new Error(`RichText node type \`${nodeType}\` has no associated \`entityType\``);
+}

package/dist/cjs/helpers/newResourceEntitySelectorConfigFromRichTextField.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return newResourceEntitySelectorConfigFromRichTextField;
+    }
+});
+const _getAllowedResourcesForNodeType = _interop_require_default(require("./getAllowedResourcesForNodeType"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function newResourceEntitySelectorConfigFromRichTextField(field, nodeType) {
+    return {
+        allowedResources: (0, _getAllowedResourcesForNodeType.default)(field, nodeType)
+    };
+}

package/dist/cjs/helpers/nodeFactory.js

@@ -0,0 +1,51 @@
+"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, {
+    document: function() {
+        return document;
+    },
+    block: function() {
+        return block;
+    },
+    inline: function() {
+        return inline;
+    },
+    text: function() {
+        return text;
+    },
+    mark: function() {
+        return mark;
+    }
+});
+const document = (...content)=>({
+        nodeType: 'document',
+        content,
+        data: {}
+    });
+const block = (nodeType, data, ...content)=>({
+        nodeType,
+        content,
+        data
+    });
+const inline = (nodeType, data, ...content)=>({
+        nodeType,
+        content,
+        data
+    });
+const text = (value = '', marks = [])=>({
+        nodeType: 'text',
+        value,
+        marks,
+        data: {}
+    });
+const mark = (type)=>({
+        type
+    });

package/dist/cjs/helpers/removeInternalMarks.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeInternalMarks", {
+    enumerable: true,
+    get: function() {
+        return removeInternalMarks;
+    }
+});
+const _constants = require("../plugins/CommandPalette/constants");
+const internalMarks = [
+    _constants.COMMAND_PROMPT
+];
+const removeInternalMarks = (document)=>{
+    return {
+        ...document,
+        content: document.content.map((node)=>{
+            if (node.nodeType === 'text') {
+                node.marks = node.marks.filter((mark)=>!internalMarks.includes(mark.type));
+                return node;
+            }
+            return removeInternalMarks(node);
+        })
+    };
+};

package/dist/cjs/helpers/sanitizeIncomingSlateDoc.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sanitizeIncomingSlateDoc", {
+    enumerable: true,
+    get: function() {
+        return sanitizeIncomingSlateDoc;
+    }
+});
+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)
+        };
+    });
+}

package/dist/cjs/helpers/sdkNavigatorSlideIn.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "watchCurrentSlide", {
+    enumerable: true,
+    get: function() {
+        return watchCurrentSlide;
+    }
+});
+const _noop = _interop_require_default(require("lodash/noop"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function watchCurrentSlide(navigator) {
+    const onActiveCallbacks = new Set();
+    let wasSlideClosed = false;
+    let initialSlideLevel;
+    let lastSlideLevel;
+    const status = ()=>({
+            wasClosed: wasSlideClosed,
+            isActive: !wasSlideClosed && lastSlideLevel === initialSlideLevel
+        });
+    const off = navigator.onSlideInNavigation(({ oldSlideLevel , newSlideLevel  })=>{
+        if (initialSlideLevel === undefined) {
+            initialSlideLevel = oldSlideLevel;
+        }
+        lastSlideLevel = newSlideLevel;
+        if (newSlideLevel < initialSlideLevel) {
+            wasSlideClosed = true;
+            off();
+            onActiveCallbacks.clear();
+        }
+        if (status().isActive && newSlideLevel !== oldSlideLevel) {
+            onActiveCallbacks.forEach((cb)=>cb());
+        }
+    });
+    function unwatch() {
+        off();
+        onActiveCallbacks.clear();
+    }
+    function onActive(cb) {
+        if (wasSlideClosed) return _noop.default;
+        if (status().isActive) {
+            cb();
+        }
+        onActiveCallbacks.add(cb);
+        return ()=>onActiveCallbacks.delete(cb);
+    }
+    return {
+        status,
+        onActive,
+        unwatch
+    };
+}

package/dist/cjs/helpers/sdkNavigatorSlideIn.spec.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _cloneDeep = _interop_require_default(require("lodash/cloneDeep"));
+const _mitt = _interop_require_default(require("mitt"));
+const _sdkNavigatorSlideIn = require("./sdkNavigatorSlideIn");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function createFakeNavigatorAPI() {
+    const localEmitter = (0, _mitt.default)();
+    const navigatorEmitter = {
+        slideIn: (slide)=>localEmitter.emit('onSlideInNavigation', slide)
+    };
+    const api = {
+        openNewAsset: async ()=>({
+                navigated: false
+            }),
+        openAsset: async ()=>({
+                navigated: false
+            }),
+        openNewEntry: async ()=>({
+                navigated: false
+            }),
+        openEntry: async ()=>({
+                navigated: false
+            }),
+        onSlideInNavigation: (handler)=>{
+            const type = `onSlideInNavigation`;
+            localEmitter.on(type, handler);
+            return ()=>{
+                localEmitter.off(type, handler);
+            };
+        }
+    };
+    return [
+        api,
+        navigatorEmitter
+    ];
+}
+describe('watchCurrentSlide().info()', ()=>{
+    let fake, slide;
+    beforeEach(()=>{
+        const fakeNavigator = createFakeNavigatorAPI();
+        const api = fakeNavigator[0];
+        fake = fakeNavigator[1];
+        slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+    });
+    it('considers current slide active initially', ()=>{
+        expect(slide.status()).toEqual({
+            wasClosed: false,
+            isActive: true
+        });
+    });
+    it('no longer considers slide active after another slide opens', ()=>{
+        fake.slideIn({
+            oldSlideLevel: 0,
+            newSlideLevel: 1
+        });
+        expect(slide.status()).toEqual({
+            wasClosed: false,
+            isActive: false
+        });
+    });
+    it('considers the original slide active after opening and closing another slide', ()=>{
+        fake.slideIn({
+            oldSlideLevel: 0,
+            newSlideLevel: 1
+        });
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 0
+        });
+        expect(slide.status()).toEqual({
+            wasClosed: false,
+            isActive: true
+        });
+    });
+    it('considers slide closed after jumping to slide below', ()=>{
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 0
+        });
+        expect(slide.status()).toEqual({
+            wasClosed: true,
+            isActive: false
+        });
+    });
+    it('still considers slide closed after jumping to slide below and opening a new one', ()=>{
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 0
+        });
+        fake.slideIn({
+            oldSlideLevel: 0,
+            newSlideLevel: 1
+        });
+        expect(slide.status()).toEqual({
+            wasClosed: true,
+            isActive: false
+        });
+    });
+    it('considers slide closed after opening new slide and then jumping to slide below', ()=>{
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 2
+        });
+        fake.slideIn({
+            oldSlideLevel: 2,
+            newSlideLevel: 0
+        });
+        expect(slide.status()).toEqual({
+            wasClosed: true,
+            isActive: false
+        });
+    });
+});
+describe('watchCurrentSlide().onActive()', ()=>{
+    let api, fake, spy;
+    beforeEach(()=>{
+        const fakeNavigator = createFakeNavigatorAPI();
+        api = fakeNavigator[0];
+        fake = fakeNavigator[1];
+        spy = jest.fn();
+    });
+    it('fires initially if there was no slide event', ()=>{
+        const slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        slide.onActive(spy);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it('does not fire initially, if new slide already opened, but fires after slide gets closed again', ()=>{
+        const slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        fake.slideIn({
+            oldSlideLevel: 2,
+            newSlideLevel: 3
+        });
+        slide.onActive(spy);
+        expect(spy).toHaveBeenCalledTimes(0);
+        fake.slideIn({
+            oldSlideLevel: 3,
+            newSlideLevel: 2
+        });
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it('fires every time slide becomes active again', ()=>{
+        const slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        slide.onActive(spy);
+        expect(spy).toHaveBeenCalledTimes(1);
+        fake.slideIn({
+            oldSlideLevel: 0,
+            newSlideLevel: 1
+        });
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 0
+        });
+        expect(spy).toHaveBeenCalledTimes(2);
+    });
+    it('does not fire on a slide-in event for the same slide we are already on', ()=>{
+        const slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        slide.onActive(spy);
+        expect(spy).toHaveBeenCalledTimes(1);
+        fake.slideIn({
+            oldSlideLevel: 0,
+            newSlideLevel: 0
+        });
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});
+describe('watchCurrentSlide().unwatch()', ()=>{
+    let api, fake;
+    beforeEach(()=>{
+        const fakeNavigator = createFakeNavigatorAPI();
+        api = fakeNavigator[0];
+        fake = fakeNavigator[1];
+    });
+    it('does not update .info() after .unwatch()', ()=>{
+        const slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        const lastStatus = (0, _cloneDeep.default)(slide.status());
+        slide.unwatch();
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 0
+        });
+        expect(lastStatus).toEqual(slide.status());
+    });
+    it('does not fire outstanding onActive after unwatch()', ()=>{
+        const slide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        const slide2 = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(api);
+        const spy = jest.fn();
+        const spy2 = jest.fn();
+        fake.slideIn({
+            oldSlideLevel: 0,
+            newSlideLevel: 1
+        });
+        slide.onActive(spy);
+        slide2.onActive(spy2);
+        slide.unwatch();
+        fake.slideIn({
+            oldSlideLevel: 1,
+            newSlideLevel: 0
+        });
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/cjs/helpers/transformers.js

@@ -0,0 +1,61 @@
+"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, {
+    transformRemove: function() {
+        return transformRemove;
+    },
+    transformParagraphs: function() {
+        return transformParagraphs;
+    },
+    transformUnwrap: function() {
+        return transformUnwrap;
+    },
+    transformWrapIn: function() {
+        return transformWrapIn;
+    },
+    transformLift: function() {
+        return transformLift;
+    }
+});
+const _transforms = require("../internal/transforms");
+const _extractNodes = require("./extractNodes");
+const transformRemove = (editor, [, path])=>{
+    (0, _transforms.removeNodes)(editor, {
+        at: path
+    });
+};
+const transformParagraphs = (editor, entry)=>{
+    const path = entry[1];
+    const nodes = (0, _extractNodes.extractParagraphs)(editor, path);
+    transformRemove(editor, entry);
+    (0, _transforms.insertNodes)(editor, nodes, {
+        at: path
+    });
+};
+const transformUnwrap = (editor, [, path])=>{
+    (0, _transforms.unwrapNodes)(editor, {
+        at: path
+    });
+};
+const transformWrapIn = (type)=>(editor, [, path])=>{
+        (0, _transforms.wrapNodes)(editor, {
+            type,
+            data: {},
+            children: []
+        }, {
+            at: path
+        });
+    };
+const transformLift = (editor, [, path])=>{
+    (0, _transforms.liftNodes)(editor, {
+        at: path
+    });
+};