@dialecte/scl 0.3.12 → 0.3.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{hooks-Cm_UYBBt.js → hooks-By65uB-0.js} +1095 -1084
- package/dist/v2019C1/extensions/data-model/transaction/import-types.d.ts.map +1 -1
- package/dist/v2019C1/extensions/identity/transaction/index.d.ts +1 -0
- package/dist/v2019C1/extensions/identity/transaction/index.d.ts.map +1 -1
- package/dist/v2019C1/extensions/identity/transaction/restore-cloned-uuids.d.ts +19 -0
- package/dist/v2019C1/extensions/identity/transaction/restore-cloned-uuids.d.ts.map +1 -0
- package/dist/v2019C1/extensions/lifecycle/contract.types.d.ts +18 -6
- package/dist/v2019C1/extensions/lifecycle/contract.types.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/cross-cutting/clone-applied-satellites.d.ts +1 -1
- package/dist/v2019C1/extensions/lifecycle/engine/diff.d.ts +3 -0
- package/dist/v2019C1/extensions/lifecycle/engine/diff.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/engine/reconcile.d.ts +6 -0
- package/dist/v2019C1/extensions/lifecycle/engine/reconcile.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/extract/transaction/asd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/extract/transaction/fsd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/instance/find-instance.d.ts +5 -0
- package/dist/v2019C1/extensions/lifecycle/instance/find-instance.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/instantiate/transaction/asd.d.ts +2 -2
- package/dist/v2019C1/extensions/lifecycle/instantiate/transaction/asd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/instantiate/transaction/fsd.d.ts +2 -2
- package/dist/v2019C1/extensions/lifecycle/instantiate/transaction/fsd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/layers/application/clone-application.d.ts +2 -1
- package/dist/v2019C1/extensions/lifecycle/layers/application/clone-application.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/layers/function/clone-function.d.ts +4 -2
- package/dist/v2019C1/extensions/lifecycle/layers/function/clone-function.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/report/query/report-fsd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/report/query/report-function.d.ts +3 -0
- package/dist/v2019C1/extensions/lifecycle/report/query/report-function.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/scenario.d.ts +21 -0
- package/dist/v2019C1/extensions/lifecycle/scenario.d.ts.map +1 -0
- package/dist/v2019C1/extensions/lifecycle/transplant/transaction/deep.d.ts +2 -1
- package/dist/v2019C1/extensions/lifecycle/transplant/transaction/deep.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/transplant/transaction/primitives/clone-referenced.d.ts +2 -2
- package/dist/v2019C1/extensions/lifecycle/transplant/transaction/primitives/clone-tree.d.ts +1 -1
- package/dist/v2019C1/extensions/lifecycle/update/transaction/asd.d.ts +1 -1
- package/dist/v2019C1/extensions/lifecycle/update/transaction/asd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/lifecycle/update/transaction/fsd.d.ts +1 -1
- package/dist/v2019C1/extensions/lifecycle/update/transaction/fsd.d.ts.map +1 -1
- package/dist/v2019C1/extensions/reference/transaction/apply-type-id-remap.d.ts +1 -1
- package/dist/v2019C1/extensions/reference/transaction/apply-uuid-remap.d.ts +21 -0
- package/dist/v2019C1/extensions/reference/transaction/apply-uuid-remap.d.ts.map +1 -0
- package/dist/v2019C1/extensions/reference/transaction/index.d.ts +1 -0
- package/dist/v2019C1/extensions/reference/transaction/index.d.ts.map +1 -1
- package/dist/v2019C1/extensions/signature/public.d.ts +1 -1
- package/dist/v2019C1/extensions/signature/public.d.ts.map +1 -1
- package/dist/v2019C1/extensions/signature/query/element-signature.types.d.ts +15 -1
- package/dist/v2019C1/extensions/signature/query/element-signature.types.d.ts.map +1 -1
- package/dist/v2019C1/extensions/signature/query/index.d.ts +1 -1
- package/dist/v2019C1/extensions/signature/query/index.d.ts.map +1 -1
- package/dist/v2019C1/hooks/index.d.ts.map +1 -1
- package/dist/v2019C1/index.js +1 -1
- package/dist/v2019C1/test/fixtures/generate-scl-stress-fixtures.d.ts +13 -0
- package/dist/v2019C1/test/fixtures/generate-scl-stress-fixtures.d.ts.map +1 -0
- package/dist/v2019C1/test/fixtures/run-scl-benchmarks.d.ts +2 -0
- package/dist/v2019C1/test/fixtures/run-scl-benchmarks.d.ts.map +1 -0
- package/dist/v2019C1/test/hydrated-test.d.ts +3 -0
- package/dist/v2019C1/test/hydrated-test.d.ts.map +1 -1
- package/dist/v2019C1/test.js +4 -3
- package/package.json +5 -5
- package/dist/v2019C1/hooks/after-deep-clone/after-deep-clone.d.ts +0 -15
- package/dist/v2019C1/hooks/after-deep-clone/after-deep-clone.d.ts.map +0 -1
- package/dist/v2019C1/hooks/after-deep-clone/index.d.ts +0 -2
- package/dist/v2019C1/hooks/after-deep-clone/index.d.ts.map +0 -1
- package/dist/v2019C1/hooks/after-deep-clone/ref-paths.d.ts +0 -12
- package/dist/v2019C1/hooks/after-deep-clone/ref-paths.d.ts.map +0 -1
|
@@ -24523,6 +24523,7 @@ var c = Object.defineProperty, l = (e, t) => {
|
|
|
24523
24523
|
".scd",
|
|
24524
24524
|
".isd",
|
|
24525
24525
|
".icd",
|
|
24526
|
+
".iid",
|
|
24526
24527
|
".xml"
|
|
24527
24528
|
] }, y = {
|
|
24528
24529
|
recordSchema: {
|
|
@@ -24658,22 +24659,22 @@ async function w(e) {
|
|
|
24658
24659
|
//#endregion
|
|
24659
24660
|
//#region src/v2019C1/extensions/data-model/query/is-lnode-locked.ts
|
|
24660
24661
|
var ee = "None";
|
|
24661
|
-
async function
|
|
24662
|
+
async function te(e, t) {
|
|
24662
24663
|
let n = await e.any.getAttribute(t, { name: "iedName" });
|
|
24663
24664
|
return !!n && n !== ee;
|
|
24664
24665
|
}
|
|
24665
24666
|
//#endregion
|
|
24666
24667
|
//#region src/v2019C1/extensions/data-model/query/index.ts
|
|
24667
|
-
var
|
|
24668
|
-
isLNodeLocked: () =>
|
|
24668
|
+
var ne = /* @__PURE__ */ l({
|
|
24669
|
+
isLNodeLocked: () => te,
|
|
24669
24670
|
resolve: () => S
|
|
24670
24671
|
});
|
|
24671
24672
|
//#endregion
|
|
24672
24673
|
//#region src/v2019C1/extensions/clean-up/transaction/orphan-lnode-bindings.ts
|
|
24673
|
-
async function
|
|
24674
|
+
async function re(e) {
|
|
24674
24675
|
let t = await e.getRecordsByTagName("LNode");
|
|
24675
24676
|
for (let n of t) {
|
|
24676
|
-
if (!await
|
|
24677
|
+
if (!await te(e, n)) {
|
|
24677
24678
|
await e.update(n, { attributes: { iedName: "None" } });
|
|
24678
24679
|
continue;
|
|
24679
24680
|
}
|
|
@@ -24681,10 +24682,10 @@ async function ne(e) {
|
|
|
24681
24682
|
tagName: "IED",
|
|
24682
24683
|
attributes: { name: t }
|
|
24683
24684
|
});
|
|
24684
|
-
r || await
|
|
24685
|
+
r || await ie(e, n);
|
|
24685
24686
|
}
|
|
24686
24687
|
}
|
|
24687
|
-
async function
|
|
24688
|
+
async function ie(e, t) {
|
|
24688
24689
|
let n = await e.getChild(t, "LNodeSpecNaming");
|
|
24689
24690
|
if (n) {
|
|
24690
24691
|
let r = await e.getAttribute(n, { name: "sLnClass" }), i = await e.getAttribute(n, { name: "sLnInst" }), a = await e.getAttribute(n, { name: "sPrefix" });
|
|
@@ -24710,7 +24711,7 @@ async function re(e, t) {
|
|
|
24710
24711
|
}
|
|
24711
24712
|
//#endregion
|
|
24712
24713
|
//#region src/v2019C1/extensions/reference/constants/path-extraction.ts
|
|
24713
|
-
var
|
|
24714
|
+
var ae = {
|
|
24714
24715
|
AccessPoint: { type: "transparent" },
|
|
24715
24716
|
Server: { type: "transparent" },
|
|
24716
24717
|
Private: { type: "transparent" },
|
|
@@ -24790,16 +24791,16 @@ var ie = {
|
|
|
24790
24791
|
PowerSystemRelation: { type: "name" },
|
|
24791
24792
|
Variable: { type: "name" },
|
|
24792
24793
|
Process: { type: "name" }
|
|
24793
|
-
},
|
|
24794
|
+
}, oe = [
|
|
24794
24795
|
"lnClass",
|
|
24795
24796
|
"prefix",
|
|
24796
24797
|
"inst",
|
|
24797
24798
|
"lnInst"
|
|
24798
|
-
],
|
|
24799
|
+
], se = new Set(Object.values(ae).flatMap((e) => {
|
|
24799
24800
|
switch (e.type) {
|
|
24800
24801
|
case "transparent": return [];
|
|
24801
24802
|
case "name": return ["name"];
|
|
24802
|
-
case "lnClass": return [...
|
|
24803
|
+
case "lnClass": return [...oe];
|
|
24803
24804
|
case "attribute": return [e.attr];
|
|
24804
24805
|
case "sourceRef": return [
|
|
24805
24806
|
"input",
|
|
@@ -24811,13 +24812,13 @@ var ie = {
|
|
|
24811
24812
|
}));
|
|
24812
24813
|
//#endregion
|
|
24813
24814
|
//#region src/v2019C1/extensions/reference/query/build/path-segment.ts
|
|
24814
|
-
function
|
|
24815
|
+
function ce(e) {
|
|
24815
24816
|
switch (e.type) {
|
|
24816
24817
|
case "transparent": return () => null;
|
|
24817
24818
|
case "name": {
|
|
24818
24819
|
let t = e.separator ?? "/";
|
|
24819
24820
|
return (e) => {
|
|
24820
|
-
let n =
|
|
24821
|
+
let n = E(e, "name");
|
|
24821
24822
|
return n ? {
|
|
24822
24823
|
segment: n,
|
|
24823
24824
|
separator: t
|
|
@@ -24825,34 +24826,34 @@ function se(e) {
|
|
|
24825
24826
|
};
|
|
24826
24827
|
}
|
|
24827
24828
|
case "lnClass": return (e) => {
|
|
24828
|
-
let t =
|
|
24829
|
+
let t = E(e, "lnClass");
|
|
24829
24830
|
return t ? {
|
|
24830
|
-
segment: `${
|
|
24831
|
+
segment: `${E(e, "prefix") ?? ""}${t}${E(e, "inst") ?? E(e, "lnInst") ?? ""}`,
|
|
24831
24832
|
separator: "/"
|
|
24832
24833
|
} : null;
|
|
24833
24834
|
};
|
|
24834
24835
|
case "attribute": return (t) => {
|
|
24835
|
-
let n =
|
|
24836
|
+
let n = E(t, e.attr);
|
|
24836
24837
|
return n ? {
|
|
24837
24838
|
segment: n,
|
|
24838
24839
|
separator: e.separator
|
|
24839
24840
|
} : null;
|
|
24840
24841
|
};
|
|
24841
24842
|
case "sourceRef": return (e) => {
|
|
24842
|
-
let t =
|
|
24843
|
+
let t = E(e, "input");
|
|
24843
24844
|
if (!t) return null;
|
|
24844
|
-
let n = t, r =
|
|
24845
|
+
let n = t, r = E(e, "inputInst");
|
|
24845
24846
|
r && r !== "1" && (n += `(${r})`);
|
|
24846
|
-
let i =
|
|
24847
|
+
let i = E(e, "pDA");
|
|
24847
24848
|
return i && (n += `.${i}`), {
|
|
24848
24849
|
segment: n,
|
|
24849
24850
|
separator: "."
|
|
24850
24851
|
};
|
|
24851
24852
|
};
|
|
24852
24853
|
case "controlRef": return (e) => {
|
|
24853
|
-
let t =
|
|
24854
|
+
let t = E(e, "output");
|
|
24854
24855
|
if (!t) return null;
|
|
24855
|
-
let n = t, r =
|
|
24856
|
+
let n = t, r = E(e, "outputInst");
|
|
24856
24857
|
return r && r !== "1" && (n += `(${r})`), {
|
|
24857
24858
|
segment: n,
|
|
24858
24859
|
separator: "."
|
|
@@ -24860,15 +24861,15 @@ function se(e) {
|
|
|
24860
24861
|
};
|
|
24861
24862
|
}
|
|
24862
24863
|
}
|
|
24863
|
-
var
|
|
24864
|
-
function
|
|
24865
|
-
let t =
|
|
24864
|
+
var le = Object.fromEntries(Object.entries(ae).map(([e, t]) => [e, ce(t)]));
|
|
24865
|
+
function T(e) {
|
|
24866
|
+
let t = le[e.tagName];
|
|
24866
24867
|
return t ? t(e) : null;
|
|
24867
24868
|
}
|
|
24868
|
-
function
|
|
24869
|
+
function ue(e) {
|
|
24869
24870
|
let { record: t, ancestry: n } = e, r = [];
|
|
24870
24871
|
for (let e of n) {
|
|
24871
|
-
let t =
|
|
24872
|
+
let t = T(e);
|
|
24872
24873
|
t && r.push({
|
|
24873
24874
|
...t,
|
|
24874
24875
|
ref: {
|
|
@@ -24877,7 +24878,7 @@ function le(e) {
|
|
|
24877
24878
|
}
|
|
24878
24879
|
});
|
|
24879
24880
|
}
|
|
24880
|
-
let i =
|
|
24881
|
+
let i = T(t);
|
|
24881
24882
|
return i && r.push({
|
|
24882
24883
|
...i,
|
|
24883
24884
|
ref: {
|
|
@@ -24885,36 +24886,36 @@ function le(e) {
|
|
|
24885
24886
|
id: t.id
|
|
24886
24887
|
}
|
|
24887
24888
|
}), r.length === 0 ? null : {
|
|
24888
|
-
path:
|
|
24889
|
+
path: de(r),
|
|
24889
24890
|
segments: r
|
|
24890
24891
|
};
|
|
24891
24892
|
}
|
|
24892
|
-
function
|
|
24893
|
+
function E(e, t) {
|
|
24893
24894
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
24894
24895
|
}
|
|
24895
|
-
function
|
|
24896
|
+
function de(e) {
|
|
24896
24897
|
let t = e[0].segment;
|
|
24897
24898
|
for (let n = 1; n < e.length; n++) t += e[n].separator + e[n].segment;
|
|
24898
24899
|
return t;
|
|
24899
24900
|
}
|
|
24900
24901
|
//#endregion
|
|
24901
24902
|
//#region src/v2019C1/extensions/reference/query/build/build-element-path.ts
|
|
24902
|
-
async function
|
|
24903
|
+
async function fe(e, t) {
|
|
24903
24904
|
let n = await e.getRecord(t);
|
|
24904
24905
|
if (!n) return null;
|
|
24905
24906
|
let r = i(n);
|
|
24906
|
-
if (!
|
|
24907
|
+
if (!T(r)) {
|
|
24907
24908
|
let e = r.attributes.find((e) => e.name === "uuid")?.value;
|
|
24908
24909
|
return console.warn(`[scl] buildElementPath: no path segment for <${r.tagName}>${e ? ` (uuid ${e})` : ""} — cannot build a path to this element; leaving any existing reference path untouched`), null;
|
|
24909
24910
|
}
|
|
24910
|
-
return
|
|
24911
|
+
return ue({
|
|
24911
24912
|
record: r,
|
|
24912
24913
|
ancestry: (await e.findAncestors(t, { order: "top-down" })).map(i)
|
|
24913
24914
|
});
|
|
24914
24915
|
}
|
|
24915
24916
|
//#endregion
|
|
24916
24917
|
//#region src/v2019C1/constants/reference-pairs.ts
|
|
24917
|
-
var
|
|
24918
|
+
var D = {
|
|
24918
24919
|
AllocationRoleRef: [{
|
|
24919
24920
|
attribute: {
|
|
24920
24921
|
path: "allocationRole",
|
|
@@ -25277,7 +25278,7 @@ var O = {
|
|
|
25277
25278
|
target: ["Variable"],
|
|
25278
25279
|
companions: []
|
|
25279
25280
|
}]
|
|
25280
|
-
},
|
|
25281
|
+
}, O = new Set([
|
|
25281
25282
|
"SourceRef",
|
|
25282
25283
|
"ControlRef",
|
|
25283
25284
|
"DOS",
|
|
@@ -25286,7 +25287,7 @@ var O = {
|
|
|
25286
25287
|
"InputVar",
|
|
25287
25288
|
"OutputVar",
|
|
25288
25289
|
"ProcessEcho"
|
|
25289
|
-
]),
|
|
25290
|
+
]), k = Object.keys(D), A = new Set(k), pe = new Set(Object.values(D).flatMap((e) => e.flatMap((e) => e.target)));
|
|
25290
25291
|
//#endregion
|
|
25291
25292
|
//#region src/v2019C1/extensions/reference/query/resolve/parse-path.ts
|
|
25292
25293
|
function me(e) {
|
|
@@ -25301,7 +25302,7 @@ function me(e) {
|
|
|
25301
25302
|
separator: r
|
|
25302
25303
|
}), t;
|
|
25303
25304
|
}
|
|
25304
|
-
function
|
|
25305
|
+
function he(e) {
|
|
25305
25306
|
let t = e.split("/"), n = t[t.length - 1], r = n.indexOf(".");
|
|
25306
25307
|
if (r === -1) return { path: e };
|
|
25307
25308
|
let i = n.substring(0, r), a = n.substring(r + 1);
|
|
@@ -25310,19 +25311,19 @@ function j(e) {
|
|
|
25310
25311
|
qualifier: a || void 0
|
|
25311
25312
|
};
|
|
25312
25313
|
}
|
|
25313
|
-
function
|
|
25314
|
-
return !e || e === M.unsupported ? null : e === M.direct ? { lookupKey: n } : e === M.iedAddress ?
|
|
25314
|
+
function ge(e, t, n, r) {
|
|
25315
|
+
return !e || e === M.unsupported ? null : e === M.direct ? { lookupKey: n } : e === M.iedAddress ? ve(n, r) : e === M.lnode ? _e(n) : e === M.behaviorDescription ? ye(t, n, r) : null;
|
|
25315
25316
|
}
|
|
25316
|
-
function
|
|
25317
|
-
let { path: t, qualifier: n } =
|
|
25317
|
+
function _e(e) {
|
|
25318
|
+
let { path: t, qualifier: n } = he(e);
|
|
25318
25319
|
return {
|
|
25319
25320
|
lookupKey: t,
|
|
25320
25321
|
qualifier: n
|
|
25321
25322
|
};
|
|
25322
25323
|
}
|
|
25323
|
-
function
|
|
25324
|
+
function ve(e, t) {
|
|
25324
25325
|
if (t) {
|
|
25325
|
-
let n =
|
|
25326
|
+
let n = Se(t);
|
|
25326
25327
|
if (n) return {
|
|
25327
25328
|
lookupKey: e,
|
|
25328
25329
|
fallbackLookupKey: `${n}/${e}`
|
|
@@ -25330,15 +25331,15 @@ function _e(e, t) {
|
|
|
25330
25331
|
}
|
|
25331
25332
|
return { lookupKey: e };
|
|
25332
25333
|
}
|
|
25333
|
-
function
|
|
25334
|
+
function ye(e, t, n) {
|
|
25334
25335
|
if (!n) return null;
|
|
25335
|
-
let r =
|
|
25336
|
+
let r = be(n);
|
|
25336
25337
|
return r ? e === "dataName" ? {
|
|
25337
25338
|
lookupKey: r,
|
|
25338
25339
|
qualifier: t
|
|
25339
|
-
} : e === "inputName" || e === "outputName" ? { lookupKey: `${r}.${
|
|
25340
|
+
} : e === "inputName" || e === "outputName" ? { lookupKey: `${r}.${xe(t)}` } : null : null;
|
|
25340
25341
|
}
|
|
25341
|
-
function
|
|
25342
|
+
function be(e) {
|
|
25342
25343
|
let t = -1;
|
|
25343
25344
|
for (let n = e.length - 1; n >= 0; n--) if (e[n].tagName === "BehaviorDescription") {
|
|
25344
25345
|
t = n;
|
|
@@ -25347,22 +25348,22 @@ function ye(e) {
|
|
|
25347
25348
|
if (t === -1) return null;
|
|
25348
25349
|
let n = [];
|
|
25349
25350
|
for (let r = 0; r < t; r++) {
|
|
25350
|
-
let t =
|
|
25351
|
+
let t = T(e[r]);
|
|
25351
25352
|
t && n.push(t);
|
|
25352
25353
|
}
|
|
25353
|
-
return n.length === 0 ? null :
|
|
25354
|
+
return n.length === 0 ? null : de(n);
|
|
25354
25355
|
}
|
|
25355
|
-
function
|
|
25356
|
+
function xe(e) {
|
|
25356
25357
|
let t = e.indexOf("("), n = e.indexOf(".");
|
|
25357
25358
|
return t === -1 ? n === -1 ? e : e.substring(0, n) : e.substring(0, t);
|
|
25358
25359
|
}
|
|
25359
|
-
function
|
|
25360
|
+
function Se(e) {
|
|
25360
25361
|
for (let t = e.length - 1; t >= 0; t--) if (e[t].tagName === "LNode") return e[t].attributes.find((e) => e.name === "iedName")?.value ?? null;
|
|
25361
25362
|
return null;
|
|
25362
25363
|
}
|
|
25363
25364
|
//#endregion
|
|
25364
25365
|
//#region src/v2019C1/extensions/reference/query/build/build-reference-path.ts
|
|
25365
|
-
async function
|
|
25366
|
+
async function j(e, t) {
|
|
25366
25367
|
let { reference: n, target: r } = t;
|
|
25367
25368
|
if (P.has(n.tagName)) return null;
|
|
25368
25369
|
let a = Te(n.tagName, r.tagName);
|
|
@@ -25370,9 +25371,9 @@ async function Se(e, t) {
|
|
|
25370
25371
|
let o = a.resolution;
|
|
25371
25372
|
if (o === M.behaviorDescription) {
|
|
25372
25373
|
let t = await e.getRecord(r);
|
|
25373
|
-
return t ?
|
|
25374
|
+
return t ? T(i(t))?.segment ?? null : null;
|
|
25374
25375
|
}
|
|
25375
|
-
let s = await
|
|
25376
|
+
let s = await fe(e, r);
|
|
25376
25377
|
if (!s) return null;
|
|
25377
25378
|
let c = s.path;
|
|
25378
25379
|
if (o === M.lnode) {
|
|
@@ -25393,10 +25394,10 @@ function Ce(e, t) {
|
|
|
25393
25394
|
}
|
|
25394
25395
|
function we(e, t) {
|
|
25395
25396
|
let n = e.attributes.find((e) => e.name === t.attribute.path)?.value;
|
|
25396
|
-
if (n) return
|
|
25397
|
+
if (n) return he(n).qualifier;
|
|
25397
25398
|
}
|
|
25398
25399
|
function Te(e, t) {
|
|
25399
|
-
let n =
|
|
25400
|
+
let n = D[e];
|
|
25400
25401
|
return n ? n.find((e) => e.target.includes(t)) ?? null : null;
|
|
25401
25402
|
}
|
|
25402
25403
|
//#endregion
|
|
@@ -25500,15 +25501,15 @@ function Oe(e) {
|
|
|
25500
25501
|
}
|
|
25501
25502
|
//#endregion
|
|
25502
25503
|
//#region src/v2019C1/extensions/reference/constants/derived.ts
|
|
25503
|
-
var ke = Ee(
|
|
25504
|
+
var ke = Ee(D), Ae = [
|
|
25504
25505
|
M.direct,
|
|
25505
25506
|
M.lnode,
|
|
25506
25507
|
M.iedAddress,
|
|
25507
25508
|
M.behaviorDescription
|
|
25508
|
-
], je = [...Ae, M.unsupported], Me = De(
|
|
25509
|
+
], je = [...Ae, M.unsupported], Me = De(D), P = new Map(Object.entries(D).flatMap(([e, t]) => t.filter((e) => e.attribute.path === "mappedDoName" || e.attribute.path === "mappedDaName").map((t) => [e, {
|
|
25509
25510
|
path: t.attribute.path,
|
|
25510
25511
|
uuid: t.attribute.uuid
|
|
25511
|
-
}]))), Ne = [...new Set(Object.values(
|
|
25512
|
+
}]))), Ne = [...new Set(Object.values(D).flatMap((e) => e.map((e) => e.attribute.uuid)))], F = new Map(Object.entries(N).map(([e, t]) => [e, [...new Set(t.map((e) => e.attribute))]])), Pe = Oe(N), Fe = new Set(Pe.keys()), Ie = new Set([..._.LNode?.attributes?.identityFields ?? [], ...F.get("LNode") ?? []]), Le = {
|
|
25512
25513
|
FunctionCatRef: ["SubCategory", "FunctionCategory"],
|
|
25513
25514
|
PowerSystemRelation: ["PowerSystemRelations"],
|
|
25514
25515
|
Resource: ["ProcessResource", "ProcessResources"],
|
|
@@ -25516,22 +25517,22 @@ var ke = Ee(O), Ae = [
|
|
|
25516
25517
|
};
|
|
25517
25518
|
//#endregion
|
|
25518
25519
|
//#region src/v2019C1/extensions/reference/query/build/build-mapped-name.ts
|
|
25519
|
-
async function
|
|
25520
|
+
async function Re(e, t) {
|
|
25520
25521
|
let n = P.get(t.tagName);
|
|
25521
25522
|
if (!n) return;
|
|
25522
25523
|
let r = t.attributes.find((e) => e.name === "name")?.value;
|
|
25523
25524
|
if (!r) return;
|
|
25524
|
-
let i = t.attributes.find((e) => e.name === n.path)?.value, a =
|
|
25525
|
+
let i = t.attributes.find((e) => e.name === n.path)?.value, a = ze(i, t.tagName === "DAS" && !await Be(e, t)) ?? r;
|
|
25525
25526
|
return a === r ? void 0 : a;
|
|
25526
25527
|
}
|
|
25527
|
-
function
|
|
25528
|
+
function ze(e, t) {
|
|
25528
25529
|
if (!e) return;
|
|
25529
|
-
let { path: n, qualifier: r } =
|
|
25530
|
+
let { path: n, qualifier: r } = he(e), i = r ?? n;
|
|
25530
25531
|
if (t) return i || void 0;
|
|
25531
25532
|
let a = i.split(".");
|
|
25532
25533
|
return a[a.length - 1] || void 0;
|
|
25533
25534
|
}
|
|
25534
|
-
async function
|
|
25535
|
+
async function Be(e, t) {
|
|
25535
25536
|
let n = (await e.findAncestors(t)).find((e) => e.tagName === "DOS" || e.tagName === "SDS");
|
|
25536
25537
|
return n ? !!await e.getAttribute({
|
|
25537
25538
|
tagName: n.tagName,
|
|
@@ -25540,32 +25541,32 @@ async function Ve(e, t) {
|
|
|
25540
25541
|
}
|
|
25541
25542
|
//#endregion
|
|
25542
25543
|
//#region src/v2019C1/extensions/reference/query/build/build-mapped-lnode-path.ts
|
|
25543
|
-
function
|
|
25544
|
+
function Ve(e) {
|
|
25544
25545
|
let t = e.iedName;
|
|
25545
|
-
if (!t || t ===
|
|
25546
|
+
if (!t || t === He) return null;
|
|
25546
25547
|
let n = e.ldInst, r = e.lnClass;
|
|
25547
25548
|
return !n || !r ? null : `${t}/${n}/${`${e.prefix ?? ""}${r}${e.lnInst ?? ""}`}`;
|
|
25548
25549
|
}
|
|
25549
|
-
var
|
|
25550
|
+
var He = "None";
|
|
25550
25551
|
//#endregion
|
|
25551
25552
|
//#region src/v2019C1/extensions/reference/query/resolve/resolve-reference-path.ts
|
|
25552
|
-
async function
|
|
25553
|
-
let r =
|
|
25553
|
+
async function Ue(e, t, n) {
|
|
25554
|
+
let r = We(t.tagName, n);
|
|
25554
25555
|
if (!r) return;
|
|
25555
25556
|
let a = t.attributes.find((e) => e.name === n)?.value;
|
|
25556
25557
|
if (!a) return;
|
|
25557
|
-
let o = await
|
|
25558
|
+
let o = await Ge(e, t, r);
|
|
25558
25559
|
if (o) return {
|
|
25559
25560
|
record: o,
|
|
25560
|
-
qualifier:
|
|
25561
|
+
qualifier: Ke(r, n, a)
|
|
25561
25562
|
};
|
|
25562
25563
|
let s;
|
|
25563
25564
|
(r.resolution === M.behaviorDescription || r.resolution === M.iedAddress) && (s = (await e.findAncestors(t, { order: "top-down" })).map((e) => i(e)));
|
|
25564
|
-
let c =
|
|
25565
|
+
let c = ge(r.resolution, n, a, s);
|
|
25565
25566
|
if (!c) return;
|
|
25566
25567
|
let l = me(c.lookupKey);
|
|
25567
25568
|
if (l.length === 0) return;
|
|
25568
|
-
let u = l[l.length - 1], d = l.slice(0, -1), f = await
|
|
25569
|
+
let u = l[l.length - 1], d = l.slice(0, -1), f = await Xe({
|
|
25569
25570
|
query: e,
|
|
25570
25571
|
targets: r.target,
|
|
25571
25572
|
segment: u,
|
|
@@ -25576,11 +25577,11 @@ async function We(e, t, n) {
|
|
|
25576
25577
|
qualifier: c.qualifier
|
|
25577
25578
|
};
|
|
25578
25579
|
}
|
|
25579
|
-
function
|
|
25580
|
-
let n =
|
|
25580
|
+
function We(e, t) {
|
|
25581
|
+
let n = D[e];
|
|
25581
25582
|
if (n) return n.find((e) => e.attribute.path === t);
|
|
25582
25583
|
}
|
|
25583
|
-
async function
|
|
25584
|
+
async function Ge(e, t, n) {
|
|
25584
25585
|
let r = n.attribute.uuid, i = t.attributes.find((e) => e.name === r)?.value;
|
|
25585
25586
|
if (i) for (let t of n.target) {
|
|
25586
25587
|
let n = await e.findByAttributes({
|
|
@@ -25590,19 +25591,19 @@ async function Ke(e, t, n) {
|
|
|
25590
25591
|
if (n.length > 0) return n[0];
|
|
25591
25592
|
}
|
|
25592
25593
|
}
|
|
25593
|
-
function
|
|
25594
|
-
if (e.resolution === M.lnode) return
|
|
25594
|
+
function Ke(e, t, n) {
|
|
25595
|
+
if (e.resolution === M.lnode) return he(n).qualifier;
|
|
25595
25596
|
if (e.resolution === M.behaviorDescription && t === "dataName") return n;
|
|
25596
25597
|
}
|
|
25597
|
-
var
|
|
25598
|
+
var qe = new Set(_.LNode.attributes.details.lnClass.facets.enumeration), Je = {
|
|
25598
25599
|
LNode: "lnInst",
|
|
25599
25600
|
LN: "inst",
|
|
25600
25601
|
LN0: "inst"
|
|
25601
25602
|
};
|
|
25602
|
-
function
|
|
25603
|
+
function Ye(e) {
|
|
25603
25604
|
for (let t = 0; t <= e.length - 4; t++) {
|
|
25604
25605
|
let n = e.substring(t, t + 4);
|
|
25605
|
-
if (
|
|
25606
|
+
if (qe.has(n)) return {
|
|
25606
25607
|
prefix: e.substring(0, t),
|
|
25607
25608
|
lnClass: n,
|
|
25608
25609
|
inst: e.substring(t + 4)
|
|
@@ -25610,12 +25611,12 @@ function Xe(e) {
|
|
|
25610
25611
|
}
|
|
25611
25612
|
return null;
|
|
25612
25613
|
}
|
|
25613
|
-
async function
|
|
25614
|
+
async function Xe(e) {
|
|
25614
25615
|
let { query: t, targets: n, segment: r, expectedAncestry: i } = e;
|
|
25615
25616
|
for (let e of n) {
|
|
25616
|
-
let n =
|
|
25617
|
+
let n = Je[e];
|
|
25617
25618
|
if (n) {
|
|
25618
|
-
let a = await
|
|
25619
|
+
let a = await Ze({
|
|
25619
25620
|
query: t,
|
|
25620
25621
|
tagName: e,
|
|
25621
25622
|
segment: r,
|
|
@@ -25624,7 +25625,7 @@ async function Ze(e) {
|
|
|
25624
25625
|
});
|
|
25625
25626
|
if (a) return a;
|
|
25626
25627
|
} else {
|
|
25627
|
-
let n = await
|
|
25628
|
+
let n = await Qe({
|
|
25628
25629
|
query: t,
|
|
25629
25630
|
tagName: e,
|
|
25630
25631
|
segment: r,
|
|
@@ -25634,8 +25635,8 @@ async function Ze(e) {
|
|
|
25634
25635
|
}
|
|
25635
25636
|
}
|
|
25636
25637
|
}
|
|
25637
|
-
async function
|
|
25638
|
-
let { query: t, tagName: n, segment: r, instAttr: i, expectedAncestry: a } = e, o =
|
|
25638
|
+
async function Ze(e) {
|
|
25639
|
+
let { query: t, tagName: n, segment: r, instAttr: i, expectedAncestry: a } = e, o = Ye(r.segment);
|
|
25639
25640
|
if (!o) return;
|
|
25640
25641
|
let s = await t.findByAttributes({
|
|
25641
25642
|
tagName: n,
|
|
@@ -25643,37 +25644,37 @@ async function Qe(e) {
|
|
|
25643
25644
|
});
|
|
25644
25645
|
for (let e of s) {
|
|
25645
25646
|
let n = e.attributes.find((e) => e.name === "prefix")?.value ?? "", r = e.attributes.find((e) => e.name === i)?.value ?? "";
|
|
25646
|
-
if (!(n !== o.prefix || r !== o.inst) && await
|
|
25647
|
+
if (!(n !== o.prefix || r !== o.inst) && await $e(t, e, a)) return e;
|
|
25647
25648
|
}
|
|
25648
25649
|
}
|
|
25649
|
-
async function
|
|
25650
|
+
async function Qe(e) {
|
|
25650
25651
|
let { query: t, tagName: n, segment: r, expectedAncestry: a } = e, o = await t.getRecordsByTagName(n);
|
|
25651
25652
|
for (let e of o) {
|
|
25652
|
-
let n =
|
|
25653
|
-
if (!(!n || n.segment !== r.segment) && await
|
|
25653
|
+
let n = T(i(e));
|
|
25654
|
+
if (!(!n || n.segment !== r.segment) && await $e(t, e, a)) return e;
|
|
25654
25655
|
}
|
|
25655
25656
|
}
|
|
25656
|
-
async function
|
|
25657
|
+
async function $e(e, t, n) {
|
|
25657
25658
|
if (n.length === 0) return !0;
|
|
25658
25659
|
let r = await e.findAncestors(t), a = [];
|
|
25659
25660
|
for (let e = r.length - 1; e >= 0; e--) {
|
|
25660
|
-
let t =
|
|
25661
|
+
let t = T(i(r[e]));
|
|
25661
25662
|
t && a.push(t);
|
|
25662
25663
|
}
|
|
25663
25664
|
return a.length === n.length ? a.every((e, t) => e.segment === n[t].segment) : !1;
|
|
25664
25665
|
}
|
|
25665
25666
|
//#endregion
|
|
25666
25667
|
//#region src/v2019C1/extensions/reference/query/resolve/resolve-element-path.ts
|
|
25667
|
-
async function
|
|
25668
|
+
async function et(e, t) {
|
|
25668
25669
|
let n = me(t);
|
|
25669
|
-
if (n.length !== 0) return
|
|
25670
|
+
if (n.length !== 0) return tt({
|
|
25670
25671
|
query: e,
|
|
25671
25672
|
current: await e.getRoot(),
|
|
25672
25673
|
segments: n,
|
|
25673
25674
|
index: 0
|
|
25674
25675
|
});
|
|
25675
25676
|
}
|
|
25676
|
-
async function
|
|
25677
|
+
async function tt(e) {
|
|
25677
25678
|
let { query: t, current: n, segments: r, index: a } = e;
|
|
25678
25679
|
if (a >= r.length) return n;
|
|
25679
25680
|
let o = n.children ?? [];
|
|
@@ -25681,9 +25682,9 @@ async function nt(e) {
|
|
|
25681
25682
|
let s = await t.getRecords(o), c = r[a];
|
|
25682
25683
|
for (let e of s) {
|
|
25683
25684
|
if (!e) continue;
|
|
25684
|
-
let n =
|
|
25685
|
+
let n = T(i(e));
|
|
25685
25686
|
if (!n) {
|
|
25686
|
-
let n = await
|
|
25687
|
+
let n = await tt({
|
|
25687
25688
|
query: t,
|
|
25688
25689
|
current: e,
|
|
25689
25690
|
segments: r,
|
|
@@ -25693,7 +25694,7 @@ async function nt(e) {
|
|
|
25693
25694
|
continue;
|
|
25694
25695
|
}
|
|
25695
25696
|
if (n.segment === c.segment && n.separator === c.separator) {
|
|
25696
|
-
let n = await
|
|
25697
|
+
let n = await tt({
|
|
25697
25698
|
query: t,
|
|
25698
25699
|
current: e,
|
|
25699
25700
|
segments: r,
|
|
@@ -25706,14 +25707,14 @@ async function nt(e) {
|
|
|
25706
25707
|
}
|
|
25707
25708
|
//#endregion
|
|
25708
25709
|
//#region src/v2019C1/extensions/reference/query/resolve/resolve-mapped-lnode.ts
|
|
25709
|
-
var
|
|
25710
|
-
async function
|
|
25711
|
-
let n =
|
|
25710
|
+
var nt = new Set(["LN", "LN0"]);
|
|
25711
|
+
async function rt(e, t) {
|
|
25712
|
+
let n = Ve(it(t));
|
|
25712
25713
|
if (!n) return;
|
|
25713
|
-
let r = await
|
|
25714
|
-
if (!(!r || !
|
|
25714
|
+
let r = await et(e, n);
|
|
25715
|
+
if (!(!r || !nt.has(r.tagName))) return r;
|
|
25715
25716
|
}
|
|
25716
|
-
function
|
|
25717
|
+
function it(e) {
|
|
25717
25718
|
let t = (t) => e.attributes.find((e) => e.name === t)?.value;
|
|
25718
25719
|
return {
|
|
25719
25720
|
iedName: t("iedName"),
|
|
@@ -25725,19 +25726,19 @@ function at(e) {
|
|
|
25725
25726
|
}
|
|
25726
25727
|
//#endregion
|
|
25727
25728
|
//#region src/v2019C1/extensions/reference/guards.ts
|
|
25728
|
-
function
|
|
25729
|
-
return
|
|
25729
|
+
function at(e) {
|
|
25730
|
+
return Fe.has(e);
|
|
25730
25731
|
}
|
|
25731
25732
|
//#endregion
|
|
25732
25733
|
//#region src/v2019C1/extensions/reference/query/find/find-refs-pointing-to.ts
|
|
25733
|
-
async function
|
|
25734
|
+
async function I(e, t) {
|
|
25734
25735
|
let { target: n, containerTagName: r } = t, i = await e.getRecord(n);
|
|
25735
|
-
return i ?
|
|
25736
|
+
return i ? at(i.tagName) ? st(e, i, r) : ot(e, i, r) : [];
|
|
25736
25737
|
}
|
|
25737
|
-
async function
|
|
25738
|
+
async function ot(e, t, r) {
|
|
25738
25739
|
let i = t.attributes.find((e) => e.name === "uuid")?.value;
|
|
25739
25740
|
if (!i) return [];
|
|
25740
|
-
let a =
|
|
25741
|
+
let a = lt(t.tagName);
|
|
25741
25742
|
if (a.length === 0) return [];
|
|
25742
25743
|
let o = [];
|
|
25743
25744
|
for (let t of a) {
|
|
@@ -25747,7 +25748,7 @@ async function st(e, t, r) {
|
|
|
25747
25748
|
attributes: { [t.uuidAttr]: i }
|
|
25748
25749
|
});
|
|
25749
25750
|
for (let t of a) {
|
|
25750
|
-
let n = r ? await
|
|
25751
|
+
let n = r ? await ut(e, t, r) : void 0;
|
|
25751
25752
|
o.push({
|
|
25752
25753
|
ref: t,
|
|
25753
25754
|
container: n
|
|
@@ -25756,10 +25757,10 @@ async function st(e, t, r) {
|
|
|
25756
25757
|
}
|
|
25757
25758
|
return o;
|
|
25758
25759
|
}
|
|
25759
|
-
async function
|
|
25760
|
+
async function st(e, t, r) {
|
|
25760
25761
|
let i = t.attributes.find((e) => e.name === "id")?.value;
|
|
25761
25762
|
if (!i) return [];
|
|
25762
|
-
let a =
|
|
25763
|
+
let a = Pe.get(t.tagName) ?? [], o = [];
|
|
25763
25764
|
for (let t of a) {
|
|
25764
25765
|
if (!n(t.refTagName, x)) continue;
|
|
25765
25766
|
let a = await e.findByAttributes({
|
|
@@ -25767,8 +25768,8 @@ async function ct(e, t, r) {
|
|
|
25767
25768
|
attributes: { [t.attribute]: i }
|
|
25768
25769
|
});
|
|
25769
25770
|
for (let n of a) {
|
|
25770
|
-
if (!
|
|
25771
|
-
let i = r ? await
|
|
25771
|
+
if (!ct(n, t)) continue;
|
|
25772
|
+
let i = r ? await ut(e, n, r) : void 0;
|
|
25772
25773
|
o.push({
|
|
25773
25774
|
ref: n,
|
|
25774
25775
|
container: i
|
|
@@ -25777,10 +25778,10 @@ async function ct(e, t, r) {
|
|
|
25777
25778
|
}
|
|
25778
25779
|
return o;
|
|
25779
25780
|
}
|
|
25780
|
-
function
|
|
25781
|
+
function ct(e, t) {
|
|
25781
25782
|
return t.when ? e.attributes.find((e) => e.name === t.when.attribute)?.value === t.when.equals : !0;
|
|
25782
25783
|
}
|
|
25783
|
-
function
|
|
25784
|
+
function lt(e) {
|
|
25784
25785
|
let t = [];
|
|
25785
25786
|
for (let n of je) {
|
|
25786
25787
|
let r = ke[n]?.get(e);
|
|
@@ -25788,12 +25789,12 @@ function ut(e) {
|
|
|
25788
25789
|
}
|
|
25789
25790
|
return t;
|
|
25790
25791
|
}
|
|
25791
|
-
async function
|
|
25792
|
+
async function ut(e, t, n) {
|
|
25792
25793
|
return (await e.findAncestors(t, { stopAtTagName: n })).find((e) => e.tagName === n);
|
|
25793
25794
|
}
|
|
25794
25795
|
//#endregion
|
|
25795
25796
|
//#region src/v2019C1/extensions/reference/query/provenance/get-provenance.constants.ts
|
|
25796
|
-
var
|
|
25797
|
+
var dt = {
|
|
25797
25798
|
Application: "application",
|
|
25798
25799
|
Function: "function",
|
|
25799
25800
|
SubFunction: "function",
|
|
@@ -25804,10 +25805,10 @@ var ft = {
|
|
|
25804
25805
|
};
|
|
25805
25806
|
//#endregion
|
|
25806
25807
|
//#region src/v2019C1/extensions/reference/query/provenance/get-provenance.ts
|
|
25807
|
-
async function
|
|
25808
|
+
async function ft(e) {
|
|
25808
25809
|
let t = await e.getRecordsByTagName("SclFileReference"), n = [];
|
|
25809
25810
|
for (let r of t) {
|
|
25810
|
-
let t = await
|
|
25811
|
+
let t = await pt(e, r);
|
|
25811
25812
|
if (!t) continue;
|
|
25812
25813
|
let { fileType: i, fileUuid: a, fileName: o, version: s, revision: c } = await e.getAttributes(r);
|
|
25813
25814
|
n.push({
|
|
@@ -25821,17 +25822,17 @@ async function pt(e) {
|
|
|
25821
25822
|
}
|
|
25822
25823
|
return n;
|
|
25823
25824
|
}
|
|
25824
|
-
async function
|
|
25825
|
+
async function pt(e, t) {
|
|
25825
25826
|
let n = await e.findAncestors(t);
|
|
25826
25827
|
for (let e of n) {
|
|
25827
|
-
let t =
|
|
25828
|
+
let t = dt[e.tagName];
|
|
25828
25829
|
if (t) return {
|
|
25829
25830
|
kind: t,
|
|
25830
|
-
ref:
|
|
25831
|
+
ref: mt(e.tagName, e.id)
|
|
25831
25832
|
};
|
|
25832
25833
|
}
|
|
25833
25834
|
}
|
|
25834
|
-
function
|
|
25835
|
+
function mt(e, t) {
|
|
25835
25836
|
return {
|
|
25836
25837
|
tagName: e,
|
|
25837
25838
|
id: t
|
|
@@ -25839,23 +25840,23 @@ function ht(e, t) {
|
|
|
25839
25840
|
}
|
|
25840
25841
|
//#endregion
|
|
25841
25842
|
//#region src/v2019C1/extensions/reference/query/index.ts
|
|
25842
|
-
var
|
|
25843
|
-
buildElementPath: () =>
|
|
25844
|
-
buildMappedLNodePath: () =>
|
|
25845
|
-
buildMappedName: () =>
|
|
25846
|
-
buildReferencePath: () =>
|
|
25847
|
-
findRefsPointingTo: () =>
|
|
25848
|
-
getProvenance: () =>
|
|
25849
|
-
resolveElementPath: () =>
|
|
25850
|
-
resolveMappedLNode: () =>
|
|
25851
|
-
resolveReferencePath: () =>
|
|
25843
|
+
var ht = /* @__PURE__ */ l({
|
|
25844
|
+
buildElementPath: () => fe,
|
|
25845
|
+
buildMappedLNodePath: () => Ve,
|
|
25846
|
+
buildMappedName: () => Re,
|
|
25847
|
+
buildReferencePath: () => j,
|
|
25848
|
+
findRefsPointingTo: () => I,
|
|
25849
|
+
getProvenance: () => ft,
|
|
25850
|
+
resolveElementPath: () => et,
|
|
25851
|
+
resolveMappedLNode: () => rt,
|
|
25852
|
+
resolveReferencePath: () => Ue
|
|
25852
25853
|
});
|
|
25853
25854
|
//#endregion
|
|
25854
25855
|
//#region src/v2019C1/extensions/reference/transaction/apply-type-id-remap.ts
|
|
25855
|
-
async function
|
|
25856
|
+
async function L(e, t) {
|
|
25856
25857
|
let { records: n, idRemap: r } = t;
|
|
25857
25858
|
if (r.size !== 0) for (let t of n) {
|
|
25858
|
-
let n =
|
|
25859
|
+
let n = F.get(t.tagName);
|
|
25859
25860
|
if (!n) continue;
|
|
25860
25861
|
let i = await e.getRecord(t);
|
|
25861
25862
|
if (!i) continue;
|
|
@@ -25870,13 +25871,56 @@ async function _t(e, t) {
|
|
|
25870
25871
|
}
|
|
25871
25872
|
}
|
|
25872
25873
|
//#endregion
|
|
25874
|
+
//#region src/v2019C1/extensions/reference/transaction/apply-uuid-remap.ts
|
|
25875
|
+
async function R(e, t) {
|
|
25876
|
+
let { mappings: n } = t;
|
|
25877
|
+
if (n.length === 0) return;
|
|
25878
|
+
let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
|
|
25879
|
+
for (let { source: t, target: a } of n) {
|
|
25880
|
+
let n = t.attributes.find((e) => e.name === "uuid")?.value;
|
|
25881
|
+
if (!n) continue;
|
|
25882
|
+
let o = await e.getRecord(a), s = o?.attributes.find((e) => e.name === "uuid")?.value;
|
|
25883
|
+
s && (r.set(n, s), i.set(s, {
|
|
25884
|
+
tagName: o.tagName,
|
|
25885
|
+
id: o.id
|
|
25886
|
+
}));
|
|
25887
|
+
}
|
|
25888
|
+
if (r.size !== 0) for (let { target: t } of n) {
|
|
25889
|
+
if (!(t.tagName in D)) continue;
|
|
25890
|
+
let n = await e.getRecord(t);
|
|
25891
|
+
if (!n) continue;
|
|
25892
|
+
let a = D[t.tagName], o = {};
|
|
25893
|
+
for (let s of a) {
|
|
25894
|
+
let a = n.attributes.find((e) => e.name === s.attribute.uuid)?.value;
|
|
25895
|
+
if (!a) continue;
|
|
25896
|
+
let c = r.get(a);
|
|
25897
|
+
if (!c || c === a) continue;
|
|
25898
|
+
o[s.attribute.uuid] = c;
|
|
25899
|
+
let l = i.get(c);
|
|
25900
|
+
if (!l) continue;
|
|
25901
|
+
let u = await j(e, {
|
|
25902
|
+
reference: {
|
|
25903
|
+
tagName: t.tagName,
|
|
25904
|
+
id: n.id
|
|
25905
|
+
},
|
|
25906
|
+
target: {
|
|
25907
|
+
tagName: l.tagName,
|
|
25908
|
+
id: l.id
|
|
25909
|
+
}
|
|
25910
|
+
}), d = n.attributes.find((e) => e.name === s.attribute.path)?.value;
|
|
25911
|
+
u && u !== d && (o[s.attribute.path] = u);
|
|
25912
|
+
}
|
|
25913
|
+
Object.keys(o).length > 0 && await e.update(n, { attributes: o });
|
|
25914
|
+
}
|
|
25915
|
+
}
|
|
25916
|
+
//#endregion
|
|
25873
25917
|
//#region src/v2019C1/extensions/reference/transaction/write-provenance.ts
|
|
25874
|
-
var
|
|
25918
|
+
var gt = {
|
|
25875
25919
|
FSD: "FunctionSclRef",
|
|
25876
25920
|
ASD: "ApplicationSclRef"
|
|
25877
25921
|
};
|
|
25878
|
-
async function
|
|
25879
|
-
let { sourceQuery: n, targetRoot: r, fileType: i } = t, [a] = await n.getRecordsByTagName("Header"), o = a ? await n.getAttributes(a) : void 0, s = await e.addChild(r, { tagName:
|
|
25922
|
+
async function _t(e, t) {
|
|
25923
|
+
let { sourceQuery: n, targetRoot: r, fileType: i } = t, [a] = await n.getRecordsByTagName("Header"), o = a ? await n.getAttributes(a) : void 0, s = await e.addChild(r, { tagName: gt[i] }), { name: c } = await n.getDocumentInfo();
|
|
25880
25924
|
await e.addChild(s, {
|
|
25881
25925
|
tagName: "SclFileReference",
|
|
25882
25926
|
attributes: {
|
|
@@ -25890,17 +25934,18 @@ async function yt(e, t) {
|
|
|
25890
25934
|
}
|
|
25891
25935
|
//#endregion
|
|
25892
25936
|
//#region src/v2019C1/extensions/reference/index.ts
|
|
25893
|
-
var
|
|
25894
|
-
query:
|
|
25937
|
+
var z = {
|
|
25938
|
+
query: ht,
|
|
25895
25939
|
transaction: /* @__PURE__ */ l({
|
|
25896
|
-
applyTypeIdRemap: () =>
|
|
25897
|
-
|
|
25940
|
+
applyTypeIdRemap: () => L,
|
|
25941
|
+
applyUuidRemap: () => R,
|
|
25942
|
+
writeProvenance: () => _t
|
|
25898
25943
|
})
|
|
25899
25944
|
};
|
|
25900
25945
|
//#endregion
|
|
25901
25946
|
//#region src/v2019C1/extensions/clean-up/transaction/prune-empty-containers.ts
|
|
25902
|
-
async function
|
|
25903
|
-
let t = [...Object.values(
|
|
25947
|
+
async function vt(e) {
|
|
25948
|
+
let t = [...Object.values(Le).flat(), "Private"];
|
|
25904
25949
|
for (let n of t) {
|
|
25905
25950
|
let t = await e.getRecordsByTagName(n);
|
|
25906
25951
|
for (let n of t) n.children.length === 0 && await e.delete(n);
|
|
@@ -25908,26 +25953,26 @@ async function bt(e) {
|
|
|
25908
25953
|
}
|
|
25909
25954
|
//#endregion
|
|
25910
25955
|
//#region src/v2019C1/extensions/clean-up/transaction/orphan-uuid-refs.ts
|
|
25911
|
-
async function
|
|
25912
|
-
for (let t of
|
|
25913
|
-
let n =
|
|
25956
|
+
async function yt(e) {
|
|
25957
|
+
for (let t of k) {
|
|
25958
|
+
let n = D[t], r = await e.getRecordsByTagName(t);
|
|
25914
25959
|
for (let i of r) {
|
|
25915
25960
|
let r = !1, a = !1, o = {};
|
|
25916
25961
|
for (let t of n) {
|
|
25917
25962
|
let n = await e.getAttribute(i, { name: t.attribute.uuid });
|
|
25918
|
-
if (n) if (r = !0, await
|
|
25963
|
+
if (n) if (r = !0, await bt(e, n, t.target)) a = !0;
|
|
25919
25964
|
else {
|
|
25920
25965
|
o[t.attribute.uuid] = void 0, o[t.attribute.path] = void 0;
|
|
25921
25966
|
for (let e of t.companions) o[e.name] = void 0;
|
|
25922
25967
|
}
|
|
25923
25968
|
}
|
|
25924
25969
|
Object.keys(o).length > 0 && await e.update(i, { attributes: o });
|
|
25925
|
-
let s =
|
|
25970
|
+
let s = O.has(t);
|
|
25926
25971
|
r && !a && !s && await e.delete(i);
|
|
25927
25972
|
}
|
|
25928
25973
|
}
|
|
25929
25974
|
}
|
|
25930
|
-
async function
|
|
25975
|
+
async function bt(e, t, n) {
|
|
25931
25976
|
for (let r of n) {
|
|
25932
25977
|
let [n] = await e.findByAttributes({
|
|
25933
25978
|
tagName: r,
|
|
@@ -25939,80 +25984,80 @@ async function St(e, t, n) {
|
|
|
25939
25984
|
}
|
|
25940
25985
|
//#endregion
|
|
25941
25986
|
//#region src/v2019C1/extensions/clean-up/index.ts
|
|
25942
|
-
var
|
|
25943
|
-
orphanUuidRefs: () =>
|
|
25944
|
-
pruneEmptyContainers: () =>
|
|
25945
|
-
resetLNode: () =>
|
|
25946
|
-
}) },
|
|
25987
|
+
var xt = { transaction: /* @__PURE__ */ l({
|
|
25988
|
+
orphanUuidRefs: () => yt,
|
|
25989
|
+
pruneEmptyContainers: () => vt,
|
|
25990
|
+
resetLNode: () => re
|
|
25991
|
+
}) }, St = ["id", "uuid"];
|
|
25947
25992
|
//#endregion
|
|
25948
25993
|
//#region src/v2019C1/extensions/signature/query/element-signature.ts
|
|
25949
|
-
async function
|
|
25994
|
+
async function Ct(e, t) {
|
|
25950
25995
|
let n = {
|
|
25951
25996
|
query: e,
|
|
25952
25997
|
resolveReferences: t.resolveReferences ?? !1,
|
|
25953
|
-
ignore: new Set(t.ignoreAttributes ??
|
|
25954
|
-
|
|
25998
|
+
ignore: new Set(t.ignoreAttributes ?? St),
|
|
25999
|
+
signatureCache: t.signatureCache ?? /* @__PURE__ */ new Map(),
|
|
25955
26000
|
seen: /* @__PURE__ */ new Set()
|
|
25956
26001
|
};
|
|
25957
|
-
return
|
|
26002
|
+
return Et(t.ref, n);
|
|
25958
26003
|
}
|
|
25959
|
-
var
|
|
25960
|
-
function
|
|
26004
|
+
var wt = /* @__PURE__ */ new Set();
|
|
26005
|
+
function Tt(e, t) {
|
|
25961
26006
|
return _[e]?.attributes?.details?.[t]?.default;
|
|
25962
26007
|
}
|
|
25963
|
-
async function
|
|
25964
|
-
let n = `${e.tagName}:${e.id}`, r = t.
|
|
26008
|
+
async function Et(e, t) {
|
|
26009
|
+
let n = `${e.tagName}:${e.id}`, r = t.signatureCache.get(n);
|
|
25965
26010
|
if (r !== void 0) return r;
|
|
25966
26011
|
if (t.seen.has(n)) return `@cycle:${e.tagName}`;
|
|
25967
26012
|
t.seen.add(n);
|
|
25968
|
-
let i = await t.query.getTree(e), a = i ? await
|
|
25969
|
-
return t.seen.delete(n), t.
|
|
26013
|
+
let i = await t.query.getTree(e), a = i ? await Dt(i, t) : "";
|
|
26014
|
+
return t.seen.delete(n), t.signatureCache.set(n, a), a;
|
|
25970
26015
|
}
|
|
25971
|
-
async function
|
|
25972
|
-
let n = t.resolveReferences ?
|
|
26016
|
+
async function Dt(e, t) {
|
|
26017
|
+
let n = t.resolveReferences ? Mt(e.tagName) : wt, r = [];
|
|
25973
26018
|
for (let i of e.attributes) {
|
|
25974
|
-
if (t.ignore.has(i.name) || n.has(i.name) || i.value ===
|
|
26019
|
+
if (t.ignore.has(i.name) || n.has(i.name) || i.value === Tt(e.tagName, i.name)) continue;
|
|
25975
26020
|
let a = i.value;
|
|
25976
26021
|
if (t.resolveReferences) {
|
|
25977
|
-
let n = await
|
|
26022
|
+
let n = await Ot(e, i.name, i.value, t);
|
|
25978
26023
|
n !== null && (a = `@sig:${n}`);
|
|
25979
26024
|
}
|
|
25980
26025
|
r.push(`${JSON.stringify(i.name)}:${JSON.stringify(a)}`);
|
|
25981
26026
|
}
|
|
25982
26027
|
r.sort();
|
|
25983
26028
|
let i = [];
|
|
25984
|
-
for (let n of e.tree ?? []) i.push(await
|
|
26029
|
+
for (let n of e.tree ?? []) i.push(await Dt(n, t));
|
|
25985
26030
|
i.sort();
|
|
25986
26031
|
let a = e.value?.trim(), o = a ? `,value:${JSON.stringify(a)}` : "";
|
|
25987
26032
|
return `{tag:${JSON.stringify(e.tagName)},attrs:[${r.join(",")}]${o},children:[${i.join(",")}]}`;
|
|
25988
26033
|
}
|
|
25989
|
-
async function
|
|
25990
|
-
let i =
|
|
26034
|
+
async function Ot(e, t, n, r) {
|
|
26035
|
+
let i = kt(e, t);
|
|
25991
26036
|
if (i) {
|
|
25992
|
-
let e = await
|
|
25993
|
-
return e ?
|
|
26037
|
+
let e = await Nt(r.query, i.target, n);
|
|
26038
|
+
return e ? Et(e, r) : `@missing:${n}`;
|
|
25994
26039
|
}
|
|
25995
|
-
let a =
|
|
26040
|
+
let a = jt(e.tagName, t);
|
|
25996
26041
|
if (a) {
|
|
25997
|
-
let e = await
|
|
25998
|
-
return e ?
|
|
26042
|
+
let e = await Pt(r.query, a.target, n);
|
|
26043
|
+
return e ? Et(e, r) : `@missing:${n}`;
|
|
25999
26044
|
}
|
|
26000
26045
|
return null;
|
|
26001
26046
|
}
|
|
26002
|
-
function
|
|
26003
|
-
return N[e.tagName]?.find((n) => n.attribute === t &&
|
|
26047
|
+
function kt(e, t) {
|
|
26048
|
+
return N[e.tagName]?.find((n) => n.attribute === t && At(e, n));
|
|
26004
26049
|
}
|
|
26005
|
-
function
|
|
26050
|
+
function At(e, t) {
|
|
26006
26051
|
return t.when ? e.attributes.find((e) => e.name === t.when.attribute)?.value === t.when.equals : !0;
|
|
26007
26052
|
}
|
|
26008
|
-
function
|
|
26009
|
-
return
|
|
26053
|
+
function jt(e, t) {
|
|
26054
|
+
return D[e]?.find((e) => e.attribute.uuid === t);
|
|
26010
26055
|
}
|
|
26011
|
-
function
|
|
26012
|
-
let t =
|
|
26013
|
-
return t ? new Set(t.map((e) => e.attribute.path)) :
|
|
26056
|
+
function Mt(e) {
|
|
26057
|
+
let t = D[e];
|
|
26058
|
+
return t ? new Set(t.map((e) => e.attribute.path)) : wt;
|
|
26014
26059
|
}
|
|
26015
|
-
async function
|
|
26060
|
+
async function Nt(e, t, n) {
|
|
26016
26061
|
let [r] = await e.findByAttributes({
|
|
26017
26062
|
tagName: t,
|
|
26018
26063
|
attributes: { id: n }
|
|
@@ -26022,7 +26067,7 @@ async function Pt(e, t, n) {
|
|
|
26022
26067
|
id: r.id
|
|
26023
26068
|
} : null;
|
|
26024
26069
|
}
|
|
26025
|
-
async function
|
|
26070
|
+
async function Pt(e, t, n) {
|
|
26026
26071
|
for (let r of t) {
|
|
26027
26072
|
let [t] = await e.findByAttributes({
|
|
26028
26073
|
tagName: r,
|
|
@@ -26037,31 +26082,42 @@ async function Ft(e, t, n) {
|
|
|
26037
26082
|
}
|
|
26038
26083
|
//#endregion
|
|
26039
26084
|
//#region src/v2019C1/extensions/signature/query/index.ts
|
|
26040
|
-
var
|
|
26085
|
+
var Ft = /* @__PURE__ */ l({ elementSignature: () => Ct });
|
|
26041
26086
|
//#endregion
|
|
26042
26087
|
//#region src/v2019C1/extensions/data-model/transaction/import-types.ts
|
|
26043
|
-
async function
|
|
26044
|
-
let { sourceQuery: n, records: r, cloneMappings: i = [], forkPrefix: a = "", keepNameTypesFrom: o = "target" } = t
|
|
26088
|
+
async function It(e, t) {
|
|
26089
|
+
let { sourceQuery: n, records: r, cloneMappings: i = [], forkPrefix: a = "", keepNameTypesFrom: o = "target" } = t;
|
|
26090
|
+
e.perf.start("scl::importTypes");
|
|
26091
|
+
let s = Lt(await S(n, { records: r })), c = await e.ensureChild(await e.getRoot(), {
|
|
26045
26092
|
tagName: "DataTypeTemplates",
|
|
26046
26093
|
attributes: {}
|
|
26047
|
-
})
|
|
26094
|
+
});
|
|
26095
|
+
e.progress.plan({
|
|
26096
|
+
steps: s.length,
|
|
26097
|
+
label: "Indexing existing types…"
|
|
26098
|
+
}), e.perf.start("scl::importTypes::preExistingIndex");
|
|
26099
|
+
let l = await zt(e);
|
|
26100
|
+
e.perf.stop("scl::importTypes::preExistingIndex");
|
|
26101
|
+
let u = /* @__PURE__ */ new Map(), d = [], f = [], p = {
|
|
26048
26102
|
reused: 0,
|
|
26049
26103
|
preserved: 0,
|
|
26050
26104
|
forked: 0,
|
|
26051
26105
|
reclaimed: 0
|
|
26052
|
-
};
|
|
26106
|
+
}, m = /* @__PURE__ */ new Map();
|
|
26107
|
+
e.perf.start("scl::importTypes::sourceLoop");
|
|
26053
26108
|
for (let t of s) {
|
|
26054
26109
|
let r = await n.getAttribute(t, { name: "id" });
|
|
26055
|
-
if (!r) continue;
|
|
26056
|
-
let i = await
|
|
26110
|
+
if (e.progress.nextStep(r ? `Importing ${r}` : void 0), !r) continue;
|
|
26111
|
+
let i = await Ct(n, {
|
|
26057
26112
|
ref: {
|
|
26058
26113
|
tagName: t.tagName,
|
|
26059
26114
|
id: t.id
|
|
26060
26115
|
},
|
|
26061
|
-
resolveReferences: !0
|
|
26116
|
+
resolveReferences: !0,
|
|
26117
|
+
signatureCache: m
|
|
26062
26118
|
}), s = l.get(i);
|
|
26063
26119
|
if (s !== void 0) {
|
|
26064
|
-
let n = o === "source" ? await
|
|
26120
|
+
let n = o === "source" ? await Bt(e, {
|
|
26065
26121
|
tagName: t.tagName,
|
|
26066
26122
|
currentId: s,
|
|
26067
26123
|
desiredId: r
|
|
@@ -26069,41 +26125,43 @@ async function Lt(e, t) {
|
|
|
26069
26125
|
u.set(r, n), n !== s && l.set(i, n), p.reused++;
|
|
26070
26126
|
continue;
|
|
26071
26127
|
}
|
|
26072
|
-
let
|
|
26073
|
-
if (!
|
|
26074
|
-
let [
|
|
26128
|
+
let h = await n.getTree(t);
|
|
26129
|
+
if (!h) continue;
|
|
26130
|
+
let [g] = await e.findByAttributes({
|
|
26075
26131
|
tagName: t.tagName,
|
|
26076
26132
|
attributes: { id: r }
|
|
26077
|
-
}),
|
|
26078
|
-
|
|
26079
|
-
let
|
|
26080
|
-
u.set(r,
|
|
26133
|
+
}), _ = r, v = h;
|
|
26134
|
+
g ? (_ = await qt(e, t.tagName, `${a}${r}_${Jt(i)}`), v = Vt(h, _), p.forked++) : p.preserved++;
|
|
26135
|
+
let y = await e.deepClone(c, v);
|
|
26136
|
+
u.set(r, _), y?.record && (d.push(B(y.record.tagName, y.record.id)), g && f.push({
|
|
26081
26137
|
oldId: r,
|
|
26082
|
-
oldRef:
|
|
26083
|
-
forkRef:
|
|
26084
|
-
forkedId:
|
|
26138
|
+
oldRef: B(g.tagName, g.id),
|
|
26139
|
+
forkRef: B(y.record.tagName, y.record.id),
|
|
26140
|
+
forkedId: _
|
|
26085
26141
|
}));
|
|
26086
26142
|
}
|
|
26087
|
-
|
|
26088
|
-
|
|
26143
|
+
e.perf.stop("scl::importTypes::sourceLoop"), e.perf.start("scl::importTypes::remap");
|
|
26144
|
+
let h = [];
|
|
26145
|
+
for (let t of i) t.target.tagName === "LNode" && await te(e, t.target) || h.push(t.target);
|
|
26089
26146
|
for (let t of d) {
|
|
26147
|
+
e.progress.nextStep("Repointing references…");
|
|
26090
26148
|
let n = await e.getTree(t);
|
|
26091
|
-
n &&
|
|
26149
|
+
n && Ht(n, h);
|
|
26092
26150
|
}
|
|
26093
|
-
return await
|
|
26094
|
-
records:
|
|
26151
|
+
return await L(e, {
|
|
26152
|
+
records: h,
|
|
26095
26153
|
idRemap: u
|
|
26096
|
-
}), f.length > 0 && await
|
|
26154
|
+
}), e.perf.stop("scl::importTypes::remap"), f.length > 0 && (e.progress.nextStep("Reclaiming ids…"), e.perf.start("scl::importTypes::reclaim"), await Ut(e, {
|
|
26097
26155
|
collisions: f,
|
|
26098
26156
|
idRemap: u,
|
|
26099
|
-
referrerRecords:
|
|
26157
|
+
referrerRecords: h,
|
|
26100
26158
|
stats: p
|
|
26101
|
-
}), {
|
|
26159
|
+
}), e.perf.stop("scl::importTypes::reclaim")), e.progress.endPlan(), e.perf.stop("scl::importTypes"), {
|
|
26102
26160
|
idRemap: u,
|
|
26103
26161
|
stats: p
|
|
26104
26162
|
};
|
|
26105
26163
|
}
|
|
26106
|
-
function
|
|
26164
|
+
function Lt(e) {
|
|
26107
26165
|
return [
|
|
26108
26166
|
...e.enumTypes,
|
|
26109
26167
|
...e.daTypes,
|
|
@@ -26111,32 +26169,33 @@ function Rt(e) {
|
|
|
26111
26169
|
...e.lnodeTypes
|
|
26112
26170
|
];
|
|
26113
26171
|
}
|
|
26114
|
-
var
|
|
26172
|
+
var Rt = [
|
|
26115
26173
|
"EnumType",
|
|
26116
26174
|
"DAType",
|
|
26117
26175
|
"DOType",
|
|
26118
26176
|
"LNodeType"
|
|
26119
26177
|
];
|
|
26120
|
-
async function
|
|
26121
|
-
let t = /* @__PURE__ */ new Map();
|
|
26122
|
-
for (let
|
|
26123
|
-
let
|
|
26124
|
-
for (let
|
|
26125
|
-
let
|
|
26126
|
-
if (!
|
|
26127
|
-
let
|
|
26178
|
+
async function zt(e) {
|
|
26179
|
+
let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
|
|
26180
|
+
for (let r of Rt) {
|
|
26181
|
+
let i = await e.getRecordsByTagName(r);
|
|
26182
|
+
for (let a of i) {
|
|
26183
|
+
let i = a.attributes.find((e) => e.name === "id")?.value;
|
|
26184
|
+
if (!i) continue;
|
|
26185
|
+
let o = await Ct(e, {
|
|
26128
26186
|
ref: {
|
|
26129
|
-
tagName:
|
|
26130
|
-
id:
|
|
26187
|
+
tagName: r,
|
|
26188
|
+
id: a.id
|
|
26131
26189
|
},
|
|
26132
|
-
resolveReferences: !0
|
|
26190
|
+
resolveReferences: !0,
|
|
26191
|
+
signatureCache: n
|
|
26133
26192
|
});
|
|
26134
|
-
t.has(
|
|
26193
|
+
t.has(o) || t.set(o, i);
|
|
26135
26194
|
}
|
|
26136
26195
|
}
|
|
26137
26196
|
return t;
|
|
26138
26197
|
}
|
|
26139
|
-
async function
|
|
26198
|
+
async function Bt(e, t) {
|
|
26140
26199
|
let { tagName: n, currentId: r, desiredId: i } = t;
|
|
26141
26200
|
if (r === i) return r;
|
|
26142
26201
|
let [a] = await e.findByAttributes({
|
|
@@ -26149,32 +26208,32 @@ async function Vt(e, t) {
|
|
|
26149
26208
|
attributes: { id: i }
|
|
26150
26209
|
});
|
|
26151
26210
|
if (o && o.id !== a.id) return r;
|
|
26152
|
-
let s =
|
|
26153
|
-
return await e.update(s, { attributes: { id: i } }), await
|
|
26154
|
-
records: c.map((e) =>
|
|
26211
|
+
let s = B(a.tagName, a.id), c = await I(e, { target: s });
|
|
26212
|
+
return await e.update(s, { attributes: { id: i } }), await L(e, {
|
|
26213
|
+
records: c.map((e) => B(e.ref.tagName, e.ref.id)),
|
|
26155
26214
|
idRemap: new Map([[r, i]])
|
|
26156
26215
|
}), i;
|
|
26157
26216
|
}
|
|
26158
|
-
function
|
|
26217
|
+
function Vt(e, t) {
|
|
26159
26218
|
let n = structuredClone(e), r = n.attributes, i = r.find((e) => e.name === "id");
|
|
26160
26219
|
return i ? i.value = t : r.push({
|
|
26161
26220
|
name: "id",
|
|
26162
26221
|
value: t
|
|
26163
26222
|
}), n;
|
|
26164
26223
|
}
|
|
26165
|
-
function
|
|
26224
|
+
function B(e, t) {
|
|
26166
26225
|
return {
|
|
26167
26226
|
tagName: e,
|
|
26168
26227
|
id: t
|
|
26169
26228
|
};
|
|
26170
26229
|
}
|
|
26171
|
-
function
|
|
26172
|
-
t.push(
|
|
26173
|
-
for (let n of e.tree ?? [])
|
|
26230
|
+
function Ht(e, t) {
|
|
26231
|
+
t.push(B(e.tagName, e.id));
|
|
26232
|
+
for (let n of e.tree ?? []) Ht(n, t);
|
|
26174
26233
|
}
|
|
26175
|
-
var
|
|
26176
|
-
async function
|
|
26177
|
-
let { collisions: n, idRemap: r, referrerRecords: i, stats: a } = t, o = await
|
|
26234
|
+
var V = (e) => `${e.tagName}#${e.id}`;
|
|
26235
|
+
async function Ut(e, t) {
|
|
26236
|
+
let { collisions: n, idRemap: r, referrerRecords: i, stats: a } = t, o = await Wt(e, n), s = /* @__PURE__ */ new Map(), c = [];
|
|
26178
26237
|
for (let t of n) if (o.has(t.oldId)) {
|
|
26179
26238
|
await e.update(t.forkRef, { attributes: { id: t.oldId } }), s.set(t.forkedId, t.oldId), c.push(t.forkRef), a.reclaimed++;
|
|
26180
26239
|
for (let [e, n] of r) n === t.forkedId && r.set(e, t.oldId);
|
|
@@ -26183,38 +26242,38 @@ async function Wt(e, t) {
|
|
|
26183
26242
|
let l = [...i];
|
|
26184
26243
|
for (let t of c) {
|
|
26185
26244
|
let n = await e.getTree(t);
|
|
26186
|
-
n &&
|
|
26245
|
+
n && Ht(n, l);
|
|
26187
26246
|
}
|
|
26188
|
-
await
|
|
26247
|
+
await L(e, {
|
|
26189
26248
|
records: l,
|
|
26190
26249
|
idRemap: s
|
|
26191
26250
|
});
|
|
26192
26251
|
}
|
|
26193
|
-
async function
|
|
26194
|
-
let n = /* @__PURE__ */ new Set(), r = new Map(t.map((e) => [
|
|
26252
|
+
async function Wt(e, t) {
|
|
26253
|
+
let n = /* @__PURE__ */ new Set(), r = new Map(t.map((e) => [V(e.oldRef), e.oldId])), i = t.map((e) => e.oldRef), a = new Set(i.map(V)), o = /* @__PURE__ */ new Set(), s = !0;
|
|
26195
26254
|
for (; s;) {
|
|
26196
26255
|
s = !1;
|
|
26197
26256
|
for (let t of i) {
|
|
26198
|
-
let c =
|
|
26199
|
-
if (o.has(c) || (await
|
|
26200
|
-
let l = await e.getTree(t), u = l ? await
|
|
26257
|
+
let c = V(t);
|
|
26258
|
+
if (o.has(c) || (await I(e, { target: t })).length > 0) continue;
|
|
26259
|
+
let l = await e.getTree(t), u = l ? await Gt(e, l) : [];
|
|
26201
26260
|
await e.delete(t), o.add(c), s = !0;
|
|
26202
26261
|
let d = r.get(c);
|
|
26203
26262
|
d !== void 0 && n.add(d);
|
|
26204
26263
|
for (let e of u) {
|
|
26205
|
-
let t =
|
|
26264
|
+
let t = V(e);
|
|
26206
26265
|
a.has(t) || (i.push(e), a.add(t));
|
|
26207
26266
|
}
|
|
26208
26267
|
}
|
|
26209
26268
|
}
|
|
26210
26269
|
return n;
|
|
26211
26270
|
}
|
|
26212
|
-
async function
|
|
26271
|
+
async function Gt(e, t) {
|
|
26213
26272
|
let n = [], r = /* @__PURE__ */ new Set();
|
|
26214
26273
|
async function i(t) {
|
|
26215
26274
|
let a = N[t.tagName];
|
|
26216
26275
|
for (let i of a ?? []) {
|
|
26217
|
-
if (!
|
|
26276
|
+
if (!Kt(t, i)) continue;
|
|
26218
26277
|
let a = t.attributes.find((e) => e.name === i.attribute)?.value;
|
|
26219
26278
|
if (!a) continue;
|
|
26220
26279
|
let [o] = await e.findByAttributes({
|
|
@@ -26222,17 +26281,17 @@ async function Kt(e, t) {
|
|
|
26222
26281
|
attributes: { id: a }
|
|
26223
26282
|
});
|
|
26224
26283
|
if (!o) continue;
|
|
26225
|
-
let s =
|
|
26284
|
+
let s = B(i.target, o.id), c = V(s);
|
|
26226
26285
|
r.has(c) || (r.add(c), n.push(s));
|
|
26227
26286
|
}
|
|
26228
26287
|
for (let e of t.tree ?? []) await i(e);
|
|
26229
26288
|
}
|
|
26230
26289
|
return await i(t), n;
|
|
26231
26290
|
}
|
|
26232
|
-
function
|
|
26291
|
+
function Kt(e, t) {
|
|
26233
26292
|
return t.when ? e.attributes.find((e) => e.name === t.when.attribute)?.value === t.when.equals : !0;
|
|
26234
26293
|
}
|
|
26235
|
-
async function
|
|
26294
|
+
async function qt(e, t, n) {
|
|
26236
26295
|
let r = n, i = 2;
|
|
26237
26296
|
for (; (await e.findByAttributes({
|
|
26238
26297
|
tagName: t,
|
|
@@ -26240,20 +26299,20 @@ async function Jt(e, t, n) {
|
|
|
26240
26299
|
})).length > 0;) r = `${n}_${i}`, i += 1;
|
|
26241
26300
|
return r;
|
|
26242
26301
|
}
|
|
26243
|
-
function
|
|
26302
|
+
function Jt(e) {
|
|
26244
26303
|
let t = 2166136261;
|
|
26245
26304
|
for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619);
|
|
26246
26305
|
return (t >>> 0).toString(16).padStart(8, "0");
|
|
26247
26306
|
}
|
|
26248
26307
|
//#endregion
|
|
26249
26308
|
//#region src/v2019C1/extensions/data-model/index.ts
|
|
26250
|
-
var
|
|
26251
|
-
query:
|
|
26252
|
-
transaction: /* @__PURE__ */ l({ importTypes: () =>
|
|
26309
|
+
var Yt = {
|
|
26310
|
+
query: ne,
|
|
26311
|
+
transaction: /* @__PURE__ */ l({ importTypes: () => It })
|
|
26253
26312
|
};
|
|
26254
26313
|
//#endregion
|
|
26255
26314
|
//#region src/v2019C1/extensions/history/query/get-sorted-hitem.ts
|
|
26256
|
-
async function
|
|
26315
|
+
async function Xt(e) {
|
|
26257
26316
|
let t = await e.getRecord({ tagName: "History" });
|
|
26258
26317
|
if (!t) return [];
|
|
26259
26318
|
let { Hitem: n = [] } = await e.findDescendants(t, { collect: "Hitem" });
|
|
@@ -26267,18 +26326,18 @@ async function Zt(e) {
|
|
|
26267
26326
|
}
|
|
26268
26327
|
//#endregion
|
|
26269
26328
|
//#region src/v2019C1/extensions/history/query/get-latest-hitem.ts
|
|
26270
|
-
async function
|
|
26271
|
-
return (await
|
|
26329
|
+
async function Zt(e) {
|
|
26330
|
+
return (await Xt(e)).at(-1);
|
|
26272
26331
|
}
|
|
26273
26332
|
//#endregion
|
|
26274
26333
|
//#region src/v2019C1/extensions/history/query/index.ts
|
|
26275
|
-
var
|
|
26276
|
-
getLatestHitem: () =>
|
|
26277
|
-
getSortedHitems: () =>
|
|
26334
|
+
var Qt = /* @__PURE__ */ l({
|
|
26335
|
+
getLatestHitem: () => Zt,
|
|
26336
|
+
getSortedHitems: () => Xt
|
|
26278
26337
|
});
|
|
26279
26338
|
//#endregion
|
|
26280
26339
|
//#region src/v2019C1/extensions/history/transaction/add-entry.ts
|
|
26281
|
-
async function
|
|
26340
|
+
async function $t(e, t) {
|
|
26282
26341
|
let { filename: n, header: r, item: i } = t, { id: a, fileType: o, nameStructure: s, version: c, tool: l } = r, { who: u, what: d, why: f } = i, p = await e.getRoot(), m = await e.getRecord({ tagName: "Header" }) ?? await e.addChild(p, {
|
|
26283
26342
|
tagName: "Header",
|
|
26284
26343
|
attributes: {
|
|
@@ -26293,7 +26352,7 @@ async function en(e, t) {
|
|
|
26293
26352
|
}), h = await e.getRecord({ tagName: "History" }) ?? await e.addChild(m, {
|
|
26294
26353
|
tagName: "History",
|
|
26295
26354
|
attributes: {}
|
|
26296
|
-
}), g = await
|
|
26355
|
+
}), g = await Zt(e), _ = g?.attributes.find((e) => e.name === "version")?.value, v = g?.attributes.find((e) => e.name === "revision")?.value, y = c === "keep" ? _ ?? "0" : _ ? String(Number(_) + 1) : "0", b = v ? String(Number(v) + 1) : "1";
|
|
26297
26356
|
await e.update(m, { attributes: {
|
|
26298
26357
|
version: y,
|
|
26299
26358
|
revision: b
|
|
@@ -26316,57 +26375,92 @@ async function en(e, t) {
|
|
|
26316
26375
|
}
|
|
26317
26376
|
//#endregion
|
|
26318
26377
|
//#region src/v2019C1/extensions/history/index.ts
|
|
26319
|
-
var
|
|
26320
|
-
query:
|
|
26321
|
-
transaction: /* @__PURE__ */ l({ addEntry: () =>
|
|
26378
|
+
var en = {
|
|
26379
|
+
query: Qt,
|
|
26380
|
+
transaction: /* @__PURE__ */ l({ addEntry: () => $t })
|
|
26322
26381
|
};
|
|
26323
26382
|
//#endregion
|
|
26324
26383
|
//#region src/v2019C1/extensions/identity/transaction/write-identity.ts
|
|
26325
|
-
async function
|
|
26384
|
+
async function H(e, t) {
|
|
26326
26385
|
let { mappings: n, mode: r } = t;
|
|
26327
26386
|
if (r !== "keep") for (let t of n) {
|
|
26328
|
-
let n = r === "strip" ?
|
|
26387
|
+
let n = r === "strip" ? tn() : nn(t);
|
|
26329
26388
|
if (Object.keys(n).length === 0) continue;
|
|
26330
26389
|
let i = await e.getRecord(t.target);
|
|
26331
26390
|
i && await e.update(i, { attributes: n });
|
|
26332
26391
|
}
|
|
26333
26392
|
}
|
|
26334
|
-
function
|
|
26393
|
+
function tn() {
|
|
26335
26394
|
return {
|
|
26336
26395
|
templateUuid: void 0,
|
|
26337
26396
|
originUuid: void 0
|
|
26338
26397
|
};
|
|
26339
26398
|
}
|
|
26340
|
-
function
|
|
26341
|
-
let t =
|
|
26399
|
+
function nn(e) {
|
|
26400
|
+
let t = an(e.source.attributes, "uuid"), n = an(e.source.attributes, "templateUuid"), r = an(e.source.attributes, "originUuid"), i = {};
|
|
26342
26401
|
t && (i.templateUuid = t);
|
|
26343
|
-
let a =
|
|
26402
|
+
let a = rn(e.target.tagName);
|
|
26344
26403
|
return n && !r && a && (i.originUuid = n), i;
|
|
26345
26404
|
}
|
|
26346
|
-
function
|
|
26405
|
+
function rn(e) {
|
|
26347
26406
|
let t = x.attributes[e];
|
|
26348
26407
|
return t ? "originUuid" in t : !1;
|
|
26349
26408
|
}
|
|
26350
|
-
function
|
|
26409
|
+
function an(e, t) {
|
|
26410
|
+
return e.find((e) => e.name === t)?.value;
|
|
26411
|
+
}
|
|
26412
|
+
//#endregion
|
|
26413
|
+
//#region src/v2019C1/extensions/identity/transaction/restore-cloned-uuids.ts
|
|
26414
|
+
async function on(e, t) {
|
|
26415
|
+
let { mappings: n } = t, r = /* @__PURE__ */ new Map(), i = [];
|
|
26416
|
+
for (let t of n) {
|
|
26417
|
+
let n = sn(t.source.attributes, "uuid");
|
|
26418
|
+
if (!n) continue;
|
|
26419
|
+
let a = await e.getRecord(t.target), o = a ? a.attributes.find((e) => e.name === "uuid")?.value : void 0;
|
|
26420
|
+
!o || o === n || (r.set(o, n), i.push({
|
|
26421
|
+
ref: t.target,
|
|
26422
|
+
sourceUuid: n
|
|
26423
|
+
}));
|
|
26424
|
+
}
|
|
26425
|
+
if (r.size !== 0) {
|
|
26426
|
+
for (let { ref: t, sourceUuid: n } of i) await e.update(t, { attributes: { uuid: n } });
|
|
26427
|
+
for (let t of n) {
|
|
26428
|
+
let n = D[t.target.tagName];
|
|
26429
|
+
if (!n) continue;
|
|
26430
|
+
let i = await e.getRecord(t.target);
|
|
26431
|
+
if (!i) continue;
|
|
26432
|
+
let a = {};
|
|
26433
|
+
for (let e of n) {
|
|
26434
|
+
let t = i.attributes.find((t) => t.name === e.attribute.uuid)?.value, n = t ? r.get(t) : void 0;
|
|
26435
|
+
n && (a[e.attribute.uuid] = n);
|
|
26436
|
+
}
|
|
26437
|
+
Object.keys(a).length > 0 && await e.update(t.target, { attributes: a });
|
|
26438
|
+
}
|
|
26439
|
+
}
|
|
26440
|
+
}
|
|
26441
|
+
function sn(e, t) {
|
|
26351
26442
|
return e.find((e) => e.name === t)?.value;
|
|
26352
26443
|
}
|
|
26353
26444
|
//#endregion
|
|
26354
26445
|
//#region src/v2019C1/extensions/identity/index.ts
|
|
26355
|
-
var
|
|
26446
|
+
var cn = { transaction: /* @__PURE__ */ l({
|
|
26447
|
+
restoreClonedUuids: () => on,
|
|
26448
|
+
writeIdentity: () => H
|
|
26449
|
+
}) };
|
|
26356
26450
|
//#endregion
|
|
26357
26451
|
//#region src/v2019C1/extensions/lifecycle/engine/group.ts
|
|
26358
|
-
function
|
|
26452
|
+
function ln(e, t) {
|
|
26359
26453
|
let n = [];
|
|
26360
|
-
return
|
|
26454
|
+
return un({
|
|
26361
26455
|
node: e,
|
|
26362
26456
|
scopePrefix: t,
|
|
26363
26457
|
out: n
|
|
26364
26458
|
}), n;
|
|
26365
26459
|
}
|
|
26366
|
-
function
|
|
26460
|
+
function un(e) {
|
|
26367
26461
|
let { node: t, scopePrefix: n, out: r } = e;
|
|
26368
26462
|
if (t.change === "unchanged") {
|
|
26369
|
-
for (let e of t.children)
|
|
26463
|
+
for (let e of t.children) un({
|
|
26370
26464
|
node: e,
|
|
26371
26465
|
scopePrefix: n,
|
|
26372
26466
|
out: r
|
|
@@ -26374,11 +26468,11 @@ function ln(e) {
|
|
|
26374
26468
|
return;
|
|
26375
26469
|
}
|
|
26376
26470
|
let i = [];
|
|
26377
|
-
|
|
26471
|
+
dn({
|
|
26378
26472
|
node: t,
|
|
26379
26473
|
out: i
|
|
26380
26474
|
}), r.push({
|
|
26381
|
-
id:
|
|
26475
|
+
id: fn(t, n),
|
|
26382
26476
|
change: t.change,
|
|
26383
26477
|
title: `${t.change} ${t.tagName}`,
|
|
26384
26478
|
primary: t,
|
|
@@ -26387,32 +26481,32 @@ function ln(e) {
|
|
|
26387
26481
|
suggestedAction: t.change === "target-only" ? "skip" : "accept"
|
|
26388
26482
|
});
|
|
26389
26483
|
}
|
|
26390
|
-
function
|
|
26484
|
+
function dn(e) {
|
|
26391
26485
|
let { node: t, out: n } = e;
|
|
26392
|
-
for (let e of t.children) e.change !== "unchanged" && n.push(e),
|
|
26486
|
+
for (let e of t.children) e.change !== "unchanged" && n.push(e), dn({
|
|
26393
26487
|
node: e,
|
|
26394
26488
|
out: n
|
|
26395
26489
|
});
|
|
26396
26490
|
}
|
|
26397
|
-
function
|
|
26491
|
+
function fn(e, t) {
|
|
26398
26492
|
let n = e.sourceRef ?? e.instanceRef, r = n ? `${n.tagName}:${n.id}` : e.tagName;
|
|
26399
26493
|
return t ? `${t}::${r}` : r;
|
|
26400
26494
|
}
|
|
26401
26495
|
//#endregion
|
|
26402
26496
|
//#region src/v2019C1/extensions/lifecycle/engine/visible-attributes.ts
|
|
26403
|
-
var
|
|
26497
|
+
var pn = new Set([
|
|
26404
26498
|
"uuid",
|
|
26405
26499
|
"templateUuid",
|
|
26406
26500
|
"originUuid"
|
|
26407
|
-
]),
|
|
26408
|
-
function
|
|
26501
|
+
]), mn = new Set(Object.values(D).flatMap((e) => e.flatMap((e) => [e.attribute.path, e.attribute.uuid])));
|
|
26502
|
+
function hn(e) {
|
|
26409
26503
|
let t = {};
|
|
26410
|
-
for (let [n, r] of Object.entries(e))
|
|
26504
|
+
for (let [n, r] of Object.entries(e)) pn.has(n) || n === "name" || mn.has(n) || (t[n] = r);
|
|
26411
26505
|
return t;
|
|
26412
26506
|
}
|
|
26413
26507
|
//#endregion
|
|
26414
26508
|
//#region src/v2019C1/extensions/lifecycle/engine/diff.ts
|
|
26415
|
-
var
|
|
26509
|
+
var gn = new Set([
|
|
26416
26510
|
"LNodeSpecNaming",
|
|
26417
26511
|
"FunctionSclRef",
|
|
26418
26512
|
"ApplicationSclRef",
|
|
@@ -26420,95 +26514,98 @@ var mn = new Set([
|
|
|
26420
26514
|
"FunctionRole",
|
|
26421
26515
|
"FunctionRoleContent"
|
|
26422
26516
|
]);
|
|
26423
|
-
async function
|
|
26424
|
-
let { sourceQuery: t, targetQuery: n, sourceRootRef: r, instanceRootRef: i, keepLeftoverRefs: a } = e, o = e.leftoverRefPolicy, s = e.refsAlwaysAdded ?? !1, c = await t.any.getTree(r);
|
|
26425
|
-
if (!
|
|
26426
|
-
let
|
|
26427
|
-
if (!
|
|
26428
|
-
let e =
|
|
26517
|
+
async function _n(e) {
|
|
26518
|
+
let { sourceQuery: t, targetQuery: n, sourceRootRef: r, instanceRootRef: i, keepLeftoverRefs: a } = e, o = e.leftoverRefPolicy, s = e.refsAlwaysAdded ?? !1, c = e.matchKey ?? "templateUuid", l = await t.any.getTree(r);
|
|
26519
|
+
if (!l) throw Error("diff: source subtree not found");
|
|
26520
|
+
let u = i ? await n.any.getTree(i) : void 0;
|
|
26521
|
+
if (!u) {
|
|
26522
|
+
let e = wn(l);
|
|
26429
26523
|
return {
|
|
26430
26524
|
root: e,
|
|
26431
|
-
groups:
|
|
26432
|
-
summary:
|
|
26525
|
+
groups: ln(e),
|
|
26526
|
+
summary: Fn(e)
|
|
26433
26527
|
};
|
|
26434
26528
|
}
|
|
26435
|
-
let
|
|
26436
|
-
await
|
|
26437
|
-
node:
|
|
26438
|
-
index:
|
|
26529
|
+
let d = /* @__PURE__ */ new Map();
|
|
26530
|
+
await Mn(n, {
|
|
26531
|
+
node: u,
|
|
26532
|
+
index: d,
|
|
26533
|
+
matchKey: c
|
|
26439
26534
|
});
|
|
26440
|
-
let
|
|
26441
|
-
await
|
|
26442
|
-
node:
|
|
26443
|
-
out:
|
|
26535
|
+
let f = /* @__PURE__ */ new Set();
|
|
26536
|
+
await Nn(t, {
|
|
26537
|
+
node: l,
|
|
26538
|
+
out: f
|
|
26444
26539
|
});
|
|
26445
|
-
let
|
|
26540
|
+
let p = await vn(t, {
|
|
26446
26541
|
targetQuery: n,
|
|
26447
|
-
sourceNode:
|
|
26448
|
-
instanceNode:
|
|
26449
|
-
index:
|
|
26450
|
-
sourceUuids:
|
|
26542
|
+
sourceNode: l,
|
|
26543
|
+
instanceNode: u,
|
|
26544
|
+
index: d,
|
|
26545
|
+
sourceUuids: f,
|
|
26451
26546
|
keepLeftoverRefs: a ?? !1,
|
|
26452
26547
|
leftoverRefPolicy: o,
|
|
26453
|
-
refsAlwaysAdded: s
|
|
26454
|
-
|
|
26548
|
+
refsAlwaysAdded: s,
|
|
26549
|
+
matchKey: c
|
|
26550
|
+
}), m = Fn(p);
|
|
26455
26551
|
return {
|
|
26456
|
-
root:
|
|
26457
|
-
groups:
|
|
26458
|
-
summary:
|
|
26552
|
+
root: p,
|
|
26553
|
+
groups: ln(p, u.id),
|
|
26554
|
+
summary: m
|
|
26459
26555
|
};
|
|
26460
26556
|
}
|
|
26461
|
-
async function
|
|
26462
|
-
let { targetQuery: n, sourceNode: r, instanceNode: i, index: o, sourceUuids: s, keepLeftoverRefs: c } = t,
|
|
26557
|
+
async function vn(e, t) {
|
|
26558
|
+
let { targetQuery: n, sourceNode: r, instanceNode: i, index: o, sourceUuids: s, keepLeftoverRefs: c, matchKey: l } = t, u = t.leftoverRefPolicy, d = t.refsAlwaysAdded ?? !1, f = await jn(e, {
|
|
26463
26559
|
targetQuery: n,
|
|
26464
26560
|
sourceNode: r,
|
|
26465
26561
|
instanceNode: i
|
|
26466
|
-
}),
|
|
26562
|
+
}), p = [], m = /* @__PURE__ */ new Set();
|
|
26467
26563
|
for (let t of r.tree) {
|
|
26468
|
-
let r = await
|
|
26564
|
+
let r = await yn(e, {
|
|
26469
26565
|
targetQuery: n,
|
|
26470
26566
|
sourceChild: t,
|
|
26471
26567
|
instanceNode: i,
|
|
26472
26568
|
index: o,
|
|
26473
|
-
matchedInstanceIds:
|
|
26474
|
-
refsAlwaysAdded:
|
|
26569
|
+
matchedInstanceIds: m,
|
|
26570
|
+
refsAlwaysAdded: d
|
|
26475
26571
|
});
|
|
26476
|
-
r ? (
|
|
26572
|
+
r ? (m.add(r.id), p.push(await vn(e, {
|
|
26477
26573
|
targetQuery: n,
|
|
26478
26574
|
sourceNode: t,
|
|
26479
26575
|
instanceNode: r,
|
|
26480
26576
|
index: o,
|
|
26481
26577
|
sourceUuids: s,
|
|
26482
26578
|
keepLeftoverRefs: c,
|
|
26483
|
-
leftoverRefPolicy:
|
|
26484
|
-
refsAlwaysAdded:
|
|
26485
|
-
|
|
26579
|
+
leftoverRefPolicy: u,
|
|
26580
|
+
refsAlwaysAdded: d,
|
|
26581
|
+
matchKey: l
|
|
26582
|
+
}))) : p.push(wn(t));
|
|
26486
26583
|
}
|
|
26487
|
-
let
|
|
26584
|
+
let h = await Dn(e, r);
|
|
26488
26585
|
for (let e of i.tree) {
|
|
26489
|
-
if (
|
|
26490
|
-
let t = await n.any.getAttribute(e, { name:
|
|
26586
|
+
if (m.has(e.id)) continue;
|
|
26587
|
+
let t = await n.any.getAttribute(e, { name: l });
|
|
26491
26588
|
if (t) {
|
|
26492
|
-
s.has(t) ||
|
|
26589
|
+
s.has(t) || p.push(Tn(e));
|
|
26493
26590
|
continue;
|
|
26494
26591
|
}
|
|
26495
|
-
if (A.has(e.tagName) && !
|
|
26496
|
-
let t = c || await
|
|
26497
|
-
t && !r ?
|
|
26592
|
+
if (A.has(e.tagName) && !O.has(e.tagName)) {
|
|
26593
|
+
let t = c || await On(n, e, h), r = t && u ? await u(e) === "removed" : !1;
|
|
26594
|
+
t && !r ? p.push(En(e)) : p.push(Tn(e));
|
|
26498
26595
|
continue;
|
|
26499
26596
|
}
|
|
26500
|
-
|
|
26597
|
+
An(e, p);
|
|
26501
26598
|
}
|
|
26502
26599
|
return {
|
|
26503
|
-
change:
|
|
26600
|
+
change: f.length > 0 ? "modified" : "unchanged",
|
|
26504
26601
|
tagName: r.tagName,
|
|
26505
26602
|
sourceRef: a(r),
|
|
26506
26603
|
instanceRef: a(i),
|
|
26507
|
-
attributeChanges:
|
|
26508
|
-
children:
|
|
26604
|
+
attributeChanges: f.length > 0 ? f : void 0,
|
|
26605
|
+
children: p
|
|
26509
26606
|
};
|
|
26510
26607
|
}
|
|
26511
|
-
async function
|
|
26608
|
+
async function yn(e, t) {
|
|
26512
26609
|
let { targetQuery: n, sourceChild: r, instanceNode: i, index: a, matchedInstanceIds: o } = t, s = await e.any.getAttribute(r, { name: "uuid" });
|
|
26513
26610
|
if (s) {
|
|
26514
26611
|
let e = a.get(s);
|
|
@@ -26518,30 +26615,30 @@ async function _n(e, t) {
|
|
|
26518
26615
|
let c = i.tree.filter((e) => e.tagName === r.tagName && !o.has(e.id));
|
|
26519
26616
|
if (c.length !== 0) {
|
|
26520
26617
|
if (A.has(r.tagName)) {
|
|
26521
|
-
let t = await
|
|
26618
|
+
let t = await bn(e, r, { mapToTemplate: !1 });
|
|
26522
26619
|
if (t === void 0) return c[0];
|
|
26523
|
-
for (let e of c) if (await
|
|
26524
|
-
let i = await
|
|
26620
|
+
for (let e of c) if (await bn(n, e, { mapToTemplate: !0 }) === t) return e;
|
|
26621
|
+
let i = await Sn(e, r);
|
|
26525
26622
|
if (i === void 0) return;
|
|
26526
|
-
for (let e of c) if (await
|
|
26623
|
+
for (let e of c) if (await Sn(n, e) === i) return e;
|
|
26527
26624
|
return;
|
|
26528
26625
|
}
|
|
26529
26626
|
return c[0];
|
|
26530
26627
|
}
|
|
26531
26628
|
}
|
|
26532
|
-
async function
|
|
26533
|
-
let r =
|
|
26629
|
+
async function bn(e, t, n) {
|
|
26630
|
+
let r = D[t.tagName];
|
|
26534
26631
|
if (!r) return;
|
|
26535
26632
|
let i = [];
|
|
26536
26633
|
for (let a of r) {
|
|
26537
26634
|
let r = await e.any.getAttribute(t, { name: a.attribute.uuid });
|
|
26538
26635
|
if (!r) continue;
|
|
26539
|
-
let o = n.mapToTemplate ? await
|
|
26636
|
+
let o = n.mapToTemplate ? await xn(e, r, a.target) : r;
|
|
26540
26637
|
i.push(`${a.attribute.uuid}=${o}`);
|
|
26541
26638
|
}
|
|
26542
26639
|
return i.length > 0 ? i.sort().join("|") : void 0;
|
|
26543
26640
|
}
|
|
26544
|
-
async function
|
|
26641
|
+
async function xn(e, t, n) {
|
|
26545
26642
|
for (let r of n) {
|
|
26546
26643
|
let n = (await e.findByAttributes({
|
|
26547
26644
|
tagName: r,
|
|
@@ -26551,19 +26648,19 @@ async function vn(e, t, n) {
|
|
|
26551
26648
|
}
|
|
26552
26649
|
return t;
|
|
26553
26650
|
}
|
|
26554
|
-
async function
|
|
26555
|
-
let n =
|
|
26651
|
+
async function Sn(e, t) {
|
|
26652
|
+
let n = D[t.tagName];
|
|
26556
26653
|
if (!n) return;
|
|
26557
26654
|
let r = [];
|
|
26558
26655
|
for (let i of n) {
|
|
26559
26656
|
let n = await e.any.getAttribute(t, { name: i.attribute.uuid });
|
|
26560
26657
|
if (!n) continue;
|
|
26561
|
-
let a = await
|
|
26658
|
+
let a = await Cn(e, n, i.target);
|
|
26562
26659
|
a !== void 0 && r.push(`${i.attribute.uuid}=${a}`);
|
|
26563
26660
|
}
|
|
26564
26661
|
return r.length > 0 ? r.sort().join("|") : void 0;
|
|
26565
26662
|
}
|
|
26566
|
-
async function
|
|
26663
|
+
async function Cn(e, t, n) {
|
|
26567
26664
|
for (let r of n) {
|
|
26568
26665
|
let n = (await e.findByAttributes({
|
|
26569
26666
|
tagName: r,
|
|
@@ -26572,8 +26669,8 @@ async function yn(e, t, n) {
|
|
|
26572
26669
|
if (n) return await e.any.getAttribute(n, { name: "name" }) || void 0;
|
|
26573
26670
|
}
|
|
26574
26671
|
}
|
|
26575
|
-
function
|
|
26576
|
-
let t = e.tree.map((e) =>
|
|
26672
|
+
function wn(e) {
|
|
26673
|
+
let t = e.tree.map((e) => wn(e));
|
|
26577
26674
|
return {
|
|
26578
26675
|
change: "added",
|
|
26579
26676
|
tagName: e.tagName,
|
|
@@ -26581,8 +26678,8 @@ function bn(e) {
|
|
|
26581
26678
|
children: t
|
|
26582
26679
|
};
|
|
26583
26680
|
}
|
|
26584
|
-
function
|
|
26585
|
-
let t = e.tree.map((e) =>
|
|
26681
|
+
function Tn(e) {
|
|
26682
|
+
let t = e.tree.map((e) => Tn(e));
|
|
26586
26683
|
return {
|
|
26587
26684
|
change: "removed",
|
|
26588
26685
|
tagName: e.tagName,
|
|
@@ -26590,7 +26687,7 @@ function xn(e) {
|
|
|
26590
26687
|
children: t
|
|
26591
26688
|
};
|
|
26592
26689
|
}
|
|
26593
|
-
function
|
|
26690
|
+
function En(e) {
|
|
26594
26691
|
return {
|
|
26595
26692
|
change: "unchanged",
|
|
26596
26693
|
tagName: e.tagName,
|
|
@@ -26598,26 +26695,26 @@ function Sn(e) {
|
|
|
26598
26695
|
children: []
|
|
26599
26696
|
};
|
|
26600
26697
|
}
|
|
26601
|
-
async function
|
|
26698
|
+
async function Dn(e, t) {
|
|
26602
26699
|
let n = /* @__PURE__ */ new Set();
|
|
26603
26700
|
for (let r of t.tree) {
|
|
26604
26701
|
if (!A.has(r.tagName)) continue;
|
|
26605
|
-
let t = await
|
|
26702
|
+
let t = await bn(e, r, { mapToTemplate: !1 });
|
|
26606
26703
|
t && n.add(t);
|
|
26607
|
-
let i = await
|
|
26704
|
+
let i = await Sn(e, r);
|
|
26608
26705
|
i && n.add(i);
|
|
26609
26706
|
}
|
|
26610
26707
|
return n;
|
|
26611
26708
|
}
|
|
26612
|
-
async function
|
|
26709
|
+
async function On(e, t, n) {
|
|
26613
26710
|
if (n.size === 0) return !1;
|
|
26614
|
-
let r = await
|
|
26711
|
+
let r = await bn(e, t, { mapToTemplate: !0 });
|
|
26615
26712
|
if (r && n.has(r)) return !0;
|
|
26616
|
-
let i = await
|
|
26713
|
+
let i = await Sn(e, t);
|
|
26617
26714
|
return !!i && n.has(i);
|
|
26618
26715
|
}
|
|
26619
|
-
function
|
|
26620
|
-
let t = e.tree.map((e) =>
|
|
26716
|
+
function kn(e) {
|
|
26717
|
+
let t = e.tree.map((e) => kn(e));
|
|
26621
26718
|
return {
|
|
26622
26719
|
change: "target-only",
|
|
26623
26720
|
tagName: e.tagName,
|
|
@@ -26625,17 +26722,17 @@ function Tn(e) {
|
|
|
26625
26722
|
children: t
|
|
26626
26723
|
};
|
|
26627
26724
|
}
|
|
26628
|
-
function
|
|
26629
|
-
if (!
|
|
26725
|
+
function An(e, t) {
|
|
26726
|
+
if (!gn.has(e.tagName)) {
|
|
26630
26727
|
if (e.tagName === "Private") {
|
|
26631
|
-
for (let n of e.tree)
|
|
26728
|
+
for (let n of e.tree) An(n, t);
|
|
26632
26729
|
return;
|
|
26633
26730
|
}
|
|
26634
|
-
t.push(
|
|
26731
|
+
t.push(kn(e));
|
|
26635
26732
|
}
|
|
26636
26733
|
}
|
|
26637
|
-
async function
|
|
26638
|
-
let { targetQuery: n, sourceNode: r, instanceNode: i } = t, a =
|
|
26734
|
+
async function jn(e, t) {
|
|
26735
|
+
let { targetQuery: n, sourceNode: r, instanceNode: i } = t, a = hn(await e.any.getAttributes(r)), o = hn(await n.any.getAttributes(i)), s = [];
|
|
26639
26736
|
for (let e of new Set([...Object.keys(a), ...Object.keys(o)])) {
|
|
26640
26737
|
let t = o[e], n = a[e];
|
|
26641
26738
|
t !== n && s.push({
|
|
@@ -26646,25 +26743,26 @@ async function Dn(e, t) {
|
|
|
26646
26743
|
}
|
|
26647
26744
|
return s;
|
|
26648
26745
|
}
|
|
26649
|
-
async function
|
|
26650
|
-
let { node: n, index: r } = t,
|
|
26651
|
-
|
|
26652
|
-
for (let t of n.tree) await
|
|
26746
|
+
async function Mn(e, t) {
|
|
26747
|
+
let { node: n, index: r, matchKey: i } = t, a = await e.any.getAttribute(n, { name: i });
|
|
26748
|
+
a && r.set(a, n);
|
|
26749
|
+
for (let t of n.tree) await Mn(e, {
|
|
26653
26750
|
node: t,
|
|
26654
|
-
index: r
|
|
26751
|
+
index: r,
|
|
26752
|
+
matchKey: i
|
|
26655
26753
|
});
|
|
26656
26754
|
}
|
|
26657
|
-
async function
|
|
26755
|
+
async function Nn(e, t) {
|
|
26658
26756
|
let { node: n, out: r } = t, i = await e.any.getAttribute(n, { name: "uuid" });
|
|
26659
26757
|
i && r.add(i);
|
|
26660
|
-
for (let t of n.tree) await
|
|
26758
|
+
for (let t of n.tree) await Nn(e, {
|
|
26661
26759
|
node: t,
|
|
26662
26760
|
out: r
|
|
26663
26761
|
});
|
|
26664
26762
|
}
|
|
26665
|
-
function
|
|
26763
|
+
function Pn(e) {
|
|
26666
26764
|
let t = e.reduce((e, t) => {
|
|
26667
|
-
let n =
|
|
26765
|
+
let n = Fn(t.tree);
|
|
26668
26766
|
return {
|
|
26669
26767
|
added: e.added + n.added,
|
|
26670
26768
|
removed: e.removed + n.removed,
|
|
@@ -26681,10 +26779,10 @@ function An(e) {
|
|
|
26681
26779
|
summary: t
|
|
26682
26780
|
};
|
|
26683
26781
|
}
|
|
26684
|
-
function
|
|
26782
|
+
function U(e) {
|
|
26685
26783
|
return e.instances.flatMap((e) => e.groups);
|
|
26686
26784
|
}
|
|
26687
|
-
function
|
|
26785
|
+
function Fn(e) {
|
|
26688
26786
|
let t = {
|
|
26689
26787
|
added: 0,
|
|
26690
26788
|
removed: 0,
|
|
@@ -26697,58 +26795,58 @@ function jn(e) {
|
|
|
26697
26795
|
}
|
|
26698
26796
|
//#endregion
|
|
26699
26797
|
//#region src/v2019C1/extensions/lifecycle/constraints/classify-attribute.constants.ts
|
|
26700
|
-
var
|
|
26798
|
+
var In = new Set([
|
|
26701
26799
|
"uuid",
|
|
26702
26800
|
"templateUuid",
|
|
26703
26801
|
"originUuid"
|
|
26704
|
-
]),
|
|
26705
|
-
function
|
|
26706
|
-
let t =
|
|
26802
|
+
]), Ln = ["rename", "free"], Rn = /* @__PURE__ */ new Map();
|
|
26803
|
+
function zn(e) {
|
|
26804
|
+
let t = Rn.get(e);
|
|
26707
26805
|
if (t) return t;
|
|
26708
26806
|
let n = _[e]?.attributes?.identityFields ?? [], r = new Set(n);
|
|
26709
|
-
return
|
|
26807
|
+
return Rn.set(e, r), r;
|
|
26710
26808
|
}
|
|
26711
26809
|
//#endregion
|
|
26712
26810
|
//#region src/v2019C1/extensions/lifecycle/constraints/classify-attribute.ts
|
|
26713
|
-
function
|
|
26714
|
-
return
|
|
26811
|
+
function W(e, t) {
|
|
26812
|
+
return In.has(t) ? "identity" : Hn(e).has(t) || Un(e).has(t) ? "reference" : t === "name" ? "rename" : se.has(t) || zn(e).has(t) ? "identity" : "free";
|
|
26715
26813
|
}
|
|
26716
|
-
function
|
|
26717
|
-
return
|
|
26814
|
+
function Bn(e) {
|
|
26815
|
+
return Ln.includes(e);
|
|
26718
26816
|
}
|
|
26719
|
-
function
|
|
26817
|
+
function Vn(e) {
|
|
26720
26818
|
let t = Object.keys(g[e] ?? {}), n = [];
|
|
26721
26819
|
for (let r of t) {
|
|
26722
|
-
let t =
|
|
26723
|
-
|
|
26820
|
+
let t = W(e, r);
|
|
26821
|
+
Bn(t) && n.push({
|
|
26724
26822
|
attr: r,
|
|
26725
26823
|
mode: t
|
|
26726
26824
|
});
|
|
26727
26825
|
}
|
|
26728
26826
|
return n;
|
|
26729
26827
|
}
|
|
26730
|
-
function
|
|
26731
|
-
let t =
|
|
26732
|
-
if (!t) return
|
|
26828
|
+
function Hn(e) {
|
|
26829
|
+
let t = D[e];
|
|
26830
|
+
if (!t) return Wn;
|
|
26733
26831
|
let n = /* @__PURE__ */ new Set();
|
|
26734
26832
|
for (let e of t) n.add(e.attribute.path), n.add(e.attribute.uuid);
|
|
26735
26833
|
return n;
|
|
26736
26834
|
}
|
|
26737
|
-
function
|
|
26738
|
-
let t =
|
|
26739
|
-
return t ? new Set(t) :
|
|
26835
|
+
function Un(e) {
|
|
26836
|
+
let t = F.get(e);
|
|
26837
|
+
return t ? new Set(t) : Wn;
|
|
26740
26838
|
}
|
|
26741
|
-
var
|
|
26839
|
+
var Wn = /* @__PURE__ */ new Set();
|
|
26742
26840
|
//#endregion
|
|
26743
26841
|
//#region src/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.ts
|
|
26744
|
-
async function
|
|
26745
|
-
let { parentRef: n, childTag: r, candidate: i, excludeId: a } = t, o =
|
|
26842
|
+
async function G(e, t) {
|
|
26843
|
+
let { parentRef: n, childTag: r, candidate: i, excludeId: a } = t, o = Kn(n.tagName).filter((e) => (e.kind === "unique" || e.kind === "key") && qn(e, r));
|
|
26746
26844
|
if (o.length === 0) return null;
|
|
26747
26845
|
let s = (await e.any.getTree(n))?.tree ?? [];
|
|
26748
26846
|
for (let e of o) {
|
|
26749
|
-
let t =
|
|
26847
|
+
let t = Jn(e);
|
|
26750
26848
|
if (!(t.length === 0 || t.some((e) => i[e] === void 0))) {
|
|
26751
|
-
for (let n of s) if (n.id !== a &&
|
|
26849
|
+
for (let n of s) if (n.id !== a && qn(e, n.tagName) && t.every((e) => Gn(n, e) === i[e])) return {
|
|
26752
26850
|
constraint: e.name,
|
|
26753
26851
|
fields: t,
|
|
26754
26852
|
offendingId: n.id
|
|
@@ -26757,41 +26855,41 @@ async function K(e, t) {
|
|
|
26757
26855
|
}
|
|
26758
26856
|
return null;
|
|
26759
26857
|
}
|
|
26760
|
-
function
|
|
26858
|
+
function Gn(e, t) {
|
|
26761
26859
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
26762
26860
|
}
|
|
26763
|
-
function
|
|
26861
|
+
function Kn(e) {
|
|
26764
26862
|
return [..._[e]?.constraints ?? []];
|
|
26765
26863
|
}
|
|
26766
|
-
function
|
|
26864
|
+
function qn(e, t) {
|
|
26767
26865
|
for (let n of e.selector ?? []) {
|
|
26768
26866
|
let e = (n.steps ?? []).at(-1);
|
|
26769
26867
|
if (e && (e.kind === "wildcard" || e.kind === "name" && e.value === t)) return !0;
|
|
26770
26868
|
}
|
|
26771
26869
|
return !1;
|
|
26772
26870
|
}
|
|
26773
|
-
function
|
|
26871
|
+
function Jn(e) {
|
|
26774
26872
|
return (e.fields ?? []).map((e) => e.target?.value).filter((e) => !!e);
|
|
26775
26873
|
}
|
|
26776
26874
|
//#endregion
|
|
26777
26875
|
//#region src/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.ts
|
|
26778
|
-
var
|
|
26779
|
-
async function
|
|
26876
|
+
var Yn = 1e3;
|
|
26877
|
+
async function Xn(e, t) {
|
|
26780
26878
|
let { parentRef: n, childTag: r, candidate: i, attr: a, decorate: o, excludeId: s } = t, c = i[a] ?? "";
|
|
26781
|
-
if (!await
|
|
26879
|
+
if (!await G(e, {
|
|
26782
26880
|
parentRef: n,
|
|
26783
26881
|
childTag: r,
|
|
26784
26882
|
candidate: i,
|
|
26785
26883
|
excludeId: s
|
|
26786
26884
|
})) return c;
|
|
26787
|
-
for (let t = 1; t <=
|
|
26885
|
+
for (let t = 1; t <= Yn; t++) {
|
|
26788
26886
|
let l = o ? o({
|
|
26789
26887
|
base: c,
|
|
26790
26888
|
attempt: t,
|
|
26791
26889
|
attr: a,
|
|
26792
26890
|
childTag: r
|
|
26793
26891
|
}) : `${c}_${t}`;
|
|
26794
|
-
if (!await
|
|
26892
|
+
if (!await G(e, {
|
|
26795
26893
|
parentRef: n,
|
|
26796
26894
|
childTag: r,
|
|
26797
26895
|
candidate: {
|
|
@@ -26801,22 +26899,22 @@ async function Kn(e, t) {
|
|
|
26801
26899
|
excludeId: s
|
|
26802
26900
|
})) return l;
|
|
26803
26901
|
}
|
|
26804
|
-
throw Error(`could not resolve a unique ${a} for <${r}> under <${n.tagName}> after ${
|
|
26902
|
+
throw Error(`could not resolve a unique ${a} for <${r}> under <${n.tagName}> after ${Yn} attempts`);
|
|
26805
26903
|
}
|
|
26806
26904
|
//#endregion
|
|
26807
26905
|
//#region src/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.ts
|
|
26808
|
-
async function
|
|
26906
|
+
async function K(e, t) {
|
|
26809
26907
|
let { ref: n, decorate: r, overrides: i } = t, a = t.parentRef ?? (await e.getRecord(n))?.parent;
|
|
26810
26908
|
if (!a) return { status: "ok" };
|
|
26811
26909
|
let o = await e.getAttributes(n);
|
|
26812
26910
|
if (i) for (let [t, r] of Object.entries(i)) {
|
|
26813
|
-
let i =
|
|
26911
|
+
let i = W(n.tagName, t);
|
|
26814
26912
|
(i === "rename" || i === "free") && o[t] !== r && (await e.update(n, { attributes: { [t]: r } }), o = {
|
|
26815
26913
|
...o,
|
|
26816
26914
|
[t]: r
|
|
26817
26915
|
});
|
|
26818
26916
|
}
|
|
26819
|
-
let s = await
|
|
26917
|
+
let s = await G(e, {
|
|
26820
26918
|
parentRef: a,
|
|
26821
26919
|
childTag: n.tagName,
|
|
26822
26920
|
candidate: o,
|
|
@@ -26824,14 +26922,14 @@ async function qn(e, t) {
|
|
|
26824
26922
|
});
|
|
26825
26923
|
if (!s) return { status: "ok" };
|
|
26826
26924
|
let c = s.fields.find((e) => {
|
|
26827
|
-
let t =
|
|
26925
|
+
let t = W(n.tagName, e);
|
|
26828
26926
|
return t === "rename" || t === "free";
|
|
26829
26927
|
});
|
|
26830
26928
|
if (!c) return {
|
|
26831
26929
|
status: "unresolvable",
|
|
26832
26930
|
violation: s
|
|
26833
26931
|
};
|
|
26834
|
-
let l = o[c] ?? "", u = await
|
|
26932
|
+
let l = o[c] ?? "", u = await Xn(e, {
|
|
26835
26933
|
parentRef: a,
|
|
26836
26934
|
childTag: n.tagName,
|
|
26837
26935
|
candidate: o,
|
|
@@ -26848,12 +26946,12 @@ async function qn(e, t) {
|
|
|
26848
26946
|
}
|
|
26849
26947
|
//#endregion
|
|
26850
26948
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/clone-tree.ts
|
|
26851
|
-
var
|
|
26949
|
+
var Zn = {
|
|
26852
26950
|
scope: "tree",
|
|
26853
26951
|
attributes: ["templateUuid", "originUuid"]
|
|
26854
26952
|
};
|
|
26855
26953
|
async function q(e, t) {
|
|
26856
|
-
let { sourceQuery: n, ref: i, targetParent: a, omit: o, retagRoot: s, strip: c =
|
|
26954
|
+
let { sourceQuery: n, ref: i, targetParent: a, omit: o, retagRoot: s, strip: c = Zn } = t, l = await n.getTree(i, {
|
|
26857
26955
|
omit: o,
|
|
26858
26956
|
unwrap: []
|
|
26859
26957
|
});
|
|
@@ -26869,7 +26967,7 @@ async function q(e, t) {
|
|
|
26869
26967
|
}
|
|
26870
26968
|
//#endregion
|
|
26871
26969
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/add-children-to.ts
|
|
26872
|
-
async function
|
|
26970
|
+
async function Qn(e, t) {
|
|
26873
26971
|
let { sourceQuery: n, source: r, target: i, omit: a, strip: o } = t, s = await n.any.getRecord(r);
|
|
26874
26972
|
if (!s) return [];
|
|
26875
26973
|
let c = [];
|
|
@@ -26890,14 +26988,14 @@ async function Yn(e, t) {
|
|
|
26890
26988
|
}
|
|
26891
26989
|
//#endregion
|
|
26892
26990
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/deep.ts
|
|
26893
|
-
async function
|
|
26894
|
-
let { sourceQuery: n, ref: r, targetParent: i, withTypes: a = !0, omit: o, strip: s = !1, retagRoot: c } = t, l = await
|
|
26991
|
+
async function J(e, t) {
|
|
26992
|
+
let { sourceQuery: n, ref: r, targetParent: i, withTypes: a = !0, omit: o, strip: s = !1, retagRoot: c } = t, l = await $n(e, {
|
|
26895
26993
|
sourceQuery: n,
|
|
26896
26994
|
ref: r,
|
|
26897
26995
|
targetParent: i
|
|
26898
26996
|
}), u, d;
|
|
26899
26997
|
if (l) {
|
|
26900
|
-
d = await
|
|
26998
|
+
d = await Qn(e, {
|
|
26901
26999
|
sourceQuery: n,
|
|
26902
27000
|
source: r,
|
|
26903
27001
|
target: l,
|
|
@@ -26921,10 +27019,10 @@ async function Xn(e, t) {
|
|
|
26921
27019
|
}
|
|
26922
27020
|
let f = /* @__PURE__ */ new Map();
|
|
26923
27021
|
if (a) {
|
|
26924
|
-
let t = await
|
|
27022
|
+
let t = await er(n, r);
|
|
26925
27023
|
if (t.length > 0) {
|
|
26926
27024
|
let r = typeof a == "object" ? a.keepNameFrom : void 0;
|
|
26927
|
-
f = (await
|
|
27025
|
+
f = (await It(e, {
|
|
26928
27026
|
sourceQuery: n,
|
|
26929
27027
|
records: t,
|
|
26930
27028
|
cloneMappings: d,
|
|
@@ -26938,7 +27036,7 @@ async function Xn(e, t) {
|
|
|
26938
27036
|
recordMappings: d
|
|
26939
27037
|
};
|
|
26940
27038
|
}
|
|
26941
|
-
async function
|
|
27039
|
+
async function $n(e, t) {
|
|
26942
27040
|
let { sourceQuery: n, ref: r, targetParent: i } = t;
|
|
26943
27041
|
if (r.tagName !== "Private") return;
|
|
26944
27042
|
let a = (await n.any.getAttributes(r)).type;
|
|
@@ -26949,7 +27047,7 @@ async function Zn(e, t) {
|
|
|
26949
27047
|
id: t.id
|
|
26950
27048
|
};
|
|
26951
27049
|
}
|
|
26952
|
-
async function
|
|
27050
|
+
async function er(e, t) {
|
|
26953
27051
|
let { LNode: n = [], LN: r = [], LN0: i = [] } = await e.findDescendants(t, { collect: [
|
|
26954
27052
|
"LNode",
|
|
26955
27053
|
"LN",
|
|
@@ -26963,8 +27061,8 @@ async function Qn(e, t) {
|
|
|
26963
27061
|
}
|
|
26964
27062
|
//#endregion
|
|
26965
27063
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/clone-referenced.ts
|
|
26966
|
-
async function
|
|
26967
|
-
let { sourceQuery: n, scopeRef: r, refTagName: i, targetTagName: a, alreadyCloned: o } = t, s =
|
|
27064
|
+
async function tr(e, t) {
|
|
27065
|
+
let { sourceQuery: n, scopeRef: r, refTagName: i, targetTagName: a, alreadyCloned: o } = t, s = D[i][0].attribute.uuid, { [i]: c = [] } = await n.findDescendants(r, { collect: i }), l = /* @__PURE__ */ new Set();
|
|
26968
27066
|
for (let e of c) {
|
|
26969
27067
|
let t = e.attributes.find((e) => e.name === s)?.value;
|
|
26970
27068
|
t && l.add(t);
|
|
@@ -26987,8 +27085,8 @@ async function $n(e, t) {
|
|
|
26987
27085
|
}
|
|
26988
27086
|
return u;
|
|
26989
27087
|
}
|
|
26990
|
-
async function
|
|
26991
|
-
let { sourceQuery: n, scopeRef: r, refTagName: i, targetTagName: a, resolveTargetParent: o, alreadyCloned: s, omit: c } = t, l = await
|
|
27088
|
+
async function nr(e, t) {
|
|
27089
|
+
let { sourceQuery: n, scopeRef: r, refTagName: i, targetTagName: a, resolveTargetParent: o, alreadyCloned: s, omit: c } = t, l = await tr(e, {
|
|
26992
27090
|
sourceQuery: n,
|
|
26993
27091
|
scopeRef: r,
|
|
26994
27092
|
refTagName: i,
|
|
@@ -27006,9 +27104,9 @@ async function er(e, t) {
|
|
|
27006
27104
|
}
|
|
27007
27105
|
return u;
|
|
27008
27106
|
}
|
|
27009
|
-
async function
|
|
27010
|
-
let { sourceQuery: n, scopeTagName: r, scopeRef: i, resolveTargetParent: a, alreadyCloned: o, skip: s = /* @__PURE__ */ new Set(), omit: c } = t, l = (p[r] ?? []).filter((e) => e in
|
|
27011
|
-
for (let t of l) for (let r of
|
|
27107
|
+
async function rr(e, t) {
|
|
27108
|
+
let { sourceQuery: n, scopeTagName: r, scopeRef: i, resolveTargetParent: a, alreadyCloned: o, skip: s = /* @__PURE__ */ new Set(), omit: c } = t, l = (p[r] ?? []).filter((e) => e in D && !s.has(e)), u = nr, d = [];
|
|
27109
|
+
for (let t of l) for (let r of D[t]) for (let s of r.target) {
|
|
27012
27110
|
let r = await u(e, {
|
|
27013
27111
|
sourceQuery: n,
|
|
27014
27112
|
scopeRef: i,
|
|
@@ -27024,7 +27122,7 @@ async function tr(e, t) {
|
|
|
27024
27122
|
}
|
|
27025
27123
|
//#endregion
|
|
27026
27124
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/merge-children-into.ts
|
|
27027
|
-
async function
|
|
27125
|
+
async function ir(e, t) {
|
|
27028
27126
|
let { sourceQuery: n, source: r, target: i, strip: a } = t, o = await n.any.getRecord(r);
|
|
27029
27127
|
if (!o) return [];
|
|
27030
27128
|
let s = [];
|
|
@@ -27032,9 +27130,9 @@ async function nr(e, t) {
|
|
|
27032
27130
|
let r = {
|
|
27033
27131
|
tagName: t.tagName,
|
|
27034
27132
|
id: t.id
|
|
27035
|
-
}, o = await n.any.getAttribute(t, { name: "name" }), c = o ? await
|
|
27133
|
+
}, o = await n.any.getAttribute(t, { name: "name" }), c = o ? await ar(e, i, t.tagName, o) : void 0;
|
|
27036
27134
|
if (c) {
|
|
27037
|
-
s.push(...await
|
|
27135
|
+
s.push(...await ir(e, {
|
|
27038
27136
|
sourceQuery: n,
|
|
27039
27137
|
source: r,
|
|
27040
27138
|
target: c,
|
|
@@ -27052,7 +27150,7 @@ async function nr(e, t) {
|
|
|
27052
27150
|
}
|
|
27053
27151
|
return s;
|
|
27054
27152
|
}
|
|
27055
|
-
async function
|
|
27153
|
+
async function ar(e, t, n, r) {
|
|
27056
27154
|
let i = await e.any.getRecord(t);
|
|
27057
27155
|
if (i) {
|
|
27058
27156
|
for (let t of i.children) if (t.tagName === n && await e.any.getAttribute(t, { name: "name" }) === r) return {
|
|
@@ -27063,7 +27161,7 @@ async function rr(e, t, n, r) {
|
|
|
27063
27161
|
}
|
|
27064
27162
|
//#endregion
|
|
27065
27163
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/resolve-structure-ref.ts
|
|
27066
|
-
async function
|
|
27164
|
+
async function Y(e, t, n) {
|
|
27067
27165
|
let r = (await e.findAncestors(t, { stopAtTagName: "Substation" })).find((e) => e.tagName in n);
|
|
27068
27166
|
s(r, {
|
|
27069
27167
|
key: "ELEMENT_NOT_FOUND",
|
|
@@ -27078,7 +27176,7 @@ async function J(e, t, n) {
|
|
|
27078
27176
|
id: i.id
|
|
27079
27177
|
};
|
|
27080
27178
|
}
|
|
27081
|
-
function
|
|
27179
|
+
function or(e) {
|
|
27082
27180
|
let { sourceQuery: t, structure: n, cloneIndex: r } = e;
|
|
27083
27181
|
return async function(e) {
|
|
27084
27182
|
let i = await t.findAncestors(e, { stopAtTagName: "Substation" });
|
|
@@ -27101,189 +27199,198 @@ function ir(e) {
|
|
|
27101
27199
|
}
|
|
27102
27200
|
//#endregion
|
|
27103
27201
|
//#region src/v2019C1/extensions/lifecycle/engine/reconcile.ts
|
|
27104
|
-
async function
|
|
27105
|
-
let { sourceQuery: n, sourceRootRef: r, instanceRootRef: i, accepted: a, overrides: o, keepNameTypesFrom: s } = t,
|
|
27106
|
-
if (!
|
|
27107
|
-
let
|
|
27108
|
-
await
|
|
27109
|
-
node:
|
|
27110
|
-
index:
|
|
27202
|
+
async function sr(e, t) {
|
|
27203
|
+
let { sourceQuery: n, sourceRootRef: r, instanceRootRef: i, accepted: a, overrides: o, keepNameTypesFrom: s, matchKey: c = "templateUuid", identityMode: l = "stamp-template" } = t, u = await n.any.getTree(r), d = await e.any.getTree(i);
|
|
27204
|
+
if (!u || !d) return;
|
|
27205
|
+
let f = /* @__PURE__ */ new Map();
|
|
27206
|
+
await fr(e, {
|
|
27207
|
+
node: d,
|
|
27208
|
+
index: f,
|
|
27209
|
+
matchKey: c
|
|
27111
27210
|
});
|
|
27112
|
-
let
|
|
27113
|
-
await
|
|
27114
|
-
node:
|
|
27115
|
-
out:
|
|
27116
|
-
}), await
|
|
27211
|
+
let p = /* @__PURE__ */ new Set();
|
|
27212
|
+
await pr(n, {
|
|
27213
|
+
node: u,
|
|
27214
|
+
out: p
|
|
27215
|
+
}), await dr(e, {
|
|
27117
27216
|
sourceQuery: n,
|
|
27118
|
-
instanceRecord:
|
|
27119
|
-
sourceNode:
|
|
27217
|
+
instanceRecord: d,
|
|
27218
|
+
sourceNode: u,
|
|
27120
27219
|
accepted: a,
|
|
27121
27220
|
overrides: o
|
|
27122
|
-
}), await
|
|
27221
|
+
}), await cr(e, {
|
|
27123
27222
|
sourceQuery: n,
|
|
27124
|
-
sourceNode:
|
|
27125
|
-
instanceParent:
|
|
27126
|
-
index:
|
|
27223
|
+
sourceNode: u,
|
|
27224
|
+
instanceParent: d,
|
|
27225
|
+
index: f,
|
|
27127
27226
|
accepted: a,
|
|
27128
27227
|
overrides: o,
|
|
27129
|
-
keepNameTypesFrom: s
|
|
27130
|
-
|
|
27131
|
-
|
|
27132
|
-
|
|
27133
|
-
|
|
27228
|
+
keepNameTypesFrom: s,
|
|
27229
|
+
matchKey: c,
|
|
27230
|
+
identityMode: l
|
|
27231
|
+
}), await lr(e, {
|
|
27232
|
+
instanceNode: d,
|
|
27233
|
+
sourceUuids: p,
|
|
27234
|
+
accepted: a,
|
|
27235
|
+
matchKey: c
|
|
27134
27236
|
});
|
|
27135
27237
|
}
|
|
27136
|
-
async function
|
|
27137
|
-
let { sourceQuery: n, sourceNode: r, instanceParent: i, index: o, accepted: s, overrides: c, keepNameTypesFrom: l } = t,
|
|
27238
|
+
async function cr(e, t) {
|
|
27239
|
+
let { sourceQuery: n, sourceNode: r, instanceParent: i, index: o, accepted: s, overrides: c, keepNameTypesFrom: l, matchKey: u, identityMode: d } = t, f = /* @__PURE__ */ new Set();
|
|
27138
27240
|
for (let t of r.tree) {
|
|
27139
|
-
let r = await n.any.getAttribute(t, { name: "uuid" }),
|
|
27140
|
-
if (
|
|
27141
|
-
|
|
27241
|
+
let r = await n.any.getAttribute(t, { name: "uuid" }), p = (r ? o.get(r) : void 0) ?? (r ? void 0 : i.tree.find((e) => e.tagName === t.tagName && !f.has(e.id)));
|
|
27242
|
+
if (p) {
|
|
27243
|
+
f.add(p.id), await dr(e, {
|
|
27142
27244
|
sourceQuery: n,
|
|
27143
|
-
instanceRecord:
|
|
27245
|
+
instanceRecord: p,
|
|
27144
27246
|
sourceNode: t,
|
|
27145
27247
|
accepted: s,
|
|
27146
27248
|
overrides: c
|
|
27147
|
-
}), await
|
|
27249
|
+
}), await cr(e, {
|
|
27148
27250
|
sourceQuery: n,
|
|
27149
27251
|
sourceNode: t,
|
|
27150
|
-
instanceParent:
|
|
27252
|
+
instanceParent: p,
|
|
27151
27253
|
index: o,
|
|
27152
27254
|
accepted: s,
|
|
27153
27255
|
overrides: c,
|
|
27154
|
-
keepNameTypesFrom: l
|
|
27256
|
+
keepNameTypesFrom: l,
|
|
27257
|
+
matchKey: u,
|
|
27258
|
+
identityMode: d
|
|
27155
27259
|
});
|
|
27156
27260
|
continue;
|
|
27157
27261
|
}
|
|
27158
27262
|
if (s && !s.sourceIds.has(t.id)) continue;
|
|
27159
|
-
let { recordMappings:
|
|
27263
|
+
let { recordMappings: m } = await J(e, {
|
|
27160
27264
|
sourceQuery: n,
|
|
27161
27265
|
ref: a(t),
|
|
27162
27266
|
targetParent: a(i),
|
|
27163
27267
|
strip: !1,
|
|
27164
27268
|
withTypes: { keepNameFrom: l }
|
|
27165
27269
|
});
|
|
27166
|
-
await
|
|
27167
|
-
mappings:
|
|
27168
|
-
mode:
|
|
27169
|
-
});
|
|
27170
|
-
let
|
|
27171
|
-
|
|
27172
|
-
ref:
|
|
27270
|
+
await H(e, {
|
|
27271
|
+
mappings: m,
|
|
27272
|
+
mode: d
|
|
27273
|
+
}), d === "keep" && await on(e, { mappings: m });
|
|
27274
|
+
let h = m.find((e) => e.source.id === t.id);
|
|
27275
|
+
h && d !== "keep" && await K(e, {
|
|
27276
|
+
ref: h.target,
|
|
27173
27277
|
parentRef: a(i),
|
|
27174
27278
|
overrides: c?.get(t.id)
|
|
27175
27279
|
});
|
|
27176
27280
|
}
|
|
27177
|
-
for (let t of i.tree) if (!
|
|
27178
|
-
if (A.has(t.tagName) && !
|
|
27281
|
+
for (let t of i.tree) if (!f.has(t.id) && !await e.any.getAttribute(t, { name: "templateUuid" })) {
|
|
27282
|
+
if (A.has(t.tagName) && !O.has(t.tagName)) {
|
|
27179
27283
|
if (s && !s.instanceIds.has(t.id)) continue;
|
|
27180
27284
|
} else if (!s || !s.instanceIds.has(t.id)) continue;
|
|
27181
27285
|
await e.any.getRecord(t) && await e.any.delete(t);
|
|
27182
27286
|
}
|
|
27183
27287
|
}
|
|
27184
|
-
async function
|
|
27185
|
-
let { instanceNode: n, sourceUuids: r, accepted: i } = t,
|
|
27186
|
-
await
|
|
27288
|
+
async function lr(e, t) {
|
|
27289
|
+
let { instanceNode: n, sourceUuids: r, accepted: i, matchKey: a } = t, o = [];
|
|
27290
|
+
await ur(e, {
|
|
27187
27291
|
node: n,
|
|
27188
27292
|
sourceUuids: r,
|
|
27189
27293
|
accepted: i,
|
|
27190
|
-
|
|
27294
|
+
matchKey: a,
|
|
27295
|
+
out: o
|
|
27191
27296
|
});
|
|
27192
|
-
for (let t of
|
|
27297
|
+
for (let t of o) await e.any.getRecord(t) && await e.any.delete(t);
|
|
27193
27298
|
}
|
|
27194
|
-
async function
|
|
27195
|
-
let { node: n, sourceUuids: r, accepted: i,
|
|
27196
|
-
if (
|
|
27197
|
-
(!i || i.instanceIds.has(n.id)) &&
|
|
27299
|
+
async function ur(e, t) {
|
|
27300
|
+
let { node: n, sourceUuids: r, accepted: i, matchKey: a, out: o } = t, s = await e.any.getAttribute(n, { name: a });
|
|
27301
|
+
if (s && !r.has(s)) {
|
|
27302
|
+
(!i || i.instanceIds.has(n.id)) && o.push(n);
|
|
27198
27303
|
return;
|
|
27199
27304
|
}
|
|
27200
|
-
for (let t of n.tree) await
|
|
27305
|
+
for (let t of n.tree) await ur(e, {
|
|
27201
27306
|
node: t,
|
|
27202
27307
|
sourceUuids: r,
|
|
27203
27308
|
accepted: i,
|
|
27204
|
-
|
|
27309
|
+
matchKey: a,
|
|
27310
|
+
out: o
|
|
27205
27311
|
});
|
|
27206
27312
|
}
|
|
27207
|
-
async function
|
|
27313
|
+
async function dr(e, t) {
|
|
27208
27314
|
let { sourceQuery: n, instanceRecord: r, sourceNode: i, accepted: a, overrides: o } = t;
|
|
27209
27315
|
if (a && !a.sourceIds.has(i.id)) return;
|
|
27210
27316
|
let s = {
|
|
27211
|
-
...
|
|
27317
|
+
...hn(await n.any.getAttributes(i)),
|
|
27212
27318
|
...o?.get(i.id)
|
|
27213
|
-
}, c =
|
|
27319
|
+
}, c = hn(await e.any.getAttributes(r)), l = {};
|
|
27214
27320
|
for (let e of new Set([...Object.keys(s), ...Object.keys(c)])) {
|
|
27215
27321
|
let t = e in s ? s[e] : void 0;
|
|
27216
27322
|
c[e] !== t && (l[e] = t);
|
|
27217
27323
|
}
|
|
27218
|
-
if (r.tagName === "LNode" && Object.keys(l).some((e) =>
|
|
27324
|
+
if (r.tagName === "LNode" && Object.keys(l).some((e) => Ie.has(e)) && await te(e, r)) for (let e of Ie) delete l[e];
|
|
27219
27325
|
Object.keys(l).length > 0 && await e.any.update(r, { attributes: l });
|
|
27220
27326
|
}
|
|
27221
|
-
async function
|
|
27222
|
-
let { node: n, index: r } = t,
|
|
27223
|
-
|
|
27224
|
-
for (let t of n.tree) await
|
|
27327
|
+
async function fr(e, t) {
|
|
27328
|
+
let { node: n, index: r, matchKey: i } = t, a = await e.any.getAttribute(n, { name: i });
|
|
27329
|
+
a && r.set(a, n);
|
|
27330
|
+
for (let t of n.tree) await fr(e, {
|
|
27225
27331
|
node: t,
|
|
27226
|
-
index: r
|
|
27332
|
+
index: r,
|
|
27333
|
+
matchKey: i
|
|
27227
27334
|
});
|
|
27228
27335
|
}
|
|
27229
|
-
async function
|
|
27336
|
+
async function pr(e, t) {
|
|
27230
27337
|
let { node: n, out: r } = t, i = await e.any.getAttribute(n, { name: "uuid" });
|
|
27231
27338
|
i && r.add(i);
|
|
27232
|
-
for (let t of n.tree) await
|
|
27339
|
+
for (let t of n.tree) await pr(e, {
|
|
27233
27340
|
node: t,
|
|
27234
27341
|
out: r
|
|
27235
27342
|
});
|
|
27236
27343
|
}
|
|
27237
27344
|
//#endregion
|
|
27238
27345
|
//#region src/v2019C1/extensions/lifecycle/engine/decide.ts
|
|
27239
|
-
function
|
|
27346
|
+
function mr(e, t) {
|
|
27240
27347
|
return e?.instances.find((e) => e.rootRef?.id === t)?.groups ?? [];
|
|
27241
27348
|
}
|
|
27242
|
-
function
|
|
27349
|
+
function hr(e) {
|
|
27243
27350
|
return e === void 0 ? "accept" : typeof e == "string" ? e : e.action;
|
|
27244
27351
|
}
|
|
27245
|
-
function
|
|
27352
|
+
function gr(e) {
|
|
27246
27353
|
return typeof e == "object" ? e.values : void 0;
|
|
27247
27354
|
}
|
|
27248
|
-
function
|
|
27355
|
+
function _r(e) {
|
|
27249
27356
|
let t = e.decisions.get(e.group.id);
|
|
27250
|
-
return t === void 0 ? e.group.suggestedAction :
|
|
27357
|
+
return t === void 0 ? e.group.suggestedAction : hr(t);
|
|
27251
27358
|
}
|
|
27252
|
-
function
|
|
27253
|
-
return
|
|
27359
|
+
function vr(e) {
|
|
27360
|
+
return _r(e) !== "skip";
|
|
27254
27361
|
}
|
|
27255
|
-
function
|
|
27362
|
+
function yr(e) {
|
|
27256
27363
|
let { groups: t, decisions: n } = e, r = /* @__PURE__ */ new Map();
|
|
27257
27364
|
for (let e of t) {
|
|
27258
27365
|
let t = n.get(e.id);
|
|
27259
|
-
if (
|
|
27366
|
+
if (_r({
|
|
27260
27367
|
group: e,
|
|
27261
27368
|
decisions: n
|
|
27262
27369
|
}) === "skip") continue;
|
|
27263
|
-
let i =
|
|
27370
|
+
let i = gr(t), a = e.primary.sourceRef?.id;
|
|
27264
27371
|
i && a && r.set(a, i);
|
|
27265
27372
|
}
|
|
27266
27373
|
return r;
|
|
27267
27374
|
}
|
|
27268
|
-
function
|
|
27375
|
+
function br(e) {
|
|
27269
27376
|
let { groups: t, decisions: n } = e;
|
|
27270
|
-
for (let e of t) if (
|
|
27377
|
+
for (let e of t) if (vr({
|
|
27271
27378
|
group: e,
|
|
27272
27379
|
decisions: n
|
|
27273
|
-
})) for (let r of e.dependsOn) s(
|
|
27274
|
-
group:
|
|
27380
|
+
})) for (let r of e.dependsOn) s(vr({
|
|
27381
|
+
group: xr(t, r) ?? e,
|
|
27275
27382
|
decisions: n
|
|
27276
27383
|
}), { detail: `decision accepts group "${e.id}" but its dependency "${r}" is skipped` });
|
|
27277
27384
|
}
|
|
27278
|
-
function
|
|
27385
|
+
function xr(e, t) {
|
|
27279
27386
|
return e.find((e) => e.id === t);
|
|
27280
27387
|
}
|
|
27281
|
-
function
|
|
27388
|
+
function Sr(e) {
|
|
27282
27389
|
let { groups: t, decisions: n } = e, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
|
|
27283
|
-
for (let e of t) if (
|
|
27390
|
+
for (let e of t) if (vr({
|
|
27284
27391
|
group: e,
|
|
27285
27392
|
decisions: n
|
|
27286
|
-
})) for (let t of [e.primary, ...e.companions])
|
|
27393
|
+
})) for (let t of [e.primary, ...e.companions]) Cr({
|
|
27287
27394
|
node: t,
|
|
27288
27395
|
sourceIds: r,
|
|
27289
27396
|
instanceIds: i
|
|
@@ -27293,69 +27400,71 @@ function br(e) {
|
|
|
27293
27400
|
instanceIds: i
|
|
27294
27401
|
};
|
|
27295
27402
|
}
|
|
27296
|
-
function
|
|
27403
|
+
function Cr(e) {
|
|
27297
27404
|
let { node: t, sourceIds: n, instanceIds: r } = e;
|
|
27298
|
-
|
|
27405
|
+
wr({
|
|
27299
27406
|
node: t,
|
|
27300
27407
|
sourceIds: n,
|
|
27301
27408
|
instanceIds: r
|
|
27302
27409
|
});
|
|
27303
|
-
for (let e of t.children)
|
|
27410
|
+
for (let e of t.children) Cr({
|
|
27304
27411
|
node: e,
|
|
27305
27412
|
sourceIds: n,
|
|
27306
27413
|
instanceIds: r
|
|
27307
27414
|
});
|
|
27308
27415
|
}
|
|
27309
|
-
function
|
|
27416
|
+
function wr(e) {
|
|
27310
27417
|
let { node: t, sourceIds: n, instanceIds: r } = e;
|
|
27311
27418
|
t.change !== "unchanged" && (t.change === "removed" || t.change === "target-only" ? t.instanceRef?.id && r.add(t.instanceRef.id) : t.sourceRef?.id && n.add(t.sourceRef.id));
|
|
27312
27419
|
}
|
|
27313
27420
|
//#endregion
|
|
27314
27421
|
//#region src/v2019C1/extensions/lifecycle/instance/composed-functions.ts
|
|
27315
|
-
async function
|
|
27422
|
+
async function Tr(e, t) {
|
|
27316
27423
|
let n = /* @__PURE__ */ new Set(), r = await e.any.getTree(t);
|
|
27317
|
-
return r && await
|
|
27424
|
+
return r && await Er(e, r, n), n;
|
|
27318
27425
|
}
|
|
27319
|
-
async function
|
|
27426
|
+
async function Er(e, t, n) {
|
|
27320
27427
|
if (t.tagName === "FunctionRef") {
|
|
27321
27428
|
let r = await e.any.getAttribute(t, { name: "functionUuid" });
|
|
27322
27429
|
r && n.add(r);
|
|
27323
27430
|
}
|
|
27324
|
-
for (let r of t.tree) await
|
|
27431
|
+
for (let r of t.tree) await Er(e, r, n);
|
|
27325
27432
|
}
|
|
27326
27433
|
//#endregion
|
|
27327
27434
|
//#region src/v2019C1/extensions/lifecycle/instance/find-instance.ts
|
|
27328
|
-
async function
|
|
27329
|
-
let { targetParent: n, tagName: r, sourceUuid: i } = t;
|
|
27435
|
+
async function Dr(e, t) {
|
|
27436
|
+
let { targetParent: n, tagName: r, sourceUuid: i, matchKey: a = "templateUuid" } = t;
|
|
27330
27437
|
if (!i) return [];
|
|
27331
|
-
let
|
|
27332
|
-
if (!
|
|
27333
|
-
let
|
|
27334
|
-
return await
|
|
27335
|
-
node:
|
|
27438
|
+
let o = await e.any.getTree(n);
|
|
27439
|
+
if (!o) return [];
|
|
27440
|
+
let s = [];
|
|
27441
|
+
return await Or(e, {
|
|
27442
|
+
node: o,
|
|
27336
27443
|
tagName: r,
|
|
27337
27444
|
sourceUuid: i,
|
|
27338
|
-
|
|
27339
|
-
|
|
27445
|
+
matchKey: a,
|
|
27446
|
+
out: s
|
|
27447
|
+
}), s;
|
|
27340
27448
|
}
|
|
27341
|
-
async function
|
|
27342
|
-
let { node: n, tagName: r, sourceUuid: i,
|
|
27343
|
-
if (n.tagName === r && await e.any.getAttribute(n, { name:
|
|
27344
|
-
|
|
27449
|
+
async function Or(e, t) {
|
|
27450
|
+
let { node: n, tagName: r, sourceUuid: i, matchKey: a, out: o } = t;
|
|
27451
|
+
if (n.tagName === r && await e.any.getAttribute(n, { name: a }) === i) {
|
|
27452
|
+
o.push(n);
|
|
27345
27453
|
return;
|
|
27346
27454
|
}
|
|
27347
|
-
for (let t of n.tree) await
|
|
27455
|
+
for (let t of n.tree) await Or(e, {
|
|
27348
27456
|
node: t,
|
|
27349
27457
|
tagName: r,
|
|
27350
27458
|
sourceUuid: i,
|
|
27351
|
-
|
|
27459
|
+
matchKey: a,
|
|
27460
|
+
out: o
|
|
27352
27461
|
});
|
|
27353
27462
|
}
|
|
27354
|
-
async function
|
|
27355
|
-
let [n] = await
|
|
27463
|
+
async function kr(e, t) {
|
|
27464
|
+
let [n] = await X(e, t);
|
|
27356
27465
|
return n;
|
|
27357
27466
|
}
|
|
27358
|
-
async function
|
|
27467
|
+
async function X(e, t) {
|
|
27359
27468
|
let { tagName: n, sourceUuid: r, sourceName: i } = t, a = await e.any.getRecordsByTagName(n), o = [];
|
|
27360
27469
|
if (r) for (let t of a) await e.any.getAttribute(t, { name: "templateUuid" }) === r && o.push(t);
|
|
27361
27470
|
if (o.length > 0) return o;
|
|
@@ -27366,16 +27475,16 @@ async function Y(e, t) {
|
|
|
27366
27475
|
}
|
|
27367
27476
|
//#endregion
|
|
27368
27477
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/satellite-reconcile.ts
|
|
27369
|
-
async function
|
|
27478
|
+
async function Ar(e, t) {
|
|
27370
27479
|
let { sourceQuery: n, satelliteRefs: r, instanceSatelliteRefs: i, structure: a, accepted: o } = t;
|
|
27371
27480
|
for (let t of r) {
|
|
27372
|
-
let { uuid: r, name: i } = await n.any.getAttributes(t), s = await
|
|
27481
|
+
let { uuid: r, name: i } = await n.any.getAttributes(t), s = await kr(e, {
|
|
27373
27482
|
tagName: t.tagName,
|
|
27374
27483
|
sourceUuid: r,
|
|
27375
27484
|
sourceName: i
|
|
27376
27485
|
});
|
|
27377
27486
|
if (s) {
|
|
27378
|
-
await
|
|
27487
|
+
await sr(e, {
|
|
27379
27488
|
sourceQuery: n,
|
|
27380
27489
|
sourceRootRef: t,
|
|
27381
27490
|
instanceRootRef: s,
|
|
@@ -27387,10 +27496,10 @@ async function Or(e, t) {
|
|
|
27387
27496
|
let c = await q(e, {
|
|
27388
27497
|
sourceQuery: n,
|
|
27389
27498
|
ref: t,
|
|
27390
|
-
targetParent: await
|
|
27499
|
+
targetParent: await Y(n, t, a),
|
|
27391
27500
|
strip: !1
|
|
27392
27501
|
});
|
|
27393
|
-
c && await
|
|
27502
|
+
c && await H(e, {
|
|
27394
27503
|
mappings: c.mappings,
|
|
27395
27504
|
mode: "stamp-template"
|
|
27396
27505
|
});
|
|
@@ -27402,26 +27511,26 @@ async function Or(e, t) {
|
|
|
27402
27511
|
tagName: t.tagName,
|
|
27403
27512
|
attributes: { uuid: r }
|
|
27404
27513
|
});
|
|
27405
|
-
i || o && t.id && !o.instanceIds.has(t.id) || (await
|
|
27514
|
+
i || o && t.id && !o.instanceIds.has(t.id) || (await I(e, { target: t })).length > 0 || await e.delete(t);
|
|
27406
27515
|
}
|
|
27407
27516
|
}
|
|
27408
27517
|
//#endregion
|
|
27409
27518
|
//#region src/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.constants.ts
|
|
27410
|
-
var
|
|
27519
|
+
var jr = ["Variable", "BehaviorDescription"];
|
|
27411
27520
|
//#endregion
|
|
27412
27521
|
//#region src/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.ts
|
|
27413
|
-
async function
|
|
27522
|
+
async function Z(e, t) {
|
|
27414
27523
|
let { primaryRef: n } = t, r = await e.any.getTree(n);
|
|
27415
27524
|
if (!r) return [];
|
|
27416
27525
|
let i = /* @__PURE__ */ new Set(), o = [];
|
|
27417
|
-
|
|
27526
|
+
Mr({
|
|
27418
27527
|
node: r,
|
|
27419
27528
|
subtreeIds: i,
|
|
27420
27529
|
targets: o
|
|
27421
27530
|
});
|
|
27422
27531
|
let s = /* @__PURE__ */ new Set(), c = [];
|
|
27423
|
-
for (let t of o) for (let n of
|
|
27424
|
-
let r = await
|
|
27532
|
+
for (let t of o) for (let n of jr) {
|
|
27533
|
+
let r = await z.query.findRefsPointingTo(e, {
|
|
27425
27534
|
target: a(t),
|
|
27426
27535
|
containerTagName: n
|
|
27427
27536
|
});
|
|
@@ -27429,10 +27538,10 @@ async function X(e, t) {
|
|
|
27429
27538
|
}
|
|
27430
27539
|
return c;
|
|
27431
27540
|
}
|
|
27432
|
-
function
|
|
27541
|
+
function Mr(e) {
|
|
27433
27542
|
let { node: t, subtreeIds: n, targets: r } = e;
|
|
27434
27543
|
n.add(t.id), t.attributes.some((e) => e.name === "uuid") && r.push(t);
|
|
27435
|
-
for (let e of t.tree)
|
|
27544
|
+
for (let e of t.tree) Mr({
|
|
27436
27545
|
node: e,
|
|
27437
27546
|
subtreeIds: n,
|
|
27438
27547
|
targets: r
|
|
@@ -27440,19 +27549,19 @@ function Ar(e) {
|
|
|
27440
27549
|
}
|
|
27441
27550
|
//#endregion
|
|
27442
27551
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/cross-cutting-satellites.ts
|
|
27443
|
-
async function
|
|
27552
|
+
async function Nr(e, t) {
|
|
27444
27553
|
let { sourceQuery: n, primaryRef: r, instancePrimaryRef: i, structure: a, accepted: o } = t;
|
|
27445
|
-
await
|
|
27554
|
+
await Ar(e, {
|
|
27446
27555
|
sourceQuery: n,
|
|
27447
|
-
satelliteRefs: await
|
|
27448
|
-
instanceSatelliteRefs: i ? await
|
|
27556
|
+
satelliteRefs: await Z(n, { primaryRef: r }),
|
|
27557
|
+
instanceSatelliteRefs: i ? await Z(e, { primaryRef: i }) : [],
|
|
27449
27558
|
structure: a,
|
|
27450
27559
|
accepted: o
|
|
27451
27560
|
});
|
|
27452
27561
|
}
|
|
27453
27562
|
//#endregion
|
|
27454
27563
|
//#region src/v2019C1/extensions/lifecycle/instantiate/transaction/resolve-target-structure.ts
|
|
27455
|
-
async function
|
|
27564
|
+
async function Q(e, t) {
|
|
27456
27565
|
let n = await e.getRecord(t);
|
|
27457
27566
|
s(n, {
|
|
27458
27567
|
key: "ELEMENT_NOT_FOUND",
|
|
@@ -27463,12 +27572,12 @@ async function Z(e, t) {
|
|
|
27463
27572
|
}
|
|
27464
27573
|
//#endregion
|
|
27465
27574
|
//#region src/v2019C1/extensions/lifecycle/cross-cutting/clone-applied-satellites.ts
|
|
27466
|
-
async function
|
|
27467
|
-
let { sourceQuery: n, primaryRef: r, structure: i, strip: a = !0 } = t, o = await
|
|
27575
|
+
async function Pr(e, t) {
|
|
27576
|
+
let { sourceQuery: n, primaryRef: r, structure: i, strip: a = !0 } = t, o = await Z(n, { primaryRef: r }), s = [];
|
|
27468
27577
|
for (let t of o) {
|
|
27469
|
-
let r = await
|
|
27578
|
+
let r = await Fr(e, n, t);
|
|
27470
27579
|
if (r) {
|
|
27471
|
-
let i = await
|
|
27580
|
+
let i = await ir(e, {
|
|
27472
27581
|
sourceQuery: n,
|
|
27473
27582
|
source: t,
|
|
27474
27583
|
target: r,
|
|
@@ -27480,14 +27589,14 @@ async function Mr(e, t) {
|
|
|
27480
27589
|
let o = await q(e, {
|
|
27481
27590
|
sourceQuery: n,
|
|
27482
27591
|
ref: t,
|
|
27483
|
-
targetParent: await
|
|
27592
|
+
targetParent: await Y(n, t, i),
|
|
27484
27593
|
...a ? {} : { strip: !1 }
|
|
27485
27594
|
});
|
|
27486
27595
|
o && s.push(...o.mappings);
|
|
27487
27596
|
}
|
|
27488
27597
|
return s;
|
|
27489
27598
|
}
|
|
27490
|
-
async function
|
|
27599
|
+
async function Fr(e, t, n) {
|
|
27491
27600
|
let r = await t.any.getRecord(n);
|
|
27492
27601
|
if (!r) return;
|
|
27493
27602
|
let i = await t.any.getAttribute(r, { name: "name" });
|
|
@@ -27503,8 +27612,8 @@ async function Nr(e, t, n) {
|
|
|
27503
27612
|
}
|
|
27504
27613
|
//#endregion
|
|
27505
27614
|
//#region src/v2019C1/extensions/lifecycle/layers/function/clone-function.ts
|
|
27506
|
-
async function
|
|
27507
|
-
let { sourceQuery: n, functionRef: r, targetParentRef: i, omit: a, stripRootAttributes: o, keepNameTypesFrom: s } = t, { recordMappings: c } = await
|
|
27615
|
+
async function Ir(e, t) {
|
|
27616
|
+
let { sourceQuery: n, functionRef: r, targetParentRef: i, omit: a, stripRootAttributes: o, keepNameTypesFrom: s } = t, { recordMappings: c } = await J(e, {
|
|
27508
27617
|
sourceQuery: n,
|
|
27509
27618
|
ref: r,
|
|
27510
27619
|
targetParent: i,
|
|
@@ -27521,15 +27630,15 @@ async function Pr(e, t) {
|
|
|
27521
27630
|
});
|
|
27522
27631
|
return c;
|
|
27523
27632
|
}
|
|
27524
|
-
async function
|
|
27525
|
-
let { sourceQuery: n, functionRef: r, structure: i, stripCategoriesUuid: a = !0 } = t, o = await
|
|
27633
|
+
async function Lr(e, t) {
|
|
27634
|
+
let { sourceQuery: n, functionRef: r, structure: i, stripCategoriesUuid: a = !0 } = t, o = await Rr(n, r), s = [];
|
|
27526
27635
|
for (let t of o) {
|
|
27527
27636
|
let r = {
|
|
27528
27637
|
tagName: "FunctionCategory",
|
|
27529
27638
|
id: t
|
|
27530
|
-
}, o = await
|
|
27639
|
+
}, o = await Br(e, n, t);
|
|
27531
27640
|
if (o) {
|
|
27532
|
-
let t = await
|
|
27641
|
+
let t = await ir(e, {
|
|
27533
27642
|
sourceQuery: n,
|
|
27534
27643
|
source: r,
|
|
27535
27644
|
target: o,
|
|
@@ -27541,25 +27650,25 @@ async function Fr(e, t) {
|
|
|
27541
27650
|
let c = await q(e, {
|
|
27542
27651
|
sourceQuery: n,
|
|
27543
27652
|
ref: r,
|
|
27544
|
-
targetParent: await
|
|
27653
|
+
targetParent: await Y(n, r, i),
|
|
27545
27654
|
...a ? {} : { strip: !1 }
|
|
27546
27655
|
});
|
|
27547
27656
|
c && s.push(...c.mappings);
|
|
27548
27657
|
}
|
|
27549
27658
|
return s;
|
|
27550
27659
|
}
|
|
27551
|
-
async function
|
|
27552
|
-
let n = await
|
|
27660
|
+
async function Rr(e, t) {
|
|
27661
|
+
let n = await zr(e, t), r = /* @__PURE__ */ new Set();
|
|
27553
27662
|
for (let { container: e } of n) e && r.add(e.id);
|
|
27554
27663
|
return r;
|
|
27555
27664
|
}
|
|
27556
|
-
async function
|
|
27557
|
-
let n = await
|
|
27665
|
+
async function zr(e, t) {
|
|
27666
|
+
let n = await z.query.findRefsPointingTo(e, {
|
|
27558
27667
|
target: t,
|
|
27559
27668
|
containerTagName: "FunctionCategory"
|
|
27560
27669
|
}), { SubFunction: r = [] } = await e.findDescendants(t, { collect: "SubFunction" });
|
|
27561
27670
|
for (let t of r) {
|
|
27562
|
-
let r = await
|
|
27671
|
+
let r = await z.query.findRefsPointingTo(e, {
|
|
27563
27672
|
target: {
|
|
27564
27673
|
tagName: "SubFunction",
|
|
27565
27674
|
id: t.id
|
|
@@ -27570,7 +27679,7 @@ async function Lr(e, t) {
|
|
|
27570
27679
|
}
|
|
27571
27680
|
return n;
|
|
27572
27681
|
}
|
|
27573
|
-
async function
|
|
27682
|
+
async function Br(e, t, n) {
|
|
27574
27683
|
let r = await t.getRecord({
|
|
27575
27684
|
tagName: "FunctionCategory",
|
|
27576
27685
|
id: n
|
|
@@ -27589,18 +27698,18 @@ async function Rr(e, t, n) {
|
|
|
27589
27698
|
}
|
|
27590
27699
|
//#endregion
|
|
27591
27700
|
//#region src/v2019C1/extensions/lifecycle/layers/function/satellites.constants.ts
|
|
27592
|
-
var
|
|
27701
|
+
var Vr = ["FunctionCategory"];
|
|
27593
27702
|
//#endregion
|
|
27594
27703
|
//#region src/v2019C1/extensions/lifecycle/layers/function/satellites.ts
|
|
27595
|
-
async function
|
|
27704
|
+
async function Hr(e, t) {
|
|
27596
27705
|
let { primaryRef: n } = t, r = [n], { SubFunction: i = [] } = await e.findDescendants(n, { collect: "SubFunction" });
|
|
27597
27706
|
for (let e of i) r.push({
|
|
27598
27707
|
tagName: "SubFunction",
|
|
27599
27708
|
id: e.id
|
|
27600
27709
|
});
|
|
27601
27710
|
let o = /* @__PURE__ */ new Set(), s = [];
|
|
27602
|
-
for (let t of r) for (let n of
|
|
27603
|
-
let r = await
|
|
27711
|
+
for (let t of r) for (let n of Vr) {
|
|
27712
|
+
let r = await z.query.findRefsPointingTo(e, {
|
|
27604
27713
|
target: t,
|
|
27605
27714
|
containerTagName: n
|
|
27606
27715
|
});
|
|
@@ -27610,8 +27719,8 @@ async function Br(e, t) {
|
|
|
27610
27719
|
}
|
|
27611
27720
|
//#endregion
|
|
27612
27721
|
//#region src/v2019C1/extensions/lifecycle/instantiate/transaction/fsd.ts
|
|
27613
|
-
async function
|
|
27614
|
-
let { sourceQuery: n, functionRef: r, targetParent: i, overrides: a, keepNameTypesFrom: o } = t, { recordMappings: s } = await
|
|
27722
|
+
async function Ur(e, t) {
|
|
27723
|
+
let { sourceQuery: n, functionRef: r, targetParent: i, overrides: a, keepNameTypesFrom: o } = t, { recordMappings: s } = await J(e, {
|
|
27615
27724
|
sourceQuery: n,
|
|
27616
27725
|
ref: r,
|
|
27617
27726
|
targetParent: i,
|
|
@@ -27621,55 +27730,55 @@ async function Vr(e, t) {
|
|
|
27621
27730
|
to: "SubFunction"
|
|
27622
27731
|
} : void 0,
|
|
27623
27732
|
withTypes: { keepNameFrom: o }
|
|
27624
|
-
}), c = await
|
|
27733
|
+
}), c = await Q(e, i), l = await Lr(e, {
|
|
27625
27734
|
sourceQuery: n,
|
|
27626
27735
|
functionRef: r,
|
|
27627
27736
|
structure: c,
|
|
27628
27737
|
stripCategoriesUuid: !1
|
|
27629
|
-
}), u = await
|
|
27738
|
+
}), u = await Pr(e, {
|
|
27630
27739
|
sourceQuery: n,
|
|
27631
27740
|
primaryRef: r,
|
|
27632
27741
|
structure: c,
|
|
27633
27742
|
strip: !1
|
|
27634
|
-
})
|
|
27635
|
-
|
|
27636
|
-
|
|
27637
|
-
|
|
27638
|
-
|
|
27639
|
-
|
|
27640
|
-
|
|
27743
|
+
}), d = [
|
|
27744
|
+
...s,
|
|
27745
|
+
...l,
|
|
27746
|
+
...u
|
|
27747
|
+
];
|
|
27748
|
+
await R(e, { mappings: d }), await H(e, {
|
|
27749
|
+
mappings: d,
|
|
27641
27750
|
mode: "stamp-template"
|
|
27642
27751
|
});
|
|
27643
|
-
let
|
|
27644
|
-
if (!
|
|
27645
|
-
let
|
|
27646
|
-
return await
|
|
27647
|
-
ref:
|
|
27752
|
+
let f = s.find((e) => e.source.id === r.id);
|
|
27753
|
+
if (!f) throw Error(`instantiate.fsd: cloned root not found for ${r.tagName}#${r.id}`);
|
|
27754
|
+
let p = f.target;
|
|
27755
|
+
return await K(e, {
|
|
27756
|
+
ref: p,
|
|
27648
27757
|
parentRef: i,
|
|
27649
27758
|
overrides: a?.get(r.id)
|
|
27650
|
-
}), await
|
|
27759
|
+
}), await _t(e, {
|
|
27651
27760
|
sourceQuery: n,
|
|
27652
|
-
targetRoot:
|
|
27761
|
+
targetRoot: p,
|
|
27653
27762
|
fileType: "FSD"
|
|
27654
27763
|
}), {
|
|
27655
|
-
functionRef:
|
|
27764
|
+
functionRef: p,
|
|
27656
27765
|
recordMappings: s
|
|
27657
27766
|
};
|
|
27658
27767
|
}
|
|
27659
27768
|
//#endregion
|
|
27660
27769
|
//#region src/v2019C1/extensions/lifecycle/layers/application/clone-application.ts
|
|
27661
|
-
async function
|
|
27662
|
-
let { sourceQuery: n, applicationRef: r, structure: i, omit: a, keepNameTypesFrom: o } = t, s = /* @__PURE__ */ new Map(), c = [], l = await
|
|
27770
|
+
async function Wr(e, t) {
|
|
27771
|
+
let { sourceQuery: n, applicationRef: r, structure: i, omit: a, keepNameTypesFrom: o } = t, s = /* @__PURE__ */ new Map(), c = [], l = await tr(e, {
|
|
27663
27772
|
sourceQuery: n,
|
|
27664
27773
|
scopeRef: r,
|
|
27665
27774
|
refTagName: "FunctionRef",
|
|
27666
27775
|
targetTagName: "Function"
|
|
27667
27776
|
});
|
|
27668
27777
|
for (let t of l) {
|
|
27669
|
-
let r = await
|
|
27778
|
+
let r = await Ir(e, {
|
|
27670
27779
|
sourceQuery: n,
|
|
27671
27780
|
functionRef: t,
|
|
27672
|
-
targetParentRef: await
|
|
27781
|
+
targetParentRef: await Y(n, t, i),
|
|
27673
27782
|
omit: a,
|
|
27674
27783
|
keepNameTypesFrom: o
|
|
27675
27784
|
});
|
|
@@ -27677,7 +27786,7 @@ async function Hr(e, t) {
|
|
|
27677
27786
|
for (let e of r) e.source.id && s.set(e.source.id, e.target);
|
|
27678
27787
|
}
|
|
27679
27788
|
for (let t of l) {
|
|
27680
|
-
let r = await
|
|
27789
|
+
let r = await Lr(e, {
|
|
27681
27790
|
sourceQuery: n,
|
|
27682
27791
|
functionRef: t,
|
|
27683
27792
|
structure: i,
|
|
@@ -27685,16 +27794,16 @@ async function Hr(e, t) {
|
|
|
27685
27794
|
});
|
|
27686
27795
|
c.push(...r);
|
|
27687
27796
|
}
|
|
27688
|
-
let u = await
|
|
27797
|
+
let u = await Gr(e, {
|
|
27689
27798
|
sourceQuery: n,
|
|
27690
27799
|
applicationRef: r
|
|
27691
27800
|
});
|
|
27692
27801
|
for (let e of u) s.set(e.sourceId, e.existingRef);
|
|
27693
|
-
let d = new Set(["FunctionRef", "FunctionCategoryRef"]), f = await
|
|
27802
|
+
let d = new Set(["FunctionRef", "FunctionCategoryRef"]), f = await rr(e, {
|
|
27694
27803
|
sourceQuery: n,
|
|
27695
27804
|
scopeTagName: "Application",
|
|
27696
27805
|
scopeRef: r,
|
|
27697
|
-
resolveTargetParent:
|
|
27806
|
+
resolveTargetParent: or({
|
|
27698
27807
|
sourceQuery: n,
|
|
27699
27808
|
structure: i,
|
|
27700
27809
|
cloneIndex: s
|
|
@@ -27707,7 +27816,7 @@ async function Hr(e, t) {
|
|
|
27707
27816
|
let p = await q(e, {
|
|
27708
27817
|
sourceQuery: n,
|
|
27709
27818
|
ref: r,
|
|
27710
|
-
targetParent: await
|
|
27819
|
+
targetParent: await Y(n, r, i),
|
|
27711
27820
|
omit: a
|
|
27712
27821
|
});
|
|
27713
27822
|
p && c.push(...p.mappings);
|
|
@@ -27723,7 +27832,7 @@ async function Hr(e, t) {
|
|
|
27723
27832
|
}
|
|
27724
27833
|
return c;
|
|
27725
27834
|
}
|
|
27726
|
-
async function
|
|
27835
|
+
async function Gr(e, t) {
|
|
27727
27836
|
let { sourceQuery: n, applicationRef: r } = t, { AllocationRoleRef: i = [] } = await n.findDescendants(r, { collect: "AllocationRoleRef" }), a = [], o = /* @__PURE__ */ new Set();
|
|
27728
27837
|
for (let t of i) {
|
|
27729
27838
|
let r = t.attributes.find((e) => e.name === "allocationRoleUuid")?.value;
|
|
@@ -27747,7 +27856,7 @@ async function Ur(e, t) {
|
|
|
27747
27856
|
tagName: "AllocationRole",
|
|
27748
27857
|
id: c.id
|
|
27749
27858
|
};
|
|
27750
|
-
await
|
|
27859
|
+
await Qn(e, {
|
|
27751
27860
|
sourceQuery: n,
|
|
27752
27861
|
source: {
|
|
27753
27862
|
tagName: "AllocationRole",
|
|
@@ -27766,20 +27875,20 @@ async function Ur(e, t) {
|
|
|
27766
27875
|
}
|
|
27767
27876
|
//#endregion
|
|
27768
27877
|
//#region src/v2019C1/extensions/lifecycle/layers/application/satellites.constants.ts
|
|
27769
|
-
var
|
|
27878
|
+
var Kr = [{
|
|
27770
27879
|
refTag: "AllocationRoleRef",
|
|
27771
27880
|
uuidAttr: "allocationRoleUuid",
|
|
27772
27881
|
targetTag: "AllocationRole"
|
|
27773
27882
|
}];
|
|
27774
27883
|
//#endregion
|
|
27775
27884
|
//#region src/v2019C1/extensions/lifecycle/layers/application/satellites.ts
|
|
27776
|
-
async function
|
|
27885
|
+
async function qr(e, t) {
|
|
27777
27886
|
let { applicationRef: n } = t, r = await e.any.getTree(n);
|
|
27778
27887
|
if (!r) return [];
|
|
27779
27888
|
let i = /* @__PURE__ */ new Set(), o = [];
|
|
27780
|
-
for (let t of
|
|
27889
|
+
for (let t of Kr) {
|
|
27781
27890
|
let n = /* @__PURE__ */ new Set();
|
|
27782
|
-
await
|
|
27891
|
+
await Jr(e, {
|
|
27783
27892
|
node: r,
|
|
27784
27893
|
refTag: t.refTag,
|
|
27785
27894
|
uuidAttr: t.uuidAttr,
|
|
@@ -27795,13 +27904,13 @@ async function Gr(e, t) {
|
|
|
27795
27904
|
}
|
|
27796
27905
|
return o;
|
|
27797
27906
|
}
|
|
27798
|
-
async function
|
|
27907
|
+
async function Jr(e, t) {
|
|
27799
27908
|
let { node: n, refTag: r, uuidAttr: i, out: a } = t;
|
|
27800
27909
|
if (n.tagName === r) {
|
|
27801
27910
|
let t = await e.any.getAttribute(n, { name: i });
|
|
27802
27911
|
t && a.add(t);
|
|
27803
27912
|
}
|
|
27804
|
-
for (let t of n.tree) await
|
|
27913
|
+
for (let t of n.tree) await Jr(e, {
|
|
27805
27914
|
node: t,
|
|
27806
27915
|
refTag: r,
|
|
27807
27916
|
uuidAttr: i,
|
|
@@ -27810,62 +27919,62 @@ async function Kr(e, t) {
|
|
|
27810
27919
|
}
|
|
27811
27920
|
//#endregion
|
|
27812
27921
|
//#region src/v2019C1/extensions/lifecycle/instantiate/transaction/asd.ts
|
|
27813
|
-
async function
|
|
27814
|
-
let { sourceQuery: n, applicationRef: r, targetParent: i, overrides: a, keepNameTypesFrom: o } = t, s = await
|
|
27922
|
+
async function Yr(e, t) {
|
|
27923
|
+
let { sourceQuery: n, applicationRef: r, targetParent: i, overrides: a, keepNameTypesFrom: o } = t, s = await Q(e, i), c = await tr(e, {
|
|
27815
27924
|
sourceQuery: n,
|
|
27816
27925
|
scopeRef: r,
|
|
27817
27926
|
refTagName: "FunctionRef",
|
|
27818
27927
|
targetTagName: "Function"
|
|
27819
|
-
}), l = await
|
|
27928
|
+
}), l = await Wr(e, {
|
|
27820
27929
|
sourceQuery: n,
|
|
27821
27930
|
applicationRef: r,
|
|
27822
27931
|
structure: s,
|
|
27823
27932
|
keepNameTypesFrom: o
|
|
27824
|
-
}), u = await
|
|
27933
|
+
}), u = await Pr(e, {
|
|
27825
27934
|
sourceQuery: n,
|
|
27826
27935
|
primaryRef: r,
|
|
27827
27936
|
structure: s,
|
|
27828
27937
|
strip: !1
|
|
27829
|
-
});
|
|
27830
|
-
await
|
|
27831
|
-
mappings:
|
|
27938
|
+
}), d = [...l, ...u];
|
|
27939
|
+
await R(e, { mappings: d }), await H(e, {
|
|
27940
|
+
mappings: d,
|
|
27832
27941
|
mode: "stamp-template"
|
|
27833
27942
|
});
|
|
27834
27943
|
for (let t of c) {
|
|
27835
27944
|
let r = l.find((e) => e.source.id === t.id);
|
|
27836
27945
|
if (!r) continue;
|
|
27837
|
-
let i = await
|
|
27838
|
-
await
|
|
27946
|
+
let i = await Y(n, t, s);
|
|
27947
|
+
await K(e, {
|
|
27839
27948
|
ref: r.target,
|
|
27840
27949
|
parentRef: i,
|
|
27841
27950
|
overrides: a?.get(t.id)
|
|
27842
27951
|
});
|
|
27843
27952
|
}
|
|
27844
|
-
let
|
|
27845
|
-
if (!
|
|
27846
|
-
let
|
|
27847
|
-
await
|
|
27848
|
-
ref:
|
|
27849
|
-
parentRef:
|
|
27953
|
+
let f = l.find((e) => e.source.id === r.id);
|
|
27954
|
+
if (!f) throw Error(`instantiate.asd: cloned Application not found for ${r.id}`);
|
|
27955
|
+
let p = await Y(n, r, s);
|
|
27956
|
+
await K(e, {
|
|
27957
|
+
ref: f.target,
|
|
27958
|
+
parentRef: p,
|
|
27850
27959
|
overrides: a?.get(r.id)
|
|
27851
|
-
}), await
|
|
27960
|
+
}), await _t(e, {
|
|
27852
27961
|
sourceQuery: n,
|
|
27853
|
-
targetRoot:
|
|
27962
|
+
targetRoot: f.target,
|
|
27854
27963
|
fileType: "ASD"
|
|
27855
27964
|
});
|
|
27856
|
-
let
|
|
27965
|
+
let m = c.map((e) => l.find((t) => t.source.id === e.id)?.target).filter((e) => !!e);
|
|
27857
27966
|
return {
|
|
27858
|
-
applicationRef:
|
|
27859
|
-
composedFunctionRefs:
|
|
27967
|
+
applicationRef: f.target,
|
|
27968
|
+
composedFunctionRefs: m,
|
|
27860
27969
|
recordMappings: l
|
|
27861
27970
|
};
|
|
27862
27971
|
}
|
|
27863
27972
|
//#endregion
|
|
27864
27973
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/function-satellites.ts
|
|
27865
|
-
async function
|
|
27866
|
-
let { sourceQuery: n, functionRef: r, instanceRef: i, targetParent: a, accepted: o } = t, s = await
|
|
27974
|
+
async function Xr(e, t) {
|
|
27975
|
+
let { sourceQuery: n, functionRef: r, instanceRef: i, targetParent: a, accepted: o } = t, s = await Hr(n, { primaryRef: r }), c = !1;
|
|
27867
27976
|
for (let t of s) {
|
|
27868
|
-
let { uuid: r, name: i } = await n.any.getAttributes(t), a = await
|
|
27977
|
+
let { uuid: r, name: i } = await n.any.getAttributes(t), a = await kr(e, {
|
|
27869
27978
|
tagName: t.tagName,
|
|
27870
27979
|
sourceUuid: r,
|
|
27871
27980
|
sourceName: i
|
|
@@ -27874,23 +27983,23 @@ async function Jr(e, t) {
|
|
|
27874
27983
|
c = !0;
|
|
27875
27984
|
continue;
|
|
27876
27985
|
}
|
|
27877
|
-
await
|
|
27986
|
+
await sr(e, {
|
|
27878
27987
|
sourceQuery: n,
|
|
27879
27988
|
sourceRootRef: t,
|
|
27880
27989
|
instanceRootRef: a,
|
|
27881
27990
|
accepted: o
|
|
27882
27991
|
});
|
|
27883
27992
|
}
|
|
27884
|
-
c && (!o || o.sourceIds.has(r.id)) && await
|
|
27885
|
-
mappings: await
|
|
27993
|
+
c && (!o || o.sourceIds.has(r.id)) && await H(e, {
|
|
27994
|
+
mappings: await Lr(e, {
|
|
27886
27995
|
sourceQuery: n,
|
|
27887
27996
|
functionRef: r,
|
|
27888
|
-
structure: await
|
|
27997
|
+
structure: await Q(e, a),
|
|
27889
27998
|
stripCategoriesUuid: !1
|
|
27890
27999
|
}),
|
|
27891
28000
|
mode: "stamp-template"
|
|
27892
28001
|
});
|
|
27893
|
-
let l = await
|
|
28002
|
+
let l = await Hr(e, { primaryRef: {
|
|
27894
28003
|
tagName: "Function",
|
|
27895
28004
|
id: i.id
|
|
27896
28005
|
} });
|
|
@@ -27901,27 +28010,36 @@ async function Jr(e, t) {
|
|
|
27901
28010
|
tagName: t.tagName,
|
|
27902
28011
|
attributes: { uuid: r }
|
|
27903
28012
|
});
|
|
27904
|
-
i || o && t.id && !o.instanceIds.has(t.id) || (await
|
|
28013
|
+
i || o && t.id && !o.instanceIds.has(t.id) || (await I(e, { target: t })).length > 0 || await e.delete(t);
|
|
27905
28014
|
}
|
|
27906
28015
|
}
|
|
27907
28016
|
//#endregion
|
|
28017
|
+
//#region src/v2019C1/extensions/lifecycle/scenario.ts
|
|
28018
|
+
function Zr(e) {
|
|
28019
|
+
return e === "fork" ? "uuid" : "templateUuid";
|
|
28020
|
+
}
|
|
28021
|
+
function Qr(e) {
|
|
28022
|
+
return e === "fork" ? "keep" : "stamp-template";
|
|
28023
|
+
}
|
|
28024
|
+
//#endregion
|
|
27908
28025
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/fsd.ts
|
|
27909
|
-
async function
|
|
27910
|
-
let { sourceQuery: n, functionRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, { uuid: l } = await n.getAttributes(r), u = a === "instantiate" ? [] : await
|
|
28026
|
+
async function $r(e, t) {
|
|
28027
|
+
let { sourceQuery: n, functionRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, { uuid: l } = await n.getAttributes(r), u = Zr(a), d = Qr(a), f = a === "instantiate" ? [] : await Dr(e, {
|
|
27911
28028
|
targetParent: i,
|
|
27912
28029
|
tagName: "Function",
|
|
27913
|
-
sourceUuid: l
|
|
27914
|
-
|
|
27915
|
-
|
|
27916
|
-
|
|
27917
|
-
|
|
28030
|
+
sourceUuid: l,
|
|
28031
|
+
matchKey: u
|
|
28032
|
+
}), p = o ? U(o) : [];
|
|
28033
|
+
if (f.length === 0) {
|
|
28034
|
+
let t = s ? Sr({
|
|
28035
|
+
groups: p,
|
|
27918
28036
|
decisions: s
|
|
27919
|
-
}) : void 0, a = s ?
|
|
27920
|
-
groups:
|
|
28037
|
+
}) : void 0, a = s ? yr({
|
|
28038
|
+
groups: p,
|
|
27921
28039
|
decisions: s
|
|
27922
28040
|
}) : void 0;
|
|
27923
28041
|
if (t && !t.sourceIds.has(r.id)) return [];
|
|
27924
|
-
let { functionRef: o } = await
|
|
28042
|
+
let { functionRef: o } = await Ur(e, {
|
|
27925
28043
|
sourceQuery: n,
|
|
27926
28044
|
functionRef: r,
|
|
27927
28045
|
targetParent: i,
|
|
@@ -27930,49 +28048,51 @@ async function Yr(e, t) {
|
|
|
27930
28048
|
});
|
|
27931
28049
|
return [o];
|
|
27932
28050
|
}
|
|
27933
|
-
let
|
|
27934
|
-
for (let t of
|
|
27935
|
-
let { instanceAccepted: a, instanceOverrides: l } =
|
|
27936
|
-
instanceGroups:
|
|
28051
|
+
let m = await Q(e, i);
|
|
28052
|
+
for (let t of f) {
|
|
28053
|
+
let { instanceAccepted: a, instanceOverrides: l } = ei({
|
|
28054
|
+
instanceGroups: mr(o, t.id),
|
|
27937
28055
|
decisions: s
|
|
27938
28056
|
});
|
|
27939
|
-
await
|
|
28057
|
+
await sr(e, {
|
|
27940
28058
|
sourceQuery: n,
|
|
27941
28059
|
sourceRootRef: r,
|
|
27942
28060
|
instanceRootRef: t,
|
|
27943
28061
|
accepted: a,
|
|
27944
28062
|
overrides: l,
|
|
27945
|
-
keepNameTypesFrom: c
|
|
27946
|
-
|
|
28063
|
+
keepNameTypesFrom: c,
|
|
28064
|
+
matchKey: u,
|
|
28065
|
+
identityMode: d
|
|
28066
|
+
}), await Xr(e, {
|
|
27947
28067
|
sourceQuery: n,
|
|
27948
28068
|
functionRef: r,
|
|
27949
28069
|
instanceRef: t,
|
|
27950
28070
|
targetParent: i,
|
|
27951
28071
|
accepted: a
|
|
27952
|
-
}), await
|
|
28072
|
+
}), await Nr(e, {
|
|
27953
28073
|
sourceQuery: n,
|
|
27954
28074
|
primaryRef: r,
|
|
27955
28075
|
instancePrimaryRef: {
|
|
27956
28076
|
tagName: "Function",
|
|
27957
28077
|
id: t.id
|
|
27958
28078
|
},
|
|
27959
|
-
structure:
|
|
28079
|
+
structure: m,
|
|
27960
28080
|
accepted: a
|
|
27961
28081
|
});
|
|
27962
28082
|
}
|
|
27963
|
-
return
|
|
28083
|
+
return f.map((e) => ({
|
|
27964
28084
|
tagName: "Function",
|
|
27965
28085
|
id: e.id
|
|
27966
28086
|
}));
|
|
27967
28087
|
}
|
|
27968
|
-
function
|
|
28088
|
+
function ei(e) {
|
|
27969
28089
|
let { instanceGroups: t, decisions: n } = e;
|
|
27970
28090
|
return n ? {
|
|
27971
|
-
instanceAccepted:
|
|
28091
|
+
instanceAccepted: Sr({
|
|
27972
28092
|
groups: t,
|
|
27973
28093
|
decisions: n
|
|
27974
28094
|
}),
|
|
27975
|
-
instanceOverrides:
|
|
28095
|
+
instanceOverrides: yr({
|
|
27976
28096
|
groups: t,
|
|
27977
28097
|
decisions: n
|
|
27978
28098
|
})
|
|
@@ -27983,16 +28103,16 @@ function Xr(e) {
|
|
|
27983
28103
|
}
|
|
27984
28104
|
//#endregion
|
|
27985
28105
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/asd.ts
|
|
27986
|
-
async function
|
|
27987
|
-
let { sourceQuery: n, applicationRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, { uuid: l } = await n.getAttributes(r), u = a === "instantiate" ? [] : await
|
|
28106
|
+
async function ti(e, t) {
|
|
28107
|
+
let { sourceQuery: n, applicationRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, { uuid: l } = await n.getAttributes(r), u = a === "instantiate" ? [] : await X(e, {
|
|
27988
28108
|
tagName: "Application",
|
|
27989
28109
|
sourceUuid: l
|
|
27990
|
-
}), d = o ?
|
|
28110
|
+
}), d = o ? U(o) : [];
|
|
27991
28111
|
if (u.length === 0) {
|
|
27992
|
-
let t = s ?
|
|
28112
|
+
let t = s ? Sr({
|
|
27993
28113
|
groups: d,
|
|
27994
28114
|
decisions: s
|
|
27995
|
-
}) : void 0, a = s ?
|
|
28115
|
+
}) : void 0, a = s ? yr({
|
|
27996
28116
|
groups: d,
|
|
27997
28117
|
decisions: s
|
|
27998
28118
|
}) : void 0;
|
|
@@ -28000,7 +28120,7 @@ async function Zr(e, t) {
|
|
|
28000
28120
|
applications: [],
|
|
28001
28121
|
functions: []
|
|
28002
28122
|
};
|
|
28003
|
-
let { applicationRef: o, composedFunctionRefs: l } = await
|
|
28123
|
+
let { applicationRef: o, composedFunctionRefs: l } = await Yr(e, {
|
|
28004
28124
|
sourceQuery: n,
|
|
28005
28125
|
applicationRef: r,
|
|
28006
28126
|
targetParent: i,
|
|
@@ -28012,12 +28132,12 @@ async function Zr(e, t) {
|
|
|
28012
28132
|
functions: l
|
|
28013
28133
|
};
|
|
28014
28134
|
}
|
|
28015
|
-
let f = await
|
|
28135
|
+
let f = await Q(e, i), p = await qr(n, { applicationRef: r }), m = [];
|
|
28016
28136
|
for (let t of u) {
|
|
28017
|
-
let i =
|
|
28137
|
+
let i = mr(o, t.id), a = s ? Sr({
|
|
28018
28138
|
groups: i,
|
|
28019
28139
|
decisions: s
|
|
28020
|
-
}) : void 0, l = s ?
|
|
28140
|
+
}) : void 0, l = s ? yr({
|
|
28021
28141
|
groups: i,
|
|
28022
28142
|
decisions: s
|
|
28023
28143
|
}) : void 0;
|
|
@@ -28025,24 +28145,24 @@ async function Zr(e, t) {
|
|
|
28025
28145
|
tagName: "Application",
|
|
28026
28146
|
id: t.id
|
|
28027
28147
|
});
|
|
28028
|
-
let u = await
|
|
28148
|
+
let u = await qr(e, { applicationRef: {
|
|
28029
28149
|
tagName: "Application",
|
|
28030
28150
|
id: t.id
|
|
28031
28151
|
} });
|
|
28032
|
-
await
|
|
28152
|
+
await sr(e, {
|
|
28033
28153
|
sourceQuery: n,
|
|
28034
28154
|
sourceRootRef: r,
|
|
28035
28155
|
instanceRootRef: t,
|
|
28036
28156
|
accepted: a,
|
|
28037
28157
|
overrides: l,
|
|
28038
28158
|
keepNameTypesFrom: c
|
|
28039
|
-
}), await
|
|
28159
|
+
}), await Ar(e, {
|
|
28040
28160
|
sourceQuery: n,
|
|
28041
28161
|
satelliteRefs: p,
|
|
28042
28162
|
instanceSatelliteRefs: u,
|
|
28043
28163
|
structure: f,
|
|
28044
28164
|
accepted: a
|
|
28045
|
-
}), await
|
|
28165
|
+
}), await Nr(e, {
|
|
28046
28166
|
sourceQuery: n,
|
|
28047
28167
|
primaryRef: r,
|
|
28048
28168
|
instancePrimaryRef: {
|
|
@@ -28055,7 +28175,7 @@ async function Zr(e, t) {
|
|
|
28055
28175
|
}
|
|
28056
28176
|
return {
|
|
28057
28177
|
applications: m,
|
|
28058
|
-
functions: await
|
|
28178
|
+
functions: await ni(e, {
|
|
28059
28179
|
sourceQuery: n,
|
|
28060
28180
|
applicationRef: r,
|
|
28061
28181
|
targetParent: i,
|
|
@@ -28066,10 +28186,10 @@ async function Zr(e, t) {
|
|
|
28066
28186
|
})
|
|
28067
28187
|
};
|
|
28068
28188
|
}
|
|
28069
|
-
async function
|
|
28070
|
-
let { sourceQuery: n, applicationRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, l = await
|
|
28189
|
+
async function ni(e, t) {
|
|
28190
|
+
let { sourceQuery: n, applicationRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, l = await Tr(n, r);
|
|
28071
28191
|
if (l.size === 0) return [];
|
|
28072
|
-
let u = await
|
|
28192
|
+
let u = await Q(e, i), d = [];
|
|
28073
28193
|
for (let t of l) {
|
|
28074
28194
|
let [r] = await n.any.findByAttributes({
|
|
28075
28195
|
tagName: "Function",
|
|
@@ -28079,10 +28199,10 @@ async function Qr(e, t) {
|
|
|
28079
28199
|
let i = {
|
|
28080
28200
|
tagName: "Function",
|
|
28081
28201
|
id: r.id
|
|
28082
|
-
}, l = await
|
|
28202
|
+
}, l = await $r(e, {
|
|
28083
28203
|
sourceQuery: n,
|
|
28084
28204
|
functionRef: i,
|
|
28085
|
-
targetParent: await
|
|
28205
|
+
targetParent: await Y(n, i, u),
|
|
28086
28206
|
scenario: a,
|
|
28087
28207
|
report: o,
|
|
28088
28208
|
decisions: s,
|
|
@@ -28094,29 +28214,29 @@ async function Qr(e, t) {
|
|
|
28094
28214
|
}
|
|
28095
28215
|
//#endregion
|
|
28096
28216
|
//#region src/v2019C1/extensions/lifecycle/update/index.ts
|
|
28097
|
-
var
|
|
28098
|
-
asd: () =>
|
|
28099
|
-
fsd: () =>
|
|
28217
|
+
var ri = /* @__PURE__ */ l({
|
|
28218
|
+
asd: () => ti,
|
|
28219
|
+
fsd: () => $r
|
|
28100
28220
|
});
|
|
28101
28221
|
//#endregion
|
|
28102
28222
|
//#region src/v2019C1/extensions/lifecycle/apply/apply.ts
|
|
28103
|
-
async function
|
|
28223
|
+
async function ii(e, t) {
|
|
28104
28224
|
let { report: n, decisions: r } = t;
|
|
28105
|
-
return r ? (
|
|
28106
|
-
groups:
|
|
28225
|
+
return r ? (br({
|
|
28226
|
+
groups: U(n),
|
|
28107
28227
|
decisions: r
|
|
28108
28228
|
}), {
|
|
28109
28229
|
report: n,
|
|
28110
|
-
instances: await
|
|
28230
|
+
instances: await oi(e, t, n, r)
|
|
28111
28231
|
}) : n.needsDecisions ? {
|
|
28112
28232
|
report: n,
|
|
28113
|
-
instances:
|
|
28233
|
+
instances: ai(t.verb)
|
|
28114
28234
|
} : {
|
|
28115
28235
|
report: n,
|
|
28116
|
-
instances: await
|
|
28236
|
+
instances: await oi(e, t, n, void 0)
|
|
28117
28237
|
};
|
|
28118
28238
|
}
|
|
28119
|
-
function
|
|
28239
|
+
function ai(e) {
|
|
28120
28240
|
return e === "fsd" ? {
|
|
28121
28241
|
verb: "fsd",
|
|
28122
28242
|
functions: []
|
|
@@ -28126,10 +28246,10 @@ function ti(e) {
|
|
|
28126
28246
|
functions: []
|
|
28127
28247
|
};
|
|
28128
28248
|
}
|
|
28129
|
-
async function
|
|
28249
|
+
async function oi(e, t, n, r) {
|
|
28130
28250
|
if (t.verb === "fsd") return {
|
|
28131
28251
|
verb: "fsd",
|
|
28132
|
-
functions: await
|
|
28252
|
+
functions: await $r(e, {
|
|
28133
28253
|
sourceQuery: t.sourceQuery,
|
|
28134
28254
|
functionRef: t.ref,
|
|
28135
28255
|
targetParent: t.anchor,
|
|
@@ -28139,7 +28259,7 @@ async function ni(e, t, n, r) {
|
|
|
28139
28259
|
keepNameTypesFrom: t.keepNameTypesFrom
|
|
28140
28260
|
})
|
|
28141
28261
|
};
|
|
28142
|
-
let { applications: i, functions: a } = await
|
|
28262
|
+
let { applications: i, functions: a } = await ti(e, {
|
|
28143
28263
|
sourceQuery: t.sourceQuery,
|
|
28144
28264
|
applicationRef: t.ref,
|
|
28145
28265
|
targetParent: t.anchor,
|
|
@@ -28156,7 +28276,7 @@ async function ni(e, t, n, r) {
|
|
|
28156
28276
|
}
|
|
28157
28277
|
//#endregion
|
|
28158
28278
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/ensure-substation-structure.ts
|
|
28159
|
-
async function
|
|
28279
|
+
async function si(e) {
|
|
28160
28280
|
let t = await e.getRoot(), n = await e.ensureChild(t, {
|
|
28161
28281
|
tagName: "Substation",
|
|
28162
28282
|
attributes: { name: "TEMPLATE" }
|
|
@@ -28175,12 +28295,12 @@ async function ri(e) {
|
|
|
28175
28295
|
}
|
|
28176
28296
|
//#endregion
|
|
28177
28297
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/post-extraction-cleanup.ts
|
|
28178
|
-
async function
|
|
28179
|
-
await
|
|
28298
|
+
async function ci(e) {
|
|
28299
|
+
await xt.transaction.orphanUuidRefs(e), await xt.transaction.resetLNode(e), await xt.transaction.pruneEmptyContainers(e);
|
|
28180
28300
|
}
|
|
28181
28301
|
//#endregion
|
|
28182
28302
|
//#region src/v2019C1/extensions/lifecycle/layers/omit-filters.ts
|
|
28183
|
-
var
|
|
28303
|
+
var li = [
|
|
28184
28304
|
"FunctionSclRef",
|
|
28185
28305
|
"ApplicationSclRef",
|
|
28186
28306
|
"GeneralEquipment",
|
|
@@ -28188,9 +28308,9 @@ var ai = [
|
|
|
28188
28308
|
];
|
|
28189
28309
|
//#endregion
|
|
28190
28310
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/asd.ts
|
|
28191
|
-
async function
|
|
28192
|
-
let { sourceQuery: n, applicationRef: r, tool: i, who: a, nameStructure: o } = t, s = await
|
|
28193
|
-
await
|
|
28311
|
+
async function ui(e, t) {
|
|
28312
|
+
let { sourceQuery: n, applicationRef: r, tool: i, who: a, nameStructure: o } = t, s = await si(e), c = await e.getAttribute(r, { name: "name" }) || "Unnamed Application";
|
|
28313
|
+
await en.transaction.addEntry(e, {
|
|
28194
28314
|
filename: `ASD_${c.replace(/\s+/g, "_")}`,
|
|
28195
28315
|
header: {
|
|
28196
28316
|
fileType: "ASD",
|
|
@@ -28203,17 +28323,17 @@ async function oi(e, t) {
|
|
|
28203
28323
|
what: "ASD initialization",
|
|
28204
28324
|
why: "Application was extracted from a previous file"
|
|
28205
28325
|
}
|
|
28206
|
-
}), await
|
|
28326
|
+
}), await R(e, { mappings: await Wr(e, {
|
|
28207
28327
|
sourceQuery: n,
|
|
28208
28328
|
applicationRef: r,
|
|
28209
28329
|
structure: s,
|
|
28210
|
-
omit:
|
|
28211
|
-
}), await
|
|
28330
|
+
omit: li
|
|
28331
|
+
}) }), await ci(e);
|
|
28212
28332
|
}
|
|
28213
28333
|
//#endregion
|
|
28214
28334
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/omit.ts
|
|
28215
|
-
var
|
|
28216
|
-
...
|
|
28335
|
+
var di = [
|
|
28336
|
+
...li,
|
|
28217
28337
|
"DOS",
|
|
28218
28338
|
"Labels",
|
|
28219
28339
|
"LNodeInputs",
|
|
@@ -28225,12 +28345,12 @@ var si = [
|
|
|
28225
28345
|
];
|
|
28226
28346
|
//#endregion
|
|
28227
28347
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/fsd.ts
|
|
28228
|
-
async function
|
|
28229
|
-
let { sourceQuery: n, functionRef: r, tool: i, who: a, nameStructure: o } = t, s = await
|
|
28348
|
+
async function fi(e, t) {
|
|
28349
|
+
let { sourceQuery: n, functionRef: r, tool: i, who: a, nameStructure: o } = t, s = await si(e), c = {
|
|
28230
28350
|
tagName: s.Substation.tagName,
|
|
28231
28351
|
id: s.Substation.id
|
|
28232
28352
|
}, l = await n.getAttribute(r, { name: "name" }) || "Unnamed Function";
|
|
28233
|
-
await
|
|
28353
|
+
await en.transaction.addEntry(e, {
|
|
28234
28354
|
filename: `FSD_${l.replace(/\s+/g, "_")}`,
|
|
28235
28355
|
header: {
|
|
28236
28356
|
fileType: "FSD",
|
|
@@ -28243,39 +28363,41 @@ async function ci(e, t) {
|
|
|
28243
28363
|
what: "FSD initialization",
|
|
28244
28364
|
why: "Function was extracted from a previous file"
|
|
28245
28365
|
}
|
|
28246
|
-
})
|
|
28366
|
+
});
|
|
28367
|
+
let u = await Ir(e, {
|
|
28247
28368
|
sourceQuery: n,
|
|
28248
28369
|
functionRef: r,
|
|
28249
28370
|
targetParentRef: c,
|
|
28250
|
-
omit:
|
|
28371
|
+
omit: di,
|
|
28251
28372
|
stripRootAttributes: ["templateUuid"]
|
|
28252
|
-
}), await
|
|
28373
|
+
}), d = await Lr(e, {
|
|
28253
28374
|
sourceQuery: n,
|
|
28254
28375
|
functionRef: r,
|
|
28255
28376
|
structure: s
|
|
28256
|
-
})
|
|
28377
|
+
});
|
|
28378
|
+
await R(e, { mappings: [...u, ...d] }), await ci(e);
|
|
28257
28379
|
}
|
|
28258
28380
|
//#endregion
|
|
28259
28381
|
//#region src/v2019C1/extensions/lifecycle/extract/index.ts
|
|
28260
|
-
var
|
|
28261
|
-
asd: () =>
|
|
28262
|
-
ensureSubstationTemplateStructure: () =>
|
|
28263
|
-
fsd: () =>
|
|
28264
|
-
}),
|
|
28265
|
-
asd: () =>
|
|
28266
|
-
fsd: () =>
|
|
28267
|
-
resolveTargetStructure: () =>
|
|
28382
|
+
var pi = /* @__PURE__ */ l({
|
|
28383
|
+
asd: () => ui,
|
|
28384
|
+
ensureSubstationTemplateStructure: () => si,
|
|
28385
|
+
fsd: () => fi
|
|
28386
|
+
}), mi = /* @__PURE__ */ l({
|
|
28387
|
+
asd: () => Yr,
|
|
28388
|
+
fsd: () => Ur,
|
|
28389
|
+
resolveTargetStructure: () => Q
|
|
28268
28390
|
});
|
|
28269
28391
|
//#endregion
|
|
28270
28392
|
//#region src/v2019C1/extensions/lifecycle/report/mark-placement-conflicts.ts
|
|
28271
|
-
async function
|
|
28272
|
-
if (t.scenario === "instantiate") for (let r of
|
|
28393
|
+
async function hi(e, t, n) {
|
|
28394
|
+
if (t.scenario === "instantiate") for (let r of U(n)) {
|
|
28273
28395
|
if (r.change !== "added") continue;
|
|
28274
28396
|
let i = r.primary.sourceRef;
|
|
28275
28397
|
if (!i) continue;
|
|
28276
28398
|
let a = await t.sourceQuery.getAttributes(i), o = a.uuid;
|
|
28277
28399
|
if (!o) continue;
|
|
28278
|
-
let s = r.primary.tagName, [c] = await
|
|
28400
|
+
let s = r.primary.tagName, [c] = await X(e, {
|
|
28279
28401
|
tagName: s,
|
|
28280
28402
|
sourceUuid: o
|
|
28281
28403
|
});
|
|
@@ -28288,7 +28410,7 @@ async function di(e, t, n) {
|
|
|
28288
28410
|
let n = {
|
|
28289
28411
|
tagName: t.tagName,
|
|
28290
28412
|
id: t.id
|
|
28291
|
-
}, r = await
|
|
28413
|
+
}, r = await G(e, {
|
|
28292
28414
|
parentRef: n,
|
|
28293
28415
|
childTag: s,
|
|
28294
28416
|
candidate: a
|
|
@@ -28299,9 +28421,9 @@ async function di(e, t, n) {
|
|
|
28299
28421
|
}
|
|
28300
28422
|
}
|
|
28301
28423
|
if (!d || !u) continue;
|
|
28302
|
-
let f = d.fields.find((e) =>
|
|
28424
|
+
let f = d.fields.find((e) => Bn(W(s, e)));
|
|
28303
28425
|
if (f) {
|
|
28304
|
-
let t = await
|
|
28426
|
+
let t = await Xn(e, {
|
|
28305
28427
|
parentRef: u,
|
|
28306
28428
|
childTag: s,
|
|
28307
28429
|
candidate: a,
|
|
@@ -28316,23 +28438,23 @@ async function di(e, t, n) {
|
|
|
28316
28438
|
}
|
|
28317
28439
|
//#endregion
|
|
28318
28440
|
//#region src/v2019C1/extensions/lifecycle/report/query/satellite-companions.ts
|
|
28319
|
-
async function
|
|
28441
|
+
async function gi(e, t) {
|
|
28320
28442
|
let { sourceQuery: n, primaryRef: r, satelliteRefs: i, instanceSatelliteRefs: a, report: o, instanceScopeId: s } = t, c = o.groups.find((e) => e.primary.sourceRef?.id === r.id);
|
|
28321
28443
|
for (let r of i) {
|
|
28322
|
-
let { uuid: i, name: a } = await n.any.getAttributes(r), l = await
|
|
28444
|
+
let { uuid: i, name: a } = await n.any.getAttributes(r), l = await _n({
|
|
28323
28445
|
sourceQuery: n,
|
|
28324
28446
|
targetQuery: e,
|
|
28325
28447
|
sourceRootRef: r,
|
|
28326
|
-
instanceRootRef: await
|
|
28448
|
+
instanceRootRef: await kr(e, {
|
|
28327
28449
|
tagName: r.tagName,
|
|
28328
28450
|
sourceUuid: i,
|
|
28329
28451
|
sourceName: a
|
|
28330
28452
|
}),
|
|
28331
28453
|
keepLeftoverRefs: !0,
|
|
28332
|
-
leftoverRefPolicy: await
|
|
28454
|
+
leftoverRefPolicy: await _i(e, n, r),
|
|
28333
28455
|
refsAlwaysAdded: t.refsAlwaysAdded ?? !1
|
|
28334
28456
|
});
|
|
28335
|
-
l.summary.added + l.summary.removed + l.summary.modified > 0 && (c ? c.companions.push(l.root) : o.groups.push(...
|
|
28457
|
+
l.summary.added + l.summary.removed + l.summary.modified > 0 && (c ? c.companions.push(l.root) : o.groups.push(...ln(l.root, s)));
|
|
28336
28458
|
}
|
|
28337
28459
|
if (c) for (let t of a ?? []) {
|
|
28338
28460
|
let { templateUuid: r } = await e.any.getAttributes(t);
|
|
@@ -28350,31 +28472,31 @@ async function fi(e, t) {
|
|
|
28350
28472
|
}
|
|
28351
28473
|
return o;
|
|
28352
28474
|
}
|
|
28353
|
-
async function
|
|
28475
|
+
async function _i(e, t, n) {
|
|
28354
28476
|
let r = await t.any.getTree(n), i = /* @__PURE__ */ new Set();
|
|
28355
|
-
return r && await
|
|
28356
|
-
let r =
|
|
28477
|
+
return r && await vi(t, r, i), async (n) => {
|
|
28478
|
+
let r = D[n.tagName];
|
|
28357
28479
|
if (!r) return "keep";
|
|
28358
28480
|
for (let a of r) {
|
|
28359
28481
|
let r = await e.any.getAttribute(n, { name: a.attribute.uuid });
|
|
28360
28482
|
if (!r) continue;
|
|
28361
|
-
let o = await
|
|
28483
|
+
let o = await yi(e, r, a.target);
|
|
28362
28484
|
if (!o) continue;
|
|
28363
28485
|
let s = await e.any.getAttribute(o, { name: "templateUuid" });
|
|
28364
|
-
if (s && await
|
|
28486
|
+
if (s && await yi(t, s, a.target) && !i.has(s)) return "removed";
|
|
28365
28487
|
}
|
|
28366
28488
|
return "keep";
|
|
28367
28489
|
};
|
|
28368
28490
|
}
|
|
28369
|
-
async function
|
|
28370
|
-
let r =
|
|
28491
|
+
async function vi(e, t, n) {
|
|
28492
|
+
let r = D[t.tagName];
|
|
28371
28493
|
if (r) for (let i of r) {
|
|
28372
28494
|
let r = await e.any.getAttribute(t, { name: i.attribute.uuid });
|
|
28373
28495
|
r && n.add(r);
|
|
28374
28496
|
}
|
|
28375
|
-
for (let r of t.tree) await
|
|
28497
|
+
for (let r of t.tree) await vi(e, r, n);
|
|
28376
28498
|
}
|
|
28377
|
-
async function
|
|
28499
|
+
async function yi(e, t, n) {
|
|
28378
28500
|
for (let r of n) {
|
|
28379
28501
|
let [n] = await e.any.findByAttributes({
|
|
28380
28502
|
tagName: r,
|
|
@@ -28385,13 +28507,13 @@ async function hi(e, t, n) {
|
|
|
28385
28507
|
}
|
|
28386
28508
|
//#endregion
|
|
28387
28509
|
//#region src/v2019C1/extensions/lifecycle/report/query/cross-cutting-satellites.ts
|
|
28388
|
-
async function
|
|
28510
|
+
async function bi(e, t) {
|
|
28389
28511
|
let { sourceQuery: n, primaryRef: r, instancePrimaryRef: i, report: a } = t;
|
|
28390
|
-
return
|
|
28512
|
+
return gi(e, {
|
|
28391
28513
|
sourceQuery: n,
|
|
28392
28514
|
primaryRef: r,
|
|
28393
|
-
satelliteRefs: await
|
|
28394
|
-
instanceSatelliteRefs: i ? await
|
|
28515
|
+
satelliteRefs: await Z(n, { primaryRef: r }),
|
|
28516
|
+
instanceSatelliteRefs: i ? await Z(e, { primaryRef: i }) : [],
|
|
28395
28517
|
report: a,
|
|
28396
28518
|
instanceScopeId: i?.id,
|
|
28397
28519
|
refsAlwaysAdded: t.refsAlwaysAdded ?? !1
|
|
@@ -28399,13 +28521,13 @@ async function gi(e, t) {
|
|
|
28399
28521
|
}
|
|
28400
28522
|
//#endregion
|
|
28401
28523
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-function-satellites.ts
|
|
28402
|
-
async function
|
|
28524
|
+
async function xi(e, t) {
|
|
28403
28525
|
let { sourceQuery: n, functionRef: r, instance: i, report: a } = t;
|
|
28404
|
-
return
|
|
28526
|
+
return gi(e, {
|
|
28405
28527
|
sourceQuery: n,
|
|
28406
28528
|
primaryRef: r,
|
|
28407
|
-
satelliteRefs: await
|
|
28408
|
-
instanceSatelliteRefs: i ? await
|
|
28529
|
+
satelliteRefs: await Hr(n, { primaryRef: r }),
|
|
28530
|
+
instanceSatelliteRefs: i ? await Hr(e, { primaryRef: {
|
|
28409
28531
|
tagName: "Function",
|
|
28410
28532
|
id: i.id
|
|
28411
28533
|
} }) : [],
|
|
@@ -28416,20 +28538,21 @@ async function _i(e, t) {
|
|
|
28416
28538
|
}
|
|
28417
28539
|
//#endregion
|
|
28418
28540
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-function.ts
|
|
28419
|
-
async function
|
|
28420
|
-
let { sourceQuery: n, functionRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await
|
|
28541
|
+
async function Si(e, t) {
|
|
28542
|
+
let { sourceQuery: n, functionRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await xi(e, {
|
|
28421
28543
|
sourceQuery: n,
|
|
28422
28544
|
functionRef: r,
|
|
28423
28545
|
instance: i,
|
|
28424
|
-
report: await
|
|
28546
|
+
report: await _n({
|
|
28425
28547
|
sourceQuery: n,
|
|
28426
28548
|
targetQuery: e,
|
|
28427
28549
|
sourceRootRef: r,
|
|
28428
|
-
instanceRootRef: i
|
|
28550
|
+
instanceRootRef: i,
|
|
28551
|
+
matchKey: t.matchKey
|
|
28429
28552
|
}),
|
|
28430
28553
|
refsAlwaysAdded: a
|
|
28431
28554
|
});
|
|
28432
|
-
return
|
|
28555
|
+
return bi(e, {
|
|
28433
28556
|
sourceQuery: n,
|
|
28434
28557
|
primaryRef: r,
|
|
28435
28558
|
instancePrimaryRef: i ? {
|
|
@@ -28442,7 +28565,7 @@ async function vi(e, t) {
|
|
|
28442
28565
|
}
|
|
28443
28566
|
//#endregion
|
|
28444
28567
|
//#region src/v2019C1/extensions/presentation/constants/title.ts
|
|
28445
|
-
var
|
|
28568
|
+
var Ci = {
|
|
28446
28569
|
LNode: {
|
|
28447
28570
|
compact: [
|
|
28448
28571
|
"prefix",
|
|
@@ -28539,29 +28662,29 @@ var yi = {
|
|
|
28539
28662
|
};
|
|
28540
28663
|
//#endregion
|
|
28541
28664
|
//#region src/v2019C1/extensions/presentation/query/extract-element-title.ts
|
|
28542
|
-
async function
|
|
28665
|
+
async function wi(e, t, n = {}) {
|
|
28543
28666
|
let r = await e.getRecord(t);
|
|
28544
28667
|
if (!r) return n.withLabels ? {
|
|
28545
28668
|
title: "",
|
|
28546
28669
|
labels: {}
|
|
28547
28670
|
} : "";
|
|
28548
|
-
let i = r.tagName, a = n.mode ?? "compact", o = await e.any.getAttributes(r), s =
|
|
28671
|
+
let i = r.tagName, a = n.mode ?? "compact", o = await e.any.getAttributes(r), s = Ci[i], c = Ti({
|
|
28549
28672
|
tag: i,
|
|
28550
28673
|
spec: s,
|
|
28551
28674
|
mode: a,
|
|
28552
28675
|
attributes: o,
|
|
28553
|
-
specAttributes: s?.attributesFrom ? await
|
|
28676
|
+
specAttributes: s?.attributesFrom ? await Ei(e, r, s.attributesFrom) : o,
|
|
28554
28677
|
value: r.value
|
|
28555
28678
|
});
|
|
28556
28679
|
return n.withLabels ? {
|
|
28557
28680
|
title: c,
|
|
28558
|
-
labels: await
|
|
28681
|
+
labels: await Di(e, r)
|
|
28559
28682
|
} : c;
|
|
28560
28683
|
}
|
|
28561
|
-
function
|
|
28684
|
+
function Ti(e) {
|
|
28562
28685
|
let { tag: t, spec: n, mode: r, attributes: i, specAttributes: a, value: o } = e;
|
|
28563
28686
|
if (n) {
|
|
28564
|
-
let e =
|
|
28687
|
+
let e = Ai(n, a, r);
|
|
28565
28688
|
if (e) return e;
|
|
28566
28689
|
}
|
|
28567
28690
|
let s = (o ?? "").trim();
|
|
@@ -28569,14 +28692,14 @@ function xi(e) {
|
|
|
28569
28692
|
let c = _[t]?.attributes?.identityFields, l = c?.find((e) => e === "name" || e === "id") ?? c?.[0];
|
|
28570
28693
|
return l && i[l] ? i[l] : i.name || t;
|
|
28571
28694
|
}
|
|
28572
|
-
async function
|
|
28695
|
+
async function Ei(e, t, n) {
|
|
28573
28696
|
let [r] = await e.any.getChildren(t, n);
|
|
28574
28697
|
return r ? e.any.getAttributes(r) : {};
|
|
28575
28698
|
}
|
|
28576
|
-
async function
|
|
28577
|
-
return
|
|
28699
|
+
async function Di(e, t) {
|
|
28700
|
+
return ki(await Oi(e, t));
|
|
28578
28701
|
}
|
|
28579
|
-
async function
|
|
28702
|
+
async function Oi(e, t) {
|
|
28580
28703
|
let n = [], r = await e.any.getChildren(t, "Labels");
|
|
28581
28704
|
for (let t of r) {
|
|
28582
28705
|
let r = await e.any.getChildren(t, "Label");
|
|
@@ -28591,18 +28714,18 @@ async function wi(e, t) {
|
|
|
28591
28714
|
}
|
|
28592
28715
|
return n;
|
|
28593
28716
|
}
|
|
28594
|
-
function
|
|
28717
|
+
function ki(e) {
|
|
28595
28718
|
let t = {};
|
|
28596
28719
|
for (let { lang: n, id: r, text: i } of e) (t[n] ??= {})[r] = i;
|
|
28597
28720
|
return t;
|
|
28598
28721
|
}
|
|
28599
|
-
function
|
|
28722
|
+
function Ai(e, t, n) {
|
|
28600
28723
|
let r = n === "full" && e.full !== void 0, i = r ? e.full : e.compact, a = r ? e.fullSeparator ?? e.separator ?? "" : e.separator ?? "";
|
|
28601
|
-
if (typeof i == "string") return
|
|
28602
|
-
if (
|
|
28724
|
+
if (typeof i == "string") return Mi(i, t);
|
|
28725
|
+
if (ji(i)) {
|
|
28603
28726
|
for (let e of i) {
|
|
28604
28727
|
if (e.whenPresent && !t[e.whenPresent]) continue;
|
|
28605
|
-
let n =
|
|
28728
|
+
let n = Mi(e.template, t);
|
|
28606
28729
|
if (n) return n;
|
|
28607
28730
|
}
|
|
28608
28731
|
return "";
|
|
@@ -28610,22 +28733,22 @@ function Ei(e, t, n) {
|
|
|
28610
28733
|
let o = i.map((e) => t[e]).filter(Boolean);
|
|
28611
28734
|
return o.length > 0 ? o.join(a) : "";
|
|
28612
28735
|
}
|
|
28613
|
-
function
|
|
28736
|
+
function ji(e) {
|
|
28614
28737
|
return typeof e[0] == "object";
|
|
28615
28738
|
}
|
|
28616
|
-
function
|
|
28739
|
+
function Mi(e, t) {
|
|
28617
28740
|
return e.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (e, n) => t[n] ?? "").replace(/\[\]/g, "").replace(/\(\)/g, "").split("/").map((e) => e.split(".").filter((e) => e !== "").join(".")).filter((e) => e !== "").join("/");
|
|
28618
28741
|
}
|
|
28619
28742
|
//#endregion
|
|
28620
28743
|
//#region src/v2019C1/extensions/presentation/query/index.ts
|
|
28621
|
-
var
|
|
28744
|
+
var Ni = /* @__PURE__ */ l({ extractElementTitle: () => wi });
|
|
28622
28745
|
//#endregion
|
|
28623
28746
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-instance.ts
|
|
28624
|
-
async function
|
|
28747
|
+
async function $(e, t) {
|
|
28625
28748
|
let { instanceDiff: n, instance: r, sourceQuery: i, sourceRef: o } = t, s = n.groups.length === 0;
|
|
28626
28749
|
if (!r) return {
|
|
28627
28750
|
rootRef: void 0,
|
|
28628
|
-
title: await
|
|
28751
|
+
title: await wi(i, o),
|
|
28629
28752
|
linked: !1,
|
|
28630
28753
|
upToDate: s,
|
|
28631
28754
|
tree: n.root,
|
|
@@ -28634,7 +28757,7 @@ async function Q(e, t) {
|
|
|
28634
28757
|
let { templateUuid: c, originUuid: l } = await e.any.getAttributes(r), u = !!(c || l);
|
|
28635
28758
|
return {
|
|
28636
28759
|
rootRef: a(r),
|
|
28637
|
-
title: await
|
|
28760
|
+
title: await wi(e, r),
|
|
28638
28761
|
linked: u,
|
|
28639
28762
|
upToDate: s,
|
|
28640
28763
|
tree: n.root,
|
|
@@ -28643,64 +28766,64 @@ async function Q(e, t) {
|
|
|
28643
28766
|
}
|
|
28644
28767
|
//#endregion
|
|
28645
28768
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-asd.ts
|
|
28646
|
-
async function
|
|
28647
|
-
let { sourceQuery: n, applicationRef: r, scenario: i } = t, { uuid: a } = await n.getAttributes(r), o = i === "instantiate" ? [] : await
|
|
28769
|
+
async function Pi(e, t) {
|
|
28770
|
+
let { sourceQuery: n, applicationRef: r, scenario: i } = t, { uuid: a } = await n.getAttributes(r), o = i === "instantiate" ? [] : await X(e, {
|
|
28648
28771
|
tagName: "Application",
|
|
28649
28772
|
sourceUuid: a
|
|
28650
28773
|
}), s = [];
|
|
28651
28774
|
if (o.length === 0) {
|
|
28652
|
-
let t = await
|
|
28775
|
+
let t = await Fi(e, {
|
|
28653
28776
|
sourceQuery: n,
|
|
28654
28777
|
applicationRef: r,
|
|
28655
28778
|
instance: void 0,
|
|
28656
28779
|
refsAlwaysAdded: i === "instantiate"
|
|
28657
28780
|
});
|
|
28658
|
-
s.push(await
|
|
28781
|
+
s.push(await $(e, {
|
|
28659
28782
|
instanceDiff: t,
|
|
28660
28783
|
instance: void 0,
|
|
28661
28784
|
sourceQuery: n,
|
|
28662
28785
|
sourceRef: r
|
|
28663
28786
|
}));
|
|
28664
28787
|
} else for (let t of o) {
|
|
28665
|
-
let a = await
|
|
28788
|
+
let a = await Fi(e, {
|
|
28666
28789
|
sourceQuery: n,
|
|
28667
28790
|
applicationRef: r,
|
|
28668
28791
|
instance: t,
|
|
28669
28792
|
refsAlwaysAdded: i === "instantiate"
|
|
28670
28793
|
});
|
|
28671
|
-
s.push(await
|
|
28794
|
+
s.push(await $(e, {
|
|
28672
28795
|
instanceDiff: a,
|
|
28673
28796
|
instance: t,
|
|
28674
28797
|
sourceQuery: n,
|
|
28675
28798
|
sourceRef: r
|
|
28676
28799
|
}));
|
|
28677
28800
|
}
|
|
28678
|
-
let c = await
|
|
28801
|
+
let c = await Ii(e, {
|
|
28679
28802
|
sourceQuery: n,
|
|
28680
28803
|
applicationRef: r,
|
|
28681
28804
|
scenario: i
|
|
28682
28805
|
});
|
|
28683
|
-
return
|
|
28806
|
+
return Pn([...s, ...c]);
|
|
28684
28807
|
}
|
|
28685
|
-
async function
|
|
28686
|
-
let { sourceQuery: n, applicationRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await
|
|
28808
|
+
async function Fi(e, t) {
|
|
28809
|
+
let { sourceQuery: n, applicationRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await _n({
|
|
28687
28810
|
sourceQuery: n,
|
|
28688
28811
|
targetQuery: e,
|
|
28689
28812
|
sourceRootRef: r,
|
|
28690
28813
|
instanceRootRef: i
|
|
28691
28814
|
});
|
|
28692
|
-
return await
|
|
28815
|
+
return await gi(e, {
|
|
28693
28816
|
sourceQuery: n,
|
|
28694
28817
|
primaryRef: r,
|
|
28695
|
-
satelliteRefs: await
|
|
28696
|
-
instanceSatelliteRefs: i ? await
|
|
28818
|
+
satelliteRefs: await qr(n, { applicationRef: r }),
|
|
28819
|
+
instanceSatelliteRefs: i ? await qr(e, { applicationRef: {
|
|
28697
28820
|
tagName: "Application",
|
|
28698
28821
|
id: i.id
|
|
28699
28822
|
} }) : [],
|
|
28700
28823
|
report: o,
|
|
28701
28824
|
instanceScopeId: i?.id,
|
|
28702
28825
|
refsAlwaysAdded: a
|
|
28703
|
-
}), await
|
|
28826
|
+
}), await bi(e, {
|
|
28704
28827
|
sourceQuery: n,
|
|
28705
28828
|
primaryRef: r,
|
|
28706
28829
|
instancePrimaryRef: i ? {
|
|
@@ -28711,8 +28834,8 @@ async function ji(e, t) {
|
|
|
28711
28834
|
refsAlwaysAdded: a
|
|
28712
28835
|
}), o;
|
|
28713
28836
|
}
|
|
28714
|
-
async function
|
|
28715
|
-
let { sourceQuery: n, applicationRef: r, scenario: i } = t, a = await
|
|
28837
|
+
async function Ii(e, t) {
|
|
28838
|
+
let { sourceQuery: n, applicationRef: r, scenario: i } = t, a = await Tr(n, r), o = [];
|
|
28716
28839
|
for (let t of a) {
|
|
28717
28840
|
let [r] = await n.any.findByAttributes({
|
|
28718
28841
|
tagName: "Function",
|
|
@@ -28722,18 +28845,18 @@ async function Mi(e, t) {
|
|
|
28722
28845
|
let a = {
|
|
28723
28846
|
tagName: "Function",
|
|
28724
28847
|
id: r.id
|
|
28725
|
-
}, s = i === "instantiate" ? [] : await
|
|
28848
|
+
}, s = i === "instantiate" ? [] : await X(e, {
|
|
28726
28849
|
tagName: "Function",
|
|
28727
28850
|
sourceUuid: t
|
|
28728
28851
|
});
|
|
28729
28852
|
if (s.length === 0) {
|
|
28730
|
-
let t = await
|
|
28853
|
+
let t = await Si(e, {
|
|
28731
28854
|
sourceQuery: n,
|
|
28732
28855
|
functionRef: a,
|
|
28733
28856
|
instance: void 0,
|
|
28734
28857
|
refsAlwaysAdded: i === "instantiate"
|
|
28735
28858
|
});
|
|
28736
|
-
o.push(await
|
|
28859
|
+
o.push(await $(e, {
|
|
28737
28860
|
instanceDiff: t,
|
|
28738
28861
|
instance: void 0,
|
|
28739
28862
|
sourceQuery: n,
|
|
@@ -28742,13 +28865,13 @@ async function Mi(e, t) {
|
|
|
28742
28865
|
continue;
|
|
28743
28866
|
}
|
|
28744
28867
|
for (let t of s) {
|
|
28745
|
-
let r = await
|
|
28868
|
+
let r = await Si(e, {
|
|
28746
28869
|
sourceQuery: n,
|
|
28747
28870
|
functionRef: a,
|
|
28748
28871
|
instance: t,
|
|
28749
28872
|
refsAlwaysAdded: i === "instantiate"
|
|
28750
28873
|
});
|
|
28751
|
-
o.push(await
|
|
28874
|
+
o.push(await $(e, {
|
|
28752
28875
|
instanceDiff: r,
|
|
28753
28876
|
instance: t,
|
|
28754
28877
|
sourceQuery: n,
|
|
@@ -28760,59 +28883,62 @@ async function Mi(e, t) {
|
|
|
28760
28883
|
}
|
|
28761
28884
|
//#endregion
|
|
28762
28885
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-fsd.ts
|
|
28763
|
-
async function
|
|
28764
|
-
let { sourceQuery: n, functionRef: r, targetParent: i, scenario: a } = t, { uuid: o } = await n.getAttributes(r), s = a === "instantiate" ? [] : await
|
|
28886
|
+
async function Li(e, t) {
|
|
28887
|
+
let { sourceQuery: n, functionRef: r, targetParent: i, scenario: a } = t, { uuid: o } = await n.getAttributes(r), s = Zr(a), c = a === "instantiate" ? [] : await Dr(e, {
|
|
28765
28888
|
targetParent: i,
|
|
28766
28889
|
tagName: "Function",
|
|
28767
|
-
sourceUuid: o
|
|
28890
|
+
sourceUuid: o,
|
|
28891
|
+
matchKey: s
|
|
28768
28892
|
});
|
|
28769
|
-
if (
|
|
28770
|
-
instanceDiff: await
|
|
28893
|
+
if (c.length === 0) return Pn([await $(e, {
|
|
28894
|
+
instanceDiff: await Si(e, {
|
|
28771
28895
|
sourceQuery: n,
|
|
28772
28896
|
functionRef: r,
|
|
28773
28897
|
instance: void 0,
|
|
28774
|
-
refsAlwaysAdded: a === "instantiate"
|
|
28898
|
+
refsAlwaysAdded: a === "instantiate",
|
|
28899
|
+
matchKey: s
|
|
28775
28900
|
}),
|
|
28776
28901
|
instance: void 0,
|
|
28777
28902
|
sourceQuery: n,
|
|
28778
28903
|
sourceRef: r
|
|
28779
28904
|
})]);
|
|
28780
|
-
let
|
|
28781
|
-
for (let t of
|
|
28782
|
-
let i = await
|
|
28905
|
+
let l = [];
|
|
28906
|
+
for (let t of c) {
|
|
28907
|
+
let i = await Si(e, {
|
|
28783
28908
|
sourceQuery: n,
|
|
28784
28909
|
functionRef: r,
|
|
28785
28910
|
instance: t,
|
|
28786
|
-
refsAlwaysAdded: a === "instantiate"
|
|
28911
|
+
refsAlwaysAdded: a === "instantiate",
|
|
28912
|
+
matchKey: s
|
|
28787
28913
|
});
|
|
28788
|
-
|
|
28914
|
+
l.push(await $(e, {
|
|
28789
28915
|
instanceDiff: i,
|
|
28790
28916
|
instance: t,
|
|
28791
28917
|
sourceQuery: n,
|
|
28792
28918
|
sourceRef: r
|
|
28793
28919
|
}));
|
|
28794
28920
|
}
|
|
28795
|
-
return
|
|
28921
|
+
return Pn(l);
|
|
28796
28922
|
}
|
|
28797
28923
|
//#endregion
|
|
28798
28924
|
//#region src/v2019C1/extensions/lifecycle/report/report.ts
|
|
28799
|
-
async function
|
|
28800
|
-
let n = t.verb === "fsd" ? await
|
|
28925
|
+
async function Ri(e, t) {
|
|
28926
|
+
let n = t.verb === "fsd" ? await Li(e, {
|
|
28801
28927
|
sourceQuery: t.sourceQuery,
|
|
28802
28928
|
functionRef: t.ref,
|
|
28803
28929
|
targetParent: t.anchor,
|
|
28804
28930
|
scenario: t.scenario
|
|
28805
|
-
}) : await
|
|
28931
|
+
}) : await Pi(e, {
|
|
28806
28932
|
sourceQuery: t.sourceQuery,
|
|
28807
28933
|
applicationRef: t.ref,
|
|
28808
28934
|
scenario: t.scenario
|
|
28809
28935
|
});
|
|
28810
|
-
for (let e of
|
|
28811
|
-
return await
|
|
28936
|
+
for (let e of U(n)) e.editableAttributes = Vn(e.primary.tagName);
|
|
28937
|
+
return await hi(e, t, n), n;
|
|
28812
28938
|
}
|
|
28813
28939
|
//#endregion
|
|
28814
28940
|
//#region src/v2019C1/extensions/lifecycle/report/presentation-scope.ts
|
|
28815
|
-
function
|
|
28941
|
+
function zi(e) {
|
|
28816
28942
|
switch (e.verb) {
|
|
28817
28943
|
case "fsd":
|
|
28818
28944
|
case "asd": return {
|
|
@@ -28824,9 +28950,9 @@ function Fi(e) {
|
|
|
28824
28950
|
}
|
|
28825
28951
|
//#endregion
|
|
28826
28952
|
//#region src/v2019C1/extensions/lifecycle/validate/template-uuid-check.ts
|
|
28827
|
-
async function
|
|
28953
|
+
async function Bi(e) {
|
|
28828
28954
|
let t = await e.any.getSnapshot({ as: "tree" }), n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
|
|
28829
|
-
await
|
|
28955
|
+
await Vi(e, t, n, r);
|
|
28830
28956
|
let i = [], a = /* @__PURE__ */ new Set();
|
|
28831
28957
|
for (let [e, { tagNames: t, refs: r }] of n) {
|
|
28832
28958
|
if (t.size < 2) continue;
|
|
@@ -28874,7 +29000,7 @@ async function Ii(e) {
|
|
|
28874
29000
|
}
|
|
28875
29001
|
return i;
|
|
28876
29002
|
}
|
|
28877
|
-
async function
|
|
29003
|
+
async function Vi(e, t, n, r) {
|
|
28878
29004
|
let i = {
|
|
28879
29005
|
tagName: t.tagName,
|
|
28880
29006
|
id: t.id
|
|
@@ -28894,35 +29020,35 @@ async function Li(e, t, n, r) {
|
|
|
28894
29020
|
ref: i
|
|
28895
29021
|
}), r.set(o, e);
|
|
28896
29022
|
}
|
|
28897
|
-
for (let i of t.tree) await
|
|
29023
|
+
for (let i of t.tree) await Vi(e, i, n, r);
|
|
28898
29024
|
}
|
|
28899
29025
|
//#endregion
|
|
28900
29026
|
//#region src/v2019C1/extensions/index.ts
|
|
28901
|
-
var
|
|
28902
|
-
cleanUp:
|
|
28903
|
-
dataModel:
|
|
28904
|
-
history:
|
|
28905
|
-
identity:
|
|
29027
|
+
var Hi = {
|
|
29028
|
+
cleanUp: xt,
|
|
29029
|
+
dataModel: Yt,
|
|
29030
|
+
history: en,
|
|
29031
|
+
identity: cn,
|
|
28906
29032
|
lifecycle: {
|
|
28907
29033
|
query: {
|
|
28908
|
-
report:
|
|
28909
|
-
checkTemplateUuids:
|
|
29034
|
+
report: Ri,
|
|
29035
|
+
checkTemplateUuids: Bi
|
|
28910
29036
|
},
|
|
28911
29037
|
transaction: {
|
|
28912
|
-
extract:
|
|
28913
|
-
instantiate:
|
|
28914
|
-
transplant: { deep:
|
|
28915
|
-
update:
|
|
28916
|
-
apply:
|
|
29038
|
+
extract: pi,
|
|
29039
|
+
instantiate: mi,
|
|
29040
|
+
transplant: { deep: J },
|
|
29041
|
+
update: ri,
|
|
29042
|
+
apply: ii
|
|
28917
29043
|
}
|
|
28918
29044
|
},
|
|
28919
|
-
reference:
|
|
28920
|
-
signature: { query:
|
|
28921
|
-
presentation: { query:
|
|
29045
|
+
reference: z,
|
|
29046
|
+
signature: { query: Ft },
|
|
29047
|
+
presentation: { query: Ni }
|
|
28922
29048
|
};
|
|
28923
29049
|
//#endregion
|
|
28924
29050
|
//#region src/v2019C1/hooks/after-created/private-wrapper.ts
|
|
28925
|
-
async function
|
|
29051
|
+
async function Ui(e) {
|
|
28926
29052
|
let { childRecord: t, parentRecord: n, query: r } = e;
|
|
28927
29053
|
if (t.namespace.prefix === x.namespaces.default.prefix) return [];
|
|
28928
29054
|
let i = n.tagName === "Private", a = n.namespace.prefix === x.namespaces.default.prefix;
|
|
@@ -28931,26 +29057,26 @@ async function zi(e) {
|
|
|
28931
29057
|
...n,
|
|
28932
29058
|
children: n.children.filter((e) => e.id !== t.id)
|
|
28933
29059
|
};
|
|
28934
|
-
return i ?
|
|
29060
|
+
return i ? Wi({
|
|
28935
29061
|
parentRecord: n,
|
|
28936
29062
|
childRecord: t,
|
|
28937
29063
|
query: r
|
|
28938
|
-
}) : o ?
|
|
29064
|
+
}) : o ? Gi({
|
|
28939
29065
|
existingPrivateRef: o,
|
|
28940
29066
|
parentRecord: n,
|
|
28941
29067
|
updatedParentRecord: s,
|
|
28942
29068
|
childRecord: t,
|
|
28943
29069
|
query: r
|
|
28944
|
-
}) : (await r.findAncestors(n)).some((e) => e.tagName === "Private" && e.attributes.some((e) => e.name === "type" && e.value === t.namespace.prefix)) ? [] :
|
|
29070
|
+
}) : (await r.findAncestors(n)).some((e) => e.tagName === "Private" && e.attributes.some((e) => e.name === "type" && e.value === t.namespace.prefix)) ? [] : Ki({
|
|
28945
29071
|
parentRecord: n,
|
|
28946
29072
|
updatedParentRecord: s,
|
|
28947
29073
|
childRecord: t
|
|
28948
29074
|
});
|
|
28949
29075
|
}
|
|
28950
|
-
async function
|
|
29076
|
+
async function Wi(e) {
|
|
28951
29077
|
let { parentRecord: t, childRecord: n, query: r } = e, a = t;
|
|
28952
29078
|
if (n.parent?.id === a.id && n.parent?.tagName === "Private") return [];
|
|
28953
|
-
let o = await
|
|
29079
|
+
let o = await qi({
|
|
28954
29080
|
privateId: a.id,
|
|
28955
29081
|
query: r
|
|
28956
29082
|
});
|
|
@@ -28958,7 +29084,7 @@ async function Bi(e) {
|
|
|
28958
29084
|
detail: "Latest private record not found",
|
|
28959
29085
|
key: "ELEMENT_NOT_FOUND"
|
|
28960
29086
|
});
|
|
28961
|
-
let { childRecord: c, privateRecord: l } =
|
|
29087
|
+
let { childRecord: c, privateRecord: l } = Ji({
|
|
28962
29088
|
privateRecord: o,
|
|
28963
29089
|
childRecord: n
|
|
28964
29090
|
});
|
|
@@ -28972,8 +29098,8 @@ async function Bi(e) {
|
|
|
28972
29098
|
newRecord: i(l)
|
|
28973
29099
|
}];
|
|
28974
29100
|
}
|
|
28975
|
-
async function
|
|
28976
|
-
let { existingPrivateRef: t, parentRecord: n, updatedParentRecord: r, childRecord: a, query: o } = e, c = await
|
|
29101
|
+
async function Gi(e) {
|
|
29102
|
+
let { existingPrivateRef: t, parentRecord: n, updatedParentRecord: r, childRecord: a, query: o } = e, c = await qi({
|
|
28977
29103
|
privateId: t.id,
|
|
28978
29104
|
query: o
|
|
28979
29105
|
});
|
|
@@ -28981,7 +29107,7 @@ async function Vi(e) {
|
|
|
28981
29107
|
detail: "Latest private record not found",
|
|
28982
29108
|
key: "ELEMENT_NOT_FOUND"
|
|
28983
29109
|
}), !c.attributes.some((e) => e.name === "type" && e.value === a.namespace.prefix)) return [];
|
|
28984
|
-
let { childRecord: l, privateRecord: u } =
|
|
29110
|
+
let { childRecord: l, privateRecord: u } = Ji({
|
|
28985
29111
|
privateRecord: c,
|
|
28986
29112
|
childRecord: a
|
|
28987
29113
|
});
|
|
@@ -29003,7 +29129,7 @@ async function Vi(e) {
|
|
|
29003
29129
|
}
|
|
29004
29130
|
];
|
|
29005
29131
|
}
|
|
29006
|
-
function
|
|
29132
|
+
function Ki(e) {
|
|
29007
29133
|
let { parentRecord: t, updatedParentRecord: n, childRecord: r } = e, a = {
|
|
29008
29134
|
id: crypto.randomUUID(),
|
|
29009
29135
|
tagName: "Private",
|
|
@@ -29052,14 +29178,14 @@ function Hi(e) {
|
|
|
29052
29178
|
}
|
|
29053
29179
|
];
|
|
29054
29180
|
}
|
|
29055
|
-
async function
|
|
29181
|
+
async function qi(e) {
|
|
29056
29182
|
let { privateId: t, query: n } = e;
|
|
29057
29183
|
return await n.getRecord({
|
|
29058
29184
|
id: t,
|
|
29059
29185
|
tagName: "Private"
|
|
29060
29186
|
});
|
|
29061
29187
|
}
|
|
29062
|
-
function
|
|
29188
|
+
function Ji(e) {
|
|
29063
29189
|
let { privateRecord: t, childRecord: n } = e;
|
|
29064
29190
|
return {
|
|
29065
29191
|
childRecord: {
|
|
@@ -29080,7 +29206,7 @@ function Wi(e) {
|
|
|
29080
29206
|
}
|
|
29081
29207
|
//#endregion
|
|
29082
29208
|
//#region src/v2019C1/hooks/shared/ref-entry-ops.ts
|
|
29083
|
-
async function
|
|
29209
|
+
async function Yi(e) {
|
|
29084
29210
|
let { uuid: t, entry: r, target: a, query: o } = e;
|
|
29085
29211
|
if (!n(r.refTagName, x)) return [];
|
|
29086
29212
|
let s = await o.getRecordsByTagName(r.refTagName), c = [];
|
|
@@ -29089,7 +29215,7 @@ async function Gi(e) {
|
|
|
29089
29215
|
let n = {
|
|
29090
29216
|
tagName: e.tagName,
|
|
29091
29217
|
id: e.id
|
|
29092
|
-
}, s = await
|
|
29218
|
+
}, s = await z.query.buildReferencePath(o, {
|
|
29093
29219
|
reference: n,
|
|
29094
29220
|
target: a
|
|
29095
29221
|
});
|
|
@@ -29109,7 +29235,7 @@ async function Gi(e) {
|
|
|
29109
29235
|
}
|
|
29110
29236
|
return c;
|
|
29111
29237
|
}
|
|
29112
|
-
function
|
|
29238
|
+
function Xi(e) {
|
|
29113
29239
|
let t = [];
|
|
29114
29240
|
for (let n of je) {
|
|
29115
29241
|
let r = ke[n]?.get(e);
|
|
@@ -29119,7 +29245,7 @@ function Ki(e) {
|
|
|
29119
29245
|
}
|
|
29120
29246
|
//#endregion
|
|
29121
29247
|
//#region src/v2019C1/hooks/shared/record-ops.ts
|
|
29122
|
-
function
|
|
29248
|
+
function Zi(e, t) {
|
|
29123
29249
|
return {
|
|
29124
29250
|
status: "updated",
|
|
29125
29251
|
oldRecord: e,
|
|
@@ -29129,7 +29255,7 @@ function qi(e, t) {
|
|
|
29129
29255
|
}
|
|
29130
29256
|
};
|
|
29131
29257
|
}
|
|
29132
|
-
function
|
|
29258
|
+
function Qi(e, t, n) {
|
|
29133
29259
|
return e.some((e) => e.name === t) ? e.map((e) => e.name === t ? {
|
|
29134
29260
|
...e,
|
|
29135
29261
|
value: n
|
|
@@ -29140,23 +29266,23 @@ function Ji(e, t, n) {
|
|
|
29140
29266
|
}
|
|
29141
29267
|
//#endregion
|
|
29142
29268
|
//#region src/v2019C1/hooks/shared/mapped-name.ts
|
|
29143
|
-
async function
|
|
29269
|
+
async function $i(e, t) {
|
|
29144
29270
|
let n = P.get(t.tagName);
|
|
29145
29271
|
if (!n || !t.attributes.find((e) => e.name === n.uuid)?.value) return null;
|
|
29146
|
-
let r = await
|
|
29147
|
-
return r === t.attributes.find((e) => e.name === n.path)?.value ? null :
|
|
29272
|
+
let r = await Re(e, t);
|
|
29273
|
+
return r === t.attributes.find((e) => e.name === n.path)?.value ? null : Zi(t, r === void 0 ? t.attributes.filter((e) => e.name !== n.path) : Qi(t.attributes, n.path, r));
|
|
29148
29274
|
}
|
|
29149
29275
|
//#endregion
|
|
29150
29276
|
//#region src/v2019C1/hooks/shared/ref-path-rebuild.ts
|
|
29151
|
-
async function
|
|
29277
|
+
async function ea(e) {
|
|
29152
29278
|
let { oldRecord: t, newRecord: n, query: r } = e;
|
|
29153
29279
|
if (P.has(n.tagName)) return [];
|
|
29154
|
-
let i =
|
|
29280
|
+
let i = D[n.tagName];
|
|
29155
29281
|
if (!i) return [];
|
|
29156
29282
|
let a = [];
|
|
29157
29283
|
for (let e of i) {
|
|
29158
|
-
if (e.resolution === M.unsupported || !
|
|
29159
|
-
let i = await
|
|
29284
|
+
if (e.resolution === M.unsupported || !ta(t, n, e)) continue;
|
|
29285
|
+
let i = await na({
|
|
29160
29286
|
newRecord: n,
|
|
29161
29287
|
pair: e,
|
|
29162
29288
|
query: r
|
|
@@ -29165,28 +29291,28 @@ async function Xi(e) {
|
|
|
29165
29291
|
}
|
|
29166
29292
|
return a;
|
|
29167
29293
|
}
|
|
29168
|
-
function
|
|
29169
|
-
return [n.attribute.uuid, ...n.companions.map((e) => e.name)].some((n) =>
|
|
29294
|
+
function ta(e, t, n) {
|
|
29295
|
+
return [n.attribute.uuid, ...n.companions.map((e) => e.name)].some((n) => ia(e, n) !== ia(t, n));
|
|
29170
29296
|
}
|
|
29171
|
-
async function
|
|
29172
|
-
let { newRecord: t, pair: n, query: r } = e, i =
|
|
29297
|
+
async function na(e) {
|
|
29298
|
+
let { newRecord: t, pair: n, query: r } = e, i = ia(t, n.attribute.uuid);
|
|
29173
29299
|
if (!i) return null;
|
|
29174
|
-
let a = await
|
|
29300
|
+
let a = await ra({
|
|
29175
29301
|
uuidValue: i,
|
|
29176
29302
|
targetTagNames: n.target,
|
|
29177
29303
|
query: r
|
|
29178
29304
|
});
|
|
29179
29305
|
if (!a) return null;
|
|
29180
|
-
let o = await
|
|
29306
|
+
let o = await j(r, {
|
|
29181
29307
|
reference: {
|
|
29182
29308
|
tagName: t.tagName,
|
|
29183
29309
|
id: t.id
|
|
29184
29310
|
},
|
|
29185
29311
|
target: a
|
|
29186
29312
|
});
|
|
29187
|
-
return !o ||
|
|
29313
|
+
return !o || ia(t, n.attribute.path) === o ? null : Zi(t, Qi(t.attributes, n.attribute.path, o));
|
|
29188
29314
|
}
|
|
29189
|
-
async function
|
|
29315
|
+
async function ra(e) {
|
|
29190
29316
|
let { uuidValue: t, targetTagNames: r, query: i } = e;
|
|
29191
29317
|
for (let e of r) {
|
|
29192
29318
|
if (!n(e, x)) continue;
|
|
@@ -29198,22 +29324,22 @@ async function $i(e) {
|
|
|
29198
29324
|
}
|
|
29199
29325
|
return null;
|
|
29200
29326
|
}
|
|
29201
|
-
function
|
|
29327
|
+
function ia(e, t) {
|
|
29202
29328
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
29203
29329
|
}
|
|
29204
29330
|
//#endregion
|
|
29205
29331
|
//#region src/v2019C1/hooks/shared/lnode-binding.ts
|
|
29206
|
-
var
|
|
29207
|
-
async function
|
|
29332
|
+
var aa = "None";
|
|
29333
|
+
async function oa(e) {
|
|
29208
29334
|
let { oldRecord: t, newRecord: n, query: r } = e;
|
|
29209
29335
|
if (n.tagName !== "LNode") return null;
|
|
29210
|
-
let i =
|
|
29336
|
+
let i = da(t, "lnUuid"), a = da(n, "lnUuid");
|
|
29211
29337
|
if (i === a) return null;
|
|
29212
|
-
let o = a ? await
|
|
29213
|
-
return o ?
|
|
29338
|
+
let o = a ? await sa(r, a) : await ca(r, n);
|
|
29339
|
+
return o ? ua(n, o) : null;
|
|
29214
29340
|
}
|
|
29215
|
-
async function
|
|
29216
|
-
let n = await
|
|
29341
|
+
async function sa(e, t) {
|
|
29342
|
+
let n = await la(e, t);
|
|
29217
29343
|
if (!n) return null;
|
|
29218
29344
|
let r = await e.getAttributes(n), i = await e.findAncestors(n), a = i.find((e) => e.tagName === "LDevice"), o = i.find((e) => e.tagName === "IED"), s = a ? await e.getAttributes({
|
|
29219
29345
|
tagName: "LDevice",
|
|
@@ -29230,9 +29356,9 @@ async function na(e, t) {
|
|
|
29230
29356
|
lnInst: r.inst
|
|
29231
29357
|
};
|
|
29232
29358
|
}
|
|
29233
|
-
async function
|
|
29359
|
+
async function ca(e, t) {
|
|
29234
29360
|
let n = {
|
|
29235
|
-
iedName:
|
|
29361
|
+
iedName: aa,
|
|
29236
29362
|
ldInst: void 0
|
|
29237
29363
|
}, r = await e.getChild({
|
|
29238
29364
|
tagName: "LNode",
|
|
@@ -29247,7 +29373,7 @@ async function ra(e, t) {
|
|
|
29247
29373
|
lnInst: i.sLnInst
|
|
29248
29374
|
};
|
|
29249
29375
|
}
|
|
29250
|
-
async function
|
|
29376
|
+
async function la(e, t) {
|
|
29251
29377
|
for (let r of ["LN", "LN0"]) {
|
|
29252
29378
|
if (!n(r, x)) continue;
|
|
29253
29379
|
let i = (await e.getRecordsByTagName(r)).find((e) => e.attributes.find((e) => e.name === "uuid")?.value === t);
|
|
@@ -29258,7 +29384,7 @@ async function ia(e, t) {
|
|
|
29258
29384
|
}
|
|
29259
29385
|
return null;
|
|
29260
29386
|
}
|
|
29261
|
-
function
|
|
29387
|
+
function ua(e, t) {
|
|
29262
29388
|
let n = [...e.attributes], r = !1;
|
|
29263
29389
|
for (let [e, i] of Object.entries(t)) {
|
|
29264
29390
|
let t = n.find((t) => t.name === e)?.value;
|
|
@@ -29267,35 +29393,35 @@ function aa(e, t) {
|
|
|
29267
29393
|
n = n.filter((t) => t.name !== e), r = !0;
|
|
29268
29394
|
continue;
|
|
29269
29395
|
}
|
|
29270
|
-
t !== i && (n =
|
|
29396
|
+
t !== i && (n = Qi(n, e, i), r = !0);
|
|
29271
29397
|
}
|
|
29272
|
-
return r ?
|
|
29398
|
+
return r ? Zi(e, n) : null;
|
|
29273
29399
|
}
|
|
29274
|
-
function
|
|
29400
|
+
function da(e, t) {
|
|
29275
29401
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
29276
29402
|
}
|
|
29277
29403
|
//#endregion
|
|
29278
29404
|
//#region src/v2019C1/hooks/after-created/ref-paths.ts
|
|
29279
|
-
async function
|
|
29280
|
-
let { childRecord: t, query: n } = e, r = await
|
|
29405
|
+
async function fa(e) {
|
|
29406
|
+
let { childRecord: t, query: n } = e, r = await pa({
|
|
29281
29407
|
childRecord: t,
|
|
29282
29408
|
query: n
|
|
29283
|
-
}), i = await
|
|
29409
|
+
}), i = await ga({
|
|
29284
29410
|
childRecord: t,
|
|
29285
29411
|
query: n
|
|
29286
|
-
}), a = await
|
|
29412
|
+
}), a = await $i(n, o(t)), s = a ? [a] : [];
|
|
29287
29413
|
return [
|
|
29288
29414
|
...r,
|
|
29289
29415
|
...i,
|
|
29290
29416
|
...s
|
|
29291
29417
|
];
|
|
29292
29418
|
}
|
|
29293
|
-
async function
|
|
29419
|
+
async function pa(e) {
|
|
29294
29420
|
let { childRecord: t, query: n } = e, r = Me.get(t.tagName);
|
|
29295
29421
|
if (!r?.length) return [];
|
|
29296
29422
|
let i = [];
|
|
29297
29423
|
for (let e of r) {
|
|
29298
|
-
let r = await
|
|
29424
|
+
let r = await ma({
|
|
29299
29425
|
childRecord: t,
|
|
29300
29426
|
pair: e,
|
|
29301
29427
|
query: n
|
|
@@ -29304,16 +29430,16 @@ async function ca(e) {
|
|
|
29304
29430
|
}
|
|
29305
29431
|
return i;
|
|
29306
29432
|
}
|
|
29307
|
-
async function
|
|
29433
|
+
async function ma(e) {
|
|
29308
29434
|
let { childRecord: t, pair: n, query: r } = e, i = t.attributes.find((e) => e.name === n.uuidAttr)?.value;
|
|
29309
29435
|
if (!i) return null;
|
|
29310
|
-
let a = await
|
|
29436
|
+
let a = await ha({
|
|
29311
29437
|
uuidValue: i,
|
|
29312
29438
|
targetTagNames: n.targetTagNames,
|
|
29313
29439
|
query: r
|
|
29314
29440
|
});
|
|
29315
29441
|
if (!a) return null;
|
|
29316
|
-
let o = await
|
|
29442
|
+
let o = await j(r, {
|
|
29317
29443
|
reference: {
|
|
29318
29444
|
tagName: t.tagName,
|
|
29319
29445
|
id: t.id
|
|
@@ -29337,7 +29463,7 @@ async function la(e) {
|
|
|
29337
29463
|
}
|
|
29338
29464
|
};
|
|
29339
29465
|
}
|
|
29340
|
-
async function
|
|
29466
|
+
async function ha(e) {
|
|
29341
29467
|
let { uuidValue: t, targetTagNames: r, query: i } = e;
|
|
29342
29468
|
for (let e of r) {
|
|
29343
29469
|
if (!n(e, x)) continue;
|
|
@@ -29349,17 +29475,17 @@ async function ua(e) {
|
|
|
29349
29475
|
}
|
|
29350
29476
|
return null;
|
|
29351
29477
|
}
|
|
29352
|
-
async function
|
|
29478
|
+
async function ga(e) {
|
|
29353
29479
|
let { childRecord: t, query: n } = e, r = t.attributes.find((e) => e.name === "uuid")?.value;
|
|
29354
29480
|
if (!r) return [];
|
|
29355
|
-
let i =
|
|
29481
|
+
let i = Xi(t.tagName);
|
|
29356
29482
|
if (i.length === 0) return [];
|
|
29357
29483
|
let a = {
|
|
29358
29484
|
tagName: t.tagName,
|
|
29359
29485
|
id: t.id
|
|
29360
29486
|
}, o = [];
|
|
29361
29487
|
for (let e of i) {
|
|
29362
|
-
let t = await
|
|
29488
|
+
let t = await Yi({
|
|
29363
29489
|
uuid: r,
|
|
29364
29490
|
entry: e,
|
|
29365
29491
|
target: a,
|
|
@@ -29371,134 +29497,20 @@ async function da(e) {
|
|
|
29371
29497
|
}
|
|
29372
29498
|
//#endregion
|
|
29373
29499
|
//#region src/v2019C1/hooks/after-created/after-created.ts
|
|
29374
|
-
async function
|
|
29375
|
-
let { childRecord: t, parentRecord: n, query: r } = e, i = await
|
|
29500
|
+
async function _a(e) {
|
|
29501
|
+
let { childRecord: t, parentRecord: n, query: r } = e, i = await Ui({
|
|
29376
29502
|
childRecord: t,
|
|
29377
29503
|
parentRecord: n,
|
|
29378
29504
|
query: r
|
|
29379
|
-
}), a = await
|
|
29505
|
+
}), a = await fa({
|
|
29380
29506
|
childRecord: t,
|
|
29381
29507
|
query: r
|
|
29382
29508
|
});
|
|
29383
29509
|
return [...i, ...a];
|
|
29384
29510
|
}
|
|
29385
29511
|
//#endregion
|
|
29386
|
-
//#region src/v2019C1/hooks/after-deep-clone/ref-paths.ts
|
|
29387
|
-
async function pa(e) {
|
|
29388
|
-
let { cumulativeCloneMappings: t, query: n } = e, { uuidMap: r, uuidToRef: i } = await ma(t, n);
|
|
29389
|
-
if (r.size === 0) return [];
|
|
29390
|
-
let a = [];
|
|
29391
|
-
for (let { target: e } of t) {
|
|
29392
|
-
let t = await ga({
|
|
29393
|
-
target: e,
|
|
29394
|
-
uuidMap: r,
|
|
29395
|
-
uuidToRef: i,
|
|
29396
|
-
query: n
|
|
29397
|
-
});
|
|
29398
|
-
t && a.push(t);
|
|
29399
|
-
}
|
|
29400
|
-
return a;
|
|
29401
|
-
}
|
|
29402
|
-
async function ma(e, t) {
|
|
29403
|
-
let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
|
|
29404
|
-
for (let { source: i, target: a } of e) await ha({
|
|
29405
|
-
source: i,
|
|
29406
|
-
target: a,
|
|
29407
|
-
query: t,
|
|
29408
|
-
uuidMap: n,
|
|
29409
|
-
uuidToRef: r
|
|
29410
|
-
});
|
|
29411
|
-
return {
|
|
29412
|
-
uuidMap: n,
|
|
29413
|
-
uuidToRef: r
|
|
29414
|
-
};
|
|
29415
|
-
}
|
|
29416
|
-
async function ha(e) {
|
|
29417
|
-
let { source: t, target: n, query: r, uuidMap: i, uuidToRef: a } = e, o = await r.getRecord(n);
|
|
29418
|
-
if (!o) return;
|
|
29419
|
-
let s = t.attributes.find((e) => e.name === "uuid")?.value, c = o.attributes.find((e) => e.name === "uuid")?.value;
|
|
29420
|
-
!s || !c || (i.set(s, c), a.set(c, {
|
|
29421
|
-
tagName: o.tagName,
|
|
29422
|
-
id: o.id
|
|
29423
|
-
}));
|
|
29424
|
-
}
|
|
29425
|
-
async function ga(e) {
|
|
29426
|
-
let { target: t, uuidMap: n, uuidToRef: r, query: a } = e, o = t.tagName;
|
|
29427
|
-
if (!(o in O)) return null;
|
|
29428
|
-
let s = await a.getRecord(t);
|
|
29429
|
-
if (!s) return null;
|
|
29430
|
-
let c = O[o], l = [...s.attributes], u = !1;
|
|
29431
|
-
for (let e of c) {
|
|
29432
|
-
let t = await _a({
|
|
29433
|
-
pair: e,
|
|
29434
|
-
tagName: o,
|
|
29435
|
-
refId: s.id,
|
|
29436
|
-
updatedAttributes: l,
|
|
29437
|
-
uuidMap: n,
|
|
29438
|
-
uuidToRef: r,
|
|
29439
|
-
query: a
|
|
29440
|
-
});
|
|
29441
|
-
t && (l = t, u = !0);
|
|
29442
|
-
}
|
|
29443
|
-
return u ? {
|
|
29444
|
-
status: "updated",
|
|
29445
|
-
oldRecord: i(s),
|
|
29446
|
-
newRecord: i({
|
|
29447
|
-
...s,
|
|
29448
|
-
attributes: l
|
|
29449
|
-
})
|
|
29450
|
-
} : null;
|
|
29451
|
-
}
|
|
29452
|
-
async function _a(e) {
|
|
29453
|
-
let { pair: t, tagName: n, refId: r, uuidMap: i, uuidToRef: a, query: o } = e, s = [...e.updatedAttributes], c = s.find((e) => e.name === t.attribute.uuid)?.value;
|
|
29454
|
-
if (!c) return null;
|
|
29455
|
-
let l = i.get(c);
|
|
29456
|
-
if (!l) return null;
|
|
29457
|
-
let u = !1, d = va(s, t.attribute.uuid, c, l);
|
|
29458
|
-
d && (s = d, u = !0);
|
|
29459
|
-
let f = await ya({
|
|
29460
|
-
attributes: s,
|
|
29461
|
-
pathAttrName: t.attribute.path,
|
|
29462
|
-
newUuid: l,
|
|
29463
|
-
uuidToRef: a,
|
|
29464
|
-
tagName: n,
|
|
29465
|
-
refId: r,
|
|
29466
|
-
query: o
|
|
29467
|
-
});
|
|
29468
|
-
return f && (s = f, u = !0), u ? s : null;
|
|
29469
|
-
}
|
|
29470
|
-
function va(e, t, n, r) {
|
|
29471
|
-
return r === n ? null : e.map((e) => e.name === t ? {
|
|
29472
|
-
...e,
|
|
29473
|
-
value: r
|
|
29474
|
-
} : e);
|
|
29475
|
-
}
|
|
29476
|
-
async function ya(e) {
|
|
29477
|
-
let { attributes: t, pathAttrName: n, newUuid: r, uuidToRef: i, tagName: a, refId: o, query: s } = e, c = i.get(r);
|
|
29478
|
-
if (!c) return null;
|
|
29479
|
-
let l = await I.query.buildReferencePath(s, {
|
|
29480
|
-
reference: {
|
|
29481
|
-
tagName: a,
|
|
29482
|
-
id: o
|
|
29483
|
-
},
|
|
29484
|
-
target: {
|
|
29485
|
-
tagName: c.tagName,
|
|
29486
|
-
id: c.id
|
|
29487
|
-
}
|
|
29488
|
-
});
|
|
29489
|
-
return !l || t.find((e) => e.name === n)?.value === l ? null : t.map((e) => e.name === n ? {
|
|
29490
|
-
...e,
|
|
29491
|
-
value: l
|
|
29492
|
-
} : e);
|
|
29493
|
-
}
|
|
29494
|
-
//#endregion
|
|
29495
|
-
//#region src/v2019C1/hooks/after-deep-clone/after-deep-clone.ts
|
|
29496
|
-
async function ba(e) {
|
|
29497
|
-
return pa(e);
|
|
29498
|
-
}
|
|
29499
|
-
//#endregion
|
|
29500
29512
|
//#region src/v2019C1/hooks/after-standardized-record/uuid-attribute.ts
|
|
29501
|
-
function
|
|
29513
|
+
function va(e) {
|
|
29502
29514
|
let { record: t } = e, { tagName: n, attributes: r } = t, i = x.definition[n];
|
|
29503
29515
|
if (!("uuid" in i.attributes.details) || r.find((e) => e.name === "uuid")?.value) return t;
|
|
29504
29516
|
let a = i.attributes.details.uuid?.namespace, o = r.filter((e) => e.name !== "uuid");
|
|
@@ -29513,21 +29525,21 @@ function xa(e) {
|
|
|
29513
29525
|
}
|
|
29514
29526
|
//#endregion
|
|
29515
29527
|
//#region src/v2019C1/hooks/after-standardized-record/after-standardized-record.ts
|
|
29516
|
-
function
|
|
29517
|
-
return
|
|
29528
|
+
function ya(e) {
|
|
29529
|
+
return va(e);
|
|
29518
29530
|
}
|
|
29519
29531
|
//#endregion
|
|
29520
29532
|
//#region src/v2019C1/hooks/after-updated/ref-paths.ts
|
|
29521
|
-
async function
|
|
29522
|
-
let { oldRecord: t, newRecord: n, query: r } = e, i = [], a = o(t), s = o(n), c = await
|
|
29533
|
+
async function ba(e) {
|
|
29534
|
+
let { oldRecord: t, newRecord: n, query: r } = e, i = [], a = o(t), s = o(n), c = await $i(r, s);
|
|
29523
29535
|
c && i.push(c);
|
|
29524
|
-
let l = await
|
|
29536
|
+
let l = await oa({
|
|
29525
29537
|
oldRecord: a,
|
|
29526
29538
|
newRecord: s,
|
|
29527
29539
|
query: r
|
|
29528
29540
|
});
|
|
29529
29541
|
l && i.push(l);
|
|
29530
|
-
let u = await
|
|
29542
|
+
let u = await ea({
|
|
29531
29543
|
oldRecord: a,
|
|
29532
29544
|
newRecord: s,
|
|
29533
29545
|
query: r
|
|
@@ -29535,12 +29547,12 @@ async function Ca(e) {
|
|
|
29535
29547
|
i.push(...u);
|
|
29536
29548
|
let d = n.attributes.find((e) => e.name === "uuid")?.value;
|
|
29537
29549
|
if (d) {
|
|
29538
|
-
let e =
|
|
29550
|
+
let e = Xi(n.tagName), t = {
|
|
29539
29551
|
tagName: n.tagName,
|
|
29540
29552
|
id: n.id
|
|
29541
29553
|
};
|
|
29542
29554
|
for (let n of e) {
|
|
29543
|
-
let e = await
|
|
29555
|
+
let e = await Yi({
|
|
29544
29556
|
uuid: d,
|
|
29545
29557
|
entry: n,
|
|
29546
29558
|
target: t,
|
|
@@ -29549,8 +29561,8 @@ async function Ca(e) {
|
|
|
29549
29561
|
i.push(...e);
|
|
29550
29562
|
}
|
|
29551
29563
|
}
|
|
29552
|
-
if (
|
|
29553
|
-
let e = await
|
|
29564
|
+
if (xa(t, n)) {
|
|
29565
|
+
let e = await Sa({
|
|
29554
29566
|
newRecord: n,
|
|
29555
29567
|
query: r
|
|
29556
29568
|
});
|
|
@@ -29558,11 +29570,11 @@ async function Ca(e) {
|
|
|
29558
29570
|
}
|
|
29559
29571
|
return i;
|
|
29560
29572
|
}
|
|
29561
|
-
function
|
|
29562
|
-
for (let n of
|
|
29573
|
+
function xa(e, t) {
|
|
29574
|
+
for (let n of se) if (e.attributes.find((e) => e.name === n)?.value !== t.attributes.find((e) => e.name === n)?.value) return !0;
|
|
29563
29575
|
return !1;
|
|
29564
29576
|
}
|
|
29565
|
-
async function
|
|
29577
|
+
async function Sa(e) {
|
|
29566
29578
|
let { newRecord: t, query: n } = e, r = {
|
|
29567
29579
|
tagName: t.tagName,
|
|
29568
29580
|
id: t.id
|
|
@@ -29571,14 +29583,14 @@ async function Ta(e) {
|
|
|
29571
29583
|
if (r.id === t.id) continue;
|
|
29572
29584
|
let e = await n.any.getAttribute(r, { name: "uuid" });
|
|
29573
29585
|
if (!e) continue;
|
|
29574
|
-
let i =
|
|
29586
|
+
let i = Xi(r.tagName);
|
|
29575
29587
|
if (i.length === 0) continue;
|
|
29576
29588
|
let o = {
|
|
29577
29589
|
tagName: r.tagName,
|
|
29578
29590
|
id: r.id
|
|
29579
29591
|
};
|
|
29580
29592
|
for (let t of i) {
|
|
29581
|
-
let r = await
|
|
29593
|
+
let r = await Yi({
|
|
29582
29594
|
uuid: e,
|
|
29583
29595
|
entry: t,
|
|
29584
29596
|
target: o,
|
|
@@ -29591,18 +29603,18 @@ async function Ta(e) {
|
|
|
29591
29603
|
}
|
|
29592
29604
|
//#endregion
|
|
29593
29605
|
//#region src/v2019C1/hooks/after-updated/after-updated.ts
|
|
29594
|
-
async function
|
|
29595
|
-
return
|
|
29606
|
+
async function Ca(e) {
|
|
29607
|
+
return ba(e);
|
|
29596
29608
|
}
|
|
29597
29609
|
//#endregion
|
|
29598
29610
|
//#region src/v2019C1/hooks/before-clone/before-clone.ts
|
|
29599
|
-
var
|
|
29600
|
-
function
|
|
29601
|
-
return
|
|
29611
|
+
var wa = new Set(Object.values(b).map((e) => e.uri)), Ta = new Set(Object.values(b).map((e) => e.prefix).filter(Boolean));
|
|
29612
|
+
function Ea(e) {
|
|
29613
|
+
return wa.has(e.namespace.uri) && !n(e.tagName, x);
|
|
29602
29614
|
}
|
|
29603
|
-
function
|
|
29615
|
+
function Da(e) {
|
|
29604
29616
|
let { record: t } = e, n = t, r = !0, i = !!t.value?.trim(), a = t.attributes.find((e) => e.name === "type")?.value, o = a !== void 0;
|
|
29605
|
-
t.tagName === "Private" && !t.tree.length && !i && !o && (r = !1), t.tagName === "Private" && !t.tree.length && !i && a !== void 0 &&
|
|
29617
|
+
t.tagName === "Private" && !t.tree.length && !i && !o && (r = !1), t.tagName === "Private" && !t.tree.length && !i && a !== void 0 && Ta.has(a) && (r = !1), Ea(n) && (r = !1), t.tagName === "Private" && n.tree.length > 0 && n.tree.every(Ea) && (r = !1);
|
|
29606
29618
|
let s = t.attributes.filter((e) => e.name !== "uuid");
|
|
29607
29619
|
return {
|
|
29608
29620
|
shouldBeCloned: r,
|
|
@@ -29614,17 +29626,17 @@ function Aa(e) {
|
|
|
29614
29626
|
}
|
|
29615
29627
|
//#endregion
|
|
29616
29628
|
//#region src/v2019C1/hooks/before-delete/orphaned-refs.ts
|
|
29617
|
-
async function
|
|
29629
|
+
async function Oa(e) {
|
|
29618
29630
|
let { record: t, query: n } = e, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
|
|
29619
|
-
if (await
|
|
29631
|
+
if (await Pa({
|
|
29620
29632
|
record: t,
|
|
29621
29633
|
query: n,
|
|
29622
29634
|
ids: r,
|
|
29623
29635
|
uuids: i
|
|
29624
29636
|
}), i.size === 0) return [];
|
|
29625
29637
|
let a = [];
|
|
29626
|
-
for (let e of
|
|
29627
|
-
let t = await
|
|
29638
|
+
for (let e of k) {
|
|
29639
|
+
let t = await ka({
|
|
29628
29640
|
refTagName: e,
|
|
29629
29641
|
subtreeIds: r,
|
|
29630
29642
|
subtreeUuids: i,
|
|
@@ -29634,11 +29646,11 @@ async function ja(e) {
|
|
|
29634
29646
|
}
|
|
29635
29647
|
return a;
|
|
29636
29648
|
}
|
|
29637
|
-
async function
|
|
29638
|
-
let { refTagName: t, subtreeIds: n, subtreeUuids: r, query: i } = e, a =
|
|
29649
|
+
async function ka(e) {
|
|
29650
|
+
let { refTagName: t, subtreeIds: n, subtreeUuids: r, query: i } = e, a = D[t], o = await i.getRecordsByTagName(t), s = [];
|
|
29639
29651
|
for (let e of o) {
|
|
29640
29652
|
if (n.has(e.id)) continue;
|
|
29641
|
-
let o = await
|
|
29653
|
+
let o = await Aa({
|
|
29642
29654
|
refTagName: t,
|
|
29643
29655
|
refRecord: e,
|
|
29644
29656
|
refPairs: a,
|
|
@@ -29649,15 +29661,15 @@ async function Ma(e) {
|
|
|
29649
29661
|
}
|
|
29650
29662
|
return s;
|
|
29651
29663
|
}
|
|
29652
|
-
async function
|
|
29653
|
-
let { refTagName: t, refRecord: n, refPairs: r, subtreeUuids: i, query: a } = e, o =
|
|
29664
|
+
async function Aa(e) {
|
|
29665
|
+
let { refTagName: t, refRecord: n, refPairs: r, subtreeUuids: i, query: a } = e, o = ja({
|
|
29654
29666
|
refPairs: r,
|
|
29655
29667
|
refRecord: n,
|
|
29656
29668
|
subtreeUuids: i
|
|
29657
29669
|
});
|
|
29658
|
-
return o.size === 0 ? [] :
|
|
29670
|
+
return o.size === 0 ? [] : O.has(t) ? [Ma(n, o)] : Na(n, a);
|
|
29659
29671
|
}
|
|
29660
|
-
function
|
|
29672
|
+
function ja(e) {
|
|
29661
29673
|
let { refPairs: t, refRecord: n, subtreeUuids: r } = e, i = /* @__PURE__ */ new Set();
|
|
29662
29674
|
for (let e of t) {
|
|
29663
29675
|
let t = n.attributes.find((t) => t.name === e.attribute.uuid)?.value;
|
|
@@ -29668,7 +29680,7 @@ function Pa(e) {
|
|
|
29668
29680
|
}
|
|
29669
29681
|
return i;
|
|
29670
29682
|
}
|
|
29671
|
-
function
|
|
29683
|
+
function Ma(e, t) {
|
|
29672
29684
|
let n = e.attributes.filter((e) => !t.has(e.name));
|
|
29673
29685
|
return {
|
|
29674
29686
|
status: "updated",
|
|
@@ -29679,7 +29691,7 @@ function Fa(e, t) {
|
|
|
29679
29691
|
})
|
|
29680
29692
|
};
|
|
29681
29693
|
}
|
|
29682
|
-
async function
|
|
29694
|
+
async function Na(e, t) {
|
|
29683
29695
|
let n = [{
|
|
29684
29696
|
status: "deleted",
|
|
29685
29697
|
oldRecord: i(e),
|
|
@@ -29701,14 +29713,14 @@ async function Ia(e, t) {
|
|
|
29701
29713
|
}
|
|
29702
29714
|
return n;
|
|
29703
29715
|
}
|
|
29704
|
-
async function
|
|
29716
|
+
async function Pa(e) {
|
|
29705
29717
|
let { record: t, query: n, ids: r, uuids: i } = e;
|
|
29706
29718
|
r.add(t.id);
|
|
29707
29719
|
let a = t.attributes.find((e) => e.name === "uuid")?.value;
|
|
29708
29720
|
a && i.add(a);
|
|
29709
29721
|
for (let e of t.children) {
|
|
29710
29722
|
let t = await n.getRecord(e);
|
|
29711
|
-
t && await
|
|
29723
|
+
t && await Pa({
|
|
29712
29724
|
record: t,
|
|
29713
29725
|
query: n,
|
|
29714
29726
|
ids: r,
|
|
@@ -29718,29 +29730,29 @@ async function La(e) {
|
|
|
29718
29730
|
}
|
|
29719
29731
|
//#endregion
|
|
29720
29732
|
//#region src/v2019C1/hooks/before-delete/before-delete.ts
|
|
29721
|
-
async function
|
|
29722
|
-
return
|
|
29733
|
+
async function Fa(e) {
|
|
29734
|
+
return Oa(e);
|
|
29723
29735
|
}
|
|
29724
29736
|
//#endregion
|
|
29725
29737
|
//#region src/v2019C1/hooks/io/io-hooks.ts
|
|
29726
|
-
function
|
|
29738
|
+
function Ia() {
|
|
29727
29739
|
let e = /* @__PURE__ */ new Map(), t = [], n = [];
|
|
29728
29740
|
return {
|
|
29729
29741
|
beforeImportRecord: (r) => {
|
|
29730
29742
|
let { record: i, ancestry: a } = r, { tagName: o } = i, s = i.attributes.find((e) => e.name === "uuid")?.value;
|
|
29731
29743
|
if (s && pe.has(o)) {
|
|
29732
|
-
let t =
|
|
29744
|
+
let t = ue({
|
|
29733
29745
|
record: i,
|
|
29734
29746
|
ancestry: a
|
|
29735
29747
|
});
|
|
29736
29748
|
t && e.set(t.path, s);
|
|
29737
29749
|
}
|
|
29738
29750
|
if (!A.has(o)) return;
|
|
29739
|
-
let c =
|
|
29751
|
+
let c = D[o];
|
|
29740
29752
|
for (let e of c) {
|
|
29741
29753
|
let r = i.attributes.find((t) => t.name === e.attribute.path)?.value;
|
|
29742
29754
|
if (!r || i.attributes.find((t) => t.name === e.attribute.uuid)?.value) continue;
|
|
29743
|
-
let s =
|
|
29755
|
+
let s = ge(e.resolution, e.attribute.path, r, a);
|
|
29744
29756
|
if (!s) {
|
|
29745
29757
|
e.resolution === M.unsupported && n.push({
|
|
29746
29758
|
type: "unsupported-xpath-reference",
|
|
@@ -29798,13 +29810,12 @@ function za() {
|
|
|
29798
29810
|
}
|
|
29799
29811
|
//#endregion
|
|
29800
29812
|
//#region src/v2019C1/hooks/index.ts
|
|
29801
|
-
var
|
|
29802
|
-
beforeClone:
|
|
29803
|
-
afterStandardizedRecord:
|
|
29804
|
-
afterCreated:
|
|
29805
|
-
|
|
29806
|
-
|
|
29807
|
-
beforeDelete: Ra
|
|
29813
|
+
var La = {
|
|
29814
|
+
beforeClone: Da,
|
|
29815
|
+
afterStandardizedRecord: ya,
|
|
29816
|
+
afterCreated: _a,
|
|
29817
|
+
afterUpdated: Ca,
|
|
29818
|
+
beforeDelete: Fa
|
|
29808
29819
|
};
|
|
29809
29820
|
//#endregion
|
|
29810
|
-
export { b as A, pe as C, y as D,
|
|
29821
|
+
export { b as A, pe as C, y as D, ae as E, x as O, A as S, se as T, Fe as _, St as a, O as b, Ne as c, P as d, Me as f, F as g, Pe as h, zi as i, v as k, je as l, Ae as m, Ia as n, at as o, ke as p, Hi as r, Le as s, La as t, Ie as u, N as v, D as w, k as x, M as y };
|