flarp 1.0.0

package/src/xml/Tree.js

@@ -0,0 +1,279 @@
+/**
+ * Tree - XML tree management
+ * 
+ * Handles parsing, serialization, and tree operations.
+ * Built to support per-node reactivity and collaborative editing.
+ * 
+ * @example
+ * const tree = new Tree();
+ * tree.parse('<User><n>Alice</n></User>');
+ * 
+ * const name = tree.at('User.Name');
+ * name.subscribe(v => console.log(v));
+ * 
+ * tree.add('User', '<Email>alice@example.com</Email>');
+ */
+
+import Signal from '../core/Signal.js';
+import State from '../core/State.js';
+import Node, { AttrNode } from './Node.js';
+import * as Path from './Path.js';
+
+export default class Tree {
+  #root;
+  #parser = new DOMParser();
+  #serializer = new XMLSerializer();
+  #state = new State();
+  #changeSignal = new Signal(0);
+
+  constructor(container = null) {
+    this.#root = container || document.createElement('div');
+  }
+
+  /**
+   * Get the state machine
+   */
+  get state() {
+    return this.#state;
+  }
+
+  /**
+   * Get the root container element
+   */
+  get root() {
+    return this.#root;
+  }
+
+  /**
+   * Get a reactive node at a path
+   * @param {string} path
+   * @returns {Node|AttrNode|null}
+   */
+  at(path) {
+    const resolved = Path.resolve(this.#root, path);
+    if (!resolved) return null;
+
+    if (resolved.attr) {
+      return AttrNode.wrap(resolved.element, resolved.attr);
+    }
+    return Node.wrap(resolved.element);
+  }
+
+  /**
+   * Get all matching nodes at a path
+   * @param {string} path
+   * @returns {Node[]}
+   */
+  query(path) {
+    return Path.resolveAll(this.#root, path).map(el => Node.wrap(el));
+  }
+
+  /**
+   * Set value at a path (creates if needed)
+   * @param {string} path
+   * @param {string} value
+   */
+  set(path, value) {
+    let node = this.at(path);
+    
+    if (!node) {
+      this.#ensurePath(path);
+      node = this.at(path);
+    }
+    
+    if (node) {
+      node.value = value;
+      this.#notifyChange();
+    }
+  }
+
+  /**
+   * Add XML fragment as child
+   * @param {string} parentPath
+   * @param {string} xml
+   * @returns {Node|Node[]} Added node(s)
+   */
+  add(parentPath, xml) {
+    const resolved = Path.resolve(this.#root, parentPath);
+    if (!resolved) {
+      throw new Error(`Parent path not found: ${parentPath}`);
+    }
+
+    const doc = this.#parser.parseFromString(
+      `<root>${xml}</root>`,
+      'application/xml'
+    );
+
+    const error = doc.querySelector('parsererror');
+    if (error) {
+      throw new Error(`Invalid XML: ${error.textContent}`);
+    }
+
+    const added = [];
+    for (const child of Array.from(doc.documentElement.children)) {
+      const imported = document.importNode(child, true);
+      
+      // Ensure UUID/rev
+      if (!imported.hasAttribute('uuid')) {
+        imported.setAttribute('uuid', crypto.randomUUID?.() || Math.random().toString(36).slice(2));
+      }
+      if (!imported.hasAttribute('rev')) {
+        imported.setAttribute('rev', '1');
+      }
+      
+      resolved.element.appendChild(imported);
+      added.push(Node.wrap(imported));
+    }
+
+    this.#notifyChange();
+    return added.length === 1 ? added[0] : added;
+  }
+
+  /**
+   * Remove node at path
+   * @param {string} path
+   * @returns {boolean}
+   */
+  remove(path) {
+    const resolved = Path.resolve(this.#root, path);
+    if (!resolved) return false;
+
+    Node.unwrap(resolved.element);
+    resolved.element.remove();
+    this.#notifyChange();
+    return true;
+  }
+
+  /**
+   * Parse and set XML content
+   * @param {string} xml
+   */
+  parse(xml) {
+    const doc = this.#parser.parseFromString(
+      `<root>${xml}</root>`,
+      'application/xml'
+    );
+
+    const error = doc.querySelector('parsererror');
+    if (error) {
+      throw new Error(`Parse error: ${error.textContent}`);
+    }
+
+    this.#root.innerHTML = '';
+    for (const child of Array.from(doc.documentElement.children)) {
+      this.#root.appendChild(document.importNode(child, true));
+    }
+
+    this.#notifyChange();
+  }
+
+  /**
+   * Serialize entire tree to XML string
+   * @returns {string}
+   */
+  serialize() {
+    return this.#root.innerHTML;
+  }
+
+  /**
+   * Serialize single node at path
+   * @param {string} path
+   * @returns {string|null}
+   */
+  serializeAt(path) {
+    const node = this.at(path);
+    return node?.serialize?.() || null;
+  }
+
+  /**
+   * Get raw XML (alias for serialize)
+   */
+  get xml() {
+    return this.serialize();
+  }
+
+  /**
+   * Set raw XML (alias for parse)
+   */
+  set xml(value) {
+    this.parse(value);
+  }
+
+  /**
+   * Subscribe to any change in the tree
+   * @param {Function} fn - Callback receiving XML string
+   * @returns {Function} Unsubscribe
+   */
+  onChange(fn) {
+    // Subscribe without autorun, only fire on actual changes
+    return this.#changeSignal.subscribe(() => fn(this.serialize()), false);
+  }
+
+  /**
+   * Subscribe with immediate callback
+   * @param {Function} fn - Callback receiving XML string
+   * @returns {Function} Unsubscribe
+   */
+  watch(fn) {
+    // Subscribe with autorun for immediate + changes
+    return this.#changeSignal.subscribe(() => fn(this.serialize()), true);
+  }
+
+  /**
+   * Check if tree has content
+   * @returns {boolean}
+   */
+  get empty() {
+    return !this.#root.firstElementChild;
+  }
+
+  #ensurePath(path) {
+    const { segments, attr } = Path.parse(path);
+    let current = this.#root;
+
+    for (const { tag, index } of segments) {
+      const tagLower = tag.toLowerCase();
+      const matches = Array.from(current.children).filter(
+        el => el.tagName.toLowerCase() === tagLower
+      );
+
+      if (matches.length === 0) {
+        const newEl = document.createElement(tag);
+        newEl.setAttribute('uuid', crypto.randomUUID?.() || Math.random().toString(36).slice(2));
+        newEl.setAttribute('rev', '1');
+        current.appendChild(newEl);
+        current = newEl;
+      } else if (index !== null && !matches[index]) {
+        throw new Error(`Index out of bounds: ${tag}[${index}]`);
+      } else {
+        current = index !== null ? matches[index] : matches[0];
+      }
+    }
+
+    return current;
+  }
+
+  #notifyChange() {
+    this.#changeSignal.value++;
+  }
+
+  /**
+   * Dispose tree and all node wrappers
+   */
+  dispose() {
+    // Dispose all wrapped nodes
+    const walk = (el) => {
+      Node.unwrap(el);
+      for (const child of el.children) {
+        walk(child);
+      }
+    };
+    
+    for (const child of this.#root.children) {
+      walk(child);
+    }
+
+    this.#state.dispose();
+    this.#changeSignal.dispose();
+  }
+}

package/src/xml/index.js

@@ -0,0 +1,7 @@
+/**
+ * XML - XML tree management utilities
+ */
+
+export { default as Node, AttrNode } from './Node.js';
+export { default as Tree } from './Tree.js';
+export * as Path from './Path.js';