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

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/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/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
+    });
+};

package/dist/cjs/helpers/validations.js

@@ -0,0 +1,56 @@
+"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, {
+    VALIDATIONS: function() {
+        return VALIDATIONS;
+    },
+    DEFAULT_ENABLED_NODE_TYPES: function() {
+        return DEFAULT_ENABLED_NODE_TYPES;
+    },
+    VALIDATABLE_NODE_TYPES: function() {
+        return VALIDATABLE_NODE_TYPES;
+    },
+    isNodeTypeEnabled: function() {
+        return isNodeTypeEnabled;
+    },
+    isMarkEnabled: function() {
+        return isMarkEnabled;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+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
+    };
+}
+const VALIDATIONS = {
+    ENABLED_MARKS: 'enabledMarks',
+    ENABLED_NODE_TYPES: 'enabledNodeTypes'
+};
+const DEFAULT_ENABLED_NODE_TYPES = [
+    _richtexttypes.BLOCKS.DOCUMENT,
+    _richtexttypes.BLOCKS.PARAGRAPH,
+    'text'
+];
+const VALIDATABLE_NODE_TYPES = [].concat(_richtexttypes.TOP_LEVEL_BLOCKS).filter((type)=>type !== _richtexttypes.BLOCKS.PARAGRAPH).concat(Object.values(_richtexttypes.INLINES));
+const getRichTextValidation = (field, validationType)=>(0, _flow.default)((v)=>(0, _find.default)(v, validationType), (v)=>(0, _get.default)(v, validationType))(field.validations);
+const isFormattingOptionEnabled = (field, validationType, nodeTypeOrMark)=>{
+    const enabledFormattings = getRichTextValidation(field, validationType);
+    if (enabledFormattings === undefined) {
+        return true;
+    }
+    return DEFAULT_ENABLED_NODE_TYPES.concat(enabledFormattings).includes(nodeTypeOrMark);
+};
+const isNodeTypeEnabled = (field, nodeType)=>isFormattingOptionEnabled(field, VALIDATIONS.ENABLED_NODE_TYPES, nodeType);
+const isMarkEnabled = (field, mark)=>isFormattingOptionEnabled(field, VALIDATIONS.ENABLED_MARKS, mark);

package/dist/cjs/index.js

@@ -0,0 +1,66 @@
+"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, {
+    RichTextEditor: function() {
+        return _RichTextEditor.default;
+    },
+    ConnectedRichTextEditor: function() {
+        return _RichTextEditor.ConnectedRichTextEditor;
+    },
+    openRichTextDialog: function() {
+        return _openRichTextDialog.openRichTextDialog;
+    },
+    renderRichTextDialog: function() {
+        return _renderRichTextDialog.renderRichTextDialog;
+    }
+});
+const _RichTextEditor = _interop_require_wildcard(require("./RichTextEditor"));
+const _openRichTextDialog = require("./dialogs/openRichTextDialog");
+const _renderRichTextDialog = require("./dialogs/renderRichTextDialog");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}