@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/hooks/useIsEditorStatic.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useIsEditorStatic", {
+    enumerable: true,
+    get: function() {
+        return useIsEditorStatic;
+    }
+});
+const _react = require("react");
+const _EditorContext = require("../contexts/EditorContext.js");
+function useIsEditorStatic() {
+    return (0, _react.useContext)(_EditorContext.EditorContext)?.isStatic ?? false;
+}

package/dist/cjs/hooks/useIsNodeSelected.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useIsNodeSelected", {
+    enumerable: true,
+    get: function() {
+        return useIsNodeSelected;
+    }
+});
+const _react = require("react");
+const _useSelectNode = require("./useSelectNode.js");
+function useIsNodeSelected() {
+    const [isSelected, setIsSelected] = (0, _react.useState)(false);
+    (0, _useSelectNode.useSelectNode)(()=>{
+        setIsSelected(true);
+    }, ()=>{
+        setIsSelected(false);
+    });
+    return isSelected;
+}

package/dist/cjs/hooks/useLayoutGroupEffect.js

@@ -0,0 +1,20 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useLayoutGroupEffect", {
+    enumerable: true,
+    get: function() {
+        return useLayoutGroupEffect;
+    }
+});
+const _react = require("react");
+const _LayoutGroupContext = require("../contexts/LayoutGroupContext.js");
+const _useClientLayoutEffect = require("./useClientLayoutEffect.js");
+function useLayoutGroupEffect(effect, deps) {
+    const register = (0, _react.useContext)(_LayoutGroupContext.LayoutGroupContext);
+    // The rule for hooks wants to statically verify the deps,
+    // but the dependencies are up to the caller, not this implementation.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>register(effect), deps);
+}

package/dist/cjs/hooks/useMarkViewDescription.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMarkViewDescription", {
+    enumerable: true,
+    get: function() {
+        return useMarkViewDescription;
+    }
+});
+const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _viewdesc = require("../viewdesc.js");
+const _useClientLayoutEffect = require("./useClientLayoutEffect.js");
+const _useEffectEvent = require("./useEffectEvent.js");
+function useMarkViewDescription(getDOM, getContentDOM, constructor, props) {
+    const mountedRef = (0, _react.useRef)(false);
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const { parentRef, siblingsRef } = (0, _react.useContext)(_ChildDescriptionsContext.ChildDescriptionsContext);
+    const contentDOMRef = (0, _react.useRef)(null);
+    const viewDescRef = (0, _react.useRef)();
+    const childrenRef = (0, _react.useRef)([]);
+    const create = (0, _useEffectEvent.useEffectEvent)(()=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) {
+            return;
+        }
+        const dom = getDOM();
+        if (!dom) {
+            return;
+        }
+        const { mark, inline, getPos } = props;
+        const markView = constructor(mark, view, inline);
+        if (!markView) {
+            return;
+        }
+        const parent = parentRef.current;
+        const children = childrenRef.current;
+        const contentDOM = getContentDOM(markView);
+        const viewDesc = new _viewdesc.ReactMarkViewDesc(parent, children, getPos, mark, dom, contentDOM ?? markView.dom, markView);
+        // When create() runs after a destroy() (either here in a layout
+        // effect or in refUpdated), the inherited children still reference
+        // the just-destroyed desc. Re-parent them onto this fresh desc
+        // before any other code can observe the stale pointer.
+        for (const child of children){
+            child.parent = viewDesc;
+        }
+        contentDOMRef.current = contentDOM;
+        return viewDesc;
+    });
+    const update = (0, _useEffectEvent.useEffectEvent)(()=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) {
+            return false;
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return false;
+        }
+        const dom = getDOM();
+        if (!dom || dom !== viewDesc.dom) {
+            return false;
+        }
+        const contentDOM = getContentDOM(viewDesc);
+        if (contentDOM !== (viewDesc.contentDOM ?? dom)) {
+            return false;
+        }
+        const { mark } = props;
+        return viewDesc.matchesMark(mark);
+    });
+    const destroy = (0, _useEffectEvent.useEffectEvent)(()=>{
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        viewDescRef.current = undefined;
+        viewDesc.destroy();
+        const siblings = siblingsRef.current;
+        if (siblings.includes(viewDesc)) {
+            const index = siblings.indexOf(viewDesc);
+            siblings.splice(index, 1);
+        }
+        contentDOMRef.current = null;
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        mountedRef.current = true;
+        viewDescRef.current = create();
+        return ()=>{
+            mountedRef.current = false;
+            destroy();
+        };
+    }, [
+        create,
+        destroy
+    ]);
+    const refUpdated = (0, _react.useCallback)(()=>{
+        if (!mountedRef.current) return;
+        if (!update()) {
+            destroy();
+            viewDescRef.current = create();
+        }
+    }, [
+        create,
+        destroy,
+        update
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!update()) {
+            destroy();
+            viewDescRef.current = create();
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        const parent = parentRef.current;
+        const siblings = siblingsRef.current;
+        const children = childrenRef.current;
+        viewDesc.parent = parent;
+        (0, _viewdesc.placeViewDesc)(siblings, viewDesc);
+        for (const child of children){
+            child.parent = viewDesc;
+        }
+    });
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childrenRef
+        }), []);
+    return {
+        childContextValue,
+        contentDOM: contentDOMRef.current ?? viewDescRef.current?.dom,
+        refUpdated
+    };
+}

package/dist/cjs/hooks/useNodePos.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useNodePos", {
+    enumerable: true,
+    get: function() {
+        return useNodePos;
+    }
+});
+const _react = require("react");
+const _NodeView = require("../components/nodes/NodeView.js");
+const _useEditorState = require("./useEditorState.js");
+function useNodePos() {
+    (0, _useEditorState.useEditorState)();
+    const getPos = (0, _react.useContext)(_NodeView.GetPosContext);
+    return getPos();
+}

package/dist/cjs/hooks/useNodeViewDescription.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useNodeViewDescription", {
+    enumerable: true,
+    get: function() {
+        return useNodeViewDescription;
+    }
+});
+const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _viewdesc = require("../viewdesc.js");
+const _useClientLayoutEffect = require("./useClientLayoutEffect.js");
+const _useEffectEvent = require("./useEffectEvent.js");
+function useNodeViewDescription(getDOM, getContentDOM, constructor, props) {
+    const mountedRef = (0, _react.useRef)(false);
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const { parentRef, siblingsRef } = (0, _react.useContext)(_ChildDescriptionsContext.ChildDescriptionsContext);
+    const contentDOMRef = (0, _react.useRef)(null);
+    const viewDescRef = (0, _react.useRef)();
+    const childrenRef = (0, _react.useRef)([]);
+    const create = (0, _useEffectEvent.useEffectEvent)(()=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) {
+            return;
+        }
+        const dom = getDOM();
+        if (!dom) {
+            return;
+        }
+        const { node, getPos, decorations, innerDecorations } = props;
+        const nodeView = constructor(node, view, getPos, decorations, innerDecorations);
+        if (!nodeView) {
+            return;
+        }
+        const parent = parentRef.current;
+        const children = childrenRef.current;
+        const contentDOM = getContentDOM(nodeView);
+        const nodeDOM = nodeView.dom;
+        const viewDesc = new _viewdesc.ReactNodeViewDesc(parent, children, getPos, node, decorations, innerDecorations, dom, contentDOM, nodeDOM, nodeView);
+        for (const child of children){
+            child.parent = viewDesc;
+        }
+        (0, _viewdesc.placeViewDesc)(siblingsRef.current, viewDesc);
+        contentDOMRef.current = getContentDOM(nodeView);
+        return viewDesc;
+    });
+    const update = (0, _useEffectEvent.useEffectEvent)(()=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) {
+            return false;
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return false;
+        }
+        const dom = getDOM();
+        if (!dom || dom !== viewDesc.dom) {
+            return false;
+        }
+        const contentDOM = getContentDOM(viewDesc);
+        if (contentDOM !== viewDesc.contentDOM) {
+            return false;
+        }
+        if (!dom.contains(viewDesc.nodeDOM)) {
+            return false;
+        }
+        const { node, decorations, innerDecorations } = props;
+        return viewDesc.matchesNode(node, decorations, innerDecorations) || viewDesc.update(node, decorations, innerDecorations, view);
+    });
+    const destroy = (0, _useEffectEvent.useEffectEvent)(()=>{
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        viewDescRef.current = undefined;
+        viewDesc.destroy();
+        const siblings = siblingsRef.current;
+        if (siblings.includes(viewDesc)) {
+            const index = siblings.indexOf(viewDesc);
+            siblings.splice(index, 1);
+        }
+        contentDOMRef.current = null;
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        mountedRef.current = true;
+        viewDescRef.current = create();
+        return ()=>{
+            mountedRef.current = false;
+            destroy();
+        };
+    }, [
+        create,
+        destroy
+    ]);
+    const refUpdated = (0, _react.useCallback)(()=>{
+        if (!mountedRef.current) return;
+        if (!update()) {
+            destroy();
+            viewDescRef.current = create();
+        }
+    }, [
+        create,
+        destroy,
+        update
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!update()) {
+            destroy();
+            viewDescRef.current = create();
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        if (view.dom === viewDesc.dom && view instanceof _ReactEditorView.ReactEditorView) {
+            view.docView = viewDesc;
+        }
+        const parent = parentRef.current;
+        const siblings = siblingsRef.current;
+        const children = childrenRef.current;
+        viewDesc.parent = parent;
+        // In strict/concurrent mode, a node can sometimes re-render
+        // entirely on its own, without even its parent re-rendering.
+        // In this case, we will have added our view descriptions to
+        // our parent's children, but our parent has no opportunity
+        // to sort its children, because it never renders. So
+        // we always place ourselves among our siblings, too.
+        (0, _viewdesc.placeViewDesc)(siblings, viewDesc);
+        // If a child updates, usually it will re-render and sort
+        // our children for us. But it's possible to reorder
+        // child nodes without changing their keys or node
+        // instances, in which case our children _won't_
+        // rerender. As a fallback, we do one last pass through
+        // our own child view descriptions and make sure
+        // they're ordered. This should be a cheap no-op in most cases.
+        children.sort(_viewdesc.sortViewDescs);
+        for (const child of children){
+            child.parent = viewDesc;
+        }
+    });
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childrenRef
+        }), []);
+    const isMounted = (0, _react.useCallback)(()=>mountedRef.current, []);
+    return {
+        childContextValue,
+        contentDOM: contentDOMRef.current,
+        refUpdated,
+        isMounted
+    };
+}

package/dist/cjs/hooks/useReactKeys.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useReactKeys", {
+    enumerable: true,
+    get: function() {
+        return useReactKeys;
+    }
+});
+const _react = require("react");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _reactKeys = require("../plugins/reactKeys.js");
+function useReactKeys() {
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    return _reactKeys.reactKeysPluginKey.getState(view.state);
+}

package/dist/cjs/hooks/useSelectNode.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useSelectNode", {
+    enumerable: true,
+    get: function() {
+        return useSelectNode;
+    }
+});
+const _react = require("react");
+const _SelectNodeContext = require("../contexts/SelectNodeContext.js");
+const _useEditorEffect = require("./useEditorEffect.js");
+const _useEditorEventCallback = require("./useEditorEventCallback.js");
+function noop() {
+// empty
+}
+function useSelectNode(selectNode) {
+    let deselectNode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
+    const register = (0, _react.useContext)(_SelectNodeContext.SelectNodeContext);
+    const selectNodeMemo = (0, _useEditorEventCallback.useEditorEventCallback)(selectNode);
+    const deselectNodeMemo = (0, _useEditorEventCallback.useEditorEventCallback)(deselectNode);
+    return (0, _useEditorEffect.useEditorEffect)(()=>{
+        return register(selectNodeMemo, deselectNodeMemo);
+    }, [
+        register,
+        selectNodeMemo,
+        deselectNodeMemo
+    ]);
+}

package/dist/cjs/hooks/useSetDom.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useSetDom", {
+    enumerable: true,
+    get: function() {
+        return useSetDom;
+    }
+});
+const _react = require("react");
+function useSetDom(domRef, refUpdated, isMounted, forceUpdate) {
+    const pendingRef = (0, _react.useRef)(false);
+    return (0, _react.useCallback)((el)=>{
+        if (el !== null) {
+            pendingRef.current = false;
+            const changed = domRef.current !== el;
+            domRef.current = el;
+            if (changed) forceUpdate?.();
+            refUpdated();
+            return;
+        }
+        if (pendingRef.current) return;
+        pendingRef.current = true;
+        // React calls old ref callbacks with
+        // null before synchronously calling
+        // new ref callbacks with the existing
+        // element ref. We don't have any
+        // way to distinguish a call with null
+        // because the downstream callback is
+        // unstable and being replaced during render
+        // from a call with null because the referenced
+        // element has been unmounted.
+        //
+        // Since the ref callback calls are synchronous,
+        // we can queue a microtask and check
+        // whether the ref is still null at
+        // the end of this event loop task. If it
+        // is, we actually unmounted. If it's not,
+        // we already handled it in the synchronous
+        // branch above, so we just bail.
+        queueMicrotask(()=>{
+            if (!pendingRef.current) return;
+            pendingRef.current = false;
+            if (domRef.current !== null) {
+                domRef.current = null;
+                if (isMounted?.()) forceUpdate?.();
+            }
+            refUpdated();
+        });
+    }, [
+        domRef,
+        forceUpdate,
+        isMounted,
+        refUpdated
+    ]);
+}

package/dist/cjs/hooks/useStopEvent.js

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

package/dist/cjs/index.js

@@ -0,0 +1,85 @@
+/* Copyright (c) The New York Times Company */ "use client";
+"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, {
+    ProseMirror: function() {
+        return _ProseMirror.ProseMirror;
+    },
+    ProseMirrorDoc: function() {
+        return _ProseMirrorDoc.ProseMirrorDoc;
+    },
+    reactKeys: function() {
+        return _reactKeys.reactKeys;
+    },
+    reorderSiblings: function() {
+        return _reorderSiblings.reorderSiblings;
+    },
+    useEditorEffect: function() {
+        return _useEditorEffect.useEditorEffect;
+    },
+    useEditorEventCallback: function() {
+        return _useEditorEventCallback.useEditorEventCallback;
+    },
+    useEditorEventListener: function() {
+        return _useEditorEventListener.useEditorEventListener;
+    },
+    useEditorState: function() {
+        return _useEditorState.useEditorState;
+    },
+    useEditorStateSelector: function() {
+        return _useEditorStateSelector.useEditorStateSelector;
+    },
+    useIgnoreMutation: function() {
+        return _useIgnoreMutation.useIgnoreMutation;
+    },
+    useIsComposingIn: function() {
+        return _useIsComposingIn.useIsComposingIn;
+    },
+    useIsEditorStatic: function() {
+        return _useIsEditorStatic.useIsEditorStatic;
+    },
+    useIsNodeSelected: function() {
+        return _useIsNodeSelected.useIsNodeSelected;
+    },
+    useMergedDOMRefs: function() {
+        return _refs.useMergedDOMRefs;
+    },
+    useNodePos: function() {
+        return _useNodePos.useNodePos;
+    },
+    useSelectNode: function() {
+        return _useSelectNode.useSelectNode;
+    },
+    useStopEvent: function() {
+        return _useStopEvent.useStopEvent;
+    },
+    widget: function() {
+        return _ReactWidgetType.widget;
+    }
+});
+const _ProseMirror = require("./components/ProseMirror.js");
+const _ProseMirrorDoc = require("./components/ProseMirrorDoc.js");
+const _reorderSiblings = require("./commands/reorderSiblings.js");
+const _useIsComposingIn = require("./hooks/useIsComposingIn.js");
+const _useEditorEffect = require("./hooks/useEditorEffect.js");
+const _useEditorEventCallback = require("./hooks/useEditorEventCallback.js");
+const _useEditorEventListener = require("./hooks/useEditorEventListener.js");
+const _useEditorState = require("./hooks/useEditorState.js");
+const _useNodePos = require("./hooks/useNodePos.js");
+const _useEditorStateSelector = require("./hooks/useEditorStateSelector.js");
+const _useStopEvent = require("./hooks/useStopEvent.js");
+const _useSelectNode = require("./hooks/useSelectNode.js");
+const _useIgnoreMutation = require("./hooks/useIgnoreMutation.js");
+const _useIsEditorStatic = require("./hooks/useIsEditorStatic.js");
+const _useIsNodeSelected = require("./hooks/useIsNodeSelected.js");
+const _reactKeys = require("./plugins/reactKeys.js");
+const _ReactWidgetType = require("./decorations/ReactWidgetType.js");
+const _refs = require("./refs.js");

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}