@handlewithcare/react-prosemirror 2.0.0

package/dist/cjs/selection/selectionToDOM.js

@@ -0,0 +1,226 @@
+"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, {
+    domIndex: function() {
+        return domIndex;
+    },
+    hasBlockDesc: function() {
+        return hasBlockDesc;
+    },
+    hasSelection: function() {
+        return hasSelection;
+    },
+    isEquivalentPosition: function() {
+        return isEquivalentPosition;
+    },
+    nodeSize: function() {
+        return nodeSize;
+    },
+    selectionToDOM: function() {
+        return selectionToDOM;
+    },
+    syncNodeSelection: function() {
+        return syncNodeSelection;
+    }
+});
+const _prosemirrorstate = require("prosemirror-state");
+const _browser = require("../browser.js");
+const isEquivalentPosition = function(node, off, targetNode, targetOff) {
+    return targetNode && (scanFor(node, off, targetNode, targetOff, -1) || scanFor(node, off, targetNode, targetOff, 1));
+};
+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 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) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            node = node.childNodes[off + (dir < 0 ? -1 : 0)];
+            if (node.contentEditable == "false") return false;
+            off = dir < 0 ? nodeSize(node) : 0;
+        } else {
+            return false;
+        }
+    }
+}
+const domIndex = function(node) {
+    let n = node;
+    for(let index = 0;; index++){
+        n = n.previousSibling;
+        if (!n) return index;
+    }
+};
+function nodeSize(node) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
+}
+function syncNodeSelection(view, sel) {
+    const v = view;
+    if (sel instanceof _prosemirrorstate.NodeSelection) {
+        const desc = v.docView.descAt(sel.from);
+        if (desc != v.lastSelectedViewDesc) {
+            clearNodeSelection(v);
+            if (desc) desc.selectNode();
+            v.lastSelectedViewDesc = desc;
+        }
+    } else {
+        clearNodeSelection(v);
+    }
+}
+// Clear all DOM statefulness of the last node selection.
+function clearNodeSelection(view) {
+    const v = view;
+    if (v.lastSelectedViewDesc) {
+        if (v.lastSelectedViewDesc.parent) v.lastSelectedViewDesc.deselectNode();
+        v.lastSelectedViewDesc = undefined;
+    }
+}
+function hasSelection(view) {
+    const v = view;
+    const sel = v.domSelectionRange();
+    if (!sel.anchorNode) return false;
+    try {
+        // Firefox will raise 'permission denied' errors when accessing
+        // properties of `sel.anchorNode` when it's in a generated CSS
+        // element.
+        return v.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode) && (v.editable || v.dom.contains(// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sel.focusNode.nodeType == 3 ? sel.focusNode.parentNode : sel.focusNode));
+    } catch (_) {
+        return false;
+    }
+}
+function editorOwnsSelection(view) {
+    return view.editable ? view.hasFocus() : hasSelection(view) && document.activeElement && document.activeElement.contains(view.dom);
+}
+function selectCursorWrapper(view) {
+    const v = view;
+    const domSel = v.domSelection(), range = document.createRange();
+    if (!domSel) return;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const node = v.cursorWrapper.dom, img = node.nodeName == "IMG";
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (img) range.setStart(node.parentNode, domIndex(node) + 1);
+    else range.setStart(node, 0);
+    range.collapse(true);
+    domSel.removeAllRanges();
+    domSel.addRange(range);
+    // Kludge to kill 'control selection' in IE11 when selecting an
+    // invisible cursor wrapper, since that would result in those weird
+    // resize handles and a selection that considers the absolutely
+    // positioned wrapper, rather than the root editable node, the
+    // focused element.
+    if (!img && !v.state.selection.visible && _browser.browser.ie && _browser.browser.ie_version <= 11) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        node.disabled = true;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        node.disabled = false;
+    }
+}
+function temporarilyEditableNear(view, pos) {
+    const v = view;
+    const { node, offset } = v.docView.domFromPos(pos, 0);
+    const after = offset < node.childNodes.length ? node.childNodes[offset] : null;
+    const before = offset ? node.childNodes[offset - 1] : null;
+    if (_browser.browser.safari && after && after.contentEditable == "false") return setEditable(after);
+    if ((!after || after.contentEditable == "false") && (!before || before.contentEditable == "false")) {
+        if (after) return setEditable(after);
+        else if (before) return setEditable(before);
+    }
+    return;
+}
+function setEditable(element) {
+    element.contentEditable = "true";
+    if (_browser.browser.safari && element.draggable) {
+        element.draggable = false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        element.wasDraggable = true;
+    }
+    return element;
+}
+function resetEditable(element) {
+    element.contentEditable = "false";
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (element.wasDraggable) {
+        element.draggable = true;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        element.wasDraggable = null;
+    }
+}
+function removeClassOnSelectionChange(view) {
+    const v = view;
+    const doc = v.dom.ownerDocument;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    doc.removeEventListener("selectionchange", v.input.hideSelectionGuard);
+    const domSel = v.domSelectionRange();
+    const node = domSel.anchorNode, offset = domSel.anchorOffset;
+    doc.addEventListener("selectionchange", v.input.hideSelectionGuard = ()=>{
+        if (domSel.anchorNode != node || domSel.anchorOffset != offset) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            doc.removeEventListener("selectionchange", v.input.hideSelectionGuard);
+            setTimeout(()=>{
+                if (!editorOwnsSelection(v) || v.state.selection.visible) v.dom.classList.remove("ProseMirror-hideselection");
+            }, 20);
+        }
+    });
+}
+const brokenSelectBetweenUneditable = _browser.browser.safari || _browser.browser.chrome && _browser.browser.chrome_version < 63;
+function selectionToDOM(view) {
+    let force = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    const v = view;
+    const sel = v.state.selection;
+    syncNodeSelection(v, sel);
+    if (!editorOwnsSelection(v)) return;
+    // The delayed drag selection causes issues with Cell Selections
+    // in Safari. And the drag selection delay is to workarond issues
+    // which only present in Chrome.
+    if (!force && v.input.mouseDown && v.input.mouseDown.allowDefault && _browser.browser.chrome) {
+        const domSel = v.domSelectionRange(), curSel = v.domObserver.currentSelection;
+        if (domSel.anchorNode && curSel.anchorNode && isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset, curSel.anchorNode, curSel.anchorOffset)) {
+            v.input.mouseDown.delayedSelectionSync = true;
+            v.domObserver.setCurSelection();
+            return;
+        }
+    }
+    v.domObserver.disconnectSelection();
+    if (v.cursorWrapper) {
+        selectCursorWrapper(v);
+    } else {
+        const { anchor, head } = sel;
+        let resetEditableFrom;
+        let resetEditableTo;
+        if (brokenSelectBetweenUneditable && !(sel instanceof _prosemirrorstate.TextSelection)) {
+            if (!sel.$from.parent.inlineContent) resetEditableFrom = temporarilyEditableNear(v, sel.from);
+            if (!sel.empty && !sel.$from.parent.inlineContent) resetEditableTo = temporarilyEditableNear(v, sel.to);
+        }
+        v.docView.setSelection(anchor, head, v.root, force);
+        if (brokenSelectBetweenUneditable) {
+            if (resetEditableFrom) resetEditable(resetEditableFrom);
+            if (resetEditableTo) resetEditable(resetEditableTo);
+        }
+        if (sel.visible) {
+            v.dom.classList.remove("ProseMirror-hideselection");
+        } else {
+            v.dom.classList.add("ProseMirror-hideselection");
+            if ("onselectionchange" in document) removeClassOnSelectionChange(v);
+        }
+    }
+    v.domObserver.setCurSelection();
+    v.domObserver.connectSelection();
+}

package/dist/cjs/ssr.js

@@ -0,0 +1,85 @@
+/* eslint-disable @typescript-eslint/no-empty-function */ /**
+ * @fileoverview
+ *
+ * Stubs for ProseMirror View during SSR. These are extremely
+ * barebones, because they _do not need to actually work_. They
+ * just need to prevent errors from being thrown when ProseMirror
+ * View attemps to access these APIs while constructing the
+ * initial EditorView. None of these APIs are necessary for SSR to
+ * work properly, so it's fine that they're all no-ops.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "setSsrStubs", {
+    enumerable: true,
+    get: function() {
+        return setSsrStubs;
+    }
+});
+let ClassList = class ClassList {
+    add() {}
+    remove() {}
+};
+let ElementStub = class ElementStub {
+    get parent() {
+        return new ElementStub();
+    }
+    get parentNode() {
+        return new ElementStub();
+    }
+    nodeName = "div";
+    appendChild() {
+        return new ElementStub();
+    }
+    setAttribute() {}
+    hasAttribute() {
+        return false;
+    }
+    insertBefore() {}
+    get classList() {
+        return new ClassList();
+    }
+    get ownerDocument() {
+        return new DocumentStub();
+    }
+    style = {};
+    addEventListener() {}
+    removeEventListener() {}
+    replaceChildren() {}
+};
+let DocumentStub = class DocumentStub {
+    createElement() {
+        return new ElementStub();
+    }
+    addEventListener() {}
+    removeEventListener() {}
+    get documentElement() {
+        return new ElementStub();
+    }
+};
+function setSsrStubs() {
+    const prevWindow = globalThis.window;
+    // @ts-expect-error HACK - EditorView checks for window.MutationObserver
+    // in its constructor, which breaks SSR. We temporarily set window
+    // to an empty object to prevent an error from being thrown, and then
+    // clean it up so that other isomorphic code doesn't get confused about
+    // whether there's a functioning global window object
+    globalThis.window ??= {
+        visualViewport: null
+    };
+    const prevDocument = globalThis.document;
+    // @ts-expect-error HACK: This is only used during SSR, and only
+    // to prevent outright errors when ProseMirror View attempts to
+    // access document properties either on import or when constructing
+    // the EditorView.
+    globalThis.document ??= new DocumentStub();
+    return function cleanupSsrStubs() {
+        if (globalThis.window !== prevWindow) {
+            globalThis.window = prevWindow;
+        }
+        if (globalThis.document !== prevDocument) {
+            globalThis.document = prevDocument;
+        }
+    };
+}

package/dist/cjs/testing/editorViewTestHelpers.js

@@ -0,0 +1,111 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ "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, {
+    findTextNode: function() {
+        return findTextNode;
+    },
+    tempEditor: function() {
+        return tempEditor;
+    }
+});
+const _react = require("@testing-library/react");
+const _expect = require("expect");
+const _prosemirrormodel = require("prosemirror-model");
+const _prosemirrorstate = require("prosemirror-state");
+const _prosemirrortestbuilder = require("prosemirror-test-builder");
+const _react1 = /*#__PURE__*/ _interop_require_default(require("react"));
+const _ProseMirror = require("../components/ProseMirror.js");
+const _ProseMirrorDoc = require("../components/ProseMirrorDoc.js");
+const _useEditorEffect = require("../hooks/useEditorEffect.js");
+const _reactKeys = require("../plugins/reactKeys.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const toEqualNode = function(actual, expected) {
+    if (!(actual instanceof _prosemirrormodel.Node && expected instanceof _prosemirrormodel.Node)) {
+        throw new Error("Must be comparing nodes");
+    }
+    const pass = (0, _prosemirrortestbuilder.eq)(actual, expected);
+    return {
+        message: ()=>// `this` context will have correct typings
+            `expected ${this.utils.printReceived(actual)} ${pass ? "not " : ""}to equal ${this.utils.printExpected(expected)}`,
+        pass
+    };
+};
+_expect.expect.extend({
+    toEqualNode
+});
+function tempEditor(param) {
+    let { doc: startDoc, selection, controlled, plugins, ...props } = param;
+    startDoc = startDoc ?? (0, _prosemirrortestbuilder.doc)((0, _prosemirrortestbuilder.p)());
+    const state = _prosemirrorstate.EditorState.create({
+        doc: startDoc,
+        schema: _prosemirrortestbuilder.schema,
+        selection: selection ?? startDoc.tag?.a ? _prosemirrorstate.TextSelection.create(startDoc, startDoc.tag.a, startDoc.tag?.b) : undefined,
+        plugins: [
+            ...plugins ?? [],
+            (0, _reactKeys.reactKeys)()
+        ]
+    });
+    let view = null;
+    function Test() {
+        (0, _useEditorEffect.useEditorEffect)((v)=>{
+            view = v;
+        });
+        return null;
+    }
+    const { rerender, unmount } = (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_ProseMirror.ProseMirror, {
+        ...controlled ? {
+            state
+        } : {
+            defaultState: state
+        },
+        ...props
+    }, /*#__PURE__*/ _react1.default.createElement(Test, null), /*#__PURE__*/ _react1.default.createElement(_ProseMirrorDoc.ProseMirrorDoc, null)));
+    function rerenderEditor() {
+        let { ...newProps } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        rerender(/*#__PURE__*/ _react1.default.createElement(_ProseMirror.ProseMirror, {
+            ...controlled ? {
+                state
+            } : {
+                defaultState: state
+            },
+            ...props,
+            ...newProps
+        }, /*#__PURE__*/ _react1.default.createElement(Test, null), /*#__PURE__*/ _react1.default.createElement(_ProseMirrorDoc.ProseMirrorDoc, null)));
+        return view;
+    }
+    // We need two renders for the hasContentDOM state to settle
+    rerenderEditor();
+    return {
+        view: view,
+        rerender: rerenderEditor,
+        unmount
+    };
+}
+function findTextNodeInner(node, text) {
+    if (node.nodeType == 3) {
+        if (node.nodeValue == text) return node;
+    } else if (node.nodeType == 1) {
+        for(let ch = node.firstChild; ch; ch = ch.nextSibling){
+            const found = findTextNodeInner(ch, text);
+            if (found) return found;
+        }
+    }
+    return undefined;
+}
+function findTextNode(node, text) {
+    const found = findTextNodeInner(node, text);
+    if (found) return found;
+    throw new Error("Unable to find matching text node");
+}

package/dist/cjs/testing/setupProseMirrorView.js

@@ -0,0 +1,94 @@
+/* Copyright (c) The New York Times Company */ "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, {
+    setupProseMirrorView: function() {
+        return setupProseMirrorView;
+    },
+    teardownProseMirrorView: function() {
+        return teardownProseMirrorView;
+    }
+});
+let oldElementFromPoint;
+let oldGetClientRects;
+let oldGetBoundingClientRect;
+const mockElementFromPoint = ()=>globalThis.document.body;
+const mockGetBoundingClientRect = ()=>{
+    return {
+        bottom: 0,
+        height: 0,
+        left: 0,
+        right: 0,
+        top: 0,
+        width: 0,
+        x: 0,
+        y: 0,
+        toJSON () {
+            return {
+                bottom: 0,
+                height: 0,
+                left: 0,
+                right: 0,
+                top: 0,
+                width: 0,
+                x: 0,
+                y: 0
+            };
+        }
+    };
+};
+const mockGetClientRects = ()=>{
+    const list = [
+        {
+            bottom: 0,
+            height: 0,
+            left: 0,
+            right: 0,
+            top: 0,
+            width: 0,
+            x: 0,
+            y: 0,
+            toJSON () {
+                return {
+                    bottom: 0,
+                    height: 0,
+                    left: 0,
+                    right: 0,
+                    top: 0,
+                    width: 0,
+                    x: 0,
+                    y: 0
+                };
+            }
+        }
+    ];
+    const domRectList = Object.assign(list, {
+        item (index) {
+            return list[index] ?? null;
+        }
+    });
+    return domRectList;
+};
+function setupProseMirrorView() {
+    oldElementFromPoint = Document.prototype.elementFromPoint;
+    Document.prototype.elementFromPoint = mockElementFromPoint;
+    oldGetClientRects = Range.prototype.getClientRects;
+    Range.prototype.getClientRects = mockGetClientRects;
+    oldGetBoundingClientRect = Range.prototype.getBoundingClientRect;
+    Range.prototype.getBoundingClientRect = mockGetBoundingClientRect;
+}
+function teardownProseMirrorView() {
+    // @ts-expect-error jsdom actually doesn't implement these, so they might be undefined
+    Document.prototype.elementFromPoint = oldElementFromPoint;
+    // @ts-expect-error jsdom actually doesn't implement these, so they might be undefined
+    Range.prototype.getClientRects = oldGetClientRects;
+    // @ts-expect-error jsdom actually doesn't implement these, so they might be undefined
+    Range.prototype.getBoundingClientRect = oldGetBoundingClientRect;
+}