@dialecte/core 0.2.1 → 0.2.3

package/dist/standardizing-FTZoR5RH.js

@@ -0,0 +1,144 @@
+import { i as h } from "./index-DWV6tSGF.js";
+const C = "db-id", O = {
+  uri: "http://dialecte.dev/XML/DEV",
+  prefix: "dev"
+}, j = `${O.prefix}:${C}`, R = [
+  "id",
+  "tagName",
+  "namespace",
+  "attributes",
+  "children",
+  "parent",
+  "value"
+], E = [...R, "status"], S = [...E, "tree"];
+function d(e, t) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  const a = Object.keys(e);
+  return t.every((n) => n in e) && a.every((n) => t.includes(n)) && a.length === t.length;
+}
+function y(e) {
+  return Array.isArray(e);
+}
+function F(e) {
+  return d(e, R);
+}
+function K(e) {
+  return d(e, E);
+}
+function V(e) {
+  return d(e, S);
+}
+function Y(e, t) {
+  return e.tagName === t;
+}
+function w(e, t) {
+  return e.tagName === t;
+}
+function B(e, t) {
+  return e.tagName === t;
+}
+function L(e, t) {
+  return t.elements.includes(e);
+}
+function P(e, t) {
+  return e.attributes.some((a) => a.name === t);
+}
+function I(e) {
+  return {
+    id: e.id,
+    tagName: e.tagName,
+    namespace: e.namespace,
+    attributes: e.attributes,
+    value: e.value,
+    parent: e.parent,
+    children: e.children
+  };
+}
+function x(e) {
+  const { record: t, status: a } = e, n = a ?? ("status" in t ? t.status : "unchanged");
+  return {
+    ...I(t),
+    status: n
+  };
+}
+function $(e) {
+  const { record: t, status: a, tree: n } = e, i = n ?? ("tree" in t ? t.tree : []);
+  return {
+    ...x({ record: t, status: a }),
+    tree: i
+  };
+}
+function M(e) {
+  const { dialecteConfig: t, tagName: a, attributes: n } = e;
+  return y(n) ? n : Object.entries(n).map(
+    ([i, s]) => ({
+      name: i,
+      value: s,
+      namespace: t.definition[a]?.attributes.details[i]?.namespace || void 0
+    })
+  );
+}
+function q(e) {
+  return h(e, {
+    detail: "The record or ref is undefined"
+  }), {
+    id: e.id,
+    tagName: e.tagName
+  };
+}
+function Q(e) {
+  const { dialecteConfig: t, hooks: a, record: n } = e, { id: i, tagName: s, attributes: l, namespace: b, value: A } = n, T = i ?? crypto.randomUUID(), o = l ? M({ tagName: s, attributes: l, dialecteConfig: t }) : [], f = {
+    id: T,
+    tagName: s,
+    attributes: o,
+    namespace: b ?? {
+      prefix: "prefixNeededForNotSupportedNamespace",
+      uri: "uriNeededForNotSupportedNamespace"
+    },
+    value: A ?? "",
+    parent: n.parent ?? null,
+    children: n.children ?? []
+  };
+  if (!t.elements.includes(s)) return f;
+  const m = t.definition[s].attributes.sequence, c = t.definition[s].attributes.details, g = m.flatMap((r) => {
+    const D = c[r].required, N = c[r]?.namespace || void 0, p = o.find((_) => _.name === r)?.value ?? (D ? c[r]?.default ?? "" : c[r]?.default);
+    return p === void 0 ? [] : [
+      {
+        name: r,
+        value: p,
+        namespace: N
+      }
+    ];
+  }), v = o.filter(
+    (r) => "namespace" in r && r.namespace != null && !m.includes(r.name)
+  );
+  let u = {
+    ...f,
+    namespace: t.definition[s].namespace,
+    attributes: [...g, ...v]
+  };
+  return a?.afterStandardizedRecord && (u = a.afterStandardizedRecord({
+    record: u
+  })), u;
+}
+export {
+  j as C,
+  O as D,
+  C as a,
+  w as b,
+  L as c,
+  y as d,
+  B as e,
+  F as f,
+  Y as g,
+  K as h,
+  P as i,
+  V as j,
+  I as k,
+  q as l,
+  x as m,
+  $ as n,
+  Q as s,
+  M as t
+};

package/dist/test/create-test-dialecte.d.ts

@@ -3,14 +3,14 @@ import { Project } from '../project';
 import { Document, Context } from '../document';
 import { AnyDialecteConfig, TransactionHooks } from '../types';
 type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
-export type TestFile<GenericConfig extends AnyDialecteConfig> = {
+export type TestDocument<GenericConfig extends AnyDialecteConfig> = {
     documentId: string;
     document: Document<GenericConfig>;
 };
 export type TestProjectResult<GenericConfig extends AnyDialecteConfig> = {
     project: Project<GenericConfig>;
-    source: TestFile<GenericConfig>;
-    target?: TestFile<GenericConfig>;
+    source: TestDocument<GenericConfig>;
+    target?: TestDocument<GenericConfig>;
 };
 /**
  * Spin up a Project with source (and optionally target) file imported.

package/dist/test/create-test-dialecte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD,MAAM,MAAM,QAAQ,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAC/D,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACxE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CAChC,CAAA;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CACvC,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CA6C5C;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAalC"}
+{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD,MAAM,MAAM,YAAY,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACnE,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACxE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;IACnC,MAAM,CAAC,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;CACpC,CAAA;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CACvC,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CA4C5C;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAalC"}

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":"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"}
+{"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.js

@@ -1,7 +1,7 @@
 import { expect as m, it as p } from "vitest";
-import { x as D, b as L, d as T } from "./project-ChrJXVyu.js";
-import { D as w, s as g, o as O, n as M } from "./merge-extensions-DQKNUthU.js";
-function h(B) {
+import { x as w, b as D, d as L } from "./project-q_8UeLBc.js";
+import { D as T, s as g, n as O, m as M } from "./standardizing-FTZoR5RH.js";
+function v(B) {
   const e = k(B);
   if (e.length === 0)
     return [B];
@@ -76,7 +76,7 @@ function y(B) {
     U({ xmlDocument: e, xpath: a, nsResolver: r });
 }
 function I(B) {
-  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = h(t);
+  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(
@@ -107,13 +107,13 @@ ${C ? x({ xml: C.outerHTML }) : "(none)"}`;
 function x(B) {
   const { xml: e } = B;
   try {
-    return D(e, { indentation: "  ", collapseContent: !0 });
+    return w(e, { indentation: "  ", collapseContent: !0 });
   } catch {
     return e;
   }
 }
 function U(B) {
-  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = h(t);
+  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = v(t);
   if (a.length > 1) {
     let s = null;
     for (let _ = 0; _ < a.length - 1; _++) {
@@ -155,7 +155,7 @@ const d = {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: w,
+  dev: T,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
@@ -1563,19 +1563,18 @@ const d = {
   io: K,
   definition: Y
 };
-async function v(B) {
+async function E(B) {
   const {
     sourceXml: e,
     targetXml: t,
     dialecteConfig: r = l,
     hooks: a
-  } = B, C = `test-${crypto.randomUUID()}`, A = await T.open({
-    name: C,
+  } = B, C = `test-${crypto.randomUUID()}`, A = await new L({
     configs: { default: r },
     defaultConfigKey: "default",
     storage: { type: "local" },
     hooks: a
-  }), s = await A.import(
+  }).open(C), s = await A.import(
     new File([e], "source.xml", { type: "text/xml" }),
     { useCustomRecordsIds: !0 }
   ), _ = {
@@ -1596,7 +1595,7 @@ async function v(B) {
   return { project: A, source: _, target: i };
 }
 async function ce(B) {
-  const { databaseName: e, dialecteConfig: t, documentId: r } = B, a = new L(e, {
+  const { databaseName: e, dialecteConfig: t, documentId: r } = B, a = new D(e, {
     recordSchema: t.database.recordSchema
   });
   return await a.open(), {
@@ -1607,8 +1606,8 @@ async function ce(B) {
     stagedOperations: []
   };
 }
-const E = crypto.randomUUID.bind(crypto);
-function b() {
+const b = crypto.randomUUID.bind(crypto);
+function X() {
   let B = 0;
   return function() {
     return `${B++}`;
@@ -1625,17 +1624,19 @@ function Z(B) {
   });
   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({
+      crypto.randomUUID = b;
+      const { project: c, source: n, target: u } = await E({
         sourceXml: _.sourceXml,
         targetXml: _.targetXml,
         dialecteConfig: a,
         hooks: r
       });
       try {
-        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 });
+        crypto.randomUUID = X();
+        const o = await t({ testCase: _, 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 });
       } finally {
         await c.destroy();
       }
@@ -1650,15 +1651,15 @@ function J(B) {
   } = 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({
+      crypto.randomUUID = b;
+      const { project: _, source: i, target: c } = await E({
         sourceXml: A.sourceXml,
         targetXml: A.targetXml,
         dialecteConfig: a,
         hooks: r
       });
       try {
-        crypto.randomUUID = b(), await t({ testCase: A, source: i.document, target: c?.document });
+        crypto.randomUUID = X(), await t({ testCase: A, source: i.document, target: c?.document });
       } finally {
         await _.destroy();
       }
@@ -1703,13 +1704,13 @@ export {
   se as XMLNS_EXT_NAMESPACE,
   V as assertExpectedElementQueries,
   y as assertUnexpectedElementQueries,
-  b as createMockRandomUUID,
+  X as createMockRandomUUID,
   ce as createTestContext,
-  v as createTestProject,
+  E as createTestProject,
   ne as createTestRecord,
   Be as createTestRecordFactory,
   te as createTestRunner,
   R as createXmlAssertions,
   ie as runTestCases,
-  h as splitXpathIntoSteps
+  v as splitXpathIntoSteps
 };

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { i as r } from "./index-C2WRi-6U.js";
+import { i as r } from "./index-DWV6tSGF.js";
 export {
   r as invariant
 };

package/package.json

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

package/dist/merge-extensions-DQKNUthU.js

@@ -1,172 +0,0 @@
-import { i as E } from "./index-C2WRi-6U.js";
-const D = "db-id", v = {
-  uri: "http://dialecte.dev/XML/DEV",
-  prefix: "dev"
-}, $ = `${v.prefix}:${D}`, b = [
-  "id",
-  "tagName",
-  "namespace",
-  "attributes",
-  "children",
-  "parent",
-  "value"
-], A = [...b, "status"], S = [...A, "tree"];
-function d(e, t) {
-  if (typeof e != "object" || e === null)
-    return !1;
-  const n = Object.keys(e);
-  return t.every((a) => a in e) && n.every((a) => t.includes(a)) && n.length === t.length;
-}
-function I(e) {
-  return Array.isArray(e);
-}
-function z(e) {
-  return d(e, b);
-}
-function F(e) {
-  return d(e, A);
-}
-function K(e) {
-  return d(e, S);
-}
-function L(e, t) {
-  return e.tagName === t;
-}
-function V(e, t) {
-  return e.tagName === t;
-}
-function Y(e, t) {
-  return e.tagName === t;
-}
-function w(e, t) {
-  return t.elements.includes(e);
-}
-function B(e, t) {
-  return e.attributes.some((n) => n.name === t);
-}
-function M(e) {
-  return {
-    id: e.id,
-    tagName: e.tagName,
-    namespace: e.namespace,
-    attributes: e.attributes,
-    value: e.value,
-    parent: e.parent,
-    children: e.children
-  };
-}
-function j(e) {
-  const { record: t, status: n } = e, a = n ?? ("status" in t ? t.status : "unchanged");
-  return {
-    ...M(t),
-    status: a
-  };
-}
-function P(e) {
-  const { record: t, status: n, tree: a } = e, r = a ?? ("tree" in t ? t.tree : []);
-  return {
-    ...j({ record: t, status: n }),
-    tree: r
-  };
-}
-function k(e) {
-  const { dialecteConfig: t, tagName: n, attributes: a } = e;
-  return I(a) ? a : Object.entries(a).map(
-    ([r, s]) => ({
-      name: r,
-      value: s,
-      namespace: t.definition[n]?.attributes.details[r]?.namespace || void 0
-    })
-  );
-}
-function X(e) {
-  return E(e, {
-    detail: "The record or ref is undefined"
-  }), {
-    id: e.id,
-    tagName: e.tagName
-  };
-}
-function G(e) {
-  const { dialecteConfig: t, hooks: n, record: a } = e, { id: r, tagName: s, attributes: l, namespace: O, value: g } = a, N = r ?? crypto.randomUUID(), c = l ? k({ tagName: s, attributes: l, dialecteConfig: t }) : [], f = {
-    id: N,
-    tagName: s,
-    attributes: c,
-    namespace: O ?? {
-      prefix: "prefixNeededForNotSupportedNamespace",
-      uri: "uriNeededForNotSupportedNamespace"
-    },
-    value: g ?? "",
-    parent: a.parent ?? null,
-    children: a.children ?? []
-  };
-  if (!t.elements.includes(s)) return f;
-  const m = t.definition[s].attributes.sequence, o = t.definition[s].attributes.details, T = m.flatMap((i) => {
-    const h = o[i].required, _ = o[i]?.namespace || void 0, p = c.find((C) => C.name === i)?.value ?? (h ? o[i]?.default ?? "" : o[i]?.default);
-    return p === void 0 ? [] : [
-      {
-        name: i,
-        value: p,
-        namespace: _
-      }
-    ];
-  }), y = c.filter(
-    (i) => "namespace" in i && i.namespace != null && !m.includes(i.name)
-  );
-  let u = {
-    ...f,
-    namespace: t.definition[s].namespace,
-    attributes: [...T, ...y]
-  };
-  return n?.afterStandardizedRecord && (u = n.afterStandardizedRecord({
-    record: u
-  })), u;
-}
-function R(e, t, n, a) {
-  if (!e || !t) return;
-  const r = Object.keys(t).filter((s) => s in e);
-  E(r.length === 0, {
-    key: "EXTENSION_METHOD_COLLISION",
-    detail: `Module "${n}" has conflicting ${a} method(s): ${r.map((s) => `"${s}"`).join(", ")}`
-  });
-}
-function H(e) {
-  const t = {}, n = {}, a = [
-    ...Object.entries(e.base ?? {}),
-    ...Object.entries(e.custom ?? {})
-  ];
-  for (const [r, s] of a)
-    s.query && (R(
-      t[r],
-      s.query,
-      r,
-      "query"
-    ), t[r] = { ...t[r], ...s.query }), s.transaction && (R(
-      n[r],
-      s.transaction,
-      r,
-      "transaction"
-    ), n[r] = { ...n[r], ...s.transaction });
-  return { query: t, transaction: n };
-}
-export {
-  $ as C,
-  v as D,
-  D as a,
-  V as b,
-  w as c,
-  I as d,
-  Y as e,
-  z as f,
-  L as g,
-  F as h,
-  B as i,
-  K as j,
-  M as k,
-  X as l,
-  H as m,
-  j as n,
-  P as o,
-  G as s,
-  k as t
-};