@dialecte/core 0.1.21 → 0.2.0

package/dist/test.js

@@ -1,153 +1,153 @@
-import { expect as f, it as p } from "vitest";
-import { x as q, D as S, i as D, o as T, e as v } from "./index-Djo88Z-U.js";
-import { D as L, s as w, o as g, n as O } from "./merge-extensions-D-JNgVJ8.js";
-function E(a) {
-  const t = M(a);
-  if (t.length === 0)
-    return [a];
-  const e = [];
-  for (const A of t)
-    e.push(a.slice(0, A));
-  return e.push(a), e;
-}
-function M(a) {
+import { expect as m, it as p } from "vitest";
+import { x as D, b as L, d as T } from "./project-Bw05Eh5i.js";
+import { D as w, s as g, o as O, n as M } from "./merge-extensions-DQKNUthU.js";
+function h(B) {
+  const e = k(B);
+  if (e.length === 0)
+    return [B];
   const t = [];
-  let e = 0, A = 0, B = null;
-  for (let _ = 0; _ < a.length; _++) {
-    const C = a[_];
-    if (B) {
-      C === B && (B = null);
+  for (const r of e)
+    t.push(B.slice(0, r));
+  return t.push(B), t;
+}
+function k(B) {
+  const e = [];
+  let t = 0, r = 0, a = null;
+  for (let C = 0; C < B.length; C++) {
+    const A = B[C];
+    if (a) {
+      A === a && (a = null);
       continue;
     }
-    if (C === '"' || C === "'") {
-      B = C;
+    if (A === '"' || A === "'") {
+      a = A;
       continue;
     }
-    if (C === "[") {
-      e++;
+    if (A === "[") {
+      t++;
       continue;
     }
-    if (C === "]") {
-      e--;
+    if (A === "]") {
+      t--;
       continue;
     }
-    if (C === "(") {
-      A++;
+    if (A === "(") {
+      r++;
       continue;
     }
-    if (C === ")") {
-      A--;
+    if (A === ")") {
+      r--;
       continue;
     }
-    if (!(e > 0 || A > 0) && C === "/") {
-      if (_ === 0) {
-        a[_ + 1] === "/" && _++;
+    if (!(t > 0 || r > 0) && A === "/") {
+      if (C === 0) {
+        B[C + 1] === "/" && C++;
         continue;
       }
-      if (t.length === 0 && _ === 1 && a[0] === "/")
+      if (e.length === 0 && C === 1 && B[0] === "/")
         continue;
-      t.push(_), a[_ + 1] === "/" && _++;
+      e.push(C), B[C + 1] === "/" && C++;
     }
   }
-  return t;
+  return e;
 }
-function k(a) {
-  const { namespaces: t } = a, e = V(t);
+function R(B) {
+  const { namespaces: e } = B, t = F(e);
   return {
-    assertExpectedElementQueries(A) {
-      R({ ...A, nsResolver: e });
+    assertExpectedElementQueries(r) {
+      V({ ...r, nsResolver: t });
     },
-    assertUnexpectedElementQueries(A) {
-      F({ ...A, nsResolver: e });
+    assertUnexpectedElementQueries(r) {
+      y({ ...r, nsResolver: t });
     }
   };
 }
-function R(a) {
-  const { xmlDocument: t, queries: e, nsResolver: A } = a;
-  for (const B of e)
-    y({ xmlDocument: t, xpath: B, nsResolver: A });
+function V(B) {
+  const { xmlDocument: e, queries: t, nsResolver: r } = B;
+  for (const a of t)
+    I({ xmlDocument: e, xpath: a, nsResolver: r });
 }
-function V(a) {
-  return (t) => t ? a[t]?.uri ?? null : null;
+function F(B) {
+  return (e) => e ? B[e]?.uri ?? null : null;
 }
-function F(a) {
-  const { xmlDocument: t, queries: e, nsResolver: A } = a;
-  for (const B of e)
-    N({ xmlDocument: t, xpath: B, nsResolver: A });
+function y(B) {
+  const { xmlDocument: e, queries: t, nsResolver: r } = B;
+  for (const a of t)
+    U({ xmlDocument: e, xpath: a, nsResolver: r });
 }
-function y(a) {
-  const { xmlDocument: t, xpath: e, nsResolver: A } = a, B = E(e);
-  let _ = null, C = 0;
-  for (let s = 0; s < B.length; s++) {
-    const r = B[s], n = t.evaluate(
-      r,
-      t,
-      A ?? null,
+function I(B) {
+  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = h(t);
+  let C = null, A = 0;
+  for (let s = 0; s < a.length; s++) {
+    const _ = a[s], c = e.evaluate(
+      _,
+      e,
+      r ?? null,
       XPathResult.FIRST_ORDERED_NODE_TYPE,
       null
     ).singleNodeValue;
-    if (n) {
-      _ = n, C = s + 1;
+    if (c) {
+      C = c, A = s + 1;
       continue;
     }
-    const i = s === 0 ? B[0] : e.slice(B[s - 1].length), u = C === 0 ? `[No parent matched — failed from document root]
+    const n = s === 0 ? a[0] : t.slice(a[s - 1].length), u = A === 0 ? `[No parent matched — failed from document root]
   Document:
-${x({ xml: new XMLSerializer().serializeToString(t) })}` : `[Last match at step ${C}/${B.length}]:
-${_ ? x({ xml: _.outerHTML }) : "(none)"}`;
-    f(
-      n,
+${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${A}/${a.length}]:
+${C ? x({ xml: C.outerHTML }) : "(none)"}`;
+    m(
+      c,
       `Element not found in XML.
-  Failed at step ${s + 1}/${B.length}: ${i.trim()}
-  Full XPath: ${e}
+  Failed at step ${s + 1}/${a.length}: ${n.trim()}
+  Full XPath: ${t}
   ${u}`
     ).toBeTruthy();
     return;
   }
 }
-function x(a) {
-  const { xml: t } = a;
+function x(B) {
+  const { xml: e } = B;
   try {
-    return q(t, { indentation: "  ", collapseContent: !0 });
+    return D(e, { indentation: "  ", collapseContent: !0 });
   } catch {
-    return t;
+    return e;
   }
 }
-function N(a) {
-  const { xmlDocument: t, xpath: e, nsResolver: A } = a, B = E(e);
-  if (B.length > 1) {
+function U(B) {
+  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = h(t);
+  if (a.length > 1) {
     let s = null;
-    for (let r = 0; r < B.length - 1; r++) {
-      const c = B[r], i = t.evaluate(
-        c,
-        t,
-        A ?? null,
+    for (let _ = 0; _ < a.length - 1; _++) {
+      const i = a[_], n = e.evaluate(
+        i,
+        e,
+        r ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).singleNodeValue, u = r === 0 ? B[0] : e.slice(B[r - 1].length), l = r === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${r}]:
+      ).singleNodeValue, u = _ === 0 ? a[0] : t.slice(a[_ - 1].length), o = _ === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${_}]:
 ${s ? x({ xml: s.outerHTML }) : "(none)"}`;
-      f(
-        i,
+      m(
+        n,
         `Absent assertion is unreliable: ancestor step does not exist.
   The query passes but for the wrong reason — an ancestor is missing, not the target element.
-  Missing at step ${r + 1}/${B.length}: ${u.trim()}
-  Full XPath: ${e}
-  ${l}`
-      ).toBeTruthy(), s = i;
+  Missing at step ${_ + 1}/${a.length}: ${u.trim()}
+  Full XPath: ${t}
+  ${o}`
+      ).toBeTruthy(), s = n;
     }
   }
-  const C = t.evaluate(
-    e,
+  const A = e.evaluate(
     t,
-    A ?? null,
+    e,
+    r ?? null,
     XPathResult.FIRST_ORDERED_NODE_TYPE,
     null
   ).singleNodeValue;
-  f(
-    C,
+  m(
+    A,
     `Element should NOT exist in XML but was found.
-  XPath: ${e}
+  XPath: ${t}
   Found:
-${C ? x({ xml: C.outerHTML }) : "(none)"}`
+${A ? x({ xml: A.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
 const d = {
@@ -155,12 +155,12 @@ const d = {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: L,
+  dev: w,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, re = `xmlns="${d.default.uri}"`, Ce = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, _e = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, U = [
+}, Ce = `xmlns="${d.default.uri}"`, _e = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, se = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, N = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const d = {
   "CC_2",
   "CC_3",
   "Root"
-], I = {
+], $ = {
   A: ["AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -224,7 +224,7 @@ const d = {
   CC_2: ["CCC_1", "CCC_2", "CCC_3"],
   CC_3: ["CCC_1", "CCC_2", "CCC_3"],
   Root: ["A", "B", "C"]
-}, $ = {
+}, P = {
   A: ["Root"],
   AAAA_1: ["AAA_1", "AAA_2", "AAA_3"],
   AAAA_2: ["AAA_1", "AAA_2", "AAA_3"],
@@ -256,7 +256,7 @@ const d = {
   CC_2: ["C"],
   CC_3: ["C"],
   Root: []
-}, P = {
+}, Q = {
   A: ["AAAA_1", "AAAA_2", "AAAA_3", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -319,7 +319,7 @@ const d = {
     "CC_2",
     "CC_3"
   ]
-}, Q = {
+}, j = {
   A: ["Root"],
   AAAA_1: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
   AAAA_2: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
@@ -508,7 +508,7 @@ const d = {
     "ext:root": "",
     root: ""
   }
-}, j = {
+}, Y = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -1533,182 +1533,183 @@ const d = {
       }
     ]
   }
-}, Y = {
+}, K = {
   supportedFileExtensions: [".xml"]
 }, W = {
+  recordSchema: {
+    primaryKey: "id",
+    indexes: ["tagName", "parent.id", "parent.tagName"],
+    compoundIndexes: [["id", "tagName"]],
+    arrayIndexes: ["children.id", "children.tagName"]
+  },
+  /** @deprecated - kept for old io/ pipeline until Phase 5 removes it */
   tables: {
     xmlElements: {
       name: "xmlElements",
       schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
     }
   }
-}, o = {
+}, l = {
   rootElementName: z,
   singletonElements: G,
-  elements: U,
+  elements: N,
   namespaces: d,
   attributes: H,
-  children: I,
-  parents: $,
-  descendants: P,
-  ancestors: Q,
+  children: $,
+  parents: P,
+  descendants: Q,
+  ancestors: j,
   database: W,
-  io: Y,
-  definition: j
+  io: K,
+  definition: Y
 };
-async function m(a) {
+async function v(B) {
   const {
-    xmlString: t,
-    dialecteConfig: e = o,
-    hooks: A
-  } = a, B = `test-${crypto.randomUUID()}.xml`, _ = new File([t], B, { type: "text/xml" }), s = (await D({
-    files: [_],
-    dialecteConfig: e,
-    useCustomRecordsIds: !0
-  }))[0], r = T({
-    config: e,
-    storage: { type: "local", databaseName: s },
-    hooks: A
-  });
-  return {
-    document: r,
-    databaseName: s,
-    exportCurrentTest: async (i) => {
-      const { extension: u = e.io.supportedFileExtensions[0], withDatabaseIds: l = !1 } = i || {};
-      return v({
-        dialecteConfig: e,
-        databaseName: s,
-        extension: u,
-        withDatabaseIds: l
-      });
-    },
-    cleanup: async () => {
-      r.destroy();
-    }
+    sourceXml: e,
+    targetXml: t,
+    dialecteConfig: r = l,
+    hooks: a
+  } = B, C = `test-${crypto.randomUUID()}`, A = await T.open({
+    name: C,
+    configs: { default: r },
+    defaultConfigKey: "default",
+    storage: { type: "local" },
+    hooks: a
+  }), s = await A.import(
+    new File([e], "source.xml", { type: "text/xml" }),
+    { useCustomRecordsIds: !0 }
+  ), _ = {
+    documentId: s.documentId,
+    document: A.openDocument(s.documentId)
   };
+  let i;
+  if (t) {
+    const c = await A.import(
+      new File([t], "target.xml", { type: "text/xml" }),
+      { useCustomRecordsIds: !0 }
+    );
+    i = {
+      documentId: c.documentId,
+      document: A.openDocument(c.documentId)
+    };
+  }
+  return { project: A, source: _, target: i };
 }
-function se(a) {
-  const { databaseName: t, dialecteConfig: e } = a;
-  return {
-    store: new S(t, e),
+async function ce(B) {
+  const { databaseName: e, dialecteConfig: t, documentId: r } = B, a = new L(e, {
+    recordSchema: t.database.recordSchema
+  });
+  return await a.open(), {
+    dialecteConfig: t,
+    store: a,
+    documentId: r,
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const b = crypto.randomUUID.bind(crypto);
-function X() {
-  let a = 0;
+const E = crypto.randomUUID.bind(crypto);
+function b() {
+  let B = 0;
   return function() {
-    return `${a++}`;
+    return `${B++}`;
   };
 }
-function Z(a) {
+function Z(B) {
   const {
-    testCases: t,
-    act: e,
-    hooks: A,
-    dialecteConfig: B = o
-  } = a, { assertExpectedElementQueries: _, assertUnexpectedElementQueries: C } = k({
-    namespaces: B.namespaces
+    testCases: e,
+    act: t,
+    hooks: r,
+    dialecteConfig: a = l
+  } = B, { assertExpectedElementQueries: C, assertUnexpectedElementQueries: A } = R({
+    namespaces: a.namespaces
   });
-  for (const [s, r] of Object.entries(t))
-    (r.only ? p.only : p)(s, async () => {
-      crypto.randomUUID = b;
-      const n = await m({
-        xmlString: r.sourceXml,
-        dialecteConfig: B,
-        hooks: A
-      }), i = r.targetXml ? await m({ xmlString: r.targetXml, dialecteConfig: B, hooks: A }) : void 0;
+  for (const [s, _] of Object.entries(e))
+    (_.only ? p.only : p)(s, async () => {
+      crypto.randomUUID = E;
+      const { project: c, source: n, target: u } = await v({
+        sourceXml: _.sourceXml,
+        targetXml: _.targetXml,
+        dialecteConfig: a,
+        hooks: r
+      });
       try {
-        crypto.randomUUID = X();
-        const { assertDatabaseName: u, withDatabaseIds: l } = await e({
-          testCase: r,
-          source: { document: n.document, databaseName: n.databaseName },
-          target: i ? { document: i.document, databaseName: i.databaseName } : void 0
-        }), { xmlDocument: h } = await v({
-          dialecteConfig: B,
-          databaseName: u,
-          extension: B.io.supportedFileExtensions[0],
-          withDatabaseIds: l ?? !0
-        });
-        r.expectedQueries?.length && _({ xmlDocument: h, queries: r.expectedQueries }), r.unexpectedQueries?.length && C({ xmlDocument: h, queries: r.unexpectedQueries });
+        crypto.randomUUID = b();
+        const o = await t({ testCase: _, source: n.document, target: u?.document }), X = o?.assertOn ?? "source", q = o?.withDatabaseIds ?? !0, S = X === "target" ? u.documentId : n.documentId, { xmlDocument: f } = await c.export(S, { withDatabaseIds: q });
+        _.expectedQueries?.length && C({ xmlDocument: f, queries: _.expectedQueries }), _.unexpectedQueries?.length && A({ xmlDocument: f, queries: _.unexpectedQueries });
       } finally {
-        await n.cleanup(), await i?.cleanup();
+        await c.destroy();
       }
     });
 }
-function J(a) {
+function J(B) {
   const {
-    testCases: t,
-    act: e,
-    hooks: A,
-    dialecteConfig: B = o
-  } = a;
-  for (const [_, C] of Object.entries(t))
-    (C.only ? p.only : p)(_, async () => {
-      crypto.randomUUID = b;
-      const r = await m({
-        xmlString: C.sourceXml,
-        dialecteConfig: B,
-        hooks: A
-      }), c = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: B, hooks: A }) : void 0;
+    testCases: e,
+    act: t,
+    hooks: r,
+    dialecteConfig: a = l
+  } = B;
+  for (const [C, A] of Object.entries(e))
+    (A.only ? p.only : p)(C, async () => {
+      crypto.randomUUID = E;
+      const { project: _, source: i, target: c } = await v({
+        sourceXml: A.sourceXml,
+        targetXml: A.targetXml,
+        dialecteConfig: a,
+        hooks: r
+      });
       try {
-        crypto.randomUUID = X(), await e({
-          testCase: C,
-          source: { document: r.document, databaseName: r.databaseName },
-          target: c ? { document: c.document, databaseName: c.databaseName } : void 0
-        });
+        crypto.randomUUID = b(), await t({ testCase: A, source: i.document, target: c?.document });
       } finally {
-        await r.cleanup(), await c?.cleanup();
+        await _.destroy();
       }
     });
 }
-function K(a, t) {
-  for (const [e, A] of Object.entries(a))
-    (A.only ? p.only : p)(e, () => t(A));
+function ee(B, e) {
+  for (const [t, r] of Object.entries(B))
+    (r.only ? p.only : p)(t, () => e(r));
 }
-const ie = ee(o);
-function ee(a, t) {
+const ie = te(l);
+function te(B, e) {
   return {
-    withExport: (e) => Z({ dialecteConfig: a, hooks: t, ...e }),
-    withoutExport: (e) => J({ dialecteConfig: a, hooks: t, ...e }),
-    generic: K
+    withExport: (t) => Z({ dialecteConfig: B, hooks: e, ...t }),
+    withoutExport: (t) => J({ dialecteConfig: B, hooks: e, ...t }),
+    generic: ee
   };
 }
-function te(a) {
-  function t(e) {
-    const { record: A, type: B = "raw" } = e, _ = w({ record: A, dialecteConfig: a });
-    switch (B) {
+function Be(B) {
+  function e(t) {
+    const { record: r, type: a = "raw" } = t, C = g({ record: r, dialecteConfig: B });
+    switch (a) {
       case "raw":
-        return _;
+        return C;
       case "tracked":
-        return O({ record: _ });
+        return M({ record: C });
       case "tree":
-        return g({ record: _ });
+        return O({ record: C });
       default:
-        throw new Error(`Unsupported record type: ${B}`);
+        throw new Error(`Unsupported record type: ${a}`);
     }
   }
-  return t;
+  return e;
 }
-const ce = te(o);
+const ne = Be(l);
 export {
   W as DATABASE_CONFIG,
   d as DIALECTE_NAMESPACES,
-  Y as IO_CONFIG,
-  o as TEST_DIALECTE_CONFIG,
-  re as XMLNS_DEFAULT_NAMESPACE,
-  Ce as XMLNS_DEV_NAMESPACE,
-  _e as XMLNS_EXT_NAMESPACE,
-  R as assertExpectedElementQueries,
-  F as assertUnexpectedElementQueries,
-  X as createMockRandomUUID,
-  se as createTestContext,
-  m as createTestDialecte,
-  ce as createTestRecord,
-  te as createTestRecordFactory,
-  ee as createTestRunner,
-  k as createXmlAssertions,
+  K as IO_CONFIG,
+  l as TEST_DIALECTE_CONFIG,
+  Ce as XMLNS_DEFAULT_NAMESPACE,
+  _e as XMLNS_DEV_NAMESPACE,
+  se as XMLNS_EXT_NAMESPACE,
+  V as assertExpectedElementQueries,
+  y as assertUnexpectedElementQueries,
+  b as createMockRandomUUID,
+  ce as createTestContext,
+  v as createTestProject,
+  ne as createTestRecord,
+  Be as createTestRecordFactory,
+  te as createTestRunner,
+  R as createXmlAssertions,
   ie as runTestCases,
-  E as splitXpathIntoSteps
+  h as splitXpathIntoSteps
 };

package/dist/types/dialecte-config.d.ts

@@ -3,9 +3,11 @@ import { ImportOptions, ExportOptions, IOHooks } from './io';
 import { Operation } from './operations';
 import { Namespace, RawRecord, TreeRecord } from './records';
 import { CloneMapping, Query } from '../document';
+import { RecordSchema } from '../store';
 export type RawDialecteConfig<GenericElementNames extends readonly string[], GenericRootElement extends GenericElementNames[number], GenericAttributes extends Record<string, any>, GenericChildren extends Record<string, readonly string[]>, GenericParents extends Record<string, readonly string[]>, GenericDescendants extends Record<string, readonly string[]>, GenericAncestors extends Record<string, readonly string[]>> = {
     rootElementName: GenericRootElement;
     singletonElements?: readonly GenericElementNames[number][];
+    transparentElements?: readonly GenericElementNames[number][];
     namespaces: Record<'default', Namespace> & Record<string, Namespace>;
     elements: GenericElementNames;
     attributes: GenericAttributes;
@@ -80,7 +82,13 @@ export type TransactionHooks<GenericConfig extends AnyDialecteConfig> = {
     }) => Promise<Operation<GenericConfig>[]>;
 };
 export type DatabaseConfig = Readonly<{
-    tables: {
+    /** Backend-agnostic index schema for per-file record tables */
+    recordSchema: RecordSchema;
+    /**
+     * @deprecated Legacy table config. Removed in Project-driven rewrite (Phase 5).
+     * Only kept for backward compat with old io/ pipeline until it's replaced.
+     */
+    tables?: {
         xmlElements: {
             name: string;
             schema: string;