@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/dom.js

@@ -0,0 +1,147 @@
+/* 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) {
+            const child = node.childNodes[off + (dir < 0 ? -1 : 0)];
+            if (child.nodeType == 1 && child.contentEditable == "false") {
+                if (child.pmViewDesc?.ignoreForSelection) off += dir;
+                else return false;
+            } else {
+                node = child;
+                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/findDOMNode.js

@@ -0,0 +1,46 @@
+"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, {
+    findDOMNode: function() {
+        return findDOMNode;
+    },
+    getInstance: function() {
+        return getInstance;
+    }
+});
+const _reflection = require("react-reconciler/reflection.js");
+function getInstance(key) {
+    return key._reactInternals;
+}
+// https://github.com/facebook/react/blob/main/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js#L322
+function getPublicInstance(instance) {
+    return instance;
+}
+// https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactFiberReconciler.js#L153
+function findHostInstance(component) {
+    const fiber = getInstance(component);
+    if (fiber === undefined) {
+        if (typeof component.render === "function") {
+            throw new Error("Unable to find node on an unmounted component.");
+        } else {
+            const keys = Object.keys(component).join(",");
+            throw new Error(`Argument appears to not be a ReactComponent. Keys: ${keys}`);
+        }
+    }
+    const hostFiber = (0, _reflection.findCurrentHostFiber)(fiber);
+    if (hostFiber === null) {
+        return null;
+    }
+    return getPublicInstance(hostFiber.stateNode);
+}
+function findDOMNode(componentOrElement) {
+    return findHostInstance(componentOrElement);
+}

package/dist/cjs/hooks/useClientLayoutEffect.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useClientLayoutEffect", {
+    enumerable: true,
+    get: function() {
+        return useClientLayoutEffect;
+    }
+});
+const _react = require("react");
+function useClientLayoutEffect() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    if (typeof document === "undefined") return;
+    // eslint-disable-next-line react-hooks/rules-of-hooks, react-hooks/exhaustive-deps
+    (0, _react.useLayoutEffect)(...args);
+}

package/dist/cjs/hooks/useComponentEventListeners.js

@@ -0,0 +1,72 @@
+/* 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 _reactdom = require("react-dom");
+function useComponentEventListeners(handleDOMEventsProp) {
+    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
+    ]);
+    (0, _react.useLayoutEffect)(()=>{
+        if (!handleDOMEventsProp) return;
+        for (const [eventType, handler] of Object.entries(handleDOMEventsProp)){
+            if (!handler) return;
+            registerEventListener(eventType, handler);
+        }
+        return ()=>{
+            for (const [eventType, handler] of Object.entries(handleDOMEventsProp)){
+                if (!handler) return;
+                unregisterEventListener(eventType, handler);
+            }
+        };
+    }, [
+        handleDOMEventsProp,
+        registerEventListener,
+        unregisterEventListener
+    ]);
+    const handleDOMEvents = (0, _react.useMemo)(()=>{
+        const domEventHandlers = {};
+        for (const [eventType, handlers] of registry.entries()){
+            function handleEvent(view, event) {
+                for (const handler of handlers){
+                    let handled = false;
+                    (0, _reactdom.unstable_batchedUpdates)(()=>{
+                        handled = !!handler(view, event);
+                    });
+                    if (handled || event.defaultPrevented) return true;
+                }
+                return false;
+            }
+            domEventHandlers[eventType] = handleEvent;
+        }
+        return domEventHandlers;
+    }, [
+        registry
+    ]);
+    return {
+        registerEventListener,
+        unregisterEventListener,
+        handleDOMEvents
+    };
+}

package/dist/cjs/hooks/useEditor.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEditor", {
+    enumerable: true,
+    get: function() {
+        return useEditor;
+    }
+});
+const _react = require("react");
+const _reactdom = require("react-dom");
+const _ReactEditorView = require("../ReactEditorView.js");
+const _StaticEditorView = require("../StaticEditorView.js");
+const _constants = require("../constants.js");
+const _RenderStoreContext = require("../contexts/RenderStoreContext.js");
+const _beforeInputPlugin = require("../plugins/beforeInputPlugin.js");
+const _useClientLayoutEffect = require("./useClientLayoutEffect.js");
+const _useComponentEventListeners = require("./useComponentEventListeners.js");
+const _useEffectEvent = require("./useEffectEvent.js");
+const _useForceUpdate = require("./useForceUpdate.js");
+let didWarnValueDefaultValue = false;
+function useEditor(mount, options) {
+    if (process.env.NODE_ENV !== "production") {
+        if (options.defaultState !== undefined && options.state !== undefined && !didWarnValueDefaultValue) {
+            console.error("A component contains a ProseMirror editor with both state and defaultState props. " + "ProseMirror editors must be either controlled or uncontrolled " + "(specify either the state prop, or the defaultState prop, but not both). " + "Decide between using a controlled or uncontrolled ProseMirror editor " + "and remove one of these props. More info: " + "https://reactjs.org/link/controlled-components");
+            didWarnValueDefaultValue = true;
+        }
+    }
+    const flushSyncRef = (0, _react.useRef)(true);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const defaultState = options.defaultState ?? _constants.EMPTY_STATE;
+    const [_state, setState] = (0, _react.useState)(defaultState);
+    const state = options.state ?? _state;
+    const [renderStore] = (0, _react.useState)(_RenderStoreContext.createRenderStore);
+    const { handleDOMEvents, registerEventListener, unregisterEventListener } = (0, _useComponentEventListeners.useComponentEventListeners)(options.handleDOMEvents);
+    const plugins = (0, _react.useMemo)(()=>[
+            ...options.plugins ?? [],
+            (0, _beforeInputPlugin.beforeInputPlugin)()
+        ], [
+        options.plugins
+    ]);
+    const dispatchTransaction = (0, _react.useCallback)(function dispatchTransaction(tr) {
+        const async = tr.getMeta("async");
+        if (flushSyncRef.current && !async) {
+            (0, _reactdom.flushSync)(()=>{
+                if (!options.state) {
+                    setState((s)=>s.apply(tr));
+                }
+                if (options.dispatchTransaction) {
+                    options.dispatchTransaction.call(this, tr);
+                }
+                if (options.stableContexts) {
+                    renderStore.announce();
+                }
+            });
+            renderStore.announced = false;
+        } else {
+            if (!options.state) {
+                setState((s)=>s.apply(tr));
+            }
+            if (options.dispatchTransaction) {
+                options.dispatchTransaction.call(this, tr);
+            }
+        }
+    }, [
+        options.dispatchTransaction,
+        options.state,
+        options.stableContexts,
+        renderStore
+    ]);
+    const directEditorProps = {
+        ...options,
+        state,
+        plugins,
+        dispatchTransaction,
+        handleDOMEvents
+    };
+    const [view, setView] = (0, _react.useState)(()=>{
+        return new _StaticEditorView.StaticEditorView(directEditorProps);
+    });
+    const createEditorView = (0, _useEffectEvent.useEffectEvent)((mount)=>{
+        if (mount && !options.static) {
+            const view = new _ReactEditorView.ReactEditorView({
+                mount
+            }, directEditorProps);
+            view.dom.addEventListener("compositionend", forceUpdate);
+            return view;
+        }
+        return new _StaticEditorView.StaticEditorView(directEditorProps);
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        const view = createEditorView(mount);
+        setView(view);
+        return ()=>{
+            view.destroy();
+        };
+    }, [
+        createEditorView,
+        mount
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        // Ensure that the EditorView hasn't been destroyed before
+        // running effects. Running effects will reattach selection
+        // change listeners if the EditorView has been destroyed.
+        if (view instanceof _ReactEditorView.ReactEditorView && !view.isDestroyed && view.domSelection()) {
+            flushSyncRef.current = false;
+            view.commitPendingEffects();
+            flushSyncRef.current = true;
+        }
+    });
+    view.update(directEditorProps);
+    const editor = (0, _react.useMemo)(()=>({
+            view,
+            flushSyncRef,
+            registerEventListener,
+            unregisterEventListener,
+            isStatic: options.static ?? false
+        }), [
+        options.static,
+        registerEventListener,
+        unregisterEventListener,
+        view
+    ]);
+    return {
+        editor,
+        state,
+        renderStore: options.stableContexts ? renderStore : null
+    };
+}

package/dist/cjs/hooks/useEditorEffect.js

@@ -0,0 +1,39 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEditorEffect", {
+    enumerable: true,
+    get: function() {
+        return useEditorEffect;
+    }
+});
+const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _useLayoutGroupEffect = require("./useLayoutGroupEffect.js");
+function useEditorEffect(effect, dependencies) {
+    const { view, flushSyncRef } = (0, _react.useContext)(_EditorContext.EditorContext);
+    // The rules of hooks want `effect` to be included in the
+    // dependency list, but dependency issues for `effect` will
+    // be caught by the linter at the call-site for
+    // `useEditorViewLayoutEffect`.
+    // Note: we specifically don't want to re-run the effect
+    // every time it changes, because it will most likely
+    // be defined inline and run on every re-render.
+    (0, _useLayoutGroupEffect.useLayoutGroupEffect)(()=>{
+        if (view instanceof _ReactEditorView.ReactEditorView) {
+            flushSyncRef.current = false;
+            const result = effect(view);
+            flushSyncRef.current = true;
+            return result;
+        }
+    }, // The rules of hooks want to be able to statically
+    // verify the dependencies for the effect, but this will
+    // have already happened at the call-site.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    dependencies && [
+        view,
+        ...dependencies
+    ]);
+}

package/dist/cjs/hooks/useEditorEventCallback.js

@@ -0,0 +1,38 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEditorEventCallback", {
+    enumerable: true,
+    get: function() {
+        return useEditorEventCallback;
+    }
+});
+const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _useEditorEffect = require("./useEditorEffect.js");
+function assertIsReactEditorView(view) {
+    if (view instanceof _ReactEditorView.ReactEditorView) {
+        return;
+    }
+    throw new DOMException("ProseMirror document is not mounted", "InvalidStateError");
+}
+function useEditorEventCallback(callback) {
+    const ref = (0, _react.useRef)(callback);
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    (0, _useEditorEffect.useEditorEffect)(()=>{
+        ref.current = callback;
+    }, [
+        callback
+    ]);
+    return (0, _react.useCallback)(function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        assertIsReactEditorView(view);
+        return ref.current.call(this, view, ...args);
+    }, [
+        view
+    ]);
+}

package/dist/cjs/hooks/useEditorEventListener.js

@@ -0,0 +1,34 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEditorEventListener", {
+    enumerable: true,
+    get: function() {
+        return useEditorEventListener;
+    }
+});
+const _react = require("react");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _useEditorEffect = require("./useEditorEffect.js");
+function useEditorEventListener(eventType, handler) {
+    const { registerEventListener, unregisterEventListener } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const ref = (0, _react.useRef)(handler);
+    (0, _useEditorEffect.useEditorEffect)(()=>{
+        ref.current = handler;
+    }, [
+        handler
+    ]);
+    const eventHandler = (0, _react.useCallback)(function(view, event) {
+        return ref.current.call(this, view, event);
+    }, []);
+    (0, _useEditorEffect.useEditorEffect)(()=>{
+        registerEventListener(eventType, eventHandler);
+        return ()=>unregisterEventListener(eventType, eventHandler);
+    }, [
+        eventHandler,
+        eventType,
+        registerEventListener,
+        unregisterEventListener
+    ]);
+}

package/dist/cjs/hooks/useEditorState.js

@@ -0,0 +1,18 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEditorState", {
+    enumerable: true,
+    get: function() {
+        return useEditorState;
+    }
+});
+const _react = require("react");
+const _EditorStateContext = require("../contexts/EditorStateContext.js");
+const _RenderStoreContext = require("../contexts/RenderStoreContext.js");
+function useEditorState() {
+    const editorState = (0, _react.useContext)(_EditorStateContext.EditorStateContext);
+    const store = (0, _RenderStoreContext.useRenderStore)();
+    return store?.state ?? editorState;
+}

package/dist/cjs/hooks/useEditorStateSelector.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEditorStateSelector", {
+    enumerable: true,
+    get: function() {
+        return useEditorStateSelector;
+    }
+});
+const _react = require("react");
+const _EditorStateStoreContext = require("../contexts/EditorStateStoreContext.js");
+function useEditorStateSelector(selector) {
+    const store = (0, _react.useContext)(_EditorStateStoreContext.EditorStateStoreContext);
+    const getSnapshot = ()=>selector(store.getState());
+    return (0, _react.useSyncExternalStore)(store.subscribe, getSnapshot, getSnapshot);
+}

package/dist/cjs/hooks/useEffectEvent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useEffectEvent", {
+    enumerable: true,
+    get: function() {
+        return useEffectEvent;
+    }
+});
+const _react = require("react");
+function useEffectEvent(fn) {
+    const ref = (0, _react.useRef)(fn);
+    // Ideally this would be a useInsertionEffect, but
+    // that was introduced in React 18 and we still
+    // support React 17. useLayoutEffect is safe
+    // here as long as the function returned by
+    // useEffectEvent isn't called in a layout effect
+    // that's defined _before_ the useEffectEvent
+    // call, and effect events are never passed
+    // to child components.
+    (0, _react.useLayoutEffect)(()=>{
+        ref.current = fn;
+    }, [
+        fn
+    ]);
+    return (0, _react.useCallback)(function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const f = ref.current;
+        return f(...args);
+    }, []);
+}

package/dist/cjs/hooks/useForceUpdate.js

@@ -0,0 +1,15 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useForceUpdate", {
+    enumerable: true,
+    get: function() {
+        return useForceUpdate;
+    }
+});
+const _react = require("react");
+function useForceUpdate() {
+    const [, forceUpdate] = (0, _react.useReducer)((x)=>x + 1, 0);
+    return forceUpdate;
+}

package/dist/cjs/hooks/useIgnoreMutation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useIgnoreMutation", {
+    enumerable: true,
+    get: function() {
+        return useIgnoreMutation;
+    }
+});
+const _react = require("react");
+const _IgnoreMutationContext = require("../contexts/IgnoreMutationContext.js");
+const _useEditorEffect = require("./useEditorEffect.js");
+const _useEditorEventCallback = require("./useEditorEventCallback.js");
+function useIgnoreMutation(ignoreMutation) {
+    const register = (0, _react.useContext)(_IgnoreMutationContext.IgnoreMutationContext);
+    const ignoreMutationMemo = (0, _useEditorEventCallback.useEditorEventCallback)(ignoreMutation);
+    (0, _useEditorEffect.useEditorEffect)(()=>{
+        return register(ignoreMutationMemo);
+    }, [
+        register,
+        ignoreMutationMemo
+    ]);
+}

package/dist/cjs/hooks/useIsComposingIn.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useIsComposingIn", {
+    enumerable: true,
+    get: function() {
+        return useIsComposingIn;
+    }
+});
+const _react = require("react");
+const _NodeView = require("../components/nodes/NodeView.js");
+const _index = require("../index.js");
+function useIsComposingIn() {
+    const [isComposing, setIsComposing] = (0, _react.useState)(false);
+    const getPos = (0, _react.useContext)(_NodeView.GetPosContext);
+    (0, _index.useEditorEventListener)("compositionstart", (view)=>{
+        const compositionRoot = view.state.selection.$from.before();
+        setIsComposing(compositionRoot === getPos());
+    });
+    (0, _index.useEditorEventListener)("compositionend", ()=>{
+        setIsComposing(false);
+    });
+    return isComposing;
+}