@uipath/rules-tool 1.204.0-preview.255 → 1.205.0-preview.256
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/README.md +7 -5
- package/dist/DmnFactory-L7MABUC6-98k17dkr.js +46 -0
- package/dist/{KieDmnMarshaller-6TTUU5B4-47q50gk4.js → KieDmnMarshaller-LGE63WDG-3vemswef.js} +2 -2
- package/dist/THIRD-PARTY-NOTICES.md +26 -9
- package/dist/{business-rules-bnr581tz.js → business-rules-pm96sefm.js} +4 -4
- package/dist/{constants-9pa118cj.js → constants-cnn0jfw6.js} +18 -17
- package/dist/{embedded-file-reader-rf2g1kfj.js → embedded-file-reader-z4becc02.js} +2 -2
- package/dist/hitPolicyResult-CGCR73CW-9bmc4nsr.js +36 -0
- package/dist/index-52h8rpew.js +21 -0
- package/dist/index-bhjt1h5c.js +227 -0
- package/dist/{index-2hzp9b97.js → index-cpm94vee.js} +21 -5
- package/dist/index-x9msn1dj.js +85 -0
- package/dist/{index-4c4exdzw.js → index-ybrgtfsg.js} +576 -285
- package/dist/index.js +2 -2
- package/dist/rule-catalog-10fhgevc.js +74 -0
- package/dist/{rules-command-error-20gp2dv9.js → rules-command-error-k6kxwfn7.js} +2 -2
- package/dist/{rules-debug-service-var52vfc.js → rules-debug-service-h0qma8db.js} +19 -13
- package/dist/{rules-init-service-0jgj6m9d.js → rules-init-service-yda3k6ea.js} +7 -7
- package/dist/{rules-refresh-service-jgk2kq9d.js → rules-refresh-service-jn6my893.js} +3 -3
- package/dist/{rules-validate-service-mr2fk58k.js → rules-validate-service-hfw8m3dm.js} +7 -7
- package/dist/{tool-pm3ewdxc.js → tool-1pccj6q3.js} +4 -3
- package/dist/tool-86f1xpxn.js +51 -0
- package/dist/{tool-qsgp0kzq.js → tool-cexyd4ff.js} +17 -7
- package/dist/tool-cfrcyxgm.js +26 -0
- package/dist/{tool-av4mmsef.js → tool-fbmxx07c.js} +2 -2
- package/dist/{tool-2cky8jwp.js → tool-fbxe48wd.js} +1071 -208
- package/dist/tool-fk8rznma.js +827 -0
- package/dist/{tool-mkn83w88.js → tool-gkbr01gc.js} +3 -3
- package/dist/{tool-8h4er38s.js → tool-h7gn1rar.js} +3 -3
- package/dist/{tool-8qy8pkp4.js → tool-t4k013ex.js} +8 -5
- package/dist/tool-tjcg2xje.js +4616 -0
- package/dist/{tool-eymjx05p.js → tool-txp5th7j.js} +760 -3395
- package/dist/{tool-tkcx6png.js → tool-wf2qkrye.js} +25 -5
- package/dist/{tool-wmh645tm.js → tool-yq5jph4h.js} +169 -119
- package/dist/tool-z1ay3csx.js +176 -0
- package/dist/{tool-6a672gmg.js → tool-z6x97pps.js} +103 -63
- package/dist/tool.js +2 -2
- package/package.json +2 -2
- package/dist/DmnFactory-VWZOSZHH-jkpbxz3n.js +0 -42
- package/dist/hitPolicyResult-4WDHTX4A-gk103w84.js +0 -33
- package/dist/index-34pj9f36.js +0 -48
- package/dist/index-fs1nd5ap.js +0 -200
- package/dist/index-t4mx1a5e.js +0 -17
- package/dist/rule-catalog-5gzpe93c.js +0 -46
- package/dist/tool-19b4ect0.js +0 -754
- package/dist/tool-4dfpdepw.js +0 -55
- package/dist/tool-m41px07w.js +0 -49
|
@@ -1,44 +1,73 @@
|
|
|
1
1
|
import {
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
} from "./tool-
|
|
2
|
+
l,
|
|
3
|
+
m as m2
|
|
4
|
+
} from "./tool-cfrcyxgm.js";
|
|
5
|
+
import {
|
|
6
|
+
K as K2,
|
|
7
|
+
Q as Q2,
|
|
8
|
+
U as U2,
|
|
9
|
+
W,
|
|
10
|
+
X,
|
|
11
|
+
Y,
|
|
12
|
+
de,
|
|
13
|
+
ee as ee2,
|
|
14
|
+
ne as ne2,
|
|
15
|
+
pe
|
|
16
|
+
} from "./tool-tjcg2xje.js";
|
|
5
17
|
import {
|
|
6
18
|
$,
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
19
|
+
At,
|
|
20
|
+
Ui,
|
|
21
|
+
fe,
|
|
22
|
+
g as g2,
|
|
23
|
+
w
|
|
24
|
+
} from "./tool-fk8rznma.js";
|
|
12
25
|
import {
|
|
13
26
|
bs
|
|
14
|
-
} from "./tool-
|
|
27
|
+
} from "./tool-h7gn1rar.js";
|
|
15
28
|
import {
|
|
16
|
-
|
|
29
|
+
J as J2,
|
|
30
|
+
_e,
|
|
17
31
|
b,
|
|
32
|
+
c,
|
|
33
|
+
ee,
|
|
34
|
+
h,
|
|
35
|
+
me,
|
|
36
|
+
ne,
|
|
18
37
|
parser,
|
|
38
|
+
te,
|
|
19
39
|
trackVariables,
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
} from "./tool-wmh645tm.js";
|
|
40
|
+
xe
|
|
41
|
+
} from "./tool-yq5jph4h.js";
|
|
23
42
|
import {
|
|
24
43
|
A,
|
|
25
|
-
|
|
26
|
-
|
|
44
|
+
C,
|
|
45
|
+
E,
|
|
27
46
|
O,
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
47
|
+
S,
|
|
48
|
+
T,
|
|
49
|
+
f,
|
|
50
|
+
g,
|
|
32
51
|
m,
|
|
33
52
|
p,
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
} from "./tool-
|
|
53
|
+
u,
|
|
54
|
+
x
|
|
55
|
+
} from "./tool-86f1xpxn.js";
|
|
56
|
+
import"./tool-qgqscsjc.js";
|
|
57
|
+
import {
|
|
58
|
+
B,
|
|
59
|
+
G,
|
|
60
|
+
J,
|
|
61
|
+
K,
|
|
62
|
+
Q,
|
|
63
|
+
R,
|
|
64
|
+
U,
|
|
65
|
+
z
|
|
66
|
+
} from "./tool-z1ay3csx.js";
|
|
37
67
|
import {
|
|
38
68
|
e,
|
|
39
69
|
r
|
|
40
70
|
} from "./tool-jd313s2x.js";
|
|
41
|
-
import"./tool-qgqscsjc.js";
|
|
42
71
|
import"./tool-7haj67tr.js";
|
|
43
72
|
import"./tool-1de529jm.js";
|
|
44
73
|
|
|
@@ -178,7 +207,7 @@ function buildNestedEntries(variables, pathParts) {
|
|
|
178
207
|
}
|
|
179
208
|
function sortEntries(variable) {
|
|
180
209
|
if (variable.entries) {
|
|
181
|
-
variable.entries.sort((a,
|
|
210
|
+
variable.entries.sort((a, b2) => a.name.localeCompare(b2.name));
|
|
182
211
|
for (const entry of variable.entries) {
|
|
183
212
|
sortEntries(entry);
|
|
184
213
|
}
|
|
@@ -547,7 +576,7 @@ function analyzeForInputs(node, source, builtinNames) {
|
|
|
547
576
|
for (const variable of inputs) {
|
|
548
577
|
sortEntries(variable);
|
|
549
578
|
}
|
|
550
|
-
inputs.sort((a,
|
|
579
|
+
inputs.sort((a, b2) => a.name.localeCompare(b2.name));
|
|
551
580
|
return inputs;
|
|
552
581
|
}
|
|
553
582
|
var ITERATION_KEYWORDS = new Set(["for", "return", "some", "every", "InExpressions", "satisfies"]);
|
|
@@ -616,7 +645,7 @@ function analyzeForFunctions(node, source, builtinNames) {
|
|
|
616
645
|
forEachChild(n, walk);
|
|
617
646
|
};
|
|
618
647
|
walk(node);
|
|
619
|
-
return functions.sort((a,
|
|
648
|
+
return functions.sort((a, b2) => a.from - b2.from);
|
|
620
649
|
}
|
|
621
650
|
function analyzeForValidity(node) {
|
|
622
651
|
return !containsErrorNodes(node);
|
|
@@ -643,7 +672,7 @@ function createContext(variables) {
|
|
|
643
672
|
|
|
644
673
|
class FeelAnalyzer {
|
|
645
674
|
constructor(options = {}) {
|
|
646
|
-
this.builtinNames = new Set(options.builtins?.map((
|
|
675
|
+
this.builtinNames = new Set(options.builtins?.map((b2) => b2.name) ?? []);
|
|
647
676
|
const config = {
|
|
648
677
|
top: options.dialect === "unaryTests" ? "UnaryTests" : "Expression",
|
|
649
678
|
dialect: options.parserDialect
|
|
@@ -729,7 +758,7 @@ function requireRe() {
|
|
|
729
758
|
const src = exports$1.src = [];
|
|
730
759
|
const safeSrc = exports$1.safeSrc = [];
|
|
731
760
|
const t = exports$1.t = {};
|
|
732
|
-
let
|
|
761
|
+
let R2 = 0;
|
|
733
762
|
const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
|
|
734
763
|
const safeRegexReplacements = [
|
|
735
764
|
["\\s", 1],
|
|
@@ -744,7 +773,7 @@ function requireRe() {
|
|
|
744
773
|
};
|
|
745
774
|
const createToken = (name, value, isGlobal) => {
|
|
746
775
|
const safe = makeSafeRegex(value);
|
|
747
|
-
const index =
|
|
776
|
+
const index = R2++;
|
|
748
777
|
debug(name, index, value);
|
|
749
778
|
t[name] = index;
|
|
750
779
|
src[index] = value;
|
|
@@ -828,19 +857,19 @@ function requireIdentifiers() {
|
|
|
828
857
|
return identifiers;
|
|
829
858
|
hasRequiredIdentifiers = 1;
|
|
830
859
|
const numeric = /^[0-9]+$/;
|
|
831
|
-
const compareIdentifiers = (a,
|
|
832
|
-
if (typeof a === "number" && typeof
|
|
833
|
-
return a ===
|
|
860
|
+
const compareIdentifiers = (a, b2) => {
|
|
861
|
+
if (typeof a === "number" && typeof b2 === "number") {
|
|
862
|
+
return a === b2 ? 0 : a < b2 ? -1 : 1;
|
|
834
863
|
}
|
|
835
864
|
const anum = numeric.test(a);
|
|
836
|
-
const bnum = numeric.test(
|
|
865
|
+
const bnum = numeric.test(b2);
|
|
837
866
|
if (anum && bnum) {
|
|
838
867
|
a = +a;
|
|
839
|
-
|
|
868
|
+
b2 = +b2;
|
|
840
869
|
}
|
|
841
|
-
return a ===
|
|
870
|
+
return a === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b2 ? -1 : 1;
|
|
842
871
|
};
|
|
843
|
-
const rcompareIdentifiers = (a,
|
|
872
|
+
const rcompareIdentifiers = (a, b2) => compareIdentifiers(b2, a);
|
|
844
873
|
identifiers = {
|
|
845
874
|
compareIdentifiers,
|
|
846
875
|
rcompareIdentifiers
|
|
@@ -878,14 +907,14 @@ function requireSemver$1() {
|
|
|
878
907
|
this.options = options;
|
|
879
908
|
this.loose = !!options.loose;
|
|
880
909
|
this.includePrerelease = !!options.includePrerelease;
|
|
881
|
-
const
|
|
882
|
-
if (!
|
|
910
|
+
const m3 = version.trim().match(options.loose ? re2[t.LOOSE] : re2[t.FULL]);
|
|
911
|
+
if (!m3) {
|
|
883
912
|
throw new TypeError(`Invalid Version: ${version}`);
|
|
884
913
|
}
|
|
885
914
|
this.raw = version;
|
|
886
|
-
this.major = +
|
|
887
|
-
this.minor = +
|
|
888
|
-
this.patch = +
|
|
915
|
+
this.major = +m3[1];
|
|
916
|
+
this.minor = +m3[2];
|
|
917
|
+
this.patch = +m3[3];
|
|
889
918
|
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
|
890
919
|
throw new TypeError("Invalid major version");
|
|
891
920
|
}
|
|
@@ -895,10 +924,10 @@ function requireSemver$1() {
|
|
|
895
924
|
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
|
896
925
|
throw new TypeError("Invalid patch version");
|
|
897
926
|
}
|
|
898
|
-
if (!
|
|
927
|
+
if (!m3[4]) {
|
|
899
928
|
this.prerelease = [];
|
|
900
929
|
} else {
|
|
901
|
-
this.prerelease =
|
|
930
|
+
this.prerelease = m3[4].split(".").map((id) => {
|
|
902
931
|
if (/^[0-9]+$/.test(id)) {
|
|
903
932
|
const num = +id;
|
|
904
933
|
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
|
@@ -908,7 +937,7 @@ function requireSemver$1() {
|
|
|
908
937
|
return id;
|
|
909
938
|
});
|
|
910
939
|
}
|
|
911
|
-
this.build =
|
|
940
|
+
this.build = m3[5] ? m3[5].split(".") : [];
|
|
912
941
|
this.format();
|
|
913
942
|
}
|
|
914
943
|
format() {
|
|
@@ -972,18 +1001,18 @@ function requireSemver$1() {
|
|
|
972
1001
|
let i = 0;
|
|
973
1002
|
do {
|
|
974
1003
|
const a = this.prerelease[i];
|
|
975
|
-
const
|
|
976
|
-
debug("prerelease compare", i, a,
|
|
977
|
-
if (a === undefined &&
|
|
1004
|
+
const b2 = other.prerelease[i];
|
|
1005
|
+
debug("prerelease compare", i, a, b2);
|
|
1006
|
+
if (a === undefined && b2 === undefined) {
|
|
978
1007
|
return 0;
|
|
979
|
-
} else if (
|
|
1008
|
+
} else if (b2 === undefined) {
|
|
980
1009
|
return 1;
|
|
981
1010
|
} else if (a === undefined) {
|
|
982
1011
|
return -1;
|
|
983
|
-
} else if (a ===
|
|
1012
|
+
} else if (a === b2) {
|
|
984
1013
|
continue;
|
|
985
1014
|
} else {
|
|
986
|
-
return compareIdentifiers(a,
|
|
1015
|
+
return compareIdentifiers(a, b2);
|
|
987
1016
|
}
|
|
988
1017
|
} while (++i);
|
|
989
1018
|
}
|
|
@@ -994,18 +1023,18 @@ function requireSemver$1() {
|
|
|
994
1023
|
let i = 0;
|
|
995
1024
|
do {
|
|
996
1025
|
const a = this.build[i];
|
|
997
|
-
const
|
|
998
|
-
debug("build compare", i, a,
|
|
999
|
-
if (a === undefined &&
|
|
1026
|
+
const b2 = other.build[i];
|
|
1027
|
+
debug("build compare", i, a, b2);
|
|
1028
|
+
if (a === undefined && b2 === undefined) {
|
|
1000
1029
|
return 0;
|
|
1001
|
-
} else if (
|
|
1030
|
+
} else if (b2 === undefined) {
|
|
1002
1031
|
return 1;
|
|
1003
1032
|
} else if (a === undefined) {
|
|
1004
1033
|
return -1;
|
|
1005
|
-
} else if (a ===
|
|
1034
|
+
} else if (a === b2) {
|
|
1006
1035
|
continue;
|
|
1007
1036
|
} else {
|
|
1008
|
-
return compareIdentifiers(a,
|
|
1037
|
+
return compareIdentifiers(a, b2);
|
|
1009
1038
|
}
|
|
1010
1039
|
} while (++i);
|
|
1011
1040
|
}
|
|
@@ -1165,8 +1194,8 @@ function requireClean() {
|
|
|
1165
1194
|
hasRequiredClean = 1;
|
|
1166
1195
|
const parse = requireParse();
|
|
1167
1196
|
const clean = (version, options) => {
|
|
1168
|
-
const
|
|
1169
|
-
return
|
|
1197
|
+
const s = parse(version.trim().replace(/^[=v]+/, ""), options);
|
|
1198
|
+
return s ? s.version : null;
|
|
1170
1199
|
};
|
|
1171
1200
|
clean_1 = clean;
|
|
1172
1201
|
return clean_1;
|
|
@@ -1292,7 +1321,7 @@ function requireCompare() {
|
|
|
1292
1321
|
return compare_1;
|
|
1293
1322
|
hasRequiredCompare = 1;
|
|
1294
1323
|
const SemVer = requireSemver$1();
|
|
1295
|
-
const compare = (a,
|
|
1324
|
+
const compare = (a, b2, loose) => new SemVer(a, loose).compare(new SemVer(b2, loose));
|
|
1296
1325
|
compare_1 = compare;
|
|
1297
1326
|
return compare_1;
|
|
1298
1327
|
}
|
|
@@ -1303,7 +1332,7 @@ function requireRcompare() {
|
|
|
1303
1332
|
return rcompare_1;
|
|
1304
1333
|
hasRequiredRcompare = 1;
|
|
1305
1334
|
const compare = requireCompare();
|
|
1306
|
-
const rcompare = (a,
|
|
1335
|
+
const rcompare = (a, b2, loose) => compare(b2, a, loose);
|
|
1307
1336
|
rcompare_1 = rcompare;
|
|
1308
1337
|
return rcompare_1;
|
|
1309
1338
|
}
|
|
@@ -1314,7 +1343,7 @@ function requireCompareLoose() {
|
|
|
1314
1343
|
return compareLoose_1;
|
|
1315
1344
|
hasRequiredCompareLoose = 1;
|
|
1316
1345
|
const compare = requireCompare();
|
|
1317
|
-
const compareLoose = (a,
|
|
1346
|
+
const compareLoose = (a, b2) => compare(a, b2, true);
|
|
1318
1347
|
compareLoose_1 = compareLoose;
|
|
1319
1348
|
return compareLoose_1;
|
|
1320
1349
|
}
|
|
@@ -1325,9 +1354,9 @@ function requireCompareBuild() {
|
|
|
1325
1354
|
return compareBuild_1;
|
|
1326
1355
|
hasRequiredCompareBuild = 1;
|
|
1327
1356
|
const SemVer = requireSemver$1();
|
|
1328
|
-
const compareBuild = (a,
|
|
1357
|
+
const compareBuild = (a, b2, loose) => {
|
|
1329
1358
|
const versionA = new SemVer(a, loose);
|
|
1330
|
-
const versionB = new SemVer(
|
|
1359
|
+
const versionB = new SemVer(b2, loose);
|
|
1331
1360
|
return versionA.compare(versionB) || versionA.compareBuild(versionB);
|
|
1332
1361
|
};
|
|
1333
1362
|
compareBuild_1 = compareBuild;
|
|
@@ -1340,7 +1369,7 @@ function requireSort() {
|
|
|
1340
1369
|
return sort_1;
|
|
1341
1370
|
hasRequiredSort = 1;
|
|
1342
1371
|
const compareBuild = requireCompareBuild();
|
|
1343
|
-
const sort = (list, loose) => list.sort((a,
|
|
1372
|
+
const sort = (list, loose) => list.sort((a, b2) => compareBuild(a, b2, loose));
|
|
1344
1373
|
sort_1 = sort;
|
|
1345
1374
|
return sort_1;
|
|
1346
1375
|
}
|
|
@@ -1351,7 +1380,7 @@ function requireRsort() {
|
|
|
1351
1380
|
return rsort_1;
|
|
1352
1381
|
hasRequiredRsort = 1;
|
|
1353
1382
|
const compareBuild = requireCompareBuild();
|
|
1354
|
-
const rsort = (list, loose) => list.sort((a,
|
|
1383
|
+
const rsort = (list, loose) => list.sort((a, b2) => compareBuild(b2, a, loose));
|
|
1355
1384
|
rsort_1 = rsort;
|
|
1356
1385
|
return rsort_1;
|
|
1357
1386
|
}
|
|
@@ -1362,7 +1391,7 @@ function requireGt() {
|
|
|
1362
1391
|
return gt_1;
|
|
1363
1392
|
hasRequiredGt = 1;
|
|
1364
1393
|
const compare = requireCompare();
|
|
1365
|
-
const gt = (a,
|
|
1394
|
+
const gt = (a, b2, loose) => compare(a, b2, loose) > 0;
|
|
1366
1395
|
gt_1 = gt;
|
|
1367
1396
|
return gt_1;
|
|
1368
1397
|
}
|
|
@@ -1373,7 +1402,7 @@ function requireLt() {
|
|
|
1373
1402
|
return lt_1;
|
|
1374
1403
|
hasRequiredLt = 1;
|
|
1375
1404
|
const compare = requireCompare();
|
|
1376
|
-
const lt = (a,
|
|
1405
|
+
const lt = (a, b2, loose) => compare(a, b2, loose) < 0;
|
|
1377
1406
|
lt_1 = lt;
|
|
1378
1407
|
return lt_1;
|
|
1379
1408
|
}
|
|
@@ -1384,7 +1413,7 @@ function requireEq() {
|
|
|
1384
1413
|
return eq_1;
|
|
1385
1414
|
hasRequiredEq = 1;
|
|
1386
1415
|
const compare = requireCompare();
|
|
1387
|
-
const eq = (a,
|
|
1416
|
+
const eq = (a, b2, loose) => compare(a, b2, loose) === 0;
|
|
1388
1417
|
eq_1 = eq;
|
|
1389
1418
|
return eq_1;
|
|
1390
1419
|
}
|
|
@@ -1395,7 +1424,7 @@ function requireNeq() {
|
|
|
1395
1424
|
return neq_1;
|
|
1396
1425
|
hasRequiredNeq = 1;
|
|
1397
1426
|
const compare = requireCompare();
|
|
1398
|
-
const neq = (a,
|
|
1427
|
+
const neq = (a, b2, loose) => compare(a, b2, loose) !== 0;
|
|
1399
1428
|
neq_1 = neq;
|
|
1400
1429
|
return neq_1;
|
|
1401
1430
|
}
|
|
@@ -1406,7 +1435,7 @@ function requireGte() {
|
|
|
1406
1435
|
return gte_1;
|
|
1407
1436
|
hasRequiredGte = 1;
|
|
1408
1437
|
const compare = requireCompare();
|
|
1409
|
-
const gte = (a,
|
|
1438
|
+
const gte = (a, b2, loose) => compare(a, b2, loose) >= 0;
|
|
1410
1439
|
gte_1 = gte;
|
|
1411
1440
|
return gte_1;
|
|
1412
1441
|
}
|
|
@@ -1417,7 +1446,7 @@ function requireLte() {
|
|
|
1417
1446
|
return lte_1;
|
|
1418
1447
|
hasRequiredLte = 1;
|
|
1419
1448
|
const compare = requireCompare();
|
|
1420
|
-
const lte = (a,
|
|
1449
|
+
const lte = (a, b2, loose) => compare(a, b2, loose) <= 0;
|
|
1421
1450
|
lte_1 = lte;
|
|
1422
1451
|
return lte_1;
|
|
1423
1452
|
}
|
|
@@ -1433,38 +1462,38 @@ function requireCmp() {
|
|
|
1433
1462
|
const gte = requireGte();
|
|
1434
1463
|
const lt = requireLt();
|
|
1435
1464
|
const lte = requireLte();
|
|
1436
|
-
const cmp = (a, op,
|
|
1465
|
+
const cmp = (a, op, b2, loose) => {
|
|
1437
1466
|
switch (op) {
|
|
1438
1467
|
case "===":
|
|
1439
1468
|
if (typeof a === "object") {
|
|
1440
1469
|
a = a.version;
|
|
1441
1470
|
}
|
|
1442
|
-
if (typeof
|
|
1443
|
-
|
|
1471
|
+
if (typeof b2 === "object") {
|
|
1472
|
+
b2 = b2.version;
|
|
1444
1473
|
}
|
|
1445
|
-
return a ===
|
|
1474
|
+
return a === b2;
|
|
1446
1475
|
case "!==":
|
|
1447
1476
|
if (typeof a === "object") {
|
|
1448
1477
|
a = a.version;
|
|
1449
1478
|
}
|
|
1450
|
-
if (typeof
|
|
1451
|
-
|
|
1479
|
+
if (typeof b2 === "object") {
|
|
1480
|
+
b2 = b2.version;
|
|
1452
1481
|
}
|
|
1453
|
-
return a !==
|
|
1482
|
+
return a !== b2;
|
|
1454
1483
|
case "":
|
|
1455
1484
|
case "=":
|
|
1456
1485
|
case "==":
|
|
1457
|
-
return eq(a,
|
|
1486
|
+
return eq(a, b2, loose);
|
|
1458
1487
|
case "!=":
|
|
1459
|
-
return neq(a,
|
|
1488
|
+
return neq(a, b2, loose);
|
|
1460
1489
|
case ">":
|
|
1461
|
-
return gt(a,
|
|
1490
|
+
return gt(a, b2, loose);
|
|
1462
1491
|
case ">=":
|
|
1463
|
-
return gte(a,
|
|
1492
|
+
return gte(a, b2, loose);
|
|
1464
1493
|
case "<":
|
|
1465
|
-
return lt(a,
|
|
1494
|
+
return lt(a, b2, loose);
|
|
1466
1495
|
case "<=":
|
|
1467
|
-
return lte(a,
|
|
1496
|
+
return lte(a, b2, loose);
|
|
1468
1497
|
default:
|
|
1469
1498
|
throw new TypeError(`Invalid operator: ${op}`);
|
|
1470
1499
|
}
|
|
@@ -1752,20 +1781,20 @@ function requireRange() {
|
|
|
1752
1781
|
};
|
|
1753
1782
|
const replaceTilde = (comp, options) => {
|
|
1754
1783
|
const r2 = options.loose ? re2[t.TILDELOOSE] : re2[t.TILDE];
|
|
1755
|
-
return comp.replace(r2, (
|
|
1756
|
-
debug("tilde", comp,
|
|
1784
|
+
return comp.replace(r2, (_, M, m3, p2, pr) => {
|
|
1785
|
+
debug("tilde", comp, _, M, m3, p2, pr);
|
|
1757
1786
|
let ret;
|
|
1758
|
-
if (isX(
|
|
1787
|
+
if (isX(M)) {
|
|
1759
1788
|
ret = "";
|
|
1760
|
-
} else if (isX(
|
|
1761
|
-
ret = `>=${
|
|
1789
|
+
} else if (isX(m3)) {
|
|
1790
|
+
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
|
|
1762
1791
|
} else if (isX(p2)) {
|
|
1763
|
-
ret = `>=${
|
|
1792
|
+
ret = `>=${M}.${m3}.0 <${M}.${+m3 + 1}.0-0`;
|
|
1764
1793
|
} else if (pr) {
|
|
1765
1794
|
debug("replaceTilde pr", pr);
|
|
1766
|
-
ret = `>=${
|
|
1795
|
+
ret = `>=${M}.${m3}.${p2}-${pr} <${M}.${+m3 + 1}.0-0`;
|
|
1767
1796
|
} else {
|
|
1768
|
-
ret = `>=${
|
|
1797
|
+
ret = `>=${M}.${m3}.${p2} <${M}.${+m3 + 1}.0-0`;
|
|
1769
1798
|
}
|
|
1770
1799
|
debug("tilde return", ret);
|
|
1771
1800
|
return ret;
|
|
@@ -1777,41 +1806,41 @@ function requireRange() {
|
|
|
1777
1806
|
const replaceCaret = (comp, options) => {
|
|
1778
1807
|
debug("caret", comp, options);
|
|
1779
1808
|
const r2 = options.loose ? re2[t.CARETLOOSE] : re2[t.CARET];
|
|
1780
|
-
const
|
|
1781
|
-
return comp.replace(r2, (
|
|
1782
|
-
debug("caret", comp,
|
|
1809
|
+
const z2 = options.includePrerelease ? "-0" : "";
|
|
1810
|
+
return comp.replace(r2, (_, M, m3, p2, pr) => {
|
|
1811
|
+
debug("caret", comp, _, M, m3, p2, pr);
|
|
1783
1812
|
let ret;
|
|
1784
|
-
if (isX(
|
|
1813
|
+
if (isX(M)) {
|
|
1785
1814
|
ret = "";
|
|
1786
|
-
} else if (isX(
|
|
1787
|
-
ret = `>=${
|
|
1815
|
+
} else if (isX(m3)) {
|
|
1816
|
+
ret = `>=${M}.0.0${z2} <${+M + 1}.0.0-0`;
|
|
1788
1817
|
} else if (isX(p2)) {
|
|
1789
|
-
if (
|
|
1790
|
-
ret = `>=${
|
|
1818
|
+
if (M === "0") {
|
|
1819
|
+
ret = `>=${M}.${m3}.0${z2} <${M}.${+m3 + 1}.0-0`;
|
|
1791
1820
|
} else {
|
|
1792
|
-
ret = `>=${
|
|
1821
|
+
ret = `>=${M}.${m3}.0${z2} <${+M + 1}.0.0-0`;
|
|
1793
1822
|
}
|
|
1794
1823
|
} else if (pr) {
|
|
1795
1824
|
debug("replaceCaret pr", pr);
|
|
1796
|
-
if (
|
|
1797
|
-
if (
|
|
1798
|
-
ret = `>=${
|
|
1825
|
+
if (M === "0") {
|
|
1826
|
+
if (m3 === "0") {
|
|
1827
|
+
ret = `>=${M}.${m3}.${p2}-${pr} <${M}.${m3}.${+p2 + 1}-0`;
|
|
1799
1828
|
} else {
|
|
1800
|
-
ret = `>=${
|
|
1829
|
+
ret = `>=${M}.${m3}.${p2}-${pr} <${M}.${+m3 + 1}.0-0`;
|
|
1801
1830
|
}
|
|
1802
1831
|
} else {
|
|
1803
|
-
ret = `>=${
|
|
1832
|
+
ret = `>=${M}.${m3}.${p2}-${pr} <${+M + 1}.0.0-0`;
|
|
1804
1833
|
}
|
|
1805
1834
|
} else {
|
|
1806
1835
|
debug("no pr");
|
|
1807
|
-
if (
|
|
1808
|
-
if (
|
|
1809
|
-
ret = `>=${
|
|
1836
|
+
if (M === "0") {
|
|
1837
|
+
if (m3 === "0") {
|
|
1838
|
+
ret = `>=${M}.${m3}.${p2}${z2} <${M}.${m3}.${+p2 + 1}-0`;
|
|
1810
1839
|
} else {
|
|
1811
|
-
ret = `>=${
|
|
1840
|
+
ret = `>=${M}.${m3}.${p2}${z2} <${M}.${+m3 + 1}.0-0`;
|
|
1812
1841
|
}
|
|
1813
1842
|
} else {
|
|
1814
|
-
ret = `>=${
|
|
1843
|
+
ret = `>=${M}.${m3}.${p2} <${+M + 1}.0.0-0`;
|
|
1815
1844
|
}
|
|
1816
1845
|
}
|
|
1817
1846
|
debug("caret return", ret);
|
|
@@ -1825,10 +1854,10 @@ function requireRange() {
|
|
|
1825
1854
|
const replaceXRange = (comp, options) => {
|
|
1826
1855
|
comp = comp.trim();
|
|
1827
1856
|
const r2 = options.loose ? re2[t.XRANGELOOSE] : re2[t.XRANGE];
|
|
1828
|
-
return comp.replace(r2, (ret, gtlt,
|
|
1829
|
-
debug("xRange", comp, ret, gtlt,
|
|
1830
|
-
const xM = isX(
|
|
1831
|
-
const xm = xM || isX(
|
|
1857
|
+
return comp.replace(r2, (ret, gtlt, M, m3, p2, pr) => {
|
|
1858
|
+
debug("xRange", comp, ret, gtlt, M, m3, p2, pr);
|
|
1859
|
+
const xM = isX(M);
|
|
1860
|
+
const xm = xM || isX(m3);
|
|
1832
1861
|
const xp = xm || isX(p2);
|
|
1833
1862
|
const anyX = xp;
|
|
1834
1863
|
if (gtlt === "=" && anyX) {
|
|
@@ -1843,35 +1872,35 @@ function requireRange() {
|
|
|
1843
1872
|
}
|
|
1844
1873
|
} else if (gtlt && anyX) {
|
|
1845
1874
|
if (xm) {
|
|
1846
|
-
|
|
1875
|
+
m3 = 0;
|
|
1847
1876
|
}
|
|
1848
1877
|
p2 = 0;
|
|
1849
1878
|
if (gtlt === ">") {
|
|
1850
1879
|
gtlt = ">=";
|
|
1851
1880
|
if (xm) {
|
|
1852
|
-
|
|
1853
|
-
|
|
1881
|
+
M = +M + 1;
|
|
1882
|
+
m3 = 0;
|
|
1854
1883
|
p2 = 0;
|
|
1855
1884
|
} else {
|
|
1856
|
-
|
|
1885
|
+
m3 = +m3 + 1;
|
|
1857
1886
|
p2 = 0;
|
|
1858
1887
|
}
|
|
1859
1888
|
} else if (gtlt === "<=") {
|
|
1860
1889
|
gtlt = "<";
|
|
1861
1890
|
if (xm) {
|
|
1862
|
-
|
|
1891
|
+
M = +M + 1;
|
|
1863
1892
|
} else {
|
|
1864
|
-
|
|
1893
|
+
m3 = +m3 + 1;
|
|
1865
1894
|
}
|
|
1866
1895
|
}
|
|
1867
1896
|
if (gtlt === "<") {
|
|
1868
1897
|
pr = "-0";
|
|
1869
1898
|
}
|
|
1870
|
-
ret = `${gtlt +
|
|
1899
|
+
ret = `${gtlt + M}.${m3}.${p2}${pr}`;
|
|
1871
1900
|
} else if (xm) {
|
|
1872
|
-
ret = `>=${
|
|
1901
|
+
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
|
|
1873
1902
|
} else if (xp) {
|
|
1874
|
-
ret = `>=${
|
|
1903
|
+
ret = `>=${M}.${m3}.0${pr} <${M}.${+m3 + 1}.0-0`;
|
|
1875
1904
|
}
|
|
1876
1905
|
debug("xRange return", ret);
|
|
1877
1906
|
return ret;
|
|
@@ -1972,18 +2001,18 @@ function requireComparator() {
|
|
|
1972
2001
|
}
|
|
1973
2002
|
parse(comp) {
|
|
1974
2003
|
const r2 = this.options.loose ? re2[t.COMPARATORLOOSE] : re2[t.COMPARATOR];
|
|
1975
|
-
const
|
|
1976
|
-
if (!
|
|
2004
|
+
const m3 = comp.match(r2);
|
|
2005
|
+
if (!m3) {
|
|
1977
2006
|
throw new TypeError(`Invalid comparator: ${comp}`);
|
|
1978
2007
|
}
|
|
1979
|
-
this.operator =
|
|
2008
|
+
this.operator = m3[1] !== undefined ? m3[1] : "";
|
|
1980
2009
|
if (this.operator === "=") {
|
|
1981
2010
|
this.operator = "";
|
|
1982
2011
|
}
|
|
1983
|
-
if (!
|
|
2012
|
+
if (!m3[2]) {
|
|
1984
2013
|
this.semver = ANY;
|
|
1985
2014
|
} else {
|
|
1986
|
-
this.semver = new SemVer(
|
|
2015
|
+
this.semver = new SemVer(m3[2], this.options.loose);
|
|
1987
2016
|
}
|
|
1988
2017
|
}
|
|
1989
2018
|
toString() {
|
|
@@ -2335,7 +2364,7 @@ function requireSimplify() {
|
|
|
2335
2364
|
const set = [];
|
|
2336
2365
|
let first = null;
|
|
2337
2366
|
let prev = null;
|
|
2338
|
-
const v = versions.sort((a,
|
|
2367
|
+
const v = versions.sort((a, b2) => compare(a, b2, options));
|
|
2339
2368
|
for (const version of v) {
|
|
2340
2369
|
const included = satisfies(version, range2, options);
|
|
2341
2370
|
if (included) {
|
|
@@ -2521,19 +2550,19 @@ function requireSubset() {
|
|
|
2521
2550
|
}
|
|
2522
2551
|
return true;
|
|
2523
2552
|
};
|
|
2524
|
-
const higherGT = (a,
|
|
2553
|
+
const higherGT = (a, b2, options) => {
|
|
2525
2554
|
if (!a) {
|
|
2526
|
-
return
|
|
2555
|
+
return b2;
|
|
2527
2556
|
}
|
|
2528
|
-
const comp = compare(a.semver,
|
|
2529
|
-
return comp > 0 ? a : comp < 0 ?
|
|
2557
|
+
const comp = compare(a.semver, b2.semver, options);
|
|
2558
|
+
return comp > 0 ? a : comp < 0 ? b2 : b2.operator === ">" && a.operator === ">=" ? b2 : a;
|
|
2530
2559
|
};
|
|
2531
|
-
const lowerLT = (a,
|
|
2560
|
+
const lowerLT = (a, b2, options) => {
|
|
2532
2561
|
if (!a) {
|
|
2533
|
-
return
|
|
2562
|
+
return b2;
|
|
2534
2563
|
}
|
|
2535
|
-
const comp = compare(a.semver,
|
|
2536
|
-
return comp < 0 ? a : comp > 0 ?
|
|
2564
|
+
const comp = compare(a.semver, b2.semver, options);
|
|
2565
|
+
return comp < 0 ? a : comp > 0 ? b2 : b2.operator === "<" && a.operator === "<=" ? b2 : a;
|
|
2537
2566
|
};
|
|
2538
2567
|
subset_1 = subset;
|
|
2539
2568
|
return subset_1;
|
|
@@ -2718,7 +2747,7 @@ var firstItem = {
|
|
|
2718
2747
|
actions: [
|
|
2719
2748
|
{
|
|
2720
2749
|
name: "fix",
|
|
2721
|
-
apply(
|
|
2750
|
+
apply(_, start = from, end = to) {
|
|
2722
2751
|
context.updateContent(start, end, content.replace(zeroIndexPattern(), "[1]"));
|
|
2723
2752
|
}
|
|
2724
2753
|
}
|
|
@@ -2856,180 +2885,442 @@ function lintExpression(expression, {
|
|
|
2856
2885
|
}
|
|
2857
2886
|
|
|
2858
2887
|
// ../../node_modules/@uipath/dmn-editor-utils/dist/validation/index.js
|
|
2859
|
-
var
|
|
2860
|
-
var
|
|
2861
|
-
|
|
2862
|
-
|
|
2863
|
-
|
|
2864
|
-
|
|
2888
|
+
var yt = (e2, t) => e2.severity === t.severity ? 0 : e2.severity === "error" ? -1 : 1;
|
|
2889
|
+
var Tt = (e2) => e2.isCollection ? `list<${e2.components ? "context" : e2.baseTypeRef ?? "Any"}>` : e2.baseTypeRef;
|
|
2890
|
+
var qe = (e2) => {
|
|
2891
|
+
let t = B(e2);
|
|
2892
|
+
if (t)
|
|
2893
|
+
return { fieldlessType: t };
|
|
2894
|
+
let n = U(e2);
|
|
2895
|
+
return n ? { fieldlessType: n, fieldlessItems: true } : {};
|
|
2865
2896
|
};
|
|
2866
|
-
var
|
|
2867
|
-
|
|
2868
|
-
|
|
2869
|
-
|
|
2870
|
-
var
|
|
2871
|
-
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
|
|
2897
|
+
var He = (e2) => z(e2) ? [] : e2.components && !e2.recursive ? e2.components.map((t) => {
|
|
2898
|
+
let n = He(t.type), i = Tt(t.type);
|
|
2899
|
+
return { name: t.name, ...i ? { detail: i } : {}, ...n ? { entries: n } : {}, ...qe(t.type) };
|
|
2900
|
+
}) : undefined;
|
|
2901
|
+
var Z = (e2, t, n, i) => {
|
|
2902
|
+
let a = { name: e2, ...t ? { detail: t } : {} };
|
|
2903
|
+
if (i?.length)
|
|
2904
|
+
return { ...a, entries: i.map((m3) => Z(m3.name, m3.typeRef, n, m3.members)) };
|
|
2905
|
+
let s = J(n ?? {}, t), r2 = n && He(s);
|
|
2906
|
+
return { ...a, ...r2 ? { entries: r2 } : {}, ...qe(s) };
|
|
2875
2907
|
};
|
|
2876
|
-
var
|
|
2877
|
-
|
|
2878
|
-
|
|
2879
|
-
|
|
2880
|
-
|
|
2881
|
-
|
|
2882
|
-
|
|
2883
|
-
|
|
2884
|
-
|
|
2885
|
-
|
|
2886
|
-
|
|
2908
|
+
var B2 = (e2, t = [], n) => {
|
|
2909
|
+
let i = e2.filter((r2) => ne(r2)), a = i.map((r2) => Z(ne(r2), r2.typeRef, n)), s = new Set(i.map(ne));
|
|
2910
|
+
for (let r2 of t)
|
|
2911
|
+
s.has(r2.name) || (s.add(r2.name), a.push(Z(r2.name, r2.typeRef, n, r2.members)));
|
|
2912
|
+
return a;
|
|
2913
|
+
};
|
|
2914
|
+
var We = "DMN_INPUT_EXPRESSION_MISSING";
|
|
2915
|
+
var Et = ["error", "warning", "info"];
|
|
2916
|
+
var vt = (e2) => Et.includes(e2) ? e2 : "info";
|
|
2917
|
+
var It = (e2) => ({ from: e2.from, to: e2.to, severity: vt(e2.severity), message: e2.message });
|
|
2918
|
+
var ee3 = (e2, t, n = []) => lintExpression(e2, { dialect: t, variables: n }).map(It);
|
|
2919
|
+
var te2 = (e2, t) => {
|
|
2920
|
+
let n = e2.trim();
|
|
2921
|
+
return n === "" || t === "unaryTests" && n === "-";
|
|
2887
2922
|
};
|
|
2888
|
-
var
|
|
2889
|
-
var
|
|
2890
|
-
|
|
2891
|
-
|
|
2923
|
+
var ht = /"(?:\\[\s\S]|[^"\\])*"?|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\n]*|'/g;
|
|
2924
|
+
var Mt = (e2) => Array.from(e2.matchAll(ht), (t) => t[0] === "'" ? t.index : -1).filter((t) => t >= 0);
|
|
2925
|
+
var Xe = (e2, t) => {
|
|
2926
|
+
let n = new Set(t.filter((i) => i.severity === "error").map((i) => i.from));
|
|
2927
|
+
return Mt(e2).find((i) => n.has(i));
|
|
2928
|
+
};
|
|
2929
|
+
var I = (e2, t, n) => {
|
|
2930
|
+
if (te2(e2, t))
|
|
2931
|
+
return [];
|
|
2932
|
+
let i = ee3(e2, t, n), a = Xe(e2, i);
|
|
2933
|
+
return a !== undefined ? [{ code: "DMN_FEEL_SYNTAX", severity: "error", messageKey: "validation_feel_single_quote", range: { from: a, to: a + 1 } }] : i.map((s) => s.severity === "error" ? { code: "DMN_FEEL_SYNTAX", severity: "error", messageKey: "validation_feel_syntax", messageParams: { message: s.message }, range: { from: s.from, to: s.to } } : { code: "DMN_FEEL_LINT", severity: "warning", messageKey: "validation_feel_lint", messageParams: { message: s.message }, range: { from: s.from, to: s.to } });
|
|
2892
2934
|
};
|
|
2893
|
-
var
|
|
2894
|
-
|
|
2895
|
-
|
|
2896
|
-
|
|
2897
|
-
if (!
|
|
2935
|
+
var ne3 = { StringLiteral: "string", NumericLiteral: "number", BooleanLiteral: "boolean" };
|
|
2936
|
+
var je = { string: ["number", "boolean"], number: ["string", "boolean"], boolean: ["string", "number"] };
|
|
2937
|
+
var ie = (e2, t) => {
|
|
2938
|
+
let n = e2.trim();
|
|
2939
|
+
if (!n)
|
|
2898
2940
|
return;
|
|
2899
|
-
let
|
|
2900
|
-
return
|
|
2941
|
+
let i = c(n, t), a;
|
|
2942
|
+
return i.iterate({ enter(s) {
|
|
2943
|
+
s.from === 0 && s.to === n.length && (a = ne3[s.name] ?? a);
|
|
2944
|
+
} }), a;
|
|
2945
|
+
};
|
|
2946
|
+
var ze = (e2, t) => !e2 || !t || !je[e2].includes(R(t)) ? [] : [{ code: "DMN_TYPE_MISMATCH", severity: "error", messageKey: "validation_type_mismatch", messageParams: { literalType: e2, columnType: t } }];
|
|
2947
|
+
var bt = new Set([...Object.keys(ne3), "DateTimeLiteral", "null"]);
|
|
2948
|
+
var St = new Set(["UnaryTests", "PositiveUnaryTests", "PositiveUnaryTest", "SimplePositiveUnaryTest", "Interval", "Expression"]);
|
|
2949
|
+
var Ot = (e2) => {
|
|
2950
|
+
for (let t = e2;t; t = t.parent)
|
|
2951
|
+
if (t.name === "Interval")
|
|
2952
|
+
return true;
|
|
2953
|
+
return false;
|
|
2954
|
+
};
|
|
2955
|
+
var Pt = (e2) => {
|
|
2956
|
+
for (let t = e2;t; t = t.parent)
|
|
2957
|
+
if (!St.has(t.name))
|
|
2958
|
+
return false;
|
|
2959
|
+
return true;
|
|
2960
|
+
};
|
|
2961
|
+
var Rt = (e2, t) => {
|
|
2962
|
+
let n = e2.trim(), i = { operands: [], intervals: [] };
|
|
2963
|
+
if (!n)
|
|
2964
|
+
return i;
|
|
2965
|
+
let a = e2.length - e2.trimStart().length;
|
|
2966
|
+
return c(n, t).iterate({ enter(s) {
|
|
2967
|
+
if (!bt.has(s.name) && s.name !== "Interval" || !Pt(s.node.parent))
|
|
2968
|
+
return;
|
|
2969
|
+
let r2 = { from: a + s.from, to: a + s.to };
|
|
2970
|
+
if (s.name === "Interval") {
|
|
2971
|
+
Ot(s.node.parent) || i.intervals.push(r2);
|
|
2972
|
+
return;
|
|
2973
|
+
}
|
|
2974
|
+
i.operands.push({ nodeName: s.name, kind: ne3[s.name], ...r2 });
|
|
2975
|
+
} }), i;
|
|
2976
|
+
};
|
|
2977
|
+
var At2 = (e2) => {
|
|
2978
|
+
let t = R(e2);
|
|
2979
|
+
return t === "string" || t === "number" || t === "boolean" ? t : undefined;
|
|
2980
|
+
};
|
|
2981
|
+
var wt = new Set(["number", "string", "date", "time", "date and time", "dayTimeDuration", "yearMonthDuration"]);
|
|
2982
|
+
var xt = new Set(["boolean"]);
|
|
2983
|
+
var Lt = (e2) => {
|
|
2984
|
+
let t = R(e2);
|
|
2985
|
+
return wt.has(t) ? "ordered" : xt.has(t) ? "unordered" : "unknown";
|
|
2986
|
+
};
|
|
2987
|
+
var $e = (e2, t) => t.from >= e2.from && t.to <= e2.to;
|
|
2988
|
+
var se = (e2, t, n) => {
|
|
2989
|
+
if (!n || te2(e2, t))
|
|
2990
|
+
return [];
|
|
2991
|
+
let { operands: i, intervals: a } = Rt(e2, t), s = [], r2 = At2(n), m3 = Lt(n), u2 = m3 === "unordered" ? a : [];
|
|
2992
|
+
if (m3 === "unordered")
|
|
2993
|
+
for (let l2 of a)
|
|
2994
|
+
s.push({ code: "DMN_RANGE_NOT_ORDERED", severity: "error", messageKey: "validation_range_not_ordered", messageParams: { columnType: n }, range: l2 });
|
|
2995
|
+
else if (!r2)
|
|
2996
|
+
for (let l2 of a)
|
|
2997
|
+
new Set(i.filter((D) => $e(l2, D) && D.kind).map((D) => D.kind)).size > 1 && s.push({ code: "DMN_RANGE_ENDPOINT_TYPES", severity: "error", messageKey: "validation_range_endpoint_types", range: l2 });
|
|
2998
|
+
if (et.has(R(n))) {
|
|
2999
|
+
for (let l2 of i) {
|
|
3000
|
+
let _ = e2.slice(l2.from, l2.to), D = l2.nodeName === "null" ? "" : Y(_);
|
|
3001
|
+
l2.nodeName !== "null" && (D === undefined || !de(D, n)) && s.push({ code: "DMN_VALUE_NOT_VALID_FOR_TYPE", severity: "error", messageKey: "validation_value_not_valid_for_type", messageParams: { value: _, columnType: n }, range: { from: l2.from, to: l2.to } });
|
|
3002
|
+
}
|
|
3003
|
+
return s;
|
|
3004
|
+
}
|
|
3005
|
+
if (!r2)
|
|
3006
|
+
return s;
|
|
3007
|
+
for (let l2 of i)
|
|
3008
|
+
if (!(l2.nodeName === "null" || u2.some((_) => $e(_, l2)))) {
|
|
3009
|
+
if (r2 === "boolean") {
|
|
3010
|
+
l2.kind !== "boolean" && s.push({ code: "DMN_BOOLEAN_COLUMN_VALUE", severity: "error", messageKey: "validation_boolean_column_value", messageParams: { value: e2.slice(l2.from, l2.to) }, range: { from: l2.from, to: l2.to } });
|
|
3011
|
+
continue;
|
|
3012
|
+
}
|
|
3013
|
+
l2.kind && je[l2.kind].includes(r2) && s.push({ code: "DMN_TYPE_MISMATCH", severity: "error", messageKey: "validation_value_not_valid_for_type", messageParams: { value: e2.slice(l2.from, l2.to), columnType: n }, range: { from: l2.from, to: l2.to } });
|
|
3014
|
+
}
|
|
3015
|
+
return s;
|
|
3016
|
+
};
|
|
3017
|
+
var Je = (e2) => {
|
|
3018
|
+
let t = c(e2.trim(), "unaryTests").topNode, n = t.getChild("PositiveUnaryTests");
|
|
3019
|
+
return n && !t.getChild("not") ? n.getChildren("PositiveUnaryTest").length : 1;
|
|
2901
3020
|
};
|
|
2902
|
-
var
|
|
2903
|
-
let
|
|
2904
|
-
|
|
3021
|
+
var re2 = (e2) => {
|
|
3022
|
+
let t = ie(e2, "expression");
|
|
3023
|
+
return t ? Ct(t, e2) : Y(e2);
|
|
3024
|
+
};
|
|
3025
|
+
var Ze = (e2) => {
|
|
3026
|
+
let t = e2.trim(), n = c(t, "unaryTests").topNode, i = n.getChild("PositiveUnaryTests");
|
|
3027
|
+
if (!i || n.getChild("not"))
|
|
2905
3028
|
return;
|
|
2906
|
-
let
|
|
2907
|
-
for (let
|
|
2908
|
-
let
|
|
2909
|
-
if (
|
|
3029
|
+
let a = new Set;
|
|
3030
|
+
for (let s of i.getChildren("PositiveUnaryTest")) {
|
|
3031
|
+
let r2 = re2(t.slice(s.from, s.to));
|
|
3032
|
+
if (r2 === undefined)
|
|
2910
3033
|
return;
|
|
2911
|
-
|
|
3034
|
+
a.add(r2);
|
|
2912
3035
|
}
|
|
2913
|
-
return
|
|
3036
|
+
return a;
|
|
3037
|
+
};
|
|
3038
|
+
var Ct = (e2, t) => {
|
|
3039
|
+
let n = t.trim();
|
|
3040
|
+
return e2 === "number" ? Number(n.replace(/\s+/g, "")) : e2 === "string" ? X(n)[0] : n === "true";
|
|
3041
|
+
};
|
|
3042
|
+
var Ft = (e2, t) => t.results.has(e2) ? ["DMN_RESULT_NAME_REFERENCED", "validation_result_name_referenced"] : t.allowedValues?.has(e2) ? ["DMN_ALLOWED_VALUE_UNQUOTED", "validation_allowed_value_unquoted"] : ["DMN_UNKNOWN_NAME", "validation_unknown_name"];
|
|
3043
|
+
var et = new Set(["date", "time", "date and time", "dayTimeDuration", "yearMonthDuration"]);
|
|
3044
|
+
var tt = (e2, t, n = new Set) => {
|
|
3045
|
+
let i = R(t ?? "string");
|
|
3046
|
+
if (!(W(i) || i === "string"))
|
|
3047
|
+
return [];
|
|
3048
|
+
let a = (m3, u2) => {
|
|
3049
|
+
if (m3 === "null")
|
|
3050
|
+
return true;
|
|
3051
|
+
if (i === "string")
|
|
3052
|
+
return U2(m3);
|
|
3053
|
+
if (et.has(i)) {
|
|
3054
|
+
let l2 = Y(m3);
|
|
3055
|
+
return l2 !== undefined && de(l2, t);
|
|
3056
|
+
}
|
|
3057
|
+
return !U2(m3) && de(u2, t);
|
|
3058
|
+
}, s = (m3, u2, l2) => ({ code: "DMN_VALUE_NOT_VALID_FOR_TYPE", severity: "error", messageKey: "validation_value_not_valid_for_type", messageParams: { value: m3, columnType: t ?? i }, range: { from: u2, to: l2 } }), r2 = ee2(t);
|
|
3059
|
+
return Q2(e2).flatMap((m3) => {
|
|
3060
|
+
if (n.has(m3.token))
|
|
3061
|
+
return [];
|
|
3062
|
+
let u2 = r2 ? K2(m3.token) : undefined;
|
|
3063
|
+
return u2 ? u2.filter((l2) => !a(l2.text, l2.text)).map((l2) => s(l2.text, m3.from + l2.from, m3.from + l2.to)) : m3.value !== undefined && !a(m3.token, m3.value) ? [s(m3.token, m3.from, m3.to)] : [];
|
|
3064
|
+
});
|
|
3065
|
+
};
|
|
3066
|
+
var Ut = (e2, t, n) => {
|
|
3067
|
+
let i;
|
|
3068
|
+
return (a, s) => !a.includes("'") && e2[s - 1] !== "'" ? false : (i ??= Xe(e2, ee3(e2, t, Array.from(n, (r2) => ({ name: r2 })))) !== undefined, i);
|
|
3069
|
+
};
|
|
3070
|
+
var Vt = (e2, t, n) => e2.filter((i) => !t.known.has(i.name) && !n(i.name, i.from)).map((i) => {
|
|
3071
|
+
let [a, s] = Ft(i.name, t);
|
|
3072
|
+
return { code: a, messageKey: s, severity: "error", messageParams: { name: i.name }, range: { from: i.from, to: i.to } };
|
|
3073
|
+
});
|
|
3074
|
+
var Qe = new WeakMap;
|
|
3075
|
+
var kt = (e2) => {
|
|
3076
|
+
let t = Qe.get(e2);
|
|
3077
|
+
return t || (t = new Map(e2.map((n) => [n.name, n])), Qe.set(e2, t)), t;
|
|
2914
3078
|
};
|
|
2915
|
-
var
|
|
3079
|
+
var Kt = (e2, t, n) => {
|
|
3080
|
+
let i = kt(t), a = (s, r2) => {
|
|
3081
|
+
if (n(s.name, s.from))
|
|
3082
|
+
return;
|
|
3083
|
+
let m3 = { from: s.from, to: s.to };
|
|
3084
|
+
if (r2.fieldlessType) {
|
|
3085
|
+
let l2 = { name: s.name, parent: r2.name, type: r2.fieldlessType };
|
|
3086
|
+
return { code: "DMN_FIELD_OF_SINGLE_VALUE", severity: "error", messageKey: r2.fieldlessItems ? "validation_field_of_list_item" : "validation_field_of_single_value", messageParams: l2, range: m3 };
|
|
3087
|
+
}
|
|
3088
|
+
return { code: "DMN_UNKNOWN_MEMBER", severity: "error", messageKey: "validation_unknown_member", messageParams: { name: s.name, parent: r2.name }, range: m3 };
|
|
3089
|
+
};
|
|
3090
|
+
return e2.flatMap(({ segments: s }) => {
|
|
3091
|
+
let r2 = i.get(s[0].name);
|
|
3092
|
+
for (let m3 of s.slice(1)) {
|
|
3093
|
+
if (!r2 || !r2.entries && !r2.fieldlessType)
|
|
3094
|
+
return [];
|
|
3095
|
+
let u2 = r2.entries?.find((l2) => l2.name === m3.name);
|
|
3096
|
+
if (!u2) {
|
|
3097
|
+
let l2 = a(m3, r2);
|
|
3098
|
+
return l2 ? [l2] : [];
|
|
3099
|
+
}
|
|
3100
|
+
r2 = u2;
|
|
3101
|
+
}
|
|
3102
|
+
return [];
|
|
3103
|
+
});
|
|
3104
|
+
};
|
|
3105
|
+
var h2 = (e2, t, n, i) => {
|
|
3106
|
+
if (te2(e2, t))
|
|
3107
|
+
return [];
|
|
3108
|
+
let a = b(e2, t).filter((r2) => !r2.inFilterPredicate), s = Ut(e2, t, n.known);
|
|
3109
|
+
return [...Vt(a, n, s), ...Kt(a, i, s)];
|
|
3110
|
+
};
|
|
3111
|
+
var w2 = (e2) => e2.filter((t) => !ne(t)).map((t) => ({ code: "DMN_INPUT_DATA_NAME_MISSING", severity: "error", messageKey: "validation_input_data_name_missing", target: { kind: "inputData", inputDataId: t.id } }));
|
|
3112
|
+
var nt = (e2) => (e2.definitions.drgElement ?? []).flatMap((t) => {
|
|
3113
|
+
if (t.__$$element !== "inputData")
|
|
3114
|
+
return [];
|
|
3115
|
+
let n = { id: g2(t), name: t["@_name"], variableName: t.variable?.["@_name"] };
|
|
3116
|
+
return w2([n]).map((i) => ({ ...i, elementName: fe(t).trim() }));
|
|
3117
|
+
});
|
|
3118
|
+
var G2 = { kind: "document" };
|
|
3119
|
+
var Yt = (e2, t) => {
|
|
3120
|
+
let n = new Set;
|
|
3121
|
+
for (let i = G(e2, t);i && !i.components?.length; i = G(e2, i)) {
|
|
3122
|
+
if (i === t)
|
|
3123
|
+
return true;
|
|
3124
|
+
if (n.has(i))
|
|
3125
|
+
return false;
|
|
3126
|
+
n.add(i);
|
|
3127
|
+
}
|
|
3128
|
+
return false;
|
|
3129
|
+
};
|
|
3130
|
+
var st = (e2) => e2.typeRef === undefined && !e2.components?.length;
|
|
3131
|
+
var rt = (e2, t) => {
|
|
3132
|
+
let n = t.components ?? [], i = new Set;
|
|
3133
|
+
return n.flatMap((a) => {
|
|
3134
|
+
let s = i.has(a.name);
|
|
3135
|
+
return i.add(a.name), [...s ? [{ code: "DMN_ITEM_COMPONENT_DUPLICATE_NAME", severity: "error", messageKey: "validation_item_component_duplicate_name", messageParams: { type: e2, field: a.name }, target: G2 }] : [], ...h(a.name) ? [] : [{ code: "DMN_ITEM_COMPONENT_NAME_INVALID", severity: "error", messageKey: "validation_item_component_name_invalid", messageParams: { type: e2, field: a.name }, target: G2 }], ...st(a) ? [{ code: "DMN_ITEM_COMPONENT_EMPTY", severity: "warning", messageKey: "validation_item_component_empty", messageParams: { type: e2, field: a.name }, target: G2 }] : [], ...rt(e2, a)];
|
|
3136
|
+
});
|
|
3137
|
+
};
|
|
3138
|
+
var at = (e2) => e2.typeRef !== undefined && !!e2.components?.length || !!e2.components?.some(at);
|
|
3139
|
+
var it = new WeakMap;
|
|
3140
|
+
var M = (e2) => {
|
|
3141
|
+
let t = e2.itemDefinitions;
|
|
3142
|
+
if (!t)
|
|
3143
|
+
return [];
|
|
3144
|
+
let n = it.get(t);
|
|
3145
|
+
if (n && n.namespace === e2.namespace && n.namespaces === e2.namespaces)
|
|
3146
|
+
return [...n.diagnostics];
|
|
3147
|
+
let i = Bt(e2, t);
|
|
3148
|
+
return it.set(t, { namespace: e2.namespace, namespaces: e2.namespaces, diagnostics: i }), [...i];
|
|
3149
|
+
};
|
|
3150
|
+
var Bt = (e2, t) => {
|
|
3151
|
+
let n = new Set;
|
|
3152
|
+
return t.flatMap((i) => {
|
|
3153
|
+
let a = i.name, s = n.has(a);
|
|
3154
|
+
n.add(a);
|
|
3155
|
+
let r2 = (m3, u2) => ({ code: m3, severity: "error", messageKey: u2, messageParams: { type: a }, target: G2 });
|
|
3156
|
+
return [...s ? [r2("DMN_ITEM_DEFINITION_DUPLICATE_NAME", "validation_item_definition_duplicate_name")] : [], ...at(i) ? [r2("DMN_ITEM_DEFINITION_SIMPLE_AND_STRUCTURED", "validation_item_definition_simple_and_structured")] : [], ...Yt(e2, i) ? [r2("DMN_ITEM_DEFINITION_CYCLE", "validation_item_definition_cycle")] : [], ...st(i) ? [{ ...r2("DMN_ITEM_DEFINITION_EMPTY", "validation_item_definition_empty"), severity: "warning" }] : [], ...rt(a, i)];
|
|
3157
|
+
});
|
|
3158
|
+
};
|
|
3159
|
+
var ot = (e2, t, n, i, a) => {
|
|
3160
|
+
let s = { ...n, field: "allowedValues" }, r2 = (m3) => m3.map((u2) => ({ ...u2, target: s }));
|
|
3161
|
+
switch (pe(e2, t)) {
|
|
3162
|
+
case "none":
|
|
3163
|
+
return [];
|
|
3164
|
+
case "list":
|
|
3165
|
+
return r2(tt(e2.text, t, a.known));
|
|
3166
|
+
default: {
|
|
3167
|
+
let m3 = I(e2.text, "unaryTests", i), l2 = m3.some((_) => _.severity === "error") ? [] : se(e2.text, "unaryTests", t);
|
|
3168
|
+
return r2([...m3, ...h2(e2.text, "unaryTests", a, i), ...l2]);
|
|
3169
|
+
}
|
|
3170
|
+
}
|
|
3171
|
+
};
|
|
3172
|
+
var Gt = (e2, t, n) => !n || !g(n) || [t, n].some((i) => R(i) === "Any") ? true : T(e2, t) ? false : !g(t) || R(t) === R(n);
|
|
3173
|
+
var dt = (e2) => {
|
|
2916
3174
|
let t = e2.trim();
|
|
2917
|
-
return
|
|
3175
|
+
return t === "" || t === "-";
|
|
2918
3176
|
};
|
|
2919
|
-
var
|
|
2920
|
-
var
|
|
2921
|
-
var
|
|
2922
|
-
var
|
|
2923
|
-
|
|
2924
|
-
|
|
3177
|
+
var qt = (e2) => JSON.stringify(e2.inputEntries.map((t) => dt(t.text) ? null : t.text.trim()));
|
|
3178
|
+
var Ht = (e2) => ({ kind: "row", ruleId: e2 });
|
|
3179
|
+
var lt = "string";
|
|
3180
|
+
var Wt = new Set(["dayTimeDuration", "yearMonthDuration"]);
|
|
3181
|
+
var mt = (e2, t) => t ? ne2(e2.inputData, t) ?? e2.scopeVariables?.find((n) => n.name === t) : undefined;
|
|
3182
|
+
var ct = (e2, t) => {
|
|
3183
|
+
if (t.foreign)
|
|
3184
|
+
return { name: "Any", list: t.isCollection, structure: false };
|
|
3185
|
+
if (!t.recursive) {
|
|
3186
|
+
if (t.components) {
|
|
3187
|
+
let n = [...t.chain].reverse().find((a) => a.components?.length);
|
|
3188
|
+
return { name: n && e2.itemDefinitions?.includes(n) ? n.name : "context", list: t.isCollection, structure: true };
|
|
3189
|
+
}
|
|
3190
|
+
return t.baseTypeRef === undefined ? undefined : { name: t.baseTypeRef, list: t.isCollection, structure: false };
|
|
3191
|
+
}
|
|
3192
|
+
};
|
|
3193
|
+
var ut = (e2, t) => {
|
|
3194
|
+
let n = e2.structure && !!t?.structure && t.name !== e2.name;
|
|
3195
|
+
return l(e2.structure && !n ? "Any" : e2.name, e2.list);
|
|
3196
|
+
};
|
|
3197
|
+
var $t = (e2, t) => e2.structure && !t.structure && t.name === "Any" && e2.list === t.list || e2.structure === t.structure && e2.name === t.name && e2.list === t.list;
|
|
3198
|
+
var Qt = (e2, t) => {
|
|
3199
|
+
let n = t.trim(), i = mt(e2, n);
|
|
3200
|
+
if (i)
|
|
3201
|
+
return J(e2, i.typeRef);
|
|
3202
|
+
let a = me(n, "expression"), s = _e(n);
|
|
3203
|
+
if (a.length !== 1 || a[0] !== s)
|
|
3204
|
+
return;
|
|
3205
|
+
let [r2, ...m3] = s.split("."), u2 = m3.length ? mt(e2, r2) : undefined;
|
|
3206
|
+
if (u2)
|
|
3207
|
+
return K(J(e2, u2.typeRef), m3).type;
|
|
2925
3208
|
};
|
|
2926
|
-
var
|
|
2927
|
-
|
|
2928
|
-
|
|
2929
|
-
|
|
2930
|
-
|
|
2931
|
-
|
|
2932
|
-
|
|
2933
|
-
let { aggregation: n } = e2;
|
|
2934
|
-
e2.outputs.forEach((p2) => {
|
|
2935
|
-
let d = p(i, p2);
|
|
2936
|
-
d && !M(i, n, p2) && t.push({ code: "DMN_COLLECT_AGGREGATION_TYPE", severity: "error", messageKey: "validation_collect_aggregation_type", messageParams: { aggregation: n, typeRef: d }, target: { kind: "output", outputId: p2.id } });
|
|
3209
|
+
var ae = (e2) => {
|
|
3210
|
+
let t = e2.decision.decisionTable, n = [], i = B2(e2.inputData, e2.scopeVariables, e2), a = new Set(i.map((o) => o.name)), s = te(e2.decision.variableName, e2.decision.name), r2 = new Set([s, ...t.outputs.map((o, c2) => ee(o, c2))]), m3 = (o) => new Set(o ? X(o.text) : []), u2 = t.inputs.map((o) => m3(o.allowedValues)), l2 = t.outputs.map((o) => m3(A(e2, o)));
|
|
3211
|
+
if (e2.decision.name.trim() || n.push({ code: "DMN_DECISION_NAME_MISSING", severity: "error", messageKey: "validation_decision_name_missing", target: { kind: "decision" } }), t.rules.length === 0 && n.push({ code: "DMN_NO_RULES", severity: "warning", messageKey: "validation_no_rules", target: { kind: "decision" } }), t.hitPolicy === e.Collect && t.aggregation) {
|
|
3212
|
+
let { aggregation: o } = t;
|
|
3213
|
+
t.outputs.forEach((f2) => {
|
|
3214
|
+
let g3 = p(e2, f2);
|
|
3215
|
+
g3 && !S(e2, o, f2) && n.push({ code: "DMN_COLLECT_AGGREGATION_TYPE", severity: "error", messageKey: "validation_collect_aggregation_type", messageParams: { aggregation: o, typeRef: g3 }, target: { kind: "output", outputId: f2.id } });
|
|
2937
3216
|
});
|
|
2938
|
-
let
|
|
2939
|
-
!!
|
|
3217
|
+
let c2 = e2.decision.variableTypeRef, d = t.outputs.length === 1, p2 = u(e2, c2);
|
|
3218
|
+
!!c2 && (d ? !Gt(e2, c2, u(e2, C(o, t.outputs[0]))) : T(e2, c2) || !!p2 && g(p2) && p2 !== "Any") && n.push({ code: "DMN_AGGREGATION_RESULT_TYPE", severity: d ? "warning" : "error", messageKey: "validation_aggregation_result_type", messageParams: { aggregation: o, typeRef: c2 }, target: { kind: "decision" } });
|
|
2940
3219
|
}
|
|
2941
|
-
if (
|
|
2942
|
-
let
|
|
2943
|
-
|
|
3220
|
+
if (m.has(t.hitPolicy)) {
|
|
3221
|
+
let o = t.outputs.flatMap((c2) => A(e2, c2) ?? []);
|
|
3222
|
+
o.length === 0 ? n.push({ code: "DMN_RANKED_OUTPUT_VALUES_MISSING", severity: "error", messageKey: "validation_ranked_output_values_missing", messageParams: { hitPolicy: t.hitPolicy }, target: { kind: "decision" } }) : o.every((c2) => Je(c2.text) < 2) && n.push({ code: "DMN_RANKED_OUTPUT_VALUES_SINGLE", severity: "warning", messageKey: "validation_ranked_output_values_single", messageParams: { hitPolicy: t.hitPolicy }, target: { kind: "decision" } });
|
|
2944
3223
|
}
|
|
2945
|
-
let
|
|
2946
|
-
|
|
2947
|
-
let
|
|
2948
|
-
|
|
2949
|
-
let
|
|
2950
|
-
|
|
2951
|
-
}),
|
|
2952
|
-
let
|
|
2953
|
-
|
|
2954
|
-
let
|
|
2955
|
-
|
|
2956
|
-
|
|
2957
|
-
|
|
2958
|
-
|
|
3224
|
+
let _ = e2.decision.variableTypeRef;
|
|
3225
|
+
O(t) === "list" && _ && x(e2, _) && n.push({ code: "DMN_LIST_RESULT_TYPE", severity: "error", messageKey: "validation_list_result_type", messageParams: { hitPolicy: t.hitPolicy, typeRef: _ }, target: { kind: "decision" } });
|
|
3226
|
+
let D = new Map;
|
|
3227
|
+
t.outputs.forEach((o, c2) => {
|
|
3228
|
+
let d = ee(o, c2);
|
|
3229
|
+
D.set(d, (D.get(d) ?? 0) + 1);
|
|
3230
|
+
}), t.inputs.forEach((o, c2) => {
|
|
3231
|
+
let p2 = { ...{ kind: "input", inputId: o.id }, field: "expression" };
|
|
3232
|
+
o.expressionText.trim() || n.push({ code: We, severity: "error", messageKey: "validation_input_expression_missing", target: p2 }), n.push(...[...I(o.expressionText, "expression", i), ...h2(o.expressionText, "expression", { known: a, results: r2 }, i)].map((y) => ({ ...y, target: p2 })));
|
|
3233
|
+
let b2 = Qt(e2, o.expressionText), f2 = b2 && ct(e2, b2), g3 = o.typeRef ? ct(e2, J(e2, o.typeRef)) : { name: lt, list: false, structure: false };
|
|
3234
|
+
if (!!f2 && (f2.structure || f2.name !== "Any" && r.includes(f2.name)) && (g3 ? !$t(f2, g3) : !f2.structure)) {
|
|
3235
|
+
let y = !f2.structure && !f2.list && f2.name === "string" && !!g3 && !g3.list && Wt.has(g3.name);
|
|
3236
|
+
n.push({ code: "DMN_COLUMN_TYPE_MISMATCH", severity: "error", messageKey: y ? "validation_column_type_mismatch_duration" : "validation_column_type_mismatch", messageParams: { name: o.expressionText.trim(), declared: ut(f2, g3), column: g3 ? ut(g3, f2) : u(e2, o.typeRef) ?? lt }, target: p2 });
|
|
3237
|
+
}
|
|
3238
|
+
if (o.allowedValues) {
|
|
3239
|
+
let y = E(e2, o.typeRef), S2 = { known: a, results: r2, allowedValues: u2[c2] };
|
|
3240
|
+
n.push(...ot(o.allowedValues, y, { kind: "input", inputId: o.id }, i, S2));
|
|
3241
|
+
}
|
|
3242
|
+
}), t.outputs.forEach((o, c2) => {
|
|
3243
|
+
let d = { kind: "output", outputId: o.id }, p2 = ee(o, c2);
|
|
3244
|
+
(D.get(p2) ?? 0) > 1 && n.push({ code: "DMN_DUPLICATE_OUTPUT_NAME", severity: "error", messageKey: "validation_duplicate_output_name", messageParams: { name: p2 }, target: d }), o.name?.trim() ? J2(o.name.trim()) || n.push({ code: "DMN_OUTPUT_NAME_INVALID", severity: "error", messageKey: "validation_output_name_invalid", messageParams: { name: o.name.trim() }, target: d }) : t.outputs.length > 1 && n.push({ code: "DMN_OUTPUT_NAME_MISSING", severity: "error", messageKey: "validation_output_name_missing", target: d }), o.allowedValues && n.push(...ot(o.allowedValues, E(e2, p(e2, o)), { kind: "output", outputId: o.id }, i, { known: a, results: r2, allowedValues: l2[c2] }));
|
|
2959
3245
|
});
|
|
2960
|
-
let
|
|
2961
|
-
|
|
2962
|
-
|
|
2963
|
-
|
|
2964
|
-
|
|
2965
|
-
|
|
2966
|
-
|
|
3246
|
+
let pt = new Set((e2.scopeVariables ?? []).map((o) => o.name)), ft = xe(t);
|
|
3247
|
+
n.push(...w2(e2.inputData));
|
|
3248
|
+
let le = e2.inputData.filter((o) => ne(o)), q = new Map;
|
|
3249
|
+
le.forEach((o) => {
|
|
3250
|
+
let c2 = ne(o);
|
|
3251
|
+
q.set(c2, (q.get(c2) ?? 0) + 1);
|
|
3252
|
+
}), le.forEach((o) => {
|
|
3253
|
+
let c2 = ne(o), d = { kind: "inputData", inputDataId: o.id };
|
|
3254
|
+
(q.get(c2) ?? 0) > 1 || c2 === s ? n.push({ code: "DMN_DUPLICATE_INPUT_DATA_NAME", severity: "error", messageKey: "validation_duplicate_input_data_name", messageParams: { name: c2 }, target: d }) : pt.has(c2) && n.push({ code: "DMN_INPUT_DATA_SHADOWS_DECISION", severity: "error", messageKey: "validation_input_data_shadows_decision", messageParams: { name: c2 }, target: d }), h(c2) || n.push({ code: "DMN_INPUT_DATA_NAME_INVALID", severity: "error", messageKey: "validation_input_data_name_invalid", messageParams: { name: c2 }, target: d }), !o.requirementId && ft.has(c2) && n.push({ code: "DMN_MISSING_REQUIREMENT", severity: "error", messageKey: "validation_missing_requirement", messageParams: { name: c2 }, target: d });
|
|
2967
3255
|
});
|
|
2968
|
-
let
|
|
2969
|
-
let
|
|
2970
|
-
return
|
|
2971
|
-
}),
|
|
2972
|
-
return
|
|
2973
|
-
let
|
|
2974
|
-
if ((
|
|
2975
|
-
let
|
|
2976
|
-
|
|
2977
|
-
}
|
|
2978
|
-
let
|
|
2979
|
-
for (let { entries:
|
|
2980
|
-
|
|
2981
|
-
let
|
|
2982
|
-
if (!
|
|
3256
|
+
let gt = t.outputs.map((o) => {
|
|
3257
|
+
let c2 = A(e2, o);
|
|
3258
|
+
return c2 && Ze(c2.text);
|
|
3259
|
+
}), me2 = t.outputs.map(() => 0), ce = new Set, ue = false;
|
|
3260
|
+
return t.rules.forEach((o) => {
|
|
3261
|
+
let c2 = Ht(o.id);
|
|
3262
|
+
if ((o.inputEntries.length !== t.inputs.length || o.outputEntries.length !== t.outputs.length) && n.push({ code: "DMN_RULE_ENTRY_COUNT", severity: "error", messageKey: "validation_rule_entry_count", target: c2 }), t.hitPolicy === e.First && (ue ? n.push({ code: "DMN_UNREACHABLE_RULE", severity: "warning", messageKey: "validation_unreachable_rule", target: c2 }) : o.inputEntries.every((p2) => dt(p2.text)) && (ue = true)), !f.has(t.hitPolicy)) {
|
|
3263
|
+
let p2 = qt(o);
|
|
3264
|
+
ce.has(p2) ? n.push({ code: "DMN_DUPLICATE_RULE", severity: "warning", messageKey: "validation_duplicate_rule", target: c2 }) : ce.add(p2);
|
|
3265
|
+
}
|
|
3266
|
+
let d = [{ entries: o.inputEntries, columns: t.inputs, literals: u2, dialect: "unaryTests" }, { entries: o.outputEntries, columns: t.outputs, literals: l2, dialect: "expression" }];
|
|
3267
|
+
for (let { entries: p2, columns: b2, literals: f2, dialect: g3 } of d)
|
|
3268
|
+
p2.forEach((E2, y) => {
|
|
3269
|
+
let S2 = b2[y];
|
|
3270
|
+
if (!S2)
|
|
2983
3271
|
return;
|
|
2984
|
-
let
|
|
2985
|
-
|
|
3272
|
+
let de2 = { kind: "cell", ruleId: o.id, columnId: S2.id }, H = I(E2.text, g3, i), W2 = g3 === "expression" && !H.some((O2) => O2.severity === "error") ? gt[y] : undefined, pe2 = W2 ? re2(E2.text) : undefined, fe2 = H.some((O2) => O2.severity === "error") ? [] : se(E2.text, g3, E(e2, S2.typeRef)), _t = [...H, ...h2(E2.text, g3, { known: a, results: r2, allowedValues: f2[y] }, i), ...fe2];
|
|
3273
|
+
n.push(..._t.map((O2) => ({ ...O2, target: de2 }))), !(!W2 || !E2.text.trim()) && (pe2 === undefined ? me2[y] += 1 : fe2.length === 0 && !W2.has(pe2) && n.push({ code: "DMN_OUTPUT_VALUE_NOT_ALLOWED", severity: "error", messageKey: "validation_output_value_not_allowed", messageParams: { value: E2.text.trim() }, target: de2 }));
|
|
2986
3274
|
});
|
|
2987
|
-
}),
|
|
2988
|
-
let
|
|
2989
|
-
|
|
2990
|
-
}),
|
|
3275
|
+
}), t.outputs.forEach((o, c2) => {
|
|
3276
|
+
let d = me2[c2];
|
|
3277
|
+
d > 0 && n.push({ code: "DMN_OUTPUT_VALUE_UNCHECKED", severity: "warning", messageKey: "validation_output_value_unchecked", messageParams: { count: d }, target: { kind: "output", outputId: o.id, field: "allowedValues" } });
|
|
3278
|
+
}), n.push(...M(e2)), n;
|
|
2991
3279
|
};
|
|
2992
|
-
var
|
|
2993
|
-
let { literalExpression:
|
|
2994
|
-
if (
|
|
2995
|
-
return
|
|
2996
|
-
|
|
2997
|
-
let
|
|
2998
|
-
return
|
|
3280
|
+
var oe = (e2) => {
|
|
3281
|
+
let { literalExpression: t } = e2.decision, n = M(e2), i = { kind: "decision" }, a = B2(e2.inputData, e2.scopeVariables, e2);
|
|
3282
|
+
if (e2.decision.name.trim() || n.push({ code: "DMN_DECISION_NAME_MISSING", severity: "error", messageKey: "validation_decision_name_missing", target: i }), n.push(...w2(e2.inputData)), !t.text.trim())
|
|
3283
|
+
return n.push({ code: "DMN_LITERAL_EXPRESSION_EMPTY", severity: "error", messageKey: "validation_literal_expression_empty", target: i }), n;
|
|
3284
|
+
t.typeRef || n.push({ code: "DMN_LITERAL_EXPRESSION_TYPE_MISSING", severity: "warning", messageKey: "validation_literal_expression_type_missing", target: i });
|
|
3285
|
+
let s = new Set(a.map((r2) => r2.name));
|
|
3286
|
+
return n.push(...[...I(t.text, "expression", a), ...h2(t.text, "expression", { known: s, results: new Set([te(e2.decision.variableName, e2.decision.name)]) }, a), ...ze(ie(t.text, "expression"), t.typeRef)].map((r2) => ({ ...r2, target: i }))), n;
|
|
2999
3287
|
};
|
|
3000
|
-
var
|
|
3001
|
-
var
|
|
3002
|
-
var
|
|
3003
|
-
let
|
|
3004
|
-
if (!
|
|
3288
|
+
var Xt = new Set(["invalid-xml", "unsafe-xml", "migration-failed", "unsupported-version"]);
|
|
3289
|
+
var jt = (e2) => Xt.has(e2) ? { code: "DMN_DOCUMENT_UNREADABLE", severity: "error", messageKey: "validation_document_unreadable", target: { kind: "document" } } : null;
|
|
3290
|
+
var zt = (e2) => {
|
|
3291
|
+
let t = e2.definitions.drgElement ?? [], n = new Set(t.filter((r2) => r2.__$$element === "inputData").map(g2)), i = new Set(t.filter((r2) => r2.__$$element === "decision").map(g2)), a = (r2, m3) => {
|
|
3292
|
+
if (!r2)
|
|
3005
3293
|
return false;
|
|
3006
|
-
let
|
|
3007
|
-
return
|
|
3294
|
+
let u2 = r2["@_href"], l2 = $(u2);
|
|
3295
|
+
return l2 !== undefined ? !m3.has(l2) : !u2;
|
|
3008
3296
|
};
|
|
3009
|
-
return
|
|
3297
|
+
return t.filter((r2) => r2.__$$element === "decision").some((r2) => (r2.informationRequirement ?? []).some((m3) => a(m3.requiredInput, n) || a(m3.requiredDecision, i))) ? [{ code: "DMN_DANGLING_REQUIREMENT", severity: "error", messageKey: "validation_dangling_requirement", target: { kind: "document" } }] : [];
|
|
3010
3298
|
};
|
|
3011
|
-
var
|
|
3012
|
-
let
|
|
3013
|
-
if (
|
|
3014
|
-
let
|
|
3015
|
-
return
|
|
3299
|
+
var Jt = async (e2, t) => {
|
|
3300
|
+
let n = await bs(e2);
|
|
3301
|
+
if (n.status === "error") {
|
|
3302
|
+
let s = jt(n.reason);
|
|
3303
|
+
return s ? [s] : [];
|
|
3016
3304
|
}
|
|
3017
|
-
let
|
|
3018
|
-
if (
|
|
3019
|
-
return
|
|
3020
|
-
if (
|
|
3021
|
-
let
|
|
3022
|
-
if (
|
|
3023
|
-
return
|
|
3305
|
+
let i = zt(n.document);
|
|
3306
|
+
if (i.length > 0)
|
|
3307
|
+
return i;
|
|
3308
|
+
if (w(n.document.definitions).length === 1) {
|
|
3309
|
+
let s = t?.kind === "decision-table" ? t : await At(e2);
|
|
3310
|
+
if (s.kind === "decision-table")
|
|
3311
|
+
return i.push(...ae(s.model)), i;
|
|
3024
3312
|
}
|
|
3025
|
-
let
|
|
3026
|
-
return
|
|
3313
|
+
let a = Ui(n.document);
|
|
3314
|
+
return a ? i.push(...oe(a)) : i.push(...nt(n.document), ...M(Q(n.document.definitions))), i;
|
|
3027
3315
|
};
|
|
3028
3316
|
export {
|
|
3029
|
-
|
|
3030
|
-
|
|
3031
|
-
|
|
3032
|
-
|
|
3317
|
+
yt as bySeverityWorstFirst,
|
|
3318
|
+
J2 as isFeelIdentifier,
|
|
3319
|
+
h as isFeelVariableName,
|
|
3320
|
+
m2 as localizedMessageParams,
|
|
3321
|
+
ae as validateDecisionTableModel,
|
|
3322
|
+
Jt as validateDmnDocument,
|
|
3323
|
+
oe as validateLiteralExpressionModel
|
|
3033
3324
|
};
|
|
3034
3325
|
|
|
3035
|
-
//# debugId=
|
|
3326
|
+
//# debugId=2D8B75C4B292421F64756E2164756E21
|