@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/contexts/EditorContext.js

@@ -0,0 +1,12 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EditorContext", {
+    enumerable: true,
+    get: function() {
+        return EditorContext;
+    }
+});
+const _react = require("react");
+const EditorContext = (0, _react.createContext)(null);

package/dist/cjs/contexts/EditorStateContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EditorStateContext", {
+    enumerable: true,
+    get: function() {
+        return EditorStateContext;
+    }
+});
+const _react = require("react");
+const EditorStateContext = (0, _react.createContext)(null);

package/dist/cjs/contexts/EditorStateStoreContext.js

@@ -0,0 +1,45 @@
+"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, {
+    EditorStateStoreContext: function() {
+        return EditorStateStoreContext;
+    },
+    createEditorStateStore: function() {
+        return createEditorStateStore;
+    }
+});
+const _react = require("react");
+function createEditorStateStore() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let state = null;
+    let pendingNotify = false;
+    const listeners = new Set();
+    return {
+        getState: ()=>state,
+        subscribe: (listener)=>{
+            listeners.add(listener);
+            return ()=>listeners.delete(listener);
+        },
+        setState: (newState)=>{
+            if (state !== newState) {
+                state = newState;
+                pendingNotify = true;
+            }
+        },
+        notifyListeners: ()=>{
+            if (pendingNotify) {
+                pendingNotify = false;
+                listeners.forEach((l)=>l());
+            }
+        }
+    };
+}
+const EditorStateStoreContext = (0, _react.createContext)(null);

package/dist/cjs/contexts/IgnoreMutationContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IgnoreMutationContext", {
+    enumerable: true,
+    get: function() {
+        return IgnoreMutationContext;
+    }
+});
+const _react = require("react");
+const IgnoreMutationContext = (0, _react.createContext)(null);

package/dist/cjs/contexts/LayoutGroupContext.js

@@ -0,0 +1,12 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LayoutGroupContext", {
+    enumerable: true,
+    get: function() {
+        return LayoutGroupContext;
+    }
+});
+const _react = require("react");
+const LayoutGroupContext = /*#__PURE__*/ (0, _react.createContext)(null);

package/dist/cjs/contexts/NodeViewContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeViewContext", {
+    enumerable: true,
+    get: function() {
+        return NodeViewContext;
+    }
+});
+const _react = require("react");
+const NodeViewContext = (0, _react.createContext)(null);

package/dist/cjs/contexts/RenderStoreContext.js

@@ -0,0 +1,54 @@
+"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, {
+    RenderStoreContext: function() {
+        return RenderStoreContext;
+    },
+    createRenderStore: function() {
+        return createRenderStore;
+    },
+    useRenderStore: function() {
+        return useRenderStore;
+    }
+});
+const _react = require("react");
+const createRenderStore = ()=>{
+    const listeners = new Set();
+    let version = 0;
+    const store = {
+        state: null,
+        doc: null,
+        announced: false,
+        getVersion: ()=>version,
+        subscribe: (listener)=>{
+            listeners.add(listener);
+            return ()=>{
+                listeners.delete(listener);
+            };
+        },
+        announce: ()=>{
+            // Nobody to re-render through the store: let the contexts change.
+            if (!listeners.size) return;
+            store.announced = true;
+            version++;
+            listeners.forEach((listener)=>listener());
+        }
+    };
+    return store;
+};
+const RenderStoreContext = (0, _react.createContext)(null);
+const inertStore = createRenderStore();
+const useRenderStore = ()=>{
+    const store = (0, _react.useContext)(RenderStoreContext);
+    const subscribed = store ?? inertStore;
+    (0, _react.useSyncExternalStore)(subscribed.subscribe, subscribed.getVersion, subscribed.getVersion);
+    return store;
+};

package/dist/cjs/contexts/SelectNodeContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SelectNodeContext", {
+    enumerable: true,
+    get: function() {
+        return SelectNodeContext;
+    }
+});
+const _react = require("react");
+const SelectNodeContext = (0, _react.createContext)(null);

package/dist/cjs/contexts/StopEventContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "StopEventContext", {
+    enumerable: true,
+    get: function() {
+        return StopEventContext;
+    }
+});
+const _react = require("react");
+const StopEventContext = (0, _react.createContext)(null);

package/dist/cjs/decorations/ReactWidgetType.js

@@ -0,0 +1,58 @@
+"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, {
+    ReactWidgetType: function() {
+        return ReactWidgetType;
+    },
+    widget: function() {
+        return widget;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+function compareObjs(a, b) {
+    if (a == b) return true;
+    for(const p in a)if (a[p] !== b[p]) return false;
+    for(const p in b)if (!(p in a)) return false;
+    return true;
+}
+const noSpec = {
+    side: 0
+};
+let ReactWidgetType = class ReactWidgetType {
+    Component;
+    side;
+    spec;
+    constructor(Component, spec){
+        this.Component = Component;
+        this.spec = spec ?? noSpec;
+        this.side = this.spec.side ?? 0;
+    }
+    map(mapping, span, offset, oldOffset) {
+        const { pos, deleted } = mapping.mapResult(span.from + oldOffset, this.side < 0 ? -1 : 1);
+        // @ts-expect-error The Decoration constructor is private/internal, but
+        // we need to use it for our custom widget implementation here.
+        return deleted ? null : new _prosemirrorview.Decoration(pos - offset, pos - offset, this);
+    }
+    valid() {
+        return true;
+    }
+    eq(other) {
+        return this == other || other instanceof ReactWidgetType && (this.spec.key && this.spec.key == other.spec.key || this.Component == other.Component && compareObjs(this.spec, other.spec));
+    }
+    destroy() {
+    // Can be implemented with React effect hooks
+    }
+};
+function widget(pos, component, spec) {
+    // @ts-expect-error The Decoration constructor is private/internal, but
+    // we need to use it for our custom widget implementation here.
+    return new _prosemirrorview.Decoration(pos, pos, new ReactWidgetType(component, spec));
+}

package/dist/cjs/decorations/computeDocDeco.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "computeDocDeco", {
+    enumerable: true,
+    get: function() {
+        return computeDocDeco;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+const DocDecorationsCache = new WeakMap();
+function computeDocDeco(view) {
+    const attrs = Object.create(null);
+    attrs.class = "ProseMirror";
+    attrs.contenteditable = String(view.editable);
+    view.someProp("attributes", (value)=>{
+        if (typeof value == "function") value = value(view.state);
+        if (value) for(const attr in value){
+            if (attr == "class") attrs.class += " " + value[attr];
+            else if (attr == "style") attrs.style = (attrs.style ? attrs.style + ";" : "") + value[attr];
+            else if (!attrs[attr] && attr != "contenteditable" && attr != "nodeName") attrs[attr] = String(value[attr]);
+        }
+    });
+    if (!attrs.translate) attrs.translate = "no";
+    const next = [
+        _prosemirrorview.Decoration.node(0, view.state.doc.content.size, attrs)
+    ];
+    const previous = DocDecorationsCache.get(view);
+    if (!previous) {
+        DocDecorationsCache.set(view, next);
+        return next;
+    }
+    if (previous[0].to !== view.state.doc.content.size) {
+        DocDecorationsCache.set(view, next);
+        return next;
+    }
+    // @ts-expect-error Internal property (Decoration.type)
+    if (!previous[0].type.eq(next[0].type)) {
+        DocDecorationsCache.set(view, next);
+        return next;
+    }
+    return previous;
+}

package/dist/cjs/decorations/internalTypes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/cjs/decorations/iterDeco.js

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "iterDeco", {
+    enumerable: true,
+    get: function() {
+        return iterDeco;
+    }
+});
+const _ReactWidgetType = require("./ReactWidgetType.js");
+function compareSide(a, b) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return a.type.side - b.type.side;
+}
+function iterDeco(parent, deco, // Callbacks have been slightly modified to pass
+// the offset, so that we can pass the position as
+// a prop to components
+onWidget, onNode) {
+    const locals = deco.locals(parent);
+    let offset = 0;
+    // Simple, cheap variant for when there are no local decorations
+    if (locals.length == 0) {
+        for(let i = 0; i < parent.childCount; i++){
+            const child = parent.child(i);
+            onNode(child, locals, deco.forChild(offset, child), offset, i);
+            offset += child.nodeSize;
+        }
+        return;
+    }
+    let decoIndex = 0;
+    const active = [];
+    let restNode = null;
+    for(let parentIndex = 0;;){
+        if (decoIndex < locals.length && locals[decoIndex].to == offset) {
+            let widget;
+            let widgets;
+            while(decoIndex < locals.length && locals[decoIndex].to == offset){
+                const next = locals[decoIndex++];
+                if (next.widget || // FORK: Our custom widget type can't report itself as a widget,
+                // so we have to explicitly check
+                next.type instanceof _ReactWidgetType.ReactWidgetType) {
+                    if (!widget) widget = next;
+                    else (widgets || (widgets = [
+                        widget
+                    ])).push(next);
+                }
+            }
+            if (widget) {
+                if (widgets) {
+                    widgets.sort(compareSide);
+                    for(let i = 0; i < widgets.length; i++)onWidget(widgets[i], // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    !(widgets[i].type instanceof _ReactWidgetType.ReactWidgetType), offset, parentIndex + i, !!restNode);
+                } else {
+                    onWidget(widget, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    !(widget.type instanceof _ReactWidgetType.ReactWidgetType), offset, parentIndex, !!restNode);
+                }
+            }
+        }
+        let child, index;
+        if (restNode) {
+            index = -1;
+            child = restNode;
+            restNode = null;
+        } else if (parentIndex < parent.childCount) {
+            index = parentIndex;
+            child = parent.child(parentIndex++);
+        } else {
+            break;
+        }
+        for(let i = 0; i < active.length; i++)if (active[i].to <= offset) active.splice(i--, 1);
+        while(decoIndex < locals.length && locals[decoIndex].from <= offset && locals[decoIndex].to > offset)active.push(locals[decoIndex++]);
+        let end = offset + child.nodeSize;
+        if (child.isText) {
+            let cutAt = end;
+            if (decoIndex < locals.length && locals[decoIndex].from < cutAt) cutAt = locals[decoIndex].from;
+            for(let i = 0; i < active.length; i++)if (active[i].to < cutAt) cutAt = active[i].to;
+            if (cutAt < end) {
+                restNode = child.cut(cutAt - offset);
+                child = child.cut(0, cutAt - offset);
+                end = cutAt;
+                index = -1;
+            }
+        } else {
+            while(decoIndex < locals.length && locals[decoIndex].to < end)decoIndex++;
+        }
+        const outerDeco = child.isInline && !child.isLeaf ? active.filter((d)=>!d.inline) : active.slice();
+        onNode(child, outerDeco, deco.forChild(offset, child), offset, index);
+        offset = end;
+    }
+}

package/dist/cjs/decorations/viewDecorations.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "viewDecorations", {
+    enumerable: true,
+    get: function() {
+        return viewDecorations;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const none = [], noSpec = {};
+const empty = _prosemirrorview.DecorationSet.empty;
+// An abstraction that allows the code dealing with decorations to
+// treat multiple DecorationSet objects as if it were a single object
+// with (a subset of) the same interface.
+let DecorationGroup = class DecorationGroup {
+    members;
+    constructor(members){
+        this.members = members;
+    }
+    map(mapping, doc) {
+        const mappedDecos = this.members.map((member)=>member.map(mapping, doc, noSpec));
+        return DecorationGroup.from(mappedDecos);
+    }
+    forChild(offset, child) {
+        if (child.isLeaf) return _prosemirrorview.DecorationSet.empty;
+        let found = [];
+        for(let i = 0; i < this.members.length; i++){
+            const result = this.members[i].forChild(offset, child);
+            if (result == empty) continue;
+            if (result instanceof DecorationGroup) found = found.concat(result.members);
+            else found.push(result);
+        }
+        return DecorationGroup.from(found);
+    }
+    eq(other) {
+        if (!(other instanceof DecorationGroup) || other.members.length != this.members.length) return false;
+        for(let i = 0; i < this.members.length; i++)if (!this.members[i].eq(other.members[i])) return false;
+        return true;
+    }
+    locals(node) {
+        let result, sorted = true;
+        for(let i = 0; i < this.members.length; i++){
+            const locals = this.members[i].localsInner(node);
+            if (!locals.length) continue;
+            if (!result) {
+                result = locals;
+            } else {
+                if (sorted) {
+                    result = result.slice();
+                    sorted = false;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                for(let j = 0; j < locals.length; j++)result.push(locals[j]);
+            }
+        }
+        return result ? removeOverlap(sorted ? result : result.sort(byPos)) : none;
+    }
+    // Create a group for the given array of decoration sets, or return
+    // a single set when possible.
+    static from(members) {
+        switch(members.length){
+            case 0:
+                return empty;
+            case 1:
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                return members[0];
+            default:
+                return new DecorationGroup(members.every((m)=>m instanceof _prosemirrorview.DecorationSet) ? members : members.reduce((r, m)=>r.concat(m instanceof _prosemirrorview.DecorationSet ? m : m.members), []));
+        }
+    }
+    forEachSet(f) {
+        for(let i = 0; i < this.members.length; i++)// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.members[i].forEachSet(f);
+    }
+};
+// Used to sort decorations so that ones with a low start position
+// come first, and within a set with the same start position, those
+// with an smaller end position come first.
+function byPos(a, b) {
+    return a.from - b.from || a.to - b.to;
+}
+// Scan a sorted array of decorations for partially overlapping spans,
+// and split those so that only fully overlapping spans are left (to
+// make subsequent rendering easier). Will return the input array if
+// no partially overlapping spans are found (the common case).
+function removeOverlap(spans) {
+    let working = spans;
+    for(let i = 0; i < working.length - 1; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const span = working[i];
+        if (span.from != span.to) for(let j = i + 1; j < working.length; j++){
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const next = working[j];
+            if (next.from == span.from) {
+                if (next.to != span.to) {
+                    if (working == spans) working = spans.slice();
+                    // Followed by a partially overlapping larger span. Split that
+                    // span.
+                    working[j] = next.copy(next.from, span.to);
+                    insertAhead(working, j + 1, next.copy(span.to, next.to));
+                }
+                continue;
+            } else {
+                if (next.from < span.to) {
+                    if (working == spans) working = spans.slice();
+                    // The end of this one overlaps with a subsequent span. Split
+                    // this one.
+                    working[i] = span.copy(span.from, next.from);
+                    insertAhead(working, j, span.copy(next.from, span.to));
+                }
+                break;
+            }
+        }
+    }
+    return working;
+}
+function insertAhead(array, i, deco) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    while(i < array.length && byPos(deco, array[i]) > 0)i++;
+    array.splice(i, 0, deco);
+}
+const ViewDecorationsCache = new WeakMap();
+function viewDecorations(view) {
+    const found = [];
+    view.someProp("decorations", (f)=>{
+        const result = f(view.state);
+        if (result && result != empty) found.push(result);
+    });
+    const previous = ViewDecorationsCache.get(view);
+    if (!previous) {
+        const result = DecorationGroup.from(found);
+        ViewDecorationsCache.set(view, result);
+        return result;
+    }
+    let numPrevious = 0;
+    let areSetsEqual = true;
+    previous.forEachSet((set)=>{
+        const next = found[numPrevious++];
+        if (next !== set) {
+            areSetsEqual = false;
+        }
+    });
+    if (numPrevious !== found.length) {
+        areSetsEqual = false;
+    }
+    if (!areSetsEqual) {
+        const result = DecorationGroup.from(found);
+        ViewDecorationsCache.set(view, result);
+        return result;
+    }
+    return previous;
+}