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

package/dist/cjs/internal/constants.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ELEMENT_DEFAULT", {
+    enumerable: true,
+    get: function() {
+        return ELEMENT_DEFAULT;
+    }
+});
+const _platecore = _interop_require_wildcard(require("@udecode/plate-core"));
+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;
+}
+const ELEMENT_DEFAULT = _platecore.ELEMENT_DEFAULT;

package/dist/cjs/internal/hooks.js

@@ -0,0 +1,65 @@
+"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, {
+    useReadOnly: function() {
+        return useReadOnly;
+    },
+    usePlateEditorRef: function() {
+        return usePlateEditorRef;
+    },
+    usePlateEditorState: function() {
+        return usePlateEditorState;
+    }
+});
+const _platecore = _interop_require_wildcard(require("@udecode/plate-core"));
+const _slatereact = _interop_require_wildcard(require("slate-react"));
+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;
+}
+const useReadOnly = _slatereact.useReadOnly;
+const usePlateEditorRef = _platecore.usePlateEditorRef;
+const usePlateEditorState = _platecore.usePlateEditorState;

package/dist/cjs/internal/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./queries"), exports);
+_export_star(require("./types"), exports);
+_export_star(require("./misc"), exports);
+_export_star(require("./transforms"), 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/internal/misc.js

@@ -0,0 +1,103 @@
+"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, {
+    createPlateEditor: function() {
+        return createPlateEditor;
+    },
+    withoutNormalizing: function() {
+        return withoutNormalizing;
+    },
+    focusEditor: function() {
+        return focusEditor;
+    },
+    blurEditor: function() {
+        return blurEditor;
+    },
+    selectEditor: function() {
+        return selectEditor;
+    },
+    fromDOMPoint: function() {
+        return fromDOMPoint;
+    },
+    mockPlugin: function() {
+        return mockPlugin;
+    },
+    getPlateSelectors: function() {
+        return getPlateSelectors;
+    }
+});
+const _platecore = _interop_require_wildcard(require("@udecode/plate-core"));
+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;
+}
+const createPlateEditor = (options = {})=>{
+    return _platecore.createPlateEditor(options);
+};
+const withoutNormalizing = (editor, fn)=>{
+    return _platecore.withoutNormalizing(editor, fn);
+};
+const focusEditor = (editor, target)=>{
+    _platecore.focusEditor(editor, target);
+};
+const blurEditor = (editor)=>{
+    _platecore.blurEditor(editor);
+};
+const selectEditor = (editor, opts)=>{
+    _platecore.selectEditor(editor, opts);
+};
+const fromDOMPoint = (editor, domPoint, opts = {
+    exactMatch: false,
+    suppressThrow: false
+})=>{
+    return _platecore.toSlatePoint(editor, domPoint, opts);
+};
+const mockPlugin = (plugin)=>{
+    return _platecore.mockPlugin(plugin);
+};
+const getPlateSelectors = (id)=>{
+    return _platecore.getPlateSelectors(id);
+};

package/dist/cjs/internal/queries.js

@@ -0,0 +1,407 @@
+"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, {
+    getText: function() {
+        return getText;
+    },
+    isText: function() {
+        return isText;
+    },
+    getEndPoint: function() {
+        return getEndPoint;
+    },
+    getStartPoint: function() {
+        return getStartPoint;
+    },
+    isNode: function() {
+        return isNode;
+    },
+    isSelectionAtBlockEnd: function() {
+        return isSelectionAtBlockEnd;
+    },
+    isSelectionAtBlockStart: function() {
+        return isSelectionAtBlockStart;
+    },
+    getBlockAbove: function() {
+        return getBlockAbove;
+    },
+    getNodeEntry: function() {
+        return getNodeEntry;
+    },
+    getNodeEntries: function() {
+        return getNodeEntries;
+    },
+    getNodeChildren: function() {
+        return getNodeChildren;
+    },
+    getParentNode: function() {
+        return getParentNode;
+    },
+    someNode: function() {
+        return someNode;
+    },
+    getChildren: function() {
+        return getChildren;
+    },
+    isFirstChild: function() {
+        return isFirstChild;
+    },
+    getDescendantNodeByPath: function() {
+        return getDescendantNodeByPath;
+    },
+    getNodeDescendants: function() {
+        return getNodeDescendants;
+    },
+    isRangeCollapsed: function() {
+        return isRangeCollapsed;
+    },
+    isRangeAcrossBlocks: function() {
+        return isRangeAcrossBlocks;
+    },
+    isRangeExpanded: function() {
+        return isRangeExpanded;
+    },
+    getRange: function() {
+        return getRange;
+    },
+    getRangeEdges: function() {
+        return getRangeEdges;
+    },
+    getRangeStart: function() {
+        return getRangeStart;
+    },
+    getRangeEnd: function() {
+        return getRangeEnd;
+    },
+    getAboveNode: function() {
+        return getAboveNode;
+    },
+    getNextNode: function() {
+        return getNextNode;
+    },
+    getCommonNode: function() {
+        return getCommonNode;
+    },
+    getNodeTexts: function() {
+        return getNodeTexts;
+    },
+    findNode: function() {
+        return findNode;
+    },
+    isMarkActive: function() {
+        return isMarkActive;
+    },
+    getMarks: function() {
+        return getMarks;
+    },
+    isEditor: function() {
+        return isEditor;
+    },
+    isEditorReadOnly: function() {
+        return isEditorReadOnly;
+    },
+    isElement: function() {
+        return isElement;
+    },
+    isBlockNode: function() {
+        return isBlockNode;
+    },
+    findNodePath: function() {
+        return findNodePath;
+    },
+    isAncestorPath: function() {
+        return isAncestorPath;
+    },
+    isAncestorEmpty: function() {
+        return isAncestorEmpty;
+    },
+    getParentPath: function() {
+        return getParentPath;
+    },
+    getNextPath: function() {
+        return getNextPath;
+    },
+    getPreviousPath: function() {
+        return getPreviousPath;
+    },
+    getLastChildPath: function() {
+        return getLastChildPath;
+    },
+    getPathLevels: function() {
+        return getPathLevels;
+    },
+    isCommonPath: function() {
+        return isCommonPath;
+    },
+    isFirstChildPath: function() {
+        return isFirstChildPath;
+    },
+    isLastChildPath: function() {
+        return isLastChildPath;
+    },
+    isChildPath: function() {
+        return isChildPath;
+    },
+    matchNode: function() {
+        return matchNode;
+    },
+    someHtmlElement: function() {
+        return someHtmlElement;
+    },
+    getPointBefore: function() {
+        return getPointBefore;
+    },
+    getPointAfter: function() {
+        return getPointAfter;
+    },
+    isEndPoint: function() {
+        return isEndPoint;
+    },
+    isInline: function() {
+        return isInline;
+    },
+    queryNode: function() {
+        return queryNode;
+    },
+    getPluginType: function() {
+        return getPluginType;
+    },
+    createPathRef: function() {
+        return createPathRef;
+    },
+    match: function() {
+        return match;
+    },
+    getLastNodeByLevel: function() {
+        return getLastNodeByLevel;
+    }
+});
+const _platecore = _interop_require_wildcard(require("@udecode/plate-core"));
+const _slate = _interop_require_wildcard(require("slate"));
+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;
+}
+const getText = (editor, at)=>{
+    return _platecore.getEditorString(editor, at);
+};
+const isText = (value)=>{
+    return _platecore.isText(value);
+};
+const getEndPoint = (editor, at)=>{
+    return _platecore.getEndPoint(editor, at);
+};
+const getStartPoint = (editor, at)=>{
+    return _platecore.getStartPoint(editor, at);
+};
+const isNode = (value)=>{
+    return _platecore.isNode(value);
+};
+const isSelectionAtBlockEnd = (editor, options)=>{
+    return _platecore.isSelectionAtBlockEnd(editor, options);
+};
+const isSelectionAtBlockStart = (editor, options)=>{
+    return _platecore.isSelectionAtBlockStart(editor, options);
+};
+const getBlockAbove = (editor, options)=>{
+    return _platecore.getBlockAbove(editor, options);
+};
+const getNodeEntry = (editor, at, options)=>{
+    return _platecore.getNodeEntry(editor, at, options);
+};
+const getNodeEntries = (editor, options)=>{
+    return _platecore.getNodeEntries(editor, options);
+};
+const getNodeChildren = (root, path, options)=>{
+    return _platecore.getNodeChildren(root, path, options);
+};
+const getParentNode = (editor, at, options)=>{
+    return _platecore.getParentNode(editor, at, options);
+};
+const someNode = (editor, options)=>{
+    return _platecore.someNode(editor, options);
+};
+const getChildren = (entry)=>{
+    if (_slate.Text.isText(entry[0])) {
+        return [];
+    }
+    return _platecore.getChildren(entry);
+};
+const isFirstChild = (path)=>{
+    return _platecore.isFirstChild(path);
+};
+const getDescendantNodeByPath = (root, path)=>{
+    return _slate.Node.get(root, path);
+};
+const getNodeDescendants = (root, options)=>{
+    return _platecore.getNodeDescendants(root, {
+        ...options,
+        pass: undefined
+    });
+};
+const isRangeCollapsed = (range)=>{
+    return _platecore.isCollapsed(range);
+};
+const isRangeAcrossBlocks = (editor, options)=>{
+    return _platecore.isRangeAcrossBlocks(editor, options);
+};
+const isRangeExpanded = (range)=>{
+    return _platecore.isExpanded(range);
+};
+const getRange = (editor, at, to)=>{
+    return _platecore.getRange(editor, at, to);
+};
+const getRangeEdges = (range)=>{
+    return _slate.Range.edges(range);
+};
+const getRangeStart = (range)=>{
+    return _slate.Range.start(range);
+};
+const getRangeEnd = (range)=>{
+    return _slate.Range.end(range);
+};
+const getAboveNode = (editor, opts)=>{
+    return _platecore.getAboveNode(editor, opts);
+};
+const getNextNode = (editor, opts)=>{
+    return _platecore.getNextNode(editor, opts);
+};
+const getCommonNode = (root, path, another)=>{
+    return _platecore.getCommonNode(root, path, another);
+};
+const getNodeTexts = (root, opts)=>{
+    return _platecore.getNodeTexts(root, opts);
+};
+const findNode = (editor, options)=>{
+    return _platecore.findNode(editor, options);
+};
+const isMarkActive = (editor, type)=>{
+    return _platecore.isMarkActive(editor, type);
+};
+const getMarks = (editor)=>{
+    return _platecore.getMarks(editor);
+};
+const isEditor = (value)=>{
+    return _platecore.isEditor(value);
+};
+const isEditorReadOnly = (editor)=>{
+    return _platecore.isEditorReadOnly(editor);
+};
+const isElement = (value)=>{
+    return _platecore.isElement(value);
+};
+const isBlockNode = (editor, value)=>{
+    return _platecore.isBlock(editor, value);
+};
+const findNodePath = (editor, node)=>{
+    return _platecore.findNodePath(editor, node);
+};
+const isAncestorPath = (path, another)=>{
+    return _slate.Path.isAncestor(path, another);
+};
+const isAncestorEmpty = (editor, node)=>{
+    return _platecore.isAncestorEmpty(editor, node);
+};
+const getParentPath = (path)=>{
+    return _slate.Path.parent(path);
+};
+const getNextPath = (path)=>{
+    return _slate.Path.next(path);
+};
+const getPreviousPath = (path)=>{
+    return _slate.Path.previous(path);
+};
+const getLastChildPath = (nodeEntry)=>{
+    return _platecore.getLastChildPath(nodeEntry);
+};
+const getPathLevels = (path, options)=>{
+    return _slate.Path.levels(path, options);
+};
+const isCommonPath = (path, anotherPath)=>{
+    return _slate.Path.isCommon(path, anotherPath);
+};
+const isFirstChildPath = (path)=>{
+    return _platecore.isFirstChild(path);
+};
+const isLastChildPath = (entry, childPath)=>{
+    return _platecore.isLastChild(entry, childPath);
+};
+const isChildPath = (path, another)=>{
+    return _slate.Path.isChild(path, another);
+};
+const matchNode = (node, path, fn)=>{
+    return _platecore.match(node, path, fn);
+};
+const someHtmlElement = (rootNode, predicate)=>{
+    return _platecore.someHtmlElement(rootNode, predicate);
+};
+const getPointBefore = (editor, at, options)=>{
+    return _platecore.getPointBefore(editor, at, options);
+};
+const getPointAfter = (editor, at, options)=>{
+    return _platecore.getPointAfter(editor, at, options);
+};
+const isEndPoint = (editor, point, at)=>{
+    return _platecore.isEndPoint(editor, point, at);
+};
+const isInline = (editor, value)=>{
+    return _platecore.isInline(editor, value);
+};
+const queryNode = (entry, options)=>{
+    return _platecore.queryNode(entry, options);
+};
+const getPluginType = (editor, key)=>{
+    return _platecore.getPluginType(editor, key);
+};
+const createPathRef = (editor, at)=>{
+    return _platecore.createPathRef(editor, at);
+};
+const match = (obj, path, predicate)=>{
+    return _platecore.match(obj, path, predicate);
+};
+const getLastNodeByLevel = (editor, level)=>{
+    return _platecore.getLastNodeByLevel(editor, level);
+};