@handlewithcare/react-prosemirror 2.0.0

package/dist/cjs/hooks/useEditor.js

@@ -0,0 +1,287 @@
+"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, {
+    ReactEditorView: function() {
+        return ReactEditorView;
+    },
+    useEditor: function() {
+        return useEditor;
+    }
+});
+const _prosemirrormodel = require("prosemirror-model");
+const _prosemirrorstate = require("prosemirror-state");
+const _prosemirrorview = require("prosemirror-view");
+const _react = require("react");
+const _reactdom = require("react-dom");
+const _beforeInputPlugin = require("../plugins/beforeInputPlugin.js");
+const _SelectionDOMObserver = require("../selection/SelectionDOMObserver.js");
+const _ssr = require("../ssr.js");
+const _viewdesc = require("../viewdesc.js");
+const _useComponentEventListeners = require("./useComponentEventListeners.js");
+const _useForceUpdate = require("./useForceUpdate.js");
+function buildNodeViews(view) {
+    const result = Object.create(null);
+    function add(obj) {
+        for(const prop in obj)if (!Object.prototype.hasOwnProperty.call(result, prop)) // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        result[prop] = obj[prop];
+    }
+    view.someProp("nodeViews", add);
+    view.someProp("markViews", add);
+    return result;
+}
+function changedNodeViews(a, b) {
+    let nA = 0, nB = 0;
+    for(const prop in a){
+        if (a[prop] != b[prop]) return true;
+        nA++;
+    }
+    for(const _ in b)nB++;
+    return nA != nB;
+}
+function changedProps(a, b) {
+    for (const prop of Object.keys(a)){
+        if (a[prop] !== b[prop]) return true;
+    }
+    return false;
+}
+function getEditable(view) {
+    return !view.someProp("editable", (value)=>value(view.state) === false);
+}
+let ReactEditorView = class ReactEditorView extends _prosemirrorview.EditorView {
+    shouldUpdatePluginViews = false;
+    oldProps;
+    _props;
+    constructor(place, props){
+        // Call the superclass constructor with an empty
+        // document and limited props. We'll set everything
+        // else ourselves.
+        const cleanup = (0, _ssr.setSsrStubs)();
+        super(place, {
+            state: _prosemirrorstate.EditorState.create({
+                schema: props.state.schema,
+                plugins: props.state.plugins
+            }),
+            plugins: props.plugins
+        });
+        cleanup();
+        this.shouldUpdatePluginViews = true;
+        this._props = props;
+        this.oldProps = {
+            state: props.state
+        };
+        this.state = props.state;
+        // @ts-expect-error We're making use of knowledge of internal attributes here
+        this.domObserver.stop();
+        // @ts-expect-error We're making use of knowledge of internal attributes here
+        this.domObserver = new _SelectionDOMObserver.SelectionDOMObserver(this);
+        // @ts-expect-error We're making use of knowledge of internal attributes here
+        this.domObserver.start();
+        this.editable = getEditable(this);
+        // Destroy the DOM created by the default
+        // ProseMirror ViewDesc implementation; we
+        // have a NodeViewDesc from React instead.
+        // @ts-expect-error We're making use of knowledge of internal attributes here
+        this.docView.dom.replaceChildren();
+        // @ts-expect-error We're making use of knowledge of internal attributes here
+        this.docView = props.docView;
+    }
+    /**
+   * Whether the EditorView's updateStateInner method thinks that the
+   * docView needs to be blown away and redrawn.
+   *
+   * @privateremarks
+   *
+   * When ProseMirror View detects that the EditorState has been reconfigured
+   * to provide new custom node views, it calls an internal function that
+   * we can't override in order to recreate the entire editor DOM.
+   *
+   * This property mimics that check, so that we can replace the EditorView
+   * with another of our own, preventing ProseMirror View from taking over
+   * DOM management responsibility.
+   */ get needsRedraw() {
+        if (this.oldProps.state.plugins === this._props.state.plugins && this._props.plugins === this.oldProps.plugins) {
+            return false;
+        }
+        const newNodeViews = buildNodeViews(this);
+        // @ts-expect-error Internal property
+        return changedNodeViews(this.nodeViews, newNodeViews);
+    }
+    /**
+   * Like setProps, but without executing any side effects.
+   * Safe to use in a component render method.
+   */ pureSetProps(props) {
+        // this.oldProps = this.props;
+        this._props = {
+            ...this._props,
+            ...props
+        };
+        this.state = this._props.state;
+        this.editable = getEditable(this);
+    }
+    /**
+   * Triggers any side effects that have been queued by previous
+   * calls to pureSetProps.
+   */ runPendingEffects() {
+        if (changedProps(this.props, this.oldProps)) {
+            const newProps = this.props;
+            this._props = this.oldProps;
+            this.state = this._props.state;
+            this.update(newProps);
+        }
+    }
+    update(props) {
+        super.update(props);
+        // Ensure that side effects aren't re-triggered until
+        // pureSetProps is called again
+        this.oldProps = props;
+    }
+    updatePluginViews(prevState) {
+        if (this.shouldUpdatePluginViews) {
+            // @ts-expect-error We're making use of knowledge of internal methods here
+            super.updatePluginViews(prevState);
+        }
+    }
+    // We want to trigger the default EditorView cleanup, but without
+    // the actual view.dom cleanup (which React will have already handled).
+    // So we give the EditorView a dummy DOM element and ask it to clean up
+    destroy() {
+        // @ts-expect-error we're intentionally overwriting this property
+        // to prevent side effects
+        this.dom = document.createElement("div");
+        super.destroy();
+    }
+};
+const EMPTY_SCHEMA = new _prosemirrormodel.Schema({
+    nodes: {
+        doc: {
+            content: "text*"
+        },
+        text: {
+            inline: true
+        }
+    }
+});
+const EMPTY_STATE = _prosemirrorstate.EditorState.create({
+    schema: EMPTY_SCHEMA
+});
+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 value and defaultValue 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 [cursorWrapper, _setCursorWrapper] = (0, _react.useState)(null);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const defaultState = options.defaultState ?? EMPTY_STATE;
+    const [_state, setState] = (0, _react.useState)(defaultState);
+    const state = options.state ?? _state;
+    const { componentEventListenersPlugin, registerEventListener, unregisterEventListener } = (0, _useComponentEventListeners.useComponentEventListeners)();
+    const setCursorWrapper = (0, _react.useCallback)((deco)=>{
+        (0, _reactdom.flushSync)(()=>{
+            _setCursorWrapper(deco);
+        });
+    }, []);
+    const plugins = (0, _react.useMemo)(()=>[
+            ...options.plugins ?? [],
+            componentEventListenersPlugin,
+            (0, _beforeInputPlugin.beforeInputPlugin)(setCursorWrapper)
+        ], [
+        options.plugins,
+        componentEventListenersPlugin,
+        setCursorWrapper
+    ]);
+    const dispatchTransaction = (0, _react.useCallback)(function dispatchTransaction(tr) {
+        (0, _reactdom.flushSync)(()=>{
+            if (!options.state) {
+                setState((s)=>s.apply(tr));
+            }
+            if (options.dispatchTransaction) {
+                options.dispatchTransaction.call(this, tr);
+            }
+        });
+    }, [
+        options.dispatchTransaction,
+        options.state
+    ]);
+    const cleanup = (0, _ssr.setSsrStubs)();
+    const tempDom = document.createElement("div");
+    cleanup();
+    const docViewDescRef = (0, _react.useRef)(new _viewdesc.NodeViewDesc(undefined, [], ()=>-1, state.doc, [], _prosemirrorview.DecorationSet.empty, tempDom, null, tempDom, ()=>false, ()=>{
+    /* The doc node can't have a node selection*/ }, ()=>{
+    /* The doc node can't have a node selection*/ }));
+    const directEditorProps = {
+        ...options,
+        state,
+        plugins,
+        dispatchTransaction,
+        docView: docViewDescRef.current
+    };
+    const [view, setView] = (0, _react.useState)(// During the initial render, we create something of a dummy
+    // EditorView. This allows us to ensure that the first render actually
+    // renders the document, which is necessary for SSR.
+    ()=>new ReactEditorView(null, directEditorProps));
+    (0, _react.useLayoutEffect)(()=>{
+        return ()=>{
+            view?.destroy();
+        };
+    }, [
+        view
+    ]);
+    // This rule is concerned about infinite updates due to the
+    // call to setView. These calls are deliberately conditional,
+    // so this is not a concern.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _react.useLayoutEffect)(()=>{
+        if (!mount) {
+            setView(null);
+            return;
+        }
+        if (!view || view.dom !== mount) {
+            const newView = new ReactEditorView({
+                mount
+            }, directEditorProps);
+            setView(newView);
+            newView.dom.addEventListener("compositionend", forceUpdate);
+            return;
+        }
+        // TODO: We should be able to put this in previous branch,
+        // but we need to convince EditorView's constructor not to
+        // clear out the DOM when passed a mount that already has
+        // content in it, otherwise React blows up when it tries
+        // to clean up.
+        if (view.needsRedraw) {
+            setView(null);
+            return;
+        }
+        // @ts-expect-error Internal property - domObserver
+        view?.domObserver.selectionToDOM();
+        view?.runPendingEffects();
+    });
+    view?.pureSetProps(directEditorProps);
+    const editor = (0, _react.useMemo)(()=>({
+            view: view,
+            registerEventListener,
+            unregisterEventListener,
+            cursorWrapper,
+            docViewDescRef
+        }), [
+        view,
+        registerEventListener,
+        unregisterEventListener,
+        cursorWrapper
+    ]);
+    return {
+        editor,
+        state
+    };
+}

package/dist/cjs/hooks/useEditorEffect.js

@@ -0,0 +1,35 @@
+/* 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 _EditorContext = require("../contexts/EditorContext.js");
+const _useLayoutGroupEffect = require("./useLayoutGroupEffect.js");
+function useEditorEffect(effect, dependencies) {
+    const { view } = (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) {
+            return effect(view);
+        }
+    }, // 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,33 @@
+/* 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 _EditorContext = require("../contexts/EditorContext.js");
+const _useEditorEffect = require("./useEditorEffect.js");
+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];
+        }
+        if (view) {
+            return ref.current(view, ...args);
+        }
+        return;
+    }, [
+        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,16 @@
+/* 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");
+function useEditorState() {
+    const editorState = (0, _react.useContext)(_EditorStateContext.EditorStateContext);
+    return editorState;
+}

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/useLayoutGroupEffect.js

@@ -0,0 +1,19 @@
+/* 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");
+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, _react.useLayoutEffect)(()=>register(effect), deps);
+}

package/dist/cjs/hooks/useNodeViewDescriptor.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useNodeViewDescriptor", {
+    enumerable: true,
+    get: function() {
+        return useNodeViewDescriptor;
+    }
+});
+const _react = require("react");
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _viewdesc = require("../viewdesc.js");
+function useNodeViewDescriptor(node, getPos, domRef, nodeDomRef, innerDecorations, outerDecorations, viewDesc, contentDOMRef) {
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const [hasContentDOM, setHasContentDOM] = (0, _react.useState)(true);
+    const nodeViewDescRef = (0, _react.useRef)(viewDesc);
+    const stopEvent = (0, _react.useRef)(()=>false);
+    const setStopEvent = (0, _react.useCallback)((newStopEvent)=>{
+        stopEvent.current = newStopEvent;
+    }, []);
+    const selectNode = (0, _react.useRef)(()=>{
+        if (!nodeDomRef.current || !node) return;
+        if (nodeDomRef.current.nodeType == 1) nodeDomRef.current.classList.add("ProseMirror-selectednode");
+        if (contentDOMRef?.current || !node.type.spec.draggable) (domRef?.current ?? nodeDomRef.current).draggable = true;
+    });
+    const deselectNode = (0, _react.useRef)(()=>{
+        if (!nodeDomRef.current || !node) return;
+        if (nodeDomRef.current.nodeType == 1) {
+            nodeDomRef.current.classList.remove("ProseMirror-selectednode");
+            if (contentDOMRef?.current || !node.type.spec.draggable) (domRef?.current ?? nodeDomRef.current).removeAttribute("draggable");
+        }
+    });
+    const setSelectNode = (0, _react.useCallback)((newSelectNode, newDeselectNode)=>{
+        selectNode.current = newSelectNode;
+        deselectNode.current = newDeselectNode;
+    }, []);
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const childDescriptors = (0, _react.useRef)([]);
+    (0, _react.useLayoutEffect)(()=>{
+        const siblings = siblingsRef.current;
+        return ()=>{
+            if (!nodeViewDescRef.current) return;
+            if (siblings.includes(nodeViewDescRef.current)) {
+                const index = siblings.indexOf(nodeViewDescRef.current);
+                siblings.splice(index, 1);
+            }
+        };
+    }, [
+        siblingsRef
+    ]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _react.useLayoutEffect)(()=>{
+        if (!node || !nodeDomRef.current) return;
+        const firstChildDesc = childDescriptors.current[0];
+        if (!nodeViewDescRef.current) {
+            nodeViewDescRef.current = new _viewdesc.NodeViewDesc(parentRef.current, childDescriptors.current, getPos, node, outerDecorations, innerDecorations, domRef?.current ?? nodeDomRef.current, firstChildDesc?.dom.parentElement ?? null, nodeDomRef.current, (event)=>!!stopEvent.current(event), ()=>selectNode.current(), ()=>deselectNode.current());
+        } else {
+            nodeViewDescRef.current.parent = parentRef.current;
+            nodeViewDescRef.current.children = childDescriptors.current;
+            nodeViewDescRef.current.node = node;
+            nodeViewDescRef.current.getPos = getPos;
+            nodeViewDescRef.current.outerDeco = outerDecorations;
+            nodeViewDescRef.current.innerDeco = innerDecorations;
+            nodeViewDescRef.current.dom = domRef?.current ?? nodeDomRef.current;
+            // @ts-expect-error We have our own ViewDesc implementations
+            nodeViewDescRef.current.dom.pmViewDesc = nodeViewDescRef.current;
+            nodeViewDescRef.current.contentDOM = // If there's already a contentDOM, we can just
+            // keep it; it won't have changed. This is especially
+            // important during compositions, where the
+            // firstChildDesc might not have a correct dom node set yet.
+            contentDOMRef?.current ?? nodeViewDescRef.current.contentDOM ?? firstChildDesc?.dom.parentElement ?? null;
+            nodeViewDescRef.current.nodeDOM = nodeDomRef.current;
+        }
+        setHasContentDOM(nodeViewDescRef.current.contentDOM !== null);
+        if (!siblingsRef.current.includes(nodeViewDescRef.current)) {
+            siblingsRef.current.push(nodeViewDescRef.current);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+        for (const childDesc of childDescriptors.current){
+            childDesc.parent = nodeViewDescRef.current;
+            // Because TextNodeViews can't locate the DOM nodes
+            // for compositions, we need to override them here
+            if (childDesc instanceof _viewdesc.CompositionViewDesc) {
+                const compositionTopDOM = nodeViewDescRef.current.contentDOM?.firstChild;
+                if (!compositionTopDOM) throw new Error(`Started a composition but couldn't find the text node it belongs to.`);
+                let textDOM = compositionTopDOM;
+                while(textDOM.firstChild){
+                    textDOM = textDOM.firstChild;
+                }
+                if (!textDOM || !(textDOM instanceof Text)) throw new Error(`Started a composition but couldn't find the text node it belongs to.`);
+                childDesc.dom = compositionTopDOM;
+                childDesc.textDOM = textDOM;
+                childDesc.text = textDOM.data;
+                // @ts-expect-error ???
+                childDesc.textDOM.pmViewDesc = childDesc;
+                // @ts-expect-error ???
+                view?.input.compositionNodes.push(childDesc);
+            }
+        }
+        return ()=>{
+            if (nodeViewDescRef.current?.children[0] instanceof _viewdesc.CompositionViewDesc && !view?.composing) {
+                nodeViewDescRef.current?.children[0].dom.parentNode?.removeChild(nodeViewDescRef.current?.children[0].dom);
+            }
+        };
+    });
+    return {
+        hasContentDOM,
+        childDescriptors,
+        nodeViewDescRef,
+        setStopEvent,
+        setSelectNode
+    };
+}

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 view && _reactKeys.reactKeysPluginKey.getState(view.state);
+}

package/dist/cjs/hooks/useSelectNode.js

@@ -0,0 +1,28 @@
+"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 useSelectNode(selectNode, deselectNode) {
+    const register = (0, _react.useContext)(_SelectNodeContext.SelectNodeContext);
+    const selectNodeMemo = (0, _useEditorEventCallback.useEditorEventCallback)(selectNode);
+    const deselectNodeMemo = (0, _useEditorEventCallback.useEditorEventCallback)(deselectNode ?? (()=>{
+    // empty
+    }));
+    return (0, _useEditorEffect.useEditorEffect)(()=>{
+        register(selectNodeMemo, deselectNodeMemo);
+    }, [
+        deselectNodeMemo,
+        register,
+        selectNodeMemo
+    ]);
+}

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)(()=>{
+        register(stopEventMemo);
+    }, [
+        register,
+        stopEventMemo
+    ]);
+}