@miy2/xml-api 0.9.0 → 0.9.1

package/README.md

@@ -56,7 +56,7 @@ if (item) {
   item.textContent = 'Updated Value';
 }
 
-console.log(api.input);
+console.log(api.source);
 /* 
 Output:
 <root>
@@ -69,7 +69,27 @@ Output:
 
 ```typescript
 // Update the source code directly at specific offsets
-api.updateInput(14, 28, "New Content");
+api.updateSource(14, 28, "New Content");
+```
+
+### Schema Projection (New in v0.9.1)
+
+Create a filtered view of the document that adheres to a specific schema (e.g. XHTML).
+The view preserves the underlying model's full fidelity (including comments and custom tags) while presenting a simplified DOM for editing.
+
+```typescript
+const api = new XMLAPI(source);
+const view = api.createView({
+  // Only show 'p' and 'div' elements
+  filter: (node) => 
+    node.getType() === 'Element' && 
+    ['p', 'div'].includes((node as ModelElement).tagName)
+});
+
+const root = view.getRoot(); // Returns a filtered DOM-like element
+const p = view.getDocument().createElement('p');
+p.textContent = "New Paragraph";
+root.appendChild(p); // Updates source automatically with smart formatting
 ```
 
 ## Documentation

package/dist/collab/bridge.js

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

package/dist/cst/cst-utils.d.ts

@@ -0,0 +1,11 @@
+import type { CST } from "./xml-cst";
+/**
+ * Detects the indentation string preceding a CST node.
+ * Scans backwards from the node's start position until a newline or non-whitespace character is found.
+ *
+ * @param node The CST node to analyze.
+ * @param source The full source string.
+ * @returns The indentation string (e.g., "  ", "\t") if the node starts on a new line (or start of file).
+ *          Returns null if the node follows non-whitespace content on the same line (inline).
+ */
+export declare function detectIndent(node: CST, source: string): string | null;

package/dist/cst/cst-utils.js

@@ -0,0 +1,32 @@
+/**
+ * Detects the indentation string preceding a CST node.
+ * Scans backwards from the node's start position until a newline or non-whitespace character is found.
+ *
+ * @param node The CST node to analyze.
+ * @param source The full source string.
+ * @returns The indentation string (e.g., "  ", "\t") if the node starts on a new line (or start of file).
+ *          Returns null if the node follows non-whitespace content on the same line (inline).
+ */
+export function detectIndent(node, source) {
+    let i = node.start - 1;
+    while (i >= 0) {
+        const char = source[i];
+        if (char === "\n") {
+            return source.slice(i + 1, node.start);
+        }
+        if (char !== " " && char !== "\t" && char !== "\r") {
+            // Found non-whitespace on the same line, so no clean indent.
+            return null;
+        }
+        i--;
+    }
+    // Start of file
+    if (node.start >= 0) {
+        // Check if the line from 0 to node.start is all whitespace
+        const prefix = source.slice(0, node.start);
+        if (/^\s*$/.test(prefix)) {
+            return prefix;
+        }
+    }
+    return null;
+}

package/dist/cst/grammar.js

@@ -1,71 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrammarBuilder = exports.Grammar = exports.ref = exports.exc = exports.opt = exports.plus = exports.rep = exports.alt = exports.seq = exports.reg = exports.lit = void 0;
 // Combinators
 /** Defines a literal string match. */
-const lit = (value) => ({ type: "Literal", value });
-exports.lit = lit;
+export const lit = (value) => ({ type: "Literal", value });
 /** Defines a regular expression match. */
-const reg = (pattern) => ({
+export const reg = (pattern) => ({
     type: "RegExpMatch",
     pattern,
 });
-exports.reg = reg;
 /** Defines a sequence of matches in order. */
-const seq = (...expressions) => ({
+export const seq = (...expressions) => ({
     type: "Sequence",
     expressions,
 });
-exports.seq = seq;
 /** Defines a choice between multiple alternatives. */
-const alt = (...expressions) => ({
+export const alt = (...expressions) => ({
     type: "Choice",
     expressions,
 });
-exports.alt = alt;
 /** Zero or more repetitions (equivalent to `*` in EBNF). */
-const rep = (expression) => ({
+export const rep = (expression) => ({
     type: "Repeat",
     expression,
     min: 0,
     max: Infinity,
 });
-exports.rep = rep;
 /** One or more repetitions (equivalent to `+` in EBNF). */
-const plus = (expression) => ({
+export const plus = (expression) => ({
     type: "Repeat",
     expression,
     min: 1,
     max: Infinity,
 });
-exports.plus = plus;
 /** Zero or one occurrence (equivalent to `?` in EBNF, optional). */
-const opt = (expression) => ({
+export const opt = (expression) => ({
     type: "Repeat",
     expression,
     min: 0,
     max: 1,
 });
-exports.opt = opt;
 /** Matches A but excludes B (e.g., matching PITarget as a Name excluding "xml"). */
-const exc = (a, b) => ({
+export const exc = (a, b) => ({
     type: "Exclusion",
     a,
     b,
 });
-exports.exc = exc;
 /** References another rule by its name. */
-const ref = (name) => ({ type: "Reference", name });
-exports.ref = ref;
-class Grammar {
+export const ref = (name) => ({ type: "Reference", name });
+export class Grammar {
     constructor(rules, validators, rootRule) {
         this.rules = rules;
         this.validators = validators;
         this.rootRule = rootRule;
     }
 }
-exports.Grammar = Grammar;
-class GrammarBuilder {
+export class GrammarBuilder {
     constructor() {
         this.rules = {};
         this.validators = {};
@@ -92,4 +79,3 @@ class GrammarBuilder {
         return new Grammar({ ...this.rules }, { ...this.validators }, root);
     }
 }
-exports.GrammarBuilder = GrammarBuilder;

package/dist/cst/parser.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
-const xml_cst_1 = require("./xml-cst");
-class Parser {
+import { CST } from "./xml-cst";
+export class Parser {
     constructor(grammar) {
         this.grammar = grammar;
     }
@@ -56,7 +53,7 @@ class Parser {
         if (ctx.input.startsWith(expr.value, ctx.pos)) {
             const start = ctx.pos;
             ctx.pos += expr.value.length;
-            return new xml_cst_1.CST("literal", undefined, start, ctx.pos);
+            return new CST("literal", undefined, start, ctx.pos);
         }
         return null;
     }
@@ -67,7 +64,7 @@ class Parser {
         if (match) {
             const start = ctx.pos;
             ctx.pos += match[0].length;
-            return new xml_cst_1.CST("regex", undefined, start, ctx.pos);
+            return new CST("regex", undefined, start, ctx.pos);
         }
         return null;
     }
@@ -86,7 +83,7 @@ class Parser {
                 wellFormed = false;
             }
         }
-        return new xml_cst_1.CST("sequence", undefined, startPos, ctx.pos, children, wellFormed);
+        return new CST("sequence", undefined, startPos, ctx.pos, children, wellFormed);
     }
     execChoice(expr, ctx) {
         for (const childExpr of expr.expressions) {
@@ -119,7 +116,7 @@ class Parser {
             ctx.pos = startPos;
             return null;
         }
-        return new xml_cst_1.CST("repeat", undefined, startPos, ctx.pos, children, wellFormed);
+        return new CST("repeat", undefined, startPos, ctx.pos, children, wellFormed);
     }
     execExclusion(expr, ctx) {
         const startPos = ctx.pos;
@@ -146,7 +143,7 @@ class Parser {
         if (result === null)
             return null;
         // Always wrap the result to preserve the rule name in the hierarchy.
-        const node = new xml_cst_1.CST(result.type, expr.name, result.start, result.end, [result], result.wellFormed);
+        const node = new CST(result.type, expr.name, result.start, result.end, [result], result.wellFormed);
         // Apply validation
         const validator = ctx.grammar.validators[expr.name];
         if (validator) {
@@ -158,4 +155,3 @@ class Parser {
         return node;
     }
 }
-exports.Parser = Parser;

package/dist/cst/xml-cst.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CST = void 0;
 /**
  * Represents a node in the Concrete Syntax Tree (Parse Tree).
  * Each node corresponds to a match of a grammatical structure or rule.
  */
-class CST {
+export class CST {
     constructor(
     /**
      * The type of the grammatical structure matched.
@@ -113,4 +110,3 @@ class CST {
         return current;
     }
 }
-exports.CST = CST;