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