@dialecte/scl 0.4.2 → 0.6.0

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

@@ -4,6 +4,7 @@ export declare const XMLNS_SCL_NAMESPACE: string;
 export declare const XMLNS_SCL_6_100_NAMESPACE: string;
 export declare const ALL_XMLNS_NAMESPACES: string;
 export { CUSTOM_RECORD_ID_ATTRIBUTE, CUSTOM_RECORD_ID_ATTRIBUTE_NAME };
+export { assertCoherentSclReferences } from './assert-coherent-scl-references';
 export { assertValidSclXml } from './assert-valid-scl-xml';
 declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Config, {
     cleanUp: {
@@ -25,6 +26,7 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
         query: {
             report: typeof import('../extensions/lifecycle/report').report;
             checkTemplateUuids: typeof import('../extensions/lifecycle/validate').checkTemplateUuids;
+            classifyIeds: typeof import('../extensions/lifecycle/ied').classifyIeds;
         };
         transaction: {
             extract: typeof import("../extensions/lifecycle/extract");
@@ -34,6 +36,7 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
             };
             update: typeof import("../extensions/lifecycle/update");
             apply: typeof import('../extensions/lifecycle/apply').apply;
+            makeUnique: typeof import('../extensions/lifecycle/constraints').makeUnique;
         };
     };
     reference: {
@@ -43,13 +46,14 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
     signature: {
         query: typeof import("../extensions/signature/query");
     };
-    presentation: {
-        query: typeof import("../extensions/presentation/query");
+    info: {
+        query: typeof import("../extensions/info/query");
     };
 }>;
 /**
- * `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}).
+ * `createTestRunner`, wrapped so every registered case's XML is checked before the suite runs —
+ * against the SCL schema (see {@link assertValidSclTestCases}), then for coherent references
+ * (see {@link assertCoherentSclReferencesTestCases}). All failing cases are reported at once.
  */
 export declare const runSclTestCases: typeof rawRunSclTestCases;
 export declare function createSclTestProject(params: {
@@ -58,6 +62,8 @@ export declare function createSclTestProject(params: {
     dev?: {
         perf?: boolean;
     };
+    /** The reason the fixtures NEED an incoherent reference; they are then left unchecked. */
+    allowIncoherentReferences?: string;
 }): Promise<import('@dialecte/core/test').TestProjectResult<Config, {
     cleanUp: {
         transaction: typeof import("../extensions/clean-up/transaction");
@@ -78,6 +84,7 @@ export declare function createSclTestProject(params: {
         query: {
             report: typeof import('../extensions/lifecycle/report').report;
             checkTemplateUuids: typeof import('../extensions/lifecycle/validate').checkTemplateUuids;
+            classifyIeds: typeof import('../extensions/lifecycle/ied').classifyIeds;
         };
         transaction: {
             extract: typeof import("../extensions/lifecycle/extract");
@@ -87,6 +94,7 @@ export declare function createSclTestProject(params: {
             };
             update: typeof import("../extensions/lifecycle/update");
             apply: typeof import('../extensions/lifecycle/apply').apply;
+            makeUnique: typeof import('../extensions/lifecycle/constraints').makeUnique;
         };
     };
     reference: {
@@ -96,8 +104,8 @@ export declare function createSclTestProject(params: {
     signature: {
         query: typeof import("../extensions/signature/query");
     };
-    presentation: {
-        query: typeof import("../extensions/presentation/query");
+    info: {
+        query: typeof import("../extensions/info/query");
     };
 }>>;
 export declare const createSclTestRecord: {

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;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"}
+{"version":3,"file":"hydrated-test.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.ts"],"names":[],"mappings":"AAMA,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,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAI1D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,kBAYpC,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;IACxB,0FAA0F;IAC1F,yBAAyB,CAAC,EAAE,MAAM,CAAA;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAAuD,CAAA;AACvF,eAAO,MAAQ,4BAA4B;;;YAAE,8BAA8B;;;UAI1E,CAAA"}

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

@@ -3,7 +3,14 @@ import { Config } from '../config/dialecte.config';
 import type * as CoreTest from '@dialecte/core/test';
 export declare namespace SclTest {
     type BaseTestCase = CoreTest.BaseTestCase;
-    type BaseXmlTestCase = CoreTest.BaseXmlTestCase;
+    type BaseXmlTestCase = CoreTest.BaseXmlTestCase & {
+        /**
+         * Set when the case NEEDS an incoherent reference (an orphan to clean up, a path to
+         * repair): the reason it does. The case's fixtures are then not checked for coherent
+         * references.
+         */
+        allowIncoherentReferences?: string;
+    };
     type TestCases<T extends BaseTestCase = BaseXmlTestCase> = Record<string, T>;
     type TestDocument = CoreTest.TestDocument<Config>;
     type TestProjectResult = CoreTest.TestProjectResult<Config, typeof SCL_EXTENSION_MODULES>;

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

@@ -1 +1 @@
-{"version":3,"file":"hydrated-test.types.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAEpD,yBAAiB,OAAO,CAAC;IACxB,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAA;IAChD,KAAY,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAA;IACtD,KAAY,SAAS,CAAC,CAAC,SAAS,YAAY,GAAG,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACnF,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;IACxD,KAAY,iBAAiB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;IAChG,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;IACpD,KAAY,SAAS,CAAC,CAAC,SAAS,QAAQ,CAAC,eAAe,IAAI,QAAQ,CAAC,SAAS,CAC7E,MAAM,EACN,CAAC,EACD,OAAO,qBAAqB,CAC5B,CAAA;IACD,KAAY,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAA;IAC1C,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;CAClF"}
+{"version":3,"file":"hydrated-test.types.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAEpD,yBAAiB,OAAO,CAAC;IACxB,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAA;IAChD,KAAY,eAAe,GAAG,QAAQ,CAAC,eAAe,GAAG;QACxD;;;;WAIG;QACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;KAClC,CAAA;IACD,KAAY,SAAS,CAAC,CAAC,SAAS,YAAY,GAAG,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACnF,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;IACxD,KAAY,iBAAiB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;IAChG,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;IACpD,KAAY,SAAS,CAAC,CAAC,SAAS,QAAQ,CAAC,eAAe,IAAI,QAAQ,CAAC,SAAS,CAC7E,MAAM,EACN,CAAC,EACD,OAAO,qBAAqB,CAC5B,CAAA;IACD,KAAY,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAA;IAC1C,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;CAClF"}

package/dist/v2019C1/test.js

@@ -1,38 +1,184 @@
-import { B as e, H as t, U as n, n as r, r as i, t as a } from "../hooks-CcSN4iH9.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, createXmlSchemaAssertions as m } from "@dialecte/core/test";
+import { $ as e, C as t, D as n, J as r, Q as i, X as a, n as o, r as s, t as c, w as l } from "../hooks-CHS8tY1i.js";
+import { CUSTOM_RECORD_ID_ATTRIBUTE as u, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as d, XMLNS_XSI_NAMESPACE as f } from "@dialecte/core/helpers";
+import { XMLNS_DEV_NAMESPACE as p, createTestProject as m, createTestRecordFactory as h, createTestRunner as g, createXmlAssertions as _, createXmlSchemaAssertions as v } from "@dialecte/core/test";
+//#region src/v2019C1/test/assert-coherent-scl-references.ts
+var y = Object.values(i).map((e) => e.uri);
+function b(e) {
+	let { xml: t } = e, n = [...new DOMParser().parseFromString(t, "application/xml").querySelectorAll("*")].filter(O), r = k(n);
+	return n.flatMap((e) => T({
+		element: e,
+		elementsByUuid: r
+	}));
+}
+function x(e) {
+	let { xml: t, label: n = "test XML" } = e, r = C({
+		xml: t,
+		label: n
+	});
+	if (r) throw Error(r);
+}
+function S(e) {
+	let { testCases: t } = e, n = Object.entries(t).flatMap(([e, t]) => t.allowIncoherentReferences ? [] : [C({
+		xml: t.sourceXml,
+		label: `${e} › sourceXml`
+	}), t.targetXml ? C({
+		xml: t.targetXml,
+		label: `${e} › targetXml`
+	}) : void 0].filter((e) => e !== void 0));
+	if (n.length > 0) throw Error(n.join("\n"));
+}
+function C(e) {
+	let { xml: t, label: n } = e, r = b({ xml: t });
+	if (r.length !== 0) return `${n}: incoherent references:\n  ${r.map(w).join("\n  ")}`;
+}
+function w(e) {
+	let t = `<${e.referenceTagName}>`;
+	switch (e.kind) {
+		case "path": return `[path] ${t} ${e.pathAttribute}="${e.written}" is not the path of the element ${e.uuidAttribute}="${e.uuid}" points at, which is "${e.expected}"`;
+		case "dangling": return `[dangling] ${t} ${e.uuidAttribute}="${e.uuid}" points at no element of the document`;
+		case "wrong-target": return `[wrong-target] ${t} ${e.uuidAttribute}="${e.uuid}" points at a <${e.targetTagName}>, which it cannot reference`;
+		case "empty": return `[empty] ${t} ${e.uuidAttribute} is empty`;
+	}
+}
+function T(e) {
+	let { element: t, elementsByUuid: n } = e, i = r[t.localName];
+	return i ? i.flatMap((e) => E({
+		element: t,
+		pair: e,
+		elementsByUuid: n
+	})) : [];
+}
+function E(e) {
+	let { element: t, pair: n, elementsByUuid: r } = e, i = t.getAttribute(n.attribute.uuid);
+	if (i === null) return [];
+	let a = n.attribute.uuid, o = t.localName;
+	if (i === "") return [{
+		kind: "empty",
+		referenceTagName: o,
+		uuidAttribute: a
+	}];
+	let s = r.get(i) ?? [];
+	if (s.length === 0) return [{
+		kind: "dangling",
+		referenceTagName: o,
+		uuidAttribute: a,
+		uuid: i
+	}];
+	let c = n.target, u = s.find((e) => c.includes(e.localName));
+	if (!u) return [{
+		kind: "wrong-target",
+		referenceTagName: o,
+		uuidAttribute: a,
+		uuid: i,
+		targetTagName: s[0].localName
+	}];
+	if (!D({
+		pair: n,
+		target: u
+	})) return [];
+	let d = t.getAttribute(n.attribute.path);
+	if (d === null) return [];
+	let f = A(u), p = l({
+		record: M(u),
+		ancestry: f.map((e, t) => M(e, `ancestor-${t}`)),
+		specNamings: j(f)
+	});
+	return !p || p.path === d ? [] : [{
+		kind: "path",
+		referenceTagName: o,
+		pathAttribute: n.attribute.path,
+		uuidAttribute: a,
+		uuid: i,
+		written: d,
+		expected: p.path
+	}];
+}
+function D(e) {
+	let { pair: r, target: i } = e;
+	return r.resolution === t.direct ? n[i.localName]?.type === "name" : !1;
+}
+function O(e) {
+	return e.namespaceURI !== null && y.includes(e.namespaceURI);
+}
+function k(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.getAttribute("uuid");
+		if (!e) continue;
+		let r = t.get(e) ?? [];
+		t.set(e, [...r, n]);
+	}
+	return t;
+}
+function A(e) {
+	let t = [], n = e.parentElement;
+	for (; n;) t.unshift(n), n = n.parentElement;
+	return t;
+}
+function j(e) {
+	let t = /* @__PURE__ */ new Map();
+	return e.forEach((e, n) => {
+		if (e.localName !== "LNode") return;
+		let r = [...e.getElementsByTagNameNS("*", "LNodeSpecNaming")].find((t) => t.parentElement?.parentElement === e);
+		r && t.set(`ancestor-${n}`, M(r));
+	}), t;
+}
+function M(e, t = "") {
+	return {
+		id: t,
+		tagName: e.localName,
+		namespace: {
+			prefix: e.prefix ?? "",
+			uri: e.namespaceURI ?? ""
+		},
+		attributes: [...e.attributes].map((e) => ({
+			name: e.localName,
+			value: e.value
+		})),
+		value: "",
+		parent: null,
+		children: []
+	};
+}
+//#endregion
 //#region src/v2019C1/test/assert-valid-scl-xml.ts
-var { assertValidXml: h, assertValidXmlTestCases: g } = m({
-	definition: n,
-	namespaces: t,
+var { assertValidXml: N, assertValidXmlTestCases: P } = v({
+	definition: e,
+	namespaces: i,
 	schemaName: "SCL"
-}), _ = h, v = g, y = {
-	...r(),
-	...a
-}, b = `xmlns="${e.namespaces.default.uri}"`, x = `xmlns:${e.namespaces.v2019C1.prefix}="${e.namespaces.v2019C1.uri}"`, S = `${b} ${x} ${l} ${c}`, C = { base: i }, w = f({
-	dialecteConfig: e,
-	extensions: C,
-	hooks: y
-}), T = {
-	...w,
+}), F = N, I = P, L = {
+	...o(),
+	...c
+}, R = `xmlns="${a.namespaces.default.uri}"`, z = `xmlns:${a.namespaces.v2019C1.prefix}="${a.namespaces.v2019C1.uri}"`, B = `${R} ${z} ${p} ${f}`, V = { base: s }, H = g({
+	dialecteConfig: a,
+	extensions: V,
+	hooks: L
+}), U = {
+	...H,
 	withExport(e) {
-		v({ testCases: e.testCases }), w.withExport(e);
+		I({ testCases: e.testCases }), S({ testCases: e.testCases }), H.withExport(e);
 	},
 	withoutExport(e) {
-		v({ testCases: e.testCases }), w.withoutExport(e);
+		I({ testCases: e.testCases }), S({ testCases: e.testCases }), H.withoutExport(e);
 	}
 };
-async function E(t) {
-	let { sourceXml: n, targetXml: r, dev: i } = t;
-	return _(n, "sourceXml", { requireComplete: !1 }), r && _(r, "targetXml", { requireComplete: !1 }), u({
-		sourceXml: n,
-		targetXml: r,
-		dialecteConfig: e,
-		extensions: C,
-		hooks: y,
-		dev: i
+async function W(e) {
+	let { sourceXml: t, targetXml: n, dev: r, allowIncoherentReferences: i } = e;
+	return F(t, "sourceXml", { requireComplete: !1 }), n && F(n, "targetXml", { requireComplete: !1 }), i || (x({
+		xml: t,
+		label: "sourceXml"
+	}), n && x({
+		xml: n,
+		label: "targetXml"
+	})), m({
+		sourceXml: t,
+		targetXml: n,
+		dialecteConfig: a,
+		extensions: V,
+		hooks: L,
+		dev: r
 	});
 }
-var D = d(e), { assertExpectedElementQueries: O, assertUnexpectedElementQueries: k } = p({ namespaces: e.namespaces });
+var G = h(a), { assertExpectedElementQueries: K, assertUnexpectedElementQueries: q } = _({ namespaces: a.namespaces });
 //#endregion
-export { S as ALL_XMLNS_NAMESPACES, o as CUSTOM_RECORD_ID_ATTRIBUTE, s as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, x as XMLNS_SCL_6_100_NAMESPACE, b as XMLNS_SCL_NAMESPACE, O as assertExpectedElementQueries, k as assertUnexpectedElementQueries, _ as assertValidSclXml, E as createSclTestProject, D as createSclTestRecord, T as runSclTestCases };
+export { B as ALL_XMLNS_NAMESPACES, u as CUSTOM_RECORD_ID_ATTRIBUTE, d as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, z as XMLNS_SCL_6_100_NAMESPACE, R as XMLNS_SCL_NAMESPACE, x as assertCoherentSclReferences, K as assertExpectedElementQueries, q as assertUnexpectedElementQueries, F as assertValidSclXml, W as createSclTestProject, G as createSclTestRecord, U as runSclTestCases };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/scl",
-	"version": "0.4.2",
+	"version": "0.6.0",
 	"description": "Dialecte - SCL (Substation Configuration Language) sdk",
 	"license": "MIT",
 	"repository": {
@@ -56,7 +56,7 @@
 		"prepare": "husky"
 	},
 	"dependencies": {
-		"@dialecte/core": "0.5.1"
+		"@dialecte/core": "0.5.4"
 	},
 	"devDependencies": {
 		"@dialecte/cli": "0.0.3",

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.types.d.ts

@@ -1,16 +0,0 @@
-/**
- * Consumer hook that shapes the collision-resolution naming scheme. Given the base
- * value and the current attempt, returns a candidate value. The engine still owns
- * uniqueness (it loops `attempt` until the candidate is collision-free), so a hook
- * need not guarantee uniqueness — only the scheme (e.g. a domain affix).
- *
- * Default (no hook): `` `${base}_${attempt}` ``. A SET affix hook could return
- * `` `${base}_Fn_${attempt}` ``.
- */
-export type CollisionDecorator = (params: {
-    base: string;
-    attempt: number;
-    attr: string;
-    childTag: string;
-}) => string;
-//# sourceMappingURL=resolve-unique-value.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-unique-value.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CAChB,KAAK,MAAM,CAAA"}

package/dist/v2019C1/extensions/lifecycle/report/mark-placement-conflicts.d.ts

@@ -1,22 +0,0 @@
-import { Config } from '../../../config';
-import { LifecycleTarget } from '../contract.types';
-import { DiffReport } from '../engine/diff.types';
-import type * as Core from '@dialecte/core';
-/**
- * Classify placement collisions for an `instantiate` report and record them on the
- * groups (generic over any scoped-uniqueness constraint, any field combination):
- *
- *  - **resolvable** — the violated constraint has an editable field (`rename`/`free`):
- *    the engine can make a distinct copy. Flag that editable attribute with the
- *    collision-free `suggestedValue` (the UI shows it; the user may override). No gate.
- *  - **identity-locked** — every field is identity (non-editable): the primary is
- *    identity-equal to an existing element and cannot be duplicated. Record
- *    `group.conflict = { fields, adoptTargetId }` and set `needsDecisions` so the user
- *    chooses skip (leave existing) or adopt (reconcile onto it).
- *
- * `update` never calls this: an identity match there is the reconcile target, not a
- * conflict. The placement parent is taken from an existing instance (same template),
- * which is exactly where the new one would be placed.
- */
-export declare function markPlacementConflicts(query: Core.Query<Config>, target: LifecycleTarget, report: DiffReport): Promise<void>;
-//# sourceMappingURL=mark-placement-conflicts.d.ts.map

package/dist/v2019C1/extensions/lifecycle/report/mark-placement-conflicts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mark-placement-conflicts.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/report/mark-placement-conflicts.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAO,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+CAA+C,CAAA;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kDAAkD,CAAA;AAClF,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,sBAAsB,CAC3C,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,UAAU,GAChB,OAAO,CAAC,IAAI,CAAC,CAuEf"}

package/dist/v2019C1/extensions/presentation/constants/title.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"title.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/presentation/constants/title.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,qBAAqB,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAoGpE,CAAA"}

package/dist/v2019C1/extensions/presentation/constants/title.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"title.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/presentation/constants/title.types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAAE,CAAA;AAE3E,MAAM,MAAM,SAAS,GAAG;IACvB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,gBAAgB,CAAA;IAC7C,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,gBAAgB,CAAA;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA"}

package/dist/v2019C1/extensions/presentation/index.d.ts

@@ -1,5 +0,0 @@
-import * as presentationQueries from './query';
-export declare const presentation: {
-    query: typeof presentationQueries;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/presentation/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/extensions/presentation/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,mBAAmB,MAAM,SAAS,CAAA;AAE9C,eAAO,MAAM,YAAY;;CAExB,CAAA"}

package/dist/v2019C1/extensions/presentation/public.d.ts

@@ -1,3 +0,0 @@
-export type { ElementTitle, ExtractElementTitleOptions, ExtractElementTitleOptionsWithLabels, } from './query/extract-element-title.types';
-export type { ConditionalTitle, TitleSpec } from './constants/title.types';
-//# sourceMappingURL=public.d.ts.map

package/dist/v2019C1/extensions/presentation/public.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/extensions/presentation/public.ts"],"names":[],"mappings":"AAGA,YAAY,EACX,YAAY,EACZ,0BAA0B,EAC1B,oCAAoC,GACpC,MAAM,qCAAqC,CAAA;AAC5C,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/v2019C1/extensions/presentation/query/extract-element-title.d.ts

@@ -1,20 +0,0 @@
-import { ElementTitle, ExtractElementTitleOptions, ExtractElementTitleOptionsWithLabels } from './extract-element-title.types';
-import { Config } from '../../../config';
-import { AnyRefOrRecord } from '@dialecte/core';
-import type * as Core from '@dialecte/core';
-/**
- * Query extension: extracts a human-readable title for an SCL element.
- *
- * Default returns the title string. Pass `{ withLabels: true }` to also
- * collect `<Labels>/<Label lang="...">` children (i18n labels); this
- * incurs extra child-record traversal so it is opt-in.
- *
- * Resolution precedence for the title (first non-empty wins):
- * 1. `TITLE_FIELDS_OVERRIDE` spec for the tag (compact or full).
- * 2. `record.value` (XML text body) - handles BayType, IEDName, Val, etc.
- * 3. `DEFINITION.identityFields` fallback (name > id > first), lineage attributes left out.
- * 4. tagName.
- */
-export declare function extractElementTitle(query: Core.Query<Config>, refOrRecord: AnyRefOrRecord, options: ExtractElementTitleOptionsWithLabels): Promise<ElementTitle>;
-export declare function extractElementTitle(query: Core.Query<Config>, refOrRecord: AnyRefOrRecord, options?: ExtractElementTitleOptions): Promise<string>;
-//# sourceMappingURL=extract-element-title.d.ts.map

package/dist/v2019C1/extensions/presentation/query/extract-element-title.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-element-title.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/presentation/query/extract-element-title.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACX,YAAY,EACZ,0BAA0B,EAC1B,oCAAoC,EACpC,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EAAO,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAIpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,WAAW,EAAE,cAAc,EAC3B,OAAO,EAAE,oCAAoC,GAC3C,OAAO,CAAC,YAAY,CAAC,CAAA;AACxB,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,WAAW,EAAE,cAAc,EAC3B,OAAO,CAAC,EAAE,0BAA0B,GAClC,OAAO,CAAC,MAAM,CAAC,CAAA"}

package/dist/v2019C1/extensions/presentation/query/extract-element-title.types.d.ts

@@ -1,24 +0,0 @@
-export type ExtractElementTitleOptions = {
-    mode?: 'compact' | 'full';
-};
-export type ExtractElementTitleOptionsWithLabels = ExtractElementTitleOptions & {
-    withLabels: true;
-};
-/**
- * Rich title payload (returned when `withLabels: true`).
- *
- * - `title` is the engineering identifier computed from override -> text body
- *   -> identityFields -> tagName.
- * - `labels` is a two-level map `[lang][id]` → text:
- *   - outer key: lowercased BCP 47 language tag (e.g. `en`, `en-us`, `fr`).
- *   - inner key: IEC `id` attribute of the `<Label>` element; `''` when absent.
- *   Empty object when no `<Labels>` element is present.
- *
- * Typical UI usage:
- *   const display = labels[currentLang]?.[''] ?? labels.en?.[''] ?? title
- */
-export type ElementTitle = {
-    title: string;
-    labels: Record<string, Record<string, string>>;
-};
-//# sourceMappingURL=extract-element-title.types.d.ts.map

package/dist/v2019C1/extensions/presentation/query/extract-element-title.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-element-title.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/presentation/query/extract-element-title.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,0BAA0B,GAAG;IACxC,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,oCAAoC,GAAG,0BAA0B,GAAG;IAC/E,UAAU,EAAE,IAAI,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC9C,CAAA"}

package/dist/v2019C1/extensions/presentation/query/index.d.ts

@@ -1,3 +0,0 @@
-export { extractElementTitle } from './extract-element-title';
-export type { ElementTitle, ExtractElementTitleOptions, ExtractElementTitleOptionsWithLabels, } from './extract-element-title.types';
-//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/presentation/query/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/presentation/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAC7D,YAAY,EACX,YAAY,EACZ,0BAA0B,EAC1B,oCAAoC,GACpC,MAAM,+BAA+B,CAAA"}

package/dist/v2019C1/extensions/reference/query/build/build-mapped-name.d.ts

@@ -1,22 +0,0 @@
-import { Scl, Config } from '../../../../config';
-import type * as Core from '@dialecte/core';
-/**
- * Compute a `DOS`/`SDS`/`DAS` mapped-name value in its documentation form: the
- * implementing short name, present only when it differs from the specified `name`,
- * otherwise omitted.
- *
- * The implementing element is authored on the record itself
- * (`mappedDoName`/`mappedDaName`), either already short or as a legacy full
- * ObjectReference (`IED/LD/LN.Pos[.stVal]`) collapsed to its short segment(s):
- * - DOS → the DO name; SDS → the SDO name: the last data segment.
- * - DAS → the DA name: the last data segment when the parent DO is mapped, but
- *   `DO.DA` (the implementing DO carried along) when the parent DO is NOT mapped,
- *   so the DA's data object stays documented.
- *
- * The caller applies this only when the DOS/SDS/DAS itself is mapped by uuid; the
- * fully-unmapped LNode case (a full IED ObjectReference) is left intact.
- *
- * @returns the short name to store, or `undefined` to omit (clear) the attribute.
- */
-export declare function buildMappedName<GenericElement extends Scl.ElementsOf>(query: Core.Query<Config>, record: Scl.RawRecord<GenericElement>): Promise<string | undefined>;
-//# sourceMappingURL=build-mapped-name.d.ts.map

package/dist/v2019C1/extensions/reference/query/build/build-mapped-name.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-mapped-name.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/reference/query/build/build-mapped-name.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CAAC,cAAc,SAAS,GAAG,CAAC,UAAU,EAC1E,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,GACnC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAa7B"}

package/dist/v2019C1/hooks/shared/mapped-name.d.ts

@@ -1,15 +0,0 @@
-import { Scl, Config } from '../../config';
-import type * as Core from '@dialecte/core';
-/**
- * Reconcile a `DOS`/`SDS`/`DAS` record's mapped-name attribute
- * (`mappedDoName`/`mappedDaName`) to its documentation form as a side effect of
- * create/update: the implementing short name, present only when it differs from
- * the specified `name`, otherwise omitted.
- *
- * Applies only when the LN is mapped by UUID (`mappedLnUuid` present) — the
- * unmapped-LN case authors a full ObjectReference that dialecte must leave intact.
- * Returns an update operation, or `null` when the record is already conformant or
- * the rule does not apply.
- */
-export declare function reconcileMappedName(query: Core.Query<Config>, record: Scl.RawRecord<Scl.ElementsOf>): Promise<Scl.Operation | null>;
-//# sourceMappingURL=mapped-name.d.ts.map

package/dist/v2019C1/hooks/shared/mapped-name.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mapped-name.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/hooks/shared/mapped-name.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACxC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,GACnC,OAAO,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAiB/B"}