@dialecte/core 0.2.9 → 0.2.11

package/dist/test.js

@@ -1,141 +1,141 @@
 import { expect as m, it as p } from "vitest";
-import { x as D, D as w, P as L } from "./index-1D8DELEq.js";
-import { D as T, s as g, o as O, n as M } from "./merge-extensions-dj7By9gG.js";
-function v(B) {
-  const e = k(B);
+import { x as L, D as T, P as w } from "./index-BdP_eGXx.js";
+import { D as g, s as O, o as M, n as k } from "./merge-extensions-dj7By9gG.js";
+function E(a) {
+  const e = R(a);
   if (e.length === 0)
-    return [B];
+    return [a];
   const t = [];
   for (const r of e)
-    t.push(B.slice(0, r));
-  return t.push(B), t;
+    t.push(a.slice(0, r));
+  return t.push(a), t;
 }
-function k(B) {
+function R(a) {
   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);
+  let t = 0, r = 0, B = null;
+  for (let A = 0; A < a.length; A++) {
+    const _ = a[A];
+    if (B) {
+      _ === B && (B = null);
       continue;
     }
-    if (A === '"' || A === "'") {
-      a = A;
+    if (_ === '"' || _ === "'") {
+      B = _;
       continue;
     }
-    if (A === "[") {
+    if (_ === "[") {
       t++;
       continue;
     }
-    if (A === "]") {
+    if (_ === "]") {
       t--;
       continue;
     }
-    if (A === "(") {
+    if (_ === "(") {
       r++;
       continue;
     }
-    if (A === ")") {
+    if (_ === ")") {
       r--;
       continue;
     }
-    if (!(t > 0 || r > 0) && A === "/") {
-      if (C === 0) {
-        B[C + 1] === "/" && C++;
+    if (!(t > 0 || r > 0) && _ === "/") {
+      if (A === 0) {
+        a[A + 1] === "/" && A++;
         continue;
       }
-      if (e.length === 0 && C === 1 && B[0] === "/")
+      if (e.length === 0 && A === 1 && a[0] === "/")
         continue;
-      e.push(C), B[C + 1] === "/" && C++;
+      e.push(A), a[A + 1] === "/" && A++;
     }
   }
   return e;
 }
-function R(B) {
-  const { namespaces: e } = B, t = F(e);
+function V(a) {
+  const { namespaces: e } = a, t = y(e);
   return {
     assertExpectedElementQueries(r) {
-      V({ ...r, nsResolver: t });
+      F({ ...r, nsResolver: t });
     },
     assertUnexpectedElementQueries(r) {
-      y({ ...r, nsResolver: t });
+      I({ ...r, nsResolver: t });
     }
   };
 }
-function V(B) {
-  const { xmlDocument: e, queries: t, nsResolver: r } = B;
-  for (const a of t)
-    I({ xmlDocument: e, xpath: a, nsResolver: r });
+function F(a) {
+  const { xmlDocument: e, queries: t, nsResolver: r } = a;
+  for (const B of t)
+    U({ xmlDocument: e, xpath: B, nsResolver: r });
 }
-function F(B) {
-  return (e) => e ? B[e]?.uri ?? null : null;
+function y(a) {
+  return (e) => e ? a[e]?.uri ?? null : null;
 }
-function y(B) {
-  const { xmlDocument: e, queries: t, nsResolver: r } = B;
-  for (const a of t)
-    U({ xmlDocument: e, xpath: a, nsResolver: r });
+function I(a) {
+  const { xmlDocument: e, queries: t, nsResolver: r } = a;
+  for (const B of t)
+    N({ xmlDocument: e, xpath: B, nsResolver: r });
 }
-function I(B) {
-  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = v(t);
-  let C = null, A = 0;
-  for (let s = 0; s < a.length; s++) {
-    const _ = a[s], c = e.evaluate(
-      _,
+function U(a) {
+  const { xmlDocument: e, xpath: t, nsResolver: r } = a, B = E(t);
+  let A = null, _ = 0;
+  for (let C = 0; C < B.length; C++) {
+    const s = B[C], n = e.evaluate(
+      s,
       e,
       r ?? null,
       XPathResult.FIRST_ORDERED_NODE_TYPE,
       null
     ).singleNodeValue;
-    if (c) {
-      C = c, A = s + 1;
+    if (n) {
+      A = n, _ = C + 1;
       continue;
     }
-    const n = s === 0 ? a[0] : t.slice(a[s - 1].length), u = A === 0 ? `[No parent matched — failed from document root]
+    const i = C === 0 ? B[0] : t.slice(B[C - 1].length), u = _ === 0 ? `[No parent matched — failed from document root]
   Document:
-${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${A}/${a.length}]:
-${C ? x({ xml: C.outerHTML }) : "(none)"}`;
+${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${B.length}]:
+${A ? x({ xml: A.outerHTML }) : "(none)"}`;
     m(
-      c,
+      n,
       `Element not found in XML.
-  Failed at step ${s + 1}/${a.length}: ${n.trim()}
+  Failed at step ${C + 1}/${B.length}: ${i.trim()}
   Full XPath: ${t}
   ${u}`
     ).toBeTruthy();
     return;
   }
 }
-function x(B) {
-  const { xml: e } = B;
+function x(a) {
+  const { xml: e } = a;
   try {
-    return D(e, { indentation: "  ", collapseContent: !0 });
+    return L(e, { indentation: "  ", collapseContent: !0 });
   } catch {
     return e;
   }
 }
-function U(B) {
-  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = v(t);
-  if (a.length > 1) {
-    let s = null;
-    for (let _ = 0; _ < a.length - 1; _++) {
-      const i = a[_], n = e.evaluate(
-        i,
+function N(a) {
+  const { xmlDocument: e, xpath: t, nsResolver: r } = a, B = E(t);
+  if (B.length > 1) {
+    let C = null;
+    for (let s = 0; s < B.length - 1; s++) {
+      const c = B[s], i = e.evaluate(
+        c,
         e,
         r ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).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)"}`;
+      ).singleNodeValue, u = s === 0 ? B[0] : t.slice(B[s - 1].length), o = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
+${C ? x({ xml: C.outerHTML }) : "(none)"}`;
       m(
-        n,
+        i,
         `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 ${_ + 1}/${a.length}: ${u.trim()}
+  Missing at step ${s + 1}/${B.length}: ${u.trim()}
   Full XPath: ${t}
   ${o}`
-      ).toBeTruthy(), s = n;
+      ).toBeTruthy(), C = i;
     }
   }
-  const A = e.evaluate(
+  const _ = e.evaluate(
     t,
     e,
     r ?? null,
@@ -143,11 +143,11 @@ ${s ? x({ xml: s.outerHTML }) : "(none)"}`;
     null
   ).singleNodeValue;
   m(
-    A,
+    _,
     `Element should NOT exist in XML but was found.
   XPath: ${t}
   Found:
-${A ? x({ xml: A.outerHTML }) : "(none)"}`
+${_ ? x({ xml: _.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
 const d = {
@@ -155,12 +155,12 @@ const d = {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: T,
+  dev: g,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, Ce = `xmlns="${d.default.uri}"`, _e = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, se = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, N = [
+}, _e = `xmlns="${d.default.uri}"`, se = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, ce = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, $ = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const d = {
   "CC_2",
   "CC_3",
   "Root"
-], $ = {
+], P = {
   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 = {
+}, Q = {
   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: []
-}, Q = {
+}, j = {
   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"
   ]
-}, j = {
+}, z = {
   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"],
@@ -351,7 +351,7 @@ const d = {
   CC_2: ["C", "Root"],
   CC_3: ["C", "Root"],
   Root: []
-}, z = "Root", G = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], H = {
+}, G = "Root", H = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], Y = {
   A: {
     aA: "",
     bA: "",
@@ -440,8 +440,6 @@ const d = {
   BB_1: {
     aBB_1: "",
     bBB_1: "",
-    dBB_1: "",
-    eBB_1: "",
     "ext:cBB_1": ""
   },
   BB_2: {
@@ -508,7 +506,7 @@ const d = {
     "ext:root": "",
     root: ""
   }
-}, Y = {
+}, K = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -840,7 +838,7 @@ const d = {
         selector: [{ steps: [{ kind: "name", value: "BB_1" }] }],
         fields: [
           { target: { kind: "attribute", value: "aBB_1", isAttribute: !0 } },
-          { target: { kind: "attribute", value: "dBB_1", isAttribute: !0 } }
+          { target: { kind: "attribute", value: "bBB_1", isAttribute: !0 } }
         ]
       },
       {
@@ -932,7 +930,7 @@ const d = {
       sequence: ["aBBB_1", "bBBB_1", "ext:cBBB_1"],
       details: {
         aBBB_1: { required: !0, facets: { whiteSpace: "preserve" } },
-        bBBB_1: { facets: { whiteSpace: "preserve" } },
+        bBBB_1: { default: "false", facets: { whiteSpace: "preserve" } },
         "ext:cBBB_1": {
           namespace: { prefix: "ext", uri: "http://dialecte.dev/XML/DEV-EXT" },
           facets: { whiteSpace: "preserve" }
@@ -1020,18 +1018,16 @@ const d = {
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
     parents: ["B"],
     attributes: {
-      sequence: ["aBB_1", "bBB_1", "dBB_1", "eBB_1", "ext:cBB_1"],
+      sequence: ["aBB_1", "bBB_1", "ext:cBB_1"],
       details: {
         aBB_1: { required: !0, facets: { whiteSpace: "preserve" } },
-        bBB_1: { facets: { whiteSpace: "preserve" } },
-        dBB_1: { default: "", facets: { whiteSpace: "preserve" } },
-        eBB_1: { default: "", facets: { whiteSpace: "preserve" } },
+        bBB_1: { default: "", facets: { whiteSpace: "preserve" } },
         "ext:cBB_1": {
           namespace: { prefix: "ext", uri: "http://dialecte.dev/XML/DEV-EXT" },
           facets: { whiteSpace: "preserve" }
         }
       },
-      identityFields: ["aBB_1", "dBB_1"]
+      identityFields: ["aBB_1", "bBB_1"]
     },
     children: {
       sequence: ["BBB_1", "BBB_2", "BBB_3"],
@@ -1080,7 +1076,7 @@ const d = {
       sequence: ["aBB_2", "bBB_2", "ext:cBB_2"],
       details: {
         aBB_2: { required: !0, facets: { whiteSpace: "preserve" } },
-        bBB_2: { facets: { whiteSpace: "preserve" } },
+        bBB_2: { default: "", facets: { whiteSpace: "preserve" } },
         "ext:cBB_2": {
           namespace: { prefix: "ext", uri: "http://dialecte.dev/XML/DEV-EXT" },
           facets: { whiteSpace: "preserve" }
@@ -1492,7 +1488,7 @@ const d = {
               selector: [{ steps: [{ kind: "name", value: "BB_1" }] }],
               fields: [
                 { target: { kind: "attribute", value: "aBB_1", isAttribute: !0 } },
-                { target: { kind: "attribute", value: "dBB_1", isAttribute: !0 } }
+                { target: { kind: "attribute", value: "bBB_1", isAttribute: !0 } }
               ]
             },
             {
@@ -1533,9 +1529,9 @@ const d = {
       }
     ]
   }
-}, K = {
-  supportedFileExtensions: [".xml"]
 }, W = {
+  supportedFileExtensions: [".xml"]
+}, Z = {
   recordSchema: {
     primaryKey: "id",
     indexes: ["tagName", "parent.id", "parent.tagName"],
@@ -1550,172 +1546,179 @@ const d = {
     }
   }
 }, l = {
-  rootElementName: z,
-  singletonElements: G,
-  elements: N,
+  rootElementName: G,
+  singletonElements: H,
+  elements: $,
   namespaces: d,
-  attributes: H,
-  children: $,
-  parents: P,
-  descendants: Q,
-  ancestors: j,
-  database: W,
-  io: K,
-  definition: Y
+  attributes: Y,
+  children: P,
+  parents: Q,
+  descendants: j,
+  ancestors: z,
+  database: Z,
+  io: W,
+  definition: K
 };
-async function E(B) {
+async function b(a) {
   const {
     sourceXml: e,
     targetXml: t,
     dialecteConfig: r = l,
-    hooks: a
-  } = B, C = `test-${crypto.randomUUID()}`, A = await new L({
+    extensions: B,
+    hooks: A
+  } = a, _ = `test-${crypto.randomUUID()}`, C = await new w({
     configs: { default: r },
     defaultConfigKey: "default",
     storage: { type: "local" },
-    hooks: a
-  }).open(C), [s] = await A.import(
+    extensions: B,
+    hooks: A
+  }).open(_), [s] = await C.import(
     [new File([e], "source.xml", { type: "text/xml" })],
     { useCustomRecordsIds: !0 }
-  ), _ = {
+  ), c = {
     documentId: s.documentId,
-    document: A.openDocument(s.documentId)
+    document: C.openDocument(s.documentId)
   };
-  let i;
+  let n;
   if (t) {
-    const [c] = await A.import(
+    const [i] = await C.import(
       [new File([t], "target.xml", { type: "text/xml" })],
       { useCustomRecordsIds: !0 }
     );
-    i = {
-      documentId: c.documentId,
-      document: A.openDocument(c.documentId)
+    n = {
+      documentId: i.documentId,
+      document: C.openDocument(i.documentId)
     };
   }
-  return { project: A, source: _, target: i };
+  return { project: C, source: c, target: n };
 }
-async function ce(B) {
-  const { databaseName: e, dialecteConfig: t, documentId: r } = B, a = new w(e, {
+async function ie(a) {
+  const { databaseName: e, dialecteConfig: t, documentId: r } = a, B = new T(e, {
     recordSchema: t.database.recordSchema
   });
-  return await a.open(), {
+  return await B.open(), {
     dialecteConfig: t,
-    store: a,
+    store: B,
     documentId: r,
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const b = crypto.randomUUID.bind(crypto);
-function X() {
-  let B = 0;
+const X = crypto.randomUUID.bind(crypto);
+function q() {
+  let a = 0;
   return function() {
-    return `${B++}`;
+    return `${a++}`;
   };
 }
-function Z(B) {
+function J(a) {
   const {
     testCases: e,
     act: t,
-    hooks: r,
-    dialecteConfig: a = l
-  } = B, { assertExpectedElementQueries: C, assertUnexpectedElementQueries: A } = R({
-    namespaces: a.namespaces
+    extensions: r,
+    hooks: B,
+    dialecteConfig: A = l
+  } = a, { assertExpectedElementQueries: _, assertUnexpectedElementQueries: C } = V({
+    namespaces: A.namespaces
   });
-  for (const [s, _] of Object.entries(e))
-    (_.only ? p.only : p)(s, async () => {
-      crypto.randomUUID = b;
-      const { project: c, source: n, target: u } = await E({
-        sourceXml: _.sourceXml,
-        targetXml: _.targetXml,
-        dialecteConfig: a,
-        hooks: r
+  for (const [s, c] of Object.entries(e))
+    (c.only ? p.only : p)(s, async () => {
+      crypto.randomUUID = X;
+      const { project: i, source: u, target: o } = await b({
+        sourceXml: c.sourceXml,
+        targetXml: c.targetXml,
+        dialecteConfig: A,
+        extensions: r,
+        hooks: B
       });
       try {
-        crypto.randomUUID = X();
-        const o = await t({
-          testCase: _,
-          project: c,
-          source: n.document,
-          target: u?.document
-        }), q = o?.assertOn ?? "source", S = o?.withDatabaseIds ?? !0, f = q === "target" ? u?.documentId : n.documentId;
-        if (!f) throw new Error("documentId required for export");
-        const { xmlDocument: h } = await c.export(f, { withDatabaseIds: S });
-        _.expectedQueries?.length && C({ xmlDocument: h, queries: _.expectedQueries }), _.unexpectedQueries?.length && A({ xmlDocument: h, queries: _.unexpectedQueries });
+        crypto.randomUUID = q();
+        const f = await t({
+          testCase: c,
+          project: i,
+          source: u.document,
+          target: o?.document
+        }), S = f?.assertOn ?? "source", D = f?.withDatabaseIds ?? !0, h = S === "target" ? o?.documentId : u.documentId;
+        if (!h) throw new Error("documentId required for export");
+        const { xmlDocument: v } = await i.export(h, { withDatabaseIds: D });
+        c.expectedQueries?.length && _({ xmlDocument: v, queries: c.expectedQueries }), c.unexpectedQueries?.length && C({ xmlDocument: v, queries: c.unexpectedQueries });
       } finally {
-        await c.destroy();
+        await i.destroy();
       }
     });
 }
-function J(B) {
+function ee(a) {
   const {
     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 = b;
-      const { project: _, source: i, target: c } = await E({
-        sourceXml: A.sourceXml,
-        targetXml: A.targetXml,
-        dialecteConfig: a,
-        hooks: r
+    extensions: r,
+    hooks: B,
+    dialecteConfig: A = l
+  } = a;
+  for (const [_, C] of Object.entries(e))
+    (C.only ? p.only : p)(_, async () => {
+      crypto.randomUUID = X;
+      const { project: c, source: n, target: i } = await b({
+        sourceXml: C.sourceXml,
+        targetXml: C.targetXml,
+        dialecteConfig: A,
+        extensions: r,
+        hooks: B
       });
       try {
-        crypto.randomUUID = X(), await t({ testCase: A, project: _, source: i.document, target: c?.document });
+        crypto.randomUUID = q(), await t({ testCase: C, project: c, source: n.document, target: i?.document });
       } finally {
-        await _.destroy();
+        await c.destroy();
       }
     });
 }
-function ee(B, e) {
-  for (const [t, r] of Object.entries(B))
+function te(a, e) {
+  for (const [t, r] of Object.entries(a))
     (r.only ? p.only : p)(t, () => e(r));
 }
-const ie = te(l);
-function te(B, e) {
+const ne = ae({ dialecteConfig: l });
+function ae(a) {
+  const { dialecteConfig: e, hooks: t, extensions: r } = a;
   return {
-    withExport: (t) => Z({ dialecteConfig: B, hooks: e, ...t }),
-    withoutExport: (t) => J({ dialecteConfig: B, hooks: e, ...t }),
-    generic: ee
+    withExport: (B) => J({ dialecteConfig: e, extensions: r, hooks: t, ...B }),
+    withoutExport: (B) => ee({ dialecteConfig: e, extensions: r, hooks: t, ...B }),
+    generic: te
   };
 }
-function Be(B) {
+function Be(a) {
   function e(t) {
-    const { record: r, type: a = "raw" } = t, C = g({ record: r, dialecteConfig: B });
-    switch (a) {
+    const { record: r, type: B = "raw" } = t, A = O({ record: r, dialecteConfig: a });
+    switch (B) {
       case "raw":
-        return C;
+        return A;
       case "tracked":
-        return M({ record: C });
+        return k({ record: A });
       case "tree":
-        return O({ record: C });
+        return M({ record: A });
       default:
-        throw new Error(`Unsupported record type: ${a}`);
+        throw new Error(`Unsupported record type: ${B}`);
     }
   }
   return e;
 }
-const ne = Be(l);
+const ue = Be(l);
 export {
-  W as DATABASE_CONFIG,
+  Z as DATABASE_CONFIG,
   d as DIALECTE_NAMESPACES,
-  K as IO_CONFIG,
+  W 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,
-  X as createMockRandomUUID,
-  ce as createTestContext,
-  E as createTestProject,
-  ne as createTestRecord,
+  _e as XMLNS_DEFAULT_NAMESPACE,
+  se as XMLNS_DEV_NAMESPACE,
+  ce as XMLNS_EXT_NAMESPACE,
+  F as assertExpectedElementQueries,
+  I as assertUnexpectedElementQueries,
+  q as createMockRandomUUID,
+  ie as createTestContext,
+  b as createTestProject,
+  ue as createTestRecord,
   Be as createTestRecordFactory,
-  te as createTestRunner,
-  R as createXmlAssertions,
-  ie as runTestCases,
-  v as splitXpathIntoSteps
+  ae as createTestRunner,
+  V as createXmlAssertions,
+  ne as runTestCases,
+  E as splitXpathIntoSteps
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/core",
-	"version": "0.2.9",
+	"version": "0.2.11",
 	"description": "Dialecte - Core functionality for Dialecte SDK",
 	"license": "MIT",
 	"repository": {