@handlewithcare/react-prosemirror 2.0.0

package/dist/cjs/decorations/computeDocDeco.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "computeDocDeco", {
+    enumerable: true,
+    get: function() {
+        return computeDocDeco;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+const DocDecorationsCache = new WeakMap();
+function computeDocDeco(view) {
+    const attrs = Object.create(null);
+    attrs.class = "ProseMirror";
+    attrs.contenteditable = String(view.editable);
+    view.someProp("attributes", (value)=>{
+        if (typeof value == "function") value = value(view.state);
+        if (value) for(const attr in value){
+            if (attr == "class") attrs.class += " " + value[attr];
+            else if (attr == "style") attrs.style = (attrs.style ? attrs.style + ";" : "") + value[attr];
+            else if (!attrs[attr] && attr != "contenteditable" && attr != "nodeName") attrs[attr] = String(value[attr]);
+        }
+    });
+    if (!attrs.translate) attrs.translate = "no";
+    const next = [
+        _prosemirrorview.Decoration.node(0, view.state.doc.content.size, attrs)
+    ];
+    const previous = DocDecorationsCache.get(view);
+    if (!previous) {
+        DocDecorationsCache.set(view, next);
+        return next;
+    }
+    if (previous[0].to !== view.state.doc.content.size) {
+        DocDecorationsCache.set(view, next);
+        return next;
+    }
+    // @ts-expect-error Internal property (Decoration.type)
+    if (!previous[0].type.eq(next[0].type)) {
+        DocDecorationsCache.set(view, next);
+        return next;
+    }
+    return previous;
+}

package/dist/cjs/decorations/internalTypes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/cjs/decorations/iterDeco.js

@@ -0,0 +1,79 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "iterDeco", {
+    enumerable: true,
+    get: function() {
+        return iterDeco;
+    }
+});
+const _ReactWidgetType = require("./ReactWidgetType.js");
+function compareSide(a, b) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return a.type.side - b.type.side;
+}
+function iterDeco(parent, deco, // Callbacks have been slightly modified to pass
+// the offset, so that we can pass the position as
+// a prop to components
+onWidget, onNode) {
+    const locals = deco.locals(parent);
+    let offset = 0;
+    // Simple, cheap variant for when there are no local decorations
+    if (locals.length == 0) {
+        for(let i = 0; i < parent.childCount; i++){
+            const child = parent.child(i);
+            onNode(child, locals, deco.forChild(offset, child), offset, i);
+            offset += child.nodeSize;
+        }
+        return;
+    }
+    let decoIndex = 0;
+    const active = [];
+    let restNode = null;
+    for(let parentIndex = 0;;){
+        if (decoIndex < locals.length && locals[decoIndex].to == offset) {
+            const widget = locals[decoIndex++];
+            let widgets;
+            while(decoIndex < locals.length && locals[decoIndex].to == offset)(widgets || (widgets = [
+                widget
+            ])).push(locals[decoIndex++]);
+            if (widgets) {
+                widgets.sort(compareSide);
+                for(let i = 0; i < widgets.length; i++)onWidget(widgets[i], // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                !(widgets[i].type instanceof _ReactWidgetType.ReactWidgetType), offset, parentIndex + i, !!restNode);
+            } else {
+                onWidget(widget, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                !(widget.type instanceof _ReactWidgetType.ReactWidgetType), offset, parentIndex, !!restNode);
+            }
+        }
+        let child, index;
+        if (restNode) {
+            index = -1;
+            child = restNode;
+            restNode = null;
+        } else if (parentIndex < parent.childCount) {
+            index = parentIndex;
+            child = parent.child(parentIndex++);
+        } else {
+            break;
+        }
+        for(let i = 0; i < active.length; i++)if (active[i].to <= offset) active.splice(i--, 1);
+        while(decoIndex < locals.length && locals[decoIndex].from <= offset && locals[decoIndex].to > offset)active.push(locals[decoIndex++]);
+        let end = offset + child.nodeSize;
+        if (child.isText) {
+            let cutAt = end;
+            if (decoIndex < locals.length && locals[decoIndex].from < cutAt) cutAt = locals[decoIndex].from;
+            for(let i = 0; i < active.length; i++)if (active[i].to < cutAt) cutAt = active[i].to;
+            if (cutAt < end) {
+                restNode = child.cut(cutAt - offset);
+                child = child.cut(0, cutAt - offset);
+                end = cutAt;
+                index = -1;
+            }
+        }
+        const outerDeco = child.isInline && !child.isLeaf ? active.filter((d)=>!d.inline) : active.slice();
+        onNode(child, outerDeco, deco.forChild(offset, child), offset, index);
+        offset = end;
+    }
+}

package/dist/cjs/decorations/viewDecorations.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "viewDecorations", {
+    enumerable: true,
+    get: function() {
+        return viewDecorations;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const none = [], noSpec = {};
+const empty = _prosemirrorview.DecorationSet.empty;
+// An abstraction that allows the code dealing with decorations to
+// treat multiple DecorationSet objects as if it were a single object
+// with (a subset of) the same interface.
+let DecorationGroup = class DecorationGroup {
+    members;
+    constructor(members){
+        this.members = members;
+    }
+    map(mapping, doc) {
+        const mappedDecos = this.members.map((member)=>member.map(mapping, doc, noSpec));
+        return DecorationGroup.from(mappedDecos);
+    }
+    forChild(offset, child) {
+        if (child.isLeaf) return _prosemirrorview.DecorationSet.empty;
+        let found = [];
+        for(let i = 0; i < this.members.length; i++){
+            const result = this.members[i].forChild(offset, child);
+            if (result == empty) continue;
+            if (result instanceof DecorationGroup) found = found.concat(result.members);
+            else found.push(result);
+        }
+        return DecorationGroup.from(found);
+    }
+    eq(other) {
+        if (!(other instanceof DecorationGroup) || other.members.length != this.members.length) return false;
+        for(let i = 0; i < this.members.length; i++)if (!this.members[i].eq(other.members[i])) return false;
+        return true;
+    }
+    locals(node) {
+        let result, sorted = true;
+        for(let i = 0; i < this.members.length; i++){
+            const locals = this.members[i].localsInner(node);
+            if (!locals.length) continue;
+            if (!result) {
+                result = locals;
+            } else {
+                if (sorted) {
+                    result = result.slice();
+                    sorted = false;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                for(let j = 0; j < locals.length; j++)result.push(locals[j]);
+            }
+        }
+        return result ? removeOverlap(sorted ? result : result.sort(byPos)) : none;
+    }
+    // Create a group for the given array of decoration sets, or return
+    // a single set when possible.
+    static from(members) {
+        switch(members.length){
+            case 0:
+                return empty;
+            case 1:
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                return members[0];
+            default:
+                return new DecorationGroup(members.every((m)=>m instanceof _prosemirrorview.DecorationSet) ? members : members.reduce((r, m)=>r.concat(m instanceof _prosemirrorview.DecorationSet ? m : m.members), []));
+        }
+    }
+    forEachSet(f) {
+        for(let i = 0; i < this.members.length; i++)// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.members[i].forEachSet(f);
+    }
+};
+// Used to sort decorations so that ones with a low start position
+// come first, and within a set with the same start position, those
+// with an smaller end position come first.
+function byPos(a, b) {
+    return a.from - b.from || a.to - b.to;
+}
+// Scan a sorted array of decorations for partially overlapping spans,
+// and split those so that only fully overlapping spans are left (to
+// make subsequent rendering easier). Will return the input array if
+// no partially overlapping spans are found (the common case).
+function removeOverlap(spans) {
+    let working = spans;
+    for(let i = 0; i < working.length - 1; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const span = working[i];
+        if (span.from != span.to) for(let j = i + 1; j < working.length; j++){
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const next = working[j];
+            if (next.from == span.from) {
+                if (next.to != span.to) {
+                    if (working == spans) working = spans.slice();
+                    // Followed by a partially overlapping larger span. Split that
+                    // span.
+                    working[j] = next.copy(next.from, span.to);
+                    insertAhead(working, j + 1, next.copy(span.to, next.to));
+                }
+                continue;
+            } else {
+                if (next.from < span.to) {
+                    if (working == spans) working = spans.slice();
+                    // The end of this one overlaps with a subsequent span. Split
+                    // this one.
+                    working[i] = span.copy(span.from, next.from);
+                    insertAhead(working, j, span.copy(next.from, span.to));
+                }
+                break;
+            }
+        }
+    }
+    return working;
+}
+function insertAhead(array, i, deco) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    while(i < array.length && byPos(deco, array[i]) > 0)i++;
+    array.splice(i, 0, deco);
+}
+const ViewDecorationsCache = new WeakMap();
+function viewDecorations(view, cursorWrapper) {
+    const found = [];
+    view.someProp("decorations", (f)=>{
+        const result = f(view.state);
+        if (result && result != empty) found.push(result);
+    });
+    // We don't have access to types for view.cursorWrapper here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (cursorWrapper) {
+        found.push(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+        _prosemirrorview.DecorationSet.create(view.state.doc, [
+            cursorWrapper
+        ]));
+    }
+    const previous = ViewDecorationsCache.get(view);
+    if (!previous) {
+        const result = DecorationGroup.from(found);
+        ViewDecorationsCache.set(view, result);
+        return result;
+    }
+    let numPrevious = 0;
+    let areSetsEqual = true;
+    previous.forEachSet((set)=>{
+        const next = found[numPrevious++];
+        if (next !== set) {
+            areSetsEqual = false;
+        }
+    });
+    if (numPrevious !== found.length) {
+        areSetsEqual = false;
+    }
+    if (!areSetsEqual) {
+        const result = DecorationGroup.from(found);
+        ViewDecorationsCache.set(view, result);
+        return result;
+    }
+    return previous;
+}

package/dist/cjs/dom.js

@@ -0,0 +1,142 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-non-null-assertion */ "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, {
+    caretFromPoint: function() {
+        return caretFromPoint;
+    },
+    deepActiveElement: function() {
+        return deepActiveElement;
+    },
+    domIndex: function() {
+        return domIndex;
+    },
+    hasBlockDesc: function() {
+        return hasBlockDesc;
+    },
+    isEquivalentPosition: function() {
+        return isEquivalentPosition;
+    },
+    isOnEdge: function() {
+        return isOnEdge;
+    },
+    keyEvent: function() {
+        return keyEvent;
+    },
+    nodeSize: function() {
+        return nodeSize;
+    },
+    parentNode: function() {
+        return parentNode;
+    },
+    selectionCollapsed: function() {
+        return selectionCollapsed;
+    },
+    textRange: function() {
+        return textRange;
+    }
+});
+const domIndex = function(node) {
+    for(let index = 0;; index++){
+        node = node.previousSibling;
+        if (!node) return index;
+    }
+};
+const parentNode = function(node) {
+    const parent = node.assignedSlot || node.parentNode;
+    return parent && parent.nodeType == 11 ? parent.host : parent;
+};
+let reusedRange = null;
+const textRange = function(node, from, to) {
+    const range = reusedRange || (reusedRange = document.createRange());
+    range.setEnd(node, to == null ? node.nodeValue.length : to);
+    range.setStart(node, from || 0);
+    return range;
+};
+const isEquivalentPosition = function(node, off, targetNode, targetOff) {
+    return targetNode && (scanFor(node, off, targetNode, targetOff, -1) || scanFor(node, off, targetNode, targetOff, 1));
+};
+const atomElements = /^(img|br|input|textarea|hr)$/i;
+function scanFor(node, off, targetNode, targetOff, dir) {
+    for(;;){
+        if (node == targetNode && off == targetOff) return true;
+        if (off == (dir < 0 ? 0 : nodeSize(node))) {
+            const parent = node.parentNode;
+            if (!parent || parent.nodeType != 1 || hasBlockDesc(node) || atomElements.test(node.nodeName) || node.contentEditable == "false") return false;
+            off = domIndex(node) + (dir < 0 ? 0 : 1);
+            node = parent;
+        } else if (node.nodeType == 1) {
+            node = node.childNodes[off + (dir < 0 ? -1 : 0)];
+            if (node.contentEditable == "false") return false;
+            off = dir < 0 ? nodeSize(node) : 0;
+        } else {
+            return false;
+        }
+    }
+}
+function nodeSize(node) {
+    return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
+}
+function isOnEdge(node, offset, parent) {
+    for(let atStart = offset == 0, atEnd = offset == nodeSize(node); atStart || atEnd;){
+        if (node == parent) return true;
+        const index = domIndex(node);
+        node = node.parentNode;
+        if (!node) return false;
+        atStart = atStart && index == 0;
+        atEnd = atEnd && index == nodeSize(node);
+    }
+    return false;
+}
+function hasBlockDesc(dom) {
+    let desc;
+    for(let cur = dom; cur; cur = cur.parentNode)if (desc = cur.pmViewDesc) break;
+    return desc && desc.node && desc.node.isBlock && (desc.dom == dom || desc.contentDOM == dom);
+}
+const selectionCollapsed = function(domSel) {
+    return domSel.focusNode && isEquivalentPosition(domSel.focusNode, domSel.focusOffset, domSel.anchorNode, domSel.anchorOffset);
+};
+function keyEvent(keyCode, key) {
+    const event = document.createEvent("Event");
+    event.initEvent("keydown", true, true);
+    event.keyCode = keyCode;
+    event.key = event.code = key;
+    return event;
+}
+function deepActiveElement(doc) {
+    let elt = doc.activeElement;
+    while(elt && elt.shadowRoot)elt = elt.shadowRoot.activeElement;
+    return elt;
+}
+function caretFromPoint(doc, x, y) {
+    if (doc.caretPositionFromPoint) {
+        try {
+            // Firefox throws for this call in hard-to-predict circumstances (#994)
+            const pos = doc.caretPositionFromPoint(x, y);
+            // Clip the offset, because Chrome will return a text offset
+            // into <input> nodes, which can't be treated as a regular DOM
+            // offset
+            if (pos) return {
+                node: pos.offsetNode,
+                offset: Math.min(nodeSize(pos.offsetNode), pos.offset)
+            };
+        } catch (_) {
+        // pass
+        }
+    }
+    if (doc.caretRangeFromPoint) {
+        const range = doc.caretRangeFromPoint(x, y);
+        if (range) return {
+            node: range.startContainer,
+            offset: Math.min(nodeSize(range.startContainer), range.startOffset)
+        };
+    }
+    return;
+}

package/dist/cjs/hooks/__tests__/useEditorViewLayoutEffect.test.js

@@ -0,0 +1,108 @@
+/* eslint-disable @typescript-eslint/no-empty-function */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = require("@testing-library/react");
+const _react1 = /*#__PURE__*/ _interopRequireDefault(require("react"));
+const _layoutGroupJs = require("../../components/LayoutGroup.js");
+const _editorContextJs = require("../../contexts/EditorContext.js");
+const _editorStateContextJs = require("../../contexts/EditorStateContext.js");
+const _useEditorEffectJs = require("../useEditorEffect.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function TestComponent(param) {
+    let { effect , dependencies =[]  } = param;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _useEditorEffectJs.useEditorEffect)(effect, dependencies);
+    return null;
+}
+describe("useEditorViewLayoutEffect", ()=>{
+    it("should run the effect", ()=>{
+        const effect = jest.fn();
+        const editorView = {};
+        const editorState = {};
+        const registerEventListener = ()=>{};
+        const unregisterEventListener = ()=>{};
+        (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_layoutGroupJs.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_editorContextJs.EditorContext.Provider, {
+            value: {
+                view: editorView,
+                registerEventListener,
+                unregisterEventListener
+            }
+        }, /*#__PURE__*/ _react1.default.createElement(_editorStateContextJs.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect
+        })))));
+        expect(effect).toHaveBeenCalled();
+        expect(effect).toHaveBeenCalledWith(editorView);
+    });
+    it("should not re-run the effect if no dependencies change", ()=>{
+        const effect = jest.fn();
+        const editorView = {};
+        const editorState = {};
+        const registerEventListener = ()=>{};
+        const unregisterEventListener = ()=>{};
+        const contextValue = {
+            view: editorView,
+            registerEventListener,
+            unregisterEventListener
+        };
+        const { rerender  } = (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_layoutGroupJs.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_editorContextJs.EditorContext.Provider, {
+            value: contextValue
+        }, /*#__PURE__*/ _react1.default.createElement(_editorStateContextJs.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: []
+        })), " ")));
+        rerender(/*#__PURE__*/ _react1.default.createElement(_layoutGroupJs.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_editorContextJs.EditorContext.Provider, {
+            value: contextValue
+        }, /*#__PURE__*/ _react1.default.createElement(_editorStateContextJs.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: []
+        })))));
+        expect(effect).toHaveBeenCalledTimes(1);
+    });
+    it("should re-run the effect if dependencies change", ()=>{
+        const effect = jest.fn();
+        const editorView = {};
+        const editorState = {};
+        const registerEventListener = ()=>{};
+        const unregisterEventListener = ()=>{};
+        const { rerender  } = (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_layoutGroupJs.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_editorContextJs.EditorContext.Provider, {
+            value: {
+                view: editorView,
+                registerEventListener,
+                unregisterEventListener
+            }
+        }, /*#__PURE__*/ _react1.default.createElement(_editorStateContextJs.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: [
+                "one"
+            ]
+        })))));
+        rerender(/*#__PURE__*/ _react1.default.createElement(_layoutGroupJs.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_editorContextJs.EditorContext.Provider, {
+            value: {
+                view: editorView,
+                registerEventListener,
+                unregisterEventListener
+            }
+        }, /*#__PURE__*/ _react1.default.createElement(_editorStateContextJs.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: [
+                "two"
+            ]
+        })))));
+        expect(effect).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/cjs/hooks/useClientOnly.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useClientOnly", {
+    enumerable: true,
+    get: function() {
+        return useClientOnly;
+    }
+});
+const _react = require("react");
+function useClientOnly() {
+    const [render, setRender] = (0, _react.useState)(false);
+    (0, _react.useEffect)(()=>{
+        setRender(true);
+    }, []);
+    return render;
+}

package/dist/cjs/hooks/useComponentEventListeners.js

@@ -0,0 +1,39 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useComponentEventListeners", {
+    enumerable: true,
+    get: function() {
+        return useComponentEventListeners;
+    }
+});
+const _react = require("react");
+const _componentEventListeners = require("../plugins/componentEventListeners.js");
+function useComponentEventListeners() {
+    const [registry, setRegistry] = (0, _react.useState)(new Map());
+    const registerEventListener = (0, _react.useCallback)((eventType, handler)=>{
+        const handlers = registry.get(eventType) ?? [];
+        handlers.unshift(handler);
+        if (!registry.has(eventType)) {
+            registry.set(eventType, handlers);
+            setRegistry(new Map(registry));
+        }
+    }, [
+        registry
+    ]);
+    const unregisterEventListener = (0, _react.useCallback)((eventType, handler)=>{
+        const handlers = registry.get(eventType);
+        handlers?.splice(handlers.indexOf(handler), 1);
+    }, [
+        registry
+    ]);
+    const componentEventListenersPlugin = (0, _react.useMemo)(()=>(0, _componentEventListeners.componentEventListeners)(registry), [
+        registry
+    ]);
+    return {
+        registerEventListener,
+        unregisterEventListener,
+        componentEventListenersPlugin
+    };
+}