@cardenelabs/dragon 0.41.1 → 0.42.0
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 +21 -1
- package/dist/cli.cjs +4094 -961
- package/dist/cli.cjs.map +1 -1
- package/dist/cli.js +4094 -961
- package/dist/cli.js.map +1 -1
- package/dist/export.cjs +3681 -939
- package/dist/export.cjs.map +1 -1
- package/dist/export.d.cts +1 -1
- package/dist/export.d.ts +1 -1
- package/dist/export.js +3681 -939
- package/dist/export.js.map +1 -1
- package/dist/index.cjs +4016 -815
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +159 -3
- package/dist/index.d.ts +159 -3
- package/dist/index.js +4016 -815
- package/dist/index.js.map +1 -1
- package/dist/{ink-B_7OXxtb.d.cts → ink-B8EZL7JV.d.cts} +95 -3
- package/dist/{ink-B_7OXxtb.d.ts → ink-B8EZL7JV.d.ts} +95 -3
- package/dist/node.cjs +2461 -726
- package/dist/node.cjs.map +1 -1
- package/dist/node.js +2461 -726
- package/dist/node.js.map +1 -1
- package/dist/player.global.js +2 -2
- package/package.json +1 -1
- package/src/field-messages.ts +12 -0
- package/src/figure-text.ts +26 -0
- package/src/index.ts +11 -1
- package/src/layout/scene.ts +23 -2
- package/src/layout/time.ts +680 -0
- package/src/look/values.ts +142 -2
- package/src/messages.ts +108 -5
- package/src/parser.ts +427 -6
- package/src/player.ts +48 -10
- package/src/printer.ts +63 -12
- package/src/render/icons.ts +2 -0
- package/src/render/parts.ts +29 -9
- package/src/render/svg.ts +129 -21
- package/src/render/time.ts +291 -0
- package/src/schema.ts +109 -10
- package/src/schemas/diagram.schema.json +224 -12
- package/src/schemas/validate-diagram.js +1 -1
- package/src/timeline.ts +147 -10
- package/src/words.ts +39 -6
package/dist/node.js
CHANGED
|
@@ -36,6 +36,9 @@ var ja = {
|
|
|
36
36
|
reserved: (names) => `${names.join(" \u3068 ")} \u306F\u72B6\u614B\u9077\u79FB\u56F3\u306E\u59CB\u307E\u308A\u3068\u7D42\u308F\u308A\u306E\u5370\u306E\u540D\u524D\u3067\u3001\u7BB1\u306E\u540D\u672D\u306B\u4F7F\u3048\u306A\u3044`,
|
|
37
37
|
kindOnly: (types, kind) => `${types.join(" \u3068 ")} \u306E\u51FA\u6765\u4E8B\u306F kind \u304C ${kind} \u306E\u6642\u3060\u3051\u66F8\u3051\u308B`,
|
|
38
38
|
hex: (min, max) => `0 \u304B\u3089 9 \u3068 a \u304B\u3089 f \u306E\u5B57\u3067 ${min} \u304B\u3089 ${max} \u5B57\u306B\u3059\u308B`,
|
|
39
|
+
duration: (units) => `\u6570\u3068\u5358\u4F4D (${units.join(" / ")}) \u306E\u7D44\u3067\u66F8\u304F (12s \u306A\u3069)`,
|
|
40
|
+
ratio: "\u5206\u6570 (2/3) \u304B\u767E\u5206\u7387 (97%) \u3067\u66F8\u304F",
|
|
41
|
+
url: "/ \u3067\u59CB\u307E\u308B path \u304B\u3001http:// \u304B https:// \u3067\u59CB\u307E\u308B URL \u306B\u3059\u308B",
|
|
39
42
|
anyOf: (fields) => fields.length > 0 ? `${fields.join(" \u304B ")} \u306E${fields.length === 2 ? "\u3069\u3061\u3089\u304B" : "\u3069\u308C\u304B"}\u306E\u6B04\u304C\u8981\u308B` : "\u66F8\u3051\u308B\u5F62\u306E\u3069\u308C\u306B\u3082\u5408\u308F\u306A\u3044",
|
|
40
43
|
oneOf: "\u66F8\u3051\u308B\u5F62\u306E\u3069\u308C\u304B 1 \u3064\u3060\u3051\u306B\u5408\u308F\u305B\u308B",
|
|
41
44
|
discriminator: (tag, values) => `${tag} \u306F ${values.join(" / ")} \u306E\u3069\u308C\u304B\u306B\u3059\u308B`,
|
|
@@ -55,6 +58,9 @@ var en = {
|
|
|
55
58
|
reserved: (names) => `${names.join(" and ")} name the start and end marks of a state diagram and cannot be box ids`,
|
|
56
59
|
kindOnly: (types, kind) => `${types.join(" and ")} events are allowed only when kind is ${kind}`,
|
|
57
60
|
hex: (min, max) => `Use ${min} to ${max} characters of 0-9 and a-f`,
|
|
61
|
+
duration: (units) => `Write a number and a unit (${units.join(" / ")}), such as 12s`,
|
|
62
|
+
ratio: "Write a fraction (2/3) or a percentage (97%)",
|
|
63
|
+
url: "Use a path that starts with / or a URL that starts with http:// or https://",
|
|
58
64
|
anyOf: (fields) => fields.length > 0 ? `Write one of the ${fields.join(" or ")} fields` : "Does not match any of the allowed shapes",
|
|
59
65
|
oneOf: "Match exactly one of the allowed shapes",
|
|
60
66
|
discriminator: (tag, values) => `${tag} is one of ${values.join(" / ")}`,
|
|
@@ -69,12 +75,255 @@ function ucs2length(str) {
|
|
|
69
75
|
return length;
|
|
70
76
|
}
|
|
71
77
|
var validate_diagram_default = validate10;
|
|
72
|
-
var schema11 = { "properties": { "version": { "description": "\u5F62\u5F0F\u306E\u7248", "type": "integer", "minimum": 1 }, "kind": { "description": "\u56F3\u306E\u7A2E\u985E", "enum": ["sequence", "architecture", "state", "git"] }, "title": { "$ref": "#/definitions/text" }, "view": { "description": "\u898B\u305B\u65B9\u3002\u66F8\u304B\u306A\u3051\u308C\u3070\u5B57\u306E\u5927\u304D\u3055\u3067\u9078\u3076\u3002fixed \u306F\u5168\u4F53\u3092\u6B62\u3081\u3066\u4E2D\u3060\u3051\u52D5\u304B\u3057\u3001follow \u306F\u5BC4\u3063\u3066\u52D5\u304B\u3057\u5168\u4F53\u56F3\u3067\u4ECA\u3069\u3053\u304B\u3092\u793A\u3059", "enum": ["fixed", "follow"] }, "regions": { "type": "array", "items": { "$ref": "#/definitions/region" } }, "boxes": { "type": "array", "items": { "$ref": "#/definitions/box" } }, "strip": { "$ref": "#/definitions/strip" }, "steps": { "type": "array", "minItems": 1, "items": { "$ref": "#/definitions/step" } }, "sequence": { "$ref": "#/definitions/sequence" }, "state": { "$ref": "#/definitions/state" }, "git": { "$ref": "#/definitions/git" } }};
|
|
73
|
-
var func2 = Object.prototype.hasOwnProperty;
|
|
74
|
-
var func3 = ucs2length;
|
|
75
|
-
var schema28 = { "enum": ["blue", "amber", "green", "violet", "rose", "slate", "coin"] };
|
|
76
|
-
var pattern0 = new RegExp("^[^\\s\\[\\]\u300C\u300D=:]+$", "u");
|
|
78
|
+
var schema11 = { "properties": { "version": { "description": "\u5F62\u5F0F\u306E\u7248", "type": "integer", "minimum": 1 }, "kind": { "description": "\u56F3\u306E\u7A2E\u985E", "enum": ["sequence", "architecture", "state", "git", "time"] }, "title": { "$ref": "#/definitions/text" }, "view": { "description": "\u898B\u305B\u65B9\u3002\u66F8\u304B\u306A\u3051\u308C\u3070\u5B57\u306E\u5927\u304D\u3055\u3067\u9078\u3076\u3002fixed \u306F\u5168\u4F53\u3092\u6B62\u3081\u3066\u4E2D\u3060\u3051\u52D5\u304B\u3057\u3001follow \u306F\u5BC4\u3063\u3066\u52D5\u304B\u3057\u5168\u4F53\u56F3\u3067\u4ECA\u3069\u3053\u304B\u3092\u793A\u3059", "enum": ["fixed", "follow"] }, "regions": { "type": "array", "items": { "$ref": "#/definitions/region" } }, "boxes": { "type": "array", "items": { "$ref": "#/definitions/box" } }, "strip": { "$ref": "#/definitions/strip" }, "steps": { "type": "array", "minItems": 1, "items": { "$ref": "#/definitions/step" } }, "sequence": { "$ref": "#/definitions/sequence" }, "state": { "$ref": "#/definitions/state" }, "git": { "$ref": "#/definitions/git" }, "time": { "$ref": "#/definitions/time" } }};
|
|
77
79
|
function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
80
|
+
let vErrors = null;
|
|
81
|
+
let errors = 0;
|
|
82
|
+
if (Array.isArray(data)) {
|
|
83
|
+
const len0 = data.length;
|
|
84
|
+
for (let i0 = 0; i0 < len0; i0++) {
|
|
85
|
+
let data0 = data[i0];
|
|
86
|
+
if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
|
|
87
|
+
if (data0.events !== void 0) {
|
|
88
|
+
let data1 = data0.events;
|
|
89
|
+
if (Array.isArray(data1)) {
|
|
90
|
+
const len1 = data1.length;
|
|
91
|
+
for (let i1 = 0; i1 < len1; i1++) {
|
|
92
|
+
let data2 = data1[i1];
|
|
93
|
+
const _errs3 = errors;
|
|
94
|
+
const _errs4 = errors;
|
|
95
|
+
if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
|
|
96
|
+
if (data2.type === void 0 && ("type")) {
|
|
97
|
+
const err0 = {};
|
|
98
|
+
if (vErrors === null) {
|
|
99
|
+
vErrors = [err0];
|
|
100
|
+
} else {
|
|
101
|
+
vErrors.push(err0);
|
|
102
|
+
}
|
|
103
|
+
errors++;
|
|
104
|
+
} else {
|
|
105
|
+
if (data2.type !== void 0) {
|
|
106
|
+
let data3 = data2.type;
|
|
107
|
+
if (!(data3 === "now" || data3 === "mark" || data3 === "span")) {
|
|
108
|
+
const err1 = {};
|
|
109
|
+
if (vErrors === null) {
|
|
110
|
+
vErrors = [err1];
|
|
111
|
+
} else {
|
|
112
|
+
vErrors.push(err1);
|
|
113
|
+
}
|
|
114
|
+
errors++;
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
var valid5 = _errs4 === errors;
|
|
120
|
+
if (valid5) {
|
|
121
|
+
const err2 = { instancePath: instancePath + "/" + i0 + "/events/" + i1, schemaPath: "#/items/properties/events/items/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
122
|
+
if (vErrors === null) {
|
|
123
|
+
vErrors = [err2];
|
|
124
|
+
} else {
|
|
125
|
+
vErrors.push(err2);
|
|
126
|
+
}
|
|
127
|
+
errors++;
|
|
128
|
+
} else {
|
|
129
|
+
errors = _errs3;
|
|
130
|
+
if (vErrors !== null) {
|
|
131
|
+
if (_errs3) {
|
|
132
|
+
vErrors.length = _errs3;
|
|
133
|
+
} else {
|
|
134
|
+
vErrors = null;
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
|
|
139
|
+
if (data2.type !== void 0) {
|
|
140
|
+
let data4 = data2.type;
|
|
141
|
+
const _errs8 = errors;
|
|
142
|
+
const _errs9 = errors;
|
|
143
|
+
if (!(data4 === "commit" || data4 === "branch")) {
|
|
144
|
+
const err3 = {};
|
|
145
|
+
if (vErrors === null) {
|
|
146
|
+
vErrors = [err3];
|
|
147
|
+
} else {
|
|
148
|
+
vErrors.push(err3);
|
|
149
|
+
}
|
|
150
|
+
errors++;
|
|
151
|
+
}
|
|
152
|
+
var valid9 = _errs9 === errors;
|
|
153
|
+
if (valid9) {
|
|
154
|
+
const err4 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/type", schemaPath: "#/items/properties/events/items/properties/type/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
155
|
+
if (vErrors === null) {
|
|
156
|
+
vErrors = [err4];
|
|
157
|
+
} else {
|
|
158
|
+
vErrors.push(err4);
|
|
159
|
+
}
|
|
160
|
+
errors++;
|
|
161
|
+
} else {
|
|
162
|
+
errors = _errs8;
|
|
163
|
+
if (vErrors !== null) {
|
|
164
|
+
if (_errs8) {
|
|
165
|
+
vErrors.length = _errs8;
|
|
166
|
+
} else {
|
|
167
|
+
vErrors = null;
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
}
|
|
172
|
+
if (data2.at !== void 0) {
|
|
173
|
+
const err5 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/at", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
174
|
+
if (vErrors === null) {
|
|
175
|
+
vErrors = [err5];
|
|
176
|
+
} else {
|
|
177
|
+
vErrors.push(err5);
|
|
178
|
+
}
|
|
179
|
+
errors++;
|
|
180
|
+
}
|
|
181
|
+
if (data2.into !== void 0) {
|
|
182
|
+
const err6 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/into", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
183
|
+
if (vErrors === null) {
|
|
184
|
+
vErrors = [err6];
|
|
185
|
+
} else {
|
|
186
|
+
vErrors.push(err6);
|
|
187
|
+
}
|
|
188
|
+
errors++;
|
|
189
|
+
}
|
|
190
|
+
if (data2.color !== void 0) {
|
|
191
|
+
const err7 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/color", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
192
|
+
if (vErrors === null) {
|
|
193
|
+
vErrors = [err7];
|
|
194
|
+
} else {
|
|
195
|
+
vErrors.push(err7);
|
|
196
|
+
}
|
|
197
|
+
errors++;
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
validate11.errors = vErrors;
|
|
207
|
+
return errors === 0;
|
|
208
|
+
}
|
|
209
|
+
function validate13(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
210
|
+
let vErrors = null;
|
|
211
|
+
let errors = 0;
|
|
212
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
213
|
+
if (data.meters !== void 0) {
|
|
214
|
+
const err0 = { instancePath: instancePath + "/meters", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
215
|
+
if (vErrors === null) {
|
|
216
|
+
vErrors = [err0];
|
|
217
|
+
} else {
|
|
218
|
+
vErrors.push(err0);
|
|
219
|
+
}
|
|
220
|
+
errors++;
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
validate13.errors = vErrors;
|
|
224
|
+
return errors === 0;
|
|
225
|
+
}
|
|
226
|
+
function validate17(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
227
|
+
let vErrors = null;
|
|
228
|
+
let errors = 0;
|
|
229
|
+
if (Array.isArray(data)) {
|
|
230
|
+
const len0 = data.length;
|
|
231
|
+
for (let i0 = 0; i0 < len0; i0++) {
|
|
232
|
+
let data0 = data[i0];
|
|
233
|
+
if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
|
|
234
|
+
if (data0.events !== void 0) {
|
|
235
|
+
let data1 = data0.events;
|
|
236
|
+
if (Array.isArray(data1)) {
|
|
237
|
+
const len1 = data1.length;
|
|
238
|
+
for (let i1 = 0; i1 < len1; i1++) {
|
|
239
|
+
let data2 = data1[i1];
|
|
240
|
+
const _errs3 = errors;
|
|
241
|
+
const _errs4 = errors;
|
|
242
|
+
if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
|
|
243
|
+
if (data2.type === void 0 && ("type")) {
|
|
244
|
+
const err0 = {};
|
|
245
|
+
if (vErrors === null) {
|
|
246
|
+
vErrors = [err0];
|
|
247
|
+
} else {
|
|
248
|
+
vErrors.push(err0);
|
|
249
|
+
}
|
|
250
|
+
errors++;
|
|
251
|
+
} else {
|
|
252
|
+
if (data2.type !== void 0) {
|
|
253
|
+
let data3 = data2.type;
|
|
254
|
+
if (!(data3 === "now" || data3 === "mark" || data3 === "span")) {
|
|
255
|
+
const err1 = {};
|
|
256
|
+
if (vErrors === null) {
|
|
257
|
+
vErrors = [err1];
|
|
258
|
+
} else {
|
|
259
|
+
vErrors.push(err1);
|
|
260
|
+
}
|
|
261
|
+
errors++;
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
var valid5 = _errs4 === errors;
|
|
267
|
+
if (valid5) {
|
|
268
|
+
const err2 = { instancePath: instancePath + "/" + i0 + "/events/" + i1, schemaPath: "#/items/properties/events/items/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
269
|
+
if (vErrors === null) {
|
|
270
|
+
vErrors = [err2];
|
|
271
|
+
} else {
|
|
272
|
+
vErrors.push(err2);
|
|
273
|
+
}
|
|
274
|
+
errors++;
|
|
275
|
+
} else {
|
|
276
|
+
errors = _errs3;
|
|
277
|
+
if (vErrors !== null) {
|
|
278
|
+
if (_errs3) {
|
|
279
|
+
vErrors.length = _errs3;
|
|
280
|
+
} else {
|
|
281
|
+
vErrors = null;
|
|
282
|
+
}
|
|
283
|
+
}
|
|
284
|
+
}
|
|
285
|
+
if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
|
|
286
|
+
if (data2.at !== void 0) {
|
|
287
|
+
const err3 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/at", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
288
|
+
if (vErrors === null) {
|
|
289
|
+
vErrors = [err3];
|
|
290
|
+
} else {
|
|
291
|
+
vErrors.push(err3);
|
|
292
|
+
}
|
|
293
|
+
errors++;
|
|
294
|
+
}
|
|
295
|
+
if (data2.into !== void 0) {
|
|
296
|
+
const err4 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/into", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
297
|
+
if (vErrors === null) {
|
|
298
|
+
vErrors = [err4];
|
|
299
|
+
} else {
|
|
300
|
+
vErrors.push(err4);
|
|
301
|
+
}
|
|
302
|
+
errors++;
|
|
303
|
+
}
|
|
304
|
+
if (data2.color !== void 0) {
|
|
305
|
+
const err5 = { instancePath: instancePath + "/" + i0 + "/events/" + i1 + "/color", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
306
|
+
if (vErrors === null) {
|
|
307
|
+
vErrors = [err5];
|
|
308
|
+
} else {
|
|
309
|
+
vErrors.push(err5);
|
|
310
|
+
}
|
|
311
|
+
errors++;
|
|
312
|
+
}
|
|
313
|
+
}
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
}
|
|
318
|
+
}
|
|
319
|
+
}
|
|
320
|
+
validate17.errors = vErrors;
|
|
321
|
+
return errors === 0;
|
|
322
|
+
}
|
|
323
|
+
var schema45 = { "enum": ["blue", "amber", "green", "violet", "rose", "slate", "coin"] };
|
|
324
|
+
var pattern0 = new RegExp("^[^\\s\\[\\]\u300C\u300D=:]+$", "u");
|
|
325
|
+
var func3 = ucs2length;
|
|
326
|
+
function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
78
327
|
let vErrors = null;
|
|
79
328
|
let errors = 0;
|
|
80
329
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -176,7 +425,7 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
176
425
|
if (data.color !== void 0) {
|
|
177
426
|
let data3 = data.color;
|
|
178
427
|
if (!(data3 === "blue" || data3 === "amber" || data3 === "green" || data3 === "violet" || data3 === "rose" || data3 === "slate" || data3 === "coin")) {
|
|
179
|
-
const err9 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues:
|
|
428
|
+
const err9 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema45.enum }, message: "must be equal to one of the allowed values" };
|
|
180
429
|
if (vErrors === null) {
|
|
181
430
|
vErrors = [err9];
|
|
182
431
|
} else {
|
|
@@ -216,10 +465,11 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
216
465
|
}
|
|
217
466
|
errors++;
|
|
218
467
|
}
|
|
219
|
-
|
|
468
|
+
validate22.errors = vErrors;
|
|
220
469
|
return errors === 0;
|
|
221
470
|
}
|
|
222
|
-
|
|
471
|
+
var pattern3 = new RegExp("^(/|https?://)", "u");
|
|
472
|
+
function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
223
473
|
let vErrors = null;
|
|
224
474
|
let errors = 0;
|
|
225
475
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -242,7 +492,7 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
242
492
|
errors++;
|
|
243
493
|
}
|
|
244
494
|
for (const key0 in data) {
|
|
245
|
-
if (!(key0 === "id" || key0 === "name" || key0 === "sub" || key0 === "color" || key0 === "icon" || key0 === "region")) {
|
|
495
|
+
if (!(key0 === "id" || key0 === "name" || key0 === "sub" || key0 === "color" || key0 === "icon" || key0 === "region" || key0 === "link")) {
|
|
246
496
|
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
247
497
|
if (vErrors === null) {
|
|
248
498
|
vErrors = [err2];
|
|
@@ -321,7 +571,7 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
321
571
|
if (data.color !== void 0) {
|
|
322
572
|
let data3 = data.color;
|
|
323
573
|
if (!(data3 === "blue" || data3 === "amber" || data3 === "green" || data3 === "violet" || data3 === "rose" || data3 === "slate" || data3 === "coin")) {
|
|
324
|
-
const err9 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues:
|
|
574
|
+
const err9 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema45.enum }, message: "must be equal to one of the allowed values" };
|
|
325
575
|
if (vErrors === null) {
|
|
326
576
|
vErrors = [err9];
|
|
327
577
|
} else {
|
|
@@ -374,19 +624,131 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
374
624
|
errors++;
|
|
375
625
|
}
|
|
376
626
|
}
|
|
627
|
+
if (data.link !== void 0) {
|
|
628
|
+
let data6 = data.link;
|
|
629
|
+
if (typeof data6 === "string") {
|
|
630
|
+
if (!pattern3.test(data6)) {
|
|
631
|
+
const err14 = { instancePath: instancePath + "/link", schemaPath: "#/definitions/url/pattern", keyword: "pattern", params: { pattern: "^(/|https?://)" }, message: 'must match pattern "^(/|https?://)"' };
|
|
632
|
+
if (vErrors === null) {
|
|
633
|
+
vErrors = [err14];
|
|
634
|
+
} else {
|
|
635
|
+
vErrors.push(err14);
|
|
636
|
+
}
|
|
637
|
+
errors++;
|
|
638
|
+
}
|
|
639
|
+
} else {
|
|
640
|
+
const err15 = { instancePath: instancePath + "/link", schemaPath: "#/definitions/url/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
641
|
+
if (vErrors === null) {
|
|
642
|
+
vErrors = [err15];
|
|
643
|
+
} else {
|
|
644
|
+
vErrors.push(err15);
|
|
645
|
+
}
|
|
646
|
+
errors++;
|
|
647
|
+
}
|
|
648
|
+
}
|
|
377
649
|
} else {
|
|
378
|
-
const
|
|
650
|
+
const err16 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
379
651
|
if (vErrors === null) {
|
|
380
|
-
vErrors = [
|
|
652
|
+
vErrors = [err16];
|
|
381
653
|
} else {
|
|
382
|
-
vErrors.push(
|
|
654
|
+
vErrors.push(err16);
|
|
383
655
|
}
|
|
384
656
|
errors++;
|
|
385
657
|
}
|
|
386
|
-
|
|
658
|
+
validate24.errors = vErrors;
|
|
659
|
+
return errors === 0;
|
|
660
|
+
}
|
|
661
|
+
var pattern4 = new RegExp("^([0-9]+/[0-9]+|[0-9]+(\\.[0-9]+)?%)$", "u");
|
|
662
|
+
function validate27(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
663
|
+
let vErrors = null;
|
|
664
|
+
let errors = 0;
|
|
665
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
666
|
+
if (data.field === void 0) {
|
|
667
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "field" }, message: "must have required property 'field'" };
|
|
668
|
+
if (vErrors === null) {
|
|
669
|
+
vErrors = [err0];
|
|
670
|
+
} else {
|
|
671
|
+
vErrors.push(err0);
|
|
672
|
+
}
|
|
673
|
+
errors++;
|
|
674
|
+
}
|
|
675
|
+
if (data.line === void 0) {
|
|
676
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "line" }, message: "must have required property 'line'" };
|
|
677
|
+
if (vErrors === null) {
|
|
678
|
+
vErrors = [err1];
|
|
679
|
+
} else {
|
|
680
|
+
vErrors.push(err1);
|
|
681
|
+
}
|
|
682
|
+
errors++;
|
|
683
|
+
}
|
|
684
|
+
for (const key0 in data) {
|
|
685
|
+
if (!(key0 === "field" || key0 === "line")) {
|
|
686
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
687
|
+
if (vErrors === null) {
|
|
688
|
+
vErrors = [err2];
|
|
689
|
+
} else {
|
|
690
|
+
vErrors.push(err2);
|
|
691
|
+
}
|
|
692
|
+
errors++;
|
|
693
|
+
}
|
|
694
|
+
}
|
|
695
|
+
if (data.field !== void 0) {
|
|
696
|
+
let data0 = data.field;
|
|
697
|
+
if (typeof data0 === "string") {
|
|
698
|
+
if (func3(data0) < 1) {
|
|
699
|
+
const err3 = { instancePath: instancePath + "/field", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
700
|
+
if (vErrors === null) {
|
|
701
|
+
vErrors = [err3];
|
|
702
|
+
} else {
|
|
703
|
+
vErrors.push(err3);
|
|
704
|
+
}
|
|
705
|
+
errors++;
|
|
706
|
+
}
|
|
707
|
+
} else {
|
|
708
|
+
const err4 = { instancePath: instancePath + "/field", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
709
|
+
if (vErrors === null) {
|
|
710
|
+
vErrors = [err4];
|
|
711
|
+
} else {
|
|
712
|
+
vErrors.push(err4);
|
|
713
|
+
}
|
|
714
|
+
errors++;
|
|
715
|
+
}
|
|
716
|
+
}
|
|
717
|
+
if (data.line !== void 0) {
|
|
718
|
+
let data1 = data.line;
|
|
719
|
+
if (typeof data1 === "string") {
|
|
720
|
+
if (!pattern4.test(data1)) {
|
|
721
|
+
const err5 = { instancePath: instancePath + "/line", schemaPath: "#/definitions/ratio/pattern", keyword: "pattern", params: { pattern: "^([0-9]+/[0-9]+|[0-9]+(\\.[0-9]+)?%)$" }, message: 'must match pattern "^([0-9]+/[0-9]+|[0-9]+(\\.[0-9]+)?%)$"' };
|
|
722
|
+
if (vErrors === null) {
|
|
723
|
+
vErrors = [err5];
|
|
724
|
+
} else {
|
|
725
|
+
vErrors.push(err5);
|
|
726
|
+
}
|
|
727
|
+
errors++;
|
|
728
|
+
}
|
|
729
|
+
} else {
|
|
730
|
+
const err6 = { instancePath: instancePath + "/line", schemaPath: "#/definitions/ratio/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
731
|
+
if (vErrors === null) {
|
|
732
|
+
vErrors = [err6];
|
|
733
|
+
} else {
|
|
734
|
+
vErrors.push(err6);
|
|
735
|
+
}
|
|
736
|
+
errors++;
|
|
737
|
+
}
|
|
738
|
+
}
|
|
739
|
+
} else {
|
|
740
|
+
const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
741
|
+
if (vErrors === null) {
|
|
742
|
+
vErrors = [err7];
|
|
743
|
+
} else {
|
|
744
|
+
vErrors.push(err7);
|
|
745
|
+
}
|
|
746
|
+
errors++;
|
|
747
|
+
}
|
|
748
|
+
validate27.errors = vErrors;
|
|
387
749
|
return errors === 0;
|
|
388
750
|
}
|
|
389
|
-
function
|
|
751
|
+
function validate26(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
390
752
|
let vErrors = null;
|
|
391
753
|
let errors = 0;
|
|
392
754
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -409,7 +771,7 @@ function validate15(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
409
771
|
errors++;
|
|
410
772
|
}
|
|
411
773
|
for (const key0 in data) {
|
|
412
|
-
if (!(key0 === "title" || key0 === "fields")) {
|
|
774
|
+
if (!(key0 === "title" || key0 === "fields" || key0 === "meters")) {
|
|
413
775
|
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
414
776
|
if (vErrors === null) {
|
|
415
777
|
vErrors = [err2];
|
|
@@ -486,51 +848,169 @@ function validate15(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
486
848
|
errors++;
|
|
487
849
|
}
|
|
488
850
|
}
|
|
851
|
+
if (data.meters !== void 0) {
|
|
852
|
+
let data3 = data.meters;
|
|
853
|
+
if (Array.isArray(data3)) {
|
|
854
|
+
if (data3.length < 1) {
|
|
855
|
+
const err9 = { instancePath: instancePath + "/meters", schemaPath: "#/properties/meters/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
|
|
856
|
+
if (vErrors === null) {
|
|
857
|
+
vErrors = [err9];
|
|
858
|
+
} else {
|
|
859
|
+
vErrors.push(err9);
|
|
860
|
+
}
|
|
861
|
+
errors++;
|
|
862
|
+
}
|
|
863
|
+
const len1 = data3.length;
|
|
864
|
+
for (let i1 = 0; i1 < len1; i1++) {
|
|
865
|
+
if (!validate27(data3[i1], { instancePath: instancePath + "/meters/" + i1, parentData: data3, parentDataProperty: i1, rootData })) {
|
|
866
|
+
vErrors = vErrors === null ? validate27.errors : vErrors.concat(validate27.errors);
|
|
867
|
+
errors = vErrors.length;
|
|
868
|
+
}
|
|
869
|
+
}
|
|
870
|
+
} else {
|
|
871
|
+
const err10 = { instancePath: instancePath + "/meters", schemaPath: "#/properties/meters/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
872
|
+
if (vErrors === null) {
|
|
873
|
+
vErrors = [err10];
|
|
874
|
+
} else {
|
|
875
|
+
vErrors.push(err10);
|
|
876
|
+
}
|
|
877
|
+
errors++;
|
|
878
|
+
}
|
|
879
|
+
}
|
|
489
880
|
} else {
|
|
490
|
-
const
|
|
881
|
+
const err11 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
491
882
|
if (vErrors === null) {
|
|
492
|
-
vErrors = [
|
|
883
|
+
vErrors = [err11];
|
|
493
884
|
} else {
|
|
494
|
-
vErrors.push(
|
|
885
|
+
vErrors.push(err11);
|
|
495
886
|
}
|
|
496
887
|
errors++;
|
|
497
888
|
}
|
|
498
|
-
|
|
889
|
+
validate26.errors = vErrors;
|
|
499
890
|
return errors === 0;
|
|
500
891
|
}
|
|
501
|
-
|
|
502
|
-
var pattern11 = new RegExp("^[0-9a-f]{4,40}$", "u");
|
|
503
|
-
var schema48 = { "properties": { "kind": { "enum": ["envelope", "tag", "coin", "none"] }}};
|
|
504
|
-
function validate19(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
892
|
+
function validate31(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
505
893
|
let vErrors = null;
|
|
506
894
|
let errors = 0;
|
|
507
|
-
const _errs1 = errors;
|
|
508
|
-
let valid0 = true;
|
|
509
|
-
const _errs2 = errors;
|
|
510
895
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
511
|
-
if (data.
|
|
512
|
-
const err0 = {};
|
|
896
|
+
if (data.name === void 0) {
|
|
897
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
|
|
513
898
|
if (vErrors === null) {
|
|
514
899
|
vErrors = [err0];
|
|
515
900
|
} else {
|
|
516
901
|
vErrors.push(err0);
|
|
517
902
|
}
|
|
518
903
|
errors++;
|
|
519
|
-
}
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
vErrors.push(err1);
|
|
527
|
-
}
|
|
528
|
-
errors++;
|
|
529
|
-
}
|
|
904
|
+
}
|
|
905
|
+
if (data.url === void 0) {
|
|
906
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "url" }, message: "must have required property 'url'" };
|
|
907
|
+
if (vErrors === null) {
|
|
908
|
+
vErrors = [err1];
|
|
909
|
+
} else {
|
|
910
|
+
vErrors.push(err1);
|
|
530
911
|
}
|
|
912
|
+
errors++;
|
|
531
913
|
}
|
|
532
|
-
|
|
533
|
-
|
|
914
|
+
for (const key0 in data) {
|
|
915
|
+
if (!(key0 === "name" || key0 === "url")) {
|
|
916
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
917
|
+
if (vErrors === null) {
|
|
918
|
+
vErrors = [err2];
|
|
919
|
+
} else {
|
|
920
|
+
vErrors.push(err2);
|
|
921
|
+
}
|
|
922
|
+
errors++;
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
if (data.name !== void 0) {
|
|
926
|
+
let data0 = data.name;
|
|
927
|
+
if (typeof data0 === "string") {
|
|
928
|
+
if (func3(data0) < 1) {
|
|
929
|
+
const err3 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
930
|
+
if (vErrors === null) {
|
|
931
|
+
vErrors = [err3];
|
|
932
|
+
} else {
|
|
933
|
+
vErrors.push(err3);
|
|
934
|
+
}
|
|
935
|
+
errors++;
|
|
936
|
+
}
|
|
937
|
+
} else {
|
|
938
|
+
const err4 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
939
|
+
if (vErrors === null) {
|
|
940
|
+
vErrors = [err4];
|
|
941
|
+
} else {
|
|
942
|
+
vErrors.push(err4);
|
|
943
|
+
}
|
|
944
|
+
errors++;
|
|
945
|
+
}
|
|
946
|
+
}
|
|
947
|
+
if (data.url !== void 0) {
|
|
948
|
+
let data1 = data.url;
|
|
949
|
+
if (typeof data1 === "string") {
|
|
950
|
+
if (!pattern3.test(data1)) {
|
|
951
|
+
const err5 = { instancePath: instancePath + "/url", schemaPath: "#/definitions/url/pattern", keyword: "pattern", params: { pattern: "^(/|https?://)" }, message: 'must match pattern "^(/|https?://)"' };
|
|
952
|
+
if (vErrors === null) {
|
|
953
|
+
vErrors = [err5];
|
|
954
|
+
} else {
|
|
955
|
+
vErrors.push(err5);
|
|
956
|
+
}
|
|
957
|
+
errors++;
|
|
958
|
+
}
|
|
959
|
+
} else {
|
|
960
|
+
const err6 = { instancePath: instancePath + "/url", schemaPath: "#/definitions/url/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
961
|
+
if (vErrors === null) {
|
|
962
|
+
vErrors = [err6];
|
|
963
|
+
} else {
|
|
964
|
+
vErrors.push(err6);
|
|
965
|
+
}
|
|
966
|
+
errors++;
|
|
967
|
+
}
|
|
968
|
+
}
|
|
969
|
+
} else {
|
|
970
|
+
const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
971
|
+
if (vErrors === null) {
|
|
972
|
+
vErrors = [err7];
|
|
973
|
+
} else {
|
|
974
|
+
vErrors.push(err7);
|
|
975
|
+
}
|
|
976
|
+
errors++;
|
|
977
|
+
}
|
|
978
|
+
validate31.errors = vErrors;
|
|
979
|
+
return errors === 0;
|
|
980
|
+
}
|
|
981
|
+
var schema68 = { "oneOf": [{ "description": "\u7DDA\u3002\u904B\u3076\u7269\u3092\u8F09\u305B\u3066\u9001\u308B\u5074\u304B\u3089\u53D7\u3051\u308B\u5074\u3078\u8D70\u308B", "type": "object", "additionalProperties": false, "required": ["type", "from", "to", "carry"], "properties": { "type": { "const": "edge" }, "from": { "$ref": "#/definitions/id" }, "to": { "$ref": "#/definitions/id" }, "label": { "$ref": "#/definitions/text" }, "carry": { "$ref": "#/definitions/carry" }, "labelSide": { "description": "\u7DDA\u306E\u540D\u524D\u3092\u7F6E\u304F\u5074 (\u5BC4\u305B\u306E\u6307\u793A)", "enum": ["above", "below", "left", "right"] }, "at": { "description": "\u6642\u9593\u8EF8\u306E\u56F3\u306E\u62E1\u5927\u306E\u5E2F\u3067\u3001\u7DDA\u3092\u5F15\u304F\u5217\u306E\u76EE\u76DB\u308A", "$ref": "#/definitions/unit" }, "into": { "description": "\u6642\u9593\u8EF8\u306E\u56F3\u306E\u62E1\u5927\u306E\u5E2F\u3067\u3001\u53D7\u3051\u308B\u7BB1\u3092\u9078\u3076\u5217\u306E\u76EE\u76DB\u308A\u3002\u66F8\u304B\u306A\u3051\u308C\u3070 at \u306E\u5217", "$ref": "#/definitions/unit" } } }, { "description": "\u7BB1\u306E\u4E2D\u306E\u51E6\u7406", "type": "object", "additionalProperties": false, "required": ["type", "box", "label"], "properties": { "type": { "const": "action" }, "box": { "$ref": "#/definitions/id" }, "label": { "$ref": "#/definitions/text" } } }, { "description": "\u7BB1\u306E\u4E0B\u306E\u5C0F\u3055\u306A\u5B57\u306E\u66F8\u304D\u63DB\u3048", "type": "object", "additionalProperties": false, "required": ["type", "box", "text"], "properties": { "type": { "const": "swap" }, "box": { "$ref": "#/definitions/id" }, "text": { "$ref": "#/definitions/text" }, "color": { "description": "\u6642\u9593\u8EF8\u306E\u56F3\u306E\u7BC0\u76EE\u306E\u4E38\u306E\u8272", "$ref": "#/definitions/color" } } }, { "description": "commit \u3092\u7A4D\u3080\u3002\u679D\u5206\u304B\u308C\u306E\u56F3\u3060\u3051\u304C\u66F8\u3051\u308B\u3002\u7A4D\u3093\u3060\u679D\u306E\u672D\u3068\u3001\u305D\u306E\u679D\u3092\u6307\u3059 HEAD \u304C\u9032\u3080\u3002\u5F53\u3066\u76F4\u3057 (copy) \u306F\u679D\u306E\u672D\u3092\u52D5\u304B\u3055\u305A\u3001merge commit (merge) \u306F\u53D6\u308A\u8FBC\u3080\u679D\u306E\u5148\u7AEF\u3082\u89AA\u306B\u6301\u3064", "type": "object", "additionalProperties": false, "required": ["type", "id", "branch"], "properties": { "type": { "const": "commit" }, "id": { "$ref": "#/definitions/id" }, "branch": { "$ref": "#/definitions/id" }, "copy": { "$ref": "#/definitions/id" }, "merge": { "$ref": "#/definitions/id" }, "hash": { "$ref": "#/definitions/hash" }, "note": { "$ref": "#/definitions/text" } } }, { "description": "\u679D\u3092\u5207\u308B\u3002\u679D\u5206\u304B\u308C\u306E\u56F3\u3060\u3051\u304C\u66F8\u3051\u308B\u3002\u679D\u306E\u672D\u3092 from \u306E commit \u3078\u7F6E\u304D\u3001HEAD \u3092\u305D\u306E\u679D\u3078\u79FB\u3059", "type": "object", "additionalProperties": false, "required": ["type", "branch", "from"], "properties": { "type": { "const": "branch" }, "branch": { "$ref": "#/definitions/id" }, "from": { "$ref": "#/definitions/id" } } }, { "description": "\u6642\u9593\u8EF8\u306E\u56F3\u306E\u4ECA\u306E\u6642\u523B\u306E\u91DD\u3092\u3001to \u306E\u76EE\u76DB\u308A\u306E\u7D42\u308F\u308A\u307E\u3067\u9032\u3081\u308B", "type": "object", "additionalProperties": false, "required": ["type", "to"], "properties": { "type": { "const": "now" }, "to": { "$ref": "#/definitions/unit" } } }, { "description": "\u6642\u9593\u8EF8\u306E\u56F3\u306E\u5370\u306E\u5217 row \u306E\u3001from \u304B\u3089 to \u306E\u76EE\u76DB\u308A\u306E\u5370\u306E\u8272\u3092\u5909\u3048\u308B", "type": "object", "additionalProperties": false, "required": ["type", "row", "from", "to", "color"], "properties": { "type": { "const": "mark" }, "row": { "$ref": "#/definitions/id" }, "from": { "$ref": "#/definitions/unit" }, "to": { "$ref": "#/definitions/unit" }, "color": { "$ref": "#/definitions/color" } } }, { "description": "\u6642\u9593\u8EF8\u306E\u56F3\u306E from \u304B\u3089 to \u306E\u76EE\u76DB\u308A\u306B\u3001\u62EC\u5F27\u3068\u5B57\u3092\u51FA\u3059\u3002shape \u304C box \u306A\u3089\u5370\u306E\u5217\u3092\u56F2\u307F\u3001\u5B57\u3092\u7E01\u306E\u672D\u306B\u3059\u308B", "type": "object", "additionalProperties": false, "required": ["type", "from", "to", "text"], "properties": { "type": { "const": "span" }, "from": { "$ref": "#/definitions/unit" }, "to": { "$ref": "#/definitions/unit" }, "text": { "$ref": "#/definitions/text" }, "shape": { "enum": ["box"] }, "color": { "$ref": "#/definitions/color" } } }, { "description": "\u4E2D\u8EAB\u306E\u5E2F\u306E\u6B04\u306E\u5024\u3068\u672D", "type": "object", "additionalProperties": false, "required": ["type", "field"], "anyOf": [{ "required": ["value"] }, { "required": ["tag"] }], "properties": { "type": { "const": "strip" }, "field": { "$ref": "#/definitions/text" }, "value": { "$ref": "#/definitions/text" }, "tag": { "$ref": "#/definitions/text" } } }] };
|
|
982
|
+
var pattern14 = new RegExp("^[0-9a-f]{4,40}$", "u");
|
|
983
|
+
var schema72 = { "properties": { "kind": { "enum": ["envelope", "tag", "coin", "none"] }}};
|
|
984
|
+
function validate34(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
985
|
+
let vErrors = null;
|
|
986
|
+
let errors = 0;
|
|
987
|
+
const _errs1 = errors;
|
|
988
|
+
let valid0 = true;
|
|
989
|
+
const _errs2 = errors;
|
|
990
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
991
|
+
if (data.kind === void 0 && ("kind")) {
|
|
992
|
+
const err0 = {};
|
|
993
|
+
if (vErrors === null) {
|
|
994
|
+
vErrors = [err0];
|
|
995
|
+
} else {
|
|
996
|
+
vErrors.push(err0);
|
|
997
|
+
}
|
|
998
|
+
errors++;
|
|
999
|
+
} else {
|
|
1000
|
+
if (data.kind !== void 0) {
|
|
1001
|
+
if ("tag" !== data.kind) {
|
|
1002
|
+
const err1 = {};
|
|
1003
|
+
if (vErrors === null) {
|
|
1004
|
+
vErrors = [err1];
|
|
1005
|
+
} else {
|
|
1006
|
+
vErrors.push(err1);
|
|
1007
|
+
}
|
|
1008
|
+
errors++;
|
|
1009
|
+
}
|
|
1010
|
+
}
|
|
1011
|
+
}
|
|
1012
|
+
}
|
|
1013
|
+
var _valid0 = _errs2 === errors;
|
|
534
1014
|
errors = _errs1;
|
|
535
1015
|
if (vErrors !== null) {
|
|
536
1016
|
if (_errs1) {
|
|
@@ -627,7 +1107,7 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
627
1107
|
if (data.kind !== void 0) {
|
|
628
1108
|
let data1 = data.kind;
|
|
629
1109
|
if (!(data1 === "envelope" || data1 === "tag" || data1 === "coin" || data1 === "none")) {
|
|
630
|
-
const err8 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues:
|
|
1110
|
+
const err8 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema72.properties.kind.enum }, message: "must be equal to one of the allowed values" };
|
|
631
1111
|
if (vErrors === null) {
|
|
632
1112
|
vErrors = [err8];
|
|
633
1113
|
} else {
|
|
@@ -667,10 +1147,10 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
667
1147
|
}
|
|
668
1148
|
errors++;
|
|
669
1149
|
}
|
|
670
|
-
|
|
1150
|
+
validate34.errors = vErrors;
|
|
671
1151
|
return errors === 0;
|
|
672
1152
|
}
|
|
673
|
-
function
|
|
1153
|
+
function validate33(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
674
1154
|
let vErrors = null;
|
|
675
1155
|
let errors = 0;
|
|
676
1156
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -724,7 +1204,7 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
724
1204
|
errors++;
|
|
725
1205
|
}
|
|
726
1206
|
for (const key0 in data) {
|
|
727
|
-
if (!(key0 === "type" || key0 === "from" || key0 === "to" || key0 === "label" || key0 === "carry" || key0 === "labelSide")) {
|
|
1207
|
+
if (!(key0 === "type" || key0 === "from" || key0 === "to" || key0 === "label" || key0 === "carry" || key0 === "labelSide" || key0 === "at" || key0 === "into")) {
|
|
728
1208
|
const err5 = { instancePath, schemaPath: "#/oneOf/0/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
729
1209
|
if (vErrors === null) {
|
|
730
1210
|
vErrors = [err5];
|
|
@@ -812,15 +1292,15 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
812
1292
|
}
|
|
813
1293
|
}
|
|
814
1294
|
if (data.carry !== void 0) {
|
|
815
|
-
if (!
|
|
816
|
-
vErrors = vErrors === null ?
|
|
1295
|
+
if (!validate34(data.carry, { instancePath: instancePath + "/carry", parentData: data, parentDataProperty: "carry", rootData })) {
|
|
1296
|
+
vErrors = vErrors === null ? validate34.errors : vErrors.concat(validate34.errors);
|
|
817
1297
|
errors = vErrors.length;
|
|
818
1298
|
}
|
|
819
1299
|
}
|
|
820
1300
|
if (data.labelSide !== void 0) {
|
|
821
1301
|
let data5 = data.labelSide;
|
|
822
1302
|
if (!(data5 === "above" || data5 === "below" || data5 === "left" || data5 === "right")) {
|
|
823
|
-
const err13 = { instancePath: instancePath + "/labelSide", schemaPath: "#/oneOf/0/properties/labelSide/enum", keyword: "enum", params: { allowedValues:
|
|
1303
|
+
const err13 = { instancePath: instancePath + "/labelSide", schemaPath: "#/oneOf/0/properties/labelSide/enum", keyword: "enum", params: { allowedValues: schema68.oneOf[0].properties.labelSide.enum }, message: "must be equal to one of the allowed values" };
|
|
824
1304
|
if (vErrors === null) {
|
|
825
1305
|
vErrors = [err13];
|
|
826
1306
|
} else {
|
|
@@ -829,717 +1309,1167 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
829
1309
|
errors++;
|
|
830
1310
|
}
|
|
831
1311
|
}
|
|
1312
|
+
if (data.at !== void 0) {
|
|
1313
|
+
let data6 = data.at;
|
|
1314
|
+
if (!(typeof data6 == "number" && (!(data6 % 1) && !isNaN(data6)) && isFinite(data6))) {
|
|
1315
|
+
const err14 = { instancePath: instancePath + "/at", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
1316
|
+
if (vErrors === null) {
|
|
1317
|
+
vErrors = [err14];
|
|
1318
|
+
} else {
|
|
1319
|
+
vErrors.push(err14);
|
|
1320
|
+
}
|
|
1321
|
+
errors++;
|
|
1322
|
+
}
|
|
1323
|
+
if (typeof data6 == "number" && isFinite(data6)) {
|
|
1324
|
+
if (data6 < 0 || isNaN(data6)) {
|
|
1325
|
+
const err15 = { instancePath: instancePath + "/at", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
1326
|
+
if (vErrors === null) {
|
|
1327
|
+
vErrors = [err15];
|
|
1328
|
+
} else {
|
|
1329
|
+
vErrors.push(err15);
|
|
1330
|
+
}
|
|
1331
|
+
errors++;
|
|
1332
|
+
}
|
|
1333
|
+
}
|
|
1334
|
+
}
|
|
1335
|
+
if (data.into !== void 0) {
|
|
1336
|
+
let data7 = data.into;
|
|
1337
|
+
if (!(typeof data7 == "number" && (!(data7 % 1) && !isNaN(data7)) && isFinite(data7))) {
|
|
1338
|
+
const err16 = { instancePath: instancePath + "/into", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
1339
|
+
if (vErrors === null) {
|
|
1340
|
+
vErrors = [err16];
|
|
1341
|
+
} else {
|
|
1342
|
+
vErrors.push(err16);
|
|
1343
|
+
}
|
|
1344
|
+
errors++;
|
|
1345
|
+
}
|
|
1346
|
+
if (typeof data7 == "number" && isFinite(data7)) {
|
|
1347
|
+
if (data7 < 0 || isNaN(data7)) {
|
|
1348
|
+
const err17 = { instancePath: instancePath + "/into", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
1349
|
+
if (vErrors === null) {
|
|
1350
|
+
vErrors = [err17];
|
|
1351
|
+
} else {
|
|
1352
|
+
vErrors.push(err17);
|
|
1353
|
+
}
|
|
1354
|
+
errors++;
|
|
1355
|
+
}
|
|
1356
|
+
}
|
|
1357
|
+
}
|
|
832
1358
|
} else {
|
|
833
|
-
const
|
|
1359
|
+
const err18 = { instancePath, schemaPath: "#/oneOf/0/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
834
1360
|
if (vErrors === null) {
|
|
835
|
-
vErrors = [
|
|
1361
|
+
vErrors = [err18];
|
|
836
1362
|
} else {
|
|
837
|
-
vErrors.push(
|
|
1363
|
+
vErrors.push(err18);
|
|
838
1364
|
}
|
|
839
1365
|
errors++;
|
|
840
1366
|
}
|
|
841
1367
|
} else if (tag0 === "action") {
|
|
842
1368
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
843
1369
|
if (data.type === void 0) {
|
|
844
|
-
const
|
|
1370
|
+
const err19 = { instancePath, schemaPath: "#/oneOf/1/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
845
1371
|
if (vErrors === null) {
|
|
846
|
-
vErrors = [
|
|
1372
|
+
vErrors = [err19];
|
|
847
1373
|
} else {
|
|
848
|
-
vErrors.push(
|
|
1374
|
+
vErrors.push(err19);
|
|
849
1375
|
}
|
|
850
1376
|
errors++;
|
|
851
1377
|
}
|
|
852
1378
|
if (data.box === void 0) {
|
|
853
|
-
const
|
|
1379
|
+
const err20 = { instancePath, schemaPath: "#/oneOf/1/required", keyword: "required", params: { missingProperty: "box" }, message: "must have required property 'box'" };
|
|
854
1380
|
if (vErrors === null) {
|
|
855
|
-
vErrors = [
|
|
1381
|
+
vErrors = [err20];
|
|
856
1382
|
} else {
|
|
857
|
-
vErrors.push(
|
|
1383
|
+
vErrors.push(err20);
|
|
858
1384
|
}
|
|
859
1385
|
errors++;
|
|
860
1386
|
}
|
|
861
1387
|
if (data.label === void 0) {
|
|
862
|
-
const
|
|
1388
|
+
const err21 = { instancePath, schemaPath: "#/oneOf/1/required", keyword: "required", params: { missingProperty: "label" }, message: "must have required property 'label'" };
|
|
863
1389
|
if (vErrors === null) {
|
|
864
|
-
vErrors = [
|
|
1390
|
+
vErrors = [err21];
|
|
865
1391
|
} else {
|
|
866
|
-
vErrors.push(
|
|
1392
|
+
vErrors.push(err21);
|
|
867
1393
|
}
|
|
868
1394
|
errors++;
|
|
869
1395
|
}
|
|
870
1396
|
for (const key1 in data) {
|
|
871
1397
|
if (!(key1 === "type" || key1 === "box" || key1 === "label")) {
|
|
872
|
-
const
|
|
1398
|
+
const err22 = { instancePath, schemaPath: "#/oneOf/1/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
|
|
873
1399
|
if (vErrors === null) {
|
|
874
|
-
vErrors = [
|
|
1400
|
+
vErrors = [err22];
|
|
875
1401
|
} else {
|
|
876
|
-
vErrors.push(
|
|
1402
|
+
vErrors.push(err22);
|
|
877
1403
|
}
|
|
878
1404
|
errors++;
|
|
879
1405
|
}
|
|
880
1406
|
}
|
|
881
1407
|
if (data.type !== void 0) {
|
|
882
1408
|
if ("action" !== data.type) {
|
|
883
|
-
const
|
|
1409
|
+
const err23 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/1/properties/type/const", keyword: "const", params: { allowedValue: "action" }, message: "must be equal to constant" };
|
|
884
1410
|
if (vErrors === null) {
|
|
885
|
-
vErrors = [
|
|
1411
|
+
vErrors = [err23];
|
|
886
1412
|
} else {
|
|
887
|
-
vErrors.push(
|
|
1413
|
+
vErrors.push(err23);
|
|
888
1414
|
}
|
|
889
1415
|
errors++;
|
|
890
1416
|
}
|
|
891
1417
|
}
|
|
892
1418
|
if (data.box !== void 0) {
|
|
893
|
-
let
|
|
894
|
-
if (typeof
|
|
895
|
-
if (!pattern0.test(
|
|
896
|
-
const
|
|
1419
|
+
let data9 = data.box;
|
|
1420
|
+
if (typeof data9 === "string") {
|
|
1421
|
+
if (!pattern0.test(data9)) {
|
|
1422
|
+
const err24 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
897
1423
|
if (vErrors === null) {
|
|
898
|
-
vErrors = [
|
|
1424
|
+
vErrors = [err24];
|
|
899
1425
|
} else {
|
|
900
|
-
vErrors.push(
|
|
1426
|
+
vErrors.push(err24);
|
|
901
1427
|
}
|
|
902
1428
|
errors++;
|
|
903
1429
|
}
|
|
904
1430
|
} else {
|
|
905
|
-
const
|
|
1431
|
+
const err25 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
906
1432
|
if (vErrors === null) {
|
|
907
|
-
vErrors = [
|
|
1433
|
+
vErrors = [err25];
|
|
908
1434
|
} else {
|
|
909
|
-
vErrors.push(
|
|
1435
|
+
vErrors.push(err25);
|
|
910
1436
|
}
|
|
911
1437
|
errors++;
|
|
912
1438
|
}
|
|
913
1439
|
}
|
|
914
1440
|
if (data.label !== void 0) {
|
|
915
|
-
let
|
|
916
|
-
if (typeof
|
|
917
|
-
if (func3(
|
|
918
|
-
const
|
|
1441
|
+
let data10 = data.label;
|
|
1442
|
+
if (typeof data10 === "string") {
|
|
1443
|
+
if (func3(data10) < 1) {
|
|
1444
|
+
const err26 = { instancePath: instancePath + "/label", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
919
1445
|
if (vErrors === null) {
|
|
920
|
-
vErrors = [
|
|
1446
|
+
vErrors = [err26];
|
|
921
1447
|
} else {
|
|
922
|
-
vErrors.push(
|
|
1448
|
+
vErrors.push(err26);
|
|
923
1449
|
}
|
|
924
1450
|
errors++;
|
|
925
1451
|
}
|
|
926
1452
|
} else {
|
|
927
|
-
const
|
|
1453
|
+
const err27 = { instancePath: instancePath + "/label", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
928
1454
|
if (vErrors === null) {
|
|
929
|
-
vErrors = [
|
|
1455
|
+
vErrors = [err27];
|
|
930
1456
|
} else {
|
|
931
|
-
vErrors.push(
|
|
1457
|
+
vErrors.push(err27);
|
|
932
1458
|
}
|
|
933
1459
|
errors++;
|
|
934
1460
|
}
|
|
935
1461
|
}
|
|
936
1462
|
} else {
|
|
937
|
-
const
|
|
1463
|
+
const err28 = { instancePath, schemaPath: "#/oneOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
938
1464
|
if (vErrors === null) {
|
|
939
|
-
vErrors = [
|
|
1465
|
+
vErrors = [err28];
|
|
940
1466
|
} else {
|
|
941
|
-
vErrors.push(
|
|
1467
|
+
vErrors.push(err28);
|
|
942
1468
|
}
|
|
943
1469
|
errors++;
|
|
944
1470
|
}
|
|
945
1471
|
} else if (tag0 === "swap") {
|
|
946
1472
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
947
1473
|
if (data.type === void 0) {
|
|
948
|
-
const
|
|
1474
|
+
const err29 = { instancePath, schemaPath: "#/oneOf/2/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
949
1475
|
if (vErrors === null) {
|
|
950
|
-
vErrors = [
|
|
1476
|
+
vErrors = [err29];
|
|
951
1477
|
} else {
|
|
952
|
-
vErrors.push(
|
|
1478
|
+
vErrors.push(err29);
|
|
953
1479
|
}
|
|
954
1480
|
errors++;
|
|
955
1481
|
}
|
|
956
1482
|
if (data.box === void 0) {
|
|
957
|
-
const
|
|
1483
|
+
const err30 = { instancePath, schemaPath: "#/oneOf/2/required", keyword: "required", params: { missingProperty: "box" }, message: "must have required property 'box'" };
|
|
958
1484
|
if (vErrors === null) {
|
|
959
|
-
vErrors = [
|
|
1485
|
+
vErrors = [err30];
|
|
960
1486
|
} else {
|
|
961
|
-
vErrors.push(
|
|
1487
|
+
vErrors.push(err30);
|
|
962
1488
|
}
|
|
963
1489
|
errors++;
|
|
964
1490
|
}
|
|
965
1491
|
if (data.text === void 0) {
|
|
966
|
-
const
|
|
1492
|
+
const err31 = { instancePath, schemaPath: "#/oneOf/2/required", keyword: "required", params: { missingProperty: "text" }, message: "must have required property 'text'" };
|
|
967
1493
|
if (vErrors === null) {
|
|
968
|
-
vErrors = [
|
|
1494
|
+
vErrors = [err31];
|
|
969
1495
|
} else {
|
|
970
|
-
vErrors.push(
|
|
1496
|
+
vErrors.push(err31);
|
|
971
1497
|
}
|
|
972
1498
|
errors++;
|
|
973
1499
|
}
|
|
974
1500
|
for (const key2 in data) {
|
|
975
|
-
if (!(key2 === "type" || key2 === "box" || key2 === "text")) {
|
|
976
|
-
const
|
|
1501
|
+
if (!(key2 === "type" || key2 === "box" || key2 === "text" || key2 === "color")) {
|
|
1502
|
+
const err32 = { instancePath, schemaPath: "#/oneOf/2/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
|
|
977
1503
|
if (vErrors === null) {
|
|
978
|
-
vErrors = [
|
|
1504
|
+
vErrors = [err32];
|
|
979
1505
|
} else {
|
|
980
|
-
vErrors.push(
|
|
1506
|
+
vErrors.push(err32);
|
|
981
1507
|
}
|
|
982
1508
|
errors++;
|
|
983
1509
|
}
|
|
984
1510
|
}
|
|
985
1511
|
if (data.type !== void 0) {
|
|
986
1512
|
if ("swap" !== data.type) {
|
|
987
|
-
const
|
|
1513
|
+
const err33 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/2/properties/type/const", keyword: "const", params: { allowedValue: "swap" }, message: "must be equal to constant" };
|
|
988
1514
|
if (vErrors === null) {
|
|
989
|
-
vErrors = [
|
|
1515
|
+
vErrors = [err33];
|
|
990
1516
|
} else {
|
|
991
|
-
vErrors.push(
|
|
1517
|
+
vErrors.push(err33);
|
|
992
1518
|
}
|
|
993
1519
|
errors++;
|
|
994
1520
|
}
|
|
995
1521
|
}
|
|
996
1522
|
if (data.box !== void 0) {
|
|
997
|
-
let
|
|
998
|
-
if (typeof
|
|
999
|
-
if (!pattern0.test(
|
|
1000
|
-
const
|
|
1523
|
+
let data12 = data.box;
|
|
1524
|
+
if (typeof data12 === "string") {
|
|
1525
|
+
if (!pattern0.test(data12)) {
|
|
1526
|
+
const err34 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1001
1527
|
if (vErrors === null) {
|
|
1002
|
-
vErrors = [
|
|
1528
|
+
vErrors = [err34];
|
|
1003
1529
|
} else {
|
|
1004
|
-
vErrors.push(
|
|
1530
|
+
vErrors.push(err34);
|
|
1005
1531
|
}
|
|
1006
1532
|
errors++;
|
|
1007
1533
|
}
|
|
1008
1534
|
} else {
|
|
1009
|
-
const
|
|
1535
|
+
const err35 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1010
1536
|
if (vErrors === null) {
|
|
1011
|
-
vErrors = [
|
|
1537
|
+
vErrors = [err35];
|
|
1012
1538
|
} else {
|
|
1013
|
-
vErrors.push(
|
|
1539
|
+
vErrors.push(err35);
|
|
1014
1540
|
}
|
|
1015
1541
|
errors++;
|
|
1016
1542
|
}
|
|
1017
1543
|
}
|
|
1018
1544
|
if (data.text !== void 0) {
|
|
1019
|
-
let
|
|
1020
|
-
if (typeof
|
|
1021
|
-
if (func3(
|
|
1022
|
-
const
|
|
1545
|
+
let data13 = data.text;
|
|
1546
|
+
if (typeof data13 === "string") {
|
|
1547
|
+
if (func3(data13) < 1) {
|
|
1548
|
+
const err36 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
1023
1549
|
if (vErrors === null) {
|
|
1024
|
-
vErrors = [
|
|
1550
|
+
vErrors = [err36];
|
|
1025
1551
|
} else {
|
|
1026
|
-
vErrors.push(
|
|
1552
|
+
vErrors.push(err36);
|
|
1027
1553
|
}
|
|
1028
1554
|
errors++;
|
|
1029
1555
|
}
|
|
1030
1556
|
} else {
|
|
1031
|
-
const
|
|
1557
|
+
const err37 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1032
1558
|
if (vErrors === null) {
|
|
1033
|
-
vErrors = [
|
|
1559
|
+
vErrors = [err37];
|
|
1034
1560
|
} else {
|
|
1035
|
-
vErrors.push(
|
|
1561
|
+
vErrors.push(err37);
|
|
1562
|
+
}
|
|
1563
|
+
errors++;
|
|
1564
|
+
}
|
|
1565
|
+
}
|
|
1566
|
+
if (data.color !== void 0) {
|
|
1567
|
+
let data14 = data.color;
|
|
1568
|
+
if (!(data14 === "blue" || data14 === "amber" || data14 === "green" || data14 === "violet" || data14 === "rose" || data14 === "slate" || data14 === "coin")) {
|
|
1569
|
+
const err38 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema45.enum }, message: "must be equal to one of the allowed values" };
|
|
1570
|
+
if (vErrors === null) {
|
|
1571
|
+
vErrors = [err38];
|
|
1572
|
+
} else {
|
|
1573
|
+
vErrors.push(err38);
|
|
1036
1574
|
}
|
|
1037
1575
|
errors++;
|
|
1038
1576
|
}
|
|
1039
1577
|
}
|
|
1040
1578
|
} else {
|
|
1041
|
-
const
|
|
1579
|
+
const err39 = { instancePath, schemaPath: "#/oneOf/2/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1042
1580
|
if (vErrors === null) {
|
|
1043
|
-
vErrors = [
|
|
1581
|
+
vErrors = [err39];
|
|
1044
1582
|
} else {
|
|
1045
|
-
vErrors.push(
|
|
1583
|
+
vErrors.push(err39);
|
|
1046
1584
|
}
|
|
1047
1585
|
errors++;
|
|
1048
1586
|
}
|
|
1049
1587
|
} else if (tag0 === "commit") {
|
|
1050
1588
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
1051
1589
|
if (data.type === void 0) {
|
|
1052
|
-
const
|
|
1590
|
+
const err40 = { instancePath, schemaPath: "#/oneOf/3/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
1053
1591
|
if (vErrors === null) {
|
|
1054
|
-
vErrors = [
|
|
1592
|
+
vErrors = [err40];
|
|
1055
1593
|
} else {
|
|
1056
|
-
vErrors.push(
|
|
1594
|
+
vErrors.push(err40);
|
|
1057
1595
|
}
|
|
1058
1596
|
errors++;
|
|
1059
1597
|
}
|
|
1060
1598
|
if (data.id === void 0) {
|
|
1061
|
-
const
|
|
1599
|
+
const err41 = { instancePath, schemaPath: "#/oneOf/3/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property 'id'" };
|
|
1062
1600
|
if (vErrors === null) {
|
|
1063
|
-
vErrors = [
|
|
1601
|
+
vErrors = [err41];
|
|
1064
1602
|
} else {
|
|
1065
|
-
vErrors.push(
|
|
1603
|
+
vErrors.push(err41);
|
|
1066
1604
|
}
|
|
1067
1605
|
errors++;
|
|
1068
1606
|
}
|
|
1069
1607
|
if (data.branch === void 0) {
|
|
1070
|
-
const
|
|
1608
|
+
const err42 = { instancePath, schemaPath: "#/oneOf/3/required", keyword: "required", params: { missingProperty: "branch" }, message: "must have required property 'branch'" };
|
|
1071
1609
|
if (vErrors === null) {
|
|
1072
|
-
vErrors = [
|
|
1610
|
+
vErrors = [err42];
|
|
1073
1611
|
} else {
|
|
1074
|
-
vErrors.push(
|
|
1612
|
+
vErrors.push(err42);
|
|
1075
1613
|
}
|
|
1076
1614
|
errors++;
|
|
1077
1615
|
}
|
|
1078
1616
|
for (const key3 in data) {
|
|
1079
1617
|
if (!(key3 === "type" || key3 === "id" || key3 === "branch" || key3 === "copy" || key3 === "merge" || key3 === "hash" || key3 === "note")) {
|
|
1080
|
-
const
|
|
1618
|
+
const err43 = { instancePath, schemaPath: "#/oneOf/3/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
|
|
1081
1619
|
if (vErrors === null) {
|
|
1082
|
-
vErrors = [
|
|
1620
|
+
vErrors = [err43];
|
|
1083
1621
|
} else {
|
|
1084
|
-
vErrors.push(
|
|
1622
|
+
vErrors.push(err43);
|
|
1085
1623
|
}
|
|
1086
1624
|
errors++;
|
|
1087
1625
|
}
|
|
1088
1626
|
}
|
|
1089
1627
|
if (data.type !== void 0) {
|
|
1090
1628
|
if ("commit" !== data.type) {
|
|
1091
|
-
const
|
|
1629
|
+
const err44 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/3/properties/type/const", keyword: "const", params: { allowedValue: "commit" }, message: "must be equal to constant" };
|
|
1092
1630
|
if (vErrors === null) {
|
|
1093
|
-
vErrors = [
|
|
1631
|
+
vErrors = [err44];
|
|
1094
1632
|
} else {
|
|
1095
|
-
vErrors.push(
|
|
1633
|
+
vErrors.push(err44);
|
|
1096
1634
|
}
|
|
1097
1635
|
errors++;
|
|
1098
1636
|
}
|
|
1099
1637
|
}
|
|
1100
1638
|
if (data.id !== void 0) {
|
|
1101
|
-
let
|
|
1102
|
-
if (typeof
|
|
1103
|
-
if (!pattern0.test(
|
|
1104
|
-
const
|
|
1639
|
+
let data16 = data.id;
|
|
1640
|
+
if (typeof data16 === "string") {
|
|
1641
|
+
if (!pattern0.test(data16)) {
|
|
1642
|
+
const err45 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1105
1643
|
if (vErrors === null) {
|
|
1106
|
-
vErrors = [
|
|
1644
|
+
vErrors = [err45];
|
|
1107
1645
|
} else {
|
|
1108
|
-
vErrors.push(
|
|
1646
|
+
vErrors.push(err45);
|
|
1109
1647
|
}
|
|
1110
1648
|
errors++;
|
|
1111
1649
|
}
|
|
1112
1650
|
} else {
|
|
1113
|
-
const
|
|
1651
|
+
const err46 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1114
1652
|
if (vErrors === null) {
|
|
1115
|
-
vErrors = [
|
|
1653
|
+
vErrors = [err46];
|
|
1116
1654
|
} else {
|
|
1117
|
-
vErrors.push(
|
|
1655
|
+
vErrors.push(err46);
|
|
1118
1656
|
}
|
|
1119
1657
|
errors++;
|
|
1120
1658
|
}
|
|
1121
1659
|
}
|
|
1122
1660
|
if (data.branch !== void 0) {
|
|
1123
|
-
let
|
|
1124
|
-
if (typeof
|
|
1125
|
-
if (!pattern0.test(
|
|
1126
|
-
const
|
|
1661
|
+
let data17 = data.branch;
|
|
1662
|
+
if (typeof data17 === "string") {
|
|
1663
|
+
if (!pattern0.test(data17)) {
|
|
1664
|
+
const err47 = { instancePath: instancePath + "/branch", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1127
1665
|
if (vErrors === null) {
|
|
1128
|
-
vErrors = [
|
|
1666
|
+
vErrors = [err47];
|
|
1129
1667
|
} else {
|
|
1130
|
-
vErrors.push(
|
|
1668
|
+
vErrors.push(err47);
|
|
1131
1669
|
}
|
|
1132
1670
|
errors++;
|
|
1133
1671
|
}
|
|
1134
1672
|
} else {
|
|
1135
|
-
const
|
|
1673
|
+
const err48 = { instancePath: instancePath + "/branch", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1136
1674
|
if (vErrors === null) {
|
|
1137
|
-
vErrors = [
|
|
1675
|
+
vErrors = [err48];
|
|
1138
1676
|
} else {
|
|
1139
|
-
vErrors.push(
|
|
1677
|
+
vErrors.push(err48);
|
|
1140
1678
|
}
|
|
1141
1679
|
errors++;
|
|
1142
1680
|
}
|
|
1143
1681
|
}
|
|
1144
1682
|
if (data.copy !== void 0) {
|
|
1145
|
-
let
|
|
1146
|
-
if (typeof
|
|
1147
|
-
if (!pattern0.test(
|
|
1148
|
-
const
|
|
1683
|
+
let data18 = data.copy;
|
|
1684
|
+
if (typeof data18 === "string") {
|
|
1685
|
+
if (!pattern0.test(data18)) {
|
|
1686
|
+
const err49 = { instancePath: instancePath + "/copy", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1149
1687
|
if (vErrors === null) {
|
|
1150
|
-
vErrors = [
|
|
1688
|
+
vErrors = [err49];
|
|
1151
1689
|
} else {
|
|
1152
|
-
vErrors.push(
|
|
1690
|
+
vErrors.push(err49);
|
|
1153
1691
|
}
|
|
1154
1692
|
errors++;
|
|
1155
1693
|
}
|
|
1156
1694
|
} else {
|
|
1157
|
-
const
|
|
1695
|
+
const err50 = { instancePath: instancePath + "/copy", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1158
1696
|
if (vErrors === null) {
|
|
1159
|
-
vErrors = [
|
|
1697
|
+
vErrors = [err50];
|
|
1160
1698
|
} else {
|
|
1161
|
-
vErrors.push(
|
|
1699
|
+
vErrors.push(err50);
|
|
1162
1700
|
}
|
|
1163
1701
|
errors++;
|
|
1164
1702
|
}
|
|
1165
1703
|
}
|
|
1166
1704
|
if (data.merge !== void 0) {
|
|
1167
|
-
let
|
|
1168
|
-
if (typeof
|
|
1169
|
-
if (!pattern0.test(
|
|
1170
|
-
const
|
|
1705
|
+
let data19 = data.merge;
|
|
1706
|
+
if (typeof data19 === "string") {
|
|
1707
|
+
if (!pattern0.test(data19)) {
|
|
1708
|
+
const err51 = { instancePath: instancePath + "/merge", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1171
1709
|
if (vErrors === null) {
|
|
1172
|
-
vErrors = [
|
|
1710
|
+
vErrors = [err51];
|
|
1173
1711
|
} else {
|
|
1174
|
-
vErrors.push(
|
|
1712
|
+
vErrors.push(err51);
|
|
1175
1713
|
}
|
|
1176
1714
|
errors++;
|
|
1177
1715
|
}
|
|
1178
1716
|
} else {
|
|
1179
|
-
const
|
|
1717
|
+
const err52 = { instancePath: instancePath + "/merge", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1180
1718
|
if (vErrors === null) {
|
|
1181
|
-
vErrors = [
|
|
1719
|
+
vErrors = [err52];
|
|
1182
1720
|
} else {
|
|
1183
|
-
vErrors.push(
|
|
1721
|
+
vErrors.push(err52);
|
|
1184
1722
|
}
|
|
1185
1723
|
errors++;
|
|
1186
1724
|
}
|
|
1187
1725
|
}
|
|
1188
1726
|
if (data.hash !== void 0) {
|
|
1189
|
-
let
|
|
1190
|
-
if (typeof
|
|
1191
|
-
if (!
|
|
1192
|
-
const
|
|
1727
|
+
let data20 = data.hash;
|
|
1728
|
+
if (typeof data20 === "string") {
|
|
1729
|
+
if (!pattern14.test(data20)) {
|
|
1730
|
+
const err53 = { instancePath: instancePath + "/hash", schemaPath: "#/definitions/hash/pattern", keyword: "pattern", params: { pattern: "^[0-9a-f]{4,40}$" }, message: 'must match pattern "^[0-9a-f]{4,40}$"' };
|
|
1193
1731
|
if (vErrors === null) {
|
|
1194
|
-
vErrors = [
|
|
1732
|
+
vErrors = [err53];
|
|
1195
1733
|
} else {
|
|
1196
|
-
vErrors.push(
|
|
1734
|
+
vErrors.push(err53);
|
|
1197
1735
|
}
|
|
1198
1736
|
errors++;
|
|
1199
1737
|
}
|
|
1200
1738
|
} else {
|
|
1201
|
-
const
|
|
1739
|
+
const err54 = { instancePath: instancePath + "/hash", schemaPath: "#/definitions/hash/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1202
1740
|
if (vErrors === null) {
|
|
1203
|
-
vErrors = [
|
|
1741
|
+
vErrors = [err54];
|
|
1204
1742
|
} else {
|
|
1205
|
-
vErrors.push(
|
|
1743
|
+
vErrors.push(err54);
|
|
1206
1744
|
}
|
|
1207
1745
|
errors++;
|
|
1208
1746
|
}
|
|
1209
1747
|
}
|
|
1210
1748
|
if (data.note !== void 0) {
|
|
1211
|
-
let
|
|
1212
|
-
if (typeof
|
|
1213
|
-
if (func3(
|
|
1214
|
-
const
|
|
1749
|
+
let data21 = data.note;
|
|
1750
|
+
if (typeof data21 === "string") {
|
|
1751
|
+
if (func3(data21) < 1) {
|
|
1752
|
+
const err55 = { instancePath: instancePath + "/note", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
1215
1753
|
if (vErrors === null) {
|
|
1216
|
-
vErrors = [
|
|
1754
|
+
vErrors = [err55];
|
|
1217
1755
|
} else {
|
|
1218
|
-
vErrors.push(
|
|
1756
|
+
vErrors.push(err55);
|
|
1219
1757
|
}
|
|
1220
1758
|
errors++;
|
|
1221
1759
|
}
|
|
1222
1760
|
} else {
|
|
1223
|
-
const
|
|
1761
|
+
const err56 = { instancePath: instancePath + "/note", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1224
1762
|
if (vErrors === null) {
|
|
1225
|
-
vErrors = [
|
|
1763
|
+
vErrors = [err56];
|
|
1226
1764
|
} else {
|
|
1227
|
-
vErrors.push(
|
|
1765
|
+
vErrors.push(err56);
|
|
1228
1766
|
}
|
|
1229
1767
|
errors++;
|
|
1230
1768
|
}
|
|
1231
1769
|
}
|
|
1232
1770
|
} else {
|
|
1233
|
-
const
|
|
1771
|
+
const err57 = { instancePath, schemaPath: "#/oneOf/3/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1234
1772
|
if (vErrors === null) {
|
|
1235
|
-
vErrors = [
|
|
1773
|
+
vErrors = [err57];
|
|
1236
1774
|
} else {
|
|
1237
|
-
vErrors.push(
|
|
1775
|
+
vErrors.push(err57);
|
|
1238
1776
|
}
|
|
1239
1777
|
errors++;
|
|
1240
1778
|
}
|
|
1241
1779
|
} else if (tag0 === "branch") {
|
|
1242
1780
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
1243
1781
|
if (data.type === void 0) {
|
|
1244
|
-
const
|
|
1782
|
+
const err58 = { instancePath, schemaPath: "#/oneOf/4/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
1245
1783
|
if (vErrors === null) {
|
|
1246
|
-
vErrors = [
|
|
1784
|
+
vErrors = [err58];
|
|
1247
1785
|
} else {
|
|
1248
|
-
vErrors.push(
|
|
1786
|
+
vErrors.push(err58);
|
|
1249
1787
|
}
|
|
1250
1788
|
errors++;
|
|
1251
1789
|
}
|
|
1252
1790
|
if (data.branch === void 0) {
|
|
1253
|
-
const
|
|
1791
|
+
const err59 = { instancePath, schemaPath: "#/oneOf/4/required", keyword: "required", params: { missingProperty: "branch" }, message: "must have required property 'branch'" };
|
|
1254
1792
|
if (vErrors === null) {
|
|
1255
|
-
vErrors = [
|
|
1793
|
+
vErrors = [err59];
|
|
1256
1794
|
} else {
|
|
1257
|
-
vErrors.push(
|
|
1795
|
+
vErrors.push(err59);
|
|
1258
1796
|
}
|
|
1259
1797
|
errors++;
|
|
1260
1798
|
}
|
|
1261
1799
|
if (data.from === void 0) {
|
|
1262
|
-
const
|
|
1800
|
+
const err60 = { instancePath, schemaPath: "#/oneOf/4/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
|
|
1263
1801
|
if (vErrors === null) {
|
|
1264
|
-
vErrors = [
|
|
1802
|
+
vErrors = [err60];
|
|
1265
1803
|
} else {
|
|
1266
|
-
vErrors.push(
|
|
1804
|
+
vErrors.push(err60);
|
|
1267
1805
|
}
|
|
1268
1806
|
errors++;
|
|
1269
1807
|
}
|
|
1270
1808
|
for (const key4 in data) {
|
|
1271
1809
|
if (!(key4 === "type" || key4 === "branch" || key4 === "from")) {
|
|
1272
|
-
const
|
|
1810
|
+
const err61 = { instancePath, schemaPath: "#/oneOf/4/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key4 }, message: "must NOT have additional properties" };
|
|
1273
1811
|
if (vErrors === null) {
|
|
1274
|
-
vErrors = [
|
|
1812
|
+
vErrors = [err61];
|
|
1275
1813
|
} else {
|
|
1276
|
-
vErrors.push(
|
|
1814
|
+
vErrors.push(err61);
|
|
1277
1815
|
}
|
|
1278
1816
|
errors++;
|
|
1279
1817
|
}
|
|
1280
1818
|
}
|
|
1281
1819
|
if (data.type !== void 0) {
|
|
1282
1820
|
if ("branch" !== data.type) {
|
|
1283
|
-
const
|
|
1821
|
+
const err62 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/4/properties/type/const", keyword: "const", params: { allowedValue: "branch" }, message: "must be equal to constant" };
|
|
1284
1822
|
if (vErrors === null) {
|
|
1285
|
-
vErrors = [
|
|
1823
|
+
vErrors = [err62];
|
|
1286
1824
|
} else {
|
|
1287
|
-
vErrors.push(
|
|
1825
|
+
vErrors.push(err62);
|
|
1288
1826
|
}
|
|
1289
1827
|
errors++;
|
|
1290
1828
|
}
|
|
1291
1829
|
}
|
|
1292
1830
|
if (data.branch !== void 0) {
|
|
1293
|
-
let
|
|
1294
|
-
if (typeof
|
|
1295
|
-
if (!pattern0.test(
|
|
1296
|
-
const
|
|
1831
|
+
let data23 = data.branch;
|
|
1832
|
+
if (typeof data23 === "string") {
|
|
1833
|
+
if (!pattern0.test(data23)) {
|
|
1834
|
+
const err63 = { instancePath: instancePath + "/branch", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1297
1835
|
if (vErrors === null) {
|
|
1298
|
-
vErrors = [
|
|
1836
|
+
vErrors = [err63];
|
|
1299
1837
|
} else {
|
|
1300
|
-
vErrors.push(
|
|
1838
|
+
vErrors.push(err63);
|
|
1301
1839
|
}
|
|
1302
1840
|
errors++;
|
|
1303
1841
|
}
|
|
1304
1842
|
} else {
|
|
1305
|
-
const
|
|
1843
|
+
const err64 = { instancePath: instancePath + "/branch", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1306
1844
|
if (vErrors === null) {
|
|
1307
|
-
vErrors = [
|
|
1845
|
+
vErrors = [err64];
|
|
1308
1846
|
} else {
|
|
1309
|
-
vErrors.push(
|
|
1847
|
+
vErrors.push(err64);
|
|
1310
1848
|
}
|
|
1311
1849
|
errors++;
|
|
1312
1850
|
}
|
|
1313
1851
|
}
|
|
1314
1852
|
if (data.from !== void 0) {
|
|
1315
|
-
let
|
|
1316
|
-
if (typeof
|
|
1317
|
-
if (!pattern0.test(
|
|
1318
|
-
const
|
|
1853
|
+
let data24 = data.from;
|
|
1854
|
+
if (typeof data24 === "string") {
|
|
1855
|
+
if (!pattern0.test(data24)) {
|
|
1856
|
+
const err65 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1319
1857
|
if (vErrors === null) {
|
|
1320
|
-
vErrors = [
|
|
1858
|
+
vErrors = [err65];
|
|
1321
1859
|
} else {
|
|
1322
|
-
vErrors.push(
|
|
1860
|
+
vErrors.push(err65);
|
|
1323
1861
|
}
|
|
1324
1862
|
errors++;
|
|
1325
1863
|
}
|
|
1326
1864
|
} else {
|
|
1327
|
-
const
|
|
1865
|
+
const err66 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1328
1866
|
if (vErrors === null) {
|
|
1329
|
-
vErrors = [
|
|
1867
|
+
vErrors = [err66];
|
|
1330
1868
|
} else {
|
|
1331
|
-
vErrors.push(
|
|
1869
|
+
vErrors.push(err66);
|
|
1332
1870
|
}
|
|
1333
1871
|
errors++;
|
|
1334
1872
|
}
|
|
1335
1873
|
}
|
|
1336
1874
|
} else {
|
|
1337
|
-
const
|
|
1875
|
+
const err67 = { instancePath, schemaPath: "#/oneOf/4/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1338
1876
|
if (vErrors === null) {
|
|
1339
|
-
vErrors = [
|
|
1877
|
+
vErrors = [err67];
|
|
1340
1878
|
} else {
|
|
1341
|
-
vErrors.push(
|
|
1879
|
+
vErrors.push(err67);
|
|
1342
1880
|
}
|
|
1343
1881
|
errors++;
|
|
1344
1882
|
}
|
|
1345
|
-
} else if (tag0 === "
|
|
1346
|
-
const _errs71 = errors;
|
|
1347
|
-
let valid27 = false;
|
|
1348
|
-
const _errs72 = errors;
|
|
1883
|
+
} else if (tag0 === "now") {
|
|
1349
1884
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
1350
|
-
if (data.
|
|
1351
|
-
const
|
|
1885
|
+
if (data.type === void 0) {
|
|
1886
|
+
const err68 = { instancePath, schemaPath: "#/oneOf/5/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
1352
1887
|
if (vErrors === null) {
|
|
1353
|
-
vErrors = [
|
|
1888
|
+
vErrors = [err68];
|
|
1354
1889
|
} else {
|
|
1355
|
-
vErrors.push(
|
|
1890
|
+
vErrors.push(err68);
|
|
1356
1891
|
}
|
|
1357
1892
|
errors++;
|
|
1358
1893
|
}
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
|
|
1364
|
-
|
|
1365
|
-
|
|
1366
|
-
|
|
1894
|
+
if (data.to === void 0) {
|
|
1895
|
+
const err69 = { instancePath, schemaPath: "#/oneOf/5/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
|
|
1896
|
+
if (vErrors === null) {
|
|
1897
|
+
vErrors = [err69];
|
|
1898
|
+
} else {
|
|
1899
|
+
vErrors.push(err69);
|
|
1900
|
+
}
|
|
1901
|
+
errors++;
|
|
1902
|
+
}
|
|
1903
|
+
for (const key5 in data) {
|
|
1904
|
+
if (!(key5 === "type" || key5 === "to")) {
|
|
1905
|
+
const err70 = { instancePath, schemaPath: "#/oneOf/5/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key5 }, message: "must NOT have additional properties" };
|
|
1367
1906
|
if (vErrors === null) {
|
|
1368
|
-
vErrors = [
|
|
1907
|
+
vErrors = [err70];
|
|
1369
1908
|
} else {
|
|
1370
|
-
vErrors.push(
|
|
1909
|
+
vErrors.push(err70);
|
|
1371
1910
|
}
|
|
1372
1911
|
errors++;
|
|
1373
1912
|
}
|
|
1374
1913
|
}
|
|
1375
|
-
|
|
1376
|
-
|
|
1377
|
-
|
|
1378
|
-
|
|
1379
|
-
|
|
1914
|
+
if (data.type !== void 0) {
|
|
1915
|
+
if ("now" !== data.type) {
|
|
1916
|
+
const err71 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/5/properties/type/const", keyword: "const", params: { allowedValue: "now" }, message: "must be equal to constant" };
|
|
1917
|
+
if (vErrors === null) {
|
|
1918
|
+
vErrors = [err71];
|
|
1919
|
+
} else {
|
|
1920
|
+
vErrors.push(err71);
|
|
1921
|
+
}
|
|
1922
|
+
errors++;
|
|
1923
|
+
}
|
|
1924
|
+
}
|
|
1925
|
+
if (data.to !== void 0) {
|
|
1926
|
+
let data26 = data.to;
|
|
1927
|
+
if (!(typeof data26 == "number" && (!(data26 % 1) && !isNaN(data26)) && isFinite(data26))) {
|
|
1928
|
+
const err72 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
1929
|
+
if (vErrors === null) {
|
|
1930
|
+
vErrors = [err72];
|
|
1931
|
+
} else {
|
|
1932
|
+
vErrors.push(err72);
|
|
1933
|
+
}
|
|
1934
|
+
errors++;
|
|
1935
|
+
}
|
|
1936
|
+
if (typeof data26 == "number" && isFinite(data26)) {
|
|
1937
|
+
if (data26 < 0 || isNaN(data26)) {
|
|
1938
|
+
const err73 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
1939
|
+
if (vErrors === null) {
|
|
1940
|
+
vErrors = [err73];
|
|
1941
|
+
} else {
|
|
1942
|
+
vErrors.push(err73);
|
|
1943
|
+
}
|
|
1944
|
+
errors++;
|
|
1945
|
+
}
|
|
1946
|
+
}
|
|
1947
|
+
}
|
|
1948
|
+
} else {
|
|
1949
|
+
const err74 = { instancePath, schemaPath: "#/oneOf/5/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1380
1950
|
if (vErrors === null) {
|
|
1381
|
-
vErrors = [
|
|
1951
|
+
vErrors = [err74];
|
|
1382
1952
|
} else {
|
|
1383
|
-
vErrors.push(
|
|
1953
|
+
vErrors.push(err74);
|
|
1384
1954
|
}
|
|
1385
1955
|
errors++;
|
|
1386
|
-
} else {
|
|
1387
|
-
errors = _errs71;
|
|
1388
|
-
if (vErrors !== null) {
|
|
1389
|
-
if (_errs71) {
|
|
1390
|
-
vErrors.length = _errs71;
|
|
1391
|
-
} else {
|
|
1392
|
-
vErrors = null;
|
|
1393
|
-
}
|
|
1394
|
-
}
|
|
1395
1956
|
}
|
|
1957
|
+
} else if (tag0 === "mark") {
|
|
1396
1958
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
1397
1959
|
if (data.type === void 0) {
|
|
1398
|
-
const
|
|
1960
|
+
const err75 = { instancePath, schemaPath: "#/oneOf/6/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
1399
1961
|
if (vErrors === null) {
|
|
1400
|
-
vErrors = [
|
|
1962
|
+
vErrors = [err75];
|
|
1401
1963
|
} else {
|
|
1402
|
-
vErrors.push(
|
|
1964
|
+
vErrors.push(err75);
|
|
1403
1965
|
}
|
|
1404
1966
|
errors++;
|
|
1405
1967
|
}
|
|
1406
|
-
if (data.
|
|
1407
|
-
const
|
|
1968
|
+
if (data.row === void 0) {
|
|
1969
|
+
const err76 = { instancePath, schemaPath: "#/oneOf/6/required", keyword: "required", params: { missingProperty: "row" }, message: "must have required property 'row'" };
|
|
1408
1970
|
if (vErrors === null) {
|
|
1409
|
-
vErrors = [
|
|
1971
|
+
vErrors = [err76];
|
|
1410
1972
|
} else {
|
|
1411
|
-
vErrors.push(
|
|
1973
|
+
vErrors.push(err76);
|
|
1412
1974
|
}
|
|
1413
1975
|
errors++;
|
|
1414
1976
|
}
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1977
|
+
if (data.from === void 0) {
|
|
1978
|
+
const err77 = { instancePath, schemaPath: "#/oneOf/6/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
|
|
1979
|
+
if (vErrors === null) {
|
|
1980
|
+
vErrors = [err77];
|
|
1981
|
+
} else {
|
|
1982
|
+
vErrors.push(err77);
|
|
1983
|
+
}
|
|
1984
|
+
errors++;
|
|
1985
|
+
}
|
|
1986
|
+
if (data.to === void 0) {
|
|
1987
|
+
const err78 = { instancePath, schemaPath: "#/oneOf/6/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
|
|
1988
|
+
if (vErrors === null) {
|
|
1989
|
+
vErrors = [err78];
|
|
1990
|
+
} else {
|
|
1991
|
+
vErrors.push(err78);
|
|
1992
|
+
}
|
|
1993
|
+
errors++;
|
|
1994
|
+
}
|
|
1995
|
+
if (data.color === void 0) {
|
|
1996
|
+
const err79 = { instancePath, schemaPath: "#/oneOf/6/required", keyword: "required", params: { missingProperty: "color" }, message: "must have required property 'color'" };
|
|
1997
|
+
if (vErrors === null) {
|
|
1998
|
+
vErrors = [err79];
|
|
1999
|
+
} else {
|
|
2000
|
+
vErrors.push(err79);
|
|
2001
|
+
}
|
|
2002
|
+
errors++;
|
|
2003
|
+
}
|
|
2004
|
+
for (const key6 in data) {
|
|
2005
|
+
if (!(key6 === "type" || key6 === "row" || key6 === "from" || key6 === "to" || key6 === "color")) {
|
|
2006
|
+
const err80 = { instancePath, schemaPath: "#/oneOf/6/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key6 }, message: "must NOT have additional properties" };
|
|
1418
2007
|
if (vErrors === null) {
|
|
1419
|
-
vErrors = [
|
|
2008
|
+
vErrors = [err80];
|
|
1420
2009
|
} else {
|
|
1421
|
-
vErrors.push(
|
|
2010
|
+
vErrors.push(err80);
|
|
1422
2011
|
}
|
|
1423
2012
|
errors++;
|
|
1424
2013
|
}
|
|
1425
2014
|
}
|
|
1426
2015
|
if (data.type !== void 0) {
|
|
1427
|
-
if ("
|
|
1428
|
-
const
|
|
2016
|
+
if ("mark" !== data.type) {
|
|
2017
|
+
const err81 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/6/properties/type/const", keyword: "const", params: { allowedValue: "mark" }, message: "must be equal to constant" };
|
|
1429
2018
|
if (vErrors === null) {
|
|
1430
|
-
vErrors = [
|
|
2019
|
+
vErrors = [err81];
|
|
1431
2020
|
} else {
|
|
1432
|
-
vErrors.push(
|
|
2021
|
+
vErrors.push(err81);
|
|
1433
2022
|
}
|
|
1434
2023
|
errors++;
|
|
1435
2024
|
}
|
|
1436
2025
|
}
|
|
1437
|
-
if (data.
|
|
1438
|
-
let
|
|
1439
|
-
if (typeof
|
|
1440
|
-
if (
|
|
1441
|
-
const
|
|
2026
|
+
if (data.row !== void 0) {
|
|
2027
|
+
let data28 = data.row;
|
|
2028
|
+
if (typeof data28 === "string") {
|
|
2029
|
+
if (!pattern0.test(data28)) {
|
|
2030
|
+
const err82 = { instancePath: instancePath + "/row", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
1442
2031
|
if (vErrors === null) {
|
|
1443
|
-
vErrors = [
|
|
2032
|
+
vErrors = [err82];
|
|
1444
2033
|
} else {
|
|
1445
|
-
vErrors.push(
|
|
2034
|
+
vErrors.push(err82);
|
|
1446
2035
|
}
|
|
1447
2036
|
errors++;
|
|
1448
2037
|
}
|
|
1449
2038
|
} else {
|
|
1450
|
-
const
|
|
2039
|
+
const err83 = { instancePath: instancePath + "/row", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
1451
2040
|
if (vErrors === null) {
|
|
1452
|
-
vErrors = [
|
|
2041
|
+
vErrors = [err83];
|
|
1453
2042
|
} else {
|
|
1454
|
-
vErrors.push(
|
|
2043
|
+
vErrors.push(err83);
|
|
1455
2044
|
}
|
|
1456
2045
|
errors++;
|
|
1457
2046
|
}
|
|
1458
2047
|
}
|
|
1459
|
-
if (data.
|
|
1460
|
-
let
|
|
1461
|
-
if (typeof
|
|
1462
|
-
|
|
1463
|
-
const err72 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
1464
|
-
if (vErrors === null) {
|
|
1465
|
-
vErrors = [err72];
|
|
1466
|
-
} else {
|
|
1467
|
-
vErrors.push(err72);
|
|
1468
|
-
}
|
|
1469
|
-
errors++;
|
|
1470
|
-
}
|
|
1471
|
-
} else {
|
|
1472
|
-
const err73 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
2048
|
+
if (data.from !== void 0) {
|
|
2049
|
+
let data29 = data.from;
|
|
2050
|
+
if (!(typeof data29 == "number" && (!(data29 % 1) && !isNaN(data29)) && isFinite(data29))) {
|
|
2051
|
+
const err84 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
1473
2052
|
if (vErrors === null) {
|
|
1474
|
-
vErrors = [
|
|
2053
|
+
vErrors = [err84];
|
|
1475
2054
|
} else {
|
|
1476
|
-
vErrors.push(
|
|
2055
|
+
vErrors.push(err84);
|
|
1477
2056
|
}
|
|
1478
2057
|
errors++;
|
|
1479
2058
|
}
|
|
1480
|
-
|
|
1481
|
-
|
|
1482
|
-
|
|
1483
|
-
if (typeof data25 === "string") {
|
|
1484
|
-
if (func3(data25) < 1) {
|
|
1485
|
-
const err74 = { instancePath: instancePath + "/tag", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
2059
|
+
if (typeof data29 == "number" && isFinite(data29)) {
|
|
2060
|
+
if (data29 < 0 || isNaN(data29)) {
|
|
2061
|
+
const err85 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
1486
2062
|
if (vErrors === null) {
|
|
1487
|
-
vErrors = [
|
|
2063
|
+
vErrors = [err85];
|
|
1488
2064
|
} else {
|
|
1489
|
-
vErrors.push(
|
|
2065
|
+
vErrors.push(err85);
|
|
1490
2066
|
}
|
|
1491
2067
|
errors++;
|
|
1492
2068
|
}
|
|
1493
|
-
}
|
|
1494
|
-
|
|
1495
|
-
|
|
1496
|
-
|
|
2069
|
+
}
|
|
2070
|
+
}
|
|
2071
|
+
if (data.to !== void 0) {
|
|
2072
|
+
let data30 = data.to;
|
|
2073
|
+
if (!(typeof data30 == "number" && (!(data30 % 1) && !isNaN(data30)) && isFinite(data30))) {
|
|
2074
|
+
const err86 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
2075
|
+
if (vErrors === null) {
|
|
2076
|
+
vErrors = [err86];
|
|
2077
|
+
} else {
|
|
2078
|
+
vErrors.push(err86);
|
|
2079
|
+
}
|
|
2080
|
+
errors++;
|
|
2081
|
+
}
|
|
2082
|
+
if (typeof data30 == "number" && isFinite(data30)) {
|
|
2083
|
+
if (data30 < 0 || isNaN(data30)) {
|
|
2084
|
+
const err87 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
2085
|
+
if (vErrors === null) {
|
|
2086
|
+
vErrors = [err87];
|
|
2087
|
+
} else {
|
|
2088
|
+
vErrors.push(err87);
|
|
2089
|
+
}
|
|
2090
|
+
errors++;
|
|
2091
|
+
}
|
|
2092
|
+
}
|
|
2093
|
+
}
|
|
2094
|
+
if (data.color !== void 0) {
|
|
2095
|
+
let data31 = data.color;
|
|
2096
|
+
if (!(data31 === "blue" || data31 === "amber" || data31 === "green" || data31 === "violet" || data31 === "rose" || data31 === "slate" || data31 === "coin")) {
|
|
2097
|
+
const err88 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema45.enum }, message: "must be equal to one of the allowed values" };
|
|
2098
|
+
if (vErrors === null) {
|
|
2099
|
+
vErrors = [err88];
|
|
2100
|
+
} else {
|
|
2101
|
+
vErrors.push(err88);
|
|
2102
|
+
}
|
|
2103
|
+
errors++;
|
|
2104
|
+
}
|
|
2105
|
+
}
|
|
2106
|
+
} else {
|
|
2107
|
+
const err89 = { instancePath, schemaPath: "#/oneOf/6/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
2108
|
+
if (vErrors === null) {
|
|
2109
|
+
vErrors = [err89];
|
|
2110
|
+
} else {
|
|
2111
|
+
vErrors.push(err89);
|
|
2112
|
+
}
|
|
2113
|
+
errors++;
|
|
2114
|
+
}
|
|
2115
|
+
} else if (tag0 === "span") {
|
|
2116
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2117
|
+
if (data.type === void 0) {
|
|
2118
|
+
const err90 = { instancePath, schemaPath: "#/oneOf/7/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
2119
|
+
if (vErrors === null) {
|
|
2120
|
+
vErrors = [err90];
|
|
2121
|
+
} else {
|
|
2122
|
+
vErrors.push(err90);
|
|
2123
|
+
}
|
|
2124
|
+
errors++;
|
|
2125
|
+
}
|
|
2126
|
+
if (data.from === void 0) {
|
|
2127
|
+
const err91 = { instancePath, schemaPath: "#/oneOf/7/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
|
|
2128
|
+
if (vErrors === null) {
|
|
2129
|
+
vErrors = [err91];
|
|
2130
|
+
} else {
|
|
2131
|
+
vErrors.push(err91);
|
|
2132
|
+
}
|
|
2133
|
+
errors++;
|
|
2134
|
+
}
|
|
2135
|
+
if (data.to === void 0) {
|
|
2136
|
+
const err92 = { instancePath, schemaPath: "#/oneOf/7/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
|
|
2137
|
+
if (vErrors === null) {
|
|
2138
|
+
vErrors = [err92];
|
|
2139
|
+
} else {
|
|
2140
|
+
vErrors.push(err92);
|
|
2141
|
+
}
|
|
2142
|
+
errors++;
|
|
2143
|
+
}
|
|
2144
|
+
if (data.text === void 0) {
|
|
2145
|
+
const err93 = { instancePath, schemaPath: "#/oneOf/7/required", keyword: "required", params: { missingProperty: "text" }, message: "must have required property 'text'" };
|
|
2146
|
+
if (vErrors === null) {
|
|
2147
|
+
vErrors = [err93];
|
|
2148
|
+
} else {
|
|
2149
|
+
vErrors.push(err93);
|
|
2150
|
+
}
|
|
2151
|
+
errors++;
|
|
2152
|
+
}
|
|
2153
|
+
for (const key7 in data) {
|
|
2154
|
+
if (!(key7 === "type" || key7 === "from" || key7 === "to" || key7 === "text" || key7 === "shape" || key7 === "color")) {
|
|
2155
|
+
const err94 = { instancePath, schemaPath: "#/oneOf/7/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key7 }, message: "must NOT have additional properties" };
|
|
2156
|
+
if (vErrors === null) {
|
|
2157
|
+
vErrors = [err94];
|
|
2158
|
+
} else {
|
|
2159
|
+
vErrors.push(err94);
|
|
2160
|
+
}
|
|
2161
|
+
errors++;
|
|
2162
|
+
}
|
|
2163
|
+
}
|
|
2164
|
+
if (data.type !== void 0) {
|
|
2165
|
+
if ("span" !== data.type) {
|
|
2166
|
+
const err95 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/7/properties/type/const", keyword: "const", params: { allowedValue: "span" }, message: "must be equal to constant" };
|
|
2167
|
+
if (vErrors === null) {
|
|
2168
|
+
vErrors = [err95];
|
|
2169
|
+
} else {
|
|
2170
|
+
vErrors.push(err95);
|
|
2171
|
+
}
|
|
2172
|
+
errors++;
|
|
2173
|
+
}
|
|
2174
|
+
}
|
|
2175
|
+
if (data.from !== void 0) {
|
|
2176
|
+
let data33 = data.from;
|
|
2177
|
+
if (!(typeof data33 == "number" && (!(data33 % 1) && !isNaN(data33)) && isFinite(data33))) {
|
|
2178
|
+
const err96 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
2179
|
+
if (vErrors === null) {
|
|
2180
|
+
vErrors = [err96];
|
|
2181
|
+
} else {
|
|
2182
|
+
vErrors.push(err96);
|
|
2183
|
+
}
|
|
2184
|
+
errors++;
|
|
2185
|
+
}
|
|
2186
|
+
if (typeof data33 == "number" && isFinite(data33)) {
|
|
2187
|
+
if (data33 < 0 || isNaN(data33)) {
|
|
2188
|
+
const err97 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
2189
|
+
if (vErrors === null) {
|
|
2190
|
+
vErrors = [err97];
|
|
2191
|
+
} else {
|
|
2192
|
+
vErrors.push(err97);
|
|
2193
|
+
}
|
|
2194
|
+
errors++;
|
|
2195
|
+
}
|
|
2196
|
+
}
|
|
2197
|
+
}
|
|
2198
|
+
if (data.to !== void 0) {
|
|
2199
|
+
let data34 = data.to;
|
|
2200
|
+
if (!(typeof data34 == "number" && (!(data34 % 1) && !isNaN(data34)) && isFinite(data34))) {
|
|
2201
|
+
const err98 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
2202
|
+
if (vErrors === null) {
|
|
2203
|
+
vErrors = [err98];
|
|
2204
|
+
} else {
|
|
2205
|
+
vErrors.push(err98);
|
|
2206
|
+
}
|
|
2207
|
+
errors++;
|
|
2208
|
+
}
|
|
2209
|
+
if (typeof data34 == "number" && isFinite(data34)) {
|
|
2210
|
+
if (data34 < 0 || isNaN(data34)) {
|
|
2211
|
+
const err99 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
2212
|
+
if (vErrors === null) {
|
|
2213
|
+
vErrors = [err99];
|
|
2214
|
+
} else {
|
|
2215
|
+
vErrors.push(err99);
|
|
2216
|
+
}
|
|
2217
|
+
errors++;
|
|
2218
|
+
}
|
|
2219
|
+
}
|
|
2220
|
+
}
|
|
2221
|
+
if (data.text !== void 0) {
|
|
2222
|
+
let data35 = data.text;
|
|
2223
|
+
if (typeof data35 === "string") {
|
|
2224
|
+
if (func3(data35) < 1) {
|
|
2225
|
+
const err100 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
2226
|
+
if (vErrors === null) {
|
|
2227
|
+
vErrors = [err100];
|
|
2228
|
+
} else {
|
|
2229
|
+
vErrors.push(err100);
|
|
2230
|
+
}
|
|
2231
|
+
errors++;
|
|
2232
|
+
}
|
|
2233
|
+
} else {
|
|
2234
|
+
const err101 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
2235
|
+
if (vErrors === null) {
|
|
2236
|
+
vErrors = [err101];
|
|
2237
|
+
} else {
|
|
2238
|
+
vErrors.push(err101);
|
|
2239
|
+
}
|
|
2240
|
+
errors++;
|
|
2241
|
+
}
|
|
2242
|
+
}
|
|
2243
|
+
if (data.shape !== void 0) {
|
|
2244
|
+
if (!(data.shape === "box")) {
|
|
2245
|
+
const err102 = { instancePath: instancePath + "/shape", schemaPath: "#/oneOf/7/properties/shape/enum", keyword: "enum", params: { allowedValues: schema68.oneOf[7].properties.shape.enum }, message: "must be equal to one of the allowed values" };
|
|
2246
|
+
if (vErrors === null) {
|
|
2247
|
+
vErrors = [err102];
|
|
2248
|
+
} else {
|
|
2249
|
+
vErrors.push(err102);
|
|
2250
|
+
}
|
|
2251
|
+
errors++;
|
|
2252
|
+
}
|
|
2253
|
+
}
|
|
2254
|
+
if (data.color !== void 0) {
|
|
2255
|
+
let data37 = data.color;
|
|
2256
|
+
if (!(data37 === "blue" || data37 === "amber" || data37 === "green" || data37 === "violet" || data37 === "rose" || data37 === "slate" || data37 === "coin")) {
|
|
2257
|
+
const err103 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema45.enum }, message: "must be equal to one of the allowed values" };
|
|
2258
|
+
if (vErrors === null) {
|
|
2259
|
+
vErrors = [err103];
|
|
2260
|
+
} else {
|
|
2261
|
+
vErrors.push(err103);
|
|
2262
|
+
}
|
|
2263
|
+
errors++;
|
|
2264
|
+
}
|
|
2265
|
+
}
|
|
2266
|
+
} else {
|
|
2267
|
+
const err104 = { instancePath, schemaPath: "#/oneOf/7/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
2268
|
+
if (vErrors === null) {
|
|
2269
|
+
vErrors = [err104];
|
|
2270
|
+
} else {
|
|
2271
|
+
vErrors.push(err104);
|
|
2272
|
+
}
|
|
2273
|
+
errors++;
|
|
2274
|
+
}
|
|
2275
|
+
} else if (tag0 === "strip") {
|
|
2276
|
+
const _errs117 = errors;
|
|
2277
|
+
let valid45 = false;
|
|
2278
|
+
const _errs118 = errors;
|
|
2279
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2280
|
+
if (data.value === void 0) {
|
|
2281
|
+
const err105 = { instancePath, schemaPath: "#/oneOf/8/anyOf/0/required", keyword: "required", params: { missingProperty: "value" }, message: "must have required property 'value'" };
|
|
2282
|
+
if (vErrors === null) {
|
|
2283
|
+
vErrors = [err105];
|
|
2284
|
+
} else {
|
|
2285
|
+
vErrors.push(err105);
|
|
2286
|
+
}
|
|
2287
|
+
errors++;
|
|
2288
|
+
}
|
|
2289
|
+
}
|
|
2290
|
+
var _valid0 = _errs118 === errors;
|
|
2291
|
+
valid45 = valid45 || _valid0;
|
|
2292
|
+
if (!valid45) {
|
|
2293
|
+
const _errs119 = errors;
|
|
2294
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2295
|
+
if (data.tag === void 0) {
|
|
2296
|
+
const err106 = { instancePath, schemaPath: "#/oneOf/8/anyOf/1/required", keyword: "required", params: { missingProperty: "tag" }, message: "must have required property 'tag'" };
|
|
2297
|
+
if (vErrors === null) {
|
|
2298
|
+
vErrors = [err106];
|
|
2299
|
+
} else {
|
|
2300
|
+
vErrors.push(err106);
|
|
2301
|
+
}
|
|
2302
|
+
errors++;
|
|
2303
|
+
}
|
|
2304
|
+
}
|
|
2305
|
+
var _valid0 = _errs119 === errors;
|
|
2306
|
+
valid45 = valid45 || _valid0;
|
|
2307
|
+
}
|
|
2308
|
+
if (!valid45) {
|
|
2309
|
+
const err107 = { instancePath, schemaPath: "#/oneOf/8/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
|
|
2310
|
+
if (vErrors === null) {
|
|
2311
|
+
vErrors = [err107];
|
|
2312
|
+
} else {
|
|
2313
|
+
vErrors.push(err107);
|
|
2314
|
+
}
|
|
2315
|
+
errors++;
|
|
2316
|
+
} else {
|
|
2317
|
+
errors = _errs117;
|
|
2318
|
+
if (vErrors !== null) {
|
|
2319
|
+
if (_errs117) {
|
|
2320
|
+
vErrors.length = _errs117;
|
|
2321
|
+
} else {
|
|
2322
|
+
vErrors = null;
|
|
2323
|
+
}
|
|
2324
|
+
}
|
|
2325
|
+
}
|
|
2326
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2327
|
+
if (data.type === void 0) {
|
|
2328
|
+
const err108 = { instancePath, schemaPath: "#/oneOf/8/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
|
|
2329
|
+
if (vErrors === null) {
|
|
2330
|
+
vErrors = [err108];
|
|
2331
|
+
} else {
|
|
2332
|
+
vErrors.push(err108);
|
|
2333
|
+
}
|
|
2334
|
+
errors++;
|
|
2335
|
+
}
|
|
2336
|
+
if (data.field === void 0) {
|
|
2337
|
+
const err109 = { instancePath, schemaPath: "#/oneOf/8/required", keyword: "required", params: { missingProperty: "field" }, message: "must have required property 'field'" };
|
|
2338
|
+
if (vErrors === null) {
|
|
2339
|
+
vErrors = [err109];
|
|
2340
|
+
} else {
|
|
2341
|
+
vErrors.push(err109);
|
|
2342
|
+
}
|
|
2343
|
+
errors++;
|
|
2344
|
+
}
|
|
2345
|
+
for (const key8 in data) {
|
|
2346
|
+
if (!(key8 === "type" || key8 === "field" || key8 === "value" || key8 === "tag")) {
|
|
2347
|
+
const err110 = { instancePath, schemaPath: "#/oneOf/8/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key8 }, message: "must NOT have additional properties" };
|
|
2348
|
+
if (vErrors === null) {
|
|
2349
|
+
vErrors = [err110];
|
|
2350
|
+
} else {
|
|
2351
|
+
vErrors.push(err110);
|
|
2352
|
+
}
|
|
2353
|
+
errors++;
|
|
2354
|
+
}
|
|
2355
|
+
}
|
|
2356
|
+
if (data.type !== void 0) {
|
|
2357
|
+
if ("strip" !== data.type) {
|
|
2358
|
+
const err111 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/8/properties/type/const", keyword: "const", params: { allowedValue: "strip" }, message: "must be equal to constant" };
|
|
2359
|
+
if (vErrors === null) {
|
|
2360
|
+
vErrors = [err111];
|
|
2361
|
+
} else {
|
|
2362
|
+
vErrors.push(err111);
|
|
2363
|
+
}
|
|
2364
|
+
errors++;
|
|
2365
|
+
}
|
|
2366
|
+
}
|
|
2367
|
+
if (data.field !== void 0) {
|
|
2368
|
+
let data39 = data.field;
|
|
2369
|
+
if (typeof data39 === "string") {
|
|
2370
|
+
if (func3(data39) < 1) {
|
|
2371
|
+
const err112 = { instancePath: instancePath + "/field", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
2372
|
+
if (vErrors === null) {
|
|
2373
|
+
vErrors = [err112];
|
|
2374
|
+
} else {
|
|
2375
|
+
vErrors.push(err112);
|
|
2376
|
+
}
|
|
2377
|
+
errors++;
|
|
2378
|
+
}
|
|
2379
|
+
} else {
|
|
2380
|
+
const err113 = { instancePath: instancePath + "/field", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
2381
|
+
if (vErrors === null) {
|
|
2382
|
+
vErrors = [err113];
|
|
2383
|
+
} else {
|
|
2384
|
+
vErrors.push(err113);
|
|
2385
|
+
}
|
|
2386
|
+
errors++;
|
|
2387
|
+
}
|
|
2388
|
+
}
|
|
2389
|
+
if (data.value !== void 0) {
|
|
2390
|
+
let data40 = data.value;
|
|
2391
|
+
if (typeof data40 === "string") {
|
|
2392
|
+
if (func3(data40) < 1) {
|
|
2393
|
+
const err114 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
2394
|
+
if (vErrors === null) {
|
|
2395
|
+
vErrors = [err114];
|
|
2396
|
+
} else {
|
|
2397
|
+
vErrors.push(err114);
|
|
2398
|
+
}
|
|
2399
|
+
errors++;
|
|
2400
|
+
}
|
|
2401
|
+
} else {
|
|
2402
|
+
const err115 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
2403
|
+
if (vErrors === null) {
|
|
2404
|
+
vErrors = [err115];
|
|
2405
|
+
} else {
|
|
2406
|
+
vErrors.push(err115);
|
|
2407
|
+
}
|
|
2408
|
+
errors++;
|
|
2409
|
+
}
|
|
2410
|
+
}
|
|
2411
|
+
if (data.tag !== void 0) {
|
|
2412
|
+
let data41 = data.tag;
|
|
2413
|
+
if (typeof data41 === "string") {
|
|
2414
|
+
if (func3(data41) < 1) {
|
|
2415
|
+
const err116 = { instancePath: instancePath + "/tag", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
2416
|
+
if (vErrors === null) {
|
|
2417
|
+
vErrors = [err116];
|
|
2418
|
+
} else {
|
|
2419
|
+
vErrors.push(err116);
|
|
2420
|
+
}
|
|
2421
|
+
errors++;
|
|
2422
|
+
}
|
|
2423
|
+
} else {
|
|
2424
|
+
const err117 = { instancePath: instancePath + "/tag", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
2425
|
+
if (vErrors === null) {
|
|
2426
|
+
vErrors = [err117];
|
|
1497
2427
|
} else {
|
|
1498
|
-
vErrors.push(
|
|
2428
|
+
vErrors.push(err117);
|
|
1499
2429
|
}
|
|
1500
2430
|
errors++;
|
|
1501
2431
|
}
|
|
1502
2432
|
}
|
|
1503
2433
|
} else {
|
|
1504
|
-
const
|
|
2434
|
+
const err118 = { instancePath, schemaPath: "#/oneOf/8/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1505
2435
|
if (vErrors === null) {
|
|
1506
|
-
vErrors = [
|
|
2436
|
+
vErrors = [err118];
|
|
1507
2437
|
} else {
|
|
1508
|
-
vErrors.push(
|
|
2438
|
+
vErrors.push(err118);
|
|
1509
2439
|
}
|
|
1510
2440
|
errors++;
|
|
1511
2441
|
}
|
|
1512
2442
|
} else {
|
|
1513
|
-
const
|
|
2443
|
+
const err119 = { instancePath, schemaPath: "#/discriminator", keyword: "discriminator", params: { error: "mapping", tag: "type", tagValue: tag0 }, message: 'value of tag "type" must be in oneOf' };
|
|
1514
2444
|
if (vErrors === null) {
|
|
1515
|
-
vErrors = [
|
|
2445
|
+
vErrors = [err119];
|
|
1516
2446
|
} else {
|
|
1517
|
-
vErrors.push(
|
|
2447
|
+
vErrors.push(err119);
|
|
1518
2448
|
}
|
|
1519
2449
|
errors++;
|
|
1520
2450
|
}
|
|
1521
2451
|
} else {
|
|
1522
|
-
const
|
|
2452
|
+
const err120 = { instancePath, schemaPath: "#/discriminator", keyword: "discriminator", params: { error: "tag", tag: "type", tagValue: tag0 }, message: 'tag "type" must be string' };
|
|
1523
2453
|
if (vErrors === null) {
|
|
1524
|
-
vErrors = [
|
|
2454
|
+
vErrors = [err120];
|
|
1525
2455
|
} else {
|
|
1526
|
-
vErrors.push(
|
|
2456
|
+
vErrors.push(err120);
|
|
1527
2457
|
}
|
|
1528
2458
|
errors++;
|
|
1529
2459
|
}
|
|
1530
2460
|
} else {
|
|
1531
|
-
const
|
|
2461
|
+
const err121 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1532
2462
|
if (vErrors === null) {
|
|
1533
|
-
vErrors = [
|
|
2463
|
+
vErrors = [err121];
|
|
1534
2464
|
} else {
|
|
1535
|
-
vErrors.push(
|
|
2465
|
+
vErrors.push(err121);
|
|
1536
2466
|
}
|
|
1537
2467
|
errors++;
|
|
1538
2468
|
}
|
|
1539
|
-
|
|
2469
|
+
validate33.errors = vErrors;
|
|
1540
2470
|
return errors === 0;
|
|
1541
2471
|
}
|
|
1542
|
-
function
|
|
2472
|
+
function validate30(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
1543
2473
|
let vErrors = null;
|
|
1544
2474
|
let errors = 0;
|
|
1545
2475
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -1571,7 +2501,7 @@ function validate17(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
1571
2501
|
errors++;
|
|
1572
2502
|
}
|
|
1573
2503
|
for (const key0 in data) {
|
|
1574
|
-
if (!(key0 === "title" || key0 === "body" || key0 === "code" || key0 === "events")) {
|
|
2504
|
+
if (!(key0 === "title" || key0 === "body" || key0 === "code" || key0 === "sources" || key0 === "events")) {
|
|
1575
2505
|
const err3 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
1576
2506
|
if (vErrors === null) {
|
|
1577
2507
|
vErrors = [err3];
|
|
@@ -1647,39 +2577,68 @@ function validate17(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
1647
2577
|
errors++;
|
|
1648
2578
|
}
|
|
1649
2579
|
}
|
|
1650
|
-
if (data.
|
|
1651
|
-
let data3 = data.
|
|
2580
|
+
if (data.sources !== void 0) {
|
|
2581
|
+
let data3 = data.sources;
|
|
1652
2582
|
if (Array.isArray(data3)) {
|
|
2583
|
+
if (data3.length < 1) {
|
|
2584
|
+
const err10 = { instancePath: instancePath + "/sources", schemaPath: "#/properties/sources/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
|
|
2585
|
+
if (vErrors === null) {
|
|
2586
|
+
vErrors = [err10];
|
|
2587
|
+
} else {
|
|
2588
|
+
vErrors.push(err10);
|
|
2589
|
+
}
|
|
2590
|
+
errors++;
|
|
2591
|
+
}
|
|
1653
2592
|
const len0 = data3.length;
|
|
1654
2593
|
for (let i0 = 0; i0 < len0; i0++) {
|
|
1655
|
-
if (!
|
|
1656
|
-
vErrors = vErrors === null ?
|
|
2594
|
+
if (!validate31(data3[i0], { instancePath: instancePath + "/sources/" + i0, parentData: data3, parentDataProperty: i0, rootData })) {
|
|
2595
|
+
vErrors = vErrors === null ? validate31.errors : vErrors.concat(validate31.errors);
|
|
1657
2596
|
errors = vErrors.length;
|
|
1658
2597
|
}
|
|
1659
2598
|
}
|
|
1660
2599
|
} else {
|
|
1661
|
-
const
|
|
2600
|
+
const err11 = { instancePath: instancePath + "/sources", schemaPath: "#/properties/sources/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
1662
2601
|
if (vErrors === null) {
|
|
1663
|
-
vErrors = [
|
|
2602
|
+
vErrors = [err11];
|
|
1664
2603
|
} else {
|
|
1665
|
-
vErrors.push(
|
|
2604
|
+
vErrors.push(err11);
|
|
2605
|
+
}
|
|
2606
|
+
errors++;
|
|
2607
|
+
}
|
|
2608
|
+
}
|
|
2609
|
+
if (data.events !== void 0) {
|
|
2610
|
+
let data5 = data.events;
|
|
2611
|
+
if (Array.isArray(data5)) {
|
|
2612
|
+
const len1 = data5.length;
|
|
2613
|
+
for (let i1 = 0; i1 < len1; i1++) {
|
|
2614
|
+
if (!validate33(data5[i1], { instancePath: instancePath + "/events/" + i1, parentData: data5, parentDataProperty: i1, rootData })) {
|
|
2615
|
+
vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
|
|
2616
|
+
errors = vErrors.length;
|
|
2617
|
+
}
|
|
2618
|
+
}
|
|
2619
|
+
} else {
|
|
2620
|
+
const err12 = { instancePath: instancePath + "/events", schemaPath: "#/properties/events/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
2621
|
+
if (vErrors === null) {
|
|
2622
|
+
vErrors = [err12];
|
|
2623
|
+
} else {
|
|
2624
|
+
vErrors.push(err12);
|
|
1666
2625
|
}
|
|
1667
2626
|
errors++;
|
|
1668
2627
|
}
|
|
1669
2628
|
}
|
|
1670
2629
|
} else {
|
|
1671
|
-
const
|
|
2630
|
+
const err13 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
1672
2631
|
if (vErrors === null) {
|
|
1673
|
-
vErrors = [
|
|
2632
|
+
vErrors = [err13];
|
|
1674
2633
|
} else {
|
|
1675
|
-
vErrors.push(
|
|
2634
|
+
vErrors.push(err13);
|
|
1676
2635
|
}
|
|
1677
2636
|
errors++;
|
|
1678
2637
|
}
|
|
1679
|
-
|
|
2638
|
+
validate30.errors = vErrors;
|
|
1680
2639
|
return errors === 0;
|
|
1681
2640
|
}
|
|
1682
|
-
function
|
|
2641
|
+
function validate38(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
1683
2642
|
let vErrors = null;
|
|
1684
2643
|
let errors = 0;
|
|
1685
2644
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -1757,10 +2716,10 @@ function validate23(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
1757
2716
|
}
|
|
1758
2717
|
errors++;
|
|
1759
2718
|
}
|
|
1760
|
-
|
|
2719
|
+
validate38.errors = vErrors;
|
|
1761
2720
|
return errors === 0;
|
|
1762
2721
|
}
|
|
1763
|
-
function
|
|
2722
|
+
function validate41(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
1764
2723
|
let vErrors = null;
|
|
1765
2724
|
let errors = 0;
|
|
1766
2725
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -1868,10 +2827,10 @@ function validate26(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
1868
2827
|
}
|
|
1869
2828
|
errors++;
|
|
1870
2829
|
}
|
|
1871
|
-
|
|
2830
|
+
validate41.errors = vErrors;
|
|
1872
2831
|
return errors === 0;
|
|
1873
2832
|
}
|
|
1874
|
-
function
|
|
2833
|
+
function validate40(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
1875
2834
|
let vErrors = null;
|
|
1876
2835
|
let errors = 0;
|
|
1877
2836
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -1909,8 +2868,8 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
1909
2868
|
}
|
|
1910
2869
|
const len0 = data0.length;
|
|
1911
2870
|
for (let i0 = 0; i0 < len0; i0++) {
|
|
1912
|
-
if (!
|
|
1913
|
-
vErrors = vErrors === null ?
|
|
2871
|
+
if (!validate41(data0[i0], { instancePath: instancePath + "/paths/" + i0, parentData: data0, parentDataProperty: i0, rootData })) {
|
|
2872
|
+
vErrors = vErrors === null ? validate41.errors : vErrors.concat(validate41.errors);
|
|
1914
2873
|
errors = vErrors.length;
|
|
1915
2874
|
}
|
|
1916
2875
|
}
|
|
@@ -1933,10 +2892,10 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
1933
2892
|
}
|
|
1934
2893
|
errors++;
|
|
1935
2894
|
}
|
|
1936
|
-
|
|
2895
|
+
validate40.errors = vErrors;
|
|
1937
2896
|
return errors === 0;
|
|
1938
2897
|
}
|
|
1939
|
-
function
|
|
2898
|
+
function validate45(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
1940
2899
|
let vErrors = null;
|
|
1941
2900
|
let errors = 0;
|
|
1942
2901
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -2013,10 +2972,10 @@ function validate30(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2013
2972
|
}
|
|
2014
2973
|
errors++;
|
|
2015
2974
|
}
|
|
2016
|
-
|
|
2975
|
+
validate45.errors = vErrors;
|
|
2017
2976
|
return errors === 0;
|
|
2018
2977
|
}
|
|
2019
|
-
function
|
|
2978
|
+
function validate44(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
2020
2979
|
let vErrors = null;
|
|
2021
2980
|
let errors = 0;
|
|
2022
2981
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
@@ -2054,8 +3013,8 @@ function validate29(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2054
3013
|
}
|
|
2055
3014
|
const len0 = data0.length;
|
|
2056
3015
|
for (let i0 = 0; i0 < len0; i0++) {
|
|
2057
|
-
if (!
|
|
2058
|
-
vErrors = vErrors === null ?
|
|
3016
|
+
if (!validate45(data0[i0], { instancePath: instancePath + "/branches/" + i0, parentData: data0, parentDataProperty: i0, rootData })) {
|
|
3017
|
+
vErrors = vErrors === null ? validate45.errors : vErrors.concat(validate45.errors);
|
|
2059
3018
|
errors = vErrors.length;
|
|
2060
3019
|
}
|
|
2061
3020
|
}
|
|
@@ -2078,27 +3037,717 @@ function validate29(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2078
3037
|
}
|
|
2079
3038
|
errors++;
|
|
2080
3039
|
}
|
|
2081
|
-
|
|
3040
|
+
validate44.errors = vErrors;
|
|
2082
3041
|
return errors === 0;
|
|
2083
3042
|
}
|
|
2084
|
-
|
|
3043
|
+
var pattern22 = new RegExp("^[0-9]+(\\.[0-9]+)?(ms|s|min|h|d)$", "u");
|
|
3044
|
+
function validate49(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
2085
3045
|
let vErrors = null;
|
|
2086
3046
|
let errors = 0;
|
|
2087
|
-
const _errs1 = errors;
|
|
2088
|
-
let valid0 = true;
|
|
2089
|
-
const _errs2 = errors;
|
|
2090
3047
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2091
|
-
if (data.
|
|
2092
|
-
const err0 = {};
|
|
3048
|
+
if (data.unit === void 0) {
|
|
3049
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "unit" }, message: "must have required property 'unit'" };
|
|
2093
3050
|
if (vErrors === null) {
|
|
2094
3051
|
vErrors = [err0];
|
|
2095
3052
|
} else {
|
|
2096
3053
|
vErrors.push(err0);
|
|
2097
3054
|
}
|
|
2098
3055
|
errors++;
|
|
2099
|
-
}
|
|
2100
|
-
|
|
2101
|
-
|
|
3056
|
+
}
|
|
3057
|
+
if (data.length === void 0) {
|
|
3058
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "length" }, message: "must have required property 'length'" };
|
|
3059
|
+
if (vErrors === null) {
|
|
3060
|
+
vErrors = [err1];
|
|
3061
|
+
} else {
|
|
3062
|
+
vErrors.push(err1);
|
|
3063
|
+
}
|
|
3064
|
+
errors++;
|
|
3065
|
+
}
|
|
3066
|
+
if (data.count === void 0) {
|
|
3067
|
+
const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "count" }, message: "must have required property 'count'" };
|
|
3068
|
+
if (vErrors === null) {
|
|
3069
|
+
vErrors = [err2];
|
|
3070
|
+
} else {
|
|
3071
|
+
vErrors.push(err2);
|
|
3072
|
+
}
|
|
3073
|
+
errors++;
|
|
3074
|
+
}
|
|
3075
|
+
for (const key0 in data) {
|
|
3076
|
+
if (!(key0 === "unit" || key0 === "length" || key0 === "count" || key0 === "from")) {
|
|
3077
|
+
const err3 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
3078
|
+
if (vErrors === null) {
|
|
3079
|
+
vErrors = [err3];
|
|
3080
|
+
} else {
|
|
3081
|
+
vErrors.push(err3);
|
|
3082
|
+
}
|
|
3083
|
+
errors++;
|
|
3084
|
+
}
|
|
3085
|
+
}
|
|
3086
|
+
if (data.unit !== void 0) {
|
|
3087
|
+
let data0 = data.unit;
|
|
3088
|
+
if (typeof data0 === "string") {
|
|
3089
|
+
if (func3(data0) < 1) {
|
|
3090
|
+
const err4 = { instancePath: instancePath + "/unit", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
3091
|
+
if (vErrors === null) {
|
|
3092
|
+
vErrors = [err4];
|
|
3093
|
+
} else {
|
|
3094
|
+
vErrors.push(err4);
|
|
3095
|
+
}
|
|
3096
|
+
errors++;
|
|
3097
|
+
}
|
|
3098
|
+
} else {
|
|
3099
|
+
const err5 = { instancePath: instancePath + "/unit", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
3100
|
+
if (vErrors === null) {
|
|
3101
|
+
vErrors = [err5];
|
|
3102
|
+
} else {
|
|
3103
|
+
vErrors.push(err5);
|
|
3104
|
+
}
|
|
3105
|
+
errors++;
|
|
3106
|
+
}
|
|
3107
|
+
}
|
|
3108
|
+
if (data.length !== void 0) {
|
|
3109
|
+
let data1 = data.length;
|
|
3110
|
+
if (typeof data1 === "string") {
|
|
3111
|
+
if (!pattern22.test(data1)) {
|
|
3112
|
+
const err6 = { instancePath: instancePath + "/length", schemaPath: "#/definitions/duration/pattern", keyword: "pattern", params: { pattern: "^[0-9]+(\\.[0-9]+)?(ms|s|min|h|d)$" }, message: 'must match pattern "^[0-9]+(\\.[0-9]+)?(ms|s|min|h|d)$"' };
|
|
3113
|
+
if (vErrors === null) {
|
|
3114
|
+
vErrors = [err6];
|
|
3115
|
+
} else {
|
|
3116
|
+
vErrors.push(err6);
|
|
3117
|
+
}
|
|
3118
|
+
errors++;
|
|
3119
|
+
}
|
|
3120
|
+
} else {
|
|
3121
|
+
const err7 = { instancePath: instancePath + "/length", schemaPath: "#/definitions/duration/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
3122
|
+
if (vErrors === null) {
|
|
3123
|
+
vErrors = [err7];
|
|
3124
|
+
} else {
|
|
3125
|
+
vErrors.push(err7);
|
|
3126
|
+
}
|
|
3127
|
+
errors++;
|
|
3128
|
+
}
|
|
3129
|
+
}
|
|
3130
|
+
if (data.count !== void 0) {
|
|
3131
|
+
let data2 = data.count;
|
|
3132
|
+
if (!(typeof data2 == "number" && (!(data2 % 1) && !isNaN(data2)) && isFinite(data2))) {
|
|
3133
|
+
const err8 = { instancePath: instancePath + "/count", schemaPath: "#/properties/count/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3134
|
+
if (vErrors === null) {
|
|
3135
|
+
vErrors = [err8];
|
|
3136
|
+
} else {
|
|
3137
|
+
vErrors.push(err8);
|
|
3138
|
+
}
|
|
3139
|
+
errors++;
|
|
3140
|
+
}
|
|
3141
|
+
if (typeof data2 == "number" && isFinite(data2)) {
|
|
3142
|
+
if (data2 < 1 || isNaN(data2)) {
|
|
3143
|
+
const err9 = { instancePath: instancePath + "/count", schemaPath: "#/properties/count/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
|
|
3144
|
+
if (vErrors === null) {
|
|
3145
|
+
vErrors = [err9];
|
|
3146
|
+
} else {
|
|
3147
|
+
vErrors.push(err9);
|
|
3148
|
+
}
|
|
3149
|
+
errors++;
|
|
3150
|
+
}
|
|
3151
|
+
}
|
|
3152
|
+
}
|
|
3153
|
+
if (data.from !== void 0) {
|
|
3154
|
+
let data3 = data.from;
|
|
3155
|
+
if (!(typeof data3 == "number" && (!(data3 % 1) && !isNaN(data3)) && isFinite(data3))) {
|
|
3156
|
+
const err10 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3157
|
+
if (vErrors === null) {
|
|
3158
|
+
vErrors = [err10];
|
|
3159
|
+
} else {
|
|
3160
|
+
vErrors.push(err10);
|
|
3161
|
+
}
|
|
3162
|
+
errors++;
|
|
3163
|
+
}
|
|
3164
|
+
if (typeof data3 == "number" && isFinite(data3)) {
|
|
3165
|
+
if (data3 < 0 || isNaN(data3)) {
|
|
3166
|
+
const err11 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
3167
|
+
if (vErrors === null) {
|
|
3168
|
+
vErrors = [err11];
|
|
3169
|
+
} else {
|
|
3170
|
+
vErrors.push(err11);
|
|
3171
|
+
}
|
|
3172
|
+
errors++;
|
|
3173
|
+
}
|
|
3174
|
+
}
|
|
3175
|
+
}
|
|
3176
|
+
} else {
|
|
3177
|
+
const err12 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
3178
|
+
if (vErrors === null) {
|
|
3179
|
+
vErrors = [err12];
|
|
3180
|
+
} else {
|
|
3181
|
+
vErrors.push(err12);
|
|
3182
|
+
}
|
|
3183
|
+
errors++;
|
|
3184
|
+
}
|
|
3185
|
+
validate49.errors = vErrors;
|
|
3186
|
+
return errors === 0;
|
|
3187
|
+
}
|
|
3188
|
+
function validate51(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
3189
|
+
let vErrors = null;
|
|
3190
|
+
let errors = 0;
|
|
3191
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
3192
|
+
if (data.name === void 0) {
|
|
3193
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
|
|
3194
|
+
if (vErrors === null) {
|
|
3195
|
+
vErrors = [err0];
|
|
3196
|
+
} else {
|
|
3197
|
+
vErrors.push(err0);
|
|
3198
|
+
}
|
|
3199
|
+
errors++;
|
|
3200
|
+
}
|
|
3201
|
+
if (data.length === void 0) {
|
|
3202
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "length" }, message: "must have required property 'length'" };
|
|
3203
|
+
if (vErrors === null) {
|
|
3204
|
+
vErrors = [err1];
|
|
3205
|
+
} else {
|
|
3206
|
+
vErrors.push(err1);
|
|
3207
|
+
}
|
|
3208
|
+
errors++;
|
|
3209
|
+
}
|
|
3210
|
+
for (const key0 in data) {
|
|
3211
|
+
if (!(key0 === "name" || key0 === "length" || key0 === "from")) {
|
|
3212
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
3213
|
+
if (vErrors === null) {
|
|
3214
|
+
vErrors = [err2];
|
|
3215
|
+
} else {
|
|
3216
|
+
vErrors.push(err2);
|
|
3217
|
+
}
|
|
3218
|
+
errors++;
|
|
3219
|
+
}
|
|
3220
|
+
}
|
|
3221
|
+
if (data.name !== void 0) {
|
|
3222
|
+
let data0 = data.name;
|
|
3223
|
+
if (typeof data0 === "string") {
|
|
3224
|
+
if (func3(data0) < 1) {
|
|
3225
|
+
const err3 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
3226
|
+
if (vErrors === null) {
|
|
3227
|
+
vErrors = [err3];
|
|
3228
|
+
} else {
|
|
3229
|
+
vErrors.push(err3);
|
|
3230
|
+
}
|
|
3231
|
+
errors++;
|
|
3232
|
+
}
|
|
3233
|
+
} else {
|
|
3234
|
+
const err4 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
3235
|
+
if (vErrors === null) {
|
|
3236
|
+
vErrors = [err4];
|
|
3237
|
+
} else {
|
|
3238
|
+
vErrors.push(err4);
|
|
3239
|
+
}
|
|
3240
|
+
errors++;
|
|
3241
|
+
}
|
|
3242
|
+
}
|
|
3243
|
+
if (data.length !== void 0) {
|
|
3244
|
+
let data1 = data.length;
|
|
3245
|
+
if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)) && isFinite(data1))) {
|
|
3246
|
+
const err5 = { instancePath: instancePath + "/length", schemaPath: "#/properties/length/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3247
|
+
if (vErrors === null) {
|
|
3248
|
+
vErrors = [err5];
|
|
3249
|
+
} else {
|
|
3250
|
+
vErrors.push(err5);
|
|
3251
|
+
}
|
|
3252
|
+
errors++;
|
|
3253
|
+
}
|
|
3254
|
+
if (typeof data1 == "number" && isFinite(data1)) {
|
|
3255
|
+
if (data1 < 1 || isNaN(data1)) {
|
|
3256
|
+
const err6 = { instancePath: instancePath + "/length", schemaPath: "#/properties/length/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
|
|
3257
|
+
if (vErrors === null) {
|
|
3258
|
+
vErrors = [err6];
|
|
3259
|
+
} else {
|
|
3260
|
+
vErrors.push(err6);
|
|
3261
|
+
}
|
|
3262
|
+
errors++;
|
|
3263
|
+
}
|
|
3264
|
+
}
|
|
3265
|
+
}
|
|
3266
|
+
if (data.from !== void 0) {
|
|
3267
|
+
let data2 = data.from;
|
|
3268
|
+
if (!(typeof data2 == "number" && (!(data2 % 1) && !isNaN(data2)) && isFinite(data2))) {
|
|
3269
|
+
const err7 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3270
|
+
if (vErrors === null) {
|
|
3271
|
+
vErrors = [err7];
|
|
3272
|
+
} else {
|
|
3273
|
+
vErrors.push(err7);
|
|
3274
|
+
}
|
|
3275
|
+
errors++;
|
|
3276
|
+
}
|
|
3277
|
+
if (typeof data2 == "number" && isFinite(data2)) {
|
|
3278
|
+
if (data2 < 0 || isNaN(data2)) {
|
|
3279
|
+
const err8 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
3280
|
+
if (vErrors === null) {
|
|
3281
|
+
vErrors = [err8];
|
|
3282
|
+
} else {
|
|
3283
|
+
vErrors.push(err8);
|
|
3284
|
+
}
|
|
3285
|
+
errors++;
|
|
3286
|
+
}
|
|
3287
|
+
}
|
|
3288
|
+
}
|
|
3289
|
+
} else {
|
|
3290
|
+
const err9 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
3291
|
+
if (vErrors === null) {
|
|
3292
|
+
vErrors = [err9];
|
|
3293
|
+
} else {
|
|
3294
|
+
vErrors.push(err9);
|
|
3295
|
+
}
|
|
3296
|
+
errors++;
|
|
3297
|
+
}
|
|
3298
|
+
validate51.errors = vErrors;
|
|
3299
|
+
return errors === 0;
|
|
3300
|
+
}
|
|
3301
|
+
function validate53(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
3302
|
+
let vErrors = null;
|
|
3303
|
+
let errors = 0;
|
|
3304
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
3305
|
+
if (data.id === void 0) {
|
|
3306
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property 'id'" };
|
|
3307
|
+
if (vErrors === null) {
|
|
3308
|
+
vErrors = [err0];
|
|
3309
|
+
} else {
|
|
3310
|
+
vErrors.push(err0);
|
|
3311
|
+
}
|
|
3312
|
+
errors++;
|
|
3313
|
+
}
|
|
3314
|
+
if (data.name === void 0) {
|
|
3315
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
|
|
3316
|
+
if (vErrors === null) {
|
|
3317
|
+
vErrors = [err1];
|
|
3318
|
+
} else {
|
|
3319
|
+
vErrors.push(err1);
|
|
3320
|
+
}
|
|
3321
|
+
errors++;
|
|
3322
|
+
}
|
|
3323
|
+
for (const key0 in data) {
|
|
3324
|
+
if (!(key0 === "id" || key0 === "name" || key0 === "color" || key0 === "empty")) {
|
|
3325
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
3326
|
+
if (vErrors === null) {
|
|
3327
|
+
vErrors = [err2];
|
|
3328
|
+
} else {
|
|
3329
|
+
vErrors.push(err2);
|
|
3330
|
+
}
|
|
3331
|
+
errors++;
|
|
3332
|
+
}
|
|
3333
|
+
}
|
|
3334
|
+
if (data.id !== void 0) {
|
|
3335
|
+
let data0 = data.id;
|
|
3336
|
+
if (typeof data0 === "string") {
|
|
3337
|
+
if (!pattern0.test(data0)) {
|
|
3338
|
+
const err3 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
3339
|
+
if (vErrors === null) {
|
|
3340
|
+
vErrors = [err3];
|
|
3341
|
+
} else {
|
|
3342
|
+
vErrors.push(err3);
|
|
3343
|
+
}
|
|
3344
|
+
errors++;
|
|
3345
|
+
}
|
|
3346
|
+
} else {
|
|
3347
|
+
const err4 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
3348
|
+
if (vErrors === null) {
|
|
3349
|
+
vErrors = [err4];
|
|
3350
|
+
} else {
|
|
3351
|
+
vErrors.push(err4);
|
|
3352
|
+
}
|
|
3353
|
+
errors++;
|
|
3354
|
+
}
|
|
3355
|
+
}
|
|
3356
|
+
if (data.name !== void 0) {
|
|
3357
|
+
let data1 = data.name;
|
|
3358
|
+
if (typeof data1 === "string") {
|
|
3359
|
+
if (func3(data1) < 1) {
|
|
3360
|
+
const err5 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
3361
|
+
if (vErrors === null) {
|
|
3362
|
+
vErrors = [err5];
|
|
3363
|
+
} else {
|
|
3364
|
+
vErrors.push(err5);
|
|
3365
|
+
}
|
|
3366
|
+
errors++;
|
|
3367
|
+
}
|
|
3368
|
+
} else {
|
|
3369
|
+
const err6 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
3370
|
+
if (vErrors === null) {
|
|
3371
|
+
vErrors = [err6];
|
|
3372
|
+
} else {
|
|
3373
|
+
vErrors.push(err6);
|
|
3374
|
+
}
|
|
3375
|
+
errors++;
|
|
3376
|
+
}
|
|
3377
|
+
}
|
|
3378
|
+
if (data.color !== void 0) {
|
|
3379
|
+
let data2 = data.color;
|
|
3380
|
+
if (!(data2 === "blue" || data2 === "amber" || data2 === "green" || data2 === "violet" || data2 === "rose" || data2 === "slate" || data2 === "coin")) {
|
|
3381
|
+
const err7 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema45.enum }, message: "must be equal to one of the allowed values" };
|
|
3382
|
+
if (vErrors === null) {
|
|
3383
|
+
vErrors = [err7];
|
|
3384
|
+
} else {
|
|
3385
|
+
vErrors.push(err7);
|
|
3386
|
+
}
|
|
3387
|
+
errors++;
|
|
3388
|
+
}
|
|
3389
|
+
}
|
|
3390
|
+
if (data.empty !== void 0) {
|
|
3391
|
+
let data3 = data.empty;
|
|
3392
|
+
if (Array.isArray(data3)) {
|
|
3393
|
+
const len0 = data3.length;
|
|
3394
|
+
for (let i0 = 0; i0 < len0; i0++) {
|
|
3395
|
+
let data4 = data3[i0];
|
|
3396
|
+
if (!(typeof data4 == "number" && (!(data4 % 1) && !isNaN(data4)) && isFinite(data4))) {
|
|
3397
|
+
const err8 = { instancePath: instancePath + "/empty/" + i0, schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3398
|
+
if (vErrors === null) {
|
|
3399
|
+
vErrors = [err8];
|
|
3400
|
+
} else {
|
|
3401
|
+
vErrors.push(err8);
|
|
3402
|
+
}
|
|
3403
|
+
errors++;
|
|
3404
|
+
}
|
|
3405
|
+
if (typeof data4 == "number" && isFinite(data4)) {
|
|
3406
|
+
if (data4 < 0 || isNaN(data4)) {
|
|
3407
|
+
const err9 = { instancePath: instancePath + "/empty/" + i0, schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
3408
|
+
if (vErrors === null) {
|
|
3409
|
+
vErrors = [err9];
|
|
3410
|
+
} else {
|
|
3411
|
+
vErrors.push(err9);
|
|
3412
|
+
}
|
|
3413
|
+
errors++;
|
|
3414
|
+
}
|
|
3415
|
+
}
|
|
3416
|
+
}
|
|
3417
|
+
} else {
|
|
3418
|
+
const err10 = { instancePath: instancePath + "/empty", schemaPath: "#/properties/empty/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
3419
|
+
if (vErrors === null) {
|
|
3420
|
+
vErrors = [err10];
|
|
3421
|
+
} else {
|
|
3422
|
+
vErrors.push(err10);
|
|
3423
|
+
}
|
|
3424
|
+
errors++;
|
|
3425
|
+
}
|
|
3426
|
+
}
|
|
3427
|
+
} else {
|
|
3428
|
+
const err11 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
3429
|
+
if (vErrors === null) {
|
|
3430
|
+
vErrors = [err11];
|
|
3431
|
+
} else {
|
|
3432
|
+
vErrors.push(err11);
|
|
3433
|
+
}
|
|
3434
|
+
errors++;
|
|
3435
|
+
}
|
|
3436
|
+
validate53.errors = vErrors;
|
|
3437
|
+
return errors === 0;
|
|
3438
|
+
}
|
|
3439
|
+
function validate55(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
3440
|
+
let vErrors = null;
|
|
3441
|
+
let errors = 0;
|
|
3442
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
3443
|
+
if (data.id === void 0) {
|
|
3444
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property 'id'" };
|
|
3445
|
+
if (vErrors === null) {
|
|
3446
|
+
vErrors = [err0];
|
|
3447
|
+
} else {
|
|
3448
|
+
vErrors.push(err0);
|
|
3449
|
+
}
|
|
3450
|
+
errors++;
|
|
3451
|
+
}
|
|
3452
|
+
if (data.at === void 0) {
|
|
3453
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "at" }, message: "must have required property 'at'" };
|
|
3454
|
+
if (vErrors === null) {
|
|
3455
|
+
vErrors = [err1];
|
|
3456
|
+
} else {
|
|
3457
|
+
vErrors.push(err1);
|
|
3458
|
+
}
|
|
3459
|
+
errors++;
|
|
3460
|
+
}
|
|
3461
|
+
for (const key0 in data) {
|
|
3462
|
+
if (!(key0 === "id" || key0 === "at")) {
|
|
3463
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
3464
|
+
if (vErrors === null) {
|
|
3465
|
+
vErrors = [err2];
|
|
3466
|
+
} else {
|
|
3467
|
+
vErrors.push(err2);
|
|
3468
|
+
}
|
|
3469
|
+
errors++;
|
|
3470
|
+
}
|
|
3471
|
+
}
|
|
3472
|
+
if (data.id !== void 0) {
|
|
3473
|
+
let data0 = data.id;
|
|
3474
|
+
if (typeof data0 === "string") {
|
|
3475
|
+
if (!pattern0.test(data0)) {
|
|
3476
|
+
const err3 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
|
|
3477
|
+
if (vErrors === null) {
|
|
3478
|
+
vErrors = [err3];
|
|
3479
|
+
} else {
|
|
3480
|
+
vErrors.push(err3);
|
|
3481
|
+
}
|
|
3482
|
+
errors++;
|
|
3483
|
+
}
|
|
3484
|
+
} else {
|
|
3485
|
+
const err4 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
3486
|
+
if (vErrors === null) {
|
|
3487
|
+
vErrors = [err4];
|
|
3488
|
+
} else {
|
|
3489
|
+
vErrors.push(err4);
|
|
3490
|
+
}
|
|
3491
|
+
errors++;
|
|
3492
|
+
}
|
|
3493
|
+
}
|
|
3494
|
+
if (data.at !== void 0) {
|
|
3495
|
+
let data1 = data.at;
|
|
3496
|
+
if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)) && isFinite(data1))) {
|
|
3497
|
+
const err5 = { instancePath: instancePath + "/at", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3498
|
+
if (vErrors === null) {
|
|
3499
|
+
vErrors = [err5];
|
|
3500
|
+
} else {
|
|
3501
|
+
vErrors.push(err5);
|
|
3502
|
+
}
|
|
3503
|
+
errors++;
|
|
3504
|
+
}
|
|
3505
|
+
if (typeof data1 == "number" && isFinite(data1)) {
|
|
3506
|
+
if (data1 < 0 || isNaN(data1)) {
|
|
3507
|
+
const err6 = { instancePath: instancePath + "/at", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
3508
|
+
if (vErrors === null) {
|
|
3509
|
+
vErrors = [err6];
|
|
3510
|
+
} else {
|
|
3511
|
+
vErrors.push(err6);
|
|
3512
|
+
}
|
|
3513
|
+
errors++;
|
|
3514
|
+
}
|
|
3515
|
+
}
|
|
3516
|
+
}
|
|
3517
|
+
} else {
|
|
3518
|
+
const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
3519
|
+
if (vErrors === null) {
|
|
3520
|
+
vErrors = [err7];
|
|
3521
|
+
} else {
|
|
3522
|
+
vErrors.push(err7);
|
|
3523
|
+
}
|
|
3524
|
+
errors++;
|
|
3525
|
+
}
|
|
3526
|
+
validate55.errors = vErrors;
|
|
3527
|
+
return errors === 0;
|
|
3528
|
+
}
|
|
3529
|
+
function validate57(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
3530
|
+
let vErrors = null;
|
|
3531
|
+
let errors = 0;
|
|
3532
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
3533
|
+
if (data.from === void 0) {
|
|
3534
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
|
|
3535
|
+
if (vErrors === null) {
|
|
3536
|
+
vErrors = [err0];
|
|
3537
|
+
} else {
|
|
3538
|
+
vErrors.push(err0);
|
|
3539
|
+
}
|
|
3540
|
+
errors++;
|
|
3541
|
+
}
|
|
3542
|
+
if (data.to === void 0) {
|
|
3543
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
|
|
3544
|
+
if (vErrors === null) {
|
|
3545
|
+
vErrors = [err1];
|
|
3546
|
+
} else {
|
|
3547
|
+
vErrors.push(err1);
|
|
3548
|
+
}
|
|
3549
|
+
errors++;
|
|
3550
|
+
}
|
|
3551
|
+
for (const key0 in data) {
|
|
3552
|
+
if (!(key0 === "from" || key0 === "to")) {
|
|
3553
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
3554
|
+
if (vErrors === null) {
|
|
3555
|
+
vErrors = [err2];
|
|
3556
|
+
} else {
|
|
3557
|
+
vErrors.push(err2);
|
|
3558
|
+
}
|
|
3559
|
+
errors++;
|
|
3560
|
+
}
|
|
3561
|
+
}
|
|
3562
|
+
if (data.from !== void 0) {
|
|
3563
|
+
let data0 = data.from;
|
|
3564
|
+
if (!(typeof data0 == "number" && (!(data0 % 1) && !isNaN(data0)) && isFinite(data0))) {
|
|
3565
|
+
const err3 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3566
|
+
if (vErrors === null) {
|
|
3567
|
+
vErrors = [err3];
|
|
3568
|
+
} else {
|
|
3569
|
+
vErrors.push(err3);
|
|
3570
|
+
}
|
|
3571
|
+
errors++;
|
|
3572
|
+
}
|
|
3573
|
+
if (typeof data0 == "number" && isFinite(data0)) {
|
|
3574
|
+
if (data0 < 0 || isNaN(data0)) {
|
|
3575
|
+
const err4 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
3576
|
+
if (vErrors === null) {
|
|
3577
|
+
vErrors = [err4];
|
|
3578
|
+
} else {
|
|
3579
|
+
vErrors.push(err4);
|
|
3580
|
+
}
|
|
3581
|
+
errors++;
|
|
3582
|
+
}
|
|
3583
|
+
}
|
|
3584
|
+
}
|
|
3585
|
+
if (data.to !== void 0) {
|
|
3586
|
+
let data1 = data.to;
|
|
3587
|
+
if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)) && isFinite(data1))) {
|
|
3588
|
+
const err5 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
3589
|
+
if (vErrors === null) {
|
|
3590
|
+
vErrors = [err5];
|
|
3591
|
+
} else {
|
|
3592
|
+
vErrors.push(err5);
|
|
3593
|
+
}
|
|
3594
|
+
errors++;
|
|
3595
|
+
}
|
|
3596
|
+
if (typeof data1 == "number" && isFinite(data1)) {
|
|
3597
|
+
if (data1 < 0 || isNaN(data1)) {
|
|
3598
|
+
const err6 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/unit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
|
|
3599
|
+
if (vErrors === null) {
|
|
3600
|
+
vErrors = [err6];
|
|
3601
|
+
} else {
|
|
3602
|
+
vErrors.push(err6);
|
|
3603
|
+
}
|
|
3604
|
+
errors++;
|
|
3605
|
+
}
|
|
3606
|
+
}
|
|
3607
|
+
}
|
|
3608
|
+
} else {
|
|
3609
|
+
const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
3610
|
+
if (vErrors === null) {
|
|
3611
|
+
vErrors = [err7];
|
|
3612
|
+
} else {
|
|
3613
|
+
vErrors.push(err7);
|
|
3614
|
+
}
|
|
3615
|
+
errors++;
|
|
3616
|
+
}
|
|
3617
|
+
validate57.errors = vErrors;
|
|
3618
|
+
return errors === 0;
|
|
3619
|
+
}
|
|
3620
|
+
function validate48(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
3621
|
+
let vErrors = null;
|
|
3622
|
+
let errors = 0;
|
|
3623
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
3624
|
+
if (data.scale === void 0) {
|
|
3625
|
+
const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "scale" }, message: "must have required property 'scale'" };
|
|
3626
|
+
if (vErrors === null) {
|
|
3627
|
+
vErrors = [err0];
|
|
3628
|
+
} else {
|
|
3629
|
+
vErrors.push(err0);
|
|
3630
|
+
}
|
|
3631
|
+
errors++;
|
|
3632
|
+
}
|
|
3633
|
+
if (data.rows === void 0) {
|
|
3634
|
+
const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "rows" }, message: "must have required property 'rows'" };
|
|
3635
|
+
if (vErrors === null) {
|
|
3636
|
+
vErrors = [err1];
|
|
3637
|
+
} else {
|
|
3638
|
+
vErrors.push(err1);
|
|
3639
|
+
}
|
|
3640
|
+
errors++;
|
|
3641
|
+
}
|
|
3642
|
+
for (const key0 in data) {
|
|
3643
|
+
if (!(key0 === "scale" || key0 === "period" || key0 === "rows" || key0 === "points" || key0 === "zoom")) {
|
|
3644
|
+
const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
3645
|
+
if (vErrors === null) {
|
|
3646
|
+
vErrors = [err2];
|
|
3647
|
+
} else {
|
|
3648
|
+
vErrors.push(err2);
|
|
3649
|
+
}
|
|
3650
|
+
errors++;
|
|
3651
|
+
}
|
|
3652
|
+
}
|
|
3653
|
+
if (data.scale !== void 0) {
|
|
3654
|
+
if (!validate49(data.scale, { instancePath: instancePath + "/scale", parentData: data, parentDataProperty: "scale", rootData })) {
|
|
3655
|
+
vErrors = vErrors === null ? validate49.errors : vErrors.concat(validate49.errors);
|
|
3656
|
+
errors = vErrors.length;
|
|
3657
|
+
}
|
|
3658
|
+
}
|
|
3659
|
+
if (data.period !== void 0) {
|
|
3660
|
+
if (!validate51(data.period, { instancePath: instancePath + "/period", parentData: data, parentDataProperty: "period", rootData })) {
|
|
3661
|
+
vErrors = vErrors === null ? validate51.errors : vErrors.concat(validate51.errors);
|
|
3662
|
+
errors = vErrors.length;
|
|
3663
|
+
}
|
|
3664
|
+
}
|
|
3665
|
+
if (data.rows !== void 0) {
|
|
3666
|
+
let data2 = data.rows;
|
|
3667
|
+
if (Array.isArray(data2)) {
|
|
3668
|
+
if (data2.length < 1) {
|
|
3669
|
+
const err3 = { instancePath: instancePath + "/rows", schemaPath: "#/properties/rows/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
|
|
3670
|
+
if (vErrors === null) {
|
|
3671
|
+
vErrors = [err3];
|
|
3672
|
+
} else {
|
|
3673
|
+
vErrors.push(err3);
|
|
3674
|
+
}
|
|
3675
|
+
errors++;
|
|
3676
|
+
}
|
|
3677
|
+
const len0 = data2.length;
|
|
3678
|
+
for (let i0 = 0; i0 < len0; i0++) {
|
|
3679
|
+
if (!validate53(data2[i0], { instancePath: instancePath + "/rows/" + i0, parentData: data2, parentDataProperty: i0, rootData })) {
|
|
3680
|
+
vErrors = vErrors === null ? validate53.errors : vErrors.concat(validate53.errors);
|
|
3681
|
+
errors = vErrors.length;
|
|
3682
|
+
}
|
|
3683
|
+
}
|
|
3684
|
+
} else {
|
|
3685
|
+
const err4 = { instancePath: instancePath + "/rows", schemaPath: "#/properties/rows/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
3686
|
+
if (vErrors === null) {
|
|
3687
|
+
vErrors = [err4];
|
|
3688
|
+
} else {
|
|
3689
|
+
vErrors.push(err4);
|
|
3690
|
+
}
|
|
3691
|
+
errors++;
|
|
3692
|
+
}
|
|
3693
|
+
}
|
|
3694
|
+
if (data.points !== void 0) {
|
|
3695
|
+
let data4 = data.points;
|
|
3696
|
+
if (Array.isArray(data4)) {
|
|
3697
|
+
const len1 = data4.length;
|
|
3698
|
+
for (let i1 = 0; i1 < len1; i1++) {
|
|
3699
|
+
if (!validate55(data4[i1], { instancePath: instancePath + "/points/" + i1, parentData: data4, parentDataProperty: i1, rootData })) {
|
|
3700
|
+
vErrors = vErrors === null ? validate55.errors : vErrors.concat(validate55.errors);
|
|
3701
|
+
errors = vErrors.length;
|
|
3702
|
+
}
|
|
3703
|
+
}
|
|
3704
|
+
} else {
|
|
3705
|
+
const err5 = { instancePath: instancePath + "/points", schemaPath: "#/properties/points/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
3706
|
+
if (vErrors === null) {
|
|
3707
|
+
vErrors = [err5];
|
|
3708
|
+
} else {
|
|
3709
|
+
vErrors.push(err5);
|
|
3710
|
+
}
|
|
3711
|
+
errors++;
|
|
3712
|
+
}
|
|
3713
|
+
}
|
|
3714
|
+
if (data.zoom !== void 0) {
|
|
3715
|
+
if (!validate57(data.zoom, { instancePath: instancePath + "/zoom", parentData: data, parentDataProperty: "zoom", rootData })) {
|
|
3716
|
+
vErrors = vErrors === null ? validate57.errors : vErrors.concat(validate57.errors);
|
|
3717
|
+
errors = vErrors.length;
|
|
3718
|
+
}
|
|
3719
|
+
}
|
|
3720
|
+
} else {
|
|
3721
|
+
const err6 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
3722
|
+
if (vErrors === null) {
|
|
3723
|
+
vErrors = [err6];
|
|
3724
|
+
} else {
|
|
3725
|
+
vErrors.push(err6);
|
|
3726
|
+
}
|
|
3727
|
+
errors++;
|
|
3728
|
+
}
|
|
3729
|
+
validate48.errors = vErrors;
|
|
3730
|
+
return errors === 0;
|
|
3731
|
+
}
|
|
3732
|
+
var func2 = Object.prototype.hasOwnProperty;
|
|
3733
|
+
function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
|
|
3734
|
+
let vErrors = null;
|
|
3735
|
+
let errors = 0;
|
|
3736
|
+
const _errs1 = errors;
|
|
3737
|
+
let valid0 = true;
|
|
3738
|
+
const _errs2 = errors;
|
|
3739
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
3740
|
+
if (data.kind === void 0 && ("kind")) {
|
|
3741
|
+
const err0 = {};
|
|
3742
|
+
if (vErrors === null) {
|
|
3743
|
+
vErrors = [err0];
|
|
3744
|
+
} else {
|
|
3745
|
+
vErrors.push(err0);
|
|
3746
|
+
}
|
|
3747
|
+
errors++;
|
|
3748
|
+
} else {
|
|
3749
|
+
if (data.kind !== void 0) {
|
|
3750
|
+
if ("sequence" !== data.kind) {
|
|
2102
3751
|
const err1 = {};
|
|
2103
3752
|
if (vErrors === null) {
|
|
2104
3753
|
vErrors = [err1];
|
|
@@ -2147,75 +3796,41 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2147
3796
|
}
|
|
2148
3797
|
}
|
|
2149
3798
|
if (data.steps !== void 0) {
|
|
2150
|
-
|
|
2151
|
-
|
|
2152
|
-
|
|
2153
|
-
|
|
2154
|
-
|
|
2155
|
-
|
|
2156
|
-
|
|
2157
|
-
|
|
2158
|
-
|
|
2159
|
-
const len1 = data4.length;
|
|
2160
|
-
for (let i1 = 0; i1 < len1; i1++) {
|
|
2161
|
-
let data5 = data4[i1];
|
|
2162
|
-
if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
|
|
2163
|
-
if (data5.type !== void 0) {
|
|
2164
|
-
let data6 = data5.type;
|
|
2165
|
-
const _errs12 = errors;
|
|
2166
|
-
const _errs13 = errors;
|
|
2167
|
-
if (!(data6 === "commit" || data6 === "branch")) {
|
|
2168
|
-
const err4 = {};
|
|
2169
|
-
if (vErrors === null) {
|
|
2170
|
-
vErrors = [err4];
|
|
2171
|
-
} else {
|
|
2172
|
-
vErrors.push(err4);
|
|
2173
|
-
}
|
|
2174
|
-
errors++;
|
|
2175
|
-
}
|
|
2176
|
-
var valid10 = _errs13 === errors;
|
|
2177
|
-
if (valid10) {
|
|
2178
|
-
const err5 = { instancePath: instancePath + "/steps/" + i0 + "/events/" + i1 + "/type", schemaPath: "#/definitions/plainSteps/items/properties/events/items/properties/type/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2179
|
-
if (vErrors === null) {
|
|
2180
|
-
vErrors = [err5];
|
|
2181
|
-
} else {
|
|
2182
|
-
vErrors.push(err5);
|
|
2183
|
-
}
|
|
2184
|
-
errors++;
|
|
2185
|
-
} else {
|
|
2186
|
-
errors = _errs12;
|
|
2187
|
-
if (vErrors !== null) {
|
|
2188
|
-
if (_errs12) {
|
|
2189
|
-
vErrors.length = _errs12;
|
|
2190
|
-
} else {
|
|
2191
|
-
vErrors = null;
|
|
2192
|
-
}
|
|
2193
|
-
}
|
|
2194
|
-
}
|
|
2195
|
-
}
|
|
2196
|
-
}
|
|
2197
|
-
}
|
|
2198
|
-
}
|
|
2199
|
-
}
|
|
2200
|
-
}
|
|
2201
|
-
}
|
|
3799
|
+
if (!validate11(data.steps, { instancePath: instancePath + "/steps", parentData: data, parentDataProperty: "steps", rootData })) {
|
|
3800
|
+
vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);
|
|
3801
|
+
errors = vErrors.length;
|
|
3802
|
+
}
|
|
3803
|
+
}
|
|
3804
|
+
if (data.strip !== void 0) {
|
|
3805
|
+
if (!validate13(data.strip, { instancePath: instancePath + "/strip", parentData: data, parentDataProperty: "strip", rootData })) {
|
|
3806
|
+
vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
|
|
3807
|
+
errors = vErrors.length;
|
|
2202
3808
|
}
|
|
2203
3809
|
}
|
|
2204
3810
|
if (data.state !== void 0) {
|
|
2205
|
-
const
|
|
3811
|
+
const err4 = { instancePath: instancePath + "/state", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2206
3812
|
if (vErrors === null) {
|
|
2207
|
-
vErrors = [
|
|
3813
|
+
vErrors = [err4];
|
|
2208
3814
|
} else {
|
|
2209
|
-
vErrors.push(
|
|
3815
|
+
vErrors.push(err4);
|
|
2210
3816
|
}
|
|
2211
3817
|
errors++;
|
|
2212
3818
|
}
|
|
2213
3819
|
if (data.git !== void 0) {
|
|
2214
|
-
const
|
|
3820
|
+
const err5 = { instancePath: instancePath + "/git", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2215
3821
|
if (vErrors === null) {
|
|
2216
|
-
vErrors = [
|
|
3822
|
+
vErrors = [err5];
|
|
2217
3823
|
} else {
|
|
2218
|
-
vErrors.push(
|
|
3824
|
+
vErrors.push(err5);
|
|
3825
|
+
}
|
|
3826
|
+
errors++;
|
|
3827
|
+
}
|
|
3828
|
+
if (data.time !== void 0) {
|
|
3829
|
+
const err6 = { instancePath: instancePath + "/time", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
3830
|
+
if (vErrors === null) {
|
|
3831
|
+
vErrors = [err6];
|
|
3832
|
+
} else {
|
|
3833
|
+
vErrors.push(err6);
|
|
2219
3834
|
}
|
|
2220
3835
|
errors++;
|
|
2221
3836
|
}
|
|
@@ -2224,89 +3839,89 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2224
3839
|
valid0 = _valid0;
|
|
2225
3840
|
ifClause0 = "then";
|
|
2226
3841
|
} else {
|
|
2227
|
-
const
|
|
2228
|
-
const
|
|
2229
|
-
let
|
|
2230
|
-
const
|
|
3842
|
+
const _errs17 = errors;
|
|
3843
|
+
const _errs18 = errors;
|
|
3844
|
+
let valid6 = true;
|
|
3845
|
+
const _errs19 = errors;
|
|
2231
3846
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2232
3847
|
if (data.kind === void 0 && ("kind")) {
|
|
2233
|
-
const
|
|
3848
|
+
const err7 = {};
|
|
2234
3849
|
if (vErrors === null) {
|
|
2235
|
-
vErrors = [
|
|
3850
|
+
vErrors = [err7];
|
|
2236
3851
|
} else {
|
|
2237
|
-
vErrors.push(
|
|
3852
|
+
vErrors.push(err7);
|
|
2238
3853
|
}
|
|
2239
3854
|
errors++;
|
|
2240
3855
|
} else {
|
|
2241
3856
|
if (data.kind !== void 0) {
|
|
2242
3857
|
if ("state" !== data.kind) {
|
|
2243
|
-
const
|
|
3858
|
+
const err8 = {};
|
|
2244
3859
|
if (vErrors === null) {
|
|
2245
|
-
vErrors = [
|
|
3860
|
+
vErrors = [err8];
|
|
2246
3861
|
} else {
|
|
2247
|
-
vErrors.push(
|
|
3862
|
+
vErrors.push(err8);
|
|
2248
3863
|
}
|
|
2249
3864
|
errors++;
|
|
2250
3865
|
}
|
|
2251
3866
|
}
|
|
2252
3867
|
}
|
|
2253
3868
|
}
|
|
2254
|
-
var _valid1 =
|
|
2255
|
-
errors =
|
|
3869
|
+
var _valid1 = _errs19 === errors;
|
|
3870
|
+
errors = _errs18;
|
|
2256
3871
|
if (vErrors !== null) {
|
|
2257
|
-
if (
|
|
2258
|
-
vErrors.length =
|
|
3872
|
+
if (_errs18) {
|
|
3873
|
+
vErrors.length = _errs18;
|
|
2259
3874
|
} else {
|
|
2260
3875
|
vErrors = null;
|
|
2261
3876
|
}
|
|
2262
3877
|
}
|
|
2263
3878
|
let ifClause1;
|
|
2264
3879
|
if (_valid1) {
|
|
2265
|
-
const
|
|
3880
|
+
const _errs21 = errors;
|
|
2266
3881
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2267
3882
|
if (data.boxes !== void 0) {
|
|
2268
|
-
let
|
|
2269
|
-
if (Array.isArray(
|
|
2270
|
-
if (
|
|
2271
|
-
const
|
|
3883
|
+
let data8 = data.boxes;
|
|
3884
|
+
if (Array.isArray(data8)) {
|
|
3885
|
+
if (data8.length < 1) {
|
|
3886
|
+
const err9 = { instancePath: instancePath + "/boxes", schemaPath: "#/else/then/properties/boxes/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
|
|
2272
3887
|
if (vErrors === null) {
|
|
2273
|
-
vErrors = [
|
|
3888
|
+
vErrors = [err9];
|
|
2274
3889
|
} else {
|
|
2275
|
-
vErrors.push(
|
|
3890
|
+
vErrors.push(err9);
|
|
2276
3891
|
}
|
|
2277
3892
|
errors++;
|
|
2278
3893
|
}
|
|
2279
|
-
const
|
|
2280
|
-
for (let
|
|
2281
|
-
let
|
|
2282
|
-
if (
|
|
2283
|
-
if (
|
|
2284
|
-
let
|
|
2285
|
-
const
|
|
2286
|
-
const
|
|
2287
|
-
if (!(
|
|
2288
|
-
const
|
|
3894
|
+
const len0 = data8.length;
|
|
3895
|
+
for (let i0 = 0; i0 < len0; i0++) {
|
|
3896
|
+
let data9 = data8[i0];
|
|
3897
|
+
if (data9 && typeof data9 == "object" && !Array.isArray(data9)) {
|
|
3898
|
+
if (data9.id !== void 0) {
|
|
3899
|
+
let data10 = data9.id;
|
|
3900
|
+
const _errs25 = errors;
|
|
3901
|
+
const _errs26 = errors;
|
|
3902
|
+
if (!(data10 === "start" || data10 === "finish")) {
|
|
3903
|
+
const err10 = {};
|
|
2289
3904
|
if (vErrors === null) {
|
|
2290
|
-
vErrors = [
|
|
3905
|
+
vErrors = [err10];
|
|
2291
3906
|
} else {
|
|
2292
|
-
vErrors.push(
|
|
3907
|
+
vErrors.push(err10);
|
|
2293
3908
|
}
|
|
2294
3909
|
errors++;
|
|
2295
3910
|
}
|
|
2296
|
-
var
|
|
2297
|
-
if (
|
|
2298
|
-
const
|
|
3911
|
+
var valid12 = _errs26 === errors;
|
|
3912
|
+
if (valid12) {
|
|
3913
|
+
const err11 = { instancePath: instancePath + "/boxes/" + i0 + "/id", schemaPath: "#/else/then/properties/boxes/items/properties/id/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2299
3914
|
if (vErrors === null) {
|
|
2300
|
-
vErrors = [
|
|
3915
|
+
vErrors = [err11];
|
|
2301
3916
|
} else {
|
|
2302
|
-
vErrors.push(
|
|
3917
|
+
vErrors.push(err11);
|
|
2303
3918
|
}
|
|
2304
3919
|
errors++;
|
|
2305
3920
|
} else {
|
|
2306
|
-
errors =
|
|
3921
|
+
errors = _errs25;
|
|
2307
3922
|
if (vErrors !== null) {
|
|
2308
|
-
if (
|
|
2309
|
-
vErrors.length =
|
|
3923
|
+
if (_errs25) {
|
|
3924
|
+
vErrors.length = _errs25;
|
|
2310
3925
|
} else {
|
|
2311
3926
|
vErrors = null;
|
|
2312
3927
|
}
|
|
@@ -2318,153 +3933,150 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2318
3933
|
}
|
|
2319
3934
|
}
|
|
2320
3935
|
if (data.steps !== void 0) {
|
|
2321
|
-
|
|
2322
|
-
|
|
2323
|
-
|
|
2324
|
-
|
|
2325
|
-
|
|
2326
|
-
|
|
2327
|
-
|
|
2328
|
-
|
|
2329
|
-
|
|
2330
|
-
const len4 = data15.length;
|
|
2331
|
-
for (let i4 = 0; i4 < len4; i4++) {
|
|
2332
|
-
let data16 = data15[i4];
|
|
2333
|
-
if (data16 && typeof data16 == "object" && !Array.isArray(data16)) {
|
|
2334
|
-
if (data16.type !== void 0) {
|
|
2335
|
-
let data17 = data16.type;
|
|
2336
|
-
const _errs36 = errors;
|
|
2337
|
-
const _errs37 = errors;
|
|
2338
|
-
if (!(data17 === "commit" || data17 === "branch")) {
|
|
2339
|
-
const err13 = {};
|
|
2340
|
-
if (vErrors === null) {
|
|
2341
|
-
vErrors = [err13];
|
|
2342
|
-
} else {
|
|
2343
|
-
vErrors.push(err13);
|
|
2344
|
-
}
|
|
2345
|
-
errors++;
|
|
2346
|
-
}
|
|
2347
|
-
var valid27 = _errs37 === errors;
|
|
2348
|
-
if (valid27) {
|
|
2349
|
-
const err14 = { instancePath: instancePath + "/steps/" + i3 + "/events/" + i4 + "/type", schemaPath: "#/definitions/plainSteps/items/properties/events/items/properties/type/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2350
|
-
if (vErrors === null) {
|
|
2351
|
-
vErrors = [err14];
|
|
2352
|
-
} else {
|
|
2353
|
-
vErrors.push(err14);
|
|
2354
|
-
}
|
|
2355
|
-
errors++;
|
|
2356
|
-
} else {
|
|
2357
|
-
errors = _errs36;
|
|
2358
|
-
if (vErrors !== null) {
|
|
2359
|
-
if (_errs36) {
|
|
2360
|
-
vErrors.length = _errs36;
|
|
2361
|
-
} else {
|
|
2362
|
-
vErrors = null;
|
|
2363
|
-
}
|
|
2364
|
-
}
|
|
2365
|
-
}
|
|
2366
|
-
}
|
|
2367
|
-
}
|
|
2368
|
-
}
|
|
2369
|
-
}
|
|
2370
|
-
}
|
|
2371
|
-
}
|
|
2372
|
-
}
|
|
3936
|
+
if (!validate11(data.steps, { instancePath: instancePath + "/steps", parentData: data, parentDataProperty: "steps", rootData })) {
|
|
3937
|
+
vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);
|
|
3938
|
+
errors = vErrors.length;
|
|
3939
|
+
}
|
|
3940
|
+
}
|
|
3941
|
+
if (data.strip !== void 0) {
|
|
3942
|
+
if (!validate13(data.strip, { instancePath: instancePath + "/strip", parentData: data, parentDataProperty: "strip", rootData })) {
|
|
3943
|
+
vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
|
|
3944
|
+
errors = vErrors.length;
|
|
2373
3945
|
}
|
|
2374
3946
|
}
|
|
2375
3947
|
if (data.git !== void 0) {
|
|
2376
|
-
const
|
|
3948
|
+
const err12 = { instancePath: instancePath + "/git", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
3949
|
+
if (vErrors === null) {
|
|
3950
|
+
vErrors = [err12];
|
|
3951
|
+
} else {
|
|
3952
|
+
vErrors.push(err12);
|
|
3953
|
+
}
|
|
3954
|
+
errors++;
|
|
3955
|
+
}
|
|
3956
|
+
if (data.time !== void 0) {
|
|
3957
|
+
const err13 = { instancePath: instancePath + "/time", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2377
3958
|
if (vErrors === null) {
|
|
2378
|
-
vErrors = [
|
|
3959
|
+
vErrors = [err13];
|
|
2379
3960
|
} else {
|
|
2380
|
-
vErrors.push(
|
|
3961
|
+
vErrors.push(err13);
|
|
2381
3962
|
}
|
|
2382
3963
|
errors++;
|
|
2383
3964
|
}
|
|
2384
3965
|
}
|
|
2385
|
-
var _valid1 =
|
|
2386
|
-
|
|
3966
|
+
var _valid1 = _errs21 === errors;
|
|
3967
|
+
valid6 = _valid1;
|
|
2387
3968
|
ifClause1 = "then";
|
|
2388
3969
|
} else {
|
|
2389
|
-
const
|
|
2390
|
-
const
|
|
2391
|
-
let
|
|
2392
|
-
const
|
|
3970
|
+
const _errs35 = errors;
|
|
3971
|
+
const _errs36 = errors;
|
|
3972
|
+
let valid15 = true;
|
|
3973
|
+
const _errs37 = errors;
|
|
2393
3974
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2394
3975
|
if (data.kind === void 0 && ("kind")) {
|
|
2395
|
-
const
|
|
3976
|
+
const err14 = {};
|
|
2396
3977
|
if (vErrors === null) {
|
|
2397
|
-
vErrors = [
|
|
3978
|
+
vErrors = [err14];
|
|
2398
3979
|
} else {
|
|
2399
|
-
vErrors.push(
|
|
3980
|
+
vErrors.push(err14);
|
|
2400
3981
|
}
|
|
2401
3982
|
errors++;
|
|
2402
3983
|
} else {
|
|
2403
3984
|
if (data.kind !== void 0) {
|
|
2404
3985
|
if ("git" !== data.kind) {
|
|
2405
|
-
const
|
|
3986
|
+
const err15 = {};
|
|
2406
3987
|
if (vErrors === null) {
|
|
2407
|
-
vErrors = [
|
|
3988
|
+
vErrors = [err15];
|
|
2408
3989
|
} else {
|
|
2409
|
-
vErrors.push(
|
|
3990
|
+
vErrors.push(err15);
|
|
2410
3991
|
}
|
|
2411
3992
|
errors++;
|
|
2412
3993
|
}
|
|
2413
3994
|
}
|
|
2414
3995
|
}
|
|
2415
3996
|
}
|
|
2416
|
-
var _valid2 =
|
|
2417
|
-
errors =
|
|
3997
|
+
var _valid2 = _errs37 === errors;
|
|
3998
|
+
errors = _errs36;
|
|
2418
3999
|
if (vErrors !== null) {
|
|
2419
|
-
if (
|
|
2420
|
-
vErrors.length =
|
|
4000
|
+
if (_errs36) {
|
|
4001
|
+
vErrors.length = _errs36;
|
|
2421
4002
|
} else {
|
|
2422
4003
|
vErrors = null;
|
|
2423
4004
|
}
|
|
2424
4005
|
}
|
|
2425
4006
|
let ifClause2;
|
|
2426
4007
|
if (_valid2) {
|
|
2427
|
-
const
|
|
4008
|
+
const _errs39 = errors;
|
|
2428
4009
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2429
4010
|
if (data.git === void 0) {
|
|
2430
|
-
const
|
|
4011
|
+
const err16 = { instancePath, schemaPath: "#/else/else/then/required", keyword: "required", params: { missingProperty: "git" }, message: "must have required property 'git'" };
|
|
2431
4012
|
if (vErrors === null) {
|
|
2432
|
-
vErrors = [
|
|
4013
|
+
vErrors = [err16];
|
|
2433
4014
|
} else {
|
|
2434
|
-
vErrors.push(
|
|
4015
|
+
vErrors.push(err16);
|
|
2435
4016
|
}
|
|
2436
4017
|
errors++;
|
|
2437
4018
|
}
|
|
4019
|
+
if (data.steps !== void 0) {
|
|
4020
|
+
if (!validate17(data.steps, { instancePath: instancePath + "/steps", parentData: data, parentDataProperty: "steps", rootData })) {
|
|
4021
|
+
vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
|
|
4022
|
+
errors = vErrors.length;
|
|
4023
|
+
}
|
|
4024
|
+
}
|
|
4025
|
+
if (data.strip !== void 0) {
|
|
4026
|
+
if (!validate13(data.strip, { instancePath: instancePath + "/strip", parentData: data, parentDataProperty: "strip", rootData })) {
|
|
4027
|
+
vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
|
|
4028
|
+
errors = vErrors.length;
|
|
4029
|
+
}
|
|
4030
|
+
}
|
|
2438
4031
|
if (data.state !== void 0) {
|
|
2439
|
-
const
|
|
4032
|
+
const err17 = { instancePath: instancePath + "/state", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2440
4033
|
if (vErrors === null) {
|
|
2441
|
-
vErrors = [
|
|
4034
|
+
vErrors = [err17];
|
|
2442
4035
|
} else {
|
|
2443
|
-
vErrors.push(
|
|
4036
|
+
vErrors.push(err17);
|
|
2444
4037
|
}
|
|
2445
4038
|
errors++;
|
|
2446
4039
|
}
|
|
2447
4040
|
if (data.regions !== void 0) {
|
|
2448
|
-
const
|
|
4041
|
+
const err18 = { instancePath: instancePath + "/regions", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2449
4042
|
if (vErrors === null) {
|
|
2450
|
-
vErrors = [
|
|
4043
|
+
vErrors = [err18];
|
|
2451
4044
|
} else {
|
|
2452
|
-
vErrors.push(
|
|
4045
|
+
vErrors.push(err18);
|
|
4046
|
+
}
|
|
4047
|
+
errors++;
|
|
4048
|
+
}
|
|
4049
|
+
if (data.time !== void 0) {
|
|
4050
|
+
const err19 = { instancePath: instancePath + "/time", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4051
|
+
if (vErrors === null) {
|
|
4052
|
+
vErrors = [err19];
|
|
4053
|
+
} else {
|
|
4054
|
+
vErrors.push(err19);
|
|
2453
4055
|
}
|
|
2454
4056
|
errors++;
|
|
2455
4057
|
}
|
|
2456
4058
|
}
|
|
2457
|
-
var _valid2 =
|
|
2458
|
-
|
|
4059
|
+
var _valid2 = _errs39 === errors;
|
|
4060
|
+
valid15 = _valid2;
|
|
2459
4061
|
ifClause2 = "then";
|
|
2460
4062
|
} else {
|
|
4063
|
+
const _errs51 = errors;
|
|
2461
4064
|
const _errs52 = errors;
|
|
4065
|
+
let valid21 = true;
|
|
4066
|
+
const _errs53 = errors;
|
|
2462
4067
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2463
|
-
if (data.
|
|
2464
|
-
|
|
2465
|
-
if (
|
|
2466
|
-
|
|
2467
|
-
|
|
4068
|
+
if (data.kind === void 0 && ("kind")) {
|
|
4069
|
+
const err20 = {};
|
|
4070
|
+
if (vErrors === null) {
|
|
4071
|
+
vErrors = [err20];
|
|
4072
|
+
} else {
|
|
4073
|
+
vErrors.push(err20);
|
|
4074
|
+
}
|
|
4075
|
+
errors++;
|
|
4076
|
+
} else {
|
|
4077
|
+
if (data.kind !== void 0) {
|
|
4078
|
+
if ("time" !== data.kind) {
|
|
4079
|
+
const err21 = {};
|
|
2468
4080
|
if (vErrors === null) {
|
|
2469
4081
|
vErrors = [err21];
|
|
2470
4082
|
} else {
|
|
@@ -2474,49 +4086,73 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2474
4086
|
}
|
|
2475
4087
|
}
|
|
2476
4088
|
}
|
|
2477
|
-
|
|
2478
|
-
|
|
2479
|
-
|
|
2480
|
-
|
|
2481
|
-
|
|
2482
|
-
|
|
2483
|
-
|
|
2484
|
-
|
|
2485
|
-
|
|
2486
|
-
|
|
2487
|
-
|
|
2488
|
-
|
|
2489
|
-
|
|
2490
|
-
|
|
2491
|
-
|
|
2492
|
-
|
|
2493
|
-
|
|
2494
|
-
|
|
2495
|
-
|
|
2496
|
-
|
|
2497
|
-
|
|
2498
|
-
|
|
2499
|
-
|
|
2500
|
-
|
|
2501
|
-
|
|
2502
|
-
|
|
2503
|
-
|
|
2504
|
-
|
|
2505
|
-
|
|
2506
|
-
|
|
2507
|
-
|
|
2508
|
-
|
|
2509
|
-
|
|
2510
|
-
|
|
4089
|
+
}
|
|
4090
|
+
var _valid3 = _errs53 === errors;
|
|
4091
|
+
errors = _errs52;
|
|
4092
|
+
if (vErrors !== null) {
|
|
4093
|
+
if (_errs52) {
|
|
4094
|
+
vErrors.length = _errs52;
|
|
4095
|
+
} else {
|
|
4096
|
+
vErrors = null;
|
|
4097
|
+
}
|
|
4098
|
+
}
|
|
4099
|
+
let ifClause3;
|
|
4100
|
+
if (_valid3) {
|
|
4101
|
+
const _errs55 = errors;
|
|
4102
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
4103
|
+
if (data.time === void 0) {
|
|
4104
|
+
const err22 = { instancePath, schemaPath: "#/else/else/else/then/required", keyword: "required", params: { missingProperty: "time" }, message: "must have required property 'time'" };
|
|
4105
|
+
if (vErrors === null) {
|
|
4106
|
+
vErrors = [err22];
|
|
4107
|
+
} else {
|
|
4108
|
+
vErrors.push(err22);
|
|
4109
|
+
}
|
|
4110
|
+
errors++;
|
|
4111
|
+
}
|
|
4112
|
+
if (data.steps !== void 0) {
|
|
4113
|
+
let data22 = data.steps;
|
|
4114
|
+
if (Array.isArray(data22)) {
|
|
4115
|
+
const len1 = data22.length;
|
|
4116
|
+
for (let i1 = 0; i1 < len1; i1++) {
|
|
4117
|
+
let data23 = data22[i1];
|
|
4118
|
+
if (data23 && typeof data23 == "object" && !Array.isArray(data23)) {
|
|
4119
|
+
if (data23.events !== void 0) {
|
|
4120
|
+
let data24 = data23.events;
|
|
4121
|
+
if (Array.isArray(data24)) {
|
|
4122
|
+
const len2 = data24.length;
|
|
4123
|
+
for (let i2 = 0; i2 < len2; i2++) {
|
|
4124
|
+
let data25 = data24[i2];
|
|
4125
|
+
if (data25 && typeof data25 == "object" && !Array.isArray(data25)) {
|
|
4126
|
+
if (data25.type !== void 0) {
|
|
4127
|
+
let data26 = data25.type;
|
|
4128
|
+
const _errs62 = errors;
|
|
4129
|
+
const _errs63 = errors;
|
|
4130
|
+
if (!(data26 === "commit" || data26 === "branch")) {
|
|
4131
|
+
const err23 = {};
|
|
4132
|
+
if (vErrors === null) {
|
|
4133
|
+
vErrors = [err23];
|
|
4134
|
+
} else {
|
|
4135
|
+
vErrors.push(err23);
|
|
4136
|
+
}
|
|
4137
|
+
errors++;
|
|
2511
4138
|
}
|
|
2512
|
-
errors
|
|
2513
|
-
|
|
2514
|
-
|
|
2515
|
-
|
|
2516
|
-
|
|
2517
|
-
vErrors.length = _errs60;
|
|
4139
|
+
var valid31 = _errs63 === errors;
|
|
4140
|
+
if (valid31) {
|
|
4141
|
+
const err24 = { instancePath: instancePath + "/steps/" + i1 + "/events/" + i2 + "/type", schemaPath: "#/definitions/timeSteps/items/properties/events/items/properties/type/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4142
|
+
if (vErrors === null) {
|
|
4143
|
+
vErrors = [err24];
|
|
2518
4144
|
} else {
|
|
2519
|
-
vErrors
|
|
4145
|
+
vErrors.push(err24);
|
|
4146
|
+
}
|
|
4147
|
+
errors++;
|
|
4148
|
+
} else {
|
|
4149
|
+
errors = _errs62;
|
|
4150
|
+
if (vErrors !== null) {
|
|
4151
|
+
if (_errs62) {
|
|
4152
|
+
vErrors.length = _errs62;
|
|
4153
|
+
} else {
|
|
4154
|
+
vErrors = null;
|
|
4155
|
+
}
|
|
2520
4156
|
}
|
|
2521
4157
|
}
|
|
2522
4158
|
}
|
|
@@ -2528,301 +4164,388 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2528
4164
|
}
|
|
2529
4165
|
}
|
|
2530
4166
|
}
|
|
2531
|
-
|
|
2532
|
-
|
|
2533
|
-
|
|
2534
|
-
|
|
2535
|
-
|
|
2536
|
-
|
|
2537
|
-
|
|
4167
|
+
if (data.state !== void 0) {
|
|
4168
|
+
const err25 = { instancePath: instancePath + "/state", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4169
|
+
if (vErrors === null) {
|
|
4170
|
+
vErrors = [err25];
|
|
4171
|
+
} else {
|
|
4172
|
+
vErrors.push(err25);
|
|
4173
|
+
}
|
|
4174
|
+
errors++;
|
|
4175
|
+
}
|
|
4176
|
+
if (data.git !== void 0) {
|
|
4177
|
+
const err26 = { instancePath: instancePath + "/git", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4178
|
+
if (vErrors === null) {
|
|
4179
|
+
vErrors = [err26];
|
|
4180
|
+
} else {
|
|
4181
|
+
vErrors.push(err26);
|
|
4182
|
+
}
|
|
4183
|
+
errors++;
|
|
4184
|
+
}
|
|
4185
|
+
if (data.regions !== void 0) {
|
|
4186
|
+
const err27 = { instancePath: instancePath + "/regions", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4187
|
+
if (vErrors === null) {
|
|
4188
|
+
vErrors = [err27];
|
|
4189
|
+
} else {
|
|
4190
|
+
vErrors.push(err27);
|
|
4191
|
+
}
|
|
4192
|
+
errors++;
|
|
2538
4193
|
}
|
|
2539
|
-
errors++;
|
|
2540
4194
|
}
|
|
2541
|
-
|
|
2542
|
-
|
|
2543
|
-
|
|
2544
|
-
|
|
2545
|
-
|
|
2546
|
-
|
|
4195
|
+
var _valid3 = _errs55 === errors;
|
|
4196
|
+
valid21 = _valid3;
|
|
4197
|
+
ifClause3 = "then";
|
|
4198
|
+
} else {
|
|
4199
|
+
const _errs73 = errors;
|
|
4200
|
+
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
4201
|
+
if (data.boxes !== void 0) {
|
|
4202
|
+
let data30 = data.boxes;
|
|
4203
|
+
if (Array.isArray(data30)) {
|
|
4204
|
+
if (data30.length < 1) {
|
|
4205
|
+
const err28 = { instancePath: instancePath + "/boxes", schemaPath: "#/else/else/else/else/properties/boxes/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
|
|
4206
|
+
if (vErrors === null) {
|
|
4207
|
+
vErrors = [err28];
|
|
4208
|
+
} else {
|
|
4209
|
+
vErrors.push(err28);
|
|
4210
|
+
}
|
|
4211
|
+
errors++;
|
|
4212
|
+
}
|
|
4213
|
+
}
|
|
2547
4214
|
}
|
|
2548
|
-
|
|
4215
|
+
if (data.steps !== void 0) {
|
|
4216
|
+
if (!validate11(data.steps, { instancePath: instancePath + "/steps", parentData: data, parentDataProperty: "steps", rootData })) {
|
|
4217
|
+
vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);
|
|
4218
|
+
errors = vErrors.length;
|
|
4219
|
+
}
|
|
4220
|
+
}
|
|
4221
|
+
if (data.strip !== void 0) {
|
|
4222
|
+
if (!validate13(data.strip, { instancePath: instancePath + "/strip", parentData: data, parentDataProperty: "strip", rootData })) {
|
|
4223
|
+
vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
|
|
4224
|
+
errors = vErrors.length;
|
|
4225
|
+
}
|
|
4226
|
+
}
|
|
4227
|
+
if (data.state !== void 0) {
|
|
4228
|
+
const err29 = { instancePath: instancePath + "/state", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4229
|
+
if (vErrors === null) {
|
|
4230
|
+
vErrors = [err29];
|
|
4231
|
+
} else {
|
|
4232
|
+
vErrors.push(err29);
|
|
4233
|
+
}
|
|
4234
|
+
errors++;
|
|
4235
|
+
}
|
|
4236
|
+
if (data.git !== void 0) {
|
|
4237
|
+
const err30 = { instancePath: instancePath + "/git", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4238
|
+
if (vErrors === null) {
|
|
4239
|
+
vErrors = [err30];
|
|
4240
|
+
} else {
|
|
4241
|
+
vErrors.push(err30);
|
|
4242
|
+
}
|
|
4243
|
+
errors++;
|
|
4244
|
+
}
|
|
4245
|
+
if (data.time !== void 0) {
|
|
4246
|
+
const err31 = { instancePath: instancePath + "/time", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
4247
|
+
if (vErrors === null) {
|
|
4248
|
+
vErrors = [err31];
|
|
4249
|
+
} else {
|
|
4250
|
+
vErrors.push(err31);
|
|
4251
|
+
}
|
|
4252
|
+
errors++;
|
|
4253
|
+
}
|
|
4254
|
+
}
|
|
4255
|
+
var _valid3 = _errs73 === errors;
|
|
4256
|
+
valid21 = _valid3;
|
|
4257
|
+
ifClause3 = "else";
|
|
4258
|
+
}
|
|
4259
|
+
if (!valid21) {
|
|
4260
|
+
const err32 = { instancePath, schemaPath: "#/else/else/else/if", keyword: "if", params: { failingKeyword: ifClause3 }, message: 'must match "' + ifClause3 + '" schema' };
|
|
4261
|
+
if (vErrors === null) {
|
|
4262
|
+
vErrors = [err32];
|
|
4263
|
+
} else {
|
|
4264
|
+
vErrors.push(err32);
|
|
2549
4265
|
}
|
|
4266
|
+
errors++;
|
|
2550
4267
|
}
|
|
2551
|
-
var _valid2 =
|
|
2552
|
-
|
|
4268
|
+
var _valid2 = _errs51 === errors;
|
|
4269
|
+
valid15 = _valid2;
|
|
2553
4270
|
ifClause2 = "else";
|
|
2554
4271
|
}
|
|
2555
|
-
if (!
|
|
2556
|
-
const
|
|
4272
|
+
if (!valid15) {
|
|
4273
|
+
const err33 = { instancePath, schemaPath: "#/else/else/if", keyword: "if", params: { failingKeyword: ifClause2 }, message: 'must match "' + ifClause2 + '" schema' };
|
|
2557
4274
|
if (vErrors === null) {
|
|
2558
|
-
vErrors = [
|
|
4275
|
+
vErrors = [err33];
|
|
2559
4276
|
} else {
|
|
2560
|
-
vErrors.push(
|
|
4277
|
+
vErrors.push(err33);
|
|
2561
4278
|
}
|
|
2562
4279
|
errors++;
|
|
2563
4280
|
}
|
|
2564
|
-
var _valid1 =
|
|
2565
|
-
|
|
4281
|
+
var _valid1 = _errs35 === errors;
|
|
4282
|
+
valid6 = _valid1;
|
|
2566
4283
|
ifClause1 = "else";
|
|
2567
4284
|
}
|
|
2568
|
-
if (!
|
|
2569
|
-
const
|
|
4285
|
+
if (!valid6) {
|
|
4286
|
+
const err34 = { instancePath, schemaPath: "#/else/if", keyword: "if", params: { failingKeyword: ifClause1 }, message: 'must match "' + ifClause1 + '" schema' };
|
|
2570
4287
|
if (vErrors === null) {
|
|
2571
|
-
vErrors = [
|
|
4288
|
+
vErrors = [err34];
|
|
2572
4289
|
} else {
|
|
2573
|
-
vErrors.push(
|
|
4290
|
+
vErrors.push(err34);
|
|
2574
4291
|
}
|
|
2575
4292
|
errors++;
|
|
2576
4293
|
}
|
|
2577
4294
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2578
4295
|
if (data.sequence !== void 0) {
|
|
2579
|
-
const
|
|
4296
|
+
const err35 = { instancePath: instancePath + "/sequence", schemaPath: "#/definitions/absent/not", keyword: "not", params: {}, message: "must NOT be valid" };
|
|
2580
4297
|
if (vErrors === null) {
|
|
2581
|
-
vErrors = [
|
|
4298
|
+
vErrors = [err35];
|
|
2582
4299
|
} else {
|
|
2583
|
-
vErrors.push(
|
|
4300
|
+
vErrors.push(err35);
|
|
2584
4301
|
}
|
|
2585
4302
|
errors++;
|
|
2586
4303
|
}
|
|
2587
4304
|
}
|
|
2588
|
-
var _valid0 =
|
|
4305
|
+
var _valid0 = _errs17 === errors;
|
|
2589
4306
|
valid0 = _valid0;
|
|
2590
4307
|
ifClause0 = "else";
|
|
2591
4308
|
}
|
|
2592
4309
|
if (!valid0) {
|
|
2593
|
-
const
|
|
4310
|
+
const err36 = { instancePath, schemaPath: "#/if", keyword: "if", params: { failingKeyword: ifClause0 }, message: 'must match "' + ifClause0 + '" schema' };
|
|
2594
4311
|
if (vErrors === null) {
|
|
2595
|
-
vErrors = [
|
|
4312
|
+
vErrors = [err36];
|
|
2596
4313
|
} else {
|
|
2597
|
-
vErrors.push(
|
|
4314
|
+
vErrors.push(err36);
|
|
2598
4315
|
}
|
|
2599
4316
|
errors++;
|
|
2600
4317
|
}
|
|
2601
4318
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
2602
4319
|
if (data.version === void 0) {
|
|
2603
|
-
const
|
|
4320
|
+
const err37 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property 'version'" };
|
|
2604
4321
|
if (vErrors === null) {
|
|
2605
|
-
vErrors = [
|
|
4322
|
+
vErrors = [err37];
|
|
2606
4323
|
} else {
|
|
2607
|
-
vErrors.push(
|
|
4324
|
+
vErrors.push(err37);
|
|
2608
4325
|
}
|
|
2609
4326
|
errors++;
|
|
2610
4327
|
}
|
|
2611
4328
|
if (data.kind === void 0) {
|
|
2612
|
-
const
|
|
4329
|
+
const err38 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind" }, message: "must have required property 'kind'" };
|
|
2613
4330
|
if (vErrors === null) {
|
|
2614
|
-
vErrors = [
|
|
4331
|
+
vErrors = [err38];
|
|
2615
4332
|
} else {
|
|
2616
|
-
vErrors.push(
|
|
4333
|
+
vErrors.push(err38);
|
|
2617
4334
|
}
|
|
2618
4335
|
errors++;
|
|
2619
4336
|
}
|
|
2620
4337
|
if (data.title === void 0) {
|
|
2621
|
-
const
|
|
4338
|
+
const err39 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "title" }, message: "must have required property 'title'" };
|
|
2622
4339
|
if (vErrors === null) {
|
|
2623
|
-
vErrors = [
|
|
4340
|
+
vErrors = [err39];
|
|
2624
4341
|
} else {
|
|
2625
|
-
vErrors.push(
|
|
4342
|
+
vErrors.push(err39);
|
|
2626
4343
|
}
|
|
2627
4344
|
errors++;
|
|
2628
4345
|
}
|
|
2629
4346
|
if (data.boxes === void 0) {
|
|
2630
|
-
const
|
|
4347
|
+
const err40 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "boxes" }, message: "must have required property 'boxes'" };
|
|
2631
4348
|
if (vErrors === null) {
|
|
2632
|
-
vErrors = [
|
|
4349
|
+
vErrors = [err40];
|
|
2633
4350
|
} else {
|
|
2634
|
-
vErrors.push(
|
|
4351
|
+
vErrors.push(err40);
|
|
2635
4352
|
}
|
|
2636
4353
|
errors++;
|
|
2637
4354
|
}
|
|
2638
4355
|
if (data.steps === void 0) {
|
|
2639
|
-
const
|
|
4356
|
+
const err41 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "steps" }, message: "must have required property 'steps'" };
|
|
2640
4357
|
if (vErrors === null) {
|
|
2641
|
-
vErrors = [
|
|
4358
|
+
vErrors = [err41];
|
|
2642
4359
|
} else {
|
|
2643
|
-
vErrors.push(
|
|
4360
|
+
vErrors.push(err41);
|
|
2644
4361
|
}
|
|
2645
4362
|
errors++;
|
|
2646
4363
|
}
|
|
2647
4364
|
for (const key0 in data) {
|
|
2648
4365
|
if (!func2.call(schema11.properties, key0)) {
|
|
2649
|
-
const
|
|
4366
|
+
const err42 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
|
|
2650
4367
|
if (vErrors === null) {
|
|
2651
|
-
vErrors = [
|
|
4368
|
+
vErrors = [err42];
|
|
2652
4369
|
} else {
|
|
2653
|
-
vErrors.push(
|
|
4370
|
+
vErrors.push(err42);
|
|
2654
4371
|
}
|
|
2655
4372
|
errors++;
|
|
2656
4373
|
}
|
|
2657
4374
|
}
|
|
2658
4375
|
if (data.version !== void 0) {
|
|
2659
|
-
let
|
|
2660
|
-
if (!(typeof
|
|
2661
|
-
const
|
|
4376
|
+
let data37 = data.version;
|
|
4377
|
+
if (!(typeof data37 == "number" && (!(data37 % 1) && !isNaN(data37)) && isFinite(data37))) {
|
|
4378
|
+
const err43 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
|
|
2662
4379
|
if (vErrors === null) {
|
|
2663
|
-
vErrors = [
|
|
4380
|
+
vErrors = [err43];
|
|
2664
4381
|
} else {
|
|
2665
|
-
vErrors.push(
|
|
4382
|
+
vErrors.push(err43);
|
|
2666
4383
|
}
|
|
2667
4384
|
errors++;
|
|
2668
4385
|
}
|
|
2669
|
-
if (typeof
|
|
2670
|
-
if (
|
|
2671
|
-
const
|
|
4386
|
+
if (typeof data37 == "number" && isFinite(data37)) {
|
|
4387
|
+
if (data37 < 1 || isNaN(data37)) {
|
|
4388
|
+
const err44 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
|
|
2672
4389
|
if (vErrors === null) {
|
|
2673
|
-
vErrors = [
|
|
4390
|
+
vErrors = [err44];
|
|
2674
4391
|
} else {
|
|
2675
|
-
vErrors.push(
|
|
4392
|
+
vErrors.push(err44);
|
|
2676
4393
|
}
|
|
2677
4394
|
errors++;
|
|
2678
4395
|
}
|
|
2679
4396
|
}
|
|
2680
4397
|
}
|
|
2681
4398
|
if (data.kind !== void 0) {
|
|
2682
|
-
let
|
|
2683
|
-
if (!(
|
|
2684
|
-
const
|
|
4399
|
+
let data38 = data.kind;
|
|
4400
|
+
if (!(data38 === "sequence" || data38 === "architecture" || data38 === "state" || data38 === "git" || data38 === "time")) {
|
|
4401
|
+
const err45 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema11.properties.kind.enum }, message: "must be equal to one of the allowed values" };
|
|
2685
4402
|
if (vErrors === null) {
|
|
2686
|
-
vErrors = [
|
|
4403
|
+
vErrors = [err45];
|
|
2687
4404
|
} else {
|
|
2688
|
-
vErrors.push(
|
|
4405
|
+
vErrors.push(err45);
|
|
2689
4406
|
}
|
|
2690
4407
|
errors++;
|
|
2691
4408
|
}
|
|
2692
4409
|
}
|
|
2693
4410
|
if (data.title !== void 0) {
|
|
2694
|
-
let
|
|
2695
|
-
if (typeof
|
|
2696
|
-
if (func3(
|
|
2697
|
-
const
|
|
4411
|
+
let data39 = data.title;
|
|
4412
|
+
if (typeof data39 === "string") {
|
|
4413
|
+
if (func3(data39) < 1) {
|
|
4414
|
+
const err46 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
|
|
2698
4415
|
if (vErrors === null) {
|
|
2699
|
-
vErrors = [
|
|
4416
|
+
vErrors = [err46];
|
|
2700
4417
|
} else {
|
|
2701
|
-
vErrors.push(
|
|
4418
|
+
vErrors.push(err46);
|
|
2702
4419
|
}
|
|
2703
4420
|
errors++;
|
|
2704
4421
|
}
|
|
2705
4422
|
} else {
|
|
2706
|
-
const
|
|
4423
|
+
const err47 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
|
|
2707
4424
|
if (vErrors === null) {
|
|
2708
|
-
vErrors = [
|
|
4425
|
+
vErrors = [err47];
|
|
2709
4426
|
} else {
|
|
2710
|
-
vErrors.push(
|
|
4427
|
+
vErrors.push(err47);
|
|
2711
4428
|
}
|
|
2712
4429
|
errors++;
|
|
2713
4430
|
}
|
|
2714
4431
|
}
|
|
2715
4432
|
if (data.view !== void 0) {
|
|
2716
|
-
let
|
|
2717
|
-
if (!(
|
|
2718
|
-
const
|
|
4433
|
+
let data40 = data.view;
|
|
4434
|
+
if (!(data40 === "fixed" || data40 === "follow")) {
|
|
4435
|
+
const err48 = { instancePath: instancePath + "/view", schemaPath: "#/properties/view/enum", keyword: "enum", params: { allowedValues: schema11.properties.view.enum }, message: "must be equal to one of the allowed values" };
|
|
2719
4436
|
if (vErrors === null) {
|
|
2720
|
-
vErrors = [
|
|
4437
|
+
vErrors = [err48];
|
|
2721
4438
|
} else {
|
|
2722
|
-
vErrors.push(
|
|
4439
|
+
vErrors.push(err48);
|
|
2723
4440
|
}
|
|
2724
4441
|
errors++;
|
|
2725
4442
|
}
|
|
2726
4443
|
}
|
|
2727
4444
|
if (data.regions !== void 0) {
|
|
2728
|
-
let
|
|
2729
|
-
if (Array.isArray(
|
|
2730
|
-
const
|
|
2731
|
-
for (let
|
|
2732
|
-
if (!
|
|
2733
|
-
vErrors = vErrors === null ?
|
|
4445
|
+
let data41 = data.regions;
|
|
4446
|
+
if (Array.isArray(data41)) {
|
|
4447
|
+
const len3 = data41.length;
|
|
4448
|
+
for (let i3 = 0; i3 < len3; i3++) {
|
|
4449
|
+
if (!validate22(data41[i3], { instancePath: instancePath + "/regions/" + i3, parentData: data41, parentDataProperty: i3, rootData })) {
|
|
4450
|
+
vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
|
|
2734
4451
|
errors = vErrors.length;
|
|
2735
4452
|
}
|
|
2736
4453
|
}
|
|
2737
4454
|
} else {
|
|
2738
|
-
const
|
|
4455
|
+
const err49 = { instancePath: instancePath + "/regions", schemaPath: "#/properties/regions/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
2739
4456
|
if (vErrors === null) {
|
|
2740
|
-
vErrors = [
|
|
4457
|
+
vErrors = [err49];
|
|
2741
4458
|
} else {
|
|
2742
|
-
vErrors.push(
|
|
4459
|
+
vErrors.push(err49);
|
|
2743
4460
|
}
|
|
2744
4461
|
errors++;
|
|
2745
4462
|
}
|
|
2746
4463
|
}
|
|
2747
4464
|
if (data.boxes !== void 0) {
|
|
2748
|
-
let
|
|
2749
|
-
if (Array.isArray(
|
|
2750
|
-
const
|
|
2751
|
-
for (let
|
|
2752
|
-
if (!
|
|
2753
|
-
vErrors = vErrors === null ?
|
|
4465
|
+
let data43 = data.boxes;
|
|
4466
|
+
if (Array.isArray(data43)) {
|
|
4467
|
+
const len4 = data43.length;
|
|
4468
|
+
for (let i4 = 0; i4 < len4; i4++) {
|
|
4469
|
+
if (!validate24(data43[i4], { instancePath: instancePath + "/boxes/" + i4, parentData: data43, parentDataProperty: i4, rootData })) {
|
|
4470
|
+
vErrors = vErrors === null ? validate24.errors : vErrors.concat(validate24.errors);
|
|
2754
4471
|
errors = vErrors.length;
|
|
2755
4472
|
}
|
|
2756
4473
|
}
|
|
2757
4474
|
} else {
|
|
2758
|
-
const
|
|
4475
|
+
const err50 = { instancePath: instancePath + "/boxes", schemaPath: "#/properties/boxes/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
2759
4476
|
if (vErrors === null) {
|
|
2760
|
-
vErrors = [
|
|
4477
|
+
vErrors = [err50];
|
|
2761
4478
|
} else {
|
|
2762
|
-
vErrors.push(
|
|
4479
|
+
vErrors.push(err50);
|
|
2763
4480
|
}
|
|
2764
4481
|
errors++;
|
|
2765
4482
|
}
|
|
2766
4483
|
}
|
|
2767
4484
|
if (data.strip !== void 0) {
|
|
2768
|
-
if (!
|
|
2769
|
-
vErrors = vErrors === null ?
|
|
4485
|
+
if (!validate26(data.strip, { instancePath: instancePath + "/strip", parentData: data, parentDataProperty: "strip", rootData })) {
|
|
4486
|
+
vErrors = vErrors === null ? validate26.errors : vErrors.concat(validate26.errors);
|
|
2770
4487
|
errors = vErrors.length;
|
|
2771
4488
|
}
|
|
2772
4489
|
}
|
|
2773
4490
|
if (data.steps !== void 0) {
|
|
2774
|
-
let
|
|
2775
|
-
if (Array.isArray(
|
|
2776
|
-
if (
|
|
2777
|
-
const
|
|
4491
|
+
let data46 = data.steps;
|
|
4492
|
+
if (Array.isArray(data46)) {
|
|
4493
|
+
if (data46.length < 1) {
|
|
4494
|
+
const err51 = { instancePath: instancePath + "/steps", schemaPath: "#/properties/steps/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
|
|
2778
4495
|
if (vErrors === null) {
|
|
2779
|
-
vErrors = [
|
|
4496
|
+
vErrors = [err51];
|
|
2780
4497
|
} else {
|
|
2781
|
-
vErrors.push(
|
|
4498
|
+
vErrors.push(err51);
|
|
2782
4499
|
}
|
|
2783
4500
|
errors++;
|
|
2784
4501
|
}
|
|
2785
|
-
const
|
|
2786
|
-
for (let
|
|
2787
|
-
if (!
|
|
2788
|
-
vErrors = vErrors === null ?
|
|
4502
|
+
const len5 = data46.length;
|
|
4503
|
+
for (let i5 = 0; i5 < len5; i5++) {
|
|
4504
|
+
if (!validate30(data46[i5], { instancePath: instancePath + "/steps/" + i5, parentData: data46, parentDataProperty: i5, rootData })) {
|
|
4505
|
+
vErrors = vErrors === null ? validate30.errors : vErrors.concat(validate30.errors);
|
|
2789
4506
|
errors = vErrors.length;
|
|
2790
4507
|
}
|
|
2791
4508
|
}
|
|
2792
4509
|
} else {
|
|
2793
|
-
const
|
|
4510
|
+
const err52 = { instancePath: instancePath + "/steps", schemaPath: "#/properties/steps/type", keyword: "type", params: { type: "array" }, message: "must be array" };
|
|
2794
4511
|
if (vErrors === null) {
|
|
2795
|
-
vErrors = [
|
|
4512
|
+
vErrors = [err52];
|
|
2796
4513
|
} else {
|
|
2797
|
-
vErrors.push(
|
|
4514
|
+
vErrors.push(err52);
|
|
2798
4515
|
}
|
|
2799
4516
|
errors++;
|
|
2800
4517
|
}
|
|
2801
4518
|
}
|
|
2802
4519
|
if (data.sequence !== void 0) {
|
|
2803
|
-
if (!
|
|
2804
|
-
vErrors = vErrors === null ?
|
|
4520
|
+
if (!validate38(data.sequence, { instancePath: instancePath + "/sequence", parentData: data, parentDataProperty: "sequence", rootData })) {
|
|
4521
|
+
vErrors = vErrors === null ? validate38.errors : vErrors.concat(validate38.errors);
|
|
2805
4522
|
errors = vErrors.length;
|
|
2806
4523
|
}
|
|
2807
4524
|
}
|
|
2808
4525
|
if (data.state !== void 0) {
|
|
2809
|
-
if (!
|
|
2810
|
-
vErrors = vErrors === null ?
|
|
4526
|
+
if (!validate40(data.state, { instancePath: instancePath + "/state", parentData: data, parentDataProperty: "state", rootData })) {
|
|
4527
|
+
vErrors = vErrors === null ? validate40.errors : vErrors.concat(validate40.errors);
|
|
2811
4528
|
errors = vErrors.length;
|
|
2812
4529
|
}
|
|
2813
4530
|
}
|
|
2814
4531
|
if (data.git !== void 0) {
|
|
2815
|
-
if (!
|
|
2816
|
-
vErrors = vErrors === null ?
|
|
4532
|
+
if (!validate44(data.git, { instancePath: instancePath + "/git", parentData: data, parentDataProperty: "git", rootData })) {
|
|
4533
|
+
vErrors = vErrors === null ? validate44.errors : vErrors.concat(validate44.errors);
|
|
4534
|
+
errors = vErrors.length;
|
|
4535
|
+
}
|
|
4536
|
+
}
|
|
4537
|
+
if (data.time !== void 0) {
|
|
4538
|
+
if (!validate48(data.time, { instancePath: instancePath + "/time", parentData: data, parentDataProperty: "time", rootData })) {
|
|
4539
|
+
vErrors = vErrors === null ? validate48.errors : vErrors.concat(validate48.errors);
|
|
2817
4540
|
errors = vErrors.length;
|
|
2818
4541
|
}
|
|
2819
4542
|
}
|
|
2820
4543
|
} else {
|
|
2821
|
-
const
|
|
4544
|
+
const err53 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
|
|
2822
4545
|
if (vErrors === null) {
|
|
2823
|
-
vErrors = [
|
|
4546
|
+
vErrors = [err53];
|
|
2824
4547
|
} else {
|
|
2825
|
-
vErrors.push(
|
|
4548
|
+
vErrors.push(err53);
|
|
2826
4549
|
}
|
|
2827
4550
|
errors++;
|
|
2828
4551
|
}
|
|
@@ -2832,16 +4555,21 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
|
|
|
2832
4555
|
var STATE_ENDS = ["start", "finish"];
|
|
2833
4556
|
|
|
2834
4557
|
// src/schema.ts
|
|
2835
|
-
var EVENT_TYPES = ["edge", "action", "swap", "strip", "commit", "branch"];
|
|
4558
|
+
var EVENT_TYPES = ["edge", "action", "swap", "strip", "commit", "branch", "now", "mark", "span"];
|
|
2836
4559
|
var ABSENT = "#/definitions/absent/not";
|
|
2837
|
-
var ABSENT_KINDS = { regions: "sequence / architecture / state" };
|
|
4560
|
+
var ABSENT_KINDS = { regions: "sequence / architecture / state", at: "time", into: "time", color: "time", meters: "time" };
|
|
2838
4561
|
var NOT_ALLOWED = {
|
|
2839
4562
|
carry: { field: "text", kind: "tag" }
|
|
2840
4563
|
};
|
|
2841
4564
|
var RESERVED_ID = /\/boxes\/items\/properties\/id\/not$/u;
|
|
2842
4565
|
var GIT_EVENT = /\/events\/items\/properties\/type\/not$/u;
|
|
2843
4566
|
var GIT_EVENTS = ["commit", "branch"];
|
|
4567
|
+
var TIME_EVENT = /\/events\/items\/not$/u;
|
|
4568
|
+
var TIME_EVENTS = ["now", "mark", "span"];
|
|
4569
|
+
var DURATION = /^\^\[0-9\]\+\(\\\.\[0-9\]\+\)\?\(([a-z|]+)\)\$$/u;
|
|
4570
|
+
var RATIO = /%\)\$$/u;
|
|
2844
4571
|
var escape = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
|
|
4572
|
+
var URL_RULE = "#/definitions/url/pattern";
|
|
2845
4573
|
var HEX = /^\^\[0-9a-f\]\{(\d+),(\d+)\}\$$/u;
|
|
2846
4574
|
function forbiddenOf(pattern) {
|
|
2847
4575
|
const inside = /^\^\[\^(.+)\]\+\$$/u.exec(pattern)?.[1];
|
|
@@ -2867,6 +4595,7 @@ function toFieldError(error, errors, m) {
|
|
|
2867
4595
|
case "not": {
|
|
2868
4596
|
if (RESERVED_ID.test(error.schemaPath)) return { pointer: at, message: m.reserved(STATE_ENDS) };
|
|
2869
4597
|
if (GIT_EVENT.test(error.schemaPath)) return { pointer: at, message: m.kindOnly(GIT_EVENTS, "git") };
|
|
4598
|
+
if (TIME_EVENT.test(error.schemaPath)) return { pointer: `${at}/type`, message: m.kindOnly(TIME_EVENTS, "time") };
|
|
2870
4599
|
const last = at.slice(at.lastIndexOf("/") + 1);
|
|
2871
4600
|
if (error.schemaPath === ABSENT) return { pointer: at, message: m.not({ field: last, kind: ABSENT_KINDS[last] ?? last }) };
|
|
2872
4601
|
const allowed = NOT_ALLOWED[last];
|
|
@@ -2888,8 +4617,14 @@ function toFieldError(error, errors, m) {
|
|
|
2888
4617
|
case "minLength":
|
|
2889
4618
|
return { pointer: at, message: m.minLength(Number(params.limit)) };
|
|
2890
4619
|
case "pattern": {
|
|
2891
|
-
|
|
2892
|
-
|
|
4620
|
+
if (error.schemaPath === URL_RULE) return { pointer: at, message: m.url };
|
|
4621
|
+
const pattern = String(params.pattern);
|
|
4622
|
+
const hex = HEX.exec(pattern);
|
|
4623
|
+
if (hex) return { pointer: at, message: m.hex(Number(hex[1]), Number(hex[2])) };
|
|
4624
|
+
const duration = DURATION.exec(pattern);
|
|
4625
|
+
if (duration) return { pointer: at, message: m.duration((duration[1] ?? "").split("|")) };
|
|
4626
|
+
if (RATIO.test(pattern)) return { pointer: at, message: m.ratio };
|
|
4627
|
+
return { pointer: at, message: m.pattern(forbiddenOf(pattern)) };
|
|
2893
4628
|
}
|
|
2894
4629
|
case "minItems":
|
|
2895
4630
|
return { pointer: at, message: m.minItems(Number(params.limit)) };
|