@dialecte/core 0.6.4 → 0.8.0

package/dist/helpers-DVShv41E.js

@@ -0,0 +1,489 @@
+import { C as e, D as t, E as n, O as r, S as i, W as a, b as o, c as s, d as c, f as l, k as u, l as d, s as f, u as p, w as m, y as h } from "./utils-USNkj4sT.js";
+// src/helpers/guard.ts
+var g = [
+	"id",
+	"tagName",
+	"namespace",
+	"attributes",
+	"children",
+	"parent",
+	"value"
+], _ = [...g, "status"], v = [..._, "tree"];
+function y(e, t) {
+	if (typeof e != "object" || !e) return !1;
+	let n = Object.keys(e);
+	return t.every((t) => t in e) && n.every((e) => t.includes(e)) && n.length === t.length;
+}
+function b(e) {
+	return Array.isArray(e);
+}
+function x(e) {
+	return y(e, g);
+}
+function S(e) {
+	return y(e, _);
+}
+function C(e) {
+	return y(e, v);
+}
+function w(e, t) {
+	return e.tagName === t;
+}
+function T(e, t) {
+	return e.tagName === t;
+}
+function E(e, t) {
+	return e.tagName === t;
+}
+function D(e, t) {
+	return t.elements.includes(e);
+}
+function O(e, t) {
+	return e.attributes.some((e) => e.name === t);
+}
+// src/helpers/converter.ts
+function k(e) {
+	return {
+		id: e.id,
+		tagName: e.tagName,
+		namespace: e.namespace,
+		attributes: e.attributes,
+		value: e.value,
+		parent: e.parent,
+		children: e.children
+	};
+}
+function A(e) {
+	return e;
+}
+function j(e) {
+	let { record: t, status: n } = e, r = n ?? ("status" in t ? t.status : "unchanged");
+	return {
+		...k(t),
+		status: r
+	};
+}
+function M(e) {
+	let { record: t, status: n, tree: r } = e, i = r ?? ("tree" in t ? t.tree : []);
+	return {
+		...j({
+			record: t,
+			status: n
+		}),
+		tree: i
+	};
+}
+function N(e) {
+	let { dialecteConfig: t, tagName: n, attributes: r, stored: i = [] } = e;
+	return (Array.isArray(r) ? r : Object.entries(r).map(([e, r]) => ({
+		name: e,
+		value: r,
+		namespace: P({
+			dialecteConfig: t,
+			tagName: n,
+			name: e
+		}) ?? i.find((t) => t.name === e)?.namespace
+	}))).map((e) => F({
+		attribute: e,
+		dialecteConfig: t,
+		tagName: n
+	}));
+}
+function P(e) {
+	let { dialecteConfig: t, tagName: n, name: r } = e, i = t.definition[n];
+	if (i === void 0) return;
+	let a = Object.values(i.declarations ?? {}), o = [i, ...a].flatMap((e) => e.variants ?? []), s = [
+		i,
+		...a,
+		...o.flatMap((e) => t.types[e] ?? [])
+	];
+	for (let e of s) {
+		let t = e.attributes.details[r]?.namespace;
+		if (t) return t;
+	}
+}
+function F(e) {
+	let { attribute: t, dialecteConfig: n, tagName: r } = e, i;
+	typeof t.namespace == "string" ? (i = p(n, t.namespace), i || a("UNKNOWN_NAMESPACE_PREFIX", {
+		detail: `Unknown namespace '${t.namespace}' on attribute '${t.name}' — use a registered namespace key or pass a full { name, namespace: { prefix, uri } }.`,
+		ref: { tagName: r }
+	})) : i = t.namespace;
+	let o = t.name.indexOf(":");
+	if (!i && o !== -1) {
+		let e = t.name.slice(0, o);
+		e !== "xmlns" && (i = d(n, e), i || a("UNKNOWN_NAMESPACE_PREFIX", {
+			detail: `Unknown namespace prefix '${e}' on attribute '${t.name}' — pass it explicitly as { name, namespace: { prefix, uri } }.`,
+			ref: { tagName: r }
+		}));
+	}
+	return i && i.prefix && i.uri !== "http://www.w3.org/2000/xmlns/" && (i = ee({
+		dialecteConfig: n,
+		uri: i.uri
+	}) ?? i), i && i.prefix && i.prefix !== "xmlns" ? {
+		...t,
+		name: `${i.prefix}:${h(t.name)}`,
+		namespace: i
+	} : (t.namespace, {
+		...t,
+		namespace: i
+	});
+}
+function ee(e) {
+	let { dialecteConfig: t, uri: n } = e;
+	return Object.values(t.namespaces).find((e) => e.uri === n && e.prefix !== "");
+}
+function I(e) {
+	return l(e, { detail: "The record or ref is undefined" }), {
+		id: e.id,
+		tagName: e.tagName
+	};
+}
+// src/helpers/standardizing.ts
+function L(e) {
+	let { dialecteConfig: t, hooks: n, record: r } = e, { id: i, tagName: a, attributes: o, namespace: c, value: l } = r, u = i ?? crypto.randomUUID(), d = R({
+		dialecteConfig: t,
+		attributes: o ? N({
+			tagName: a,
+			attributes: o,
+			dialecteConfig: t
+		}) : []
+	}), p = {
+		id: u,
+		tagName: a,
+		attributes: d,
+		namespace: c ?? {
+			prefix: "prefixNeededForNotSupportedNamespace",
+			uri: "uriNeededForNotSupportedNamespace"
+		},
+		value: l ?? "",
+		parent: r.parent ?? null,
+		children: r.children ?? []
+	}, h = Object.values(t.namespaces).map(({ uri: e }) => e), g = c?.uri != null && !h.includes(c.uri);
+	if (!t.elements.includes(a) || g) return p;
+	let _ = m({
+		dialecteConfig: t,
+		record: {
+			...p,
+			namespace: c
+		}
+	}), v = _?.attributes.sequence ?? [], y = f({
+		wildcard: _?.attributes.any,
+		namespaceUri: ""
+	}), b = d.filter((e) => {
+		let t = v.includes(e.name), n = "namespace" in e && e.namespace != null;
+		if (!t && !n && !y) return !1;
+		if (!t) return !0;
+		if (e.value === void 0 || e.value === null) return !1;
+		if (e.value !== "") return !0;
+		let r = _?.attributes.details[e.name];
+		return r?.default !== void 0 || r?.fixed !== void 0;
+	}), x = t.namespaces.default.uri, S = b.map((e) => {
+		if ("namespace" in e && e.namespace?.uri === x) {
+			let { namespace: t, ...n } = e;
+			return n;
+		}
+		return e;
+	}), C = t.definition[a], w = [_?.namespace ?? C.namespace, ...Object.values(C.declarations ?? {}).map((e) => e.namespace)], T = w.find((e) => e.uri === c?.uri), E = {
+		...p,
+		namespace: T ?? c ?? w[0],
+		attributes: s(S, v)
+	};
+	return n?.afterStandardizedRecord && (E = n.afterStandardizedRecord({ record: E }), E = {
+		...E,
+		attributes: s(R({
+			dialecteConfig: t,
+			attributes: E.attributes
+		}), v)
+	}), E;
+}
+function R(e) {
+	let { dialecteConfig: t, attributes: n } = e;
+	return u({
+		dialecteConfig: t,
+		attributes: n,
+		namespaceOf: r({
+			dialecteConfig: t,
+			attributes: n
+		})
+	});
+}
+// src/helpers/assert-fixed.ts
+function z(e) {
+	let { dialecteConfig: t, record: n, attributes: r } = e;
+	for (let e of r) {
+		let r = o({
+			dialecteConfig: t,
+			record: n,
+			attributeName: e.name
+		});
+		r.fixed !== void 0 && e.value !== r.fixed && a("FIXED_VALUE_VIOLATION", {
+			detail: `Attribute '${e.name}' on '${n.tagName}' is fixed to '${r.fixed}' but was set to '${String(e.value)}'.`,
+			ref: { tagName: n.tagName }
+		});
+	}
+}
+// src/helpers/assert-xsi-type.ts
+function B(r) {
+	let { dialecteConfig: i, record: o } = r, s = o.attributes.find(n);
+	if (s === void 0) {
+		m({
+			dialecteConfig: i,
+			record: o
+		})?.abstractType && a("XSI_TYPE_REQUIRED", {
+			detail: `'${o.tagName}' is declared with an abstract type: name one of its variants with xsi:type (${e({
+				dialecteConfig: i,
+				record: o
+			}).join(", ")}).`,
+			ref: { tagName: o.tagName }
+		});
+		return;
+	}
+	if (m({
+		dialecteConfig: i,
+		record: o
+	}) === void 0) return;
+	let c = t({
+		dialecteConfig: i,
+		record: o
+	});
+	if (c?.namespace === "http://www.w3.org/2001/XMLSchema") return;
+	let l = e({
+		dialecteConfig: i,
+		record: o
+	});
+	c !== void 0 && l.includes(c.clark) || a("XSI_TYPE_NOT_ADMITTED", {
+		detail: `'${o.tagName}' may not name the type '${String(s.value)}' with xsi:type; it admits ${l.join(", ") || "none"}.`,
+		ref: { tagName: o.tagName },
+		meta: {
+			value: s.value,
+			admitted: l
+		}
+	});
+}
+function V(e) {
+	let { dialecteConfig: t, merged: n, record: r } = e, i = new Set(r.attributes.map((e) => e.name)), o = n.filter((e) => e.value !== "" && !i.has(e.name)).map((e) => e.name), s = m({
+		dialecteConfig: t,
+		record: r
+	}), c = new Set(s?.children.sequence ?? []), l = s?.children.any ? [] : [...new Set(r.children.map((e) => e.tagName))].filter((e) => !c.has(e));
+	(o.length !== 0 || l.length !== 0) && a("XSI_TYPE_CHANGE_LEAVES_CONTENT", {
+		detail: `'${r.tagName}' now names a type that does not admit ` + [o.length > 0 ? `the attributes ${o.join(", ")} (clear them in the same update)` : "", l.length > 0 ? `the children ${l.join(", ")} (delete them first)` : ""].filter(Boolean).join(" nor ") + ".",
+		ref: { tagName: r.tagName },
+		meta: {
+			attributes: o,
+			children: l
+		}
+	});
+}
+// src/helpers/merge-extensions.ts
+function H(e, t, n, r) {
+	if (!e || !t) return;
+	let i = Object.keys(t).filter((t) => t in e);
+	l(i.length === 0, {
+		key: "EXTENSION_METHOD_COLLISION",
+		detail: `Module "${n}" has conflicting ${r} method(s): ${i.map((e) => `"${e}"`).join(", ")}`
+	});
+}
+function U(e) {
+	let t = {}, n = {}, r = [...Object.entries(e.base ?? {}), ...Object.entries(e.custom ?? {})];
+	for (let [e, i] of r) i.query && (H(t[e], i.query, e, "query"), t[e] = {
+		...t[e],
+		...i.query
+	}), i.transaction && (H(n[e], i.transaction, e, "transaction"), n[e] = {
+		...n[e],
+		...i.transaction
+	});
+	return {
+		query: t,
+		transaction: n
+	};
+}
+// src/helpers/strip-attributes.ts
+function W(e, t) {
+	let n = new Set(t), r = {
+		...e,
+		attributes: e.attributes.filter((e) => !n.has(e.name))
+	};
+	return "tree" in e ? {
+		...r,
+		tree: e.tree.map((e) => W(e, t))
+	} : r;
+}
+// src/helpers/read-attributes.ts
+function G(e) {
+	let { record: t, dialecteConfig: n, name: r, namespace: a, fullObject: s, defaults: c = "optional" } = e, l = K({
+		dialecteConfig: n,
+		name: r,
+		namespace: a
+	}), u = t.attributes.find((e) => e.name === l);
+	if (u) return s ? u : u.value;
+	let d = i({
+		dialecteConfig: n,
+		record: t,
+		attributeName: l,
+		defaults: c
+	});
+	if (!s) return d ?? "";
+	if (d === void 0) return;
+	let { namespace: f } = o({
+		dialecteConfig: n,
+		record: t,
+		attributeName: l
+	});
+	return {
+		name: l,
+		value: d,
+		namespace: f
+	};
+}
+function K(e) {
+	let { dialecteConfig: t, name: n, namespace: r } = e;
+	if (r === void 0) return n;
+	let i = c(t, r);
+	return i ? `${i}:${n}` : n;
+}
+function q(e) {
+	return e.fullObject ? Y(e) : J(e);
+}
+function J(e) {
+	let { record: t, dialecteConfig: n, namespace: r, defaults: a = "optional" } = e, o = r === void 0 ? void 0 : c(n, r), s = {};
+	for (let e of t.attributes) {
+		let t = Z({
+			name: e.name,
+			namespace: e.namespace,
+			targetPrefix: o
+		});
+		t !== void 0 && (s[t] = e.value ?? "");
+	}
+	if (a === "none") return s;
+	for (let e of X({
+		dialecteConfig: n,
+		record: t
+	})) {
+		let r = Z({
+			name: e,
+			targetPrefix: o
+		});
+		if (r === void 0 || r in s) continue;
+		let c = i({
+			dialecteConfig: n,
+			record: t,
+			attributeName: e,
+			defaults: a
+		});
+		c !== void 0 && (s[r] = c);
+	}
+	return s;
+}
+function Y(e) {
+	let { record: t, dialecteConfig: n, defaults: r = "optional" } = e, a = [...t.attributes];
+	if (r === "none") return a;
+	let s = new Set(a.map((e) => e.name));
+	for (let e of X({
+		dialecteConfig: n,
+		record: t
+	})) {
+		if (s.has(e)) continue;
+		let c = i({
+			dialecteConfig: n,
+			record: t,
+			attributeName: e,
+			defaults: r
+		});
+		if (c === void 0) continue;
+		let { namespace: l } = o({
+			dialecteConfig: n,
+			record: t,
+			attributeName: e
+		});
+		a.push({
+			name: e,
+			value: c,
+			namespace: l
+		});
+	}
+	return a;
+}
+function X(e) {
+	let { dialecteConfig: t, record: n } = e;
+	return m({
+		dialecteConfig: t,
+		record: n
+	})?.attributes.sequence ?? [];
+}
+function Z(e) {
+	let { name: t, namespace: n, targetPrefix: r } = e, { prefix: i, local: a, isXmlns: o } = Q(t);
+	if (!(o || n?.uri === "http://www.w3.org/2000/xmlns/")) return r === void 0 ? t : i === r ? a : void 0;
+}
+function Q(e) {
+	if (e === "xmlns" || e.startsWith("xmlns:")) return {
+		prefix: "",
+		local: e,
+		isXmlns: !0
+	};
+	let t = e.indexOf(":");
+	return t === -1 ? {
+		prefix: "",
+		local: e,
+		isXmlns: !1
+	} : {
+		prefix: e.slice(0, t),
+		local: e.slice(t + 1),
+		isXmlns: !1
+	};
+}
+// src/helpers/evaluate-expectations.ts
+async function te(e, t) {
+	let n = {
+		passed: [],
+		failed: []
+	};
+	for (let r of t.expectations) {
+		let t = await ne(e, { expectation: r });
+		re({
+			expectation: r,
+			actualCount: t
+		}) ? n.passed.push(r) : n.failed.push({
+			expectation: r,
+			actualCount: t,
+			message: ie({
+				expectation: r,
+				actualCount: t
+			})
+		});
+	}
+	return n;
+}
+async function ne(e, t) {
+	let { tag: n, where: r = {}, under: i } = t.expectation;
+	if (!i) return (await e.any.findByAttributes({
+		tagName: n,
+		attributes: r
+	})).length;
+	let a = await e.any.findByAttributes({
+		tagName: i.tag,
+		attributes: i.where ?? {}
+	}), o = [{ [n]: { where: r } }], s = /* @__PURE__ */ new Set();
+	for (let t of a) {
+		let r = await e.findDescendants({
+			tagName: t.tagName,
+			id: t.id
+		}, { collect: o });
+		for (let e of r[n] ?? []) s.add(e.id);
+	}
+	return s.size;
+}
+function re(e) {
+	let { expectation: t, actualCount: n } = e;
+	return t.count === void 0 ? n > 0 : n === t.count;
+}
+function ie(e) {
+	let { expectation: t, actualCount: n } = e, r = t.count === void 0 ? "at least one" : t.count === 0 ? "no" : String(t.count), i = t.under ? ` under ${$(t.under)}` : "";
+	return `expected ${r} ${$(t)}${i}, found ${n}`;
+}
+function $(e) {
+	let t = Object.entries(e.where ?? {}).map(function([e, t]) {
+		return `[${e}=${(Array.isArray(t) ? t : [t]).map((e) => `"${e}"`).join("|")}]`;
+	});
+	return `${e.tag}${t.join("")}`;
+}
+export { S as C, w as S, T as _, U as a, E as b, z as c, k as d, I as f, O as g, A as h, W as i, L as l, M as m, G as n, B as o, j as p, q as r, V as s, te as t, N as u, D as v, C as w, x, b as y };