@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/esm/AbstractEditorView.js

@@ -0,0 +1 @@
+export { };

package/dist/esm/ReactEditorView.js

@@ -0,0 +1,194 @@
+import { EditorView } from "prosemirror-view";
+import { EMPTY_STATE } from "./constants.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;
+}
+/**
+ * Extends EditorView to make prop and state updates pure, remove the DOM
+ * Mutation Observer, and use a custom document view managed by React.
+ *
+ * @privateRemarks
+ *
+ * The implementation relies on the base class using a private member to store
+ * the committed props and having a public getter that we override to return the
+ * latest, uncommitted props. The base class can then be told to update when the
+ * React effects are commit an update, applying the pending, uncommitted props.
+ */ export class ReactEditorView extends EditorView {
+    nextProps;
+    prevState;
+    _destroyed;
+    cursorWrapped;
+    constructor(place, props){
+        // Prevent the base class from destroying the React-managed nodes.
+        // Restore them below after invoking the base class constructor.
+        const reactContent = [
+            ...place.mount.childNodes
+        ];
+        // Prevent the base class from mutating the React-managed attributes.
+        // Restore them below after invoking the base class constructor.
+        const reactAttrs = [
+            ...place.mount.attributes
+        ];
+        for (const attr of reactAttrs){
+            place.mount.removeAttributeNode(attr);
+        }
+        try {
+            // Call the superclass constructor with only a state and no plugins.
+            // We'll set everything else ourselves and apply props during layout.
+            super(place, {
+                state: EMPTY_STATE
+            });
+            this.domObserver.stop();
+            this.domObserver.observer = null;
+            this.domObserver.queue = [];
+            const originalOnSelectionChange = this.domObserver.onSelectionChange;
+            this.domObserver.onSelectionChange = ()=>{
+                // During a composition, we completely pause React-driven
+                // selection and DOM updates. Compositions are "fragile";
+                // in Safari, even updating the selection to the same
+                // position it's already set to will end the current
+                // composition.
+                if (this.composing) return;
+                originalOnSelectionChange();
+            };
+        } finally{
+            place.mount.replaceChildren(...reactContent);
+            for (const attr of place.mount.attributes){
+                place.mount.removeAttributeNode(attr);
+            }
+            for (const attr of reactAttrs){
+                place.mount.setAttributeNode(attr);
+            }
+        }
+        this.prevState = EMPTY_STATE;
+        this.nextProps = props;
+        this.state = props.state;
+        this.nodeViews = buildNodeViews(this);
+        // Destroy the document view description that the base class makes.
+        // A React document view will assign itself to this attribute later.
+        this.docView.destroy();
+        // @ts-expect-error this violates the typing but class does it, too.
+        this.docView = null;
+        this._destroyed = false;
+        this.cursorWrapped = false;
+    }
+    get props() {
+        return this.nextProps;
+    }
+    /**
+   * @privateremarks
+   *
+   * We override this getter because the base implementation
+   * relies on checking `docView === null`, but we unconditionally
+   * set view.docView in a layout effect in the DocNodeView.
+   * This has the effect of "un-destroying" the EditorView,
+   * making it impossible to determine whether it's been destroyed.
+   */ get isDestroyed() {
+        return this._destroyed;
+    }
+    setProps(props) {
+        this.update({
+            ...this.props,
+            ...props
+        });
+    }
+    update(props) {
+        const prevProps = this.nextProps;
+        this.nextProps = props;
+        this.state = props.state;
+        if (prevProps.state.plugins !== props.state.plugins || prevProps.plugins !== props.plugins || prevProps.nodeViews !== props.nodeViews) {
+            const nodeViews = buildNodeViews(this);
+            if (changedNodeViews(this.nodeViews, nodeViews)) {
+                this.nodeViews = nodeViews;
+            }
+        }
+        this.editable = !this.someProp("editable", (value)=>value(this.state) === false);
+    }
+    updateState(state) {
+        this.setProps({
+            state
+        });
+    }
+    someProp(propName, f) {
+        if (!this.props) {
+            // The base class constructor calls this method before props are set.
+            return undefined;
+        }
+        const prop = this.props[propName];
+        if (prop != null) {
+            const result = f ? f(prop) : prop;
+            if (result) {
+                return result;
+            }
+        }
+        for (const plugin of this.props.plugins ?? []){
+            const prop = plugin.props[propName];
+            if (prop != null) {
+                const result = f ? f(prop) : prop;
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        for (const plugin of this.state.plugins){
+            const prop = plugin.props[propName];
+            if (prop != null) {
+                const result = f ? f(prop) : prop;
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return undefined;
+    }
+    destroy() {
+        // Prevent the base class from destroying the React-managed nodes.
+        // Restore them below after invoking the base class method.
+        const reactContent = [
+            ...this.dom.childNodes
+        ];
+        try {
+            super.destroy();
+        } finally{
+            this.dom.replaceChildren(...reactContent);
+            this._destroyed = true;
+        }
+    }
+    /**
+   * Commit effects by appling the pending props and state.
+   *
+   * Ensures the DOM selection is correct and updates plugin views.
+   *
+   * @privateRemarks
+   *
+   * The correctness of this depends on the pure update function ensuring that
+   * the node view set is up to date so that it does not try to redraw.
+   */ commitPendingEffects() {
+        // This class tracks state eagerly but the base class does it lazily.
+        // Temporarily roll it back so the base class can handle the updates.
+        this.state = this.prevState;
+        // Force the base class to try to update the document. React updated it, but
+        // this ensures that the base class validates the DOM selection and invokes
+        // node view selection callbacks.
+        this.docView.markDirty(-1, -1);
+        super.update(this.nextProps);
+        // Store the new previous state.
+        this.prevState = this.state;
+    }
+}

package/dist/esm/StaticEditorView.js

@@ -0,0 +1,79 @@
+export class StaticEditorView {
+    props;
+    nodeViews;
+    constructor(props){
+        this.props = props;
+        this.nodeViews = {};
+    }
+    get composing() {
+        return false;
+    }
+    get dom() {
+        return null;
+    }
+    get editable() {
+        return false;
+    }
+    get state() {
+        return this.props.state;
+    }
+    get isDestroyed() {
+        return false;
+    }
+    setProps(props) {
+        return this.update({
+            ...this.props,
+            ...props
+        });
+    }
+    update(props) {
+        this.props = props;
+    }
+    updateState(state) {
+        this.setProps({
+            state
+        });
+    }
+    someProp(propName, f) {
+        const prop = this.props[propName];
+        if (prop != null) {
+            const result = f ? f(prop) : prop;
+            if (result) {
+                return result;
+            }
+        }
+        for (const plugin of this.props.plugins ?? []){
+            const prop = plugin.props[propName];
+            if (prop != null) {
+                const result = f ? f(prop) : prop;
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        for (const plugin of this.state.plugins){
+            const prop = plugin.props[propName];
+            if (prop != null) {
+                const result = f ? f(prop) : prop;
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return undefined;
+    }
+    destroy() {
+    // pass
+    }
+    domSelectionRange() {
+        return {
+            anchorNode: null,
+            anchorOffset: 0,
+            focusNode: null,
+            focusOffset: 0
+        };
+    }
+    domSelection() {
+        return null;
+    }
+}

package/dist/esm/browser.js

@@ -0,0 +1,43 @@
+const nav = typeof navigator != "undefined" ? navigator : null;
+const doc = typeof document != "undefined" ? document : null;
+const agent = nav && nav.userAgent || "";
+const ie_edge = /Edge\/(\d+)/.exec(agent);
+const ie_upto10 = /MSIE \d/.exec(agent);
+const ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(agent);
+const ie = !!(ie_upto10 || ie_11up || ie_edge);
+const ie_version = ie_upto10 ? document.documentMode : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0;
+const gecko = !ie && /gecko\/(\d+)/i.test(agent);
+const gecko_version = gecko && +(/Firefox\/(\d+)/.exec(agent) || [
+    0,
+    0
+])[1];
+const _chrome = !ie && /Chrome\/(\d+)/.exec(agent);
+const chrome = !!_chrome;
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const chrome_version = _chrome ? +_chrome[1] : 0;
+const safari = !ie && !!nav && /Apple Computer/.test(nav.vendor);
+// Is true for both iOS and iPadOS for convenience
+const ios = safari && (/Mobile\/\w+/.test(agent) || !!nav && nav.maxTouchPoints > 2);
+const mac = ios || (nav ? /Mac/.test(nav.platform) : false);
+const windows = nav ? /Win/.test(nav.platform) : false;
+const android = /Android \d/.test(agent);
+const webkit = !!doc && "webkitFontSmoothing" in doc.documentElement.style;
+const webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [
+    0,
+    0
+])[1] : 0;
+export const browser = {
+    ie,
+    ie_version,
+    gecko,
+    gecko_version,
+    chrome,
+    chrome_version,
+    safari,
+    ios,
+    mac,
+    windows,
+    android,
+    webkit,
+    webkit_version
+};

package/dist/esm/commands/reorderSiblings.js

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ import { reactKeysPluginKey } from "../plugins/reactKeys.js";
+/**
+ * Create a command function that reorders the adjacent nodes starting
+ * at the provided position.
+ *
+ * @param pos - The `start` position of the parent of the nodes being reordered
+ * @param order - The new order for the nodes, expressed as an array of indices. For
+ *                example, to swap the first two nodes in a set of three, `order`
+ *                would be set to `[1, 0, 2]`. To move the first node to the end,
+ *                and keep the other two in relative order, set `order` to `[1, 2, 0]`.
+ */ export function reorderSiblings(pos, order) {
+    return function reorderSiblingsCommand(state, dispatch) {
+        const tr = state.tr;
+        return reorderSiblingsOnTransaction(pos, order, tr, state, dispatch);
+    };
+}
+export function reorderSiblingsOnTransaction(pos, order, tr, state, dispatch) {
+    const orderLookup = order.reduce((acc, oldIndex, newIndex)=>{
+        acc[oldIndex] = newIndex;
+        return acc;
+    }, []);
+    const $pos = state.doc.resolve(pos);
+    if ($pos.start() !== pos) {
+        return false;
+    }
+    if (!dispatch) return true;
+    const nodes = $pos.parent.children;
+    const reordered = nodes.map((node, i)=>[
+            node,
+            i
+        ]).sort((param, param1)=>{
+        let [, a] = param, [, b] = param1;
+        return orderLookup[a] - orderLookup[b];
+    }).map((param)=>{
+        let [node] = param;
+        return node;
+    });
+    tr.replaceWith(pos, $pos.parent.content.size + pos, reordered);
+    const meta = {
+        overrides: {}
+    };
+    const oldPositions = [];
+    let start = pos;
+    for (const node of nodes){
+        oldPositions.push(start);
+        start += node.nodeSize;
+    }
+    start = pos;
+    const newPositions = [];
+    for(let i = 0; i < reordered.length; i++){
+        const node = reordered[i];
+        newPositions[order[i]] = start;
+        start += node.nodeSize;
+    }
+    for(let i = 0; i < oldPositions.length; i++){
+        const oldPosition = oldPositions[i];
+        const newPosition = newPositions[i];
+        meta.overrides[oldPosition] = newPosition;
+    }
+    tr.setMeta(reactKeysPluginKey, meta);
+    dispatch(tr);
+    return true;
+}