@dialecte/scl 0.3.12 → 0.3.13
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-D5DJSztS.js} +1081 -1082
- 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.js +1 -1
- 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,32 @@ 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, s =
|
|
26088
|
+
async function It(e, t) {
|
|
26089
|
+
let { sourceQuery: n, records: r, cloneMappings: i = [], forkPrefix: a = "", keepNameTypesFrom: o = "target" } = t, s = Lt(await S(n, { records: r })), c = await e.ensureChild(await e.getRoot(), {
|
|
26045
26090
|
tagName: "DataTypeTemplates",
|
|
26046
26091
|
attributes: {}
|
|
26047
|
-
}), l = await
|
|
26092
|
+
}), l = await zt(e), u = /* @__PURE__ */ new Map(), d = [], f = [], p = {
|
|
26048
26093
|
reused: 0,
|
|
26049
26094
|
preserved: 0,
|
|
26050
26095
|
forked: 0,
|
|
26051
26096
|
reclaimed: 0
|
|
26052
|
-
};
|
|
26097
|
+
}, m = /* @__PURE__ */ new Map();
|
|
26053
26098
|
for (let t of s) {
|
|
26054
26099
|
let r = await n.getAttribute(t, { name: "id" });
|
|
26055
26100
|
if (!r) continue;
|
|
26056
|
-
let i = await
|
|
26101
|
+
let i = await Ct(n, {
|
|
26057
26102
|
ref: {
|
|
26058
26103
|
tagName: t.tagName,
|
|
26059
26104
|
id: t.id
|
|
26060
26105
|
},
|
|
26061
|
-
resolveReferences: !0
|
|
26106
|
+
resolveReferences: !0,
|
|
26107
|
+
signatureCache: m
|
|
26062
26108
|
}), s = l.get(i);
|
|
26063
26109
|
if (s !== void 0) {
|
|
26064
|
-
let n = o === "source" ? await
|
|
26110
|
+
let n = o === "source" ? await Bt(e, {
|
|
26065
26111
|
tagName: t.tagName,
|
|
26066
26112
|
currentId: s,
|
|
26067
26113
|
desiredId: r
|
|
@@ -26069,41 +26115,41 @@ async function Lt(e, t) {
|
|
|
26069
26115
|
u.set(r, n), n !== s && l.set(i, n), p.reused++;
|
|
26070
26116
|
continue;
|
|
26071
26117
|
}
|
|
26072
|
-
let
|
|
26073
|
-
if (!
|
|
26074
|
-
let [
|
|
26118
|
+
let h = await n.getTree(t);
|
|
26119
|
+
if (!h) continue;
|
|
26120
|
+
let [g] = await e.findByAttributes({
|
|
26075
26121
|
tagName: t.tagName,
|
|
26076
26122
|
attributes: { id: r }
|
|
26077
|
-
}),
|
|
26078
|
-
|
|
26079
|
-
let
|
|
26080
|
-
u.set(r,
|
|
26123
|
+
}), _ = r, v = h;
|
|
26124
|
+
g ? (_ = await qt(e, t.tagName, `${a}${r}_${Jt(i)}`), v = Vt(h, _), p.forked++) : p.preserved++;
|
|
26125
|
+
let y = await e.deepClone(c, v);
|
|
26126
|
+
u.set(r, _), y?.record && (d.push(B(y.record.tagName, y.record.id)), g && f.push({
|
|
26081
26127
|
oldId: r,
|
|
26082
|
-
oldRef:
|
|
26083
|
-
forkRef:
|
|
26084
|
-
forkedId:
|
|
26128
|
+
oldRef: B(g.tagName, g.id),
|
|
26129
|
+
forkRef: B(y.record.tagName, y.record.id),
|
|
26130
|
+
forkedId: _
|
|
26085
26131
|
}));
|
|
26086
26132
|
}
|
|
26087
|
-
let
|
|
26088
|
-
for (let t of i) t.target.tagName === "LNode" && await
|
|
26133
|
+
let h = [];
|
|
26134
|
+
for (let t of i) t.target.tagName === "LNode" && await te(e, t.target) || h.push(t.target);
|
|
26089
26135
|
for (let t of d) {
|
|
26090
26136
|
let n = await e.getTree(t);
|
|
26091
|
-
n &&
|
|
26137
|
+
n && Ht(n, h);
|
|
26092
26138
|
}
|
|
26093
|
-
return await
|
|
26094
|
-
records:
|
|
26139
|
+
return await L(e, {
|
|
26140
|
+
records: h,
|
|
26095
26141
|
idRemap: u
|
|
26096
|
-
}), f.length > 0 && await
|
|
26142
|
+
}), f.length > 0 && await Ut(e, {
|
|
26097
26143
|
collisions: f,
|
|
26098
26144
|
idRemap: u,
|
|
26099
|
-
referrerRecords:
|
|
26145
|
+
referrerRecords: h,
|
|
26100
26146
|
stats: p
|
|
26101
26147
|
}), {
|
|
26102
26148
|
idRemap: u,
|
|
26103
26149
|
stats: p
|
|
26104
26150
|
};
|
|
26105
26151
|
}
|
|
26106
|
-
function
|
|
26152
|
+
function Lt(e) {
|
|
26107
26153
|
return [
|
|
26108
26154
|
...e.enumTypes,
|
|
26109
26155
|
...e.daTypes,
|
|
@@ -26111,32 +26157,33 @@ function Rt(e) {
|
|
|
26111
26157
|
...e.lnodeTypes
|
|
26112
26158
|
];
|
|
26113
26159
|
}
|
|
26114
|
-
var
|
|
26160
|
+
var Rt = [
|
|
26115
26161
|
"EnumType",
|
|
26116
26162
|
"DAType",
|
|
26117
26163
|
"DOType",
|
|
26118
26164
|
"LNodeType"
|
|
26119
26165
|
];
|
|
26120
|
-
async function
|
|
26121
|
-
let t = /* @__PURE__ */ new Map();
|
|
26122
|
-
for (let
|
|
26123
|
-
let
|
|
26124
|
-
for (let
|
|
26125
|
-
let
|
|
26126
|
-
if (!
|
|
26127
|
-
let
|
|
26166
|
+
async function zt(e) {
|
|
26167
|
+
let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
|
|
26168
|
+
for (let r of Rt) {
|
|
26169
|
+
let i = await e.getRecordsByTagName(r);
|
|
26170
|
+
for (let a of i) {
|
|
26171
|
+
let i = a.attributes.find((e) => e.name === "id")?.value;
|
|
26172
|
+
if (!i) continue;
|
|
26173
|
+
let o = await Ct(e, {
|
|
26128
26174
|
ref: {
|
|
26129
|
-
tagName:
|
|
26130
|
-
id:
|
|
26175
|
+
tagName: r,
|
|
26176
|
+
id: a.id
|
|
26131
26177
|
},
|
|
26132
|
-
resolveReferences: !0
|
|
26178
|
+
resolveReferences: !0,
|
|
26179
|
+
signatureCache: n
|
|
26133
26180
|
});
|
|
26134
|
-
t.has(
|
|
26181
|
+
t.has(o) || t.set(o, i);
|
|
26135
26182
|
}
|
|
26136
26183
|
}
|
|
26137
26184
|
return t;
|
|
26138
26185
|
}
|
|
26139
|
-
async function
|
|
26186
|
+
async function Bt(e, t) {
|
|
26140
26187
|
let { tagName: n, currentId: r, desiredId: i } = t;
|
|
26141
26188
|
if (r === i) return r;
|
|
26142
26189
|
let [a] = await e.findByAttributes({
|
|
@@ -26149,32 +26196,32 @@ async function Vt(e, t) {
|
|
|
26149
26196
|
attributes: { id: i }
|
|
26150
26197
|
});
|
|
26151
26198
|
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) =>
|
|
26199
|
+
let s = B(a.tagName, a.id), c = await I(e, { target: s });
|
|
26200
|
+
return await e.update(s, { attributes: { id: i } }), await L(e, {
|
|
26201
|
+
records: c.map((e) => B(e.ref.tagName, e.ref.id)),
|
|
26155
26202
|
idRemap: new Map([[r, i]])
|
|
26156
26203
|
}), i;
|
|
26157
26204
|
}
|
|
26158
|
-
function
|
|
26205
|
+
function Vt(e, t) {
|
|
26159
26206
|
let n = structuredClone(e), r = n.attributes, i = r.find((e) => e.name === "id");
|
|
26160
26207
|
return i ? i.value = t : r.push({
|
|
26161
26208
|
name: "id",
|
|
26162
26209
|
value: t
|
|
26163
26210
|
}), n;
|
|
26164
26211
|
}
|
|
26165
|
-
function
|
|
26212
|
+
function B(e, t) {
|
|
26166
26213
|
return {
|
|
26167
26214
|
tagName: e,
|
|
26168
26215
|
id: t
|
|
26169
26216
|
};
|
|
26170
26217
|
}
|
|
26171
|
-
function
|
|
26172
|
-
t.push(
|
|
26173
|
-
for (let n of e.tree ?? [])
|
|
26218
|
+
function Ht(e, t) {
|
|
26219
|
+
t.push(B(e.tagName, e.id));
|
|
26220
|
+
for (let n of e.tree ?? []) Ht(n, t);
|
|
26174
26221
|
}
|
|
26175
|
-
var
|
|
26176
|
-
async function
|
|
26177
|
-
let { collisions: n, idRemap: r, referrerRecords: i, stats: a } = t, o = await
|
|
26222
|
+
var V = (e) => `${e.tagName}#${e.id}`;
|
|
26223
|
+
async function Ut(e, t) {
|
|
26224
|
+
let { collisions: n, idRemap: r, referrerRecords: i, stats: a } = t, o = await Wt(e, n), s = /* @__PURE__ */ new Map(), c = [];
|
|
26178
26225
|
for (let t of n) if (o.has(t.oldId)) {
|
|
26179
26226
|
await e.update(t.forkRef, { attributes: { id: t.oldId } }), s.set(t.forkedId, t.oldId), c.push(t.forkRef), a.reclaimed++;
|
|
26180
26227
|
for (let [e, n] of r) n === t.forkedId && r.set(e, t.oldId);
|
|
@@ -26183,38 +26230,38 @@ async function Wt(e, t) {
|
|
|
26183
26230
|
let l = [...i];
|
|
26184
26231
|
for (let t of c) {
|
|
26185
26232
|
let n = await e.getTree(t);
|
|
26186
|
-
n &&
|
|
26233
|
+
n && Ht(n, l);
|
|
26187
26234
|
}
|
|
26188
|
-
await
|
|
26235
|
+
await L(e, {
|
|
26189
26236
|
records: l,
|
|
26190
26237
|
idRemap: s
|
|
26191
26238
|
});
|
|
26192
26239
|
}
|
|
26193
|
-
async function
|
|
26194
|
-
let n = /* @__PURE__ */ new Set(), r = new Map(t.map((e) => [
|
|
26240
|
+
async function Wt(e, t) {
|
|
26241
|
+
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
26242
|
for (; s;) {
|
|
26196
26243
|
s = !1;
|
|
26197
26244
|
for (let t of i) {
|
|
26198
|
-
let c =
|
|
26199
|
-
if (o.has(c) || (await
|
|
26200
|
-
let l = await e.getTree(t), u = l ? await
|
|
26245
|
+
let c = V(t);
|
|
26246
|
+
if (o.has(c) || (await I(e, { target: t })).length > 0) continue;
|
|
26247
|
+
let l = await e.getTree(t), u = l ? await Gt(e, l) : [];
|
|
26201
26248
|
await e.delete(t), o.add(c), s = !0;
|
|
26202
26249
|
let d = r.get(c);
|
|
26203
26250
|
d !== void 0 && n.add(d);
|
|
26204
26251
|
for (let e of u) {
|
|
26205
|
-
let t =
|
|
26252
|
+
let t = V(e);
|
|
26206
26253
|
a.has(t) || (i.push(e), a.add(t));
|
|
26207
26254
|
}
|
|
26208
26255
|
}
|
|
26209
26256
|
}
|
|
26210
26257
|
return n;
|
|
26211
26258
|
}
|
|
26212
|
-
async function
|
|
26259
|
+
async function Gt(e, t) {
|
|
26213
26260
|
let n = [], r = /* @__PURE__ */ new Set();
|
|
26214
26261
|
async function i(t) {
|
|
26215
26262
|
let a = N[t.tagName];
|
|
26216
26263
|
for (let i of a ?? []) {
|
|
26217
|
-
if (!
|
|
26264
|
+
if (!Kt(t, i)) continue;
|
|
26218
26265
|
let a = t.attributes.find((e) => e.name === i.attribute)?.value;
|
|
26219
26266
|
if (!a) continue;
|
|
26220
26267
|
let [o] = await e.findByAttributes({
|
|
@@ -26222,17 +26269,17 @@ async function Kt(e, t) {
|
|
|
26222
26269
|
attributes: { id: a }
|
|
26223
26270
|
});
|
|
26224
26271
|
if (!o) continue;
|
|
26225
|
-
let s =
|
|
26272
|
+
let s = B(i.target, o.id), c = V(s);
|
|
26226
26273
|
r.has(c) || (r.add(c), n.push(s));
|
|
26227
26274
|
}
|
|
26228
26275
|
for (let e of t.tree ?? []) await i(e);
|
|
26229
26276
|
}
|
|
26230
26277
|
return await i(t), n;
|
|
26231
26278
|
}
|
|
26232
|
-
function
|
|
26279
|
+
function Kt(e, t) {
|
|
26233
26280
|
return t.when ? e.attributes.find((e) => e.name === t.when.attribute)?.value === t.when.equals : !0;
|
|
26234
26281
|
}
|
|
26235
|
-
async function
|
|
26282
|
+
async function qt(e, t, n) {
|
|
26236
26283
|
let r = n, i = 2;
|
|
26237
26284
|
for (; (await e.findByAttributes({
|
|
26238
26285
|
tagName: t,
|
|
@@ -26240,20 +26287,20 @@ async function Jt(e, t, n) {
|
|
|
26240
26287
|
})).length > 0;) r = `${n}_${i}`, i += 1;
|
|
26241
26288
|
return r;
|
|
26242
26289
|
}
|
|
26243
|
-
function
|
|
26290
|
+
function Jt(e) {
|
|
26244
26291
|
let t = 2166136261;
|
|
26245
26292
|
for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619);
|
|
26246
26293
|
return (t >>> 0).toString(16).padStart(8, "0");
|
|
26247
26294
|
}
|
|
26248
26295
|
//#endregion
|
|
26249
26296
|
//#region src/v2019C1/extensions/data-model/index.ts
|
|
26250
|
-
var
|
|
26251
|
-
query:
|
|
26252
|
-
transaction: /* @__PURE__ */ l({ importTypes: () =>
|
|
26297
|
+
var Yt = {
|
|
26298
|
+
query: ne,
|
|
26299
|
+
transaction: /* @__PURE__ */ l({ importTypes: () => It })
|
|
26253
26300
|
};
|
|
26254
26301
|
//#endregion
|
|
26255
26302
|
//#region src/v2019C1/extensions/history/query/get-sorted-hitem.ts
|
|
26256
|
-
async function
|
|
26303
|
+
async function Xt(e) {
|
|
26257
26304
|
let t = await e.getRecord({ tagName: "History" });
|
|
26258
26305
|
if (!t) return [];
|
|
26259
26306
|
let { Hitem: n = [] } = await e.findDescendants(t, { collect: "Hitem" });
|
|
@@ -26267,18 +26314,18 @@ async function Zt(e) {
|
|
|
26267
26314
|
}
|
|
26268
26315
|
//#endregion
|
|
26269
26316
|
//#region src/v2019C1/extensions/history/query/get-latest-hitem.ts
|
|
26270
|
-
async function
|
|
26271
|
-
return (await
|
|
26317
|
+
async function Zt(e) {
|
|
26318
|
+
return (await Xt(e)).at(-1);
|
|
26272
26319
|
}
|
|
26273
26320
|
//#endregion
|
|
26274
26321
|
//#region src/v2019C1/extensions/history/query/index.ts
|
|
26275
|
-
var
|
|
26276
|
-
getLatestHitem: () =>
|
|
26277
|
-
getSortedHitems: () =>
|
|
26322
|
+
var Qt = /* @__PURE__ */ l({
|
|
26323
|
+
getLatestHitem: () => Zt,
|
|
26324
|
+
getSortedHitems: () => Xt
|
|
26278
26325
|
});
|
|
26279
26326
|
//#endregion
|
|
26280
26327
|
//#region src/v2019C1/extensions/history/transaction/add-entry.ts
|
|
26281
|
-
async function
|
|
26328
|
+
async function $t(e, t) {
|
|
26282
26329
|
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
26330
|
tagName: "Header",
|
|
26284
26331
|
attributes: {
|
|
@@ -26293,7 +26340,7 @@ async function en(e, t) {
|
|
|
26293
26340
|
}), h = await e.getRecord({ tagName: "History" }) ?? await e.addChild(m, {
|
|
26294
26341
|
tagName: "History",
|
|
26295
26342
|
attributes: {}
|
|
26296
|
-
}), g = await
|
|
26343
|
+
}), 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
26344
|
await e.update(m, { attributes: {
|
|
26298
26345
|
version: y,
|
|
26299
26346
|
revision: b
|
|
@@ -26316,57 +26363,92 @@ async function en(e, t) {
|
|
|
26316
26363
|
}
|
|
26317
26364
|
//#endregion
|
|
26318
26365
|
//#region src/v2019C1/extensions/history/index.ts
|
|
26319
|
-
var
|
|
26320
|
-
query:
|
|
26321
|
-
transaction: /* @__PURE__ */ l({ addEntry: () =>
|
|
26366
|
+
var en = {
|
|
26367
|
+
query: Qt,
|
|
26368
|
+
transaction: /* @__PURE__ */ l({ addEntry: () => $t })
|
|
26322
26369
|
};
|
|
26323
26370
|
//#endregion
|
|
26324
26371
|
//#region src/v2019C1/extensions/identity/transaction/write-identity.ts
|
|
26325
|
-
async function
|
|
26372
|
+
async function H(e, t) {
|
|
26326
26373
|
let { mappings: n, mode: r } = t;
|
|
26327
26374
|
if (r !== "keep") for (let t of n) {
|
|
26328
|
-
let n = r === "strip" ?
|
|
26375
|
+
let n = r === "strip" ? tn() : nn(t);
|
|
26329
26376
|
if (Object.keys(n).length === 0) continue;
|
|
26330
26377
|
let i = await e.getRecord(t.target);
|
|
26331
26378
|
i && await e.update(i, { attributes: n });
|
|
26332
26379
|
}
|
|
26333
26380
|
}
|
|
26334
|
-
function
|
|
26381
|
+
function tn() {
|
|
26335
26382
|
return {
|
|
26336
26383
|
templateUuid: void 0,
|
|
26337
26384
|
originUuid: void 0
|
|
26338
26385
|
};
|
|
26339
26386
|
}
|
|
26340
|
-
function
|
|
26341
|
-
let t =
|
|
26387
|
+
function nn(e) {
|
|
26388
|
+
let t = an(e.source.attributes, "uuid"), n = an(e.source.attributes, "templateUuid"), r = an(e.source.attributes, "originUuid"), i = {};
|
|
26342
26389
|
t && (i.templateUuid = t);
|
|
26343
|
-
let a =
|
|
26390
|
+
let a = rn(e.target.tagName);
|
|
26344
26391
|
return n && !r && a && (i.originUuid = n), i;
|
|
26345
26392
|
}
|
|
26346
|
-
function
|
|
26393
|
+
function rn(e) {
|
|
26347
26394
|
let t = x.attributes[e];
|
|
26348
26395
|
return t ? "originUuid" in t : !1;
|
|
26349
26396
|
}
|
|
26350
|
-
function
|
|
26397
|
+
function an(e, t) {
|
|
26398
|
+
return e.find((e) => e.name === t)?.value;
|
|
26399
|
+
}
|
|
26400
|
+
//#endregion
|
|
26401
|
+
//#region src/v2019C1/extensions/identity/transaction/restore-cloned-uuids.ts
|
|
26402
|
+
async function on(e, t) {
|
|
26403
|
+
let { mappings: n } = t, r = /* @__PURE__ */ new Map(), i = [];
|
|
26404
|
+
for (let t of n) {
|
|
26405
|
+
let n = sn(t.source.attributes, "uuid");
|
|
26406
|
+
if (!n) continue;
|
|
26407
|
+
let a = await e.getRecord(t.target), o = a ? a.attributes.find((e) => e.name === "uuid")?.value : void 0;
|
|
26408
|
+
!o || o === n || (r.set(o, n), i.push({
|
|
26409
|
+
ref: t.target,
|
|
26410
|
+
sourceUuid: n
|
|
26411
|
+
}));
|
|
26412
|
+
}
|
|
26413
|
+
if (r.size !== 0) {
|
|
26414
|
+
for (let { ref: t, sourceUuid: n } of i) await e.update(t, { attributes: { uuid: n } });
|
|
26415
|
+
for (let t of n) {
|
|
26416
|
+
let n = D[t.target.tagName];
|
|
26417
|
+
if (!n) continue;
|
|
26418
|
+
let i = await e.getRecord(t.target);
|
|
26419
|
+
if (!i) continue;
|
|
26420
|
+
let a = {};
|
|
26421
|
+
for (let e of n) {
|
|
26422
|
+
let t = i.attributes.find((t) => t.name === e.attribute.uuid)?.value, n = t ? r.get(t) : void 0;
|
|
26423
|
+
n && (a[e.attribute.uuid] = n);
|
|
26424
|
+
}
|
|
26425
|
+
Object.keys(a).length > 0 && await e.update(t.target, { attributes: a });
|
|
26426
|
+
}
|
|
26427
|
+
}
|
|
26428
|
+
}
|
|
26429
|
+
function sn(e, t) {
|
|
26351
26430
|
return e.find((e) => e.name === t)?.value;
|
|
26352
26431
|
}
|
|
26353
26432
|
//#endregion
|
|
26354
26433
|
//#region src/v2019C1/extensions/identity/index.ts
|
|
26355
|
-
var
|
|
26434
|
+
var cn = { transaction: /* @__PURE__ */ l({
|
|
26435
|
+
restoreClonedUuids: () => on,
|
|
26436
|
+
writeIdentity: () => H
|
|
26437
|
+
}) };
|
|
26356
26438
|
//#endregion
|
|
26357
26439
|
//#region src/v2019C1/extensions/lifecycle/engine/group.ts
|
|
26358
|
-
function
|
|
26440
|
+
function ln(e, t) {
|
|
26359
26441
|
let n = [];
|
|
26360
|
-
return
|
|
26442
|
+
return un({
|
|
26361
26443
|
node: e,
|
|
26362
26444
|
scopePrefix: t,
|
|
26363
26445
|
out: n
|
|
26364
26446
|
}), n;
|
|
26365
26447
|
}
|
|
26366
|
-
function
|
|
26448
|
+
function un(e) {
|
|
26367
26449
|
let { node: t, scopePrefix: n, out: r } = e;
|
|
26368
26450
|
if (t.change === "unchanged") {
|
|
26369
|
-
for (let e of t.children)
|
|
26451
|
+
for (let e of t.children) un({
|
|
26370
26452
|
node: e,
|
|
26371
26453
|
scopePrefix: n,
|
|
26372
26454
|
out: r
|
|
@@ -26374,11 +26456,11 @@ function ln(e) {
|
|
|
26374
26456
|
return;
|
|
26375
26457
|
}
|
|
26376
26458
|
let i = [];
|
|
26377
|
-
|
|
26459
|
+
dn({
|
|
26378
26460
|
node: t,
|
|
26379
26461
|
out: i
|
|
26380
26462
|
}), r.push({
|
|
26381
|
-
id:
|
|
26463
|
+
id: fn(t, n),
|
|
26382
26464
|
change: t.change,
|
|
26383
26465
|
title: `${t.change} ${t.tagName}`,
|
|
26384
26466
|
primary: t,
|
|
@@ -26387,32 +26469,32 @@ function ln(e) {
|
|
|
26387
26469
|
suggestedAction: t.change === "target-only" ? "skip" : "accept"
|
|
26388
26470
|
});
|
|
26389
26471
|
}
|
|
26390
|
-
function
|
|
26472
|
+
function dn(e) {
|
|
26391
26473
|
let { node: t, out: n } = e;
|
|
26392
|
-
for (let e of t.children) e.change !== "unchanged" && n.push(e),
|
|
26474
|
+
for (let e of t.children) e.change !== "unchanged" && n.push(e), dn({
|
|
26393
26475
|
node: e,
|
|
26394
26476
|
out: n
|
|
26395
26477
|
});
|
|
26396
26478
|
}
|
|
26397
|
-
function
|
|
26479
|
+
function fn(e, t) {
|
|
26398
26480
|
let n = e.sourceRef ?? e.instanceRef, r = n ? `${n.tagName}:${n.id}` : e.tagName;
|
|
26399
26481
|
return t ? `${t}::${r}` : r;
|
|
26400
26482
|
}
|
|
26401
26483
|
//#endregion
|
|
26402
26484
|
//#region src/v2019C1/extensions/lifecycle/engine/visible-attributes.ts
|
|
26403
|
-
var
|
|
26485
|
+
var pn = new Set([
|
|
26404
26486
|
"uuid",
|
|
26405
26487
|
"templateUuid",
|
|
26406
26488
|
"originUuid"
|
|
26407
|
-
]),
|
|
26408
|
-
function
|
|
26489
|
+
]), mn = new Set(Object.values(D).flatMap((e) => e.flatMap((e) => [e.attribute.path, e.attribute.uuid])));
|
|
26490
|
+
function hn(e) {
|
|
26409
26491
|
let t = {};
|
|
26410
|
-
for (let [n, r] of Object.entries(e))
|
|
26492
|
+
for (let [n, r] of Object.entries(e)) pn.has(n) || n === "name" || mn.has(n) || (t[n] = r);
|
|
26411
26493
|
return t;
|
|
26412
26494
|
}
|
|
26413
26495
|
//#endregion
|
|
26414
26496
|
//#region src/v2019C1/extensions/lifecycle/engine/diff.ts
|
|
26415
|
-
var
|
|
26497
|
+
var gn = new Set([
|
|
26416
26498
|
"LNodeSpecNaming",
|
|
26417
26499
|
"FunctionSclRef",
|
|
26418
26500
|
"ApplicationSclRef",
|
|
@@ -26420,95 +26502,98 @@ var mn = new Set([
|
|
|
26420
26502
|
"FunctionRole",
|
|
26421
26503
|
"FunctionRoleContent"
|
|
26422
26504
|
]);
|
|
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 =
|
|
26505
|
+
async function _n(e) {
|
|
26506
|
+
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);
|
|
26507
|
+
if (!l) throw Error("diff: source subtree not found");
|
|
26508
|
+
let u = i ? await n.any.getTree(i) : void 0;
|
|
26509
|
+
if (!u) {
|
|
26510
|
+
let e = wn(l);
|
|
26429
26511
|
return {
|
|
26430
26512
|
root: e,
|
|
26431
|
-
groups:
|
|
26432
|
-
summary:
|
|
26513
|
+
groups: ln(e),
|
|
26514
|
+
summary: Fn(e)
|
|
26433
26515
|
};
|
|
26434
26516
|
}
|
|
26435
|
-
let
|
|
26436
|
-
await
|
|
26437
|
-
node:
|
|
26438
|
-
index:
|
|
26517
|
+
let d = /* @__PURE__ */ new Map();
|
|
26518
|
+
await Mn(n, {
|
|
26519
|
+
node: u,
|
|
26520
|
+
index: d,
|
|
26521
|
+
matchKey: c
|
|
26439
26522
|
});
|
|
26440
|
-
let
|
|
26441
|
-
await
|
|
26442
|
-
node:
|
|
26443
|
-
out:
|
|
26523
|
+
let f = /* @__PURE__ */ new Set();
|
|
26524
|
+
await Nn(t, {
|
|
26525
|
+
node: l,
|
|
26526
|
+
out: f
|
|
26444
26527
|
});
|
|
26445
|
-
let
|
|
26528
|
+
let p = await vn(t, {
|
|
26446
26529
|
targetQuery: n,
|
|
26447
|
-
sourceNode:
|
|
26448
|
-
instanceNode:
|
|
26449
|
-
index:
|
|
26450
|
-
sourceUuids:
|
|
26530
|
+
sourceNode: l,
|
|
26531
|
+
instanceNode: u,
|
|
26532
|
+
index: d,
|
|
26533
|
+
sourceUuids: f,
|
|
26451
26534
|
keepLeftoverRefs: a ?? !1,
|
|
26452
26535
|
leftoverRefPolicy: o,
|
|
26453
|
-
refsAlwaysAdded: s
|
|
26454
|
-
|
|
26536
|
+
refsAlwaysAdded: s,
|
|
26537
|
+
matchKey: c
|
|
26538
|
+
}), m = Fn(p);
|
|
26455
26539
|
return {
|
|
26456
|
-
root:
|
|
26457
|
-
groups:
|
|
26458
|
-
summary:
|
|
26540
|
+
root: p,
|
|
26541
|
+
groups: ln(p, u.id),
|
|
26542
|
+
summary: m
|
|
26459
26543
|
};
|
|
26460
26544
|
}
|
|
26461
|
-
async function
|
|
26462
|
-
let { targetQuery: n, sourceNode: r, instanceNode: i, index: o, sourceUuids: s, keepLeftoverRefs: c } = t,
|
|
26545
|
+
async function vn(e, t) {
|
|
26546
|
+
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
26547
|
targetQuery: n,
|
|
26464
26548
|
sourceNode: r,
|
|
26465
26549
|
instanceNode: i
|
|
26466
|
-
}),
|
|
26550
|
+
}), p = [], m = /* @__PURE__ */ new Set();
|
|
26467
26551
|
for (let t of r.tree) {
|
|
26468
|
-
let r = await
|
|
26552
|
+
let r = await yn(e, {
|
|
26469
26553
|
targetQuery: n,
|
|
26470
26554
|
sourceChild: t,
|
|
26471
26555
|
instanceNode: i,
|
|
26472
26556
|
index: o,
|
|
26473
|
-
matchedInstanceIds:
|
|
26474
|
-
refsAlwaysAdded:
|
|
26557
|
+
matchedInstanceIds: m,
|
|
26558
|
+
refsAlwaysAdded: d
|
|
26475
26559
|
});
|
|
26476
|
-
r ? (
|
|
26560
|
+
r ? (m.add(r.id), p.push(await vn(e, {
|
|
26477
26561
|
targetQuery: n,
|
|
26478
26562
|
sourceNode: t,
|
|
26479
26563
|
instanceNode: r,
|
|
26480
26564
|
index: o,
|
|
26481
26565
|
sourceUuids: s,
|
|
26482
26566
|
keepLeftoverRefs: c,
|
|
26483
|
-
leftoverRefPolicy:
|
|
26484
|
-
refsAlwaysAdded:
|
|
26485
|
-
|
|
26567
|
+
leftoverRefPolicy: u,
|
|
26568
|
+
refsAlwaysAdded: d,
|
|
26569
|
+
matchKey: l
|
|
26570
|
+
}))) : p.push(wn(t));
|
|
26486
26571
|
}
|
|
26487
|
-
let
|
|
26572
|
+
let h = await Dn(e, r);
|
|
26488
26573
|
for (let e of i.tree) {
|
|
26489
|
-
if (
|
|
26490
|
-
let t = await n.any.getAttribute(e, { name:
|
|
26574
|
+
if (m.has(e.id)) continue;
|
|
26575
|
+
let t = await n.any.getAttribute(e, { name: l });
|
|
26491
26576
|
if (t) {
|
|
26492
|
-
s.has(t) ||
|
|
26577
|
+
s.has(t) || p.push(Tn(e));
|
|
26493
26578
|
continue;
|
|
26494
26579
|
}
|
|
26495
|
-
if (A.has(e.tagName) && !
|
|
26496
|
-
let t = c || await
|
|
26497
|
-
t && !r ?
|
|
26580
|
+
if (A.has(e.tagName) && !O.has(e.tagName)) {
|
|
26581
|
+
let t = c || await On(n, e, h), r = t && u ? await u(e) === "removed" : !1;
|
|
26582
|
+
t && !r ? p.push(En(e)) : p.push(Tn(e));
|
|
26498
26583
|
continue;
|
|
26499
26584
|
}
|
|
26500
|
-
|
|
26585
|
+
An(e, p);
|
|
26501
26586
|
}
|
|
26502
26587
|
return {
|
|
26503
|
-
change:
|
|
26588
|
+
change: f.length > 0 ? "modified" : "unchanged",
|
|
26504
26589
|
tagName: r.tagName,
|
|
26505
26590
|
sourceRef: a(r),
|
|
26506
26591
|
instanceRef: a(i),
|
|
26507
|
-
attributeChanges:
|
|
26508
|
-
children:
|
|
26592
|
+
attributeChanges: f.length > 0 ? f : void 0,
|
|
26593
|
+
children: p
|
|
26509
26594
|
};
|
|
26510
26595
|
}
|
|
26511
|
-
async function
|
|
26596
|
+
async function yn(e, t) {
|
|
26512
26597
|
let { targetQuery: n, sourceChild: r, instanceNode: i, index: a, matchedInstanceIds: o } = t, s = await e.any.getAttribute(r, { name: "uuid" });
|
|
26513
26598
|
if (s) {
|
|
26514
26599
|
let e = a.get(s);
|
|
@@ -26518,30 +26603,30 @@ async function _n(e, t) {
|
|
|
26518
26603
|
let c = i.tree.filter((e) => e.tagName === r.tagName && !o.has(e.id));
|
|
26519
26604
|
if (c.length !== 0) {
|
|
26520
26605
|
if (A.has(r.tagName)) {
|
|
26521
|
-
let t = await
|
|
26606
|
+
let t = await bn(e, r, { mapToTemplate: !1 });
|
|
26522
26607
|
if (t === void 0) return c[0];
|
|
26523
|
-
for (let e of c) if (await
|
|
26524
|
-
let i = await
|
|
26608
|
+
for (let e of c) if (await bn(n, e, { mapToTemplate: !0 }) === t) return e;
|
|
26609
|
+
let i = await Sn(e, r);
|
|
26525
26610
|
if (i === void 0) return;
|
|
26526
|
-
for (let e of c) if (await
|
|
26611
|
+
for (let e of c) if (await Sn(n, e) === i) return e;
|
|
26527
26612
|
return;
|
|
26528
26613
|
}
|
|
26529
26614
|
return c[0];
|
|
26530
26615
|
}
|
|
26531
26616
|
}
|
|
26532
|
-
async function
|
|
26533
|
-
let r =
|
|
26617
|
+
async function bn(e, t, n) {
|
|
26618
|
+
let r = D[t.tagName];
|
|
26534
26619
|
if (!r) return;
|
|
26535
26620
|
let i = [];
|
|
26536
26621
|
for (let a of r) {
|
|
26537
26622
|
let r = await e.any.getAttribute(t, { name: a.attribute.uuid });
|
|
26538
26623
|
if (!r) continue;
|
|
26539
|
-
let o = n.mapToTemplate ? await
|
|
26624
|
+
let o = n.mapToTemplate ? await xn(e, r, a.target) : r;
|
|
26540
26625
|
i.push(`${a.attribute.uuid}=${o}`);
|
|
26541
26626
|
}
|
|
26542
26627
|
return i.length > 0 ? i.sort().join("|") : void 0;
|
|
26543
26628
|
}
|
|
26544
|
-
async function
|
|
26629
|
+
async function xn(e, t, n) {
|
|
26545
26630
|
for (let r of n) {
|
|
26546
26631
|
let n = (await e.findByAttributes({
|
|
26547
26632
|
tagName: r,
|
|
@@ -26551,19 +26636,19 @@ async function vn(e, t, n) {
|
|
|
26551
26636
|
}
|
|
26552
26637
|
return t;
|
|
26553
26638
|
}
|
|
26554
|
-
async function
|
|
26555
|
-
let n =
|
|
26639
|
+
async function Sn(e, t) {
|
|
26640
|
+
let n = D[t.tagName];
|
|
26556
26641
|
if (!n) return;
|
|
26557
26642
|
let r = [];
|
|
26558
26643
|
for (let i of n) {
|
|
26559
26644
|
let n = await e.any.getAttribute(t, { name: i.attribute.uuid });
|
|
26560
26645
|
if (!n) continue;
|
|
26561
|
-
let a = await
|
|
26646
|
+
let a = await Cn(e, n, i.target);
|
|
26562
26647
|
a !== void 0 && r.push(`${i.attribute.uuid}=${a}`);
|
|
26563
26648
|
}
|
|
26564
26649
|
return r.length > 0 ? r.sort().join("|") : void 0;
|
|
26565
26650
|
}
|
|
26566
|
-
async function
|
|
26651
|
+
async function Cn(e, t, n) {
|
|
26567
26652
|
for (let r of n) {
|
|
26568
26653
|
let n = (await e.findByAttributes({
|
|
26569
26654
|
tagName: r,
|
|
@@ -26572,8 +26657,8 @@ async function yn(e, t, n) {
|
|
|
26572
26657
|
if (n) return await e.any.getAttribute(n, { name: "name" }) || void 0;
|
|
26573
26658
|
}
|
|
26574
26659
|
}
|
|
26575
|
-
function
|
|
26576
|
-
let t = e.tree.map((e) =>
|
|
26660
|
+
function wn(e) {
|
|
26661
|
+
let t = e.tree.map((e) => wn(e));
|
|
26577
26662
|
return {
|
|
26578
26663
|
change: "added",
|
|
26579
26664
|
tagName: e.tagName,
|
|
@@ -26581,8 +26666,8 @@ function bn(e) {
|
|
|
26581
26666
|
children: t
|
|
26582
26667
|
};
|
|
26583
26668
|
}
|
|
26584
|
-
function
|
|
26585
|
-
let t = e.tree.map((e) =>
|
|
26669
|
+
function Tn(e) {
|
|
26670
|
+
let t = e.tree.map((e) => Tn(e));
|
|
26586
26671
|
return {
|
|
26587
26672
|
change: "removed",
|
|
26588
26673
|
tagName: e.tagName,
|
|
@@ -26590,7 +26675,7 @@ function xn(e) {
|
|
|
26590
26675
|
children: t
|
|
26591
26676
|
};
|
|
26592
26677
|
}
|
|
26593
|
-
function
|
|
26678
|
+
function En(e) {
|
|
26594
26679
|
return {
|
|
26595
26680
|
change: "unchanged",
|
|
26596
26681
|
tagName: e.tagName,
|
|
@@ -26598,26 +26683,26 @@ function Sn(e) {
|
|
|
26598
26683
|
children: []
|
|
26599
26684
|
};
|
|
26600
26685
|
}
|
|
26601
|
-
async function
|
|
26686
|
+
async function Dn(e, t) {
|
|
26602
26687
|
let n = /* @__PURE__ */ new Set();
|
|
26603
26688
|
for (let r of t.tree) {
|
|
26604
26689
|
if (!A.has(r.tagName)) continue;
|
|
26605
|
-
let t = await
|
|
26690
|
+
let t = await bn(e, r, { mapToTemplate: !1 });
|
|
26606
26691
|
t && n.add(t);
|
|
26607
|
-
let i = await
|
|
26692
|
+
let i = await Sn(e, r);
|
|
26608
26693
|
i && n.add(i);
|
|
26609
26694
|
}
|
|
26610
26695
|
return n;
|
|
26611
26696
|
}
|
|
26612
|
-
async function
|
|
26697
|
+
async function On(e, t, n) {
|
|
26613
26698
|
if (n.size === 0) return !1;
|
|
26614
|
-
let r = await
|
|
26699
|
+
let r = await bn(e, t, { mapToTemplate: !0 });
|
|
26615
26700
|
if (r && n.has(r)) return !0;
|
|
26616
|
-
let i = await
|
|
26701
|
+
let i = await Sn(e, t);
|
|
26617
26702
|
return !!i && n.has(i);
|
|
26618
26703
|
}
|
|
26619
|
-
function
|
|
26620
|
-
let t = e.tree.map((e) =>
|
|
26704
|
+
function kn(e) {
|
|
26705
|
+
let t = e.tree.map((e) => kn(e));
|
|
26621
26706
|
return {
|
|
26622
26707
|
change: "target-only",
|
|
26623
26708
|
tagName: e.tagName,
|
|
@@ -26625,17 +26710,17 @@ function Tn(e) {
|
|
|
26625
26710
|
children: t
|
|
26626
26711
|
};
|
|
26627
26712
|
}
|
|
26628
|
-
function
|
|
26629
|
-
if (!
|
|
26713
|
+
function An(e, t) {
|
|
26714
|
+
if (!gn.has(e.tagName)) {
|
|
26630
26715
|
if (e.tagName === "Private") {
|
|
26631
|
-
for (let n of e.tree)
|
|
26716
|
+
for (let n of e.tree) An(n, t);
|
|
26632
26717
|
return;
|
|
26633
26718
|
}
|
|
26634
|
-
t.push(
|
|
26719
|
+
t.push(kn(e));
|
|
26635
26720
|
}
|
|
26636
26721
|
}
|
|
26637
|
-
async function
|
|
26638
|
-
let { targetQuery: n, sourceNode: r, instanceNode: i } = t, a =
|
|
26722
|
+
async function jn(e, t) {
|
|
26723
|
+
let { targetQuery: n, sourceNode: r, instanceNode: i } = t, a = hn(await e.any.getAttributes(r)), o = hn(await n.any.getAttributes(i)), s = [];
|
|
26639
26724
|
for (let e of new Set([...Object.keys(a), ...Object.keys(o)])) {
|
|
26640
26725
|
let t = o[e], n = a[e];
|
|
26641
26726
|
t !== n && s.push({
|
|
@@ -26646,25 +26731,26 @@ async function Dn(e, t) {
|
|
|
26646
26731
|
}
|
|
26647
26732
|
return s;
|
|
26648
26733
|
}
|
|
26649
|
-
async function
|
|
26650
|
-
let { node: n, index: r } = t,
|
|
26651
|
-
|
|
26652
|
-
for (let t of n.tree) await
|
|
26734
|
+
async function Mn(e, t) {
|
|
26735
|
+
let { node: n, index: r, matchKey: i } = t, a = await e.any.getAttribute(n, { name: i });
|
|
26736
|
+
a && r.set(a, n);
|
|
26737
|
+
for (let t of n.tree) await Mn(e, {
|
|
26653
26738
|
node: t,
|
|
26654
|
-
index: r
|
|
26739
|
+
index: r,
|
|
26740
|
+
matchKey: i
|
|
26655
26741
|
});
|
|
26656
26742
|
}
|
|
26657
|
-
async function
|
|
26743
|
+
async function Nn(e, t) {
|
|
26658
26744
|
let { node: n, out: r } = t, i = await e.any.getAttribute(n, { name: "uuid" });
|
|
26659
26745
|
i && r.add(i);
|
|
26660
|
-
for (let t of n.tree) await
|
|
26746
|
+
for (let t of n.tree) await Nn(e, {
|
|
26661
26747
|
node: t,
|
|
26662
26748
|
out: r
|
|
26663
26749
|
});
|
|
26664
26750
|
}
|
|
26665
|
-
function
|
|
26751
|
+
function Pn(e) {
|
|
26666
26752
|
let t = e.reduce((e, t) => {
|
|
26667
|
-
let n =
|
|
26753
|
+
let n = Fn(t.tree);
|
|
26668
26754
|
return {
|
|
26669
26755
|
added: e.added + n.added,
|
|
26670
26756
|
removed: e.removed + n.removed,
|
|
@@ -26681,10 +26767,10 @@ function An(e) {
|
|
|
26681
26767
|
summary: t
|
|
26682
26768
|
};
|
|
26683
26769
|
}
|
|
26684
|
-
function
|
|
26770
|
+
function U(e) {
|
|
26685
26771
|
return e.instances.flatMap((e) => e.groups);
|
|
26686
26772
|
}
|
|
26687
|
-
function
|
|
26773
|
+
function Fn(e) {
|
|
26688
26774
|
let t = {
|
|
26689
26775
|
added: 0,
|
|
26690
26776
|
removed: 0,
|
|
@@ -26697,58 +26783,58 @@ function jn(e) {
|
|
|
26697
26783
|
}
|
|
26698
26784
|
//#endregion
|
|
26699
26785
|
//#region src/v2019C1/extensions/lifecycle/constraints/classify-attribute.constants.ts
|
|
26700
|
-
var
|
|
26786
|
+
var In = new Set([
|
|
26701
26787
|
"uuid",
|
|
26702
26788
|
"templateUuid",
|
|
26703
26789
|
"originUuid"
|
|
26704
|
-
]),
|
|
26705
|
-
function
|
|
26706
|
-
let t =
|
|
26790
|
+
]), Ln = ["rename", "free"], Rn = /* @__PURE__ */ new Map();
|
|
26791
|
+
function zn(e) {
|
|
26792
|
+
let t = Rn.get(e);
|
|
26707
26793
|
if (t) return t;
|
|
26708
26794
|
let n = _[e]?.attributes?.identityFields ?? [], r = new Set(n);
|
|
26709
|
-
return
|
|
26795
|
+
return Rn.set(e, r), r;
|
|
26710
26796
|
}
|
|
26711
26797
|
//#endregion
|
|
26712
26798
|
//#region src/v2019C1/extensions/lifecycle/constraints/classify-attribute.ts
|
|
26713
|
-
function
|
|
26714
|
-
return
|
|
26799
|
+
function W(e, t) {
|
|
26800
|
+
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
26801
|
}
|
|
26716
|
-
function
|
|
26717
|
-
return
|
|
26802
|
+
function Bn(e) {
|
|
26803
|
+
return Ln.includes(e);
|
|
26718
26804
|
}
|
|
26719
|
-
function
|
|
26805
|
+
function Vn(e) {
|
|
26720
26806
|
let t = Object.keys(g[e] ?? {}), n = [];
|
|
26721
26807
|
for (let r of t) {
|
|
26722
|
-
let t =
|
|
26723
|
-
|
|
26808
|
+
let t = W(e, r);
|
|
26809
|
+
Bn(t) && n.push({
|
|
26724
26810
|
attr: r,
|
|
26725
26811
|
mode: t
|
|
26726
26812
|
});
|
|
26727
26813
|
}
|
|
26728
26814
|
return n;
|
|
26729
26815
|
}
|
|
26730
|
-
function
|
|
26731
|
-
let t =
|
|
26732
|
-
if (!t) return
|
|
26816
|
+
function Hn(e) {
|
|
26817
|
+
let t = D[e];
|
|
26818
|
+
if (!t) return Wn;
|
|
26733
26819
|
let n = /* @__PURE__ */ new Set();
|
|
26734
26820
|
for (let e of t) n.add(e.attribute.path), n.add(e.attribute.uuid);
|
|
26735
26821
|
return n;
|
|
26736
26822
|
}
|
|
26737
|
-
function
|
|
26738
|
-
let t =
|
|
26739
|
-
return t ? new Set(t) :
|
|
26823
|
+
function Un(e) {
|
|
26824
|
+
let t = F.get(e);
|
|
26825
|
+
return t ? new Set(t) : Wn;
|
|
26740
26826
|
}
|
|
26741
|
-
var
|
|
26827
|
+
var Wn = /* @__PURE__ */ new Set();
|
|
26742
26828
|
//#endregion
|
|
26743
26829
|
//#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 =
|
|
26830
|
+
async function G(e, t) {
|
|
26831
|
+
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
26832
|
if (o.length === 0) return null;
|
|
26747
26833
|
let s = (await e.any.getTree(n))?.tree ?? [];
|
|
26748
26834
|
for (let e of o) {
|
|
26749
|
-
let t =
|
|
26835
|
+
let t = Jn(e);
|
|
26750
26836
|
if (!(t.length === 0 || t.some((e) => i[e] === void 0))) {
|
|
26751
|
-
for (let n of s) if (n.id !== a &&
|
|
26837
|
+
for (let n of s) if (n.id !== a && qn(e, n.tagName) && t.every((e) => Gn(n, e) === i[e])) return {
|
|
26752
26838
|
constraint: e.name,
|
|
26753
26839
|
fields: t,
|
|
26754
26840
|
offendingId: n.id
|
|
@@ -26757,41 +26843,41 @@ async function K(e, t) {
|
|
|
26757
26843
|
}
|
|
26758
26844
|
return null;
|
|
26759
26845
|
}
|
|
26760
|
-
function
|
|
26846
|
+
function Gn(e, t) {
|
|
26761
26847
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
26762
26848
|
}
|
|
26763
|
-
function
|
|
26849
|
+
function Kn(e) {
|
|
26764
26850
|
return [..._[e]?.constraints ?? []];
|
|
26765
26851
|
}
|
|
26766
|
-
function
|
|
26852
|
+
function qn(e, t) {
|
|
26767
26853
|
for (let n of e.selector ?? []) {
|
|
26768
26854
|
let e = (n.steps ?? []).at(-1);
|
|
26769
26855
|
if (e && (e.kind === "wildcard" || e.kind === "name" && e.value === t)) return !0;
|
|
26770
26856
|
}
|
|
26771
26857
|
return !1;
|
|
26772
26858
|
}
|
|
26773
|
-
function
|
|
26859
|
+
function Jn(e) {
|
|
26774
26860
|
return (e.fields ?? []).map((e) => e.target?.value).filter((e) => !!e);
|
|
26775
26861
|
}
|
|
26776
26862
|
//#endregion
|
|
26777
26863
|
//#region src/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.ts
|
|
26778
|
-
var
|
|
26779
|
-
async function
|
|
26864
|
+
var Yn = 1e3;
|
|
26865
|
+
async function Xn(e, t) {
|
|
26780
26866
|
let { parentRef: n, childTag: r, candidate: i, attr: a, decorate: o, excludeId: s } = t, c = i[a] ?? "";
|
|
26781
|
-
if (!await
|
|
26867
|
+
if (!await G(e, {
|
|
26782
26868
|
parentRef: n,
|
|
26783
26869
|
childTag: r,
|
|
26784
26870
|
candidate: i,
|
|
26785
26871
|
excludeId: s
|
|
26786
26872
|
})) return c;
|
|
26787
|
-
for (let t = 1; t <=
|
|
26873
|
+
for (let t = 1; t <= Yn; t++) {
|
|
26788
26874
|
let l = o ? o({
|
|
26789
26875
|
base: c,
|
|
26790
26876
|
attempt: t,
|
|
26791
26877
|
attr: a,
|
|
26792
26878
|
childTag: r
|
|
26793
26879
|
}) : `${c}_${t}`;
|
|
26794
|
-
if (!await
|
|
26880
|
+
if (!await G(e, {
|
|
26795
26881
|
parentRef: n,
|
|
26796
26882
|
childTag: r,
|
|
26797
26883
|
candidate: {
|
|
@@ -26801,22 +26887,22 @@ async function Kn(e, t) {
|
|
|
26801
26887
|
excludeId: s
|
|
26802
26888
|
})) return l;
|
|
26803
26889
|
}
|
|
26804
|
-
throw Error(`could not resolve a unique ${a} for <${r}> under <${n.tagName}> after ${
|
|
26890
|
+
throw Error(`could not resolve a unique ${a} for <${r}> under <${n.tagName}> after ${Yn} attempts`);
|
|
26805
26891
|
}
|
|
26806
26892
|
//#endregion
|
|
26807
26893
|
//#region src/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.ts
|
|
26808
|
-
async function
|
|
26894
|
+
async function K(e, t) {
|
|
26809
26895
|
let { ref: n, decorate: r, overrides: i } = t, a = t.parentRef ?? (await e.getRecord(n))?.parent;
|
|
26810
26896
|
if (!a) return { status: "ok" };
|
|
26811
26897
|
let o = await e.getAttributes(n);
|
|
26812
26898
|
if (i) for (let [t, r] of Object.entries(i)) {
|
|
26813
|
-
let i =
|
|
26899
|
+
let i = W(n.tagName, t);
|
|
26814
26900
|
(i === "rename" || i === "free") && o[t] !== r && (await e.update(n, { attributes: { [t]: r } }), o = {
|
|
26815
26901
|
...o,
|
|
26816
26902
|
[t]: r
|
|
26817
26903
|
});
|
|
26818
26904
|
}
|
|
26819
|
-
let s = await
|
|
26905
|
+
let s = await G(e, {
|
|
26820
26906
|
parentRef: a,
|
|
26821
26907
|
childTag: n.tagName,
|
|
26822
26908
|
candidate: o,
|
|
@@ -26824,14 +26910,14 @@ async function qn(e, t) {
|
|
|
26824
26910
|
});
|
|
26825
26911
|
if (!s) return { status: "ok" };
|
|
26826
26912
|
let c = s.fields.find((e) => {
|
|
26827
|
-
let t =
|
|
26913
|
+
let t = W(n.tagName, e);
|
|
26828
26914
|
return t === "rename" || t === "free";
|
|
26829
26915
|
});
|
|
26830
26916
|
if (!c) return {
|
|
26831
26917
|
status: "unresolvable",
|
|
26832
26918
|
violation: s
|
|
26833
26919
|
};
|
|
26834
|
-
let l = o[c] ?? "", u = await
|
|
26920
|
+
let l = o[c] ?? "", u = await Xn(e, {
|
|
26835
26921
|
parentRef: a,
|
|
26836
26922
|
childTag: n.tagName,
|
|
26837
26923
|
candidate: o,
|
|
@@ -26848,12 +26934,12 @@ async function qn(e, t) {
|
|
|
26848
26934
|
}
|
|
26849
26935
|
//#endregion
|
|
26850
26936
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/clone-tree.ts
|
|
26851
|
-
var
|
|
26937
|
+
var Zn = {
|
|
26852
26938
|
scope: "tree",
|
|
26853
26939
|
attributes: ["templateUuid", "originUuid"]
|
|
26854
26940
|
};
|
|
26855
26941
|
async function q(e, t) {
|
|
26856
|
-
let { sourceQuery: n, ref: i, targetParent: a, omit: o, retagRoot: s, strip: c =
|
|
26942
|
+
let { sourceQuery: n, ref: i, targetParent: a, omit: o, retagRoot: s, strip: c = Zn } = t, l = await n.getTree(i, {
|
|
26857
26943
|
omit: o,
|
|
26858
26944
|
unwrap: []
|
|
26859
26945
|
});
|
|
@@ -26869,7 +26955,7 @@ async function q(e, t) {
|
|
|
26869
26955
|
}
|
|
26870
26956
|
//#endregion
|
|
26871
26957
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/add-children-to.ts
|
|
26872
|
-
async function
|
|
26958
|
+
async function Qn(e, t) {
|
|
26873
26959
|
let { sourceQuery: n, source: r, target: i, omit: a, strip: o } = t, s = await n.any.getRecord(r);
|
|
26874
26960
|
if (!s) return [];
|
|
26875
26961
|
let c = [];
|
|
@@ -26890,14 +26976,14 @@ async function Yn(e, t) {
|
|
|
26890
26976
|
}
|
|
26891
26977
|
//#endregion
|
|
26892
26978
|
//#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
|
|
26979
|
+
async function J(e, t) {
|
|
26980
|
+
let { sourceQuery: n, ref: r, targetParent: i, withTypes: a = !0, omit: o, strip: s = !1, retagRoot: c } = t, l = await $n(e, {
|
|
26895
26981
|
sourceQuery: n,
|
|
26896
26982
|
ref: r,
|
|
26897
26983
|
targetParent: i
|
|
26898
26984
|
}), u, d;
|
|
26899
26985
|
if (l) {
|
|
26900
|
-
d = await
|
|
26986
|
+
d = await Qn(e, {
|
|
26901
26987
|
sourceQuery: n,
|
|
26902
26988
|
source: r,
|
|
26903
26989
|
target: l,
|
|
@@ -26921,10 +27007,10 @@ async function Xn(e, t) {
|
|
|
26921
27007
|
}
|
|
26922
27008
|
let f = /* @__PURE__ */ new Map();
|
|
26923
27009
|
if (a) {
|
|
26924
|
-
let t = await
|
|
27010
|
+
let t = await er(n, r);
|
|
26925
27011
|
if (t.length > 0) {
|
|
26926
27012
|
let r = typeof a == "object" ? a.keepNameFrom : void 0;
|
|
26927
|
-
f = (await
|
|
27013
|
+
f = (await It(e, {
|
|
26928
27014
|
sourceQuery: n,
|
|
26929
27015
|
records: t,
|
|
26930
27016
|
cloneMappings: d,
|
|
@@ -26938,7 +27024,7 @@ async function Xn(e, t) {
|
|
|
26938
27024
|
recordMappings: d
|
|
26939
27025
|
};
|
|
26940
27026
|
}
|
|
26941
|
-
async function
|
|
27027
|
+
async function $n(e, t) {
|
|
26942
27028
|
let { sourceQuery: n, ref: r, targetParent: i } = t;
|
|
26943
27029
|
if (r.tagName !== "Private") return;
|
|
26944
27030
|
let a = (await n.any.getAttributes(r)).type;
|
|
@@ -26949,7 +27035,7 @@ async function Zn(e, t) {
|
|
|
26949
27035
|
id: t.id
|
|
26950
27036
|
};
|
|
26951
27037
|
}
|
|
26952
|
-
async function
|
|
27038
|
+
async function er(e, t) {
|
|
26953
27039
|
let { LNode: n = [], LN: r = [], LN0: i = [] } = await e.findDescendants(t, { collect: [
|
|
26954
27040
|
"LNode",
|
|
26955
27041
|
"LN",
|
|
@@ -26963,8 +27049,8 @@ async function Qn(e, t) {
|
|
|
26963
27049
|
}
|
|
26964
27050
|
//#endregion
|
|
26965
27051
|
//#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 =
|
|
27052
|
+
async function tr(e, t) {
|
|
27053
|
+
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
27054
|
for (let e of c) {
|
|
26969
27055
|
let t = e.attributes.find((e) => e.name === s)?.value;
|
|
26970
27056
|
t && l.add(t);
|
|
@@ -26987,8 +27073,8 @@ async function $n(e, t) {
|
|
|
26987
27073
|
}
|
|
26988
27074
|
return u;
|
|
26989
27075
|
}
|
|
26990
|
-
async function
|
|
26991
|
-
let { sourceQuery: n, scopeRef: r, refTagName: i, targetTagName: a, resolveTargetParent: o, alreadyCloned: s, omit: c } = t, l = await
|
|
27076
|
+
async function nr(e, t) {
|
|
27077
|
+
let { sourceQuery: n, scopeRef: r, refTagName: i, targetTagName: a, resolveTargetParent: o, alreadyCloned: s, omit: c } = t, l = await tr(e, {
|
|
26992
27078
|
sourceQuery: n,
|
|
26993
27079
|
scopeRef: r,
|
|
26994
27080
|
refTagName: i,
|
|
@@ -27006,9 +27092,9 @@ async function er(e, t) {
|
|
|
27006
27092
|
}
|
|
27007
27093
|
return u;
|
|
27008
27094
|
}
|
|
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
|
|
27095
|
+
async function rr(e, t) {
|
|
27096
|
+
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 = [];
|
|
27097
|
+
for (let t of l) for (let r of D[t]) for (let s of r.target) {
|
|
27012
27098
|
let r = await u(e, {
|
|
27013
27099
|
sourceQuery: n,
|
|
27014
27100
|
scopeRef: i,
|
|
@@ -27024,7 +27110,7 @@ async function tr(e, t) {
|
|
|
27024
27110
|
}
|
|
27025
27111
|
//#endregion
|
|
27026
27112
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/primitives/merge-children-into.ts
|
|
27027
|
-
async function
|
|
27113
|
+
async function ir(e, t) {
|
|
27028
27114
|
let { sourceQuery: n, source: r, target: i, strip: a } = t, o = await n.any.getRecord(r);
|
|
27029
27115
|
if (!o) return [];
|
|
27030
27116
|
let s = [];
|
|
@@ -27032,9 +27118,9 @@ async function nr(e, t) {
|
|
|
27032
27118
|
let r = {
|
|
27033
27119
|
tagName: t.tagName,
|
|
27034
27120
|
id: t.id
|
|
27035
|
-
}, o = await n.any.getAttribute(t, { name: "name" }), c = o ? await
|
|
27121
|
+
}, o = await n.any.getAttribute(t, { name: "name" }), c = o ? await ar(e, i, t.tagName, o) : void 0;
|
|
27036
27122
|
if (c) {
|
|
27037
|
-
s.push(...await
|
|
27123
|
+
s.push(...await ir(e, {
|
|
27038
27124
|
sourceQuery: n,
|
|
27039
27125
|
source: r,
|
|
27040
27126
|
target: c,
|
|
@@ -27052,7 +27138,7 @@ async function nr(e, t) {
|
|
|
27052
27138
|
}
|
|
27053
27139
|
return s;
|
|
27054
27140
|
}
|
|
27055
|
-
async function
|
|
27141
|
+
async function ar(e, t, n, r) {
|
|
27056
27142
|
let i = await e.any.getRecord(t);
|
|
27057
27143
|
if (i) {
|
|
27058
27144
|
for (let t of i.children) if (t.tagName === n && await e.any.getAttribute(t, { name: "name" }) === r) return {
|
|
@@ -27063,7 +27149,7 @@ async function rr(e, t, n, r) {
|
|
|
27063
27149
|
}
|
|
27064
27150
|
//#endregion
|
|
27065
27151
|
//#region src/v2019C1/extensions/lifecycle/transplant/transaction/resolve-structure-ref.ts
|
|
27066
|
-
async function
|
|
27152
|
+
async function Y(e, t, n) {
|
|
27067
27153
|
let r = (await e.findAncestors(t, { stopAtTagName: "Substation" })).find((e) => e.tagName in n);
|
|
27068
27154
|
s(r, {
|
|
27069
27155
|
key: "ELEMENT_NOT_FOUND",
|
|
@@ -27078,7 +27164,7 @@ async function J(e, t, n) {
|
|
|
27078
27164
|
id: i.id
|
|
27079
27165
|
};
|
|
27080
27166
|
}
|
|
27081
|
-
function
|
|
27167
|
+
function or(e) {
|
|
27082
27168
|
let { sourceQuery: t, structure: n, cloneIndex: r } = e;
|
|
27083
27169
|
return async function(e) {
|
|
27084
27170
|
let i = await t.findAncestors(e, { stopAtTagName: "Substation" });
|
|
@@ -27101,189 +27187,198 @@ function ir(e) {
|
|
|
27101
27187
|
}
|
|
27102
27188
|
//#endregion
|
|
27103
27189
|
//#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:
|
|
27190
|
+
async function sr(e, t) {
|
|
27191
|
+
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);
|
|
27192
|
+
if (!u || !d) return;
|
|
27193
|
+
let f = /* @__PURE__ */ new Map();
|
|
27194
|
+
await fr(e, {
|
|
27195
|
+
node: d,
|
|
27196
|
+
index: f,
|
|
27197
|
+
matchKey: c
|
|
27111
27198
|
});
|
|
27112
|
-
let
|
|
27113
|
-
await
|
|
27114
|
-
node:
|
|
27115
|
-
out:
|
|
27116
|
-
}), await
|
|
27199
|
+
let p = /* @__PURE__ */ new Set();
|
|
27200
|
+
await pr(n, {
|
|
27201
|
+
node: u,
|
|
27202
|
+
out: p
|
|
27203
|
+
}), await dr(e, {
|
|
27117
27204
|
sourceQuery: n,
|
|
27118
|
-
instanceRecord:
|
|
27119
|
-
sourceNode:
|
|
27205
|
+
instanceRecord: d,
|
|
27206
|
+
sourceNode: u,
|
|
27120
27207
|
accepted: a,
|
|
27121
27208
|
overrides: o
|
|
27122
|
-
}), await
|
|
27209
|
+
}), await cr(e, {
|
|
27123
27210
|
sourceQuery: n,
|
|
27124
|
-
sourceNode:
|
|
27125
|
-
instanceParent:
|
|
27126
|
-
index:
|
|
27211
|
+
sourceNode: u,
|
|
27212
|
+
instanceParent: d,
|
|
27213
|
+
index: f,
|
|
27127
27214
|
accepted: a,
|
|
27128
27215
|
overrides: o,
|
|
27129
|
-
keepNameTypesFrom: s
|
|
27130
|
-
|
|
27131
|
-
|
|
27132
|
-
|
|
27133
|
-
|
|
27216
|
+
keepNameTypesFrom: s,
|
|
27217
|
+
matchKey: c,
|
|
27218
|
+
identityMode: l
|
|
27219
|
+
}), await lr(e, {
|
|
27220
|
+
instanceNode: d,
|
|
27221
|
+
sourceUuids: p,
|
|
27222
|
+
accepted: a,
|
|
27223
|
+
matchKey: c
|
|
27134
27224
|
});
|
|
27135
27225
|
}
|
|
27136
|
-
async function
|
|
27137
|
-
let { sourceQuery: n, sourceNode: r, instanceParent: i, index: o, accepted: s, overrides: c, keepNameTypesFrom: l } = t,
|
|
27226
|
+
async function cr(e, t) {
|
|
27227
|
+
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
27228
|
for (let t of r.tree) {
|
|
27139
|
-
let r = await n.any.getAttribute(t, { name: "uuid" }),
|
|
27140
|
-
if (
|
|
27141
|
-
|
|
27229
|
+
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)));
|
|
27230
|
+
if (p) {
|
|
27231
|
+
f.add(p.id), await dr(e, {
|
|
27142
27232
|
sourceQuery: n,
|
|
27143
|
-
instanceRecord:
|
|
27233
|
+
instanceRecord: p,
|
|
27144
27234
|
sourceNode: t,
|
|
27145
27235
|
accepted: s,
|
|
27146
27236
|
overrides: c
|
|
27147
|
-
}), await
|
|
27237
|
+
}), await cr(e, {
|
|
27148
27238
|
sourceQuery: n,
|
|
27149
27239
|
sourceNode: t,
|
|
27150
|
-
instanceParent:
|
|
27240
|
+
instanceParent: p,
|
|
27151
27241
|
index: o,
|
|
27152
27242
|
accepted: s,
|
|
27153
27243
|
overrides: c,
|
|
27154
|
-
keepNameTypesFrom: l
|
|
27244
|
+
keepNameTypesFrom: l,
|
|
27245
|
+
matchKey: u,
|
|
27246
|
+
identityMode: d
|
|
27155
27247
|
});
|
|
27156
27248
|
continue;
|
|
27157
27249
|
}
|
|
27158
27250
|
if (s && !s.sourceIds.has(t.id)) continue;
|
|
27159
|
-
let { recordMappings:
|
|
27251
|
+
let { recordMappings: m } = await J(e, {
|
|
27160
27252
|
sourceQuery: n,
|
|
27161
27253
|
ref: a(t),
|
|
27162
27254
|
targetParent: a(i),
|
|
27163
27255
|
strip: !1,
|
|
27164
27256
|
withTypes: { keepNameFrom: l }
|
|
27165
27257
|
});
|
|
27166
|
-
await
|
|
27167
|
-
mappings:
|
|
27168
|
-
mode:
|
|
27169
|
-
});
|
|
27170
|
-
let
|
|
27171
|
-
|
|
27172
|
-
ref:
|
|
27258
|
+
await H(e, {
|
|
27259
|
+
mappings: m,
|
|
27260
|
+
mode: d
|
|
27261
|
+
}), d === "keep" && await on(e, { mappings: m });
|
|
27262
|
+
let h = m.find((e) => e.source.id === t.id);
|
|
27263
|
+
h && d !== "keep" && await K(e, {
|
|
27264
|
+
ref: h.target,
|
|
27173
27265
|
parentRef: a(i),
|
|
27174
27266
|
overrides: c?.get(t.id)
|
|
27175
27267
|
});
|
|
27176
27268
|
}
|
|
27177
|
-
for (let t of i.tree) if (!
|
|
27178
|
-
if (A.has(t.tagName) && !
|
|
27269
|
+
for (let t of i.tree) if (!f.has(t.id) && !await e.any.getAttribute(t, { name: "templateUuid" })) {
|
|
27270
|
+
if (A.has(t.tagName) && !O.has(t.tagName)) {
|
|
27179
27271
|
if (s && !s.instanceIds.has(t.id)) continue;
|
|
27180
27272
|
} else if (!s || !s.instanceIds.has(t.id)) continue;
|
|
27181
27273
|
await e.any.getRecord(t) && await e.any.delete(t);
|
|
27182
27274
|
}
|
|
27183
27275
|
}
|
|
27184
|
-
async function
|
|
27185
|
-
let { instanceNode: n, sourceUuids: r, accepted: i } = t,
|
|
27186
|
-
await
|
|
27276
|
+
async function lr(e, t) {
|
|
27277
|
+
let { instanceNode: n, sourceUuids: r, accepted: i, matchKey: a } = t, o = [];
|
|
27278
|
+
await ur(e, {
|
|
27187
27279
|
node: n,
|
|
27188
27280
|
sourceUuids: r,
|
|
27189
27281
|
accepted: i,
|
|
27190
|
-
|
|
27282
|
+
matchKey: a,
|
|
27283
|
+
out: o
|
|
27191
27284
|
});
|
|
27192
|
-
for (let t of
|
|
27285
|
+
for (let t of o) await e.any.getRecord(t) && await e.any.delete(t);
|
|
27193
27286
|
}
|
|
27194
|
-
async function
|
|
27195
|
-
let { node: n, sourceUuids: r, accepted: i,
|
|
27196
|
-
if (
|
|
27197
|
-
(!i || i.instanceIds.has(n.id)) &&
|
|
27287
|
+
async function ur(e, t) {
|
|
27288
|
+
let { node: n, sourceUuids: r, accepted: i, matchKey: a, out: o } = t, s = await e.any.getAttribute(n, { name: a });
|
|
27289
|
+
if (s && !r.has(s)) {
|
|
27290
|
+
(!i || i.instanceIds.has(n.id)) && o.push(n);
|
|
27198
27291
|
return;
|
|
27199
27292
|
}
|
|
27200
|
-
for (let t of n.tree) await
|
|
27293
|
+
for (let t of n.tree) await ur(e, {
|
|
27201
27294
|
node: t,
|
|
27202
27295
|
sourceUuids: r,
|
|
27203
27296
|
accepted: i,
|
|
27204
|
-
|
|
27297
|
+
matchKey: a,
|
|
27298
|
+
out: o
|
|
27205
27299
|
});
|
|
27206
27300
|
}
|
|
27207
|
-
async function
|
|
27301
|
+
async function dr(e, t) {
|
|
27208
27302
|
let { sourceQuery: n, instanceRecord: r, sourceNode: i, accepted: a, overrides: o } = t;
|
|
27209
27303
|
if (a && !a.sourceIds.has(i.id)) return;
|
|
27210
27304
|
let s = {
|
|
27211
|
-
...
|
|
27305
|
+
...hn(await n.any.getAttributes(i)),
|
|
27212
27306
|
...o?.get(i.id)
|
|
27213
|
-
}, c =
|
|
27307
|
+
}, c = hn(await e.any.getAttributes(r)), l = {};
|
|
27214
27308
|
for (let e of new Set([...Object.keys(s), ...Object.keys(c)])) {
|
|
27215
27309
|
let t = e in s ? s[e] : void 0;
|
|
27216
27310
|
c[e] !== t && (l[e] = t);
|
|
27217
27311
|
}
|
|
27218
|
-
if (r.tagName === "LNode" && Object.keys(l).some((e) =>
|
|
27312
|
+
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
27313
|
Object.keys(l).length > 0 && await e.any.update(r, { attributes: l });
|
|
27220
27314
|
}
|
|
27221
|
-
async function
|
|
27222
|
-
let { node: n, index: r } = t,
|
|
27223
|
-
|
|
27224
|
-
for (let t of n.tree) await
|
|
27315
|
+
async function fr(e, t) {
|
|
27316
|
+
let { node: n, index: r, matchKey: i } = t, a = await e.any.getAttribute(n, { name: i });
|
|
27317
|
+
a && r.set(a, n);
|
|
27318
|
+
for (let t of n.tree) await fr(e, {
|
|
27225
27319
|
node: t,
|
|
27226
|
-
index: r
|
|
27320
|
+
index: r,
|
|
27321
|
+
matchKey: i
|
|
27227
27322
|
});
|
|
27228
27323
|
}
|
|
27229
|
-
async function
|
|
27324
|
+
async function pr(e, t) {
|
|
27230
27325
|
let { node: n, out: r } = t, i = await e.any.getAttribute(n, { name: "uuid" });
|
|
27231
27326
|
i && r.add(i);
|
|
27232
|
-
for (let t of n.tree) await
|
|
27327
|
+
for (let t of n.tree) await pr(e, {
|
|
27233
27328
|
node: t,
|
|
27234
27329
|
out: r
|
|
27235
27330
|
});
|
|
27236
27331
|
}
|
|
27237
27332
|
//#endregion
|
|
27238
27333
|
//#region src/v2019C1/extensions/lifecycle/engine/decide.ts
|
|
27239
|
-
function
|
|
27334
|
+
function mr(e, t) {
|
|
27240
27335
|
return e?.instances.find((e) => e.rootRef?.id === t)?.groups ?? [];
|
|
27241
27336
|
}
|
|
27242
|
-
function
|
|
27337
|
+
function hr(e) {
|
|
27243
27338
|
return e === void 0 ? "accept" : typeof e == "string" ? e : e.action;
|
|
27244
27339
|
}
|
|
27245
|
-
function
|
|
27340
|
+
function gr(e) {
|
|
27246
27341
|
return typeof e == "object" ? e.values : void 0;
|
|
27247
27342
|
}
|
|
27248
|
-
function
|
|
27343
|
+
function _r(e) {
|
|
27249
27344
|
let t = e.decisions.get(e.group.id);
|
|
27250
|
-
return t === void 0 ? e.group.suggestedAction :
|
|
27345
|
+
return t === void 0 ? e.group.suggestedAction : hr(t);
|
|
27251
27346
|
}
|
|
27252
|
-
function
|
|
27253
|
-
return
|
|
27347
|
+
function vr(e) {
|
|
27348
|
+
return _r(e) !== "skip";
|
|
27254
27349
|
}
|
|
27255
|
-
function
|
|
27350
|
+
function yr(e) {
|
|
27256
27351
|
let { groups: t, decisions: n } = e, r = /* @__PURE__ */ new Map();
|
|
27257
27352
|
for (let e of t) {
|
|
27258
27353
|
let t = n.get(e.id);
|
|
27259
|
-
if (
|
|
27354
|
+
if (_r({
|
|
27260
27355
|
group: e,
|
|
27261
27356
|
decisions: n
|
|
27262
27357
|
}) === "skip") continue;
|
|
27263
|
-
let i =
|
|
27358
|
+
let i = gr(t), a = e.primary.sourceRef?.id;
|
|
27264
27359
|
i && a && r.set(a, i);
|
|
27265
27360
|
}
|
|
27266
27361
|
return r;
|
|
27267
27362
|
}
|
|
27268
|
-
function
|
|
27363
|
+
function br(e) {
|
|
27269
27364
|
let { groups: t, decisions: n } = e;
|
|
27270
|
-
for (let e of t) if (
|
|
27365
|
+
for (let e of t) if (vr({
|
|
27271
27366
|
group: e,
|
|
27272
27367
|
decisions: n
|
|
27273
|
-
})) for (let r of e.dependsOn) s(
|
|
27274
|
-
group:
|
|
27368
|
+
})) for (let r of e.dependsOn) s(vr({
|
|
27369
|
+
group: xr(t, r) ?? e,
|
|
27275
27370
|
decisions: n
|
|
27276
27371
|
}), { detail: `decision accepts group "${e.id}" but its dependency "${r}" is skipped` });
|
|
27277
27372
|
}
|
|
27278
|
-
function
|
|
27373
|
+
function xr(e, t) {
|
|
27279
27374
|
return e.find((e) => e.id === t);
|
|
27280
27375
|
}
|
|
27281
|
-
function
|
|
27376
|
+
function Sr(e) {
|
|
27282
27377
|
let { groups: t, decisions: n } = e, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
|
|
27283
|
-
for (let e of t) if (
|
|
27378
|
+
for (let e of t) if (vr({
|
|
27284
27379
|
group: e,
|
|
27285
27380
|
decisions: n
|
|
27286
|
-
})) for (let t of [e.primary, ...e.companions])
|
|
27381
|
+
})) for (let t of [e.primary, ...e.companions]) Cr({
|
|
27287
27382
|
node: t,
|
|
27288
27383
|
sourceIds: r,
|
|
27289
27384
|
instanceIds: i
|
|
@@ -27293,69 +27388,71 @@ function br(e) {
|
|
|
27293
27388
|
instanceIds: i
|
|
27294
27389
|
};
|
|
27295
27390
|
}
|
|
27296
|
-
function
|
|
27391
|
+
function Cr(e) {
|
|
27297
27392
|
let { node: t, sourceIds: n, instanceIds: r } = e;
|
|
27298
|
-
|
|
27393
|
+
wr({
|
|
27299
27394
|
node: t,
|
|
27300
27395
|
sourceIds: n,
|
|
27301
27396
|
instanceIds: r
|
|
27302
27397
|
});
|
|
27303
|
-
for (let e of t.children)
|
|
27398
|
+
for (let e of t.children) Cr({
|
|
27304
27399
|
node: e,
|
|
27305
27400
|
sourceIds: n,
|
|
27306
27401
|
instanceIds: r
|
|
27307
27402
|
});
|
|
27308
27403
|
}
|
|
27309
|
-
function
|
|
27404
|
+
function wr(e) {
|
|
27310
27405
|
let { node: t, sourceIds: n, instanceIds: r } = e;
|
|
27311
27406
|
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
27407
|
}
|
|
27313
27408
|
//#endregion
|
|
27314
27409
|
//#region src/v2019C1/extensions/lifecycle/instance/composed-functions.ts
|
|
27315
|
-
async function
|
|
27410
|
+
async function Tr(e, t) {
|
|
27316
27411
|
let n = /* @__PURE__ */ new Set(), r = await e.any.getTree(t);
|
|
27317
|
-
return r && await
|
|
27412
|
+
return r && await Er(e, r, n), n;
|
|
27318
27413
|
}
|
|
27319
|
-
async function
|
|
27414
|
+
async function Er(e, t, n) {
|
|
27320
27415
|
if (t.tagName === "FunctionRef") {
|
|
27321
27416
|
let r = await e.any.getAttribute(t, { name: "functionUuid" });
|
|
27322
27417
|
r && n.add(r);
|
|
27323
27418
|
}
|
|
27324
|
-
for (let r of t.tree) await
|
|
27419
|
+
for (let r of t.tree) await Er(e, r, n);
|
|
27325
27420
|
}
|
|
27326
27421
|
//#endregion
|
|
27327
27422
|
//#region src/v2019C1/extensions/lifecycle/instance/find-instance.ts
|
|
27328
|
-
async function
|
|
27329
|
-
let { targetParent: n, tagName: r, sourceUuid: i } = t;
|
|
27423
|
+
async function Dr(e, t) {
|
|
27424
|
+
let { targetParent: n, tagName: r, sourceUuid: i, matchKey: a = "templateUuid" } = t;
|
|
27330
27425
|
if (!i) return [];
|
|
27331
|
-
let
|
|
27332
|
-
if (!
|
|
27333
|
-
let
|
|
27334
|
-
return await
|
|
27335
|
-
node:
|
|
27426
|
+
let o = await e.any.getTree(n);
|
|
27427
|
+
if (!o) return [];
|
|
27428
|
+
let s = [];
|
|
27429
|
+
return await Or(e, {
|
|
27430
|
+
node: o,
|
|
27336
27431
|
tagName: r,
|
|
27337
27432
|
sourceUuid: i,
|
|
27338
|
-
|
|
27339
|
-
|
|
27433
|
+
matchKey: a,
|
|
27434
|
+
out: s
|
|
27435
|
+
}), s;
|
|
27340
27436
|
}
|
|
27341
|
-
async function
|
|
27342
|
-
let { node: n, tagName: r, sourceUuid: i,
|
|
27343
|
-
if (n.tagName === r && await e.any.getAttribute(n, { name:
|
|
27344
|
-
|
|
27437
|
+
async function Or(e, t) {
|
|
27438
|
+
let { node: n, tagName: r, sourceUuid: i, matchKey: a, out: o } = t;
|
|
27439
|
+
if (n.tagName === r && await e.any.getAttribute(n, { name: a }) === i) {
|
|
27440
|
+
o.push(n);
|
|
27345
27441
|
return;
|
|
27346
27442
|
}
|
|
27347
|
-
for (let t of n.tree) await
|
|
27443
|
+
for (let t of n.tree) await Or(e, {
|
|
27348
27444
|
node: t,
|
|
27349
27445
|
tagName: r,
|
|
27350
27446
|
sourceUuid: i,
|
|
27351
|
-
|
|
27447
|
+
matchKey: a,
|
|
27448
|
+
out: o
|
|
27352
27449
|
});
|
|
27353
27450
|
}
|
|
27354
|
-
async function
|
|
27355
|
-
let [n] = await
|
|
27451
|
+
async function kr(e, t) {
|
|
27452
|
+
let [n] = await X(e, t);
|
|
27356
27453
|
return n;
|
|
27357
27454
|
}
|
|
27358
|
-
async function
|
|
27455
|
+
async function X(e, t) {
|
|
27359
27456
|
let { tagName: n, sourceUuid: r, sourceName: i } = t, a = await e.any.getRecordsByTagName(n), o = [];
|
|
27360
27457
|
if (r) for (let t of a) await e.any.getAttribute(t, { name: "templateUuid" }) === r && o.push(t);
|
|
27361
27458
|
if (o.length > 0) return o;
|
|
@@ -27366,16 +27463,16 @@ async function Y(e, t) {
|
|
|
27366
27463
|
}
|
|
27367
27464
|
//#endregion
|
|
27368
27465
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/satellite-reconcile.ts
|
|
27369
|
-
async function
|
|
27466
|
+
async function Ar(e, t) {
|
|
27370
27467
|
let { sourceQuery: n, satelliteRefs: r, instanceSatelliteRefs: i, structure: a, accepted: o } = t;
|
|
27371
27468
|
for (let t of r) {
|
|
27372
|
-
let { uuid: r, name: i } = await n.any.getAttributes(t), s = await
|
|
27469
|
+
let { uuid: r, name: i } = await n.any.getAttributes(t), s = await kr(e, {
|
|
27373
27470
|
tagName: t.tagName,
|
|
27374
27471
|
sourceUuid: r,
|
|
27375
27472
|
sourceName: i
|
|
27376
27473
|
});
|
|
27377
27474
|
if (s) {
|
|
27378
|
-
await
|
|
27475
|
+
await sr(e, {
|
|
27379
27476
|
sourceQuery: n,
|
|
27380
27477
|
sourceRootRef: t,
|
|
27381
27478
|
instanceRootRef: s,
|
|
@@ -27387,10 +27484,10 @@ async function Or(e, t) {
|
|
|
27387
27484
|
let c = await q(e, {
|
|
27388
27485
|
sourceQuery: n,
|
|
27389
27486
|
ref: t,
|
|
27390
|
-
targetParent: await
|
|
27487
|
+
targetParent: await Y(n, t, a),
|
|
27391
27488
|
strip: !1
|
|
27392
27489
|
});
|
|
27393
|
-
c && await
|
|
27490
|
+
c && await H(e, {
|
|
27394
27491
|
mappings: c.mappings,
|
|
27395
27492
|
mode: "stamp-template"
|
|
27396
27493
|
});
|
|
@@ -27402,26 +27499,26 @@ async function Or(e, t) {
|
|
|
27402
27499
|
tagName: t.tagName,
|
|
27403
27500
|
attributes: { uuid: r }
|
|
27404
27501
|
});
|
|
27405
|
-
i || o && t.id && !o.instanceIds.has(t.id) || (await
|
|
27502
|
+
i || o && t.id && !o.instanceIds.has(t.id) || (await I(e, { target: t })).length > 0 || await e.delete(t);
|
|
27406
27503
|
}
|
|
27407
27504
|
}
|
|
27408
27505
|
//#endregion
|
|
27409
27506
|
//#region src/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.constants.ts
|
|
27410
|
-
var
|
|
27507
|
+
var jr = ["Variable", "BehaviorDescription"];
|
|
27411
27508
|
//#endregion
|
|
27412
27509
|
//#region src/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.ts
|
|
27413
|
-
async function
|
|
27510
|
+
async function Z(e, t) {
|
|
27414
27511
|
let { primaryRef: n } = t, r = await e.any.getTree(n);
|
|
27415
27512
|
if (!r) return [];
|
|
27416
27513
|
let i = /* @__PURE__ */ new Set(), o = [];
|
|
27417
|
-
|
|
27514
|
+
Mr({
|
|
27418
27515
|
node: r,
|
|
27419
27516
|
subtreeIds: i,
|
|
27420
27517
|
targets: o
|
|
27421
27518
|
});
|
|
27422
27519
|
let s = /* @__PURE__ */ new Set(), c = [];
|
|
27423
|
-
for (let t of o) for (let n of
|
|
27424
|
-
let r = await
|
|
27520
|
+
for (let t of o) for (let n of jr) {
|
|
27521
|
+
let r = await z.query.findRefsPointingTo(e, {
|
|
27425
27522
|
target: a(t),
|
|
27426
27523
|
containerTagName: n
|
|
27427
27524
|
});
|
|
@@ -27429,10 +27526,10 @@ async function X(e, t) {
|
|
|
27429
27526
|
}
|
|
27430
27527
|
return c;
|
|
27431
27528
|
}
|
|
27432
|
-
function
|
|
27529
|
+
function Mr(e) {
|
|
27433
27530
|
let { node: t, subtreeIds: n, targets: r } = e;
|
|
27434
27531
|
n.add(t.id), t.attributes.some((e) => e.name === "uuid") && r.push(t);
|
|
27435
|
-
for (let e of t.tree)
|
|
27532
|
+
for (let e of t.tree) Mr({
|
|
27436
27533
|
node: e,
|
|
27437
27534
|
subtreeIds: n,
|
|
27438
27535
|
targets: r
|
|
@@ -27440,19 +27537,19 @@ function Ar(e) {
|
|
|
27440
27537
|
}
|
|
27441
27538
|
//#endregion
|
|
27442
27539
|
//#region src/v2019C1/extensions/lifecycle/update/transaction/cross-cutting-satellites.ts
|
|
27443
|
-
async function
|
|
27540
|
+
async function Nr(e, t) {
|
|
27444
27541
|
let { sourceQuery: n, primaryRef: r, instancePrimaryRef: i, structure: a, accepted: o } = t;
|
|
27445
|
-
await
|
|
27542
|
+
await Ar(e, {
|
|
27446
27543
|
sourceQuery: n,
|
|
27447
|
-
satelliteRefs: await
|
|
27448
|
-
instanceSatelliteRefs: i ? await
|
|
27544
|
+
satelliteRefs: await Z(n, { primaryRef: r }),
|
|
27545
|
+
instanceSatelliteRefs: i ? await Z(e, { primaryRef: i }) : [],
|
|
27449
27546
|
structure: a,
|
|
27450
27547
|
accepted: o
|
|
27451
27548
|
});
|
|
27452
27549
|
}
|
|
27453
27550
|
//#endregion
|
|
27454
27551
|
//#region src/v2019C1/extensions/lifecycle/instantiate/transaction/resolve-target-structure.ts
|
|
27455
|
-
async function
|
|
27552
|
+
async function Q(e, t) {
|
|
27456
27553
|
let n = await e.getRecord(t);
|
|
27457
27554
|
s(n, {
|
|
27458
27555
|
key: "ELEMENT_NOT_FOUND",
|
|
@@ -27463,12 +27560,12 @@ async function Z(e, t) {
|
|
|
27463
27560
|
}
|
|
27464
27561
|
//#endregion
|
|
27465
27562
|
//#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
|
|
27563
|
+
async function Pr(e, t) {
|
|
27564
|
+
let { sourceQuery: n, primaryRef: r, structure: i, strip: a = !0 } = t, o = await Z(n, { primaryRef: r }), s = [];
|
|
27468
27565
|
for (let t of o) {
|
|
27469
|
-
let r = await
|
|
27566
|
+
let r = await Fr(e, n, t);
|
|
27470
27567
|
if (r) {
|
|
27471
|
-
let i = await
|
|
27568
|
+
let i = await ir(e, {
|
|
27472
27569
|
sourceQuery: n,
|
|
27473
27570
|
source: t,
|
|
27474
27571
|
target: r,
|
|
@@ -27480,14 +27577,14 @@ async function Mr(e, t) {
|
|
|
27480
27577
|
let o = await q(e, {
|
|
27481
27578
|
sourceQuery: n,
|
|
27482
27579
|
ref: t,
|
|
27483
|
-
targetParent: await
|
|
27580
|
+
targetParent: await Y(n, t, i),
|
|
27484
27581
|
...a ? {} : { strip: !1 }
|
|
27485
27582
|
});
|
|
27486
27583
|
o && s.push(...o.mappings);
|
|
27487
27584
|
}
|
|
27488
27585
|
return s;
|
|
27489
27586
|
}
|
|
27490
|
-
async function
|
|
27587
|
+
async function Fr(e, t, n) {
|
|
27491
27588
|
let r = await t.any.getRecord(n);
|
|
27492
27589
|
if (!r) return;
|
|
27493
27590
|
let i = await t.any.getAttribute(r, { name: "name" });
|
|
@@ -27503,8 +27600,8 @@ async function Nr(e, t, n) {
|
|
|
27503
27600
|
}
|
|
27504
27601
|
//#endregion
|
|
27505
27602
|
//#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
|
|
27603
|
+
async function Ir(e, t) {
|
|
27604
|
+
let { sourceQuery: n, functionRef: r, targetParentRef: i, omit: a, stripRootAttributes: o, keepNameTypesFrom: s } = t, { recordMappings: c } = await J(e, {
|
|
27508
27605
|
sourceQuery: n,
|
|
27509
27606
|
ref: r,
|
|
27510
27607
|
targetParent: i,
|
|
@@ -27521,15 +27618,15 @@ async function Pr(e, t) {
|
|
|
27521
27618
|
});
|
|
27522
27619
|
return c;
|
|
27523
27620
|
}
|
|
27524
|
-
async function
|
|
27525
|
-
let { sourceQuery: n, functionRef: r, structure: i, stripCategoriesUuid: a = !0 } = t, o = await
|
|
27621
|
+
async function Lr(e, t) {
|
|
27622
|
+
let { sourceQuery: n, functionRef: r, structure: i, stripCategoriesUuid: a = !0 } = t, o = await Rr(n, r), s = [];
|
|
27526
27623
|
for (let t of o) {
|
|
27527
27624
|
let r = {
|
|
27528
27625
|
tagName: "FunctionCategory",
|
|
27529
27626
|
id: t
|
|
27530
|
-
}, o = await
|
|
27627
|
+
}, o = await Br(e, n, t);
|
|
27531
27628
|
if (o) {
|
|
27532
|
-
let t = await
|
|
27629
|
+
let t = await ir(e, {
|
|
27533
27630
|
sourceQuery: n,
|
|
27534
27631
|
source: r,
|
|
27535
27632
|
target: o,
|
|
@@ -27541,25 +27638,25 @@ async function Fr(e, t) {
|
|
|
27541
27638
|
let c = await q(e, {
|
|
27542
27639
|
sourceQuery: n,
|
|
27543
27640
|
ref: r,
|
|
27544
|
-
targetParent: await
|
|
27641
|
+
targetParent: await Y(n, r, i),
|
|
27545
27642
|
...a ? {} : { strip: !1 }
|
|
27546
27643
|
});
|
|
27547
27644
|
c && s.push(...c.mappings);
|
|
27548
27645
|
}
|
|
27549
27646
|
return s;
|
|
27550
27647
|
}
|
|
27551
|
-
async function
|
|
27552
|
-
let n = await
|
|
27648
|
+
async function Rr(e, t) {
|
|
27649
|
+
let n = await zr(e, t), r = /* @__PURE__ */ new Set();
|
|
27553
27650
|
for (let { container: e } of n) e && r.add(e.id);
|
|
27554
27651
|
return r;
|
|
27555
27652
|
}
|
|
27556
|
-
async function
|
|
27557
|
-
let n = await
|
|
27653
|
+
async function zr(e, t) {
|
|
27654
|
+
let n = await z.query.findRefsPointingTo(e, {
|
|
27558
27655
|
target: t,
|
|
27559
27656
|
containerTagName: "FunctionCategory"
|
|
27560
27657
|
}), { SubFunction: r = [] } = await e.findDescendants(t, { collect: "SubFunction" });
|
|
27561
27658
|
for (let t of r) {
|
|
27562
|
-
let r = await
|
|
27659
|
+
let r = await z.query.findRefsPointingTo(e, {
|
|
27563
27660
|
target: {
|
|
27564
27661
|
tagName: "SubFunction",
|
|
27565
27662
|
id: t.id
|
|
@@ -27570,7 +27667,7 @@ async function Lr(e, t) {
|
|
|
27570
27667
|
}
|
|
27571
27668
|
return n;
|
|
27572
27669
|
}
|
|
27573
|
-
async function
|
|
27670
|
+
async function Br(e, t, n) {
|
|
27574
27671
|
let r = await t.getRecord({
|
|
27575
27672
|
tagName: "FunctionCategory",
|
|
27576
27673
|
id: n
|
|
@@ -27589,18 +27686,18 @@ async function Rr(e, t, n) {
|
|
|
27589
27686
|
}
|
|
27590
27687
|
//#endregion
|
|
27591
27688
|
//#region src/v2019C1/extensions/lifecycle/layers/function/satellites.constants.ts
|
|
27592
|
-
var
|
|
27689
|
+
var Vr = ["FunctionCategory"];
|
|
27593
27690
|
//#endregion
|
|
27594
27691
|
//#region src/v2019C1/extensions/lifecycle/layers/function/satellites.ts
|
|
27595
|
-
async function
|
|
27692
|
+
async function Hr(e, t) {
|
|
27596
27693
|
let { primaryRef: n } = t, r = [n], { SubFunction: i = [] } = await e.findDescendants(n, { collect: "SubFunction" });
|
|
27597
27694
|
for (let e of i) r.push({
|
|
27598
27695
|
tagName: "SubFunction",
|
|
27599
27696
|
id: e.id
|
|
27600
27697
|
});
|
|
27601
27698
|
let o = /* @__PURE__ */ new Set(), s = [];
|
|
27602
|
-
for (let t of r) for (let n of
|
|
27603
|
-
let r = await
|
|
27699
|
+
for (let t of r) for (let n of Vr) {
|
|
27700
|
+
let r = await z.query.findRefsPointingTo(e, {
|
|
27604
27701
|
target: t,
|
|
27605
27702
|
containerTagName: n
|
|
27606
27703
|
});
|
|
@@ -27610,8 +27707,8 @@ async function Br(e, t) {
|
|
|
27610
27707
|
}
|
|
27611
27708
|
//#endregion
|
|
27612
27709
|
//#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
|
|
27710
|
+
async function Ur(e, t) {
|
|
27711
|
+
let { sourceQuery: n, functionRef: r, targetParent: i, overrides: a, keepNameTypesFrom: o } = t, { recordMappings: s } = await J(e, {
|
|
27615
27712
|
sourceQuery: n,
|
|
27616
27713
|
ref: r,
|
|
27617
27714
|
targetParent: i,
|
|
@@ -27621,55 +27718,55 @@ async function Vr(e, t) {
|
|
|
27621
27718
|
to: "SubFunction"
|
|
27622
27719
|
} : void 0,
|
|
27623
27720
|
withTypes: { keepNameFrom: o }
|
|
27624
|
-
}), c = await
|
|
27721
|
+
}), c = await Q(e, i), l = await Lr(e, {
|
|
27625
27722
|
sourceQuery: n,
|
|
27626
27723
|
functionRef: r,
|
|
27627
27724
|
structure: c,
|
|
27628
27725
|
stripCategoriesUuid: !1
|
|
27629
|
-
}), u = await
|
|
27726
|
+
}), u = await Pr(e, {
|
|
27630
27727
|
sourceQuery: n,
|
|
27631
27728
|
primaryRef: r,
|
|
27632
27729
|
structure: c,
|
|
27633
27730
|
strip: !1
|
|
27634
|
-
})
|
|
27635
|
-
|
|
27636
|
-
|
|
27637
|
-
|
|
27638
|
-
|
|
27639
|
-
|
|
27640
|
-
|
|
27731
|
+
}), d = [
|
|
27732
|
+
...s,
|
|
27733
|
+
...l,
|
|
27734
|
+
...u
|
|
27735
|
+
];
|
|
27736
|
+
await R(e, { mappings: d }), await H(e, {
|
|
27737
|
+
mappings: d,
|
|
27641
27738
|
mode: "stamp-template"
|
|
27642
27739
|
});
|
|
27643
|
-
let
|
|
27644
|
-
if (!
|
|
27645
|
-
let
|
|
27646
|
-
return await
|
|
27647
|
-
ref:
|
|
27740
|
+
let f = s.find((e) => e.source.id === r.id);
|
|
27741
|
+
if (!f) throw Error(`instantiate.fsd: cloned root not found for ${r.tagName}#${r.id}`);
|
|
27742
|
+
let p = f.target;
|
|
27743
|
+
return await K(e, {
|
|
27744
|
+
ref: p,
|
|
27648
27745
|
parentRef: i,
|
|
27649
27746
|
overrides: a?.get(r.id)
|
|
27650
|
-
}), await
|
|
27747
|
+
}), await _t(e, {
|
|
27651
27748
|
sourceQuery: n,
|
|
27652
|
-
targetRoot:
|
|
27749
|
+
targetRoot: p,
|
|
27653
27750
|
fileType: "FSD"
|
|
27654
27751
|
}), {
|
|
27655
|
-
functionRef:
|
|
27752
|
+
functionRef: p,
|
|
27656
27753
|
recordMappings: s
|
|
27657
27754
|
};
|
|
27658
27755
|
}
|
|
27659
27756
|
//#endregion
|
|
27660
27757
|
//#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
|
|
27758
|
+
async function Wr(e, t) {
|
|
27759
|
+
let { sourceQuery: n, applicationRef: r, structure: i, omit: a, keepNameTypesFrom: o } = t, s = /* @__PURE__ */ new Map(), c = [], l = await tr(e, {
|
|
27663
27760
|
sourceQuery: n,
|
|
27664
27761
|
scopeRef: r,
|
|
27665
27762
|
refTagName: "FunctionRef",
|
|
27666
27763
|
targetTagName: "Function"
|
|
27667
27764
|
});
|
|
27668
27765
|
for (let t of l) {
|
|
27669
|
-
let r = await
|
|
27766
|
+
let r = await Ir(e, {
|
|
27670
27767
|
sourceQuery: n,
|
|
27671
27768
|
functionRef: t,
|
|
27672
|
-
targetParentRef: await
|
|
27769
|
+
targetParentRef: await Y(n, t, i),
|
|
27673
27770
|
omit: a,
|
|
27674
27771
|
keepNameTypesFrom: o
|
|
27675
27772
|
});
|
|
@@ -27677,7 +27774,7 @@ async function Hr(e, t) {
|
|
|
27677
27774
|
for (let e of r) e.source.id && s.set(e.source.id, e.target);
|
|
27678
27775
|
}
|
|
27679
27776
|
for (let t of l) {
|
|
27680
|
-
let r = await
|
|
27777
|
+
let r = await Lr(e, {
|
|
27681
27778
|
sourceQuery: n,
|
|
27682
27779
|
functionRef: t,
|
|
27683
27780
|
structure: i,
|
|
@@ -27685,16 +27782,16 @@ async function Hr(e, t) {
|
|
|
27685
27782
|
});
|
|
27686
27783
|
c.push(...r);
|
|
27687
27784
|
}
|
|
27688
|
-
let u = await
|
|
27785
|
+
let u = await Gr(e, {
|
|
27689
27786
|
sourceQuery: n,
|
|
27690
27787
|
applicationRef: r
|
|
27691
27788
|
});
|
|
27692
27789
|
for (let e of u) s.set(e.sourceId, e.existingRef);
|
|
27693
|
-
let d = new Set(["FunctionRef", "FunctionCategoryRef"]), f = await
|
|
27790
|
+
let d = new Set(["FunctionRef", "FunctionCategoryRef"]), f = await rr(e, {
|
|
27694
27791
|
sourceQuery: n,
|
|
27695
27792
|
scopeTagName: "Application",
|
|
27696
27793
|
scopeRef: r,
|
|
27697
|
-
resolveTargetParent:
|
|
27794
|
+
resolveTargetParent: or({
|
|
27698
27795
|
sourceQuery: n,
|
|
27699
27796
|
structure: i,
|
|
27700
27797
|
cloneIndex: s
|
|
@@ -27707,7 +27804,7 @@ async function Hr(e, t) {
|
|
|
27707
27804
|
let p = await q(e, {
|
|
27708
27805
|
sourceQuery: n,
|
|
27709
27806
|
ref: r,
|
|
27710
|
-
targetParent: await
|
|
27807
|
+
targetParent: await Y(n, r, i),
|
|
27711
27808
|
omit: a
|
|
27712
27809
|
});
|
|
27713
27810
|
p && c.push(...p.mappings);
|
|
@@ -27723,7 +27820,7 @@ async function Hr(e, t) {
|
|
|
27723
27820
|
}
|
|
27724
27821
|
return c;
|
|
27725
27822
|
}
|
|
27726
|
-
async function
|
|
27823
|
+
async function Gr(e, t) {
|
|
27727
27824
|
let { sourceQuery: n, applicationRef: r } = t, { AllocationRoleRef: i = [] } = await n.findDescendants(r, { collect: "AllocationRoleRef" }), a = [], o = /* @__PURE__ */ new Set();
|
|
27728
27825
|
for (let t of i) {
|
|
27729
27826
|
let r = t.attributes.find((e) => e.name === "allocationRoleUuid")?.value;
|
|
@@ -27747,7 +27844,7 @@ async function Ur(e, t) {
|
|
|
27747
27844
|
tagName: "AllocationRole",
|
|
27748
27845
|
id: c.id
|
|
27749
27846
|
};
|
|
27750
|
-
await
|
|
27847
|
+
await Qn(e, {
|
|
27751
27848
|
sourceQuery: n,
|
|
27752
27849
|
source: {
|
|
27753
27850
|
tagName: "AllocationRole",
|
|
@@ -27766,20 +27863,20 @@ async function Ur(e, t) {
|
|
|
27766
27863
|
}
|
|
27767
27864
|
//#endregion
|
|
27768
27865
|
//#region src/v2019C1/extensions/lifecycle/layers/application/satellites.constants.ts
|
|
27769
|
-
var
|
|
27866
|
+
var Kr = [{
|
|
27770
27867
|
refTag: "AllocationRoleRef",
|
|
27771
27868
|
uuidAttr: "allocationRoleUuid",
|
|
27772
27869
|
targetTag: "AllocationRole"
|
|
27773
27870
|
}];
|
|
27774
27871
|
//#endregion
|
|
27775
27872
|
//#region src/v2019C1/extensions/lifecycle/layers/application/satellites.ts
|
|
27776
|
-
async function
|
|
27873
|
+
async function qr(e, t) {
|
|
27777
27874
|
let { applicationRef: n } = t, r = await e.any.getTree(n);
|
|
27778
27875
|
if (!r) return [];
|
|
27779
27876
|
let i = /* @__PURE__ */ new Set(), o = [];
|
|
27780
|
-
for (let t of
|
|
27877
|
+
for (let t of Kr) {
|
|
27781
27878
|
let n = /* @__PURE__ */ new Set();
|
|
27782
|
-
await
|
|
27879
|
+
await Jr(e, {
|
|
27783
27880
|
node: r,
|
|
27784
27881
|
refTag: t.refTag,
|
|
27785
27882
|
uuidAttr: t.uuidAttr,
|
|
@@ -27795,13 +27892,13 @@ async function Gr(e, t) {
|
|
|
27795
27892
|
}
|
|
27796
27893
|
return o;
|
|
27797
27894
|
}
|
|
27798
|
-
async function
|
|
27895
|
+
async function Jr(e, t) {
|
|
27799
27896
|
let { node: n, refTag: r, uuidAttr: i, out: a } = t;
|
|
27800
27897
|
if (n.tagName === r) {
|
|
27801
27898
|
let t = await e.any.getAttribute(n, { name: i });
|
|
27802
27899
|
t && a.add(t);
|
|
27803
27900
|
}
|
|
27804
|
-
for (let t of n.tree) await
|
|
27901
|
+
for (let t of n.tree) await Jr(e, {
|
|
27805
27902
|
node: t,
|
|
27806
27903
|
refTag: r,
|
|
27807
27904
|
uuidAttr: i,
|
|
@@ -27810,62 +27907,62 @@ async function Kr(e, t) {
|
|
|
27810
27907
|
}
|
|
27811
27908
|
//#endregion
|
|
27812
27909
|
//#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
|
|
27910
|
+
async function Yr(e, t) {
|
|
27911
|
+
let { sourceQuery: n, applicationRef: r, targetParent: i, overrides: a, keepNameTypesFrom: o } = t, s = await Q(e, i), c = await tr(e, {
|
|
27815
27912
|
sourceQuery: n,
|
|
27816
27913
|
scopeRef: r,
|
|
27817
27914
|
refTagName: "FunctionRef",
|
|
27818
27915
|
targetTagName: "Function"
|
|
27819
|
-
}), l = await
|
|
27916
|
+
}), l = await Wr(e, {
|
|
27820
27917
|
sourceQuery: n,
|
|
27821
27918
|
applicationRef: r,
|
|
27822
27919
|
structure: s,
|
|
27823
27920
|
keepNameTypesFrom: o
|
|
27824
|
-
}), u = await
|
|
27921
|
+
}), u = await Pr(e, {
|
|
27825
27922
|
sourceQuery: n,
|
|
27826
27923
|
primaryRef: r,
|
|
27827
27924
|
structure: s,
|
|
27828
27925
|
strip: !1
|
|
27829
|
-
});
|
|
27830
|
-
await
|
|
27831
|
-
mappings:
|
|
27926
|
+
}), d = [...l, ...u];
|
|
27927
|
+
await R(e, { mappings: d }), await H(e, {
|
|
27928
|
+
mappings: d,
|
|
27832
27929
|
mode: "stamp-template"
|
|
27833
27930
|
});
|
|
27834
27931
|
for (let t of c) {
|
|
27835
27932
|
let r = l.find((e) => e.source.id === t.id);
|
|
27836
27933
|
if (!r) continue;
|
|
27837
|
-
let i = await
|
|
27838
|
-
await
|
|
27934
|
+
let i = await Y(n, t, s);
|
|
27935
|
+
await K(e, {
|
|
27839
27936
|
ref: r.target,
|
|
27840
27937
|
parentRef: i,
|
|
27841
27938
|
overrides: a?.get(t.id)
|
|
27842
27939
|
});
|
|
27843
27940
|
}
|
|
27844
|
-
let
|
|
27845
|
-
if (!
|
|
27846
|
-
let
|
|
27847
|
-
await
|
|
27848
|
-
ref:
|
|
27849
|
-
parentRef:
|
|
27941
|
+
let f = l.find((e) => e.source.id === r.id);
|
|
27942
|
+
if (!f) throw Error(`instantiate.asd: cloned Application not found for ${r.id}`);
|
|
27943
|
+
let p = await Y(n, r, s);
|
|
27944
|
+
await K(e, {
|
|
27945
|
+
ref: f.target,
|
|
27946
|
+
parentRef: p,
|
|
27850
27947
|
overrides: a?.get(r.id)
|
|
27851
|
-
}), await
|
|
27948
|
+
}), await _t(e, {
|
|
27852
27949
|
sourceQuery: n,
|
|
27853
|
-
targetRoot:
|
|
27950
|
+
targetRoot: f.target,
|
|
27854
27951
|
fileType: "ASD"
|
|
27855
27952
|
});
|
|
27856
|
-
let
|
|
27953
|
+
let m = c.map((e) => l.find((t) => t.source.id === e.id)?.target).filter((e) => !!e);
|
|
27857
27954
|
return {
|
|
27858
|
-
applicationRef:
|
|
27859
|
-
composedFunctionRefs:
|
|
27955
|
+
applicationRef: f.target,
|
|
27956
|
+
composedFunctionRefs: m,
|
|
27860
27957
|
recordMappings: l
|
|
27861
27958
|
};
|
|
27862
27959
|
}
|
|
27863
27960
|
//#endregion
|
|
27864
27961
|
//#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
|
|
27962
|
+
async function Xr(e, t) {
|
|
27963
|
+
let { sourceQuery: n, functionRef: r, instanceRef: i, targetParent: a, accepted: o } = t, s = await Hr(n, { primaryRef: r }), c = !1;
|
|
27867
27964
|
for (let t of s) {
|
|
27868
|
-
let { uuid: r, name: i } = await n.any.getAttributes(t), a = await
|
|
27965
|
+
let { uuid: r, name: i } = await n.any.getAttributes(t), a = await kr(e, {
|
|
27869
27966
|
tagName: t.tagName,
|
|
27870
27967
|
sourceUuid: r,
|
|
27871
27968
|
sourceName: i
|
|
@@ -27874,23 +27971,23 @@ async function Jr(e, t) {
|
|
|
27874
27971
|
c = !0;
|
|
27875
27972
|
continue;
|
|
27876
27973
|
}
|
|
27877
|
-
await
|
|
27974
|
+
await sr(e, {
|
|
27878
27975
|
sourceQuery: n,
|
|
27879
27976
|
sourceRootRef: t,
|
|
27880
27977
|
instanceRootRef: a,
|
|
27881
27978
|
accepted: o
|
|
27882
27979
|
});
|
|
27883
27980
|
}
|
|
27884
|
-
c && (!o || o.sourceIds.has(r.id)) && await
|
|
27885
|
-
mappings: await
|
|
27981
|
+
c && (!o || o.sourceIds.has(r.id)) && await H(e, {
|
|
27982
|
+
mappings: await Lr(e, {
|
|
27886
27983
|
sourceQuery: n,
|
|
27887
27984
|
functionRef: r,
|
|
27888
|
-
structure: await
|
|
27985
|
+
structure: await Q(e, a),
|
|
27889
27986
|
stripCategoriesUuid: !1
|
|
27890
27987
|
}),
|
|
27891
27988
|
mode: "stamp-template"
|
|
27892
27989
|
});
|
|
27893
|
-
let l = await
|
|
27990
|
+
let l = await Hr(e, { primaryRef: {
|
|
27894
27991
|
tagName: "Function",
|
|
27895
27992
|
id: i.id
|
|
27896
27993
|
} });
|
|
@@ -27901,27 +27998,36 @@ async function Jr(e, t) {
|
|
|
27901
27998
|
tagName: t.tagName,
|
|
27902
27999
|
attributes: { uuid: r }
|
|
27903
28000
|
});
|
|
27904
|
-
i || o && t.id && !o.instanceIds.has(t.id) || (await
|
|
28001
|
+
i || o && t.id && !o.instanceIds.has(t.id) || (await I(e, { target: t })).length > 0 || await e.delete(t);
|
|
27905
28002
|
}
|
|
27906
28003
|
}
|
|
27907
28004
|
//#endregion
|
|
28005
|
+
//#region src/v2019C1/extensions/lifecycle/scenario.ts
|
|
28006
|
+
function Zr(e) {
|
|
28007
|
+
return e === "fork" ? "uuid" : "templateUuid";
|
|
28008
|
+
}
|
|
28009
|
+
function Qr(e) {
|
|
28010
|
+
return e === "fork" ? "keep" : "stamp-template";
|
|
28011
|
+
}
|
|
28012
|
+
//#endregion
|
|
27908
28013
|
//#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
|
|
28014
|
+
async function $r(e, t) {
|
|
28015
|
+
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
28016
|
targetParent: i,
|
|
27912
28017
|
tagName: "Function",
|
|
27913
|
-
sourceUuid: l
|
|
27914
|
-
|
|
27915
|
-
|
|
27916
|
-
|
|
27917
|
-
|
|
28018
|
+
sourceUuid: l,
|
|
28019
|
+
matchKey: u
|
|
28020
|
+
}), p = o ? U(o) : [];
|
|
28021
|
+
if (f.length === 0) {
|
|
28022
|
+
let t = s ? Sr({
|
|
28023
|
+
groups: p,
|
|
27918
28024
|
decisions: s
|
|
27919
|
-
}) : void 0, a = s ?
|
|
27920
|
-
groups:
|
|
28025
|
+
}) : void 0, a = s ? yr({
|
|
28026
|
+
groups: p,
|
|
27921
28027
|
decisions: s
|
|
27922
28028
|
}) : void 0;
|
|
27923
28029
|
if (t && !t.sourceIds.has(r.id)) return [];
|
|
27924
|
-
let { functionRef: o } = await
|
|
28030
|
+
let { functionRef: o } = await Ur(e, {
|
|
27925
28031
|
sourceQuery: n,
|
|
27926
28032
|
functionRef: r,
|
|
27927
28033
|
targetParent: i,
|
|
@@ -27930,49 +28036,51 @@ async function Yr(e, t) {
|
|
|
27930
28036
|
});
|
|
27931
28037
|
return [o];
|
|
27932
28038
|
}
|
|
27933
|
-
let
|
|
27934
|
-
for (let t of
|
|
27935
|
-
let { instanceAccepted: a, instanceOverrides: l } =
|
|
27936
|
-
instanceGroups:
|
|
28039
|
+
let m = await Q(e, i);
|
|
28040
|
+
for (let t of f) {
|
|
28041
|
+
let { instanceAccepted: a, instanceOverrides: l } = ei({
|
|
28042
|
+
instanceGroups: mr(o, t.id),
|
|
27937
28043
|
decisions: s
|
|
27938
28044
|
});
|
|
27939
|
-
await
|
|
28045
|
+
await sr(e, {
|
|
27940
28046
|
sourceQuery: n,
|
|
27941
28047
|
sourceRootRef: r,
|
|
27942
28048
|
instanceRootRef: t,
|
|
27943
28049
|
accepted: a,
|
|
27944
28050
|
overrides: l,
|
|
27945
|
-
keepNameTypesFrom: c
|
|
27946
|
-
|
|
28051
|
+
keepNameTypesFrom: c,
|
|
28052
|
+
matchKey: u,
|
|
28053
|
+
identityMode: d
|
|
28054
|
+
}), await Xr(e, {
|
|
27947
28055
|
sourceQuery: n,
|
|
27948
28056
|
functionRef: r,
|
|
27949
28057
|
instanceRef: t,
|
|
27950
28058
|
targetParent: i,
|
|
27951
28059
|
accepted: a
|
|
27952
|
-
}), await
|
|
28060
|
+
}), await Nr(e, {
|
|
27953
28061
|
sourceQuery: n,
|
|
27954
28062
|
primaryRef: r,
|
|
27955
28063
|
instancePrimaryRef: {
|
|
27956
28064
|
tagName: "Function",
|
|
27957
28065
|
id: t.id
|
|
27958
28066
|
},
|
|
27959
|
-
structure:
|
|
28067
|
+
structure: m,
|
|
27960
28068
|
accepted: a
|
|
27961
28069
|
});
|
|
27962
28070
|
}
|
|
27963
|
-
return
|
|
28071
|
+
return f.map((e) => ({
|
|
27964
28072
|
tagName: "Function",
|
|
27965
28073
|
id: e.id
|
|
27966
28074
|
}));
|
|
27967
28075
|
}
|
|
27968
|
-
function
|
|
28076
|
+
function ei(e) {
|
|
27969
28077
|
let { instanceGroups: t, decisions: n } = e;
|
|
27970
28078
|
return n ? {
|
|
27971
|
-
instanceAccepted:
|
|
28079
|
+
instanceAccepted: Sr({
|
|
27972
28080
|
groups: t,
|
|
27973
28081
|
decisions: n
|
|
27974
28082
|
}),
|
|
27975
|
-
instanceOverrides:
|
|
28083
|
+
instanceOverrides: yr({
|
|
27976
28084
|
groups: t,
|
|
27977
28085
|
decisions: n
|
|
27978
28086
|
})
|
|
@@ -27983,16 +28091,16 @@ function Xr(e) {
|
|
|
27983
28091
|
}
|
|
27984
28092
|
//#endregion
|
|
27985
28093
|
//#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
|
|
28094
|
+
async function ti(e, t) {
|
|
28095
|
+
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
28096
|
tagName: "Application",
|
|
27989
28097
|
sourceUuid: l
|
|
27990
|
-
}), d = o ?
|
|
28098
|
+
}), d = o ? U(o) : [];
|
|
27991
28099
|
if (u.length === 0) {
|
|
27992
|
-
let t = s ?
|
|
28100
|
+
let t = s ? Sr({
|
|
27993
28101
|
groups: d,
|
|
27994
28102
|
decisions: s
|
|
27995
|
-
}) : void 0, a = s ?
|
|
28103
|
+
}) : void 0, a = s ? yr({
|
|
27996
28104
|
groups: d,
|
|
27997
28105
|
decisions: s
|
|
27998
28106
|
}) : void 0;
|
|
@@ -28000,7 +28108,7 @@ async function Zr(e, t) {
|
|
|
28000
28108
|
applications: [],
|
|
28001
28109
|
functions: []
|
|
28002
28110
|
};
|
|
28003
|
-
let { applicationRef: o, composedFunctionRefs: l } = await
|
|
28111
|
+
let { applicationRef: o, composedFunctionRefs: l } = await Yr(e, {
|
|
28004
28112
|
sourceQuery: n,
|
|
28005
28113
|
applicationRef: r,
|
|
28006
28114
|
targetParent: i,
|
|
@@ -28012,12 +28120,12 @@ async function Zr(e, t) {
|
|
|
28012
28120
|
functions: l
|
|
28013
28121
|
};
|
|
28014
28122
|
}
|
|
28015
|
-
let f = await
|
|
28123
|
+
let f = await Q(e, i), p = await qr(n, { applicationRef: r }), m = [];
|
|
28016
28124
|
for (let t of u) {
|
|
28017
|
-
let i =
|
|
28125
|
+
let i = mr(o, t.id), a = s ? Sr({
|
|
28018
28126
|
groups: i,
|
|
28019
28127
|
decisions: s
|
|
28020
|
-
}) : void 0, l = s ?
|
|
28128
|
+
}) : void 0, l = s ? yr({
|
|
28021
28129
|
groups: i,
|
|
28022
28130
|
decisions: s
|
|
28023
28131
|
}) : void 0;
|
|
@@ -28025,24 +28133,24 @@ async function Zr(e, t) {
|
|
|
28025
28133
|
tagName: "Application",
|
|
28026
28134
|
id: t.id
|
|
28027
28135
|
});
|
|
28028
|
-
let u = await
|
|
28136
|
+
let u = await qr(e, { applicationRef: {
|
|
28029
28137
|
tagName: "Application",
|
|
28030
28138
|
id: t.id
|
|
28031
28139
|
} });
|
|
28032
|
-
await
|
|
28140
|
+
await sr(e, {
|
|
28033
28141
|
sourceQuery: n,
|
|
28034
28142
|
sourceRootRef: r,
|
|
28035
28143
|
instanceRootRef: t,
|
|
28036
28144
|
accepted: a,
|
|
28037
28145
|
overrides: l,
|
|
28038
28146
|
keepNameTypesFrom: c
|
|
28039
|
-
}), await
|
|
28147
|
+
}), await Ar(e, {
|
|
28040
28148
|
sourceQuery: n,
|
|
28041
28149
|
satelliteRefs: p,
|
|
28042
28150
|
instanceSatelliteRefs: u,
|
|
28043
28151
|
structure: f,
|
|
28044
28152
|
accepted: a
|
|
28045
|
-
}), await
|
|
28153
|
+
}), await Nr(e, {
|
|
28046
28154
|
sourceQuery: n,
|
|
28047
28155
|
primaryRef: r,
|
|
28048
28156
|
instancePrimaryRef: {
|
|
@@ -28055,7 +28163,7 @@ async function Zr(e, t) {
|
|
|
28055
28163
|
}
|
|
28056
28164
|
return {
|
|
28057
28165
|
applications: m,
|
|
28058
|
-
functions: await
|
|
28166
|
+
functions: await ni(e, {
|
|
28059
28167
|
sourceQuery: n,
|
|
28060
28168
|
applicationRef: r,
|
|
28061
28169
|
targetParent: i,
|
|
@@ -28066,10 +28174,10 @@ async function Zr(e, t) {
|
|
|
28066
28174
|
})
|
|
28067
28175
|
};
|
|
28068
28176
|
}
|
|
28069
|
-
async function
|
|
28070
|
-
let { sourceQuery: n, applicationRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, l = await
|
|
28177
|
+
async function ni(e, t) {
|
|
28178
|
+
let { sourceQuery: n, applicationRef: r, targetParent: i, scenario: a, report: o, decisions: s, keepNameTypesFrom: c } = t, l = await Tr(n, r);
|
|
28071
28179
|
if (l.size === 0) return [];
|
|
28072
|
-
let u = await
|
|
28180
|
+
let u = await Q(e, i), d = [];
|
|
28073
28181
|
for (let t of l) {
|
|
28074
28182
|
let [r] = await n.any.findByAttributes({
|
|
28075
28183
|
tagName: "Function",
|
|
@@ -28079,10 +28187,10 @@ async function Qr(e, t) {
|
|
|
28079
28187
|
let i = {
|
|
28080
28188
|
tagName: "Function",
|
|
28081
28189
|
id: r.id
|
|
28082
|
-
}, l = await
|
|
28190
|
+
}, l = await $r(e, {
|
|
28083
28191
|
sourceQuery: n,
|
|
28084
28192
|
functionRef: i,
|
|
28085
|
-
targetParent: await
|
|
28193
|
+
targetParent: await Y(n, i, u),
|
|
28086
28194
|
scenario: a,
|
|
28087
28195
|
report: o,
|
|
28088
28196
|
decisions: s,
|
|
@@ -28094,29 +28202,29 @@ async function Qr(e, t) {
|
|
|
28094
28202
|
}
|
|
28095
28203
|
//#endregion
|
|
28096
28204
|
//#region src/v2019C1/extensions/lifecycle/update/index.ts
|
|
28097
|
-
var
|
|
28098
|
-
asd: () =>
|
|
28099
|
-
fsd: () =>
|
|
28205
|
+
var ri = /* @__PURE__ */ l({
|
|
28206
|
+
asd: () => ti,
|
|
28207
|
+
fsd: () => $r
|
|
28100
28208
|
});
|
|
28101
28209
|
//#endregion
|
|
28102
28210
|
//#region src/v2019C1/extensions/lifecycle/apply/apply.ts
|
|
28103
|
-
async function
|
|
28211
|
+
async function ii(e, t) {
|
|
28104
28212
|
let { report: n, decisions: r } = t;
|
|
28105
|
-
return r ? (
|
|
28106
|
-
groups:
|
|
28213
|
+
return r ? (br({
|
|
28214
|
+
groups: U(n),
|
|
28107
28215
|
decisions: r
|
|
28108
28216
|
}), {
|
|
28109
28217
|
report: n,
|
|
28110
|
-
instances: await
|
|
28218
|
+
instances: await oi(e, t, n, r)
|
|
28111
28219
|
}) : n.needsDecisions ? {
|
|
28112
28220
|
report: n,
|
|
28113
|
-
instances:
|
|
28221
|
+
instances: ai(t.verb)
|
|
28114
28222
|
} : {
|
|
28115
28223
|
report: n,
|
|
28116
|
-
instances: await
|
|
28224
|
+
instances: await oi(e, t, n, void 0)
|
|
28117
28225
|
};
|
|
28118
28226
|
}
|
|
28119
|
-
function
|
|
28227
|
+
function ai(e) {
|
|
28120
28228
|
return e === "fsd" ? {
|
|
28121
28229
|
verb: "fsd",
|
|
28122
28230
|
functions: []
|
|
@@ -28126,10 +28234,10 @@ function ti(e) {
|
|
|
28126
28234
|
functions: []
|
|
28127
28235
|
};
|
|
28128
28236
|
}
|
|
28129
|
-
async function
|
|
28237
|
+
async function oi(e, t, n, r) {
|
|
28130
28238
|
if (t.verb === "fsd") return {
|
|
28131
28239
|
verb: "fsd",
|
|
28132
|
-
functions: await
|
|
28240
|
+
functions: await $r(e, {
|
|
28133
28241
|
sourceQuery: t.sourceQuery,
|
|
28134
28242
|
functionRef: t.ref,
|
|
28135
28243
|
targetParent: t.anchor,
|
|
@@ -28139,7 +28247,7 @@ async function ni(e, t, n, r) {
|
|
|
28139
28247
|
keepNameTypesFrom: t.keepNameTypesFrom
|
|
28140
28248
|
})
|
|
28141
28249
|
};
|
|
28142
|
-
let { applications: i, functions: a } = await
|
|
28250
|
+
let { applications: i, functions: a } = await ti(e, {
|
|
28143
28251
|
sourceQuery: t.sourceQuery,
|
|
28144
28252
|
applicationRef: t.ref,
|
|
28145
28253
|
targetParent: t.anchor,
|
|
@@ -28156,7 +28264,7 @@ async function ni(e, t, n, r) {
|
|
|
28156
28264
|
}
|
|
28157
28265
|
//#endregion
|
|
28158
28266
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/ensure-substation-structure.ts
|
|
28159
|
-
async function
|
|
28267
|
+
async function si(e) {
|
|
28160
28268
|
let t = await e.getRoot(), n = await e.ensureChild(t, {
|
|
28161
28269
|
tagName: "Substation",
|
|
28162
28270
|
attributes: { name: "TEMPLATE" }
|
|
@@ -28175,12 +28283,12 @@ async function ri(e) {
|
|
|
28175
28283
|
}
|
|
28176
28284
|
//#endregion
|
|
28177
28285
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/post-extraction-cleanup.ts
|
|
28178
|
-
async function
|
|
28179
|
-
await
|
|
28286
|
+
async function ci(e) {
|
|
28287
|
+
await xt.transaction.orphanUuidRefs(e), await xt.transaction.resetLNode(e), await xt.transaction.pruneEmptyContainers(e);
|
|
28180
28288
|
}
|
|
28181
28289
|
//#endregion
|
|
28182
28290
|
//#region src/v2019C1/extensions/lifecycle/layers/omit-filters.ts
|
|
28183
|
-
var
|
|
28291
|
+
var li = [
|
|
28184
28292
|
"FunctionSclRef",
|
|
28185
28293
|
"ApplicationSclRef",
|
|
28186
28294
|
"GeneralEquipment",
|
|
@@ -28188,9 +28296,9 @@ var ai = [
|
|
|
28188
28296
|
];
|
|
28189
28297
|
//#endregion
|
|
28190
28298
|
//#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
|
|
28299
|
+
async function ui(e, t) {
|
|
28300
|
+
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";
|
|
28301
|
+
await en.transaction.addEntry(e, {
|
|
28194
28302
|
filename: `ASD_${c.replace(/\s+/g, "_")}`,
|
|
28195
28303
|
header: {
|
|
28196
28304
|
fileType: "ASD",
|
|
@@ -28203,17 +28311,17 @@ async function oi(e, t) {
|
|
|
28203
28311
|
what: "ASD initialization",
|
|
28204
28312
|
why: "Application was extracted from a previous file"
|
|
28205
28313
|
}
|
|
28206
|
-
}), await
|
|
28314
|
+
}), await R(e, { mappings: await Wr(e, {
|
|
28207
28315
|
sourceQuery: n,
|
|
28208
28316
|
applicationRef: r,
|
|
28209
28317
|
structure: s,
|
|
28210
|
-
omit:
|
|
28211
|
-
}), await
|
|
28318
|
+
omit: li
|
|
28319
|
+
}) }), await ci(e);
|
|
28212
28320
|
}
|
|
28213
28321
|
//#endregion
|
|
28214
28322
|
//#region src/v2019C1/extensions/lifecycle/extract/transaction/omit.ts
|
|
28215
|
-
var
|
|
28216
|
-
...
|
|
28323
|
+
var di = [
|
|
28324
|
+
...li,
|
|
28217
28325
|
"DOS",
|
|
28218
28326
|
"Labels",
|
|
28219
28327
|
"LNodeInputs",
|
|
@@ -28225,12 +28333,12 @@ var si = [
|
|
|
28225
28333
|
];
|
|
28226
28334
|
//#endregion
|
|
28227
28335
|
//#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
|
|
28336
|
+
async function fi(e, t) {
|
|
28337
|
+
let { sourceQuery: n, functionRef: r, tool: i, who: a, nameStructure: o } = t, s = await si(e), c = {
|
|
28230
28338
|
tagName: s.Substation.tagName,
|
|
28231
28339
|
id: s.Substation.id
|
|
28232
28340
|
}, l = await n.getAttribute(r, { name: "name" }) || "Unnamed Function";
|
|
28233
|
-
await
|
|
28341
|
+
await en.transaction.addEntry(e, {
|
|
28234
28342
|
filename: `FSD_${l.replace(/\s+/g, "_")}`,
|
|
28235
28343
|
header: {
|
|
28236
28344
|
fileType: "FSD",
|
|
@@ -28243,39 +28351,41 @@ async function ci(e, t) {
|
|
|
28243
28351
|
what: "FSD initialization",
|
|
28244
28352
|
why: "Function was extracted from a previous file"
|
|
28245
28353
|
}
|
|
28246
|
-
})
|
|
28354
|
+
});
|
|
28355
|
+
let u = await Ir(e, {
|
|
28247
28356
|
sourceQuery: n,
|
|
28248
28357
|
functionRef: r,
|
|
28249
28358
|
targetParentRef: c,
|
|
28250
|
-
omit:
|
|
28359
|
+
omit: di,
|
|
28251
28360
|
stripRootAttributes: ["templateUuid"]
|
|
28252
|
-
}), await
|
|
28361
|
+
}), d = await Lr(e, {
|
|
28253
28362
|
sourceQuery: n,
|
|
28254
28363
|
functionRef: r,
|
|
28255
28364
|
structure: s
|
|
28256
|
-
})
|
|
28365
|
+
});
|
|
28366
|
+
await R(e, { mappings: [...u, ...d] }), await ci(e);
|
|
28257
28367
|
}
|
|
28258
28368
|
//#endregion
|
|
28259
28369
|
//#region src/v2019C1/extensions/lifecycle/extract/index.ts
|
|
28260
|
-
var
|
|
28261
|
-
asd: () =>
|
|
28262
|
-
ensureSubstationTemplateStructure: () =>
|
|
28263
|
-
fsd: () =>
|
|
28264
|
-
}),
|
|
28265
|
-
asd: () =>
|
|
28266
|
-
fsd: () =>
|
|
28267
|
-
resolveTargetStructure: () =>
|
|
28370
|
+
var pi = /* @__PURE__ */ l({
|
|
28371
|
+
asd: () => ui,
|
|
28372
|
+
ensureSubstationTemplateStructure: () => si,
|
|
28373
|
+
fsd: () => fi
|
|
28374
|
+
}), mi = /* @__PURE__ */ l({
|
|
28375
|
+
asd: () => Yr,
|
|
28376
|
+
fsd: () => Ur,
|
|
28377
|
+
resolveTargetStructure: () => Q
|
|
28268
28378
|
});
|
|
28269
28379
|
//#endregion
|
|
28270
28380
|
//#region src/v2019C1/extensions/lifecycle/report/mark-placement-conflicts.ts
|
|
28271
|
-
async function
|
|
28272
|
-
if (t.scenario === "instantiate") for (let r of
|
|
28381
|
+
async function hi(e, t, n) {
|
|
28382
|
+
if (t.scenario === "instantiate") for (let r of U(n)) {
|
|
28273
28383
|
if (r.change !== "added") continue;
|
|
28274
28384
|
let i = r.primary.sourceRef;
|
|
28275
28385
|
if (!i) continue;
|
|
28276
28386
|
let a = await t.sourceQuery.getAttributes(i), o = a.uuid;
|
|
28277
28387
|
if (!o) continue;
|
|
28278
|
-
let s = r.primary.tagName, [c] = await
|
|
28388
|
+
let s = r.primary.tagName, [c] = await X(e, {
|
|
28279
28389
|
tagName: s,
|
|
28280
28390
|
sourceUuid: o
|
|
28281
28391
|
});
|
|
@@ -28288,7 +28398,7 @@ async function di(e, t, n) {
|
|
|
28288
28398
|
let n = {
|
|
28289
28399
|
tagName: t.tagName,
|
|
28290
28400
|
id: t.id
|
|
28291
|
-
}, r = await
|
|
28401
|
+
}, r = await G(e, {
|
|
28292
28402
|
parentRef: n,
|
|
28293
28403
|
childTag: s,
|
|
28294
28404
|
candidate: a
|
|
@@ -28299,9 +28409,9 @@ async function di(e, t, n) {
|
|
|
28299
28409
|
}
|
|
28300
28410
|
}
|
|
28301
28411
|
if (!d || !u) continue;
|
|
28302
|
-
let f = d.fields.find((e) =>
|
|
28412
|
+
let f = d.fields.find((e) => Bn(W(s, e)));
|
|
28303
28413
|
if (f) {
|
|
28304
|
-
let t = await
|
|
28414
|
+
let t = await Xn(e, {
|
|
28305
28415
|
parentRef: u,
|
|
28306
28416
|
childTag: s,
|
|
28307
28417
|
candidate: a,
|
|
@@ -28316,23 +28426,23 @@ async function di(e, t, n) {
|
|
|
28316
28426
|
}
|
|
28317
28427
|
//#endregion
|
|
28318
28428
|
//#region src/v2019C1/extensions/lifecycle/report/query/satellite-companions.ts
|
|
28319
|
-
async function
|
|
28429
|
+
async function gi(e, t) {
|
|
28320
28430
|
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
28431
|
for (let r of i) {
|
|
28322
|
-
let { uuid: i, name: a } = await n.any.getAttributes(r), l = await
|
|
28432
|
+
let { uuid: i, name: a } = await n.any.getAttributes(r), l = await _n({
|
|
28323
28433
|
sourceQuery: n,
|
|
28324
28434
|
targetQuery: e,
|
|
28325
28435
|
sourceRootRef: r,
|
|
28326
|
-
instanceRootRef: await
|
|
28436
|
+
instanceRootRef: await kr(e, {
|
|
28327
28437
|
tagName: r.tagName,
|
|
28328
28438
|
sourceUuid: i,
|
|
28329
28439
|
sourceName: a
|
|
28330
28440
|
}),
|
|
28331
28441
|
keepLeftoverRefs: !0,
|
|
28332
|
-
leftoverRefPolicy: await
|
|
28442
|
+
leftoverRefPolicy: await _i(e, n, r),
|
|
28333
28443
|
refsAlwaysAdded: t.refsAlwaysAdded ?? !1
|
|
28334
28444
|
});
|
|
28335
|
-
l.summary.added + l.summary.removed + l.summary.modified > 0 && (c ? c.companions.push(l.root) : o.groups.push(...
|
|
28445
|
+
l.summary.added + l.summary.removed + l.summary.modified > 0 && (c ? c.companions.push(l.root) : o.groups.push(...ln(l.root, s)));
|
|
28336
28446
|
}
|
|
28337
28447
|
if (c) for (let t of a ?? []) {
|
|
28338
28448
|
let { templateUuid: r } = await e.any.getAttributes(t);
|
|
@@ -28350,31 +28460,31 @@ async function fi(e, t) {
|
|
|
28350
28460
|
}
|
|
28351
28461
|
return o;
|
|
28352
28462
|
}
|
|
28353
|
-
async function
|
|
28463
|
+
async function _i(e, t, n) {
|
|
28354
28464
|
let r = await t.any.getTree(n), i = /* @__PURE__ */ new Set();
|
|
28355
|
-
return r && await
|
|
28356
|
-
let r =
|
|
28465
|
+
return r && await vi(t, r, i), async (n) => {
|
|
28466
|
+
let r = D[n.tagName];
|
|
28357
28467
|
if (!r) return "keep";
|
|
28358
28468
|
for (let a of r) {
|
|
28359
28469
|
let r = await e.any.getAttribute(n, { name: a.attribute.uuid });
|
|
28360
28470
|
if (!r) continue;
|
|
28361
|
-
let o = await
|
|
28471
|
+
let o = await yi(e, r, a.target);
|
|
28362
28472
|
if (!o) continue;
|
|
28363
28473
|
let s = await e.any.getAttribute(o, { name: "templateUuid" });
|
|
28364
|
-
if (s && await
|
|
28474
|
+
if (s && await yi(t, s, a.target) && !i.has(s)) return "removed";
|
|
28365
28475
|
}
|
|
28366
28476
|
return "keep";
|
|
28367
28477
|
};
|
|
28368
28478
|
}
|
|
28369
|
-
async function
|
|
28370
|
-
let r =
|
|
28479
|
+
async function vi(e, t, n) {
|
|
28480
|
+
let r = D[t.tagName];
|
|
28371
28481
|
if (r) for (let i of r) {
|
|
28372
28482
|
let r = await e.any.getAttribute(t, { name: i.attribute.uuid });
|
|
28373
28483
|
r && n.add(r);
|
|
28374
28484
|
}
|
|
28375
|
-
for (let r of t.tree) await
|
|
28485
|
+
for (let r of t.tree) await vi(e, r, n);
|
|
28376
28486
|
}
|
|
28377
|
-
async function
|
|
28487
|
+
async function yi(e, t, n) {
|
|
28378
28488
|
for (let r of n) {
|
|
28379
28489
|
let [n] = await e.any.findByAttributes({
|
|
28380
28490
|
tagName: r,
|
|
@@ -28385,13 +28495,13 @@ async function hi(e, t, n) {
|
|
|
28385
28495
|
}
|
|
28386
28496
|
//#endregion
|
|
28387
28497
|
//#region src/v2019C1/extensions/lifecycle/report/query/cross-cutting-satellites.ts
|
|
28388
|
-
async function
|
|
28498
|
+
async function bi(e, t) {
|
|
28389
28499
|
let { sourceQuery: n, primaryRef: r, instancePrimaryRef: i, report: a } = t;
|
|
28390
|
-
return
|
|
28500
|
+
return gi(e, {
|
|
28391
28501
|
sourceQuery: n,
|
|
28392
28502
|
primaryRef: r,
|
|
28393
|
-
satelliteRefs: await
|
|
28394
|
-
instanceSatelliteRefs: i ? await
|
|
28503
|
+
satelliteRefs: await Z(n, { primaryRef: r }),
|
|
28504
|
+
instanceSatelliteRefs: i ? await Z(e, { primaryRef: i }) : [],
|
|
28395
28505
|
report: a,
|
|
28396
28506
|
instanceScopeId: i?.id,
|
|
28397
28507
|
refsAlwaysAdded: t.refsAlwaysAdded ?? !1
|
|
@@ -28399,13 +28509,13 @@ async function gi(e, t) {
|
|
|
28399
28509
|
}
|
|
28400
28510
|
//#endregion
|
|
28401
28511
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-function-satellites.ts
|
|
28402
|
-
async function
|
|
28512
|
+
async function xi(e, t) {
|
|
28403
28513
|
let { sourceQuery: n, functionRef: r, instance: i, report: a } = t;
|
|
28404
|
-
return
|
|
28514
|
+
return gi(e, {
|
|
28405
28515
|
sourceQuery: n,
|
|
28406
28516
|
primaryRef: r,
|
|
28407
|
-
satelliteRefs: await
|
|
28408
|
-
instanceSatelliteRefs: i ? await
|
|
28517
|
+
satelliteRefs: await Hr(n, { primaryRef: r }),
|
|
28518
|
+
instanceSatelliteRefs: i ? await Hr(e, { primaryRef: {
|
|
28409
28519
|
tagName: "Function",
|
|
28410
28520
|
id: i.id
|
|
28411
28521
|
} }) : [],
|
|
@@ -28416,20 +28526,21 @@ async function _i(e, t) {
|
|
|
28416
28526
|
}
|
|
28417
28527
|
//#endregion
|
|
28418
28528
|
//#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
|
|
28529
|
+
async function Si(e, t) {
|
|
28530
|
+
let { sourceQuery: n, functionRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await xi(e, {
|
|
28421
28531
|
sourceQuery: n,
|
|
28422
28532
|
functionRef: r,
|
|
28423
28533
|
instance: i,
|
|
28424
|
-
report: await
|
|
28534
|
+
report: await _n({
|
|
28425
28535
|
sourceQuery: n,
|
|
28426
28536
|
targetQuery: e,
|
|
28427
28537
|
sourceRootRef: r,
|
|
28428
|
-
instanceRootRef: i
|
|
28538
|
+
instanceRootRef: i,
|
|
28539
|
+
matchKey: t.matchKey
|
|
28429
28540
|
}),
|
|
28430
28541
|
refsAlwaysAdded: a
|
|
28431
28542
|
});
|
|
28432
|
-
return
|
|
28543
|
+
return bi(e, {
|
|
28433
28544
|
sourceQuery: n,
|
|
28434
28545
|
primaryRef: r,
|
|
28435
28546
|
instancePrimaryRef: i ? {
|
|
@@ -28442,7 +28553,7 @@ async function vi(e, t) {
|
|
|
28442
28553
|
}
|
|
28443
28554
|
//#endregion
|
|
28444
28555
|
//#region src/v2019C1/extensions/presentation/constants/title.ts
|
|
28445
|
-
var
|
|
28556
|
+
var Ci = {
|
|
28446
28557
|
LNode: {
|
|
28447
28558
|
compact: [
|
|
28448
28559
|
"prefix",
|
|
@@ -28539,29 +28650,29 @@ var yi = {
|
|
|
28539
28650
|
};
|
|
28540
28651
|
//#endregion
|
|
28541
28652
|
//#region src/v2019C1/extensions/presentation/query/extract-element-title.ts
|
|
28542
|
-
async function
|
|
28653
|
+
async function wi(e, t, n = {}) {
|
|
28543
28654
|
let r = await e.getRecord(t);
|
|
28544
28655
|
if (!r) return n.withLabels ? {
|
|
28545
28656
|
title: "",
|
|
28546
28657
|
labels: {}
|
|
28547
28658
|
} : "";
|
|
28548
|
-
let i = r.tagName, a = n.mode ?? "compact", o = await e.any.getAttributes(r), s =
|
|
28659
|
+
let i = r.tagName, a = n.mode ?? "compact", o = await e.any.getAttributes(r), s = Ci[i], c = Ti({
|
|
28549
28660
|
tag: i,
|
|
28550
28661
|
spec: s,
|
|
28551
28662
|
mode: a,
|
|
28552
28663
|
attributes: o,
|
|
28553
|
-
specAttributes: s?.attributesFrom ? await
|
|
28664
|
+
specAttributes: s?.attributesFrom ? await Ei(e, r, s.attributesFrom) : o,
|
|
28554
28665
|
value: r.value
|
|
28555
28666
|
});
|
|
28556
28667
|
return n.withLabels ? {
|
|
28557
28668
|
title: c,
|
|
28558
|
-
labels: await
|
|
28669
|
+
labels: await Di(e, r)
|
|
28559
28670
|
} : c;
|
|
28560
28671
|
}
|
|
28561
|
-
function
|
|
28672
|
+
function Ti(e) {
|
|
28562
28673
|
let { tag: t, spec: n, mode: r, attributes: i, specAttributes: a, value: o } = e;
|
|
28563
28674
|
if (n) {
|
|
28564
|
-
let e =
|
|
28675
|
+
let e = Ai(n, a, r);
|
|
28565
28676
|
if (e) return e;
|
|
28566
28677
|
}
|
|
28567
28678
|
let s = (o ?? "").trim();
|
|
@@ -28569,14 +28680,14 @@ function xi(e) {
|
|
|
28569
28680
|
let c = _[t]?.attributes?.identityFields, l = c?.find((e) => e === "name" || e === "id") ?? c?.[0];
|
|
28570
28681
|
return l && i[l] ? i[l] : i.name || t;
|
|
28571
28682
|
}
|
|
28572
|
-
async function
|
|
28683
|
+
async function Ei(e, t, n) {
|
|
28573
28684
|
let [r] = await e.any.getChildren(t, n);
|
|
28574
28685
|
return r ? e.any.getAttributes(r) : {};
|
|
28575
28686
|
}
|
|
28576
|
-
async function
|
|
28577
|
-
return
|
|
28687
|
+
async function Di(e, t) {
|
|
28688
|
+
return ki(await Oi(e, t));
|
|
28578
28689
|
}
|
|
28579
|
-
async function
|
|
28690
|
+
async function Oi(e, t) {
|
|
28580
28691
|
let n = [], r = await e.any.getChildren(t, "Labels");
|
|
28581
28692
|
for (let t of r) {
|
|
28582
28693
|
let r = await e.any.getChildren(t, "Label");
|
|
@@ -28591,18 +28702,18 @@ async function wi(e, t) {
|
|
|
28591
28702
|
}
|
|
28592
28703
|
return n;
|
|
28593
28704
|
}
|
|
28594
|
-
function
|
|
28705
|
+
function ki(e) {
|
|
28595
28706
|
let t = {};
|
|
28596
28707
|
for (let { lang: n, id: r, text: i } of e) (t[n] ??= {})[r] = i;
|
|
28597
28708
|
return t;
|
|
28598
28709
|
}
|
|
28599
|
-
function
|
|
28710
|
+
function Ai(e, t, n) {
|
|
28600
28711
|
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 (
|
|
28712
|
+
if (typeof i == "string") return Mi(i, t);
|
|
28713
|
+
if (ji(i)) {
|
|
28603
28714
|
for (let e of i) {
|
|
28604
28715
|
if (e.whenPresent && !t[e.whenPresent]) continue;
|
|
28605
|
-
let n =
|
|
28716
|
+
let n = Mi(e.template, t);
|
|
28606
28717
|
if (n) return n;
|
|
28607
28718
|
}
|
|
28608
28719
|
return "";
|
|
@@ -28610,22 +28721,22 @@ function Ei(e, t, n) {
|
|
|
28610
28721
|
let o = i.map((e) => t[e]).filter(Boolean);
|
|
28611
28722
|
return o.length > 0 ? o.join(a) : "";
|
|
28612
28723
|
}
|
|
28613
|
-
function
|
|
28724
|
+
function ji(e) {
|
|
28614
28725
|
return typeof e[0] == "object";
|
|
28615
28726
|
}
|
|
28616
|
-
function
|
|
28727
|
+
function Mi(e, t) {
|
|
28617
28728
|
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
28729
|
}
|
|
28619
28730
|
//#endregion
|
|
28620
28731
|
//#region src/v2019C1/extensions/presentation/query/index.ts
|
|
28621
|
-
var
|
|
28732
|
+
var Ni = /* @__PURE__ */ l({ extractElementTitle: () => wi });
|
|
28622
28733
|
//#endregion
|
|
28623
28734
|
//#region src/v2019C1/extensions/lifecycle/report/query/report-instance.ts
|
|
28624
|
-
async function
|
|
28735
|
+
async function $(e, t) {
|
|
28625
28736
|
let { instanceDiff: n, instance: r, sourceQuery: i, sourceRef: o } = t, s = n.groups.length === 0;
|
|
28626
28737
|
if (!r) return {
|
|
28627
28738
|
rootRef: void 0,
|
|
28628
|
-
title: await
|
|
28739
|
+
title: await wi(i, o),
|
|
28629
28740
|
linked: !1,
|
|
28630
28741
|
upToDate: s,
|
|
28631
28742
|
tree: n.root,
|
|
@@ -28634,7 +28745,7 @@ async function Q(e, t) {
|
|
|
28634
28745
|
let { templateUuid: c, originUuid: l } = await e.any.getAttributes(r), u = !!(c || l);
|
|
28635
28746
|
return {
|
|
28636
28747
|
rootRef: a(r),
|
|
28637
|
-
title: await
|
|
28748
|
+
title: await wi(e, r),
|
|
28638
28749
|
linked: u,
|
|
28639
28750
|
upToDate: s,
|
|
28640
28751
|
tree: n.root,
|
|
@@ -28643,64 +28754,64 @@ async function Q(e, t) {
|
|
|
28643
28754
|
}
|
|
28644
28755
|
//#endregion
|
|
28645
28756
|
//#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
|
|
28757
|
+
async function Pi(e, t) {
|
|
28758
|
+
let { sourceQuery: n, applicationRef: r, scenario: i } = t, { uuid: a } = await n.getAttributes(r), o = i === "instantiate" ? [] : await X(e, {
|
|
28648
28759
|
tagName: "Application",
|
|
28649
28760
|
sourceUuid: a
|
|
28650
28761
|
}), s = [];
|
|
28651
28762
|
if (o.length === 0) {
|
|
28652
|
-
let t = await
|
|
28763
|
+
let t = await Fi(e, {
|
|
28653
28764
|
sourceQuery: n,
|
|
28654
28765
|
applicationRef: r,
|
|
28655
28766
|
instance: void 0,
|
|
28656
28767
|
refsAlwaysAdded: i === "instantiate"
|
|
28657
28768
|
});
|
|
28658
|
-
s.push(await
|
|
28769
|
+
s.push(await $(e, {
|
|
28659
28770
|
instanceDiff: t,
|
|
28660
28771
|
instance: void 0,
|
|
28661
28772
|
sourceQuery: n,
|
|
28662
28773
|
sourceRef: r
|
|
28663
28774
|
}));
|
|
28664
28775
|
} else for (let t of o) {
|
|
28665
|
-
let a = await
|
|
28776
|
+
let a = await Fi(e, {
|
|
28666
28777
|
sourceQuery: n,
|
|
28667
28778
|
applicationRef: r,
|
|
28668
28779
|
instance: t,
|
|
28669
28780
|
refsAlwaysAdded: i === "instantiate"
|
|
28670
28781
|
});
|
|
28671
|
-
s.push(await
|
|
28782
|
+
s.push(await $(e, {
|
|
28672
28783
|
instanceDiff: a,
|
|
28673
28784
|
instance: t,
|
|
28674
28785
|
sourceQuery: n,
|
|
28675
28786
|
sourceRef: r
|
|
28676
28787
|
}));
|
|
28677
28788
|
}
|
|
28678
|
-
let c = await
|
|
28789
|
+
let c = await Ii(e, {
|
|
28679
28790
|
sourceQuery: n,
|
|
28680
28791
|
applicationRef: r,
|
|
28681
28792
|
scenario: i
|
|
28682
28793
|
});
|
|
28683
|
-
return
|
|
28794
|
+
return Pn([...s, ...c]);
|
|
28684
28795
|
}
|
|
28685
|
-
async function
|
|
28686
|
-
let { sourceQuery: n, applicationRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await
|
|
28796
|
+
async function Fi(e, t) {
|
|
28797
|
+
let { sourceQuery: n, applicationRef: r, instance: i } = t, a = t.refsAlwaysAdded ?? !1, o = await _n({
|
|
28687
28798
|
sourceQuery: n,
|
|
28688
28799
|
targetQuery: e,
|
|
28689
28800
|
sourceRootRef: r,
|
|
28690
28801
|
instanceRootRef: i
|
|
28691
28802
|
});
|
|
28692
|
-
return await
|
|
28803
|
+
return await gi(e, {
|
|
28693
28804
|
sourceQuery: n,
|
|
28694
28805
|
primaryRef: r,
|
|
28695
|
-
satelliteRefs: await
|
|
28696
|
-
instanceSatelliteRefs: i ? await
|
|
28806
|
+
satelliteRefs: await qr(n, { applicationRef: r }),
|
|
28807
|
+
instanceSatelliteRefs: i ? await qr(e, { applicationRef: {
|
|
28697
28808
|
tagName: "Application",
|
|
28698
28809
|
id: i.id
|
|
28699
28810
|
} }) : [],
|
|
28700
28811
|
report: o,
|
|
28701
28812
|
instanceScopeId: i?.id,
|
|
28702
28813
|
refsAlwaysAdded: a
|
|
28703
|
-
}), await
|
|
28814
|
+
}), await bi(e, {
|
|
28704
28815
|
sourceQuery: n,
|
|
28705
28816
|
primaryRef: r,
|
|
28706
28817
|
instancePrimaryRef: i ? {
|
|
@@ -28711,8 +28822,8 @@ async function ji(e, t) {
|
|
|
28711
28822
|
refsAlwaysAdded: a
|
|
28712
28823
|
}), o;
|
|
28713
28824
|
}
|
|
28714
|
-
async function
|
|
28715
|
-
let { sourceQuery: n, applicationRef: r, scenario: i } = t, a = await
|
|
28825
|
+
async function Ii(e, t) {
|
|
28826
|
+
let { sourceQuery: n, applicationRef: r, scenario: i } = t, a = await Tr(n, r), o = [];
|
|
28716
28827
|
for (let t of a) {
|
|
28717
28828
|
let [r] = await n.any.findByAttributes({
|
|
28718
28829
|
tagName: "Function",
|
|
@@ -28722,18 +28833,18 @@ async function Mi(e, t) {
|
|
|
28722
28833
|
let a = {
|
|
28723
28834
|
tagName: "Function",
|
|
28724
28835
|
id: r.id
|
|
28725
|
-
}, s = i === "instantiate" ? [] : await
|
|
28836
|
+
}, s = i === "instantiate" ? [] : await X(e, {
|
|
28726
28837
|
tagName: "Function",
|
|
28727
28838
|
sourceUuid: t
|
|
28728
28839
|
});
|
|
28729
28840
|
if (s.length === 0) {
|
|
28730
|
-
let t = await
|
|
28841
|
+
let t = await Si(e, {
|
|
28731
28842
|
sourceQuery: n,
|
|
28732
28843
|
functionRef: a,
|
|
28733
28844
|
instance: void 0,
|
|
28734
28845
|
refsAlwaysAdded: i === "instantiate"
|
|
28735
28846
|
});
|
|
28736
|
-
o.push(await
|
|
28847
|
+
o.push(await $(e, {
|
|
28737
28848
|
instanceDiff: t,
|
|
28738
28849
|
instance: void 0,
|
|
28739
28850
|
sourceQuery: n,
|
|
@@ -28742,13 +28853,13 @@ async function Mi(e, t) {
|
|
|
28742
28853
|
continue;
|
|
28743
28854
|
}
|
|
28744
28855
|
for (let t of s) {
|
|
28745
|
-
let r = await
|
|
28856
|
+
let r = await Si(e, {
|
|
28746
28857
|
sourceQuery: n,
|
|
28747
28858
|
functionRef: a,
|
|
28748
28859
|
instance: t,
|
|
28749
28860
|
refsAlwaysAdded: i === "instantiate"
|
|
28750
28861
|
});
|
|
28751
|
-
o.push(await
|
|
28862
|
+
o.push(await $(e, {
|
|
28752
28863
|
instanceDiff: r,
|
|
28753
28864
|
instance: t,
|
|
28754
28865
|
sourceQuery: n,
|
|
@@ -28760,59 +28871,62 @@ async function Mi(e, t) {
|
|
|
28760
28871
|
}
|
|
28761
28872
|
//#endregion
|
|
28762
28873
|
//#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
|
|
28874
|
+
async function Li(e, t) {
|
|
28875
|
+
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
28876
|
targetParent: i,
|
|
28766
28877
|
tagName: "Function",
|
|
28767
|
-
sourceUuid: o
|
|
28878
|
+
sourceUuid: o,
|
|
28879
|
+
matchKey: s
|
|
28768
28880
|
});
|
|
28769
|
-
if (
|
|
28770
|
-
instanceDiff: await
|
|
28881
|
+
if (c.length === 0) return Pn([await $(e, {
|
|
28882
|
+
instanceDiff: await Si(e, {
|
|
28771
28883
|
sourceQuery: n,
|
|
28772
28884
|
functionRef: r,
|
|
28773
28885
|
instance: void 0,
|
|
28774
|
-
refsAlwaysAdded: a === "instantiate"
|
|
28886
|
+
refsAlwaysAdded: a === "instantiate",
|
|
28887
|
+
matchKey: s
|
|
28775
28888
|
}),
|
|
28776
28889
|
instance: void 0,
|
|
28777
28890
|
sourceQuery: n,
|
|
28778
28891
|
sourceRef: r
|
|
28779
28892
|
})]);
|
|
28780
|
-
let
|
|
28781
|
-
for (let t of
|
|
28782
|
-
let i = await
|
|
28893
|
+
let l = [];
|
|
28894
|
+
for (let t of c) {
|
|
28895
|
+
let i = await Si(e, {
|
|
28783
28896
|
sourceQuery: n,
|
|
28784
28897
|
functionRef: r,
|
|
28785
28898
|
instance: t,
|
|
28786
|
-
refsAlwaysAdded: a === "instantiate"
|
|
28899
|
+
refsAlwaysAdded: a === "instantiate",
|
|
28900
|
+
matchKey: s
|
|
28787
28901
|
});
|
|
28788
|
-
|
|
28902
|
+
l.push(await $(e, {
|
|
28789
28903
|
instanceDiff: i,
|
|
28790
28904
|
instance: t,
|
|
28791
28905
|
sourceQuery: n,
|
|
28792
28906
|
sourceRef: r
|
|
28793
28907
|
}));
|
|
28794
28908
|
}
|
|
28795
|
-
return
|
|
28909
|
+
return Pn(l);
|
|
28796
28910
|
}
|
|
28797
28911
|
//#endregion
|
|
28798
28912
|
//#region src/v2019C1/extensions/lifecycle/report/report.ts
|
|
28799
|
-
async function
|
|
28800
|
-
let n = t.verb === "fsd" ? await
|
|
28913
|
+
async function Ri(e, t) {
|
|
28914
|
+
let n = t.verb === "fsd" ? await Li(e, {
|
|
28801
28915
|
sourceQuery: t.sourceQuery,
|
|
28802
28916
|
functionRef: t.ref,
|
|
28803
28917
|
targetParent: t.anchor,
|
|
28804
28918
|
scenario: t.scenario
|
|
28805
|
-
}) : await
|
|
28919
|
+
}) : await Pi(e, {
|
|
28806
28920
|
sourceQuery: t.sourceQuery,
|
|
28807
28921
|
applicationRef: t.ref,
|
|
28808
28922
|
scenario: t.scenario
|
|
28809
28923
|
});
|
|
28810
|
-
for (let e of
|
|
28811
|
-
return await
|
|
28924
|
+
for (let e of U(n)) e.editableAttributes = Vn(e.primary.tagName);
|
|
28925
|
+
return await hi(e, t, n), n;
|
|
28812
28926
|
}
|
|
28813
28927
|
//#endregion
|
|
28814
28928
|
//#region src/v2019C1/extensions/lifecycle/report/presentation-scope.ts
|
|
28815
|
-
function
|
|
28929
|
+
function zi(e) {
|
|
28816
28930
|
switch (e.verb) {
|
|
28817
28931
|
case "fsd":
|
|
28818
28932
|
case "asd": return {
|
|
@@ -28824,9 +28938,9 @@ function Fi(e) {
|
|
|
28824
28938
|
}
|
|
28825
28939
|
//#endregion
|
|
28826
28940
|
//#region src/v2019C1/extensions/lifecycle/validate/template-uuid-check.ts
|
|
28827
|
-
async function
|
|
28941
|
+
async function Bi(e) {
|
|
28828
28942
|
let t = await e.any.getSnapshot({ as: "tree" }), n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
|
|
28829
|
-
await
|
|
28943
|
+
await Vi(e, t, n, r);
|
|
28830
28944
|
let i = [], a = /* @__PURE__ */ new Set();
|
|
28831
28945
|
for (let [e, { tagNames: t, refs: r }] of n) {
|
|
28832
28946
|
if (t.size < 2) continue;
|
|
@@ -28874,7 +28988,7 @@ async function Ii(e) {
|
|
|
28874
28988
|
}
|
|
28875
28989
|
return i;
|
|
28876
28990
|
}
|
|
28877
|
-
async function
|
|
28991
|
+
async function Vi(e, t, n, r) {
|
|
28878
28992
|
let i = {
|
|
28879
28993
|
tagName: t.tagName,
|
|
28880
28994
|
id: t.id
|
|
@@ -28894,35 +29008,35 @@ async function Li(e, t, n, r) {
|
|
|
28894
29008
|
ref: i
|
|
28895
29009
|
}), r.set(o, e);
|
|
28896
29010
|
}
|
|
28897
|
-
for (let i of t.tree) await
|
|
29011
|
+
for (let i of t.tree) await Vi(e, i, n, r);
|
|
28898
29012
|
}
|
|
28899
29013
|
//#endregion
|
|
28900
29014
|
//#region src/v2019C1/extensions/index.ts
|
|
28901
|
-
var
|
|
28902
|
-
cleanUp:
|
|
28903
|
-
dataModel:
|
|
28904
|
-
history:
|
|
28905
|
-
identity:
|
|
29015
|
+
var Hi = {
|
|
29016
|
+
cleanUp: xt,
|
|
29017
|
+
dataModel: Yt,
|
|
29018
|
+
history: en,
|
|
29019
|
+
identity: cn,
|
|
28906
29020
|
lifecycle: {
|
|
28907
29021
|
query: {
|
|
28908
|
-
report:
|
|
28909
|
-
checkTemplateUuids:
|
|
29022
|
+
report: Ri,
|
|
29023
|
+
checkTemplateUuids: Bi
|
|
28910
29024
|
},
|
|
28911
29025
|
transaction: {
|
|
28912
|
-
extract:
|
|
28913
|
-
instantiate:
|
|
28914
|
-
transplant: { deep:
|
|
28915
|
-
update:
|
|
28916
|
-
apply:
|
|
29026
|
+
extract: pi,
|
|
29027
|
+
instantiate: mi,
|
|
29028
|
+
transplant: { deep: J },
|
|
29029
|
+
update: ri,
|
|
29030
|
+
apply: ii
|
|
28917
29031
|
}
|
|
28918
29032
|
},
|
|
28919
|
-
reference:
|
|
28920
|
-
signature: { query:
|
|
28921
|
-
presentation: { query:
|
|
29033
|
+
reference: z,
|
|
29034
|
+
signature: { query: Ft },
|
|
29035
|
+
presentation: { query: Ni }
|
|
28922
29036
|
};
|
|
28923
29037
|
//#endregion
|
|
28924
29038
|
//#region src/v2019C1/hooks/after-created/private-wrapper.ts
|
|
28925
|
-
async function
|
|
29039
|
+
async function Ui(e) {
|
|
28926
29040
|
let { childRecord: t, parentRecord: n, query: r } = e;
|
|
28927
29041
|
if (t.namespace.prefix === x.namespaces.default.prefix) return [];
|
|
28928
29042
|
let i = n.tagName === "Private", a = n.namespace.prefix === x.namespaces.default.prefix;
|
|
@@ -28931,26 +29045,26 @@ async function zi(e) {
|
|
|
28931
29045
|
...n,
|
|
28932
29046
|
children: n.children.filter((e) => e.id !== t.id)
|
|
28933
29047
|
};
|
|
28934
|
-
return i ?
|
|
29048
|
+
return i ? Wi({
|
|
28935
29049
|
parentRecord: n,
|
|
28936
29050
|
childRecord: t,
|
|
28937
29051
|
query: r
|
|
28938
|
-
}) : o ?
|
|
29052
|
+
}) : o ? Gi({
|
|
28939
29053
|
existingPrivateRef: o,
|
|
28940
29054
|
parentRecord: n,
|
|
28941
29055
|
updatedParentRecord: s,
|
|
28942
29056
|
childRecord: t,
|
|
28943
29057
|
query: r
|
|
28944
|
-
}) : (await r.findAncestors(n)).some((e) => e.tagName === "Private" && e.attributes.some((e) => e.name === "type" && e.value === t.namespace.prefix)) ? [] :
|
|
29058
|
+
}) : (await r.findAncestors(n)).some((e) => e.tagName === "Private" && e.attributes.some((e) => e.name === "type" && e.value === t.namespace.prefix)) ? [] : Ki({
|
|
28945
29059
|
parentRecord: n,
|
|
28946
29060
|
updatedParentRecord: s,
|
|
28947
29061
|
childRecord: t
|
|
28948
29062
|
});
|
|
28949
29063
|
}
|
|
28950
|
-
async function
|
|
29064
|
+
async function Wi(e) {
|
|
28951
29065
|
let { parentRecord: t, childRecord: n, query: r } = e, a = t;
|
|
28952
29066
|
if (n.parent?.id === a.id && n.parent?.tagName === "Private") return [];
|
|
28953
|
-
let o = await
|
|
29067
|
+
let o = await qi({
|
|
28954
29068
|
privateId: a.id,
|
|
28955
29069
|
query: r
|
|
28956
29070
|
});
|
|
@@ -28958,7 +29072,7 @@ async function Bi(e) {
|
|
|
28958
29072
|
detail: "Latest private record not found",
|
|
28959
29073
|
key: "ELEMENT_NOT_FOUND"
|
|
28960
29074
|
});
|
|
28961
|
-
let { childRecord: c, privateRecord: l } =
|
|
29075
|
+
let { childRecord: c, privateRecord: l } = Ji({
|
|
28962
29076
|
privateRecord: o,
|
|
28963
29077
|
childRecord: n
|
|
28964
29078
|
});
|
|
@@ -28972,8 +29086,8 @@ async function Bi(e) {
|
|
|
28972
29086
|
newRecord: i(l)
|
|
28973
29087
|
}];
|
|
28974
29088
|
}
|
|
28975
|
-
async function
|
|
28976
|
-
let { existingPrivateRef: t, parentRecord: n, updatedParentRecord: r, childRecord: a, query: o } = e, c = await
|
|
29089
|
+
async function Gi(e) {
|
|
29090
|
+
let { existingPrivateRef: t, parentRecord: n, updatedParentRecord: r, childRecord: a, query: o } = e, c = await qi({
|
|
28977
29091
|
privateId: t.id,
|
|
28978
29092
|
query: o
|
|
28979
29093
|
});
|
|
@@ -28981,7 +29095,7 @@ async function Vi(e) {
|
|
|
28981
29095
|
detail: "Latest private record not found",
|
|
28982
29096
|
key: "ELEMENT_NOT_FOUND"
|
|
28983
29097
|
}), !c.attributes.some((e) => e.name === "type" && e.value === a.namespace.prefix)) return [];
|
|
28984
|
-
let { childRecord: l, privateRecord: u } =
|
|
29098
|
+
let { childRecord: l, privateRecord: u } = Ji({
|
|
28985
29099
|
privateRecord: c,
|
|
28986
29100
|
childRecord: a
|
|
28987
29101
|
});
|
|
@@ -29003,7 +29117,7 @@ async function Vi(e) {
|
|
|
29003
29117
|
}
|
|
29004
29118
|
];
|
|
29005
29119
|
}
|
|
29006
|
-
function
|
|
29120
|
+
function Ki(e) {
|
|
29007
29121
|
let { parentRecord: t, updatedParentRecord: n, childRecord: r } = e, a = {
|
|
29008
29122
|
id: crypto.randomUUID(),
|
|
29009
29123
|
tagName: "Private",
|
|
@@ -29052,14 +29166,14 @@ function Hi(e) {
|
|
|
29052
29166
|
}
|
|
29053
29167
|
];
|
|
29054
29168
|
}
|
|
29055
|
-
async function
|
|
29169
|
+
async function qi(e) {
|
|
29056
29170
|
let { privateId: t, query: n } = e;
|
|
29057
29171
|
return await n.getRecord({
|
|
29058
29172
|
id: t,
|
|
29059
29173
|
tagName: "Private"
|
|
29060
29174
|
});
|
|
29061
29175
|
}
|
|
29062
|
-
function
|
|
29176
|
+
function Ji(e) {
|
|
29063
29177
|
let { privateRecord: t, childRecord: n } = e;
|
|
29064
29178
|
return {
|
|
29065
29179
|
childRecord: {
|
|
@@ -29080,7 +29194,7 @@ function Wi(e) {
|
|
|
29080
29194
|
}
|
|
29081
29195
|
//#endregion
|
|
29082
29196
|
//#region src/v2019C1/hooks/shared/ref-entry-ops.ts
|
|
29083
|
-
async function
|
|
29197
|
+
async function Yi(e) {
|
|
29084
29198
|
let { uuid: t, entry: r, target: a, query: o } = e;
|
|
29085
29199
|
if (!n(r.refTagName, x)) return [];
|
|
29086
29200
|
let s = await o.getRecordsByTagName(r.refTagName), c = [];
|
|
@@ -29089,7 +29203,7 @@ async function Gi(e) {
|
|
|
29089
29203
|
let n = {
|
|
29090
29204
|
tagName: e.tagName,
|
|
29091
29205
|
id: e.id
|
|
29092
|
-
}, s = await
|
|
29206
|
+
}, s = await z.query.buildReferencePath(o, {
|
|
29093
29207
|
reference: n,
|
|
29094
29208
|
target: a
|
|
29095
29209
|
});
|
|
@@ -29109,7 +29223,7 @@ async function Gi(e) {
|
|
|
29109
29223
|
}
|
|
29110
29224
|
return c;
|
|
29111
29225
|
}
|
|
29112
|
-
function
|
|
29226
|
+
function Xi(e) {
|
|
29113
29227
|
let t = [];
|
|
29114
29228
|
for (let n of je) {
|
|
29115
29229
|
let r = ke[n]?.get(e);
|
|
@@ -29119,7 +29233,7 @@ function Ki(e) {
|
|
|
29119
29233
|
}
|
|
29120
29234
|
//#endregion
|
|
29121
29235
|
//#region src/v2019C1/hooks/shared/record-ops.ts
|
|
29122
|
-
function
|
|
29236
|
+
function Zi(e, t) {
|
|
29123
29237
|
return {
|
|
29124
29238
|
status: "updated",
|
|
29125
29239
|
oldRecord: e,
|
|
@@ -29129,7 +29243,7 @@ function qi(e, t) {
|
|
|
29129
29243
|
}
|
|
29130
29244
|
};
|
|
29131
29245
|
}
|
|
29132
|
-
function
|
|
29246
|
+
function Qi(e, t, n) {
|
|
29133
29247
|
return e.some((e) => e.name === t) ? e.map((e) => e.name === t ? {
|
|
29134
29248
|
...e,
|
|
29135
29249
|
value: n
|
|
@@ -29140,23 +29254,23 @@ function Ji(e, t, n) {
|
|
|
29140
29254
|
}
|
|
29141
29255
|
//#endregion
|
|
29142
29256
|
//#region src/v2019C1/hooks/shared/mapped-name.ts
|
|
29143
|
-
async function
|
|
29257
|
+
async function $i(e, t) {
|
|
29144
29258
|
let n = P.get(t.tagName);
|
|
29145
29259
|
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 :
|
|
29260
|
+
let r = await Re(e, t);
|
|
29261
|
+
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
29262
|
}
|
|
29149
29263
|
//#endregion
|
|
29150
29264
|
//#region src/v2019C1/hooks/shared/ref-path-rebuild.ts
|
|
29151
|
-
async function
|
|
29265
|
+
async function ea(e) {
|
|
29152
29266
|
let { oldRecord: t, newRecord: n, query: r } = e;
|
|
29153
29267
|
if (P.has(n.tagName)) return [];
|
|
29154
|
-
let i =
|
|
29268
|
+
let i = D[n.tagName];
|
|
29155
29269
|
if (!i) return [];
|
|
29156
29270
|
let a = [];
|
|
29157
29271
|
for (let e of i) {
|
|
29158
|
-
if (e.resolution === M.unsupported || !
|
|
29159
|
-
let i = await
|
|
29272
|
+
if (e.resolution === M.unsupported || !ta(t, n, e)) continue;
|
|
29273
|
+
let i = await na({
|
|
29160
29274
|
newRecord: n,
|
|
29161
29275
|
pair: e,
|
|
29162
29276
|
query: r
|
|
@@ -29165,28 +29279,28 @@ async function Xi(e) {
|
|
|
29165
29279
|
}
|
|
29166
29280
|
return a;
|
|
29167
29281
|
}
|
|
29168
|
-
function
|
|
29169
|
-
return [n.attribute.uuid, ...n.companions.map((e) => e.name)].some((n) =>
|
|
29282
|
+
function ta(e, t, n) {
|
|
29283
|
+
return [n.attribute.uuid, ...n.companions.map((e) => e.name)].some((n) => ia(e, n) !== ia(t, n));
|
|
29170
29284
|
}
|
|
29171
|
-
async function
|
|
29172
|
-
let { newRecord: t, pair: n, query: r } = e, i =
|
|
29285
|
+
async function na(e) {
|
|
29286
|
+
let { newRecord: t, pair: n, query: r } = e, i = ia(t, n.attribute.uuid);
|
|
29173
29287
|
if (!i) return null;
|
|
29174
|
-
let a = await
|
|
29288
|
+
let a = await ra({
|
|
29175
29289
|
uuidValue: i,
|
|
29176
29290
|
targetTagNames: n.target,
|
|
29177
29291
|
query: r
|
|
29178
29292
|
});
|
|
29179
29293
|
if (!a) return null;
|
|
29180
|
-
let o = await
|
|
29294
|
+
let o = await j(r, {
|
|
29181
29295
|
reference: {
|
|
29182
29296
|
tagName: t.tagName,
|
|
29183
29297
|
id: t.id
|
|
29184
29298
|
},
|
|
29185
29299
|
target: a
|
|
29186
29300
|
});
|
|
29187
|
-
return !o ||
|
|
29301
|
+
return !o || ia(t, n.attribute.path) === o ? null : Zi(t, Qi(t.attributes, n.attribute.path, o));
|
|
29188
29302
|
}
|
|
29189
|
-
async function
|
|
29303
|
+
async function ra(e) {
|
|
29190
29304
|
let { uuidValue: t, targetTagNames: r, query: i } = e;
|
|
29191
29305
|
for (let e of r) {
|
|
29192
29306
|
if (!n(e, x)) continue;
|
|
@@ -29198,22 +29312,22 @@ async function $i(e) {
|
|
|
29198
29312
|
}
|
|
29199
29313
|
return null;
|
|
29200
29314
|
}
|
|
29201
|
-
function
|
|
29315
|
+
function ia(e, t) {
|
|
29202
29316
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
29203
29317
|
}
|
|
29204
29318
|
//#endregion
|
|
29205
29319
|
//#region src/v2019C1/hooks/shared/lnode-binding.ts
|
|
29206
|
-
var
|
|
29207
|
-
async function
|
|
29320
|
+
var aa = "None";
|
|
29321
|
+
async function oa(e) {
|
|
29208
29322
|
let { oldRecord: t, newRecord: n, query: r } = e;
|
|
29209
29323
|
if (n.tagName !== "LNode") return null;
|
|
29210
|
-
let i =
|
|
29324
|
+
let i = da(t, "lnUuid"), a = da(n, "lnUuid");
|
|
29211
29325
|
if (i === a) return null;
|
|
29212
|
-
let o = a ? await
|
|
29213
|
-
return o ?
|
|
29326
|
+
let o = a ? await sa(r, a) : await ca(r, n);
|
|
29327
|
+
return o ? ua(n, o) : null;
|
|
29214
29328
|
}
|
|
29215
|
-
async function
|
|
29216
|
-
let n = await
|
|
29329
|
+
async function sa(e, t) {
|
|
29330
|
+
let n = await la(e, t);
|
|
29217
29331
|
if (!n) return null;
|
|
29218
29332
|
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
29333
|
tagName: "LDevice",
|
|
@@ -29230,9 +29344,9 @@ async function na(e, t) {
|
|
|
29230
29344
|
lnInst: r.inst
|
|
29231
29345
|
};
|
|
29232
29346
|
}
|
|
29233
|
-
async function
|
|
29347
|
+
async function ca(e, t) {
|
|
29234
29348
|
let n = {
|
|
29235
|
-
iedName:
|
|
29349
|
+
iedName: aa,
|
|
29236
29350
|
ldInst: void 0
|
|
29237
29351
|
}, r = await e.getChild({
|
|
29238
29352
|
tagName: "LNode",
|
|
@@ -29247,7 +29361,7 @@ async function ra(e, t) {
|
|
|
29247
29361
|
lnInst: i.sLnInst
|
|
29248
29362
|
};
|
|
29249
29363
|
}
|
|
29250
|
-
async function
|
|
29364
|
+
async function la(e, t) {
|
|
29251
29365
|
for (let r of ["LN", "LN0"]) {
|
|
29252
29366
|
if (!n(r, x)) continue;
|
|
29253
29367
|
let i = (await e.getRecordsByTagName(r)).find((e) => e.attributes.find((e) => e.name === "uuid")?.value === t);
|
|
@@ -29258,7 +29372,7 @@ async function ia(e, t) {
|
|
|
29258
29372
|
}
|
|
29259
29373
|
return null;
|
|
29260
29374
|
}
|
|
29261
|
-
function
|
|
29375
|
+
function ua(e, t) {
|
|
29262
29376
|
let n = [...e.attributes], r = !1;
|
|
29263
29377
|
for (let [e, i] of Object.entries(t)) {
|
|
29264
29378
|
let t = n.find((t) => t.name === e)?.value;
|
|
@@ -29267,35 +29381,35 @@ function aa(e, t) {
|
|
|
29267
29381
|
n = n.filter((t) => t.name !== e), r = !0;
|
|
29268
29382
|
continue;
|
|
29269
29383
|
}
|
|
29270
|
-
t !== i && (n =
|
|
29384
|
+
t !== i && (n = Qi(n, e, i), r = !0);
|
|
29271
29385
|
}
|
|
29272
|
-
return r ?
|
|
29386
|
+
return r ? Zi(e, n) : null;
|
|
29273
29387
|
}
|
|
29274
|
-
function
|
|
29388
|
+
function da(e, t) {
|
|
29275
29389
|
return e.attributes.find((e) => e.name === t)?.value;
|
|
29276
29390
|
}
|
|
29277
29391
|
//#endregion
|
|
29278
29392
|
//#region src/v2019C1/hooks/after-created/ref-paths.ts
|
|
29279
|
-
async function
|
|
29280
|
-
let { childRecord: t, query: n } = e, r = await
|
|
29393
|
+
async function fa(e) {
|
|
29394
|
+
let { childRecord: t, query: n } = e, r = await pa({
|
|
29281
29395
|
childRecord: t,
|
|
29282
29396
|
query: n
|
|
29283
|
-
}), i = await
|
|
29397
|
+
}), i = await ga({
|
|
29284
29398
|
childRecord: t,
|
|
29285
29399
|
query: n
|
|
29286
|
-
}), a = await
|
|
29400
|
+
}), a = await $i(n, o(t)), s = a ? [a] : [];
|
|
29287
29401
|
return [
|
|
29288
29402
|
...r,
|
|
29289
29403
|
...i,
|
|
29290
29404
|
...s
|
|
29291
29405
|
];
|
|
29292
29406
|
}
|
|
29293
|
-
async function
|
|
29407
|
+
async function pa(e) {
|
|
29294
29408
|
let { childRecord: t, query: n } = e, r = Me.get(t.tagName);
|
|
29295
29409
|
if (!r?.length) return [];
|
|
29296
29410
|
let i = [];
|
|
29297
29411
|
for (let e of r) {
|
|
29298
|
-
let r = await
|
|
29412
|
+
let r = await ma({
|
|
29299
29413
|
childRecord: t,
|
|
29300
29414
|
pair: e,
|
|
29301
29415
|
query: n
|
|
@@ -29304,16 +29418,16 @@ async function ca(e) {
|
|
|
29304
29418
|
}
|
|
29305
29419
|
return i;
|
|
29306
29420
|
}
|
|
29307
|
-
async function
|
|
29421
|
+
async function ma(e) {
|
|
29308
29422
|
let { childRecord: t, pair: n, query: r } = e, i = t.attributes.find((e) => e.name === n.uuidAttr)?.value;
|
|
29309
29423
|
if (!i) return null;
|
|
29310
|
-
let a = await
|
|
29424
|
+
let a = await ha({
|
|
29311
29425
|
uuidValue: i,
|
|
29312
29426
|
targetTagNames: n.targetTagNames,
|
|
29313
29427
|
query: r
|
|
29314
29428
|
});
|
|
29315
29429
|
if (!a) return null;
|
|
29316
|
-
let o = await
|
|
29430
|
+
let o = await j(r, {
|
|
29317
29431
|
reference: {
|
|
29318
29432
|
tagName: t.tagName,
|
|
29319
29433
|
id: t.id
|
|
@@ -29337,7 +29451,7 @@ async function la(e) {
|
|
|
29337
29451
|
}
|
|
29338
29452
|
};
|
|
29339
29453
|
}
|
|
29340
|
-
async function
|
|
29454
|
+
async function ha(e) {
|
|
29341
29455
|
let { uuidValue: t, targetTagNames: r, query: i } = e;
|
|
29342
29456
|
for (let e of r) {
|
|
29343
29457
|
if (!n(e, x)) continue;
|
|
@@ -29349,17 +29463,17 @@ async function ua(e) {
|
|
|
29349
29463
|
}
|
|
29350
29464
|
return null;
|
|
29351
29465
|
}
|
|
29352
|
-
async function
|
|
29466
|
+
async function ga(e) {
|
|
29353
29467
|
let { childRecord: t, query: n } = e, r = t.attributes.find((e) => e.name === "uuid")?.value;
|
|
29354
29468
|
if (!r) return [];
|
|
29355
|
-
let i =
|
|
29469
|
+
let i = Xi(t.tagName);
|
|
29356
29470
|
if (i.length === 0) return [];
|
|
29357
29471
|
let a = {
|
|
29358
29472
|
tagName: t.tagName,
|
|
29359
29473
|
id: t.id
|
|
29360
29474
|
}, o = [];
|
|
29361
29475
|
for (let e of i) {
|
|
29362
|
-
let t = await
|
|
29476
|
+
let t = await Yi({
|
|
29363
29477
|
uuid: r,
|
|
29364
29478
|
entry: e,
|
|
29365
29479
|
target: a,
|
|
@@ -29371,134 +29485,20 @@ async function da(e) {
|
|
|
29371
29485
|
}
|
|
29372
29486
|
//#endregion
|
|
29373
29487
|
//#region src/v2019C1/hooks/after-created/after-created.ts
|
|
29374
|
-
async function
|
|
29375
|
-
let { childRecord: t, parentRecord: n, query: r } = e, i = await
|
|
29488
|
+
async function _a(e) {
|
|
29489
|
+
let { childRecord: t, parentRecord: n, query: r } = e, i = await Ui({
|
|
29376
29490
|
childRecord: t,
|
|
29377
29491
|
parentRecord: n,
|
|
29378
29492
|
query: r
|
|
29379
|
-
}), a = await
|
|
29493
|
+
}), a = await fa({
|
|
29380
29494
|
childRecord: t,
|
|
29381
29495
|
query: r
|
|
29382
29496
|
});
|
|
29383
29497
|
return [...i, ...a];
|
|
29384
29498
|
}
|
|
29385
29499
|
//#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
29500
|
//#region src/v2019C1/hooks/after-standardized-record/uuid-attribute.ts
|
|
29501
|
-
function
|
|
29501
|
+
function va(e) {
|
|
29502
29502
|
let { record: t } = e, { tagName: n, attributes: r } = t, i = x.definition[n];
|
|
29503
29503
|
if (!("uuid" in i.attributes.details) || r.find((e) => e.name === "uuid")?.value) return t;
|
|
29504
29504
|
let a = i.attributes.details.uuid?.namespace, o = r.filter((e) => e.name !== "uuid");
|
|
@@ -29513,21 +29513,21 @@ function xa(e) {
|
|
|
29513
29513
|
}
|
|
29514
29514
|
//#endregion
|
|
29515
29515
|
//#region src/v2019C1/hooks/after-standardized-record/after-standardized-record.ts
|
|
29516
|
-
function
|
|
29517
|
-
return
|
|
29516
|
+
function ya(e) {
|
|
29517
|
+
return va(e);
|
|
29518
29518
|
}
|
|
29519
29519
|
//#endregion
|
|
29520
29520
|
//#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
|
|
29521
|
+
async function ba(e) {
|
|
29522
|
+
let { oldRecord: t, newRecord: n, query: r } = e, i = [], a = o(t), s = o(n), c = await $i(r, s);
|
|
29523
29523
|
c && i.push(c);
|
|
29524
|
-
let l = await
|
|
29524
|
+
let l = await oa({
|
|
29525
29525
|
oldRecord: a,
|
|
29526
29526
|
newRecord: s,
|
|
29527
29527
|
query: r
|
|
29528
29528
|
});
|
|
29529
29529
|
l && i.push(l);
|
|
29530
|
-
let u = await
|
|
29530
|
+
let u = await ea({
|
|
29531
29531
|
oldRecord: a,
|
|
29532
29532
|
newRecord: s,
|
|
29533
29533
|
query: r
|
|
@@ -29535,12 +29535,12 @@ async function Ca(e) {
|
|
|
29535
29535
|
i.push(...u);
|
|
29536
29536
|
let d = n.attributes.find((e) => e.name === "uuid")?.value;
|
|
29537
29537
|
if (d) {
|
|
29538
|
-
let e =
|
|
29538
|
+
let e = Xi(n.tagName), t = {
|
|
29539
29539
|
tagName: n.tagName,
|
|
29540
29540
|
id: n.id
|
|
29541
29541
|
};
|
|
29542
29542
|
for (let n of e) {
|
|
29543
|
-
let e = await
|
|
29543
|
+
let e = await Yi({
|
|
29544
29544
|
uuid: d,
|
|
29545
29545
|
entry: n,
|
|
29546
29546
|
target: t,
|
|
@@ -29549,8 +29549,8 @@ async function Ca(e) {
|
|
|
29549
29549
|
i.push(...e);
|
|
29550
29550
|
}
|
|
29551
29551
|
}
|
|
29552
|
-
if (
|
|
29553
|
-
let e = await
|
|
29552
|
+
if (xa(t, n)) {
|
|
29553
|
+
let e = await Sa({
|
|
29554
29554
|
newRecord: n,
|
|
29555
29555
|
query: r
|
|
29556
29556
|
});
|
|
@@ -29558,11 +29558,11 @@ async function Ca(e) {
|
|
|
29558
29558
|
}
|
|
29559
29559
|
return i;
|
|
29560
29560
|
}
|
|
29561
|
-
function
|
|
29562
|
-
for (let n of
|
|
29561
|
+
function xa(e, t) {
|
|
29562
|
+
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
29563
|
return !1;
|
|
29564
29564
|
}
|
|
29565
|
-
async function
|
|
29565
|
+
async function Sa(e) {
|
|
29566
29566
|
let { newRecord: t, query: n } = e, r = {
|
|
29567
29567
|
tagName: t.tagName,
|
|
29568
29568
|
id: t.id
|
|
@@ -29571,14 +29571,14 @@ async function Ta(e) {
|
|
|
29571
29571
|
if (r.id === t.id) continue;
|
|
29572
29572
|
let e = await n.any.getAttribute(r, { name: "uuid" });
|
|
29573
29573
|
if (!e) continue;
|
|
29574
|
-
let i =
|
|
29574
|
+
let i = Xi(r.tagName);
|
|
29575
29575
|
if (i.length === 0) continue;
|
|
29576
29576
|
let o = {
|
|
29577
29577
|
tagName: r.tagName,
|
|
29578
29578
|
id: r.id
|
|
29579
29579
|
};
|
|
29580
29580
|
for (let t of i) {
|
|
29581
|
-
let r = await
|
|
29581
|
+
let r = await Yi({
|
|
29582
29582
|
uuid: e,
|
|
29583
29583
|
entry: t,
|
|
29584
29584
|
target: o,
|
|
@@ -29591,18 +29591,18 @@ async function Ta(e) {
|
|
|
29591
29591
|
}
|
|
29592
29592
|
//#endregion
|
|
29593
29593
|
//#region src/v2019C1/hooks/after-updated/after-updated.ts
|
|
29594
|
-
async function
|
|
29595
|
-
return
|
|
29594
|
+
async function Ca(e) {
|
|
29595
|
+
return ba(e);
|
|
29596
29596
|
}
|
|
29597
29597
|
//#endregion
|
|
29598
29598
|
//#region src/v2019C1/hooks/before-clone/before-clone.ts
|
|
29599
|
-
var
|
|
29600
|
-
function
|
|
29601
|
-
return
|
|
29599
|
+
var wa = new Set(Object.values(b).map((e) => e.uri)), Ta = new Set(Object.values(b).map((e) => e.prefix).filter(Boolean));
|
|
29600
|
+
function Ea(e) {
|
|
29601
|
+
return wa.has(e.namespace.uri) && !n(e.tagName, x);
|
|
29602
29602
|
}
|
|
29603
|
-
function
|
|
29603
|
+
function Da(e) {
|
|
29604
29604
|
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 &&
|
|
29605
|
+
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
29606
|
let s = t.attributes.filter((e) => e.name !== "uuid");
|
|
29607
29607
|
return {
|
|
29608
29608
|
shouldBeCloned: r,
|
|
@@ -29614,17 +29614,17 @@ function Aa(e) {
|
|
|
29614
29614
|
}
|
|
29615
29615
|
//#endregion
|
|
29616
29616
|
//#region src/v2019C1/hooks/before-delete/orphaned-refs.ts
|
|
29617
|
-
async function
|
|
29617
|
+
async function Oa(e) {
|
|
29618
29618
|
let { record: t, query: n } = e, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
|
|
29619
|
-
if (await
|
|
29619
|
+
if (await Pa({
|
|
29620
29620
|
record: t,
|
|
29621
29621
|
query: n,
|
|
29622
29622
|
ids: r,
|
|
29623
29623
|
uuids: i
|
|
29624
29624
|
}), i.size === 0) return [];
|
|
29625
29625
|
let a = [];
|
|
29626
|
-
for (let e of
|
|
29627
|
-
let t = await
|
|
29626
|
+
for (let e of k) {
|
|
29627
|
+
let t = await ka({
|
|
29628
29628
|
refTagName: e,
|
|
29629
29629
|
subtreeIds: r,
|
|
29630
29630
|
subtreeUuids: i,
|
|
@@ -29634,11 +29634,11 @@ async function ja(e) {
|
|
|
29634
29634
|
}
|
|
29635
29635
|
return a;
|
|
29636
29636
|
}
|
|
29637
|
-
async function
|
|
29638
|
-
let { refTagName: t, subtreeIds: n, subtreeUuids: r, query: i } = e, a =
|
|
29637
|
+
async function ka(e) {
|
|
29638
|
+
let { refTagName: t, subtreeIds: n, subtreeUuids: r, query: i } = e, a = D[t], o = await i.getRecordsByTagName(t), s = [];
|
|
29639
29639
|
for (let e of o) {
|
|
29640
29640
|
if (n.has(e.id)) continue;
|
|
29641
|
-
let o = await
|
|
29641
|
+
let o = await Aa({
|
|
29642
29642
|
refTagName: t,
|
|
29643
29643
|
refRecord: e,
|
|
29644
29644
|
refPairs: a,
|
|
@@ -29649,15 +29649,15 @@ async function Ma(e) {
|
|
|
29649
29649
|
}
|
|
29650
29650
|
return s;
|
|
29651
29651
|
}
|
|
29652
|
-
async function
|
|
29653
|
-
let { refTagName: t, refRecord: n, refPairs: r, subtreeUuids: i, query: a } = e, o =
|
|
29652
|
+
async function Aa(e) {
|
|
29653
|
+
let { refTagName: t, refRecord: n, refPairs: r, subtreeUuids: i, query: a } = e, o = ja({
|
|
29654
29654
|
refPairs: r,
|
|
29655
29655
|
refRecord: n,
|
|
29656
29656
|
subtreeUuids: i
|
|
29657
29657
|
});
|
|
29658
|
-
return o.size === 0 ? [] :
|
|
29658
|
+
return o.size === 0 ? [] : O.has(t) ? [Ma(n, o)] : Na(n, a);
|
|
29659
29659
|
}
|
|
29660
|
-
function
|
|
29660
|
+
function ja(e) {
|
|
29661
29661
|
let { refPairs: t, refRecord: n, subtreeUuids: r } = e, i = /* @__PURE__ */ new Set();
|
|
29662
29662
|
for (let e of t) {
|
|
29663
29663
|
let t = n.attributes.find((t) => t.name === e.attribute.uuid)?.value;
|
|
@@ -29668,7 +29668,7 @@ function Pa(e) {
|
|
|
29668
29668
|
}
|
|
29669
29669
|
return i;
|
|
29670
29670
|
}
|
|
29671
|
-
function
|
|
29671
|
+
function Ma(e, t) {
|
|
29672
29672
|
let n = e.attributes.filter((e) => !t.has(e.name));
|
|
29673
29673
|
return {
|
|
29674
29674
|
status: "updated",
|
|
@@ -29679,7 +29679,7 @@ function Fa(e, t) {
|
|
|
29679
29679
|
})
|
|
29680
29680
|
};
|
|
29681
29681
|
}
|
|
29682
|
-
async function
|
|
29682
|
+
async function Na(e, t) {
|
|
29683
29683
|
let n = [{
|
|
29684
29684
|
status: "deleted",
|
|
29685
29685
|
oldRecord: i(e),
|
|
@@ -29701,14 +29701,14 @@ async function Ia(e, t) {
|
|
|
29701
29701
|
}
|
|
29702
29702
|
return n;
|
|
29703
29703
|
}
|
|
29704
|
-
async function
|
|
29704
|
+
async function Pa(e) {
|
|
29705
29705
|
let { record: t, query: n, ids: r, uuids: i } = e;
|
|
29706
29706
|
r.add(t.id);
|
|
29707
29707
|
let a = t.attributes.find((e) => e.name === "uuid")?.value;
|
|
29708
29708
|
a && i.add(a);
|
|
29709
29709
|
for (let e of t.children) {
|
|
29710
29710
|
let t = await n.getRecord(e);
|
|
29711
|
-
t && await
|
|
29711
|
+
t && await Pa({
|
|
29712
29712
|
record: t,
|
|
29713
29713
|
query: n,
|
|
29714
29714
|
ids: r,
|
|
@@ -29718,29 +29718,29 @@ async function La(e) {
|
|
|
29718
29718
|
}
|
|
29719
29719
|
//#endregion
|
|
29720
29720
|
//#region src/v2019C1/hooks/before-delete/before-delete.ts
|
|
29721
|
-
async function
|
|
29722
|
-
return
|
|
29721
|
+
async function Fa(e) {
|
|
29722
|
+
return Oa(e);
|
|
29723
29723
|
}
|
|
29724
29724
|
//#endregion
|
|
29725
29725
|
//#region src/v2019C1/hooks/io/io-hooks.ts
|
|
29726
|
-
function
|
|
29726
|
+
function Ia() {
|
|
29727
29727
|
let e = /* @__PURE__ */ new Map(), t = [], n = [];
|
|
29728
29728
|
return {
|
|
29729
29729
|
beforeImportRecord: (r) => {
|
|
29730
29730
|
let { record: i, ancestry: a } = r, { tagName: o } = i, s = i.attributes.find((e) => e.name === "uuid")?.value;
|
|
29731
29731
|
if (s && pe.has(o)) {
|
|
29732
|
-
let t =
|
|
29732
|
+
let t = ue({
|
|
29733
29733
|
record: i,
|
|
29734
29734
|
ancestry: a
|
|
29735
29735
|
});
|
|
29736
29736
|
t && e.set(t.path, s);
|
|
29737
29737
|
}
|
|
29738
29738
|
if (!A.has(o)) return;
|
|
29739
|
-
let c =
|
|
29739
|
+
let c = D[o];
|
|
29740
29740
|
for (let e of c) {
|
|
29741
29741
|
let r = i.attributes.find((t) => t.name === e.attribute.path)?.value;
|
|
29742
29742
|
if (!r || i.attributes.find((t) => t.name === e.attribute.uuid)?.value) continue;
|
|
29743
|
-
let s =
|
|
29743
|
+
let s = ge(e.resolution, e.attribute.path, r, a);
|
|
29744
29744
|
if (!s) {
|
|
29745
29745
|
e.resolution === M.unsupported && n.push({
|
|
29746
29746
|
type: "unsupported-xpath-reference",
|
|
@@ -29798,13 +29798,12 @@ function za() {
|
|
|
29798
29798
|
}
|
|
29799
29799
|
//#endregion
|
|
29800
29800
|
//#region src/v2019C1/hooks/index.ts
|
|
29801
|
-
var
|
|
29802
|
-
beforeClone:
|
|
29803
|
-
afterStandardizedRecord:
|
|
29804
|
-
afterCreated:
|
|
29805
|
-
|
|
29806
|
-
|
|
29807
|
-
beforeDelete: Ra
|
|
29801
|
+
var La = {
|
|
29802
|
+
beforeClone: Da,
|
|
29803
|
+
afterStandardizedRecord: ya,
|
|
29804
|
+
afterCreated: _a,
|
|
29805
|
+
afterUpdated: Ca,
|
|
29806
|
+
beforeDelete: Fa
|
|
29808
29807
|
};
|
|
29809
29808
|
//#endregion
|
|
29810
|
-
export { b as A, pe as C, y as D,
|
|
29809
|
+
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 };
|