@dialecte/core 0.1.7 → 0.1.9

package/dist/test/run-test-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAO/C,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,SAAS,EACT,SAAS,EACT,SAAS,EACT,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAMrD,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAKhG;AAID,wBAAgB,eAAe,CAC9B,eAAe,SAAS,eAAe,EACvC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;IAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CAAA;AACR,wBAAgB,eAAe,CAC9B,eAAe,SAAS,eAAe,EACvC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACzE,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CAAA;AAgFR;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,eAAe,SAAS,YAAY,EAChE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAKN"}
+{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"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"}

package/dist/test/run-test-cases.type.d.ts

@@ -23,4 +23,17 @@ export type ActResult = {
     assertDatabaseName: string;
     withDatabaseIds?: boolean;
 };
+export type TestRunner<GenericConfig extends AnyDialecteConfig> = {
+    withExport<GenericTestCase extends BaseXmlTestCase>(params: {
+        testCases: TestCases<GenericTestCase>;
+        act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<ActResult>;
+        dialecteConfig?: GenericConfig;
+    }): void;
+    withoutExport<GenericTestCase extends BaseXmlTestCase>(params: {
+        testCases: TestCases<GenericTestCase>;
+        act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<void>;
+        dialecteConfig?: GenericConfig;
+    }): void;
+    generic<GenericTestCase extends BaseTestCase>(testCases: Record<string, GenericTestCase>, act: (testCase: GenericTestCase) => void): void;
+};
 //# sourceMappingURL=run-test-cases.type.d.ts.map

package/dist/test/run-test-cases.type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAA;CACd,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAEhG,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAClE,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,IACpC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA"}
+{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAA;CACd,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAEhG,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAClE,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,IACpC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,UAAU,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACjE,UAAU,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC3D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;QAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;KAC9B,GAAG,IAAI,CAAA;IACR,aAAa,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC9D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACzE,cAAc,CAAC,EAAE,aAAa,CAAA;KAC9B,GAAG,IAAI,CAAA;IACR,OAAO,CAAC,eAAe,SAAS,YAAY,EAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAAA;CACP,CAAA"}

package/dist/test.js

@@ -1,83 +1,83 @@
-import { expect as o, it as d } from "vitest";
-import { x as b, D as X, i as q, o as S, e as v } from "./index-BcfPvtox.js";
-import { DIALECTE_DEV_NAMESPACE as D, standardizeRecord as T, toTreeRecord as L, toTrackedRecord as w } from "./helpers.js";
-function E(a) {
-  const e = O(a);
+import { expect as f, it as p } from "vitest";
+import { x as X, D as q, i as S, o as D, e as h } from "./index-BcfPvtox.js";
+import { DIALECTE_DEV_NAMESPACE as T, standardizeRecord as L, toTreeRecord as w, toTrackedRecord as g } from "./helpers.js";
+function v(t) {
+  const e = O(t);
   if (e.length === 0)
-    return [a];
-  const t = [];
+    return [t];
+  const a = [];
   for (const B of e)
-    t.push(a.slice(0, B));
-  return t.push(a), t;
+    a.push(t.slice(0, B));
+  return a.push(t), a;
 }
-function O(a) {
+function O(t) {
   const e = [];
-  let t = 0, B = 0, A = null;
-  for (let _ = 0; _ < a.length; _++) {
-    const r = a[_];
+  let a = 0, B = 0, A = null;
+  for (let r = 0; r < t.length; r++) {
+    const _ = t[r];
     if (A) {
-      r === A && (A = null);
+      _ === A && (A = null);
       continue;
     }
-    if (r === '"' || r === "'") {
-      A = r;
+    if (_ === '"' || _ === "'") {
+      A = _;
       continue;
     }
-    if (r === "[") {
-      t++;
+    if (_ === "[") {
+      a++;
       continue;
     }
-    if (r === "]") {
-      t--;
+    if (_ === "]") {
+      a--;
       continue;
     }
-    if (r === "(") {
+    if (_ === "(") {
       B++;
       continue;
     }
-    if (r === ")") {
+    if (_ === ")") {
       B--;
       continue;
     }
-    if (!(t > 0 || B > 0) && r === "/") {
-      if (_ === 0) {
-        a[_ + 1] === "/" && _++;
+    if (!(a > 0 || B > 0) && _ === "/") {
+      if (r === 0) {
+        t[r + 1] === "/" && r++;
         continue;
       }
-      if (e.length === 0 && _ === 1 && a[0] === "/")
+      if (e.length === 0 && r === 1 && t[0] === "/")
         continue;
-      e.push(_), a[_ + 1] === "/" && _++;
+      e.push(r), t[r + 1] === "/" && r++;
     }
   }
   return e;
 }
-function g(a) {
-  const { namespaces: e } = a, t = R(e);
+function M(t) {
+  const { namespaces: e } = t, a = R(e);
   return {
     assertExpectedElementQueries(B) {
-      M({ ...B, nsResolver: t });
+      k({ ...B, nsResolver: a });
     },
     assertUnexpectedElementQueries(B) {
-      k({ ...B, nsResolver: t });
+      V({ ...B, nsResolver: a });
     }
   };
 }
-function M(a) {
-  const { xmlDocument: e, queries: t, nsResolver: B } = a;
-  for (const A of t)
-    V({ xmlDocument: e, xpath: A, nsResolver: B });
+function k(t) {
+  const { xmlDocument: e, queries: a, nsResolver: B } = t;
+  for (const A of a)
+    F({ xmlDocument: e, xpath: A, nsResolver: B });
 }
-function R(a) {
-  return (e) => e ? a[e]?.uri ?? null : null;
+function R(t) {
+  return (e) => e ? t[e]?.uri ?? null : null;
 }
-function k(a) {
-  const { xmlDocument: e, queries: t, nsResolver: B } = a;
-  for (const A of t)
-    F({ xmlDocument: e, xpath: A, nsResolver: B });
+function V(t) {
+  const { xmlDocument: e, queries: a, nsResolver: B } = t;
+  for (const A of a)
+    N({ xmlDocument: e, xpath: A, nsResolver: B });
 }
-function V(a) {
-  const { xmlDocument: e, xpath: t, nsResolver: B } = a, A = E(t);
-  let _ = null, r = 0;
+function F(t) {
+  const { xmlDocument: e, xpath: a, nsResolver: B } = t, A = v(a);
+  let r = null, _ = 0;
   for (let C = 0; C < A.length; C++) {
     const s = A[C], c = e.evaluate(
       s,
@@ -87,80 +87,80 @@ function V(a) {
       null
     ).singleNodeValue;
     if (c) {
-      _ = c, r = C + 1;
+      r = c, _ = C + 1;
       continue;
     }
-    const u = C === 0 ? A[0] : t.slice(A[C - 1].length), i = r === 0 ? `[No parent matched — failed from document root]
+    const i = C === 0 ? A[0] : a.slice(A[C - 1].length), u = _ === 0 ? `[No parent matched — failed from document root]
   Document:
-${l({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${r}/${A.length}]:
-${_ ? l({ xml: _.outerHTML }) : "(none)"}`;
-    o(
+${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${A.length}]:
+${r ? x({ xml: r.outerHTML }) : "(none)"}`;
+    f(
       c,
       `Element not found in XML.
-  Failed at step ${C + 1}/${A.length}: ${u.trim()}
-  Full XPath: ${t}
-  ${i}`
+  Failed at step ${C + 1}/${A.length}: ${i.trim()}
+  Full XPath: ${a}
+  ${u}`
     ).toBeTruthy();
     return;
   }
 }
-function l(a) {
-  const { xml: e } = a;
+function x(t) {
+  const { xml: e } = t;
   try {
-    return b(e, { indentation: "  ", collapseContent: !0 });
+    return X(e, { indentation: "  ", collapseContent: !0 });
   } catch {
     return e;
   }
 }
-function F(a) {
-  const { xmlDocument: e, xpath: t, nsResolver: B } = a, A = E(t);
+function N(t) {
+  const { xmlDocument: e, xpath: a, nsResolver: B } = t, A = v(a);
   if (A.length > 1) {
     let C = null;
     for (let s = 0; s < A.length - 1; s++) {
-      const n = A[s], u = e.evaluate(
+      const n = A[s], i = e.evaluate(
         n,
         e,
         B ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).singleNodeValue, i = s === 0 ? A[0] : t.slice(A[s - 1].length), m = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
-${C ? l({ xml: C.outerHTML }) : "(none)"}`;
-      o(
-        u,
+      ).singleNodeValue, u = s === 0 ? A[0] : a.slice(A[s - 1].length), o = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
+${C ? x({ xml: C.outerHTML }) : "(none)"}`;
+      f(
+        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 ${s + 1}/${A.length}: ${i.trim()}
-  Full XPath: ${t}
-  ${m}`
-      ).toBeTruthy(), C = u;
+  Missing at step ${s + 1}/${A.length}: ${u.trim()}
+  Full XPath: ${a}
+  ${o}`
+      ).toBeTruthy(), C = i;
     }
   }
-  const r = e.evaluate(
-    t,
+  const _ = e.evaluate(
+    a,
     e,
     B ?? null,
     XPathResult.FIRST_ORDERED_NODE_TYPE,
     null
   ).singleNodeValue;
-  o(
-    r,
+  f(
+    _,
     `Element should NOT exist in XML but was found.
-  XPath: ${t}
+  XPath: ${a}
   Found:
-${r ? l({ xml: r.outerHTML }) : "(none)"}`
+${_ ? x({ xml: _.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
-const p = {
+const d = {
   default: {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: D,
+  dev: T,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, te = `xmlns="${p.default.uri}"`, ae = `xmlns:${p.dev.prefix}="${p.dev.uri}"`, Be = `xmlns:${p.ext.prefix}="${p.ext.uri}"`, N = [
+}, Ae = `xmlns="${d.default.uri}"`, re = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, Ce = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, U = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const p = {
   "CC_2",
   "CC_3",
   "Root"
-], U = {
+], y = {
   A: ["AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -224,7 +224,7 @@ const p = {
   CC_2: ["CCC_1", "CCC_2", "CCC_3"],
   CC_3: ["CCC_1", "CCC_2", "CCC_3"],
   Root: ["A", "B", "C"]
-}, y = {
+}, I = {
   A: ["Root"],
   AAAA_1: ["AAA_1", "AAA_2", "AAA_3"],
   AAAA_2: ["AAA_1", "AAA_2", "AAA_3"],
@@ -256,7 +256,7 @@ const p = {
   CC_2: ["C"],
   CC_3: ["C"],
   Root: []
-}, I = {
+}, $ = {
   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 p = {
     "CC_2",
     "CC_3"
   ]
-}, $ = {
+}, P = {
   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 p = {
   CC_2: ["C", "Root"],
   CC_3: ["C", "Root"],
   Root: []
-}, P = "Root", Q = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], z = {
+}, Q = "Root", z = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], G = {
   A: {
     aA: "",
     bA: "",
@@ -506,7 +506,7 @@ const p = {
     "ext:root": "",
     root: ""
   }
-}, G = {
+}, H = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -1508,7 +1508,7 @@ const p = {
       }
     ]
   }
-}, H = {
+}, j = {
   supportedFileExtensions: [".xml"]
 }, Y = {
   tables: {
@@ -1517,40 +1517,40 @@ const p = {
       schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
     }
   }
-}, x = {
-  rootElementName: P,
-  singletonElements: Q,
-  elements: N,
-  namespaces: p,
-  attributes: z,
-  children: U,
-  parents: y,
-  descendants: I,
-  ancestors: $,
+}, l = {
+  rootElementName: Q,
+  singletonElements: z,
+  elements: U,
+  namespaces: d,
+  attributes: G,
+  children: y,
+  parents: I,
+  descendants: $,
+  ancestors: P,
   database: Y,
-  io: H,
-  definition: G,
+  io: j,
+  definition: H,
   hooks: {}
 };
-async function h(a) {
-  const { xmlString: e, dialecteConfig: t = x } = a, B = `test-${crypto.randomUUID()}.xml`, A = new File([e], B, { type: "text/xml" }), r = (await q({
+async function m(t) {
+  const { xmlString: e, dialecteConfig: a = l } = t, B = `test-${crypto.randomUUID()}.xml`, A = new File([e], B, { type: "text/xml" }), _ = (await S({
     files: [A],
-    dialecteConfig: t,
+    dialecteConfig: a,
     useCustomRecordsIds: !0
-  }))[0], C = S({
-    config: t,
-    storage: { type: "local", databaseName: r }
+  }))[0], C = D({
+    config: a,
+    storage: { type: "local", databaseName: _ }
   });
   return {
     document: C,
-    databaseName: r,
+    databaseName: _,
     exportCurrentTest: async (c) => {
-      const { extension: u = t.io.supportedFileExtensions[0], withDatabaseIds: i = !1 } = c || {};
-      return v({
-        dialecteConfig: t,
-        databaseName: r,
-        extension: u,
-        withDatabaseIds: i
+      const { extension: i = a.io.supportedFileExtensions[0], withDatabaseIds: u = !1 } = c || {};
+      return h({
+        dialecteConfig: a,
+        databaseName: _,
+        extension: i,
+        withDatabaseIds: u
       });
     },
     cleanup: async () => {
@@ -1558,99 +1558,118 @@ async function h(a) {
     }
   };
 }
-function Ae(a) {
-  const { databaseName: e, dialecteConfig: t } = a;
+function _e(t) {
+  const { databaseName: e, dialecteConfig: a } = t;
   return {
-    store: new X(e, t),
+    store: new q(e, a),
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const j = crypto.randomUUID.bind(crypto);
-function Z() {
-  let a = 0;
+const E = crypto.randomUUID.bind(crypto);
+function b() {
+  let t = 0;
   return function() {
-    return `${a++}`;
+    return `${t++}`;
   };
 }
-function Ce(a) {
+function W(t) {
   const {
     testCases: e,
-    act: t,
-    dialecteConfig: B = x
-  } = a, { assertExpectedElementQueries: A, assertUnexpectedElementQueries: _ } = g({
+    act: a,
+    dialecteConfig: B = l
+  } = t, { assertExpectedElementQueries: A, assertUnexpectedElementQueries: r } = M({
     namespaces: B.namespaces
   });
-  for (const [r, C] of Object.entries(e))
-    (C.only ? d.only : d)(r, async () => {
-      crypto.randomUUID = j;
-      const n = await h({
-        xmlString: C.sourceXml,
-        dialecteConfig: B
-      }), c = C.targetXml ? await h({ xmlString: C.targetXml, dialecteConfig: B }) : void 0;
+  for (const [_, C] of Object.entries(e))
+    (C.only ? p.only : p)(_, async () => {
+      crypto.randomUUID = E;
+      const n = await m({ xmlString: C.sourceXml, dialecteConfig: B }), c = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: B }) : void 0;
       try {
-        crypto.randomUUID = Z();
-        const i = (await t({
+        crypto.randomUUID = b();
+        const { assertDatabaseName: i, withDatabaseIds: u } = await a({
           testCase: C,
           source: { document: n.document, databaseName: n.databaseName },
           target: c ? { document: c.document, databaseName: c.databaseName } : void 0
-        }))?.assertDatabaseName;
-        if (C.expectedQueries?.length || C.unexpectedQueries?.length) {
-          if (!i)
-            throw new Error(
-              `Test "${r}": assertDatabaseName is required when expectedQueries or unexpectedQueries are defined`
-            );
-          const { xmlDocument: f } = await v({
-            dialecteConfig: B,
-            databaseName: i,
-            extension: B.io.supportedFileExtensions[0],
-            withDatabaseIds: !0
-          });
-          C.expectedQueries?.length && A({ xmlDocument: f, queries: C.expectedQueries }), C.unexpectedQueries?.length && _({ xmlDocument: f, queries: C.unexpectedQueries });
-        }
+        }), { xmlDocument: o } = await h({
+          dialecteConfig: B,
+          databaseName: i,
+          extension: B.io.supportedFileExtensions[0],
+          withDatabaseIds: u ?? !0
+        });
+        C.expectedQueries?.length && A({ xmlDocument: o, queries: C.expectedQueries }), C.unexpectedQueries?.length && r({ xmlDocument: o, queries: C.unexpectedQueries });
       } finally {
         await n.cleanup(), await c?.cleanup();
       }
     });
 }
-function re(a, e) {
-  for (const [t, B] of Object.entries(a))
-    (B.only ? d.only : d)(t, () => e(B));
+function Z(t) {
+  const {
+    testCases: e,
+    act: a,
+    dialecteConfig: B = l
+  } = t;
+  for (const [A, r] of Object.entries(e))
+    (r.only ? p.only : p)(A, async () => {
+      crypto.randomUUID = E;
+      const C = await m({ xmlString: r.sourceXml, dialecteConfig: B }), s = r.targetXml ? await m({ xmlString: r.targetXml, dialecteConfig: B }) : void 0;
+      try {
+        crypto.randomUUID = b(), await a({
+          testCase: r,
+          source: { document: C.document, databaseName: C.databaseName },
+          target: s ? { document: s.document, databaseName: s.databaseName } : void 0
+        });
+      } finally {
+        await C.cleanup(), await s?.cleanup();
+      }
+    });
+}
+function J(t, e) {
+  for (const [a, B] of Object.entries(t))
+    (B.only ? p.only : p)(a, () => e(B));
+}
+const se = K(l);
+function K(t) {
+  return {
+    withExport: (e) => W({ dialecteConfig: t, ...e }),
+    withoutExport: (e) => Z({ dialecteConfig: t, ...e }),
+    generic: J
+  };
 }
-function J(a) {
-  function e(t) {
-    const { record: B, type: A = "raw" } = t, _ = T({ record: B, dialecteConfig: a });
+function ee(t) {
+  function e(a) {
+    const { record: B, type: A = "raw" } = a, r = L({ record: B, dialecteConfig: t });
     switch (A) {
       case "raw":
-        return _;
+        return r;
       case "tracked":
-        return w({ record: _ });
+        return g({ record: r });
       case "tree":
-        return L({ record: _ });
+        return w({ record: r });
       default:
         throw new Error(`Unsupported record type: ${A}`);
     }
   }
   return e;
 }
-const _e = J(x);
+const ce = ee(l);
 export {
   Y as DATABASE_CONFIG,
-  p as DIALECTE_NAMESPACES,
-  H as IO_CONFIG,
-  x as TEST_DIALECTE_CONFIG,
-  te as XMLNS_DEFAULT_NAMESPACE,
-  ae as XMLNS_DEV_NAMESPACE,
-  Be as XMLNS_EXT_NAMESPACE,
-  M as assertExpectedElementQueries,
-  k as assertUnexpectedElementQueries,
-  Z as createMockRandomUUID,
-  Ae as createTestContext,
-  h as createTestDialecte,
-  _e as createTestRecord,
-  J as createTestRecordFactory,
-  g as createXmlAssertions,
-  re as runTestCases,
-  Ce as runXmlTestCases,
-  E as splitXpathIntoSteps
+  d as DIALECTE_NAMESPACES,
+  j as IO_CONFIG,
+  l as TEST_DIALECTE_CONFIG,
+  Ae as XMLNS_DEFAULT_NAMESPACE,
+  re as XMLNS_DEV_NAMESPACE,
+  Ce as XMLNS_EXT_NAMESPACE,
+  k as assertExpectedElementQueries,
+  V as assertUnexpectedElementQueries,
+  b as createMockRandomUUID,
+  _e as createTestContext,
+  m as createTestDialecte,
+  ce as createTestRecord,
+  ee as createTestRecordFactory,
+  K as createTestRunner,
+  M as createXmlAssertions,
+  se as runTestCases,
+  v as splitXpathIntoSteps
 };

package/package.json

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