@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/props.js

@@ -0,0 +1,283 @@
+"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, {
+    htmlAttrsToReactProps: function() {
+        return htmlAttrsToReactProps;
+    },
+    mergeReactProps: function() {
+        return mergeReactProps;
+    }
+});
+const _classnames = /*#__PURE__*/ _interop_require_default(require("classnames"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let patched = false;
+function patchConsoleError() {
+    if (patched) return;
+    /* eslint-disable no-console */ const consoleError = console.error;
+    console.error = function() {
+        for(var _len = arguments.length, data = new Array(_len), _key = 0; _key < _len; _key++){
+            data[_key] = arguments[_key];
+        }
+        const [message, prop, correction] = data;
+        if (typeof message === "string" && message.includes("Invalid DOM property `%s`. Did you mean `%s`?") && prop === "STYLE" && correction === "style") {
+            return;
+        }
+        consoleError(...data);
+    };
+    patched = true;
+/* eslint-enable no-console */ }
+function mergeStyleProps(a, b) {
+    if (!("STYLE" in a) || typeof a.STYLE !== "string") {
+        if (!("STYLE" in b) || typeof b.STYLE !== "string") {
+            return undefined;
+        }
+        return b.STYLE;
+    }
+    if (!("STYLE" in b) || typeof b.STYLE !== "string") {
+        return a.STYLE;
+    }
+    return `${a.STYLE.match(/;\s*$/) ? a.STYLE : `${a.STYLE};`} ${b.STYLE}`;
+}
+function mergeReactProps(a, b) {
+    return {
+        ...a,
+        ...b,
+        className: (0, _classnames.default)(a.className, b.className),
+        STYLE: mergeStyleProps(a, b),
+        style: {
+            ...a.style,
+            ...b.style
+        }
+    };
+}
+function htmlAttrsToReactProps(attrs) {
+    patchConsoleError();
+    const props = {};
+    for (const [attrName, attrValue] of Object.entries(attrs)){
+        switch(attrName.toLowerCase()){
+            case "class":
+                {
+                    props.className = attrValue;
+                    break;
+                }
+            case "style":
+                {
+                    // HACK: React expects the `style` prop to be an
+                    // object mapping from CSS property name to value.
+                    // However, it will pass un-recognized props through
+                    // to the underlying DOM element, and HTML attributes
+                    // are case insensitive. So we use `STYLE` instead,
+                    // which React doesn't intercept, but the DOM treats
+                    // as `style`
+                    props.STYLE = attrValue;
+                    break;
+                }
+            case "autocapitalize":
+                {
+                    props.autoCapitalize = attrValue;
+                    break;
+                }
+            case "contenteditable":
+                {
+                    if (attrValue === "" || attrValue === "true") {
+                        props.contentEditable = true;
+                        break;
+                    }
+                    if (attrValue === "false") {
+                        props.contentEditable = false;
+                        break;
+                    }
+                    if (attrValue === "plaintext-only") {
+                        props.contentEditable = "plaintext-only";
+                        break;
+                    }
+                    props.contentEditable = null;
+                    break;
+                }
+            case "draggable":
+                {
+                    props.draggable = attrValue != null;
+                    break;
+                }
+            case "enterkeyhint":
+                {
+                    props.enterKeyHint = attrValue;
+                    break;
+                }
+            case "for":
+                {
+                    props.htmlFor = attrValue;
+                    break;
+                }
+            case "hidden":
+                {
+                    props.hidden = attrValue;
+                    break;
+                }
+            case "inputmode":
+                {
+                    props.inputMode = attrValue;
+                    break;
+                }
+            case "itemprop":
+                {
+                    props.itemProp = attrValue;
+                    break;
+                }
+            case "spellcheck":
+                {
+                    if (attrValue === "" || attrValue === "true") {
+                        props.spellCheck = true;
+                        break;
+                    }
+                    if (attrValue === "false") {
+                        props.spellCheck = false;
+                        break;
+                    }
+                    props.spellCheck = null;
+                    break;
+                }
+            case "tabindex":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.tabIndex = numValue;
+                    }
+                    break;
+                }
+            case "autocomplete":
+                {
+                    props.autoComplete = attrValue;
+                    break;
+                }
+            case "autofocus":
+                {
+                    props.autoFocus = attrValue != null;
+                    break;
+                }
+            case "formaction":
+                {
+                    props.formAction = attrValue;
+                    break;
+                }
+            case "formenctype":
+                {
+                    props.formEnctype = attrValue;
+                    break;
+                }
+            case "formmethod":
+                {
+                    props.formMethod = attrValue;
+                    break;
+                }
+            case "formnovalidate":
+                {
+                    props.formNoValidate = attrValue;
+                    break;
+                }
+            case "formtarget":
+                {
+                    props.formTarget = attrValue;
+                    break;
+                }
+            case "maxlength":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.maxLength = attrValue;
+                    }
+                    break;
+                }
+            case "minlength":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.minLength = attrValue;
+                    }
+                    break;
+                }
+            case "max":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.max = attrValue;
+                    }
+                    break;
+                }
+            case "min":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.min = attrValue;
+                    }
+                    break;
+                }
+            case "multiple":
+                {
+                    props.multiple = attrValue != null;
+                    break;
+                }
+            case "readonly":
+                {
+                    props.readOnly = attrValue != null;
+                    break;
+                }
+            case "required":
+                {
+                    props.required = attrValue != null;
+                    break;
+                }
+            case "size":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.size = attrValue;
+                    }
+                    break;
+                }
+            case "step":
+                {
+                    if (attrValue === "any") {
+                        props.step = attrValue;
+                        break;
+                    }
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue) && numValue > 0) {
+                        props.step = attrValue;
+                    }
+                    break;
+                }
+            case "disabled":
+                {
+                    props.disabled = attrValue != null;
+                    break;
+                }
+            case "rows":
+                {
+                    const numValue = parseInt(attrValue, 10);
+                    if (!Number.isNaN(numValue)) {
+                        props.rows = attrValue;
+                    }
+                    break;
+                }
+            default:
+                {
+                    props[attrName] = attrValue;
+                    break;
+                }
+        }
+    }
+    return props;
+}

package/dist/cjs/refs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMergedDOMRefs", {
+    enumerable: true,
+    get: function() {
+        return useMergedDOMRefs;
+    }
+});
+const _react = require("react");
+function useMergedDOMRefs() {
+    for(var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++){
+        refs[_key] = arguments[_key];
+    }
+    return (0, _react.useCallback)((value)=>{
+        refs.forEach((ref)=>{
+            if (typeof ref === "function") {
+                ref(value);
+                return;
+            }
+            if (ref) {
+                ref.current = value;
+            }
+        });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, refs);
+}

package/dist/cjs/testing/editorViewTestHelpers.js

@@ -0,0 +1,109 @@
+/* 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;
+    }
+    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;
+}

package/dist/cjs/tiptap/ReactProseMirrorNodeView.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactProseMirrorNodeView", {
+    enumerable: true,
+    get: function() {
+        return ReactProseMirrorNodeView;
+    }
+});
+const _core = require("@tiptap/core");
+let ReactProseMirrorNodeView = class ReactProseMirrorNodeView extends _core.NodeView {
+    _dom;
+    _contentDOM;
+    constructor(component, props, dom, contentDOM, options){
+        super(component, props, options);
+        this._dom = dom;
+        this._contentDOM = contentDOM;
+    }
+    get dom() {
+        return this._dom;
+    }
+    get contentDOM() {
+        return this._contentDOM;
+    }
+};

package/dist/cjs/tiptap/TiptapEditor.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TiptapEditor", {
+    enumerable: true,
+    get: function() {
+        return TiptapEditor;
+    }
+});
+const _core = require("@tiptap/core");
+const _prosemirrorstate = require("prosemirror-state");
+const _StaticEditorView = require("../StaticEditorView.js");
+let TiptapEditor = class TiptapEditor extends _core.Editor {
+    constructor(options = {}){
+        super({
+            ...options,
+            element: null
+        });
+    }
+    get view() {
+        return(// @ts-expect-error private property
+        this.editorView ?? new _StaticEditorView.StaticEditorView({
+            state: _prosemirrorstate.EditorState.create({
+                schema: this.extensionManager.schema
+            }),
+            ...this.options.editorProps,
+            attributes: {
+                role: "textbox",
+                ...this.options.editorProps.attributes
+            }
+        }));
+    }
+};