@miy2/xml-api 0.9.0

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

@@ -0,0 +1,47 @@
+import type { CST } from "../cst/xml-cst";
+export type NodeId = string;
+export declare enum ModelNodeType {
+    Element = "Element",
+    Text = "Text",
+    Comment = "Comment",
+    CDATA = "CDATA"
+}
+export declare abstract class ModelNode {
+    readonly id: NodeId;
+    parent: ModelElement | null;
+    cst: CST | null;
+    constructor();
+    abstract getType(): ModelNodeType;
+    abstract clone(preserveId?: boolean): ModelNode;
+    protected cloneBase(target: ModelNode, preserveId: boolean): void;
+}
+export declare class ModelElement extends ModelNode {
+    tagName: string;
+    attributes: Map<string, string>;
+    children: ModelNode[];
+    constructor(tagName: string);
+    getType(): ModelNodeType;
+    clone(preserveId?: boolean): ModelElement;
+    addChild(node: ModelNode): void;
+    setAttribute(key: string, value: string): void;
+    find(tagName: string): ModelElement[];
+    text(): string;
+}
+export declare class ModelText extends ModelNode {
+    text: string;
+    constructor(text: string);
+    getType(): ModelNodeType;
+    clone(preserveId?: boolean): ModelText;
+}
+export declare class ModelComment extends ModelNode {
+    content: string;
+    constructor(content: string);
+    getType(): ModelNodeType;
+    clone(preserveId?: boolean): ModelComment;
+}
+export declare class ModelCDATA extends ModelNode {
+    content: string;
+    constructor(content: string);
+    getType(): ModelNodeType;
+    clone(preserveId?: boolean): ModelCDATA;
+}

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelCDATA = exports.ModelComment = exports.ModelText = exports.ModelElement = exports.ModelNode = exports.ModelNodeType = void 0;
+var ModelNodeType;
+(function (ModelNodeType) {
+    ModelNodeType["Element"] = "Element";
+    ModelNodeType["Text"] = "Text";
+    ModelNodeType["Comment"] = "Comment";
+    ModelNodeType["CDATA"] = "CDATA";
+})(ModelNodeType || (exports.ModelNodeType = ModelNodeType = {}));
+class ModelNode {
+    constructor() {
+        this.parent = null;
+        this.cst = null;
+        this.id = crypto.randomUUID();
+    }
+    cloneBase(target, preserveId) {
+        if (preserveId) {
+            // @ts-ignore
+            target.id = this.id;
+        }
+        target.cst = this.cst;
+    }
+}
+exports.ModelNode = ModelNode;
+class ModelElement extends ModelNode {
+    constructor(tagName) {
+        super();
+        this.attributes = new Map();
+        this.children = [];
+        this.tagName = tagName;
+    }
+    getType() {
+        return ModelNodeType.Element;
+    }
+    clone(preserveId = false) {
+        const clone = new ModelElement(this.tagName);
+        this.cloneBase(clone, preserveId);
+        clone.attributes = new Map(this.attributes);
+        clone.children = this.children.map((c) => {
+            const cClone = c.clone(preserveId);
+            cClone.parent = clone;
+            return cClone;
+        });
+        return clone;
+    }
+    addChild(node) {
+        node.parent = this;
+        this.children.push(node);
+    }
+    setAttribute(key, value) {
+        this.attributes.set(key, value);
+    }
+    find(tagName) {
+        let results = [];
+        for (const child of this.children) {
+            if (child instanceof ModelElement) {
+                if (child.tagName === tagName) {
+                    results.push(child);
+                }
+                results = results.concat(child.find(tagName));
+            }
+        }
+        return results;
+    }
+    text() {
+        return this.children
+            .map((c) => {
+            if (c instanceof ModelText)
+                return c.text;
+            if (c instanceof ModelCDATA)
+                return c.content;
+            if (c instanceof ModelElement)
+                return c.text();
+            return "";
+        })
+            .join("");
+    }
+}
+exports.ModelElement = ModelElement;
+class ModelText extends ModelNode {
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    getType() {
+        return ModelNodeType.Text;
+    }
+    clone(preserveId = false) {
+        const clone = new ModelText(this.text);
+        this.cloneBase(clone, preserveId);
+        return clone;
+    }
+}
+exports.ModelText = ModelText;
+class ModelComment extends ModelNode {
+    constructor(content) {
+        super();
+        this.content = content;
+    }
+    getType() {
+        return ModelNodeType.Comment;
+    }
+    clone(preserveId = false) {
+        const clone = new ModelComment(this.content);
+        this.cloneBase(clone, preserveId);
+        return clone;
+    }
+}
+exports.ModelComment = ModelComment;
+class ModelCDATA extends ModelNode {
+    constructor(content) {
+        super();
+        this.content = content;
+    }
+    getType() {
+        return ModelNodeType.CDATA;
+    }
+    clone(preserveId = false) {
+        const clone = new ModelCDATA(this.content);
+        this.cloneBase(clone, preserveId);
+        return clone;
+    }
+}
+exports.ModelCDATA = ModelCDATA;

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

@@ -0,0 +1,37 @@
+import type { CST } from "../cst/xml-cst";
+import { ModelElement, type ModelNode } from "./xml-api-model";
+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;
+    private canReconcile;
+    private applyReconciliation;
+    calcSetAttributePatch(model: ModelElement, key: string, value: string): {
+        start: number;
+        end: number;
+        text: string;
+    } | null;
+    calcUpdateTextPatch(model: ModelElement, text: string): {
+        start: number;
+        end: number;
+        text: string;
+    } | null;
+    calcReplaceNodePatch(model: ModelNode, newXml: string): {
+        start: number;
+        end: number;
+        text: string;
+    } | null;
+    calcInsertNodePatch(parent: ModelElement, index: number, insertText: string): {
+        start: number;
+        end: number;
+        text: string;
+    } | null;
+    calcRemoveNodePatch(child: ModelNode): {
+        start: number;
+        end: number;
+        text: string;
+    } | null;
+    private parseTag;
+}

package/dist/model/xml-binder.js

@@ -0,0 +1,484 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XMLBinder = void 0;
+const xml_api_model_1 = require("./xml-api-model");
+class XMLBinder {
+    constructor(input) {
+        this.input = input;
+    }
+    isHydratable(name) {
+        if (!name)
+            return false;
+        return [
+            "element",
+            "document",
+            "CharData",
+            "Reference",
+            "CharRef",
+            "EntityRef",
+            "CDSect",
+            "Comment",
+        ].includes(name);
+    }
+    hydrate(node) {
+        let result = null;
+        // 1. Handle known rule names
+        if (node.name === "CharData") {
+            result = new xml_api_model_1.ModelText(node.getText(this.input));
+        }
+        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));
+            }
+            else {
+                result = new xml_api_model_1.ModelText(text);
+            }
+        }
+        else if (node.name === "CharRef") {
+            result = new xml_api_model_1.ModelText(decodeCharRef(node, this.input));
+        }
+        else if (node.name === "EntityRef") {
+            result = new xml_api_model_1.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));
+            }
+            else {
+                result = new xml_api_model_1.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);
+        }
+        else if (node.name === "PI") {
+            result = null;
+        }
+        else if (node.name === "element" || node.name === "document") {
+            const structural = node.unwrap();
+            // document rule: seq(prolog, element, Misc*)
+            if (node.name === "document" &&
+                structural.type === "sequence" &&
+                structural.children.length >= 2) {
+                const elementNode = structural.children[1];
+                result = this.hydrate(elementNode);
+            }
+            else if (structural.children.length === 3 &&
+                structural.children[0].name === "STag") {
+                // Case 1: Sequence [STag, content, ETag]
+                const stag = structural.children[0];
+                const content = structural.children[1];
+                const elem = this.parseTag(stag);
+                // elem.cst will be set at the end
+                const contentStructural = content.unwrap();
+                // content rule: seq(opt(CharData), rep(seq(alt(...), opt(CharData))))
+                // Initial CharData
+                const initialCharDataRep = contentStructural.children[0];
+                if (initialCharDataRep && initialCharDataRep.children.length > 0) {
+                    const textNode = this.hydrate(initialCharDataRep.children[0]);
+                    if (textNode)
+                        elem.addChild(textNode);
+                }
+                // Repeating part
+                const repeatingPart = contentStructural.children[1];
+                if (repeatingPart) {
+                    for (const seqNode of repeatingPart.children) {
+                        // seq(alt(...), opt(CharData))
+                        const choiceNode = seqNode.children[0];
+                        const converted = this.hydrate(choiceNode);
+                        if (converted) {
+                            elem.addChild(converted);
+                        }
+                        const trailingCharDataRep = seqNode.children[1];
+                        if (trailingCharDataRep &&
+                            trailingCharDataRep.children.length > 0) {
+                            const textNode = this.hydrate(trailingCharDataRep.children[0]);
+                            if (textNode)
+                                elem.addChild(textNode);
+                        }
+                    }
+                }
+                result = elem;
+            }
+            else if (structural.children.length >= 2 &&
+                structural.children[0].type === "literal" &&
+                structural.children[0].getText(this.input) === "<") {
+                // Case 2: EmptyElemTag
+                result = this.parseTag(node);
+            }
+            else if (structural !== node) {
+                // Wrapper check
+                result = this.hydrate(structural);
+            }
+        }
+        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));
+        }
+        else if (node.children.length === 1 &&
+            node.children[0].start === node.start &&
+            node.children[0].end === node.end) {
+            // 3. Fallback wrapper unwrap
+            result = this.hydrate(node.children[0]);
+        }
+        if (result) {
+            if (!result.cst) {
+                result.cst = node;
+            }
+        }
+        return result;
+    }
+    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.
+        //
+        // Optimization: hydrate returns a NEW model tree.
+        // We then compare this new tree with currentModel.
+        // If they match in structure/identity-keys, we update currentModel and return it.
+        // If not, we return the new model.
+        const newModel = this.hydrate(newCst);
+        if (!newModel) {
+            // If hydration failed (e.g. comment), but we had a model, return null?
+            // Or if the node disappeared.
+            // 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?
+        }
+        if (this.canReconcile(currentModel, newModel)) {
+            this.applyReconciliation(currentModel, newModel);
+            return currentModel;
+        }
+        return newModel;
+    }
+    canReconcile(a, b) {
+        if (a.getType() !== b.getType())
+            return false;
+        if (a.getType() === xml_api_model_1.ModelNodeType.Element) {
+            return a.tagName === b.tagName;
+        }
+        // Text nodes can always be reconciled (updated)
+        return true;
+    }
+    applyReconciliation(target, source) {
+        target.cst = source.cst; // Update CST reference
+        if (target.getType() === xml_api_model_1.ModelNodeType.Text) {
+            target.text = source.text;
+        }
+        else if (target.getType() === xml_api_model_1.ModelNodeType.Comment) {
+            target.content = source.content;
+        }
+        else if (target.getType() === xml_api_model_1.ModelNodeType.CDATA) {
+            target.content = source.content;
+        }
+        else {
+            const t = target;
+            const s = source;
+            // Update Attributes
+            t.attributes = s.attributes;
+            // Reconcile Children with Key-based Matching
+            const newChildren = [];
+            // 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) {
+                    const el = child;
+                    const id = el.attributes.get("id");
+                    if (id) {
+                        keyedChildren.set(id, el);
+                    }
+                    else {
+                        nonKeyedChildren.push(child);
+                    }
+                }
+                else {
+                    nonKeyedChildren.push(child);
+                }
+            }
+            // 2. Iterate source children and try to match
+            for (const sChild of s.children) {
+                let matchedNode;
+                // Try Keyed Match
+                if (sChild.getType() === xml_api_model_1.ModelNodeType.Element) {
+                    const sEl = sChild;
+                    const id = sEl.attributes.get("id");
+                    if (id && keyedChildren.has(id)) {
+                        matchedNode = keyedChildren.get(id);
+                        keyedChildren.delete(id);
+                    }
+                }
+                // Try Non-Keyed Match (First compatible)
+                if (!matchedNode) {
+                    for (let i = 0; i < nonKeyedChildren.length; i++) {
+                        const candidate = nonKeyedChildren[i];
+                        if (this.canReconcile(candidate, sChild)) {
+                            matchedNode = candidate;
+                            nonKeyedChildren.splice(i, 1);
+                            break;
+                        }
+                    }
+                }
+                if (matchedNode) {
+                    // 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);
+                }
+                else {
+                    // No match found, use new node
+                    sChild.parent = t;
+                    newChildren.push(sChild);
+                }
+            }
+            t.children = newChildren;
+        }
+    }
+    calcSetAttributePatch(model, key, value) {
+        if (!model.cst)
+            return null;
+        const structural = model.cst.unwrap();
+        let tagNode = null;
+        // Identify tag node (STag or EmptyElemTag)
+        // Case 1: element ::= STag content ETag
+        if (structural.children.length === 3 &&
+            structural.children[0].name === "STag") {
+            tagNode = structural.children[0];
+        }
+        // Case 2: element ::= EmptyElemTag
+        else if (structural.name === "EmptyElemTag") {
+            tagNode = structural;
+        }
+        // Case 3: Wrapper or other structure (try to find tag in children)
+        else {
+            for (const child of structural.children) {
+                if (child.name === "STag" || child.name === "EmptyElemTag") {
+                    tagNode = child;
+                    break;
+                }
+            }
+            // If structural is strictly EmptyElemTag but unwrap failed to show name? (Unlikely)
+            if (!tagNode &&
+                structural.children.length >= 2 &&
+                structural.children[0].getText(this.input) === "<") {
+                // Fallback: assume it matches EmptyElemTag structure directly
+                tagNode = structural;
+            }
+        }
+        if (!tagNode)
+            return null;
+        const tagStructural = tagNode.unwrap();
+        // Expected structure: < Name (S Attribute)* S? >  (Length 5)
+        // Robust access to attributes
+        // Index 2 is rep(seq(S, Attribute))
+        const attrRep = tagStructural.children[2];
+        if (attrRep && attrRep.type === "repeat") {
+            for (const seqNode of attrRep.children) {
+                // seq(S, Attribute)
+                const attrNode = seqNode.children[1];
+                if (attrNode && attrNode.name === "Attribute") {
+                    const attrStructural = attrNode.unwrap();
+                    const nameNode = attrStructural.children[0];
+                    const attrName = nameNode.getText(this.input);
+                    if (attrName === key) {
+                        // Found existing attribute
+                        const attValueNode = attrStructural.children[2];
+                        const oldText = attValueNode.getText(this.input);
+                        const quote = oldText[0];
+                        // Preserve quote style if possible
+                        const newQuote = quote === "'" || quote === '"' ? quote : '"';
+                        return {
+                            start: attValueNode.start,
+                            end: attValueNode.end,
+                            text: `${newQuote}${escapeAttributeValue(value)}${newQuote}`,
+                        };
+                    }
+                }
+            }
+        }
+        // Attribute not found, insert new one.
+        // Insert before the closing sequence (S? > or S? />)
+        // The closing sequence starts after the attributes.
+        // We can insert at the end of attrRep?
+        // Or just look at the end of the tag and back up.
+        const len = tagStructural.children.length;
+        const closing = tagStructural.children[len - 1]; // > or />
+        const _optS = tagStructural.children[len - 2]; // S?
+        // Insert before closing bracket.
+        // If optS is present (has children or length > 0), we can insert before or after it?
+        // If we insert ` id="val"`, we provide the space.
+        // So inserting at `closing.start` is safe.
+        // Special case: If EmptyElemTag ends with `/>` (start is 2 chars before end).
+        // closing.start points to `/`.
+        return {
+            start: closing.start,
+            end: closing.start,
+            text: ` ${key}="${escapeAttributeValue(value)}"`,
+        };
+    }
+    calcUpdateTextPatch(model, text) {
+        if (!model.cst)
+            return null;
+        const structural = model.cst.unwrap();
+        // Case 1: Sequence [STag, content, ETag]
+        if (structural.children.length === 3 &&
+            structural.children[0].name === "STag") {
+            const contentNode = structural.children[1];
+            return {
+                start: contentNode.start,
+                end: contentNode.end,
+                text: escapeText(text),
+            };
+        }
+        // Case 2: EmptyElemTag
+        // <Name ... /> -> <Name ... >text</Name>
+        // We need to find "/>" at the end and replace it with ">text</Name>"
+        if (structural.name === "EmptyElemTag" ||
+            (structural.children.length >= 2 &&
+                structural.children[0].getText(this.input) === "<")) {
+            const len = structural.children.length;
+            const closing = structural.children[len - 1]; // "/>"
+            if (closing.getText(this.input) === "/>") {
+                return {
+                    start: closing.start,
+                    end: closing.end,
+                    text: `>${escapeText(text)}</${model.tagName}>`,
+                };
+            }
+        }
+        return null;
+    }
+    calcReplaceNodePatch(model, newXml) {
+        if (!model.cst)
+            return null;
+        // Direct replacement of the CST range
+        return {
+            start: model.cst.start,
+            end: model.cst.end,
+            text: newXml,
+        };
+    }
+    calcInsertNodePatch(parent, index, insertText) {
+        if (!parent.cst)
+            return null;
+        const structural = parent.cst.unwrap();
+        // Case 1: Sequence [STag, content, ETag]
+        if (structural.children.length === 3 &&
+            structural.children[0].name === "STag") {
+            // content -> seq(opt(CharData), rep(seq(alt(...), opt(CharData))))
+            let insertPos;
+            // Look for the next sibling that has a CST (stable anchor)
+            // Since the model already contains the new node at 'index', we look from 'index + 1'
+            let anchorNode = null;
+            for (let i = index + 1; i < parent.children.length; i++) {
+                if (parent.children[i].cst) {
+                    anchorNode = parent.children[i];
+                    break;
+                }
+            }
+            if (anchorNode && anchorNode.cst) {
+                insertPos = anchorNode.cst.start;
+            }
+            else {
+                // No following stable anchor found, insert before ETag
+                const etag = structural.children[2];
+                insertPos = etag.start;
+            }
+            return {
+                start: insertPos,
+                end: insertPos,
+                text: insertText,
+            };
+        }
+        // Case 2: EmptyElemTag
+        // <Name ... /> -> <Name ... >insertText</Name>
+        if (structural.name === "EmptyElemTag" ||
+            (structural.children.length >= 2 &&
+                structural.children[0].getText(this.input) === "<")) {
+            const len = structural.children.length;
+            const closing = structural.children[len - 1]; // "/>"
+            if (closing.getText(this.input) === "/>") {
+                return {
+                    start: closing.start,
+                    end: closing.end,
+                    text: `>${insertText}</${parent.tagName}>`,
+                };
+            }
+        }
+        return null;
+    }
+    calcRemoveNodePatch(child) {
+        if (!child.cst)
+            return null;
+        // TODO: Ideally we should remove surrounding whitespace if it becomes redundant (pretty print maintenance).
+        // For now, strict removal.
+        return {
+            start: child.cst.start,
+            end: child.cst.end,
+            text: "",
+        };
+    }
+    parseTag(node) {
+        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 attrRep = structural.children[2]; // rep(seq(S, Attribute))
+        for (const seq of attrRep.children) {
+            const attrNode = seq.children[1]; // Attribute
+            const attrStructural = attrNode.unwrap();
+            const attrName = attrStructural.children[0].getText(this.input);
+            const attValueNode = attrStructural.children[2];
+            const attValueStructural = attValueNode.unwrap();
+            const valRep = attValueStructural.children[1];
+            let valText = "";
+            for (const chunk of valRep.children) {
+                // Use hydrate to get text nodes from value chunks, or just getText?
+                // convert() recursively called convert, which returned AST|string.
+                // For attribute values, we expect string.
+                // 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) {
+                    valText += modelNode.text;
+                }
+                else if (modelNode) {
+                    // Fallback if somehow it returned an Element (unlikely in AttValue)
+                    // But wait, hydrate returns ModelNode.
+                    // If it's a reference, it returns ModelText.
+                    // If it's a literal/regex, it returns ModelText.
+                    // So this should be fine.
+                    // However, if hydrate returns null, we skip.
+                }
+            }
+            elem.setAttribute(attrName, valText);
+        }
+        return elem;
+    }
+}
+exports.XMLBinder = XMLBinder;
+function decodeCharRef(node, input) {
+    const text = node.getText(input);
+    let code;
+    if (text.startsWith("&#x")) {
+        code = parseInt(text.slice(3, -1), 16);
+    }
+    else {
+        code = parseInt(text.slice(2, -1), 10);
+    }
+    return String.fromCodePoint(code);
+}
+function escapeText(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttributeValue(str) {
+    return escapeText(str).replace(/"/g, "&quot;");
+}