@miy2/xml-api 0.9.0

package/dist/engine/sync-engine.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncEngine = void 0;
+const parser_1 = require("../cst/parser");
+const xml_grammar_1 = require("../cst/xml-grammar");
+const history_manager_1 = require("../history-manager");
+const formatter_1 = require("../model/formatter");
+const xml_api_model_1 = require("../model/xml-api-model");
+const xml_binder_1 = require("../model/xml-binder");
+const xml_api_events_1 = require("../xml-api-events");
+const editor_state_1 = require("./editor-state");
+const transaction_1 = require("./transaction");
+class SyncEngine {
+    constructor(source, grammar = xml_grammar_1.grammar) {
+        this.isTransacting = false;
+        this.collabBridge = null;
+        this._state = editor_state_1.EditorState.create(source);
+        this.parser = new parser_1.Parser(grammar);
+        this.binder = new xml_binder_1.XMLBinder(source);
+        this.history = new history_manager_1.HistoryManager();
+        this.events = new xml_api_events_1.EventEmitter();
+        this.fullParse();
+    }
+    get state() {
+        return this._state;
+    }
+    get source() {
+        return this._state.source;
+    }
+    get model() {
+        return this._state.model;
+    }
+    get cst() {
+        return this._state.cst;
+    }
+    get grammar() {
+        return this.parser.grammar;
+    }
+    setCollabBridge(bridge) {
+        this.collabBridge = bridge;
+    }
+    /**
+     * Subscribe to model changes.
+     */
+    on(handler) {
+        return this.events.on(handler);
+    }
+    /**
+     * Applies a transaction to the engine, updating the state and notifying listeners.
+     */
+    dispatch(tr) {
+        if (!tr.docChanged)
+            return;
+        const oldState = this._state;
+        const newSource = tr.newSource;
+        // History Recording
+        if (!this.isTransacting) {
+            // In a real transaction system, we would store the inverse patches.
+            // For now, we rely on the single patch assumption for history or reconstruct it.
+            // Since Transaction can have multiple patches, simple history push is harder.
+            // We'll approximate by storing the full undo/redo for the range covered.
+            // Ideally, HistoryManager should handle Transaction objects.
+            // Temporary: Only support history for single-patch transactions or reconstruct simple history
+            if (tr.patches.length === 1) {
+                const p = tr.patches[0];
+                const oldText = oldState.source.slice(p.from, p.to);
+                const newEnd = p.from + p.text.length;
+                this.history.push({
+                    redo: { from: p.from, to: p.to, text: p.text },
+                    undo: { from: p.from, to: newEnd, text: oldText },
+                });
+            }
+            else {
+                // Fallback for multi-patch (clear history or just skip? Skipping is dangerous for undo)
+                // For Phase 3, we accept this limitation or clear history.
+                // Or we assume history only tracks updateSource calls which are single patch.
+            }
+        }
+        this._state = this._state.update({ source: newSource });
+        // Core Update Logic (Parser / Binder)
+        this.binder = new xml_binder_1.XMLBinder(newSource);
+        // Optimization: If single patch, try incremental. Else full parse.
+        let handled = false;
+        if (tr.patches.length === 1 && oldState.cst) {
+            const p = tr.patches[0];
+            const delta = p.text.length - (p.to - p.from);
+            const incrementalResult = this.tryIncrementalUpdate(p.from, p.to, delta);
+            if (incrementalResult) {
+                if (oldState.model) {
+                    this.updateModelIncremental(incrementalResult.oldNode, incrementalResult.newNode, tr);
+                }
+                else {
+                    this.events.emit({ type: "full", transaction: tr });
+                }
+                if (this._state.cst && !this._state.cst.wellFormed) {
+                    this._state = this._state.update({ model: null });
+                    this.events.emit({ type: "full", transaction: tr });
+                }
+                handled = true;
+            }
+        }
+        if (!handled) {
+            this.fullParse();
+            this.events.emit({ type: "full", transaction: tr });
+        }
+        // Notify Collaboration Bridge if local change
+        if (!tr.isRemote && this.collabBridge) {
+            this.collabBridge.receiveLocalTransaction(tr);
+        }
+    }
+    /**
+     * Update the source code (e.g. from text editor).
+     * Handles history recording and incremental parsing.
+     */
+    updateSource(from, to, text) {
+        const tr = new transaction_1.Transaction(this._state);
+        tr.replace(from, to, text);
+        this.dispatch(tr);
+    }
+    /**
+     * Apply a programmatic change derived from Model operations.
+     * This is the "Application -> Source" flow.
+     */
+    applyPatch(start, end, text) {
+        // Uses dispatch via updateSource logic, but conceptually distinct
+        const tr = new transaction_1.Transaction(this._state);
+        tr.replace(start, end, text);
+        this.dispatch(tr);
+    }
+    // --- History Operations ---
+    undo() {
+        const tx = this.history.undo();
+        if (tx) {
+            this.isTransacting = true;
+            try {
+                this.updateSource(tx.undo.from, tx.undo.to, tx.undo.text);
+            }
+            finally {
+                this.isTransacting = false;
+            }
+        }
+    }
+    redo() {
+        const tx = this.history.redo();
+        if (tx) {
+            this.isTransacting = true;
+            try {
+                this.updateSource(tx.redo.from, tx.redo.to, tx.redo.text);
+            }
+            finally {
+                this.isTransacting = false;
+            }
+        }
+    }
+    // --- High-Level Model Operations (delegated to Binder) ---
+    setAttribute(modelNode, key, value) {
+        if (!modelNode.cst)
+            throw new Error("Model node not linked to CST");
+        const patch = this.binder.calcSetAttributePatch(modelNode, key, value);
+        if (patch) {
+            this.applyPatch(patch.start, patch.end, patch.text);
+        }
+    }
+    updateText(modelNode, text) {
+        if (!modelNode.cst)
+            throw new Error("Model node not linked to CST");
+        const patch = this.binder.calcUpdateTextPatch(modelNode, text);
+        if (patch) {
+            this.applyPatch(patch.start, patch.end, patch.text);
+        }
+    }
+    replaceNode(target, content) {
+        var _a;
+        if (!target.cst)
+            throw new Error("Model node not linked to CST");
+        // Formatting logic
+        let indentUnit = "  ";
+        let currentIndent = "";
+        if (target.cst) {
+            currentIndent = this.detectIndent(target.cst);
+            if ((_a = target.parent) === null || _a === void 0 ? void 0 : _a.cst) {
+                const parentIndent = this.detectIndent(target.parent.cst);
+                if (currentIndent.startsWith(parentIndent)) {
+                    const diff = currentIndent.slice(parentIndent.length);
+                    if (diff.length > 0 && !diff.includes("\n")) {
+                        indentUnit = diff;
+                    }
+                }
+            }
+        }
+        const formatter = new formatter_1.Formatter({ indent: indentUnit });
+        let newXml = formatter.format(content);
+        if (currentIndent && newXml.includes("\n")) {
+            newXml = newXml
+                .split("\n")
+                .map((line, index) => (index === 0 ? line : currentIndent + line))
+                .join("\n");
+        }
+        const patch = this.binder.calcReplaceNodePatch(target, newXml);
+        if (patch) {
+            this.applyPatch(patch.start, patch.end, patch.text);
+        }
+    }
+    insertNode(parent, child, index) {
+        if (!parent.cst)
+            throw new Error("Parent node not linked to CST");
+        // Determine basic indentation (simplistic)
+        let indentUnit = "  ";
+        if (parent.cst) {
+            const parentIndent = this.detectIndent(parent.cst);
+            // Try to find a child to detect indent step
+            // ... skipping complex logic for now
+        }
+        const formatter = new formatter_1.Formatter({ indent: indentUnit });
+        const insertText = formatter.format(child);
+        const patch = this.binder.calcInsertNodePatch(parent, index, insertText);
+        if (patch) {
+            this.applyPatch(patch.start, patch.end, patch.text);
+        }
+    }
+    removeNode(parent, child) {
+        if (!child.cst)
+            throw new Error("Target node not linked to CST");
+        const patch = this.binder.calcRemoveNodePatch(child);
+        if (patch) {
+            this.applyPatch(patch.start, patch.end, patch.text);
+        }
+    }
+    // --- Internal Logic ---
+    fullParse() {
+        try {
+            const cst = this.parser.parse(this._state.source);
+            let model = null;
+            if (cst === null || cst === void 0 ? void 0 : cst.wellFormed) {
+                // Hydrate full model
+                const newModel = this.binder.hydrate(cst);
+                if (newModel instanceof xml_api_model_1.ModelElement) {
+                    model = newModel;
+                }
+            }
+            this._state = this._state.update({ cst, model });
+        }
+        catch (e) {
+            console.error("Parse error:", e);
+            this._state = this._state.update({ cst: null, model: null });
+        }
+    }
+    tryIncrementalUpdate(from, to, delta) {
+        const currentCst = this._state.cst;
+        if (!currentCst)
+            return null;
+        let target = this.findNodeAt(currentCst, from, to);
+        while (target) {
+            if (target.name) {
+                if (!this.binder.isHydratable(target.name)) {
+                    target = target.parent;
+                    continue;
+                }
+                const parseStart = target.parent ? target.start : 0;
+                const result = this.parser.parseAt(this._state.source, parseStart, target.name);
+                const expectedEnd = target.end + delta;
+                if (result && result.end === expectedEnd) {
+                    if (target.parent) {
+                        currentCst.shift(from, delta);
+                        const index = target.parent.children.indexOf(target);
+                        if (index !== -1) {
+                            target.parent.children[index] = result.node;
+                            result.node.parent = target.parent;
+                            this.updateAncestorsWellFormed(result.node);
+                            // State update is implicitly handled because we mutated the CST object
+                            // which is referenced by this._state.cst
+                            return { oldNode: target, newNode: result.node };
+                        }
+                    }
+                    else {
+                        this._state = this._state.update({ cst: result.node });
+                        return { oldNode: target, newNode: result.node };
+                    }
+                }
+            }
+            target = target.parent;
+        }
+        return null;
+    }
+    updateModelIncremental(oldNode, newNode, tr) {
+        const currentModel = this._state.model;
+        if (!currentModel)
+            return;
+        if (currentModel.cst === oldNode) {
+            const newModelNode = this.binder.hydrate(newNode);
+            if (newModelNode instanceof xml_api_model_1.ModelElement) {
+                this._state = this._state.update({ model: newModelNode });
+                this.events.emit({
+                    type: "full",
+                    target: newModelNode,
+                    transaction: tr,
+                });
+            }
+            return;
+        }
+        const modelPath = this.findModelNodePath(currentModel, oldNode);
+        if (modelPath) {
+            const reconciledModel = this.binder.reconcile(modelPath.node, newNode);
+            if (reconciledModel) {
+                if (reconciledModel !== modelPath.node) {
+                    modelPath.parent.children[modelPath.index] = reconciledModel;
+                    reconciledModel.parent = modelPath.parent;
+                }
+                this.events.emit({
+                    type: "structure",
+                    target: reconciledModel,
+                    transaction: tr,
+                });
+            }
+        }
+    }
+    // --- Helpers ---
+    findNodeAt(root, from, to) {
+        let current = root;
+        while (true) {
+            let foundChild = null;
+            // Binary search optimization
+            let left = 0;
+            let right = current.children.length - 1;
+            let candidateIndex = -1;
+            while (left <= right) {
+                const mid = (left + right) >>> 1;
+                if (current.children[mid].start <= from) {
+                    candidateIndex = mid;
+                    left = mid + 1;
+                }
+                else {
+                    right = mid - 1;
+                }
+            }
+            if (candidateIndex !== -1) {
+                const candidate = current.children[candidateIndex];
+                if (candidate.end >= to) {
+                    foundChild = candidate;
+                }
+            }
+            if (foundChild) {
+                current = foundChild;
+            }
+            else {
+                break;
+            }
+        }
+        return current;
+    }
+    findModelNodePath(root, cstNode) {
+        for (let i = 0; i < root.children.length; i++) {
+            const child = root.children[i];
+            if (child.cst === cstNode) {
+                return { parent: root, index: i, node: child };
+            }
+            if (child instanceof xml_api_model_1.ModelElement) {
+                const found = this.findModelNodePath(child, cstNode);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    updateAncestorsWellFormed(node) {
+        let current = node.parent;
+        while (current) {
+            let childrenWellFormed = true;
+            for (const child of current.children) {
+                if (!child.wellFormed) {
+                    childrenWellFormed = false;
+                    break;
+                }
+            }
+            let selfWellFormed = childrenWellFormed;
+            if (current.name && selfWellFormed) {
+                const validator = this.parser.grammar.validators[current.name];
+                if (validator && !validator(current, this._state.source)) {
+                    selfWellFormed = false;
+                }
+            }
+            current.wellFormed = selfWellFormed;
+            current = current.parent;
+        }
+    }
+    detectIndent(node) {
+        const input = this._state.source;
+        let i = node.start - 1;
+        while (i >= 0) {
+            if (input[i] === "\n") {
+                return input.slice(i + 1, node.start);
+            }
+            if (input[i] !== " " && input[i] !== "\t") {
+                return "";
+            }
+            i--;
+        }
+        return "";
+    }
+}
+exports.SyncEngine = SyncEngine;

package/dist/engine/transaction.d.ts

@@ -0,0 +1,30 @@
+import type { EditorState } from "./editor-state";
+export interface TextPatch {
+    from: number;
+    to: number;
+    text: string;
+}
+/**
+ * Represents a unit of change to the editor state.
+ * Currently focuses on text changes (patches).
+ */
+export declare class Transaction {
+    readonly startState: EditorState;
+    readonly patches: TextPatch[];
+    docChanged: boolean;
+    /** Indicates if this transaction originated from a remote source (collaboration). */
+    isRemote: boolean;
+    constructor(startState: EditorState);
+    /**
+     * Adds a text change to the transaction.
+     * @param from Start index
+     * @param to End index
+     * @param text New text
+     */
+    replace(from: number, to: number, text: string): this;
+    /**
+     * Calculates the new source text by applying patches.
+     * Handles multiple patches by sorting them in reverse order of position.
+     */
+    get newSource(): string;
+}

package/dist/engine/transaction.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+/**
+ * Represents a unit of change to the editor state.
+ * Currently focuses on text changes (patches).
+ */
+class Transaction {
+    // Placeholder for future selection and metadata
+    // public selection: Selection | null = null;
+    // public meta: Map<string, any> = new Map();
+    constructor(startState) {
+        this.startState = startState;
+        this.patches = [];
+        this.docChanged = false;
+        /** Indicates if this transaction originated from a remote source (collaboration). */
+        this.isRemote = false;
+    }
+    /**
+     * Adds a text change to the transaction.
+     * @param from Start index
+     * @param to End index
+     * @param text New text
+     */
+    replace(from, to, text) {
+        if (from < 0 || from > to) {
+            throw new Error(`Invalid patch range: ${from}-${to}`);
+        }
+        this.patches.push({ from, to, text });
+        this.docChanged = true;
+        return this;
+    }
+    /**
+     * Calculates the new source text by applying patches.
+     * Handles multiple patches by sorting them in reverse order of position.
+     */
+    get newSource() {
+        let source = this.startState.source;
+        // Sort descending by position to apply from end to start
+        // This avoids index shifting issues for subsequent patches
+        const sorted = [...this.patches].sort((a, b) => b.from - a.from);
+        for (const p of sorted) {
+            // Validate range
+            if (p.from > source.length || p.to > source.length) {
+                throw new Error(`Invalid patch range: ${p.from}-${p.to} (Length: ${source.length})`);
+            }
+            source = source.slice(0, p.from) + p.text + source.slice(p.to);
+        }
+        return source;
+    }
+}
+exports.Transaction = Transaction;

package/dist/history-manager.d.ts

@@ -0,0 +1,23 @@
+export interface Transaction {
+    redo: {
+        from: number;
+        to: number;
+        text: string;
+    };
+    undo: {
+        from: number;
+        to: number;
+        text: string;
+    };
+}
+export declare class HistoryManager {
+    private undoStack;
+    private redoStack;
+    private maxHistory;
+    constructor(maxHistory?: number);
+    push(transaction: Transaction): void;
+    undo(): Transaction | null;
+    redo(): Transaction | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}

package/dist/history-manager.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryManager = void 0;
+class HistoryManager {
+    constructor(maxHistory = 100) {
+        this.undoStack = [];
+        this.redoStack = [];
+        this.maxHistory = maxHistory;
+    }
+    push(transaction) {
+        this.undoStack.push(transaction);
+        if (this.undoStack.length > this.maxHistory) {
+            this.undoStack.shift();
+        }
+        this.redoStack = []; // Clear redo stack on new operation
+    }
+    undo() {
+        const transaction = this.undoStack.pop();
+        if (transaction) {
+            this.redoStack.push(transaction);
+            return transaction;
+        }
+        return null;
+    }
+    redo() {
+        const transaction = this.redoStack.pop();
+        if (transaction) {
+            this.undoStack.push(transaction);
+            return transaction;
+        }
+        return null;
+    }
+    canUndo() {
+        return this.undoStack.length > 0;
+    }
+    canRedo() {
+        return this.redoStack.length > 0;
+    }
+}
+exports.HistoryManager = HistoryManager;

package/dist/model/formatter.d.ts

@@ -0,0 +1,20 @@
+import { type ModelNode } from "./xml-api-model";
+export interface FormatterOptions {
+    indent?: string;
+    newline?: string;
+    force?: boolean;
+}
+export declare class Formatter {
+    private indent;
+    private newline;
+    private force;
+    constructor(options?: FormatterOptions);
+    format(node: ModelNode): string;
+    private formatNode;
+    private formatAttributes;
+    private isInline;
+    private hasFormatting;
+    private getIndent;
+    private escape;
+    private escapeAttribute;
+}

package/dist/model/formatter.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+const xml_api_model_1 = require("./xml-api-model");
+class Formatter {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        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;
+    }
+    format(node) {
+        return this.formatNode(node, 0);
+    }
+    formatNode(node, level) {
+        if (node instanceof xml_api_model_1.ModelText) {
+            return this.escape(node.text);
+        }
+        if (node instanceof xml_api_model_1.ModelComment) {
+            return `<!--${node.content}-->`;
+        }
+        if (node instanceof xml_api_model_1.ModelCDATA) {
+            return `<![CDATA[${node.content}]]>`;
+        }
+        if (node instanceof xml_api_model_1.ModelElement) {
+            const tagName = node.tagName;
+            const attributes = this.formatAttributes(node.attributes);
+            const children = node.children;
+            if (children.length === 0) {
+                return `<${tagName}${attributes} />`;
+            }
+            const isInline = this.isInline(children);
+            const hasFormatting = this.force ? false : this.hasFormatting(children);
+            let result = `<${tagName}${attributes}>`;
+            if (isInline || hasFormatting) {
+                for (const child of children) {
+                    if (this.force &&
+                        child instanceof xml_api_model_1.ModelText &&
+                        child.text.includes("\n") &&
+                        child.text.trim().length === 0) {
+                        continue;
+                    }
+                    result += this.formatNode(child, level + 1);
+                }
+                result += `</${tagName}>`;
+            }
+            else {
+                for (const child of children) {
+                    if (this.force &&
+                        child instanceof xml_api_model_1.ModelText &&
+                        child.text.includes("\n") &&
+                        child.text.trim().length === 0) {
+                        continue;
+                    }
+                    result +=
+                        this.newline +
+                            this.getIndent(level + 1) +
+                            this.formatNode(child, level + 1);
+                }
+                result += `${this.newline + this.getIndent(level)}</${tagName}>`;
+            }
+            return result;
+        }
+        return "";
+    }
+    formatAttributes(attributes) {
+        if (attributes.size === 0)
+            return "";
+        const entries = Array.from(attributes.entries());
+        return (" " +
+            entries
+                .map(([key, value]) => `${key}="${this.escapeAttribute(value)}"`) // Corrected: escaped " to \"
+                .join(" "));
+    }
+    isInline(children) {
+        for (const theChild of children) {
+            if (theChild instanceof xml_api_model_1.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) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasFormatting(children) {
+        for (const theChild of children) {
+            if (theChild instanceof xml_api_model_1.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;
+                }
+            }
+        }
+        return false;
+    }
+    getIndent(level) {
+        return this.indent.repeat(level);
+    }
+    escape(str) {
+        return str
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;");
+    }
+    escapeAttribute(str) {
+        return this.escape(str).replace(/"/g, "&quot;");
+    }
+}
+exports.Formatter = Formatter;