@handlewithcare/react-prosemirror 2.4.12 → 2.5.0

package/dist/cjs/selection/selectionToDOM.js

@@ -1,226 +0,0 @@
-"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, 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

@@ -1,85 +0,0 @@
-/* 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/esm/components/Editor.js

@@ -1,15 +0,0 @@
-import React from "react";
-import { EditorContext } from "../contexts/EditorContext.js";
-import { useEditorView } from "../hooks/useEditorView.js";
-import { useNodeViews } from "../hooks/useNodeViews.js";
-export function Editor(param) {
-    let { mount , children , ...options } = param;
-    const { nodeViews , nodeViewsComponent  } = useNodeViews(options.nodeViews);
-    const value = useEditorView(mount, {
-        ...options,
-        nodeViews
-    });
-    return /*#__PURE__*/ React.createElement(EditorContext.Provider, {
-        value: value
-    }, children, nodeViewsComponent);
-}

package/dist/esm/components/NodeViews.js

@@ -1,26 +0,0 @@
-import React, { useState } from "react";
-import { NodeViewsContext } from "../contexts/NodeViewsContext.js";
-import { useEditorEffect } from "../hooks/useEditorEffect.js";
-import { ROOT_NODE_KEY } from "../plugins/react.js";
-export function NodeViews(param) {
-    let { portals  } = param;
-    const rootRegisteredPortals = portals[ROOT_NODE_KEY];
-    const [rootPortals, setRootPortals] = useState(rootRegisteredPortals?.map((param)=>{
-        let { portal  } = param;
-        return portal;
-    }) ?? []);
-    // `getPos` is technically derived from the EditorView
-    // state, so it's not safe to call until after the EditorView
-    // has been updated
-    useEditorEffect(()=>{
-        setRootPortals(rootRegisteredPortals?.sort((a, b)=>a.getPos() - b.getPos()).map((param)=>{
-            let { portal  } = param;
-            return portal;
-        }) ?? []);
-    }, [
-        rootRegisteredPortals
-    ]);
-    return /*#__PURE__*/ React.createElement(NodeViewsContext.Provider, {
-        value: portals
-    }, rootPortals);
-}

package/dist/esm/components/__tests__/LayoutGroup.test.js

@@ -1,98 +0,0 @@
-import { act, render, screen } from "@testing-library/react";
-import React, { useLayoutEffect, useState } from "react";
-import { useLayoutGroupEffect } from "../../hooks/useLayoutGroupEffect.js";
-import { LayoutGroup } from "../LayoutGroup.js";
-describe("LayoutGroup", ()=>{
-    jest.useFakeTimers("modern");
-    it("registers multiple effects and runs them", ()=>{
-        function Parent() {
-            return /*#__PURE__*/ React.createElement(LayoutGroup, null, /*#__PURE__*/ React.createElement(Child, null));
-        }
-        function Child() {
-            const [double, setDouble] = useState(1);
-            useLayoutEffect(()=>{
-                if (double === 2) {
-                    setTimeout(()=>{
-                        setDouble((d)=>d * 2.5);
-                    }, 500);
-                }
-                if (double === 20) {
-                    setDouble((d)=>d * 2.5);
-                }
-            }, [
-                double
-            ]);
-            useLayoutGroupEffect(()=>{
-                const timeout = setTimeout(()=>{
-                    setDouble((d)=>d * 2);
-                }, 1000);
-                return ()=>{
-                    clearTimeout(timeout);
-                };
-            }, [
-                double
-            ]);
-            return /*#__PURE__*/ React.createElement("div", null, /*#__PURE__*/ React.createElement("div", {
-                "data-testid": "double"
-            }, double));
-        }
-        // The component mounts ...
-        // ... the initial value should be 1
-        // ... there should be one timeout scheduled by the deferred effect
-        render(/*#__PURE__*/ React.createElement(Parent, null));
-        expect(screen.getByTestId("double").innerHTML).toBe("1");
-        // This block assert that deferred effects run.
-        // --------------------------------------------
-        // 1000 milliseconds go by ...
-        // ... the timeout set by the deferred effect should run
-        // ... the timeout should double the new value to 2
-        // ... the immediate effect should set a timeout
-        // ... the deferred effect should set a timeout
-        act(()=>{
-            jest.advanceTimersByTime(1000);
-        });
-        expect(screen.getByTestId("double").innerHTML).toBe("2");
-        // The next three blocks assert that cleanup of deferred effects run.
-        // ------------------------------------------------------------------
-        // 500 milliseconds go by ...
-        // ... the timeout set by the immediate effect should run
-        // ... the timeout should set the value to 5
-        // ... the old deferred effect should cancel its timeout
-        // ... the new deferred effect should set a new timeout
-        act(()=>{
-            jest.advanceTimersByTime(500);
-        });
-        expect(screen.getByTestId("double").innerHTML).toBe("5");
-        // ... 500 more milliseconds go by ...
-        // ... the canceled timeout should not run
-        // ... the rescheduled timoeut should not yet run
-        act(()=>{
-            jest.advanceTimersByTime(500);
-        });
-        expect(screen.getByTestId("double").innerHTML).toBe("5");
-        // ... 500 more milliseconds go by ...
-        // ... the rescheduled timeout should run
-        // ... the timeout should double the value to 10
-        // ... the deferred effect should set a new timeout
-        act(()=>{
-            jest.advanceTimersByTime(500);
-        });
-        expect(screen.getByTestId("double").innerHTML).toBe("10");
-        // The next block asserts that cancelation of deferred effects works.
-        // ------------------------------------------------------------------
-        // 1000 milliseconds go by ...
-        // ... the timeout set by the deferred effect should run
-        // ... the timeout should double the value to 20
-        // ... the immediate effect should then set the value to 50
-        // ... the deferred effect from the first render should not run
-        // ... the deferred effect from the second render should run
-        // ... the deferred effect that does run should set a new timeout
-        act(()=>{
-            jest.advanceTimersByTime(1000);
-        });
-        // For this assertion, we need to clear a timer from the React scheduler.
-        jest.advanceTimersByTime(1);
-        expect(screen.getByTestId("double").innerHTML).toBe("50");
-        expect(jest.getTimerCount()).toBe(1);
-    });
-});

package/dist/esm/components/__tests__/ProseMirror.test.js

@@ -1,207 +0,0 @@
-import { act, render, screen } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { Schema } from "prosemirror-model";
-import { EditorState } from "prosemirror-state";
-import React, { useEffect, useState } from "react";
-import { react } from "../../plugins/react.js";
-import { setupProseMirrorView, teardownProseMirrorView } from "../../testing/setupProseMirrorView.js";
-import { ProseMirror } from "../ProseMirror.js";
-// Mock `ReactDOM.flushSync` to call `act` to flush updates from DOM mutations.
-jest.mock("react-dom", ()=>({
-        ...jest.requireActual("react-dom"),
-        flushSync: (fn)=>act(fn)
-    }));
-describe("ProseMirror", ()=>{
-    beforeAll(()=>{
-        setupProseMirrorView();
-    });
-    it("renders a contenteditable", async ()=>{
-        const schema = new Schema({
-            nodes: {
-                text: {},
-                doc: {
-                    content: "text*"
-                }
-            }
-        });
-        const defaultState = EditorState.create({
-            schema
-        });
-        function TestEditor() {
-            const [mount, setMount] = useState(null);
-            return /*#__PURE__*/ React.createElement(ProseMirror, {
-                mount: mount,
-                defaultState: defaultState
-            }, /*#__PURE__*/ React.createElement("div", {
-                "data-testid": "editor",
-                ref: setMount
-            }));
-        }
-        const user = userEvent.setup();
-        render(/*#__PURE__*/ React.createElement(TestEditor, null));
-        const editor = screen.getByTestId("editor");
-        await user.type(editor, "Hello, world!");
-        expect(editor.textContent).toBe("Hello, world!");
-    });
-    it("supports observing transaction dispatch", async ()=>{
-        const schema = new Schema({
-            nodes: {
-                text: {},
-                doc: {
-                    content: "text*"
-                }
-            }
-        });
-        const defaultState = EditorState.create({
-            schema
-        });
-        const dispatchTransaction = jest.fn();
-        function TestEditor() {
-            const [mount, setMount] = useState(null);
-            return /*#__PURE__*/ React.createElement(ProseMirror, {
-                mount: mount,
-                defaultState: defaultState,
-                dispatchTransaction: dispatchTransaction
-            }, /*#__PURE__*/ React.createElement("div", {
-                "data-testid": "editor",
-                ref: setMount
-            }));
-        }
-        const user = userEvent.setup();
-        render(/*#__PURE__*/ React.createElement(TestEditor, null));
-        const editor = screen.getByTestId("editor");
-        await user.type(editor, "Hello, world!");
-        expect(editor.textContent).toBe("Hello, world!");
-        expect(dispatchTransaction).toHaveBeenCalledTimes(13);
-    });
-    it("supports controlling the editor state", async ()=>{
-        const schema = new Schema({
-            nodes: {
-                text: {},
-                doc: {
-                    content: "text*"
-                }
-            }
-        });
-        let observedState = EditorState.create({
-            schema
-        });
-        function TestEditor() {
-            const [state, setState] = useState(observedState);
-            const [mount, setMount] = useState(null);
-            useEffect(()=>{
-                observedState = state;
-            }, [
-                state
-            ]);
-            return /*#__PURE__*/ React.createElement(ProseMirror, {
-                mount: mount,
-                state: state,
-                dispatchTransaction: (tr)=>{
-                    setState((s)=>s.apply(tr));
-                }
-            }, /*#__PURE__*/ React.createElement("div", {
-                "data-testid": "editor",
-                ref: setMount
-            }));
-        }
-        const user = userEvent.setup();
-        render(/*#__PURE__*/ React.createElement(TestEditor, null));
-        const editor = screen.getByTestId("editor");
-        await user.type(editor, "Hello, world!");
-        expect(observedState.doc.textContent).toBe("Hello, world!");
-    });
-    it("updates props atomically", async ()=>{
-        const schema = new Schema({
-            nodes: {
-                text: {},
-                doc: {
-                    content: "text*"
-                }
-            }
-        });
-        const defaultState = EditorState.create({
-            schema
-        });
-        let allStatesMatched = true;
-        function TestEditor() {
-            const [state, setState] = useState(defaultState);
-            const [mount, setMount] = useState(null);
-            // Check that function props get invoked with the latest React state.
-            const editable = (viewState)=>{
-                allStatesMatched &&= viewState === state;
-                return true;
-            };
-            return /*#__PURE__*/ React.createElement(ProseMirror, {
-                mount: mount,
-                editable: editable,
-                state: state,
-                dispatchTransaction: (tr)=>{
-                    setState((s)=>s.apply(tr));
-                }
-            }, /*#__PURE__*/ React.createElement("div", {
-                "data-testid": "editor",
-                ref: setMount
-            }));
-        }
-        const user = userEvent.setup();
-        render(/*#__PURE__*/ React.createElement(TestEditor, null));
-        const editor = screen.getByTestId("editor");
-        await user.type(editor, "Hello, world!");
-        expect(allStatesMatched).toBe(true);
-    });
-    it("supports React NodeViews", async ()=>{
-        const schema = new Schema({
-            nodes: {
-                text: {},
-                paragraph: {
-                    content: "text*"
-                },
-                doc: {
-                    content: "paragraph+"
-                }
-            }
-        });
-        const defaultState = EditorState.create({
-            schema,
-            plugins: [
-                react()
-            ]
-        });
-        function Paragraph(param) {
-            let { children  } = param;
-            return /*#__PURE__*/ React.createElement("p", {
-                "data-testid": "paragraph"
-            }, children);
-        }
-        const nodeViews = {
-            paragraph: ()=>({
-                    component: Paragraph,
-                    dom: document.createElement("div"),
-                    contentDOM: document.createElement("span")
-                })
-        };
-        function TestEditor() {
-            const [mount, setMount] = useState(null);
-            return /*#__PURE__*/ React.createElement(ProseMirror, {
-                mount: mount,
-                defaultState: defaultState,
-                nodeViews: nodeViews
-            }, /*#__PURE__*/ React.createElement("div", {
-                "data-testid": "editor",
-                ref: setMount
-            }));
-        }
-        const user = userEvent.setup();
-        render(/*#__PURE__*/ React.createElement(TestEditor, null));
-        const editor = screen.getByTestId("editor");
-        await user.type(editor, "Hello, world!");
-        expect(editor.textContent).toBe("Hello, world!");
-        // Ensure that ProseMirror really rendered our Paragraph
-        // component, not just any old <p> tag
-        expect(screen.getAllByTestId("paragraph").length).toBeGreaterThanOrEqual(1);
-    });
-    afterAll(()=>{
-        teardownProseMirrorView();
-    });
-});

package/dist/esm/contexts/NodeViewsContext.js

@@ -1,9 +0,0 @@
-import { createContext } from "react";
-/**
- * A context containing a map of node view keys to portals.
- *
- * Each node view registers a portal under its parent's
- * key. Each can then retrieve the list of portals under their
- * key, allowing portals to be rendered with the appropriate
- * hierarchy.
- */ export const NodeViewsContext = createContext(null);