@miy2/xml-api 0.9.0 → 0.9.1

package/dist/history-manager.js

@@ -1,19 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HistoryManager = void 0;
-class HistoryManager {
+export class HistoryManager {
     constructor(maxHistory = 100) {
         this.undoStack = [];
         this.redoStack = [];
+        this.mergeThreshold = 1000; // ms
         this.maxHistory = maxHistory;
     }
     push(transaction) {
+        const last = this.undoStack[this.undoStack.length - 1];
+        if (last && this.shouldMerge(last, transaction)) {
+            this.merge(last, transaction);
+            return;
+        }
         this.undoStack.push(transaction);
         if (this.undoStack.length > this.maxHistory) {
             this.undoStack.shift();
         }
         this.redoStack = []; // Clear redo stack on new operation
     }
+    shouldMerge(last, next) {
+        // Check time threshold
+        if (next.timestamp - last.timestamp > this.mergeThreshold)
+            return false;
+        // Detect type of operation
+        // Pattern 1: Incremental Insertion (CodeEditor / Typing)
+        // Last: Insert "A" at 10. (from: 10, to: 10, text: "A")
+        // Next: Insert "B" at 11. (from: 11, to: 11, text: "B")
+        const isInsertion = last.redo.from === last.redo.to &&
+            next.redo.from === next.redo.to &&
+            next.redo.from === last.redo.from + last.redo.text.length;
+        if (isInsertion)
+            return true;
+        // Pattern 2: Replacement Extension (WYSIWYG / ViewBinder)
+        // Last: Replace "A" with "AB" at 10. (from: 10, to: 11, text: "AB")
+        // Next: Replace "AB" with "ABC" at 10. (from: 10, to: 12, text: "ABC")
+        // Condition: Start position same.
+        const isReplacementExtension = last.redo.from === next.redo.from &&
+            // Check if next is extending last
+            next.redo.text.startsWith(last.redo.text) &&
+            // Check if the previous state of next matches the current state of last
+            next.undo.text === last.redo.text;
+        // Note: next.undo.text is the text that was replaced by next.
+        // In Pattern 2, we replaced "AB" (last.redo.text) with "ABC".
+        // So next.undo.text should be "AB".
+        if (isReplacementExtension)
+            return true;
+        return false;
+    }
+    merge(last, next) {
+        last.timestamp = next.timestamp;
+        if (last.redo.from === last.redo.to && next.redo.from === next.redo.to) {
+            // Pattern 1: Incremental Insertion
+            // Last: Insert "A" at 10.
+            // Next: Insert "B" at 11.
+            // Merged: Insert "AB" at 10.
+            last.redo.text += next.redo.text;
+            // Undo:
+            // Last Undo: Delete 10-11 ("A").
+            // Next Undo: Delete 11-12 ("B").
+            // Merged Undo: Delete 10-12.
+            // The `to` of undo represents the end of the range to be replaced/deleted in the current doc.
+            // last.undo.to needs to expand by the length of the new insertion.
+            last.undo.to += next.redo.text.length;
+            // last.undo.text remains same (usually empty for insertion)
+        }
+        else {
+            // Pattern 2: Replacement Extension
+            // Last: Replace "A" (10-11) with "AB". Redo: "AB". Undo: "A" (from 10, to 12).
+            // Next: Replace "AB" (10-12) with "ABC". Redo: "ABC". Undo: "AB" (from 10, to 13).
+            // Merged: Replace "A" (10-11) with "ABC".
+            // Update Redo
+            last.redo.text = next.redo.text;
+            // last.redo.from/to remain as the original range of "A" (10-11).
+            // Update Undo
+            // We want undo to restore "A".
+            // Current state is "ABC" (10-13).
+            // Undo operation should be: replace 10-13 with "A".
+            // last.undo.from is 10. Correct.
+            // last.undo.text is "A". Correct.
+            // last.undo.to needs to be 13.
+            // next.undo.to is 13. (SyncEngine calculates this as from + text.length? No, SyncEngine calculates undo.to as newEnd)
+            // SyncEngine: undo: { from: p.from, to: newEnd, text: oldText }
+            // newEnd is the end of the newly inserted text.
+            // So yes, next.undo.to is 13.
+            last.undo.to = next.undo.to;
+        }
+    }
     undo() {
         const transaction = this.undoStack.pop();
         if (transaction) {
@@ -37,4 +108,3 @@ class HistoryManager {
         return this.redoStack.length > 0;
     }
 }
-exports.HistoryManager = HistoryManager;

package/dist/model/formatter.d.ts

@@ -2,11 +2,13 @@ import { type ModelNode } from "./xml-api-model";
 export interface FormatterOptions {
     indent?: string;
     newline?: string;
+    baseIndent?: string;
     force?: boolean;
 }
 export declare class Formatter {
     private indent;
     private newline;
+    private baseIndent;
     private force;
     constructor(options?: FormatterOptions);
     format(node: ModelNode): string;

package/dist/model/formatter.js

@@ -1,28 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Formatter = void 0;
-const xml_api_model_1 = require("./xml-api-model");
-class Formatter {
+import { ModelCDATA, ModelComment, ModelElement, ModelText, } from "./xml-api-model";
+export class Formatter {
     constructor(options = {}) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this.indent = (_a = options.indent) !== null && _a !== void 0 ? _a : "  ";
         this.newline = (_b = options.newline) !== null && _b !== void 0 ? _b : "\n";
-        this.force = (_c = options.force) !== null && _c !== void 0 ? _c : false;
+        this.baseIndent = (_c = options.baseIndent) !== null && _c !== void 0 ? _c : "";
+        this.force = (_d = options.force) !== null && _d !== void 0 ? _d : false;
     }
     format(node) {
         return this.formatNode(node, 0);
     }
     formatNode(node, level) {
-        if (node instanceof xml_api_model_1.ModelText) {
+        if (node instanceof ModelText) {
             return this.escape(node.text);
         }
-        if (node instanceof xml_api_model_1.ModelComment) {
+        if (node instanceof ModelComment) {
             return `<!--${node.content}-->`;
         }
-        if (node instanceof xml_api_model_1.ModelCDATA) {
+        if (node instanceof ModelCDATA) {
             return `<![CDATA[${node.content}]]>`;
         }
-        if (node instanceof xml_api_model_1.ModelElement) {
+        if (node instanceof ModelElement) {
             const tagName = node.tagName;
             const attributes = this.formatAttributes(node.attributes);
             const children = node.children;
@@ -35,7 +33,7 @@ class Formatter {
             if (isInline || hasFormatting) {
                 for (const child of children) {
                     if (this.force &&
-                        child instanceof xml_api_model_1.ModelText &&
+                        child instanceof ModelText &&
                         child.text.includes("\n") &&
                         child.text.trim().length === 0) {
                         continue;
@@ -47,7 +45,7 @@ class Formatter {
             else {
                 for (const child of children) {
                     if (this.force &&
-                        child instanceof xml_api_model_1.ModelText &&
+                        child instanceof ModelText &&
                         child.text.includes("\n") &&
                         child.text.trim().length === 0) {
                         continue;
@@ -74,12 +72,12 @@ class Formatter {
     }
     isInline(children) {
         for (const theChild of children) {
-            if (theChild instanceof xml_api_model_1.ModelText) {
+            if (theChild instanceof ModelText) {
                 // If there is any non-whitespace text, treat as inline.
                 if (theChild.text.trim().length > 0)
                     return true;
             }
-            if (theChild instanceof xml_api_model_1.ModelCDATA) {
+            if (theChild instanceof ModelCDATA) {
                 return true;
             }
         }
@@ -87,7 +85,7 @@ class Formatter {
     }
     hasFormatting(children) {
         for (const theChild of children) {
-            if (theChild instanceof xml_api_model_1.ModelText) {
+            if (theChild instanceof ModelText) {
                 // If it contains a newline and is otherwise whitespace, it's likely formatting.
                 if (theChild.text.includes("\n") && theChild.text.trim().length === 0) {
                     return true;
@@ -97,7 +95,7 @@ class Formatter {
         return false;
     }
     getIndent(level) {
-        return this.indent.repeat(level);
+        return this.baseIndent + this.indent.repeat(level);
     }
     escape(str) {
         return str
@@ -109,4 +107,3 @@ class Formatter {
         return this.escape(str).replace(/"/g, "&quot;");
     }
 }
-exports.Formatter = Formatter;

package/dist/model/xml-api-model.d.ts

@@ -6,42 +6,53 @@ export declare enum ModelNodeType {
     Comment = "Comment",
     CDATA = "CDATA"
 }
+export interface ModelFormatting {
+    /**
+     * The whitespace preceding the node, if it starts on a new line.
+     * Null if the node is inline (preceded by non-whitespace content).
+     */
+    indent: string | null;
+}
 export declare abstract class ModelNode {
     readonly id: NodeId;
     parent: ModelElement | null;
     cst: CST | null;
-    constructor();
+    formatting: ModelFormatting;
+    constructor(id?: NodeId);
     abstract getType(): ModelNodeType;
     abstract clone(preserveId?: boolean): ModelNode;
-    protected cloneBase(target: ModelNode, preserveId: boolean): void;
+    findNodeById(id: string): ModelNode | null;
+    protected cloneBase(target: ModelNode, _preserveId: boolean): void;
 }
 export declare class ModelElement extends ModelNode {
     tagName: string;
     attributes: Map<string, string>;
     children: ModelNode[];
-    constructor(tagName: string);
+    constructor(tagName: string, id?: NodeId);
     getType(): ModelNodeType;
     clone(preserveId?: boolean): ModelElement;
     addChild(node: ModelNode): void;
     setAttribute(key: string, value: string): void;
     find(tagName: string): ModelElement[];
+    findNodeById(id: string): ModelNode | null;
     text(): string;
 }
 export declare class ModelText extends ModelNode {
     text: string;
-    constructor(text: string);
+    kind: "text" | "whitespace";
+    constructor(text: string, id?: NodeId, kind?: "text" | "whitespace");
     getType(): ModelNodeType;
     clone(preserveId?: boolean): ModelText;
 }
 export declare class ModelComment extends ModelNode {
     content: string;
-    constructor(content: string);
+    constructor(content: string, id?: NodeId);
     getType(): ModelNodeType;
     clone(preserveId?: boolean): ModelComment;
 }
 export declare class ModelCDATA extends ModelNode {
     content: string;
-    constructor(content: string);
+    constructor(content: string, id?: NodeId);
     getType(): ModelNodeType;
     clone(preserveId?: boolean): ModelCDATA;
 }

package/dist/model/xml-api-model.js

@@ -1,31 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelCDATA = exports.ModelComment = exports.ModelText = exports.ModelElement = exports.ModelNode = exports.ModelNodeType = void 0;
-var ModelNodeType;
+export var ModelNodeType;
 (function (ModelNodeType) {
     ModelNodeType["Element"] = "Element";
     ModelNodeType["Text"] = "Text";
     ModelNodeType["Comment"] = "Comment";
     ModelNodeType["CDATA"] = "CDATA";
-})(ModelNodeType || (exports.ModelNodeType = ModelNodeType = {}));
-class ModelNode {
-    constructor() {
+})(ModelNodeType || (ModelNodeType = {}));
+export class ModelNode {
+    constructor(id) {
         this.parent = null;
         this.cst = null;
-        this.id = crypto.randomUUID();
+        this.formatting = { indent: null };
+        this.id = id !== null && id !== void 0 ? id : crypto.randomUUID();
     }
-    cloneBase(target, preserveId) {
-        if (preserveId) {
-            // @ts-ignore
-            target.id = this.id;
-        }
+    findNodeById(id) {
+        if (this.id === id)
+            return this;
+        return null;
+    }
+    cloneBase(target, _preserveId) {
         target.cst = this.cst;
+        target.formatting = { ...this.formatting };
     }
 }
-exports.ModelNode = ModelNode;
-class ModelElement extends ModelNode {
-    constructor(tagName) {
-        super();
+export class ModelElement extends ModelNode {
+    constructor(tagName, id) {
+        super(id);
         this.attributes = new Map();
         this.children = [];
         this.tagName = tagName;
@@ -34,7 +33,7 @@ class ModelElement extends ModelNode {
         return ModelNodeType.Element;
     }
     clone(preserveId = false) {
-        const clone = new ModelElement(this.tagName);
+        const clone = new ModelElement(this.tagName, preserveId ? this.id : undefined);
         this.cloneBase(clone, preserveId);
         clone.attributes = new Map(this.attributes);
         clone.children = this.children.map((c) => {
@@ -63,6 +62,16 @@ class ModelElement extends ModelNode {
         }
         return results;
     }
+    findNodeById(id) {
+        if (this.id === id)
+            return this;
+        for (const child of this.children) {
+            const found = child.findNodeById(id);
+            if (found)
+                return found;
+        }
+        return null;
+    }
     text() {
         return this.children
             .map((c) => {
@@ -77,49 +86,46 @@ class ModelElement extends ModelNode {
             .join("");
     }
 }
-exports.ModelElement = ModelElement;
-class ModelText extends ModelNode {
-    constructor(text) {
-        super();
+export class ModelText extends ModelNode {
+    constructor(text, id, kind = "text") {
+        super(id);
         this.text = text;
+        this.kind = kind;
     }
     getType() {
         return ModelNodeType.Text;
     }
     clone(preserveId = false) {
-        const clone = new ModelText(this.text);
+        const clone = new ModelText(this.text, preserveId ? this.id : undefined, this.kind);
         this.cloneBase(clone, preserveId);
         return clone;
     }
 }
-exports.ModelText = ModelText;
-class ModelComment extends ModelNode {
-    constructor(content) {
-        super();
+export class ModelComment extends ModelNode {
+    constructor(content, id) {
+        super(id);
         this.content = content;
     }
     getType() {
         return ModelNodeType.Comment;
     }
     clone(preserveId = false) {
-        const clone = new ModelComment(this.content);
+        const clone = new ModelComment(this.content, preserveId ? this.id : undefined);
         this.cloneBase(clone, preserveId);
         return clone;
     }
 }
-exports.ModelComment = ModelComment;
-class ModelCDATA extends ModelNode {
-    constructor(content) {
-        super();
+export class ModelCDATA extends ModelNode {
+    constructor(content, id) {
+        super(id);
         this.content = content;
     }
     getType() {
         return ModelNodeType.CDATA;
     }
     clone(preserveId = false) {
-        const clone = new ModelCDATA(this.content);
+        const clone = new ModelCDATA(this.content, preserveId ? this.id : undefined);
         this.cloneBase(clone, preserveId);
         return clone;
     }
 }
-exports.ModelCDATA = ModelCDATA;

package/dist/model/xml-binder.d.ts

@@ -1,11 +1,18 @@
 import type { CST } from "../cst/xml-cst";
 import { ModelElement, type ModelNode } from "./xml-api-model";
+export interface ReconcileResult {
+    node: ModelNode | null;
+    diff?: {
+        addedNodes: ModelNode[];
+        removedNodes: ModelNode[];
+    };
+}
 export declare class XMLBinder {
     private input;
     constructor(input: string);
     isHydratable(name: string | undefined): boolean;
     hydrate(node: CST): ModelNode | null;
-    reconcile(currentModel: ModelNode, newCst: CST): ModelNode;
+    reconcile(currentModel: ModelNode, newCst: CST): ReconcileResult;
     private canReconcile;
     private applyReconciliation;
     calcSetAttributePatch(model: ModelElement, key: string, value: string): {

package/dist/model/xml-binder.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XMLBinder = void 0;
-const xml_api_model_1 = require("./xml-api-model");
-class XMLBinder {
+import { detectIndent } from "../cst/cst-utils";
+import { ModelCDATA, ModelComment, ModelElement, ModelNodeType, ModelText, } from "./xml-api-model";
+export class XMLBinder {
     constructor(input) {
         this.input = input;
     }
@@ -24,37 +22,39 @@ class XMLBinder {
         let result = null;
         // 1. Handle known rule names
         if (node.name === "CharData") {
-            result = new xml_api_model_1.ModelText(node.getText(this.input));
+            const text = node.getText(this.input);
+            const kind = /^\s*$/.test(text) ? "whitespace" : "text";
+            result = new ModelText(text, undefined, kind);
         }
         else if (node.name === "Reference") {
             const text = node.getText(this.input);
             if (text.startsWith("&#")) {
-                result = new xml_api_model_1.ModelText(decodeCharRef(node, this.input));
+                result = new ModelText(decodeCharRef(node, this.input));
             }
             else {
-                result = new xml_api_model_1.ModelText(text);
+                result = new ModelText(text);
             }
         }
         else if (node.name === "CharRef") {
-            result = new xml_api_model_1.ModelText(decodeCharRef(node, this.input));
+            result = new ModelText(decodeCharRef(node, this.input));
         }
         else if (node.name === "EntityRef") {
-            result = new xml_api_model_1.ModelText(node.getText(this.input));
+            result = new ModelText(node.getText(this.input));
         }
         else if (node.name === "CDSect") {
             const structural = node.unwrap();
             if (structural.children.length === 3) {
-                result = new xml_api_model_1.ModelCDATA(structural.children[1].getText(this.input));
+                result = new ModelCDATA(structural.children[1].getText(this.input));
             }
             else {
-                result = new xml_api_model_1.ModelCDATA("");
+                result = new ModelCDATA("");
             }
         }
         else if (node.name === "Comment") {
             const text = node.getText(this.input);
             // Remove <!-- and -->
             const content = text.substring(4, text.length - 3);
-            result = new xml_api_model_1.ModelComment(content);
+            result = new ModelComment(content);
         }
         else if (node.name === "PI") {
             result = null;
@@ -118,7 +118,7 @@ class XMLBinder {
         }
         else if (node.type === "regex" || node.type === "literal") {
             // 2. Handle structural nodes (literals/regex)
-            result = new xml_api_model_1.ModelText(node.getText(this.input));
+            result = new ModelText(node.getText(this.input));
         }
         else if (node.children.length === 1 &&
             node.children[0].start === node.start &&
@@ -130,11 +130,14 @@ class XMLBinder {
             if (!result.cst) {
                 result.cst = node;
             }
+            if (result.cst) {
+                result.formatting.indent = detectIndent(result.cst, this.input);
+            }
         }
         return result;
     }
+    // ... (rest of class)
     reconcile(currentModel, newCst) {
-        // 1. Try to hydrate the new CST to see what it *should* look like.
         // This is inefficient (double parsing) but robust for a first implementation.
         // A better way would be to traverse CST and update Model in one pass.
         // But since `hydrate` logic is complex (handling grammar rules), duplicating it for reconcile is risky.
@@ -150,18 +153,18 @@ class XMLBinder {
             // For now, assume strict mapping.
             // But hydrate returns null for Comments/PIs.
             // If currentModel was something else, it's a replacement.
-            return newModel; // Should handle null better in caller?
+            return { node: newModel, diff: undefined };
         }
         if (this.canReconcile(currentModel, newModel)) {
-            this.applyReconciliation(currentModel, newModel);
-            return currentModel;
+            const diff = this.applyReconciliation(currentModel, newModel);
+            return { node: currentModel, diff };
         }
-        return newModel;
+        return { node: newModel, diff: undefined };
     }
     canReconcile(a, b) {
         if (a.getType() !== b.getType())
             return false;
-        if (a.getType() === xml_api_model_1.ModelNodeType.Element) {
+        if (a.getType() === ModelNodeType.Element) {
             return a.tagName === b.tagName;
         }
         // Text nodes can always be reconciled (updated)
@@ -169,13 +172,17 @@ class XMLBinder {
     }
     applyReconciliation(target, source) {
         target.cst = source.cst; // Update CST reference
-        if (target.getType() === xml_api_model_1.ModelNodeType.Text) {
-            target.text = source.text;
+        target.formatting = { ...source.formatting };
+        if (target.getType() === ModelNodeType.Text) {
+            const t = target;
+            const s = source;
+            t.text = s.text;
+            t.kind = s.kind;
         }
-        else if (target.getType() === xml_api_model_1.ModelNodeType.Comment) {
+        else if (target.getType() === ModelNodeType.Comment) {
             target.content = source.content;
         }
-        else if (target.getType() === xml_api_model_1.ModelNodeType.CDATA) {
+        else if (target.getType() === ModelNodeType.CDATA) {
             target.content = source.content;
         }
         else {
@@ -185,11 +192,12 @@ class XMLBinder {
             t.attributes = s.attributes;
             // Reconcile Children with Key-based Matching
             const newChildren = [];
+            const oldChildrenSet = new Set(t.children);
             // 1. Map existing children by ID
             const keyedChildren = new Map();
             const nonKeyedChildren = [];
             for (const child of t.children) {
-                if (child.getType() === xml_api_model_1.ModelNodeType.Element) {
+                if (child.getType() === ModelNodeType.Element) {
                     const el = child;
                     const id = el.attributes.get("id");
                     if (id) {
@@ -207,7 +215,7 @@ class XMLBinder {
             for (const sChild of s.children) {
                 let matchedNode;
                 // Try Keyed Match
-                if (sChild.getType() === xml_api_model_1.ModelNodeType.Element) {
+                if (sChild.getType() === ModelNodeType.Element) {
                     const sEl = sChild;
                     const id = sEl.attributes.get("id");
                     if (id && keyedChildren.has(id)) {
@@ -226,12 +234,15 @@ class XMLBinder {
                         }
                     }
                 }
-                if (matchedNode) {
+                if (matchedNode && sChild.cst) {
                     // Found a match (keyed or non-keyed)
                     // Use CST from new node to update existing node
-                    const reconciled = this.reconcile(matchedNode, sChild.cst);
-                    reconciled.parent = t;
-                    newChildren.push(reconciled);
+                    const result = this.reconcile(matchedNode, sChild.cst);
+                    const reconciled = result.node;
+                    if (reconciled) {
+                        newChildren.push(reconciled);
+                        reconciled.parent = t;
+                    }
                 }
                 else {
                     // No match found, use new node
@@ -240,7 +251,11 @@ class XMLBinder {
                 }
             }
             t.children = newChildren;
+            const addedNodes = newChildren.filter((c) => !oldChildrenSet.has(c));
+            const removedNodes = Array.from(oldChildrenSet).filter((c) => !newChildren.includes(c));
+            return { addedNodes, removedNodes };
         }
+        return undefined;
     }
     calcSetAttributePatch(model, key, value) {
         if (!model.cst)
@@ -384,7 +399,7 @@ class XMLBinder {
                     break;
                 }
             }
-            if (anchorNode && anchorNode.cst) {
+            if (anchorNode === null || anchorNode === void 0 ? void 0 : anchorNode.cst) {
                 insertPos = anchorNode.cst.start;
             }
             else {
@@ -430,7 +445,7 @@ class XMLBinder {
         const structural = node.unwrap();
         const nameNode = structural.children[1];
         const tagName = nameNode.getText(this.input);
-        const elem = new xml_api_model_1.ModelElement(tagName);
+        const elem = new ModelElement(tagName);
         const attrRep = structural.children[2]; // rep(seq(S, Attribute))
         for (const seq of attrRep.children) {
             const attrNode = seq.children[1]; // Attribute
@@ -447,7 +462,7 @@ class XMLBinder {
                 // Since hydrate returns ModelNode, we need to extract text.
                 // But attribute values might be complex? In current grammar, they are mostly text/refs.
                 const modelNode = this.hydrate(chunk);
-                if (modelNode instanceof xml_api_model_1.ModelText) {
+                if (modelNode instanceof ModelText) {
                     valText += modelNode.text;
                 }
                 else if (modelNode) {
@@ -464,7 +479,6 @@ class XMLBinder {
         return elem;
     }
 }
-exports.XMLBinder = XMLBinder;
 function decodeCharRef(node, input) {
     const text = node.getText(input);
     let code;

package/dist/model/xml-schema.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XMLSchema = void 0;
-class XMLSchema {
+export class XMLSchema {
     constructor(definitions = []) {
         this.elements = new Map();
         for (const def of definitions) {
@@ -13,4 +10,3 @@ class XMLSchema {
         return (_b = (_a = this.elements.get(tagName)) === null || _a === void 0 ? void 0 : _a.isVoid) !== null && _b !== void 0 ? _b : false;
     }
 }
-exports.XMLSchema = XMLSchema;