@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.8 → 0.3.3-wrap-unwrap.10

package/dist/features/wrapUnwrap/revert/revertMoveOp.d.ts

@@ -1,9 +1,8 @@
 import { type Transform } from "prosemirror-transform";
 import { type MoveOp } from "../types.js";
 import { type Node } from "prosemirror-model";
-import { type NodeWithChildren, type Parent } from "../types.js";
+import { type Parent } from "../types.js";
 export declare function revertMoveOp(op: MoveOp, tr: Transform, node: Node, pos: number): void;
-export declare function getNodesWithChildren(doc: Node): Map<string, NodeWithChildren>;
 export declare function getDeepestSurvivingParent(parentChain: Parent[], doc: Node): {
     parent: Parent;
     node: Node;
@@ -11,4 +10,7 @@ export declare function getDeepestSurvivingParent(parentChain: Parent[], doc: No
     remainingChain: Parent[];
 };
 export declare function wrapNodeInParentChain(parentChain: Parent[], node: Node): Node;
-export declare function findInsertionPos(node: Node, pos: number | null, parent: Parent): number;
+export declare function findInsertionPos(node: Node, pos: number | null, parent: Parent, child: Node): number | {
+    from: number;
+    to: number;
+};

package/dist/features/wrapUnwrap/revert/revertMoveOp.js

@@ -1,6 +1,5 @@
 import { deleteNodeUpwards } from "./deleteNodeUpwards.js";
 import { getNodeId } from "../getNodeId.js";
-import { guardDocParent, guardDocWithChildren } from "../types.js";
 export function revertMoveOp(op, tr, node, pos) {
     console.log("revertMoveOp", "node", node.toString(), "was moved from", op.from, {
         op,
@@ -11,50 +10,15 @@ export function revertMoveOp(op, tr, node, pos) {
         parent
     });
     const child = wrapNodeInParentChain(parent.remainingChain, node);
-    console.log("revertMoveOp", "wrapped node in parent chain is", child.toString(), {
-        child
-    });
-    const insertionPos = findInsertionPos(parent.node, parent.pos, parent.parent);
-    console.log("revertMoveOp", "insertion pos", {
-        insertionPos
-    });
-    tr.insert(insertionPos, child);
+    const insertTo = findInsertionPos(parent.node, parent.pos, parent.parent, child);
+    if (typeof insertTo === "number") {
+        tr.insert(insertTo, child);
+    } else {
+        tr.replaceWith(insertTo.from, insertTo.to, child);
+    }
     const mappedPos = tr.mapping.map(pos);
     deleteNodeUpwards(tr, node, mappedPos);
 }
-export function getNodesWithChildren(doc) {
-    const nodesWithChildren = new Map();
-    const docWithChildren = {
-        node: doc,
-        pos: null,
-        children: new Set()
-    };
-    doc.children.forEach((child)=>{
-        const nodeId = getNodeId(child);
-        if (nodeId == null) return;
-        docWithChildren.children.add(nodeId);
-    });
-    nodesWithChildren.set("__doc__", docWithChildren);
-    doc.descendants((node, pos)=>{
-        if (node.isText) return true;
-        const nodeId = getNodeId(node);
-        if (nodeId == null) return true;
-        if (nodesWithChildren.has(nodeId)) return true;
-        const children = node.children.reduce((acc, child)=>{
-            const childId = getNodeId(child);
-            if (childId == null) return acc;
-            acc.add(childId);
-            return acc;
-        }, new Set());
-        nodesWithChildren.set(nodeId, {
-            node,
-            pos,
-            children
-        });
-        return true;
-    });
-    return nodesWithChildren;
-}
 // given a chain of parent node descriptors, follow the chain from top to bottom as long as nodes exist
 // return the deepest existing parent node descriptor, along with the actual node and the pos in the current document
 // also return the remaining part of the chain
@@ -62,38 +26,41 @@ export function getDeepestSurvivingParent(parentChain, doc) {
     const chain = [
         ...parentChain
     ].reverse();
-    const currentNodes = getNodesWithChildren(doc);
-    let currentNode = currentNodes.get("__doc__"); // get doc node with children from current doc
-    if (!guardDocWithChildren(currentNode)) {
-        throw new Error("doc not found in nodesWithChildren");
-    }
-    let parent = chain.shift(); // get doc node descriptor from parent chain
-    if (!guardDocParent(parent)) {
-        throw new Error("doc parent not found in op chain");
+    const root = chain.shift();
+    if (root == null) {
+        throw new Error("Parent chain is empty");
     }
-    let remainingChain = [];
-    for (const [index, nextParent] of chain.entries()){
-        const nextNodeWithChildren = currentNodes.get(nextParent.nodeId);
-        // nextParent does not exist in the current document at all
-        if (nextNodeWithChildren == null) {
-            remainingChain = chain.slice(index);
-            break;
-        }
-        // nextParent exists in the document, but in a different parent chain
-        if (!currentNode.children.has(nextParent.nodeId)) {
-            remainingChain = chain.slice(index);
-            break;
-        }
-        currentNode = nextNodeWithChildren;
-        parent = nextParent;
+    let result = {
+        parent: root,
+        node: doc,
+        pos: null
+    };
+    let remainingChain = [
+        ...chain
+    ];
+    // follow the chain up-down
+    // look for the node with the matching id in the children of the previously found node
+    for (const [index, item] of chain.entries()){
+        let found = false;
+        result.node.forEach((child, offset)=>{
+            if (found) return;
+            if (child.attrs["id"] !== item.nodeId) return;
+            found = true;
+            const pos = result.pos == null ? offset : result.pos + 1 + offset;
+            result = {
+                parent: item,
+                node: child,
+                pos
+            };
+            remainingChain = chain.slice(index + 1);
+        });
+        if (!found) break;
     }
     return {
-        parent,
-        node: currentNode.node,
-        pos: currentNode.pos,
-        remainingChain: [
-            ...remainingChain
-        ].reverse()
+        parent: result.parent,
+        node: result.node,
+        pos: result.pos,
+        remainingChain: remainingChain.reverse()
     };
 }
 // given a chain of parent node descriptors and a node
@@ -107,14 +74,17 @@ export function wrapNodeInParentChain(parentChain, node) {
             throw new Error(`node type ${parent.nodeType} not found in schema`);
         }
         const marks = parent.nodeMarks.map((mark)=>schema.markFromJSON(mark));
-        child = nodeType.create(parent.nodeAttrs, child, marks);
+        const parentNode = nodeType.createAndFill(parent.nodeAttrs, child, marks);
+        if (parentNode == null) throw new Error(`Unable to create node ${nodeType.name} with child ${child.toString()}`);
+        child = parentNode;
+        child.check();
     }
     return child;
 }
 // given a node, its position, and a parent descriptor of this node in some parent chain,
 // use the info from the descriptor to find the insertion position in the node
 // first try to find siblings, fallback to end of node
-export function findInsertionPos(node, pos, parent) {
+export function findInsertionPos(node, pos, parent, child) {
     let leftSibling = null;
     let rightSibling = null;
     node.descendants((child, localChildPos)=>{
@@ -137,6 +107,16 @@ export function findInsertionPos(node, pos, parent) {
         return false;
     });
     if (rightSibling != null) {
+        // special case: we need to insert as the first child, but the existing first child is an empty node of the same type
+        // in this case, we need to replace the existing first child with the new node
+        const firstChild = node.children[0];
+        if (parent.childSiblingIds[0] == null && firstChild?.type === child.type && firstChild.textContent === "") {
+            const from = pos != null ? pos + 1 : 0;
+            return {
+                from,
+                to: from + firstChild.nodeSize
+            };
+        }
         // insert before right sibling
         return rightSibling.pos;
     }

package/dist/features/wrapUnwrap/revert/revertStructureSuggestions.js

@@ -43,11 +43,11 @@ function revertStructureSuggestionWithPrerequisites(tr, suggestionId) {
 function revertOneStructureSuggestion(tr, suggestionId) {
     console.group("revertStructureSuggestion", "reverting structure suggestion", suggestionId);
     let structureMark = findNextStructureMark(tr.doc, suggestionId);
-    while(structureMark != null){
-        console.groupCollapsed("revertStructureSuggestion", "reverting structure mark", structureMark.mark.attrs["id"], "at pos", structureMark.$pos.pos, "at node", structureMark.node.toString(), {
+    while(structureMark !== null){
+        console.groupCollapsed("revertStructureSuggestion", "reverting structure mark", structureMark.mark.attrs["id"], "at pos", structureMark.pos, "at node", structureMark.node.toString(), {
             structureMark
         });
-        revertStructureMark(tr, structureMark.mark, structureMark.$pos.pos);
+        revertStructureMark(tr, structureMark.mark, structureMark.pos);
         console.groupEnd();
         structureMark = findNextStructureMark(tr.doc, suggestionId);
     }
@@ -154,7 +154,6 @@ function buildOrderedSuggestionIds(node, suggestionId, materializedPaths) {
     return Array.from(suggestionIds).reverse();
 }
 function findNextStructureMark(node, suggestionId) {
-    console.log("findNextStructureMark", suggestionId);
     const { structure } = getSuggestionMarks(node.type.schema);
     const structureMarks = [];
     node.descendants((descendant, pos)=>{
@@ -163,18 +162,11 @@ function findNextStructureMark(node, suggestionId) {
         structureMarks.push({
             mark,
             node: descendant,
+            pos,
             $pos: node.resolve(pos)
         });
         return true;
     });
     structureMarks.sort((a, b)=>b.$pos.depth - a.$pos.depth);
-    if (structureMarks[0]) {
-        console.log("findStructureMark", "found structure mark with id", suggestionId, {
-            structureMark: structureMarks[0],
-            suggestionId
-        });
-    } else {
-        console.log("findStructureMark", "no structure mark found with id", suggestionId);
-    }
-    return structureMarks[0];
+    return structureMarks[0] ?? null;
 }

package/dist/features/wrapUnwrap/types.d.ts

@@ -1,13 +1,4 @@
-import { type Attrs, type Node } from "prosemirror-model";
-interface NonDocNodeWithChildren {
-    node: Node;
-    pos: number;
-    children: Set<string>;
-}
-export interface DocWithChildren extends Omit<NonDocNodeWithChildren, "pos"> {
-    pos: null;
-}
-export type NodeWithChildren = NonDocNodeWithChildren | DocWithChildren;
+import { type Attrs } from "prosemirror-model";
 interface NodeParent {
     nodeId: string;
     nodeType: string;
@@ -41,5 +32,4 @@ export type MaterializedPaths = Map<string, {
 }>;
 export declare function guardDocParent(parent: Parent | undefined): parent is DocParent;
 export declare function guardStructureMarkAttrs(attrs: Attrs): attrs is StructureMarkAttrs;
-export declare function guardDocWithChildren(nodeWithChildren: NodeWithChildren | undefined): nodeWithChildren is DocWithChildren;
 export {};

package/dist/features/wrapUnwrap/types.js

@@ -8,6 +8,3 @@ export function guardStructureMarkAttrs(attrs) {
     if (!("op" in data)) return false;
     return true;
 }
-export function guardDocWithChildren(nodeWithChildren) {
-    return nodeWithChildren != null && nodeWithChildren.pos === null;
-}

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export { withSuggestChanges, transformToSuggestionTransaction, } from "./withSug
 export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled, } from "./ensureSelectionPlugin.js";
 export { guardStructureMarkAttrs } from "./features/wrapUnwrap/types.js";
 export type { Op as StructureOp, StructureMarkAttrs, } from "./features/wrapUnwrap/types.js";
+export { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/index.js

@@ -4,3 +4,4 @@ export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled } from "./pl
 export { withSuggestChanges, transformToSuggestionTransaction } from "./withSuggestChanges.js";
 export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled } from "./ensureSelectionPlugin.js";
 export { guardStructureMarkAttrs } from "./features/wrapUnwrap/types.js";
+export { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/listInputRules.d.ts

@@ -0,0 +1,2 @@
+import { type NodeType } from "prosemirror-model";
+export declare function listInputRules(bulletListNodeType: NodeType, orderedListNodeType: NodeType): import("prosemirror-inputrules").InputRule[];

package/dist/listInputRules.js

@@ -0,0 +1,14 @@
+import { wrappingInputRule } from "./wrappingInputRule.js";
+import { ZWSP } from "./constants.js";
+export function listInputRules(bulletListNodeType, orderedListNodeType) {
+    const bulletListInputRule = wrappingInputRule(// ^ string start, [${ZWSP}\\s]* zero or more ZWSP or whitespace, ([-+*]) one of -+* , \\s one whitespace, $ end of string
+    // "u" flag treats \u as unicode code points instead of literal "u"
+    new RegExp(`^[${ZWSP}\\s]*([-+*])\\s$`, "u"), bulletListNodeType);
+    // ^ string start, [${ZWSP}\\s]* zero or more ZWSP or whitespace, ([0-9]+\\.) digit followed by dot, \\s one whitespace, $ end of string
+    // "u" flag treats \u as unicode code points instead of literal "u"
+    const orderedListInputRule = wrappingInputRule(new RegExp(`^[${ZWSP}\\s]*([0-9]+\\.)\\s$`, "u"), orderedListNodeType);
+    return [
+        bulletListInputRule,
+        orderedListInputRule
+    ];
+}

package/dist/wrappingInputRule.d.ts

@@ -0,0 +1,4 @@
+import { InputRule } from "prosemirror-inputrules";
+import { type Node } from "prosemirror-model";
+import { type Attrs, type NodeType } from "prosemirror-model";
+export declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;

package/dist/wrappingInputRule.js

@@ -0,0 +1,28 @@
+import { InputRule } from "prosemirror-inputrules";
+import { canJoin, findWrapping } from "prosemirror-transform";
+import { getSuggestionMarks } from "./utils.js";
+import { ZWSP } from "./constants.js";
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end)=>{
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const tr = state.tr;
+        // check and try to preserve zwsp
+        const { insertion } = getSuggestionMarks(state.doc.type.schema);
+        let $start = tr.doc.resolve(start);
+        if (insertion.isInSet($start.nodeAfter?.marks ?? []) && match[0].startsWith(ZWSP)) {
+            // preserve a single ZWSP at the start
+            tr.delete(start + 1, end);
+        } else {
+            tr.delete(start, end);
+        }
+        // the rest of the rule unchanged
+        $start = tr.doc.resolve(start);
+        const range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping) return null;
+        tr.wrap(range, wrapping);
+        const before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before))) tr.join(start - 1);
+        return tr;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-marker/prosemirror-suggest-changes",
-  "version": "0.3.3-wrap-unwrap.8",
+  "version": "0.3.3-wrap-unwrap.10",
   "license": "MIT",
   "type": "module",
   "module": "dist/index.js",