@dialecte/scl 0.3.16 → 0.3.17

package/dist/v2019C1/test/assert-valid-scl-xml.d.ts

@@ -1,8 +1,10 @@
+import { AssertValidSclTestCasesParams, AssertValidSclXmlOptions } from './assert-valid-scl-xml.types';
 /**
  * Assert a test XML string is valid SCL, structurally: every element's namespace matches its parent
  * context, every element is an allowed child of its parent, and every attribute is a known attribute of
- * its element. Elements/parents unknown to the schema are skipped (bespoke content under a transparent
- * `Private`, or dev-namespace scaffolding).
+ * its element. Elements unknown to the schema are skipped (bespoke content under a transparent
+ * `Private`), and so is any element in a namespace the SCL config does not declare — even when its
+ * local name collides with a schema element.
  *
  * `requireComplete` (default `true`) additionally requires every schema-required attribute to be
  * present. Minimal test fixtures legitimately omit these (e.g. a bare `<SCL>` without
@@ -12,7 +14,11 @@
  * NOT yet enforced (planned with the validation feature): attribute VALUE facets (uuid pattern, enums,
  * datatypes) and cross-element constraints (unique keys, keyref resolution).
  */
-export declare function assertValidSclXml(xml: string, label?: string, options?: {
-    requireComplete?: boolean;
-}): void;
+export declare function assertValidSclXml(xml: string, label?: string, options?: AssertValidSclXmlOptions): void;
+/**
+ * Validate every case's `sourceXml`/`targetXml` and throw ONCE with the violations of all invalid
+ * cases, each attributed to its case name — so a suite's fixtures are fixed in one round instead of
+ * one failure at a time.
+ */
+export declare function assertValidSclTestCases(params: AssertValidSclTestCasesParams): void;
 //# sourceMappingURL=assert-valid-scl-xml.d.ts.map

package/dist/v2019C1/test/assert-valid-scl-xml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert-valid-scl-xml.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-valid-scl-xml.ts"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,MAAM,EACX,KAAK,SAAa,EAClB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GACzC,IAAI,CAqDN"}
+{"version":3,"file":"assert-valid-scl-xml.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-valid-scl-xml.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACX,6BAA6B,EAC7B,wBAAwB,EAKxB,MAAM,8BAA8B,CAAA;AAsJrC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,MAAM,EACX,KAAK,SAAa,EAClB,OAAO,GAAE,wBAA6B,GACpC,IAAI,CAIN;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,6BAA6B,GAAG,IAAI,CAkBnF"}

package/dist/v2019C1/test/assert-valid-scl-xml.types.d.ts

@@ -0,0 +1,45 @@
+export type SchemaNamespace = {
+    uri: string;
+};
+/** The slice of a generated element definition the fixture validator reads. */
+export type SchemaElementDefinition = {
+    namespace?: SchemaNamespace;
+    attributes?: {
+        sequence?: readonly string[];
+        details?: Record<string, {
+            required?: boolean;
+        } | undefined>;
+    };
+    children?: {
+        sequence?: readonly string[];
+        any?: boolean;
+        details?: Record<string, {
+            namespace?: SchemaNamespace;
+        } | undefined>;
+    };
+};
+export type AssertValidSclXmlOptions = {
+    requireComplete?: boolean;
+};
+export type DescribeInvalidSclXmlParams = {
+    xml: string;
+    label: string;
+    requireComplete: boolean;
+};
+export type CollectElementViolationsParams = {
+    element: Element;
+    parentLocalName: string | undefined;
+    requireComplete: boolean;
+};
+export type CollectAttributeViolationsParams = {
+    element: Element;
+    definition: SchemaElementDefinition;
+    requireComplete: boolean;
+};
+export type AssertValidSclTestCasesParams = {
+    testCases: Record<string, {
+        sourceXml: string;
+        targetXml?: string;
+    }>;
+};
+//# sourceMappingURL=assert-valid-scl-xml.types.d.ts.map

package/dist/v2019C1/test/assert-valid-scl-xml.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-valid-scl-xml.types.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-valid-scl-xml.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7C,+EAA+E;AAC/E,MAAM,MAAM,uBAAuB,GAAG;IACrC,SAAS,CAAC,EAAE,eAAe,CAAA;IAC3B,UAAU,CAAC,EAAE;QACZ,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;QAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE,GAAG,SAAS,CAAC,CAAA;KAC5D,CAAA;IACD,QAAQ,CAAC,EAAE;QACV,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;QAC5B,GAAG,CAAC,EAAE,OAAO,CAAA;QACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,SAAS,CAAC,EAAE,eAAe,CAAA;SAAE,GAAG,SAAS,CAAC,CAAA;KACrE,CAAA;CACD,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAEpE,MAAM,MAAM,2BAA2B,GAAG;IACzC,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,eAAe,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC5C,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,eAAe,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,gCAAgC,GAAG;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,uBAAuB,CAAA;IACnC,eAAe,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACpE,CAAA"}

package/dist/v2019C1/test/hydrated-test.d.ts

@@ -48,8 +48,8 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
     };
 }>;
 /**
- * `createTestRunner`, wrapped so every registered case's XML is checked against the SCL schema's
- * per-element namespaces before the suite runs (see {@link assertValidSclXml}).
+ * `createTestRunner`, wrapped so every registered case's XML is checked against the SCL schema
+ * before the suite runs — all invalid cases reported at once (see {@link assertValidSclTestCases}).
  */
 export declare const runSclTestCases: typeof rawRunSclTestCases;
 export declare function createSclTestProject(params: {

package/dist/v2019C1/test/hydrated-test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrated-test.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,0BAA0B,EAC1B,+BAA+B,EAE/B,MAAM,wBAAwB,CAAA;AAa/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAO9D,eAAO,MAAM,mBAAmB,QAA0D,CAAA;AAC1F,eAAO,MAAM,yBAAyB,QAA2G,CAAA;AACjJ,eAAO,MAAM,oBAAoB,QAAsG,CAAA;AACvI,OAAO,EAAE,0BAA0B,EAAE,+BAA+B,EAAE,CAAA;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAI1D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAA;AAaF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,kBAUpC,CAAA;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IAClD,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAaA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAAuD,CAAA;AACvF,eAAO,MAAQ,4BAA4B;;;YAAE,8BAA8B;;;UAI1E,CAAA"}
+{"version":3,"file":"hydrated-test.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,0BAA0B,EAC1B,+BAA+B,EAE/B,MAAM,wBAAwB,CAAA;AAa/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAO9D,eAAO,MAAM,mBAAmB,QAA0D,CAAA;AAC1F,eAAO,MAAM,yBAAyB,QAA2G,CAAA;AACjJ,eAAO,MAAM,oBAAoB,QAAsG,CAAA;AACvI,OAAO,EAAE,0BAA0B,EAAE,+BAA+B,EAAE,CAAA;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAI1D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,kBAUpC,CAAA;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IAClD,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAaA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAAuD,CAAA;AACvF,eAAO,MAAQ,4BAA4B;;;YAAE,8BAA8B;;;UAI1E,CAAA"}

package/dist/v2019C1/test.js

@@ -1,70 +1,120 @@
-import { F as e, M as t, n, r, t as i } from "../hooks-BBGXNK0x.js";
-import { CUSTOM_RECORD_ID_ATTRIBUTE as a, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as o, XMLNS_XSI_NAMESPACE as s } from "@dialecte/core/helpers";
-import { XMLNS_DEV_NAMESPACE as c, createTestProject as l, createTestRecordFactory as u, createTestRunner as d, createXmlAssertions as f } from "@dialecte/core/test";
+import { F as e, M as t, P as n, n as r, r as i, t as a } from "../hooks-BBGXNK0x.js";
+import { CUSTOM_RECORD_ID_ATTRIBUTE as o, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as s, XMLNS_XSI_NAMESPACE as c } from "@dialecte/core/helpers";
+import { XMLNS_DEV_NAMESPACE as l, createTestProject as u, createTestRecordFactory as d, createTestRunner as f, createXmlAssertions as p } from "@dialecte/core/test";
 //#region src/v2019C1/test/assert-valid-scl-xml.ts
-var p = e;
-function m(e, t) {
-	return ((e ? p[e]?.children?.details?.[t]?.namespace : void 0) ?? p[t]?.namespace)?.uri;
+var m = e, h = Object.values(n).map((e) => e.uri);
+function g(e) {
+	return e.namespaceURI !== null && !h.includes(e.namespaceURI);
+}
+function _(e, t) {
+	return ((e ? m[e]?.children?.details?.[t]?.namespace : void 0) ?? m[t]?.namespace)?.uri;
 }
-function h(e, t) {
+function v(e, t) {
 	let n = e.children;
 	return n ? n.any === !0 || n.sequence?.includes(t) ? !0 : n.details ? t in n.details : !1 : !1;
 }
-function g(e) {
+function y(e) {
 	return new Set([...e.attributes?.sequence ?? [], ...Object.keys(e.attributes?.details ?? {})]);
 }
-function _(e, t = "test XML", n = {}) {
-	let r = n.requireComplete ?? !0, i = new DOMParser().parseFromString(e, "application/xml"), a = i.querySelector("parsererror");
-	if (a) throw Error(`${t}: malformed XML — ${a.textContent?.trim()}`);
-	let o = [], s = (e, t) => {
-		let n = e.localName, i = p[n], a = m(t, n);
-		if (a !== void 0 && e.namespaceURI !== a) {
-			let n = t ? ` under <${t}>` : "";
-			o.push(`[namespace] <${e.tagName}>${n}: is in ${e.namespaceURI ?? "(no namespace)"}, schema declares ${a}`);
-		}
-		let c = t ? p[t] : void 0;
-		if (c && !h(c, n) && o.push(`[containment] <${n}> is not a valid child of <${t}>`), i?.attributes) {
-			let t = g(i);
-			for (let r of Array.from(e.attributes)) r.namespaceURI === null && (t.has(r.localName) || o.push(`[attribute] <${n}> has unknown attribute '${r.localName}'`));
-			if (r) for (let [t, r] of Object.entries(i.attributes.details ?? {})) r?.required && !e.hasAttribute(t) && o.push(`[required] <${n}> is missing required attribute '${t}'`);
-		}
-		for (let t of Array.from(e.children)) s(t, n);
-	};
-	if (i.documentElement && s(i.documentElement, void 0), o.length > 0) throw Error(`${t}: not valid SCL:\n  ${o.join("\n  ")}`);
+function b(e) {
+	let { element: t, definition: n, requireComplete: r } = e;
+	if (!n.attributes) return [];
+	let i = y(n), a = Array.from(t.attributes).filter((e) => e.namespaceURI === null && !i.has(e.localName)).map((e) => `[attribute] <${t.localName}> has unknown attribute '${e.localName}'`);
+	if (!r) return a;
+	let o = Object.entries(n.attributes.details ?? {}).filter(([e, n]) => n?.required && !t.hasAttribute(e)).map(([e]) => `[required] <${t.localName}> is missing required attribute '${e}'`);
+	return [...a, ...o];
+}
+function x(e) {
+	let { element: t, parentLocalName: n, requireComplete: r } = e, i = Array.from(t.children);
+	if (g(t)) return i.flatMap((e) => x({
+		element: e,
+		parentLocalName: void 0,
+		requireComplete: r
+	}));
+	let a = t.localName, o = [], s = _(n, a);
+	if (s !== void 0 && t.namespaceURI !== s) {
+		let e = n ? ` under <${n}>` : "";
+		o.push(`[namespace] <${t.tagName}>${e}: is in ${t.namespaceURI ?? "(no namespace)"}, schema declares ${s}`);
+	}
+	let c = n ? m[n] : void 0;
+	c && !v(c, a) && o.push(`[containment] <${a}> is not a valid child of <${n}>`);
+	let l = m[a], u = l ? b({
+		element: t,
+		definition: l,
+		requireComplete: r
+	}) : [], d = i.flatMap((e) => x({
+		element: e,
+		parentLocalName: a,
+		requireComplete: r
+	}));
+	return [
+		...o,
+		...u,
+		...d
+	];
+}
+function S(e) {
+	let { xml: t, label: n, requireComplete: r } = e;
+	if (!t.startsWith("<?xml") && t.trimStart().startsWith("<?xml")) return `${n}: malformed XML — the XML declaration must be the very first characters of the string: remove the declaration (a snippet does not need one) or the whitespace before it`;
+	let i = new DOMParser().parseFromString(t, "application/xml"), a = i.querySelector("parsererror");
+	if (a) return `${n}: malformed XML — ${a.textContent?.trim()}`;
+	if (!i.documentElement) return;
+	let o = x({
+		element: i.documentElement,
+		parentLocalName: void 0,
+		requireComplete: r
+	});
+	return o.length > 0 ? `${n}: not valid SCL:\n  ${o.join("\n  ")}` : void 0;
+}
+function C(e, t = "test XML", n = {}) {
+	let r = S({
+		xml: e,
+		label: t,
+		requireComplete: n.requireComplete ?? !0
+	});
+	if (r) throw Error(r);
 }
-//#endregion
-//#region src/v2019C1/test/hydrated-test.ts
-var v = {
-	...n(),
-	...i
-}, y = `xmlns="${t.namespaces.default.uri}"`, b = `xmlns:${t.namespaces.v2019C1.prefix}="${t.namespaces.v2019C1.uri}"`, x = `${y} ${b} ${c} ${s}`, S = { base: r }, C = d({
-	dialecteConfig: t,
-	extensions: S,
-	hooks: v
-});
 function w(e) {
-	for (let [t, n] of Object.entries(e)) _(n.sourceXml, `${t} › sourceXml`, { requireComplete: !1 }), n.targetXml && _(n.targetXml, `${t} › targetXml`, { requireComplete: !1 });
+	let { testCases: t } = e, n = Object.entries(t).flatMap(([e, t]) => [S({
+		xml: t.sourceXml,
+		label: `${e} › sourceXml`,
+		requireComplete: !1
+	}), t.targetXml ? S({
+		xml: t.targetXml,
+		label: `${e} › targetXml`,
+		requireComplete: !1
+	}) : void 0].filter((e) => e !== void 0));
+	if (n.length > 0) throw Error(n.join("\n"));
 }
+//#endregion
+//#region src/v2019C1/test/hydrated-test.ts
 var T = {
-	...C,
+	...r(),
+	...a
+}, E = `xmlns="${t.namespaces.default.uri}"`, D = `xmlns:${t.namespaces.v2019C1.prefix}="${t.namespaces.v2019C1.uri}"`, O = `${E} ${D} ${l} ${c}`, k = { base: i }, A = f({
+	dialecteConfig: t,
+	extensions: k,
+	hooks: T
+}), j = {
+	...A,
 	withExport(e) {
-		w(e.testCases), C.withExport(e);
+		w({ testCases: e.testCases }), A.withExport(e);
 	},
 	withoutExport(e) {
-		w(e.testCases), C.withoutExport(e);
+		w({ testCases: e.testCases }), A.withoutExport(e);
 	}
 };
-async function E(e) {
+async function M(e) {
 	let { sourceXml: n, targetXml: r, dev: i } = e;
-	return _(n, "sourceXml", { requireComplete: !1 }), r && _(r, "targetXml", { requireComplete: !1 }), l({
+	return C(n, "sourceXml", { requireComplete: !1 }), r && C(r, "targetXml", { requireComplete: !1 }), u({
 		sourceXml: n,
 		targetXml: r,
 		dialecteConfig: t,
-		extensions: S,
-		hooks: v,
+		extensions: k,
+		hooks: T,
 		dev: i
 	});
 }
-var D = u(t), { assertExpectedElementQueries: O, assertUnexpectedElementQueries: k } = f({ namespaces: t.namespaces });
+var N = d(t), { assertExpectedElementQueries: P, assertUnexpectedElementQueries: F } = p({ namespaces: t.namespaces });
 //#endregion
-export { x as ALL_XMLNS_NAMESPACES, a as CUSTOM_RECORD_ID_ATTRIBUTE, o as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, b as XMLNS_SCL_6_100_NAMESPACE, y as XMLNS_SCL_NAMESPACE, O as assertExpectedElementQueries, k as assertUnexpectedElementQueries, _ as assertValidSclXml, E as createSclTestProject, D as createSclTestRecord, T as runSclTestCases };
+export { O as ALL_XMLNS_NAMESPACES, o as CUSTOM_RECORD_ID_ATTRIBUTE, s as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, D as XMLNS_SCL_6_100_NAMESPACE, E as XMLNS_SCL_NAMESPACE, P as assertExpectedElementQueries, F as assertUnexpectedElementQueries, C as assertValidSclXml, M as createSclTestProject, N as createSclTestRecord, j as runSclTestCases };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/scl",
-	"version": "0.3.16",
+	"version": "0.3.17",
 	"description": "Dialecte - SCL (Substation Configuration Language) sdk",
 	"license": "MIT",
 	"repository": {