xnl-collab-core 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kongweixian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,573 @@
+'use strict';
+
+var xnlCore = require('xnl-core');
+var diff = require('diff');
+
+// src/id.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function encodeTime(timeMs) {
+  let t = Math.floor(timeMs);
+  let out = "";
+  for (let i = 0; i < 10; i++) {
+    out = ENCODING[t % 32] + out;
+    t = Math.floor(t / 32);
+  }
+  return out;
+}
+function fillRandom(bytes) {
+  const c = globalThis.crypto;
+  if (c && typeof c.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+    return;
+  }
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+}
+function encodeRandom(length) {
+  const bytes = new Uint8Array(length);
+  fillRandom(bytes);
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += ENCODING[bytes[i] & 31];
+  }
+  return out;
+}
+function ulid(nowMs = Date.now()) {
+  return encodeTime(nowMs) + encodeRandom(16);
+}
+function makeId(prefix) {
+  return `${prefix}${ulid()}`;
+}
+function assertAtMostOneRoot(nodes, context) {
+  if (nodes.length <= 1) return;
+  throw new Error(`${context}: expected 0 or 1 root node, got ${nodes.length}`);
+}
+function lastOrUndefined(nodes) {
+  return nodes.length ? nodes[nodes.length - 1] : void 0;
+}
+function mergeRootNodes3(baseNodes, leftNodes, rightNodes) {
+  const b = lastOrUndefined(baseNodes);
+  const l = lastOrUndefined(leftNodes);
+  const r = lastOrUndefined(rightNodes);
+  const bid = b ? readStableId(b) : void 0;
+  const lid = l ? readStableId(l) : void 0;
+  const rid = r ? readStableId(r) : void 0;
+  if (!b) {
+    if (!l && !r) return [];
+    if (!l) return [r];
+    if (!r) return [l];
+    if (lid && rid && lid === rid) {
+      const merged = mergeAny(void 0, l, r);
+      return merged === void 0 ? [] : [merged];
+    }
+    return [r] ;
+  }
+  if (!l && !r) return [];
+  if (!l && r) {
+    if (bid && rid && bid === rid) return [];
+    return [r];
+  }
+  if (l && !r) {
+    if (bid && lid && bid === lid) return [];
+    return [] ;
+  }
+  if (lid && rid && lid === rid) {
+    const merged = bid && bid === lid ? mergeAny(b, l, r) : mergeAny(void 0, l, r);
+    return merged === void 0 ? [] : [merged];
+  }
+  if (bid && lid && bid === lid && (!rid || bid !== rid)) {
+    return [r];
+  }
+  if (bid && rid && bid === rid && (!lid || bid !== lid)) {
+    return [l];
+  }
+  return [r] ;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && value.kind === void 0;
+}
+function isDataElement(node) {
+  return node && node.kind === "DataElement";
+}
+function isTextElement(node) {
+  return node && node.kind === "TextElement";
+}
+function cloneJson(v) {
+  return JSON.parse(JSON.stringify(v));
+}
+function readNodeId(node) {
+  if (!isDataElement(node) && !isTextElement(node)) return void 0;
+  return xnlCore.wordToString(node.id);
+}
+function readMetaId(node) {
+  if (!isDataElement(node) && !isTextElement(node)) return void 0;
+  const raw = node.metadata?.id;
+  if (typeof raw === "string") return raw;
+  if (xnlCore.isWord(raw)) return xnlCore.wordToString(raw) ?? void 0;
+  return void 0;
+}
+function readStableId(node) {
+  return readMetaId(node) ?? readNodeId(node);
+}
+function readTag(node) {
+  if (!isDataElement(node) && !isTextElement(node)) return void 0;
+  return node.tag;
+}
+function setMetaId(node, id) {
+  if (!isDataElement(node) && !isTextElement(node)) return;
+  if (!node.metadata || typeof node.metadata !== "object" || Array.isArray(node.metadata)) {
+    node.metadata = {};
+  }
+  node.metadata.id = id;
+}
+function makeMetaId(prefix) {
+  return makeId(prefix);
+}
+function ensureMetadataIds(root, prefix) {
+  const visit = (node) => {
+    if (isDataElement(node) || isTextElement(node)) {
+      const existing = readMetaId(node);
+      if (!existing) {
+        setMetaId(node, makeMetaId(prefix));
+      } else if (node.metadata?.id && typeof node.metadata.id !== "string") {
+        setMetaId(node, existing);
+      }
+      if (isDataElement(node)) {
+        if (node.body) for (const child of node.body) visit(child);
+        if (node.extend) {
+          for (const tag of node.extend.order) {
+            const child = node.extend.children[tag];
+            if (child) visit(child);
+          }
+        }
+        if (node.attributes) {
+          for (const v of Object.values(node.attributes)) visit(v);
+        }
+        for (const v of Object.values(node.metadata ?? {})) visit(v);
+      } else {
+        if (node.attributes) {
+          for (const v of Object.values(node.attributes)) visit(v);
+        }
+        for (const v of Object.values(node.metadata ?? {})) visit(v);
+      }
+      return;
+    }
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child);
+      return;
+    }
+    if (isPlainObject(node)) {
+      for (const key of Object.keys(node)) visit(node[key]);
+    }
+  };
+  if (root.nodes && Array.isArray(root.nodes)) {
+    for (const n of root.nodes) visit(n);
+  } else {
+    visit(root);
+  }
+}
+function mergePrimitive(base, left, right, key) {
+  if (left === right) return left;
+  if (left === base) return right;
+  if (right === base) return left;
+  return right ;
+}
+function normalizeEdits(edits) {
+  const sorted = edits.slice().sort((a, b) => a.start !== b.start ? a.start - b.start : a.end - b.end);
+  const out = [];
+  for (const e of sorted) {
+    const prev = out[out.length - 1];
+    if (!prev) {
+      out.push(e);
+      continue;
+    }
+    if (prev.end === e.start && prev.end === prev.start && e.start === e.end) {
+      prev.text += e.text;
+      continue;
+    }
+    if (prev.end === e.start && prev.text.length === 0 && e.text.length === 0) {
+      prev.end = e.end;
+      continue;
+    }
+    out.push(e);
+  }
+  return out;
+}
+function diffToEdits(base, other) {
+  const changes = diff.diffChars(base, other);
+  let basePos = 0;
+  const edits = [];
+  for (let i = 0; i < changes.length; i++) {
+    const c = changes[i];
+    if (c.removed) {
+      const start = basePos;
+      const end = basePos + c.value.length;
+      basePos = end;
+      let inserted = "";
+      while (i + 1 < changes.length && changes[i + 1].added) {
+        inserted += changes[i + 1].value;
+        i++;
+      }
+      edits.push({ start, end, text: inserted });
+      continue;
+    }
+    if (c.added) {
+      edits.push({ start: basePos, end: basePos, text: c.value });
+      continue;
+    }
+    basePos += c.value.length;
+  }
+  return normalizeEdits(edits);
+}
+function editsOverlap(a, b) {
+  const aIsIns = a.start === a.end;
+  const bIsIns = b.start === b.end;
+  if (aIsIns && bIsIns) {
+    return a.start === b.start;
+  }
+  if (aIsIns && !bIsIns) {
+    return b.start <= a.start && a.start <= b.end;
+  }
+  if (!aIsIns && bIsIns) {
+    return a.start <= b.start && b.start <= a.end;
+  }
+  return Math.max(a.start, b.start) < Math.min(a.end, b.end);
+}
+function hasOverlappingEdits(left, right) {
+  let i = 0;
+  let j = 0;
+  const l = left.slice().sort((a, b) => a.start - b.start);
+  const r = right.slice().sort((a, b) => a.start - b.start);
+  while (i < l.length && j < r.length) {
+    const le = l[i];
+    const re = r[j];
+    if (editsOverlap(le, re)) return true;
+    const leEnd = le.end;
+    const reEnd = re.end;
+    if (leEnd < re.start || le.end === le.start && le.start < re.start) {
+      i++;
+      continue;
+    }
+    if (reEnd < le.start || re.end === re.start && re.start < le.start) {
+      j++;
+      continue;
+    }
+    if (le.start <= re.start) i++;
+    else j++;
+  }
+  return false;
+}
+function applyEdits(base, edits) {
+  const sorted = edits.slice().sort((a, b) => a.start !== b.start ? a.start - b.start : a.end - b.end);
+  let out = "";
+  let cursor = 0;
+  for (const e of sorted) {
+    out += base.slice(cursor, e.start);
+    out += e.text;
+    cursor = e.end;
+  }
+  out += base.slice(cursor);
+  return out;
+}
+function mergeText3(base, left, right) {
+  if (left === right) return left;
+  if (left === base) return right;
+  if (right === base) return left;
+  const editsL = diffToEdits(base, left);
+  const editsR = diffToEdits(base, right);
+  if (hasOverlappingEdits(editsL, editsR)) {
+    return right ;
+  }
+  return applyEdits(base, [...editsL, ...editsR]);
+}
+function mergePlainObject(base, left, right) {
+  const out = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(base || {}), ...Object.keys(left || {}), ...Object.keys(right || {})]);
+  for (const key of keys) {
+    const b = (base || {})[key];
+    const l = (left || {})[key];
+    const r = (right || {})[key];
+    if (l === void 0 && r === void 0) continue;
+    out[key] = mergeAny(b, l, r);
+  }
+  return out;
+}
+function stableUnique(values) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    if (seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+  }
+  return out;
+}
+function mergeIdOrder(baseIds, leftIds, rightIds) {
+  const present = /* @__PURE__ */ new Set([...leftIds, ...rightIds]);
+  const nodes = Array.from(present);
+  const edges = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  for (const id of nodes) {
+    edges.set(id, /* @__PURE__ */ new Set());
+    indeg.set(id, 0);
+  }
+  const addEdge = (from, to) => {
+    if (!present.has(from) || !present.has(to)) return;
+    if (from === to) return;
+    const s = edges.get(from);
+    if (s.has(to)) return;
+    s.add(to);
+    indeg.set(to, (indeg.get(to) ?? 0) + 1);
+  };
+  const addEdgesFromOrder = (order) => {
+    for (let i = 0; i + 1 < order.length; i++) addEdge(order[i], order[i + 1]);
+  };
+  addEdgesFromOrder(leftIds);
+  addEdgesFromOrder(rightIds);
+  const basePos = /* @__PURE__ */ new Map();
+  baseIds.forEach((id, idx) => basePos.set(id, idx));
+  const leftPos = /* @__PURE__ */ new Map();
+  leftIds.forEach((id, idx) => leftPos.set(id, idx));
+  const rightPos = /* @__PURE__ */ new Map();
+  rightIds.forEach((id, idx) => rightPos.set(id, idx));
+  const rank = (id) => {
+    return [basePos.get(id) ?? 1e9, leftPos.get(id) ?? 1e9, rightPos.get(id) ?? 1e9, id];
+  };
+  const compare = (a, b) => {
+    const ra = rank(a);
+    const rb = rank(b);
+    for (let i = 0; i < ra.length; i++) {
+      if (ra[i] < rb[i]) return -1;
+      if (ra[i] > rb[i]) return 1;
+    }
+    return 0;
+  };
+  const zeros = nodes.filter((id) => (indeg.get(id) ?? 0) === 0).sort(compare);
+  const out = [];
+  while (zeros.length) {
+    const id = zeros.shift();
+    out.push(id);
+    for (const to of edges.get(id) ?? []) {
+      indeg.set(to, (indeg.get(to) ?? 0) - 1);
+      if ((indeg.get(to) ?? 0) === 0) {
+        zeros.push(to);
+      }
+    }
+    zeros.sort(compare);
+  }
+  if (out.length !== nodes.length) {
+    return stableUnique([...leftIds, ...rightIds]);
+  }
+  return out;
+}
+function mergeNodeList(base, left, right) {
+  const baseById = /* @__PURE__ */ new Map();
+  const leftById = /* @__PURE__ */ new Map();
+  const rightById = /* @__PURE__ */ new Map();
+  const baseIds = [];
+  const leftIds = [];
+  const rightIds = [];
+  const collect = (arr, ids, map) => {
+    for (const n of arr) {
+      const id = readStableId(n);
+      if (!id) continue;
+      ids.push(id);
+      if (!map.has(id)) map.set(id, n);
+    }
+  };
+  collect(base, baseIds, baseById);
+  collect(left, leftIds, leftById);
+  collect(right, rightIds, rightById);
+  const order = mergeIdOrder(baseIds, leftIds, rightIds);
+  const merged = [];
+  for (const id of order) {
+    const b = baseById.get(id);
+    const l = leftById.get(id);
+    const r = rightById.get(id);
+    const m = mergeAny(b, l, r);
+    if (m !== void 0) merged.push(m);
+  }
+  const seenAnon = /* @__PURE__ */ new Set();
+  const pushAnon = (n) => {
+    const key = JSON.stringify(n);
+    if (seenAnon.has(key)) return;
+    seenAnon.add(key);
+    merged.push(n);
+  };
+  for (const n of left) {
+    if (readStableId(n)) continue;
+    pushAnon(n);
+  }
+  for (const n of right) {
+    if (readStableId(n)) continue;
+    pushAnon(n);
+  }
+  return merged;
+}
+function mergeExtend(base, left, right) {
+  if (!base && !left && !right) return void 0;
+  const b = base ?? { order: [], children: {} };
+  const l = left ?? { order: [], children: {} };
+  const r = right ?? { order: [], children: {} };
+  const mergedChildren = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(b.children), ...Object.keys(l.children), ...Object.keys(r.children)]);
+  for (const k of keys) {
+    const bv = b.children[k];
+    const lv = l.children[k];
+    const rv = r.children[k];
+    if (lv === void 0 && rv === void 0) continue;
+    const merged = mergeAny(bv, lv, rv);
+    if (merged !== void 0) mergedChildren[k] = merged;
+  }
+  const present = new Set(Object.keys(mergedChildren));
+  const order = stableUnique([...l.order, ...r.order, ...b.order]).filter((t) => present.has(t));
+  return { order, children: mergedChildren };
+}
+function mergeTextElement(base, left, right) {
+  const tag = mergePrimitive(base.tag, left.tag, right.tag);
+  const id = mergePrimitive(base.id, left.id, right.id);
+  const metadata = mergePlainObject(base.metadata ?? {}, left.metadata ?? {}, right.metadata ?? {});
+  const attributes = mergePlainObject(base.attributes ?? {}, left.attributes ?? {}, right.attributes ?? {});
+  const baseText = base.text ?? "";
+  const leftText = left.text ?? "";
+  const rightText = right.text ?? "";
+  const text = mergeText3(baseText, leftText, rightText);
+  const baseMarker = base.textMarker ?? "";
+  const leftMarker = left.textMarker ?? "";
+  const rightMarker = right.textMarker ?? "";
+  const textMarker = mergeText3(baseMarker, leftMarker, rightMarker);
+  const out = {
+    kind: "TextElement",
+    tag,
+    id,
+    metadata,
+    attributes: Object.keys(attributes).length ? attributes : void 0,
+    text: text.length ? text : void 0,
+    textMarker: textMarker.length ? textMarker : void 0
+  };
+  const sid = readMetaId(left) ?? readMetaId(right) ?? readMetaId(base);
+  if (sid) setMetaId(out, sid);
+  return out;
+}
+function mergeDataElement(base, left, right) {
+  const tag = mergePrimitive(base.tag, left.tag, right.tag);
+  const id = mergePrimitive(base.id, left.id, right.id);
+  const metadata = mergePlainObject(base.metadata ?? {}, left.metadata ?? {}, right.metadata ?? {});
+  const attributes = mergePlainObject(base.attributes ?? {}, left.attributes ?? {}, right.attributes ?? {});
+  const body = mergeNodeList(base.body ?? [], left.body ?? [], right.body ?? []);
+  const extend = mergeExtend(base.extend, left.extend, right.extend);
+  const out = {
+    kind: "DataElement",
+    tag,
+    id,
+    metadata,
+    attributes: Object.keys(attributes).length ? attributes : void 0,
+    body: body.length ? body : void 0,
+    extend
+  };
+  const sid = readMetaId(left) ?? readMetaId(right) ?? readMetaId(base);
+  if (sid) setMetaId(out, sid);
+  return out;
+}
+function mergeAny(base, left, right, key) {
+  if (left === void 0 && right === void 0) return void 0;
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  if (left === right) return left;
+  if (base === void 0) {
+    if (isDataElement(left) && isDataElement(right)) {
+      return mergeDataElement(left, left, right);
+    }
+    if (isTextElement(left) && isTextElement(right)) {
+      return mergeTextElement(left, left, right);
+    }
+    if (Array.isArray(left) && Array.isArray(right)) {
+      return mergeNodeList([], left, right);
+    }
+    if (isPlainObject(left) && isPlainObject(right)) {
+      return mergePlainObject({}, left, right);
+    }
+    return right ;
+  }
+  if (typeof base === "string" || typeof base === "number" || typeof base === "boolean" || base === null) {
+    return mergePrimitive(base, left, right);
+  }
+  if (Array.isArray(base) && Array.isArray(left) && Array.isArray(right)) {
+    return mergeNodeList(base, left, right);
+  }
+  if (isPlainObject(base) && isPlainObject(left) && isPlainObject(right)) {
+    return mergePlainObject(base, left, right);
+  }
+  if (isTextElement(base) && isTextElement(left) && isTextElement(right)) {
+    return mergeTextElement(base, left, right);
+  }
+  if (isDataElement(base) && isDataElement(left) && isDataElement(right)) {
+    return mergeDataElement(base, left, right);
+  }
+  return mergePrimitive(base, left, right);
+}
+function mergeDocuments3(baseText, leftText, rightText) {
+  const base = xnlCore.parseXnl(baseText);
+  const left = xnlCore.parseXnl(leftText);
+  const right = xnlCore.parseXnl(rightText);
+  const mergedNodes = mergeRootNodes3(base.nodes, left.nodes, right.nodes);
+  ensureMetadataIds({ nodes: mergedNodes }, "m_");
+  const mergedText = xnlCore.XNL.stringify({ nodes: mergedNodes });
+  const canonical = xnlCore.parseXnl(mergedText);
+  assertAtMostOneRoot(canonical.nodes, "mergeDocuments3");
+  const canonicalText = xnlCore.XNL.stringify(canonical);
+  return { text: canonicalText, nodes: canonical.nodes };
+}
+function canonicalizeText(text, prefix) {
+  const parsed = xnlCore.parseXnl(text);
+  assertAtMostOneRoot(parsed.nodes, "canonicalizeText");
+  const nodes = cloneJson(parsed.nodes);
+  ensureMetadataIds({ nodes }, prefix);
+  const withIdsText = xnlCore.XNL.stringify({ nodes });
+  const canonical = xnlCore.parseXnl(withIdsText);
+  assertAtMostOneRoot(canonical.nodes, "canonicalizeText");
+  const canonicalText = xnlCore.XNL.stringify(canonical);
+  return { text: canonicalText, nodes: canonical.nodes };
+}
+function applyIntent(baseText, mutations) {
+  const base = canonicalizeText(baseText, "s_");
+  assertAtMostOneRoot(base.nodes, "applyIntent");
+  const baseRoot = base.nodes[0];
+  const baseTag = baseRoot ? readTag(baseRoot) : void 0;
+  const root = cloneJson(base.nodes);
+  const next = xnlCore.XNL.mutation.apply(root, mutations, { metadataIdMode: "identity" });
+  if (!Array.isArray(next)) {
+    throw new Error("Root must remain array");
+  }
+  assertAtMostOneRoot(next, "applyIntent");
+  if (baseTag) {
+    const nextRoot = next[0];
+    const nextTag = nextRoot ? readTag(nextRoot) : void 0;
+    if (!nextTag) {
+      throw new Error("applyIntent: root node required");
+    }
+    if (nextTag !== baseTag) {
+      throw new Error(`applyIntent: root tag locked to <${baseTag}>`);
+    }
+  }
+  ensureMetadataIds({ nodes: next }, "s_");
+  const nextText = xnlCore.XNL.stringify({ nodes: next });
+  const canonical = xnlCore.parseXnl(nextText);
+  assertAtMostOneRoot(canonical.nodes, "applyIntent");
+  const canonicalText = xnlCore.XNL.stringify(canonical);
+  return { text: canonicalText, nodes: canonical.nodes };
+}
+function mergeExample(baseText, leftText, rightText) {
+  return mergeDocuments3(baseText, leftText, rightText).text;
+}
+
+exports.applyIntent = applyIntent;
+exports.canonicalizeText = canonicalizeText;
+exports.ensureMetadataIds = ensureMetadataIds;
+exports.makeId = makeId;
+exports.mergeDocuments3 = mergeDocuments3;
+exports.mergeExample = mergeExample;
+exports.ulid = ulid;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map