@shaclmate/shacl-ast 4.0.14 → 4.0.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/AbstractShapesGraph.d.ts +75 -0
- package/dist/AbstractShapesGraph.js +380 -0
- package/dist/ShapesGraph.d.ts +21 -74
- package/dist/ShapesGraph.js +36 -319
- package/dist/generated.d.ts +190 -46
- package/dist/generated.js +1387 -98
- package/dist/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/package.json +3 -9
package/dist/generated.js
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
import dataFactory from "@rdfjs/data-model";
|
|
2
2
|
import datasetFactory from "@rdfjs/dataset";
|
|
3
|
+
import { LiteralFactory } from "@rdfx/literal";
|
|
4
|
+
import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet, } from "@rdfx/resource";
|
|
3
5
|
import { Either, Left, Maybe, Right } from "purify-ts";
|
|
4
|
-
import { LiteralFactory, PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet, } from "rdfjs-resource";
|
|
5
6
|
function $filterArray(filterItem) {
|
|
6
7
|
return (filter, values) => {
|
|
7
8
|
for (const value of values) {
|
|
@@ -162,6 +163,21 @@ class $IdentifierSet {
|
|
|
162
163
|
}
|
|
163
164
|
}
|
|
164
165
|
}
|
|
166
|
+
function $isReadonlyBigIntArray(x) {
|
|
167
|
+
return Array.isArray(x) && x.every((z) => typeof z === "bigint");
|
|
168
|
+
}
|
|
169
|
+
function $isReadonlyBooleanArray(x) {
|
|
170
|
+
return Array.isArray(x) && x.every((z) => typeof z === "boolean");
|
|
171
|
+
}
|
|
172
|
+
function $isReadonlyNumberArray(x) {
|
|
173
|
+
return Array.isArray(x) && x.every((z) => typeof z === "number");
|
|
174
|
+
}
|
|
175
|
+
function $isReadonlyObjectArray(x) {
|
|
176
|
+
return Array.isArray(x) && x.every((z) => typeof z === "object");
|
|
177
|
+
}
|
|
178
|
+
function $isReadonlyStringArray(x) {
|
|
179
|
+
return Array.isArray(x) && x.every((z) => typeof z === "string");
|
|
180
|
+
}
|
|
165
181
|
const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
|
|
166
182
|
export var $PropertyPath;
|
|
167
183
|
(function ($PropertyPath) {
|
|
@@ -219,6 +235,576 @@ function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }
|
|
|
219
235
|
}
|
|
220
236
|
export var PropertyShape;
|
|
221
237
|
(function (PropertyShape) {
|
|
238
|
+
function $create(parameters) {
|
|
239
|
+
let $identifier;
|
|
240
|
+
if (typeof parameters.$identifier === "object") {
|
|
241
|
+
$identifier = parameters.$identifier;
|
|
242
|
+
}
|
|
243
|
+
else if (typeof parameters.$identifier === "string") {
|
|
244
|
+
$identifier = dataFactory.namedNode(parameters.$identifier);
|
|
245
|
+
}
|
|
246
|
+
else if (parameters.$identifier === undefined) {
|
|
247
|
+
$identifier = dataFactory.blankNode();
|
|
248
|
+
}
|
|
249
|
+
else {
|
|
250
|
+
$identifier = parameters.$identifier;
|
|
251
|
+
}
|
|
252
|
+
const $type = "PropertyShape";
|
|
253
|
+
let and;
|
|
254
|
+
if (Maybe.isMaybe(parameters.and)) {
|
|
255
|
+
and = parameters.and;
|
|
256
|
+
}
|
|
257
|
+
else if ($isReadonlyObjectArray(parameters.and)) {
|
|
258
|
+
and = Maybe.of(parameters.and);
|
|
259
|
+
}
|
|
260
|
+
else if ($isReadonlyStringArray(parameters.and)) {
|
|
261
|
+
and = Maybe.of(parameters.and.map((item) => dataFactory.namedNode(item)));
|
|
262
|
+
}
|
|
263
|
+
else if (parameters.and === undefined) {
|
|
264
|
+
and = Maybe.empty();
|
|
265
|
+
}
|
|
266
|
+
else {
|
|
267
|
+
and = parameters.and;
|
|
268
|
+
}
|
|
269
|
+
let classes;
|
|
270
|
+
if (parameters.classes === undefined) {
|
|
271
|
+
classes = [];
|
|
272
|
+
}
|
|
273
|
+
else if ($isReadonlyObjectArray(parameters.classes)) {
|
|
274
|
+
classes = parameters.classes;
|
|
275
|
+
}
|
|
276
|
+
else if ($isReadonlyStringArray(parameters.classes)) {
|
|
277
|
+
classes = parameters.classes.map((item) => dataFactory.namedNode(item));
|
|
278
|
+
}
|
|
279
|
+
else {
|
|
280
|
+
classes = parameters.classes;
|
|
281
|
+
}
|
|
282
|
+
let comment;
|
|
283
|
+
if (Maybe.isMaybe(parameters.comment)) {
|
|
284
|
+
comment = parameters.comment;
|
|
285
|
+
}
|
|
286
|
+
else if (typeof parameters.comment === "string") {
|
|
287
|
+
comment = Maybe.of(parameters.comment);
|
|
288
|
+
}
|
|
289
|
+
else if (parameters.comment === undefined) {
|
|
290
|
+
comment = Maybe.empty();
|
|
291
|
+
}
|
|
292
|
+
else {
|
|
293
|
+
comment = parameters.comment;
|
|
294
|
+
}
|
|
295
|
+
let datatype;
|
|
296
|
+
if (Maybe.isMaybe(parameters.datatype)) {
|
|
297
|
+
datatype = parameters.datatype;
|
|
298
|
+
}
|
|
299
|
+
else if (typeof parameters.datatype === "object") {
|
|
300
|
+
datatype = Maybe.of(parameters.datatype);
|
|
301
|
+
}
|
|
302
|
+
else if (typeof parameters.datatype === "string") {
|
|
303
|
+
datatype = Maybe.of(dataFactory.namedNode(parameters.datatype));
|
|
304
|
+
}
|
|
305
|
+
else if (parameters.datatype === undefined) {
|
|
306
|
+
datatype = Maybe.empty();
|
|
307
|
+
}
|
|
308
|
+
else {
|
|
309
|
+
datatype = parameters.datatype;
|
|
310
|
+
}
|
|
311
|
+
let deactivated;
|
|
312
|
+
if (Maybe.isMaybe(parameters.deactivated)) {
|
|
313
|
+
deactivated = parameters.deactivated;
|
|
314
|
+
}
|
|
315
|
+
else if (typeof parameters.deactivated === "boolean") {
|
|
316
|
+
deactivated = Maybe.of(parameters.deactivated);
|
|
317
|
+
}
|
|
318
|
+
else if (parameters.deactivated === undefined) {
|
|
319
|
+
deactivated = Maybe.empty();
|
|
320
|
+
}
|
|
321
|
+
else {
|
|
322
|
+
deactivated = parameters.deactivated;
|
|
323
|
+
}
|
|
324
|
+
let defaultValue;
|
|
325
|
+
if (Maybe.isMaybe(parameters.defaultValue)) {
|
|
326
|
+
defaultValue = parameters.defaultValue;
|
|
327
|
+
}
|
|
328
|
+
else if (typeof parameters.defaultValue === "bigint") {
|
|
329
|
+
defaultValue = Maybe.of($literalFactory.bigint(parameters.defaultValue));
|
|
330
|
+
}
|
|
331
|
+
else if (typeof parameters.defaultValue === "boolean") {
|
|
332
|
+
defaultValue = Maybe.of($literalFactory.boolean(parameters.defaultValue));
|
|
333
|
+
}
|
|
334
|
+
else if (typeof parameters.defaultValue === "object" &&
|
|
335
|
+
parameters.defaultValue instanceof Date) {
|
|
336
|
+
defaultValue = Maybe.of($literalFactory.date(parameters.defaultValue));
|
|
337
|
+
}
|
|
338
|
+
else if (typeof parameters.defaultValue === "number") {
|
|
339
|
+
defaultValue = Maybe.of($literalFactory.number(parameters.defaultValue));
|
|
340
|
+
}
|
|
341
|
+
else if (typeof parameters.defaultValue === "string") {
|
|
342
|
+
defaultValue = Maybe.of($literalFactory.string(parameters.defaultValue));
|
|
343
|
+
}
|
|
344
|
+
else if (typeof parameters.defaultValue === "object") {
|
|
345
|
+
defaultValue = Maybe.of(parameters.defaultValue);
|
|
346
|
+
}
|
|
347
|
+
else if (parameters.defaultValue === undefined) {
|
|
348
|
+
defaultValue = Maybe.empty();
|
|
349
|
+
}
|
|
350
|
+
else {
|
|
351
|
+
defaultValue = parameters.defaultValue;
|
|
352
|
+
}
|
|
353
|
+
let description;
|
|
354
|
+
if (Maybe.isMaybe(parameters.description)) {
|
|
355
|
+
description = parameters.description;
|
|
356
|
+
}
|
|
357
|
+
else if (typeof parameters.description === "string") {
|
|
358
|
+
description = Maybe.of(parameters.description);
|
|
359
|
+
}
|
|
360
|
+
else if (parameters.description === undefined) {
|
|
361
|
+
description = Maybe.empty();
|
|
362
|
+
}
|
|
363
|
+
else {
|
|
364
|
+
description = parameters.description;
|
|
365
|
+
}
|
|
366
|
+
let flags;
|
|
367
|
+
if (parameters.flags === undefined) {
|
|
368
|
+
flags = [];
|
|
369
|
+
}
|
|
370
|
+
else if (typeof parameters.flags === "object") {
|
|
371
|
+
flags = parameters.flags;
|
|
372
|
+
}
|
|
373
|
+
else {
|
|
374
|
+
flags = parameters.flags;
|
|
375
|
+
}
|
|
376
|
+
let groups;
|
|
377
|
+
if (parameters.groups === undefined) {
|
|
378
|
+
groups = [];
|
|
379
|
+
}
|
|
380
|
+
else if ($isReadonlyObjectArray(parameters.groups)) {
|
|
381
|
+
groups = parameters.groups;
|
|
382
|
+
}
|
|
383
|
+
else if ($isReadonlyStringArray(parameters.groups)) {
|
|
384
|
+
groups = parameters.groups.map((item) => dataFactory.namedNode(item));
|
|
385
|
+
}
|
|
386
|
+
else {
|
|
387
|
+
groups = parameters.groups;
|
|
388
|
+
}
|
|
389
|
+
let hasValues;
|
|
390
|
+
if (parameters.hasValues === undefined) {
|
|
391
|
+
hasValues = [];
|
|
392
|
+
}
|
|
393
|
+
else if ($isReadonlyObjectArray(parameters.hasValues)) {
|
|
394
|
+
hasValues = parameters.hasValues;
|
|
395
|
+
}
|
|
396
|
+
else if ($isReadonlyBigIntArray(parameters.hasValues)) {
|
|
397
|
+
hasValues = parameters.hasValues.map((item) => $literalFactory.bigint(item));
|
|
398
|
+
}
|
|
399
|
+
else if ($isReadonlyBooleanArray(parameters.hasValues)) {
|
|
400
|
+
hasValues = parameters.hasValues.map((item) => $literalFactory.boolean(item));
|
|
401
|
+
}
|
|
402
|
+
else if ($isReadonlyNumberArray(parameters.hasValues)) {
|
|
403
|
+
hasValues = parameters.hasValues.map((item) => $literalFactory.number(item));
|
|
404
|
+
}
|
|
405
|
+
else if ($isReadonlyStringArray(parameters.hasValues)) {
|
|
406
|
+
hasValues = parameters.hasValues.map((item) => $literalFactory.string(item));
|
|
407
|
+
}
|
|
408
|
+
else {
|
|
409
|
+
hasValues = parameters.hasValues;
|
|
410
|
+
}
|
|
411
|
+
let in_;
|
|
412
|
+
if (Maybe.isMaybe(parameters.in_)) {
|
|
413
|
+
in_ = parameters.in_;
|
|
414
|
+
}
|
|
415
|
+
else if ($isReadonlyObjectArray(parameters.in_)) {
|
|
416
|
+
in_ = Maybe.of(parameters.in_);
|
|
417
|
+
}
|
|
418
|
+
else if ($isReadonlyBigIntArray(parameters.in_)) {
|
|
419
|
+
in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.bigint(item)));
|
|
420
|
+
}
|
|
421
|
+
else if ($isReadonlyBooleanArray(parameters.in_)) {
|
|
422
|
+
in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.boolean(item)));
|
|
423
|
+
}
|
|
424
|
+
else if ($isReadonlyNumberArray(parameters.in_)) {
|
|
425
|
+
in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.number(item)));
|
|
426
|
+
}
|
|
427
|
+
else if ($isReadonlyStringArray(parameters.in_)) {
|
|
428
|
+
in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.string(item)));
|
|
429
|
+
}
|
|
430
|
+
else if (parameters.in_ === undefined) {
|
|
431
|
+
in_ = Maybe.empty();
|
|
432
|
+
}
|
|
433
|
+
else {
|
|
434
|
+
in_ = parameters.in_;
|
|
435
|
+
}
|
|
436
|
+
let isDefinedBy;
|
|
437
|
+
if (Maybe.isMaybe(parameters.isDefinedBy)) {
|
|
438
|
+
isDefinedBy = parameters.isDefinedBy;
|
|
439
|
+
}
|
|
440
|
+
else if (typeof parameters.isDefinedBy === "object") {
|
|
441
|
+
isDefinedBy = Maybe.of(parameters.isDefinedBy);
|
|
442
|
+
}
|
|
443
|
+
else if (typeof parameters.isDefinedBy === "string") {
|
|
444
|
+
isDefinedBy = Maybe.of(dataFactory.namedNode(parameters.isDefinedBy));
|
|
445
|
+
}
|
|
446
|
+
else if (parameters.isDefinedBy === undefined) {
|
|
447
|
+
isDefinedBy = Maybe.empty();
|
|
448
|
+
}
|
|
449
|
+
else {
|
|
450
|
+
isDefinedBy = parameters.isDefinedBy;
|
|
451
|
+
}
|
|
452
|
+
let label;
|
|
453
|
+
if (Maybe.isMaybe(parameters.label)) {
|
|
454
|
+
label = parameters.label;
|
|
455
|
+
}
|
|
456
|
+
else if (typeof parameters.label === "string") {
|
|
457
|
+
label = Maybe.of(parameters.label);
|
|
458
|
+
}
|
|
459
|
+
else if (parameters.label === undefined) {
|
|
460
|
+
label = Maybe.empty();
|
|
461
|
+
}
|
|
462
|
+
else {
|
|
463
|
+
label = parameters.label;
|
|
464
|
+
}
|
|
465
|
+
let languageIn;
|
|
466
|
+
if (Maybe.isMaybe(parameters.languageIn)) {
|
|
467
|
+
languageIn = parameters.languageIn;
|
|
468
|
+
}
|
|
469
|
+
else if (typeof parameters.languageIn === "object") {
|
|
470
|
+
languageIn = Maybe.of(parameters.languageIn);
|
|
471
|
+
}
|
|
472
|
+
else if (parameters.languageIn === undefined) {
|
|
473
|
+
languageIn = Maybe.empty();
|
|
474
|
+
}
|
|
475
|
+
else {
|
|
476
|
+
languageIn = parameters.languageIn;
|
|
477
|
+
}
|
|
478
|
+
let maxCount;
|
|
479
|
+
if (Maybe.isMaybe(parameters.maxCount)) {
|
|
480
|
+
maxCount = parameters.maxCount;
|
|
481
|
+
}
|
|
482
|
+
else if (typeof parameters.maxCount === "number") {
|
|
483
|
+
maxCount = Maybe.of(parameters.maxCount);
|
|
484
|
+
}
|
|
485
|
+
else if (parameters.maxCount === undefined) {
|
|
486
|
+
maxCount = Maybe.empty();
|
|
487
|
+
}
|
|
488
|
+
else {
|
|
489
|
+
maxCount = parameters.maxCount;
|
|
490
|
+
}
|
|
491
|
+
let maxExclusive;
|
|
492
|
+
if (Maybe.isMaybe(parameters.maxExclusive)) {
|
|
493
|
+
maxExclusive = parameters.maxExclusive;
|
|
494
|
+
}
|
|
495
|
+
else if (typeof parameters.maxExclusive === "bigint") {
|
|
496
|
+
maxExclusive = Maybe.of($literalFactory.bigint(parameters.maxExclusive));
|
|
497
|
+
}
|
|
498
|
+
else if (typeof parameters.maxExclusive === "boolean") {
|
|
499
|
+
maxExclusive = Maybe.of($literalFactory.boolean(parameters.maxExclusive));
|
|
500
|
+
}
|
|
501
|
+
else if (typeof parameters.maxExclusive === "object" &&
|
|
502
|
+
parameters.maxExclusive instanceof Date) {
|
|
503
|
+
maxExclusive = Maybe.of($literalFactory.date(parameters.maxExclusive));
|
|
504
|
+
}
|
|
505
|
+
else if (typeof parameters.maxExclusive === "number") {
|
|
506
|
+
maxExclusive = Maybe.of($literalFactory.number(parameters.maxExclusive));
|
|
507
|
+
}
|
|
508
|
+
else if (typeof parameters.maxExclusive === "string") {
|
|
509
|
+
maxExclusive = Maybe.of($literalFactory.string(parameters.maxExclusive));
|
|
510
|
+
}
|
|
511
|
+
else if (typeof parameters.maxExclusive === "object") {
|
|
512
|
+
maxExclusive = Maybe.of(parameters.maxExclusive);
|
|
513
|
+
}
|
|
514
|
+
else if (parameters.maxExclusive === undefined) {
|
|
515
|
+
maxExclusive = Maybe.empty();
|
|
516
|
+
}
|
|
517
|
+
else {
|
|
518
|
+
maxExclusive = parameters.maxExclusive;
|
|
519
|
+
}
|
|
520
|
+
let maxInclusive;
|
|
521
|
+
if (Maybe.isMaybe(parameters.maxInclusive)) {
|
|
522
|
+
maxInclusive = parameters.maxInclusive;
|
|
523
|
+
}
|
|
524
|
+
else if (typeof parameters.maxInclusive === "bigint") {
|
|
525
|
+
maxInclusive = Maybe.of($literalFactory.bigint(parameters.maxInclusive));
|
|
526
|
+
}
|
|
527
|
+
else if (typeof parameters.maxInclusive === "boolean") {
|
|
528
|
+
maxInclusive = Maybe.of($literalFactory.boolean(parameters.maxInclusive));
|
|
529
|
+
}
|
|
530
|
+
else if (typeof parameters.maxInclusive === "object" &&
|
|
531
|
+
parameters.maxInclusive instanceof Date) {
|
|
532
|
+
maxInclusive = Maybe.of($literalFactory.date(parameters.maxInclusive));
|
|
533
|
+
}
|
|
534
|
+
else if (typeof parameters.maxInclusive === "number") {
|
|
535
|
+
maxInclusive = Maybe.of($literalFactory.number(parameters.maxInclusive));
|
|
536
|
+
}
|
|
537
|
+
else if (typeof parameters.maxInclusive === "string") {
|
|
538
|
+
maxInclusive = Maybe.of($literalFactory.string(parameters.maxInclusive));
|
|
539
|
+
}
|
|
540
|
+
else if (typeof parameters.maxInclusive === "object") {
|
|
541
|
+
maxInclusive = Maybe.of(parameters.maxInclusive);
|
|
542
|
+
}
|
|
543
|
+
else if (parameters.maxInclusive === undefined) {
|
|
544
|
+
maxInclusive = Maybe.empty();
|
|
545
|
+
}
|
|
546
|
+
else {
|
|
547
|
+
maxInclusive = parameters.maxInclusive;
|
|
548
|
+
}
|
|
549
|
+
let maxLength;
|
|
550
|
+
if (Maybe.isMaybe(parameters.maxLength)) {
|
|
551
|
+
maxLength = parameters.maxLength;
|
|
552
|
+
}
|
|
553
|
+
else if (typeof parameters.maxLength === "number") {
|
|
554
|
+
maxLength = Maybe.of(parameters.maxLength);
|
|
555
|
+
}
|
|
556
|
+
else if (parameters.maxLength === undefined) {
|
|
557
|
+
maxLength = Maybe.empty();
|
|
558
|
+
}
|
|
559
|
+
else {
|
|
560
|
+
maxLength = parameters.maxLength;
|
|
561
|
+
}
|
|
562
|
+
let minCount;
|
|
563
|
+
if (Maybe.isMaybe(parameters.minCount)) {
|
|
564
|
+
minCount = parameters.minCount;
|
|
565
|
+
}
|
|
566
|
+
else if (typeof parameters.minCount === "number") {
|
|
567
|
+
minCount = Maybe.of(parameters.minCount);
|
|
568
|
+
}
|
|
569
|
+
else if (parameters.minCount === undefined) {
|
|
570
|
+
minCount = Maybe.empty();
|
|
571
|
+
}
|
|
572
|
+
else {
|
|
573
|
+
minCount = parameters.minCount;
|
|
574
|
+
}
|
|
575
|
+
let minExclusive;
|
|
576
|
+
if (Maybe.isMaybe(parameters.minExclusive)) {
|
|
577
|
+
minExclusive = parameters.minExclusive;
|
|
578
|
+
}
|
|
579
|
+
else if (typeof parameters.minExclusive === "bigint") {
|
|
580
|
+
minExclusive = Maybe.of($literalFactory.bigint(parameters.minExclusive));
|
|
581
|
+
}
|
|
582
|
+
else if (typeof parameters.minExclusive === "boolean") {
|
|
583
|
+
minExclusive = Maybe.of($literalFactory.boolean(parameters.minExclusive));
|
|
584
|
+
}
|
|
585
|
+
else if (typeof parameters.minExclusive === "object" &&
|
|
586
|
+
parameters.minExclusive instanceof Date) {
|
|
587
|
+
minExclusive = Maybe.of($literalFactory.date(parameters.minExclusive));
|
|
588
|
+
}
|
|
589
|
+
else if (typeof parameters.minExclusive === "number") {
|
|
590
|
+
minExclusive = Maybe.of($literalFactory.number(parameters.minExclusive));
|
|
591
|
+
}
|
|
592
|
+
else if (typeof parameters.minExclusive === "string") {
|
|
593
|
+
minExclusive = Maybe.of($literalFactory.string(parameters.minExclusive));
|
|
594
|
+
}
|
|
595
|
+
else if (typeof parameters.minExclusive === "object") {
|
|
596
|
+
minExclusive = Maybe.of(parameters.minExclusive);
|
|
597
|
+
}
|
|
598
|
+
else if (parameters.minExclusive === undefined) {
|
|
599
|
+
minExclusive = Maybe.empty();
|
|
600
|
+
}
|
|
601
|
+
else {
|
|
602
|
+
minExclusive = parameters.minExclusive;
|
|
603
|
+
}
|
|
604
|
+
let minInclusive;
|
|
605
|
+
if (Maybe.isMaybe(parameters.minInclusive)) {
|
|
606
|
+
minInclusive = parameters.minInclusive;
|
|
607
|
+
}
|
|
608
|
+
else if (typeof parameters.minInclusive === "bigint") {
|
|
609
|
+
minInclusive = Maybe.of($literalFactory.bigint(parameters.minInclusive));
|
|
610
|
+
}
|
|
611
|
+
else if (typeof parameters.minInclusive === "boolean") {
|
|
612
|
+
minInclusive = Maybe.of($literalFactory.boolean(parameters.minInclusive));
|
|
613
|
+
}
|
|
614
|
+
else if (typeof parameters.minInclusive === "object" &&
|
|
615
|
+
parameters.minInclusive instanceof Date) {
|
|
616
|
+
minInclusive = Maybe.of($literalFactory.date(parameters.minInclusive));
|
|
617
|
+
}
|
|
618
|
+
else if (typeof parameters.minInclusive === "number") {
|
|
619
|
+
minInclusive = Maybe.of($literalFactory.number(parameters.minInclusive));
|
|
620
|
+
}
|
|
621
|
+
else if (typeof parameters.minInclusive === "string") {
|
|
622
|
+
minInclusive = Maybe.of($literalFactory.string(parameters.minInclusive));
|
|
623
|
+
}
|
|
624
|
+
else if (typeof parameters.minInclusive === "object") {
|
|
625
|
+
minInclusive = Maybe.of(parameters.minInclusive);
|
|
626
|
+
}
|
|
627
|
+
else if (parameters.minInclusive === undefined) {
|
|
628
|
+
minInclusive = Maybe.empty();
|
|
629
|
+
}
|
|
630
|
+
else {
|
|
631
|
+
minInclusive = parameters.minInclusive;
|
|
632
|
+
}
|
|
633
|
+
let minLength;
|
|
634
|
+
if (Maybe.isMaybe(parameters.minLength)) {
|
|
635
|
+
minLength = parameters.minLength;
|
|
636
|
+
}
|
|
637
|
+
else if (typeof parameters.minLength === "number") {
|
|
638
|
+
minLength = Maybe.of(parameters.minLength);
|
|
639
|
+
}
|
|
640
|
+
else if (parameters.minLength === undefined) {
|
|
641
|
+
minLength = Maybe.empty();
|
|
642
|
+
}
|
|
643
|
+
else {
|
|
644
|
+
minLength = parameters.minLength;
|
|
645
|
+
}
|
|
646
|
+
let name;
|
|
647
|
+
if (Maybe.isMaybe(parameters.name)) {
|
|
648
|
+
name = parameters.name;
|
|
649
|
+
}
|
|
650
|
+
else if (typeof parameters.name === "string") {
|
|
651
|
+
name = Maybe.of(parameters.name);
|
|
652
|
+
}
|
|
653
|
+
else if (parameters.name === undefined) {
|
|
654
|
+
name = Maybe.empty();
|
|
655
|
+
}
|
|
656
|
+
else {
|
|
657
|
+
name = parameters.name;
|
|
658
|
+
}
|
|
659
|
+
let nodeKind;
|
|
660
|
+
if (Maybe.isMaybe(parameters.nodeKind)) {
|
|
661
|
+
nodeKind = parameters.nodeKind;
|
|
662
|
+
}
|
|
663
|
+
else if (typeof parameters.nodeKind === "object") {
|
|
664
|
+
nodeKind = Maybe.of(parameters.nodeKind);
|
|
665
|
+
}
|
|
666
|
+
else if (typeof parameters.nodeKind === "string") {
|
|
667
|
+
nodeKind = Maybe.of(dataFactory.namedNode(parameters.nodeKind));
|
|
668
|
+
}
|
|
669
|
+
else if (parameters.nodeKind === undefined) {
|
|
670
|
+
nodeKind = Maybe.empty();
|
|
671
|
+
}
|
|
672
|
+
else {
|
|
673
|
+
nodeKind = parameters.nodeKind;
|
|
674
|
+
}
|
|
675
|
+
let nodes;
|
|
676
|
+
if (parameters.nodes === undefined) {
|
|
677
|
+
nodes = [];
|
|
678
|
+
}
|
|
679
|
+
else if ($isReadonlyObjectArray(parameters.nodes)) {
|
|
680
|
+
nodes = parameters.nodes;
|
|
681
|
+
}
|
|
682
|
+
else if ($isReadonlyStringArray(parameters.nodes)) {
|
|
683
|
+
nodes = parameters.nodes.map((item) => dataFactory.namedNode(item));
|
|
684
|
+
}
|
|
685
|
+
else {
|
|
686
|
+
nodes = parameters.nodes;
|
|
687
|
+
}
|
|
688
|
+
let not;
|
|
689
|
+
if (parameters.not === undefined) {
|
|
690
|
+
not = [];
|
|
691
|
+
}
|
|
692
|
+
else if ($isReadonlyObjectArray(parameters.not)) {
|
|
693
|
+
not = parameters.not;
|
|
694
|
+
}
|
|
695
|
+
else if ($isReadonlyStringArray(parameters.not)) {
|
|
696
|
+
not = parameters.not.map((item) => dataFactory.namedNode(item));
|
|
697
|
+
}
|
|
698
|
+
else {
|
|
699
|
+
not = parameters.not;
|
|
700
|
+
}
|
|
701
|
+
let or;
|
|
702
|
+
if (Maybe.isMaybe(parameters.or)) {
|
|
703
|
+
or = parameters.or;
|
|
704
|
+
}
|
|
705
|
+
else if ($isReadonlyObjectArray(parameters.or)) {
|
|
706
|
+
or = Maybe.of(parameters.or);
|
|
707
|
+
}
|
|
708
|
+
else if ($isReadonlyStringArray(parameters.or)) {
|
|
709
|
+
or = Maybe.of(parameters.or.map((item) => dataFactory.namedNode(item)));
|
|
710
|
+
}
|
|
711
|
+
else if (parameters.or === undefined) {
|
|
712
|
+
or = Maybe.empty();
|
|
713
|
+
}
|
|
714
|
+
else {
|
|
715
|
+
or = parameters.or;
|
|
716
|
+
}
|
|
717
|
+
let order;
|
|
718
|
+
if (Maybe.isMaybe(parameters.order)) {
|
|
719
|
+
order = parameters.order;
|
|
720
|
+
}
|
|
721
|
+
else if (typeof parameters.order === "number") {
|
|
722
|
+
order = Maybe.of(parameters.order);
|
|
723
|
+
}
|
|
724
|
+
else if (parameters.order === undefined) {
|
|
725
|
+
order = Maybe.empty();
|
|
726
|
+
}
|
|
727
|
+
else {
|
|
728
|
+
order = parameters.order;
|
|
729
|
+
}
|
|
730
|
+
const path = parameters.path;
|
|
731
|
+
let patterns;
|
|
732
|
+
if (parameters.patterns === undefined) {
|
|
733
|
+
patterns = [];
|
|
734
|
+
}
|
|
735
|
+
else if (typeof parameters.patterns === "object") {
|
|
736
|
+
patterns = parameters.patterns;
|
|
737
|
+
}
|
|
738
|
+
else {
|
|
739
|
+
patterns = parameters.patterns;
|
|
740
|
+
}
|
|
741
|
+
let uniqueLang;
|
|
742
|
+
if (Maybe.isMaybe(parameters.uniqueLang)) {
|
|
743
|
+
uniqueLang = parameters.uniqueLang;
|
|
744
|
+
}
|
|
745
|
+
else if (typeof parameters.uniqueLang === "boolean") {
|
|
746
|
+
uniqueLang = Maybe.of(parameters.uniqueLang);
|
|
747
|
+
}
|
|
748
|
+
else if (parameters.uniqueLang === undefined) {
|
|
749
|
+
uniqueLang = Maybe.empty();
|
|
750
|
+
}
|
|
751
|
+
else {
|
|
752
|
+
uniqueLang = parameters.uniqueLang;
|
|
753
|
+
}
|
|
754
|
+
let xone;
|
|
755
|
+
if (Maybe.isMaybe(parameters.xone)) {
|
|
756
|
+
xone = parameters.xone;
|
|
757
|
+
}
|
|
758
|
+
else if ($isReadonlyObjectArray(parameters.xone)) {
|
|
759
|
+
xone = Maybe.of(parameters.xone);
|
|
760
|
+
}
|
|
761
|
+
else if ($isReadonlyStringArray(parameters.xone)) {
|
|
762
|
+
xone = Maybe.of(parameters.xone.map((item) => dataFactory.namedNode(item)));
|
|
763
|
+
}
|
|
764
|
+
else if (parameters.xone === undefined) {
|
|
765
|
+
xone = Maybe.empty();
|
|
766
|
+
}
|
|
767
|
+
else {
|
|
768
|
+
xone = parameters.xone;
|
|
769
|
+
}
|
|
770
|
+
return {
|
|
771
|
+
$identifier,
|
|
772
|
+
$type,
|
|
773
|
+
and,
|
|
774
|
+
classes,
|
|
775
|
+
comment,
|
|
776
|
+
datatype,
|
|
777
|
+
deactivated,
|
|
778
|
+
defaultValue,
|
|
779
|
+
description,
|
|
780
|
+
flags,
|
|
781
|
+
groups,
|
|
782
|
+
hasValues,
|
|
783
|
+
in_,
|
|
784
|
+
isDefinedBy,
|
|
785
|
+
label,
|
|
786
|
+
languageIn,
|
|
787
|
+
maxCount,
|
|
788
|
+
maxExclusive,
|
|
789
|
+
maxInclusive,
|
|
790
|
+
maxLength,
|
|
791
|
+
minCount,
|
|
792
|
+
minExclusive,
|
|
793
|
+
minInclusive,
|
|
794
|
+
minLength,
|
|
795
|
+
name,
|
|
796
|
+
nodeKind,
|
|
797
|
+
nodes,
|
|
798
|
+
not,
|
|
799
|
+
or,
|
|
800
|
+
order,
|
|
801
|
+
path,
|
|
802
|
+
patterns,
|
|
803
|
+
uniqueLang,
|
|
804
|
+
xone,
|
|
805
|
+
};
|
|
806
|
+
}
|
|
807
|
+
PropertyShape.$create = $create;
|
|
222
808
|
let $Identifier;
|
|
223
809
|
(function ($Identifier) {
|
|
224
810
|
$Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
|
|
@@ -230,7 +816,7 @@ export var PropertyShape;
|
|
|
230
816
|
return false;
|
|
231
817
|
}
|
|
232
818
|
if (filter.and !== undefined &&
|
|
233
|
-
!$
|
|
819
|
+
!$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
|
|
234
820
|
return false;
|
|
235
821
|
}
|
|
236
822
|
if (filter.classes !== undefined &&
|
|
@@ -334,7 +920,7 @@ export var PropertyShape;
|
|
|
334
920
|
return false;
|
|
335
921
|
}
|
|
336
922
|
if (filter.or !== undefined &&
|
|
337
|
-
!$
|
|
923
|
+
!$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
|
|
338
924
|
return false;
|
|
339
925
|
}
|
|
340
926
|
if (filter.order !== undefined &&
|
|
@@ -354,7 +940,7 @@ export var PropertyShape;
|
|
|
354
940
|
return false;
|
|
355
941
|
}
|
|
356
942
|
if (filter.xone !== undefined &&
|
|
357
|
-
!$
|
|
943
|
+
!$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
|
|
358
944
|
return false;
|
|
359
945
|
}
|
|
360
946
|
return true;
|
|
@@ -425,12 +1011,13 @@ export var PropertyShape;
|
|
|
425
1011
|
values: valueList.toArray(),
|
|
426
1012
|
})).chain((values) => values.chainMap((value) => value.toIdentifier()))))
|
|
427
1013
|
.map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
|
|
428
|
-
.map((values) => values.
|
|
429
|
-
.map((
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
1014
|
+
.map((values) => values.length > 0
|
|
1015
|
+
? values.map((value) => Maybe.of(value))
|
|
1016
|
+
: Resource.Values.fromValue({
|
|
1017
|
+
focusResource: $resource,
|
|
1018
|
+
propertyPath: PropertyShape.$schema.properties.and.path,
|
|
1019
|
+
value: Maybe.empty(),
|
|
1020
|
+
})),
|
|
434
1021
|
}).chain((and) => $shaclPropertyFromRdf({
|
|
435
1022
|
graph: _$options.graph,
|
|
436
1023
|
resource: $resource,
|
|
@@ -920,16 +1507,18 @@ export var PropertyShape;
|
|
|
920
1507
|
values: valueList.toArray(),
|
|
921
1508
|
})).chain((values) => values.chainMap((value) => value.toIdentifier()))))
|
|
922
1509
|
.map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
|
|
923
|
-
.map((values) => values.
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
1510
|
+
.map((values) => values.length >
|
|
1511
|
+
0
|
|
1512
|
+
? values.map((value) => Maybe.of(value))
|
|
1513
|
+
: Resource.Values.fromValue({
|
|
1514
|
+
focusResource: $resource,
|
|
1515
|
+
propertyPath: PropertyShape
|
|
1516
|
+
.$schema
|
|
1517
|
+
.properties
|
|
1518
|
+
.or
|
|
1519
|
+
.path,
|
|
1520
|
+
value: Maybe.empty(),
|
|
1521
|
+
})),
|
|
933
1522
|
}).chain((or) => $shaclPropertyFromRdf({
|
|
934
1523
|
graph: _$options.graph,
|
|
935
1524
|
resource: $resource,
|
|
@@ -1028,16 +1617,18 @@ export var PropertyShape;
|
|
|
1028
1617
|
values: valueList.toArray(),
|
|
1029
1618
|
})).chain((values) => values.chainMap((value) => value.toIdentifier()))))
|
|
1030
1619
|
.map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
|
|
1031
|
-
.map((values) => values.
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1620
|
+
.map((values) => values.length >
|
|
1621
|
+
0
|
|
1622
|
+
? values.map((value) => Maybe.of(value))
|
|
1623
|
+
: Resource.Values.fromValue({
|
|
1624
|
+
focusResource: $resource,
|
|
1625
|
+
propertyPath: PropertyShape
|
|
1626
|
+
.$schema
|
|
1627
|
+
.properties
|
|
1628
|
+
.xone
|
|
1629
|
+
.path,
|
|
1630
|
+
value: Maybe.empty(),
|
|
1631
|
+
})),
|
|
1041
1632
|
}).map((xone) => ({
|
|
1042
1633
|
$identifier,
|
|
1043
1634
|
$type,
|
|
@@ -1091,7 +1682,7 @@ export var PropertyShape;
|
|
|
1091
1682
|
and: {
|
|
1092
1683
|
kind: "Shacl",
|
|
1093
1684
|
type: () => ({
|
|
1094
|
-
kind: "
|
|
1685
|
+
kind: "Maybe",
|
|
1095
1686
|
item: () => ({
|
|
1096
1687
|
kind: "List",
|
|
1097
1688
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -1318,7 +1909,7 @@ export var PropertyShape;
|
|
|
1318
1909
|
or: {
|
|
1319
1910
|
kind: "Shacl",
|
|
1320
1911
|
type: () => ({
|
|
1321
|
-
kind: "
|
|
1912
|
+
kind: "Maybe",
|
|
1322
1913
|
item: () => ({
|
|
1323
1914
|
kind: "List",
|
|
1324
1915
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -1358,7 +1949,7 @@ export var PropertyShape;
|
|
|
1358
1949
|
xone: {
|
|
1359
1950
|
kind: "Shacl",
|
|
1360
1951
|
type: () => ({
|
|
1361
|
-
kind: "
|
|
1952
|
+
kind: "Maybe",
|
|
1362
1953
|
item: () => ({
|
|
1363
1954
|
kind: "List",
|
|
1364
1955
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -1375,9 +1966,9 @@ export var PropertyShape;
|
|
|
1375
1966
|
if (!options?.ignoreRdfType) {
|
|
1376
1967
|
resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), options?.graph);
|
|
1377
1968
|
}
|
|
1378
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _propertyShape.and.flatMap((
|
|
1379
|
-
|
|
1380
|
-
?
|
|
1969
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _propertyShape.and.toList().flatMap((value) => [
|
|
1970
|
+
value.length > 0
|
|
1971
|
+
? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
|
|
1381
1972
|
if (itemIndex === 0) {
|
|
1382
1973
|
currentSubListResource = listResource;
|
|
1383
1974
|
}
|
|
@@ -1492,9 +2083,9 @@ export var PropertyShape;
|
|
|
1492
2083
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _propertyShape.nodeKind.toList(), options?.graph);
|
|
1493
2084
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _propertyShape.nodes.flatMap((item) => [item]), options?.graph);
|
|
1494
2085
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _propertyShape.not.flatMap((item) => [item]), options?.graph);
|
|
1495
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _propertyShape.or.flatMap((
|
|
1496
|
-
|
|
1497
|
-
?
|
|
2086
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _propertyShape.or.toList().flatMap((value) => [
|
|
2087
|
+
value.length > 0
|
|
2088
|
+
? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
|
|
1498
2089
|
if (itemIndex === 0) {
|
|
1499
2090
|
currentSubListResource = listResource;
|
|
1500
2091
|
}
|
|
@@ -1531,9 +2122,9 @@ export var PropertyShape;
|
|
|
1531
2122
|
.flatMap((value) => [
|
|
1532
2123
|
$literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
|
|
1533
2124
|
]), options?.graph);
|
|
1534
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _propertyShape.xone.flatMap((
|
|
1535
|
-
|
|
1536
|
-
?
|
|
2125
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _propertyShape.xone.toList().flatMap((value) => [
|
|
2126
|
+
value.length > 0
|
|
2127
|
+
? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
|
|
1537
2128
|
if (itemIndex === 0) {
|
|
1538
2129
|
currentSubListResource = listResource;
|
|
1539
2130
|
}
|
|
@@ -1559,6 +2150,50 @@ export var PropertyShape;
|
|
|
1559
2150
|
})(PropertyShape || (PropertyShape = {}));
|
|
1560
2151
|
export var PropertyGroup;
|
|
1561
2152
|
(function (PropertyGroup) {
|
|
2153
|
+
function $create(parameters) {
|
|
2154
|
+
let $identifier;
|
|
2155
|
+
if (typeof parameters?.$identifier === "object") {
|
|
2156
|
+
$identifier = parameters?.$identifier;
|
|
2157
|
+
}
|
|
2158
|
+
else if (typeof parameters?.$identifier === "string") {
|
|
2159
|
+
$identifier = dataFactory.namedNode(parameters?.$identifier);
|
|
2160
|
+
}
|
|
2161
|
+
else if (parameters?.$identifier === undefined) {
|
|
2162
|
+
$identifier = dataFactory.blankNode();
|
|
2163
|
+
}
|
|
2164
|
+
else {
|
|
2165
|
+
$identifier = parameters?.$identifier;
|
|
2166
|
+
}
|
|
2167
|
+
const $type = "PropertyGroup";
|
|
2168
|
+
let comment;
|
|
2169
|
+
if (Maybe.isMaybe(parameters?.comment)) {
|
|
2170
|
+
comment = parameters?.comment;
|
|
2171
|
+
}
|
|
2172
|
+
else if (typeof parameters?.comment === "string") {
|
|
2173
|
+
comment = Maybe.of(parameters?.comment);
|
|
2174
|
+
}
|
|
2175
|
+
else if (parameters?.comment === undefined) {
|
|
2176
|
+
comment = Maybe.empty();
|
|
2177
|
+
}
|
|
2178
|
+
else {
|
|
2179
|
+
comment = parameters?.comment;
|
|
2180
|
+
}
|
|
2181
|
+
let label;
|
|
2182
|
+
if (Maybe.isMaybe(parameters?.label)) {
|
|
2183
|
+
label = parameters?.label;
|
|
2184
|
+
}
|
|
2185
|
+
else if (typeof parameters?.label === "string") {
|
|
2186
|
+
label = Maybe.of(parameters?.label);
|
|
2187
|
+
}
|
|
2188
|
+
else if (parameters?.label === undefined) {
|
|
2189
|
+
label = Maybe.empty();
|
|
2190
|
+
}
|
|
2191
|
+
else {
|
|
2192
|
+
label = parameters?.label;
|
|
2193
|
+
}
|
|
2194
|
+
return { $identifier, $type, comment, label };
|
|
2195
|
+
}
|
|
2196
|
+
PropertyGroup.$create = $create;
|
|
1562
2197
|
let $Identifier;
|
|
1563
2198
|
(function ($Identifier) {
|
|
1564
2199
|
$Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
|
|
@@ -1713,6 +2348,50 @@ export var PropertyGroup;
|
|
|
1713
2348
|
})(PropertyGroup || (PropertyGroup = {}));
|
|
1714
2349
|
export var Ontology;
|
|
1715
2350
|
(function (Ontology) {
|
|
2351
|
+
function $create(parameters) {
|
|
2352
|
+
let $identifier;
|
|
2353
|
+
if (typeof parameters?.$identifier === "object") {
|
|
2354
|
+
$identifier = parameters?.$identifier;
|
|
2355
|
+
}
|
|
2356
|
+
else if (typeof parameters?.$identifier === "string") {
|
|
2357
|
+
$identifier = dataFactory.namedNode(parameters?.$identifier);
|
|
2358
|
+
}
|
|
2359
|
+
else if (parameters?.$identifier === undefined) {
|
|
2360
|
+
$identifier = dataFactory.blankNode();
|
|
2361
|
+
}
|
|
2362
|
+
else {
|
|
2363
|
+
$identifier = parameters?.$identifier;
|
|
2364
|
+
}
|
|
2365
|
+
const $type = "Ontology";
|
|
2366
|
+
let comment;
|
|
2367
|
+
if (Maybe.isMaybe(parameters?.comment)) {
|
|
2368
|
+
comment = parameters?.comment;
|
|
2369
|
+
}
|
|
2370
|
+
else if (typeof parameters?.comment === "string") {
|
|
2371
|
+
comment = Maybe.of(parameters?.comment);
|
|
2372
|
+
}
|
|
2373
|
+
else if (parameters?.comment === undefined) {
|
|
2374
|
+
comment = Maybe.empty();
|
|
2375
|
+
}
|
|
2376
|
+
else {
|
|
2377
|
+
comment = parameters?.comment;
|
|
2378
|
+
}
|
|
2379
|
+
let label;
|
|
2380
|
+
if (Maybe.isMaybe(parameters?.label)) {
|
|
2381
|
+
label = parameters?.label;
|
|
2382
|
+
}
|
|
2383
|
+
else if (typeof parameters?.label === "string") {
|
|
2384
|
+
label = Maybe.of(parameters?.label);
|
|
2385
|
+
}
|
|
2386
|
+
else if (parameters?.label === undefined) {
|
|
2387
|
+
label = Maybe.empty();
|
|
2388
|
+
}
|
|
2389
|
+
else {
|
|
2390
|
+
label = parameters?.label;
|
|
2391
|
+
}
|
|
2392
|
+
return { $identifier, $type, comment, label };
|
|
2393
|
+
}
|
|
2394
|
+
Ontology.$create = $create;
|
|
1716
2395
|
let $Identifier;
|
|
1717
2396
|
(function ($Identifier) {
|
|
1718
2397
|
$Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
|
|
@@ -1855,18 +2534,559 @@ export var Ontology;
|
|
|
1855
2534
|
if (!options?.ignoreRdfType) {
|
|
1856
2535
|
resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
|
|
1857
2536
|
}
|
|
1858
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _ontology.comment
|
|
1859
|
-
.toList()
|
|
1860
|
-
.flatMap((value) => [$literalFactory.string(value)]), options?.graph);
|
|
1861
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _ontology.label
|
|
1862
|
-
.toList()
|
|
1863
|
-
.flatMap((value) => [$literalFactory.string(value)]), options?.graph);
|
|
1864
|
-
return resource;
|
|
2537
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _ontology.comment
|
|
2538
|
+
.toList()
|
|
2539
|
+
.flatMap((value) => [$literalFactory.string(value)]), options?.graph);
|
|
2540
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _ontology.label
|
|
2541
|
+
.toList()
|
|
2542
|
+
.flatMap((value) => [$literalFactory.string(value)]), options?.graph);
|
|
2543
|
+
return resource;
|
|
2544
|
+
}
|
|
2545
|
+
Ontology.$toRdfResource = $toRdfResource;
|
|
2546
|
+
})(Ontology || (Ontology = {}));
|
|
2547
|
+
export var NodeShape;
|
|
2548
|
+
(function (NodeShape) {
|
|
2549
|
+
function $create(parameters) {
|
|
2550
|
+
let $identifier;
|
|
2551
|
+
if (typeof parameters?.$identifier === "object") {
|
|
2552
|
+
$identifier = parameters?.$identifier;
|
|
2553
|
+
}
|
|
2554
|
+
else if (typeof parameters?.$identifier === "string") {
|
|
2555
|
+
$identifier = dataFactory.namedNode(parameters?.$identifier);
|
|
2556
|
+
}
|
|
2557
|
+
else if (parameters?.$identifier === undefined) {
|
|
2558
|
+
$identifier = dataFactory.blankNode();
|
|
2559
|
+
}
|
|
2560
|
+
else {
|
|
2561
|
+
$identifier = parameters?.$identifier;
|
|
2562
|
+
}
|
|
2563
|
+
const $type = "NodeShape";
|
|
2564
|
+
let and;
|
|
2565
|
+
if (Maybe.isMaybe(parameters?.and)) {
|
|
2566
|
+
and = parameters?.and;
|
|
2567
|
+
}
|
|
2568
|
+
else if ($isReadonlyObjectArray(parameters?.and)) {
|
|
2569
|
+
and = Maybe.of(parameters?.and);
|
|
2570
|
+
}
|
|
2571
|
+
else if ($isReadonlyStringArray(parameters?.and)) {
|
|
2572
|
+
and = Maybe.of(parameters?.and.map((item) => dataFactory.namedNode(item)));
|
|
2573
|
+
}
|
|
2574
|
+
else if (parameters?.and === undefined) {
|
|
2575
|
+
and = Maybe.empty();
|
|
2576
|
+
}
|
|
2577
|
+
else {
|
|
2578
|
+
and = parameters?.and;
|
|
2579
|
+
}
|
|
2580
|
+
let classes;
|
|
2581
|
+
if (parameters?.classes === undefined) {
|
|
2582
|
+
classes = [];
|
|
2583
|
+
}
|
|
2584
|
+
else if ($isReadonlyObjectArray(parameters?.classes)) {
|
|
2585
|
+
classes = parameters?.classes;
|
|
2586
|
+
}
|
|
2587
|
+
else if ($isReadonlyStringArray(parameters?.classes)) {
|
|
2588
|
+
classes = parameters?.classes.map((item) => dataFactory.namedNode(item));
|
|
2589
|
+
}
|
|
2590
|
+
else {
|
|
2591
|
+
classes = parameters?.classes;
|
|
2592
|
+
}
|
|
2593
|
+
let closed;
|
|
2594
|
+
if (Maybe.isMaybe(parameters?.closed)) {
|
|
2595
|
+
closed = parameters?.closed;
|
|
2596
|
+
}
|
|
2597
|
+
else if (typeof parameters?.closed === "boolean") {
|
|
2598
|
+
closed = Maybe.of(parameters?.closed);
|
|
2599
|
+
}
|
|
2600
|
+
else if (parameters?.closed === undefined) {
|
|
2601
|
+
closed = Maybe.empty();
|
|
2602
|
+
}
|
|
2603
|
+
else {
|
|
2604
|
+
closed = parameters?.closed;
|
|
2605
|
+
}
|
|
2606
|
+
let comment;
|
|
2607
|
+
if (Maybe.isMaybe(parameters?.comment)) {
|
|
2608
|
+
comment = parameters?.comment;
|
|
2609
|
+
}
|
|
2610
|
+
else if (typeof parameters?.comment === "string") {
|
|
2611
|
+
comment = Maybe.of(parameters?.comment);
|
|
2612
|
+
}
|
|
2613
|
+
else if (parameters?.comment === undefined) {
|
|
2614
|
+
comment = Maybe.empty();
|
|
2615
|
+
}
|
|
2616
|
+
else {
|
|
2617
|
+
comment = parameters?.comment;
|
|
2618
|
+
}
|
|
2619
|
+
let datatype;
|
|
2620
|
+
if (Maybe.isMaybe(parameters?.datatype)) {
|
|
2621
|
+
datatype = parameters?.datatype;
|
|
2622
|
+
}
|
|
2623
|
+
else if (typeof parameters?.datatype === "object") {
|
|
2624
|
+
datatype = Maybe.of(parameters?.datatype);
|
|
2625
|
+
}
|
|
2626
|
+
else if (typeof parameters?.datatype === "string") {
|
|
2627
|
+
datatype = Maybe.of(dataFactory.namedNode(parameters?.datatype));
|
|
2628
|
+
}
|
|
2629
|
+
else if (parameters?.datatype === undefined) {
|
|
2630
|
+
datatype = Maybe.empty();
|
|
2631
|
+
}
|
|
2632
|
+
else {
|
|
2633
|
+
datatype = parameters?.datatype;
|
|
2634
|
+
}
|
|
2635
|
+
let deactivated;
|
|
2636
|
+
if (Maybe.isMaybe(parameters?.deactivated)) {
|
|
2637
|
+
deactivated = parameters?.deactivated;
|
|
2638
|
+
}
|
|
2639
|
+
else if (typeof parameters?.deactivated === "boolean") {
|
|
2640
|
+
deactivated = Maybe.of(parameters?.deactivated);
|
|
2641
|
+
}
|
|
2642
|
+
else if (parameters?.deactivated === undefined) {
|
|
2643
|
+
deactivated = Maybe.empty();
|
|
2644
|
+
}
|
|
2645
|
+
else {
|
|
2646
|
+
deactivated = parameters?.deactivated;
|
|
2647
|
+
}
|
|
2648
|
+
let flags;
|
|
2649
|
+
if (parameters?.flags === undefined) {
|
|
2650
|
+
flags = [];
|
|
2651
|
+
}
|
|
2652
|
+
else if (typeof parameters?.flags === "object") {
|
|
2653
|
+
flags = parameters?.flags;
|
|
2654
|
+
}
|
|
2655
|
+
else {
|
|
2656
|
+
flags = parameters?.flags;
|
|
2657
|
+
}
|
|
2658
|
+
let hasValues;
|
|
2659
|
+
if (parameters?.hasValues === undefined) {
|
|
2660
|
+
hasValues = [];
|
|
2661
|
+
}
|
|
2662
|
+
else if ($isReadonlyObjectArray(parameters?.hasValues)) {
|
|
2663
|
+
hasValues = parameters?.hasValues;
|
|
2664
|
+
}
|
|
2665
|
+
else if ($isReadonlyBigIntArray(parameters?.hasValues)) {
|
|
2666
|
+
hasValues = parameters?.hasValues.map((item) => $literalFactory.bigint(item));
|
|
2667
|
+
}
|
|
2668
|
+
else if ($isReadonlyBooleanArray(parameters?.hasValues)) {
|
|
2669
|
+
hasValues = parameters?.hasValues.map((item) => $literalFactory.boolean(item));
|
|
2670
|
+
}
|
|
2671
|
+
else if ($isReadonlyNumberArray(parameters?.hasValues)) {
|
|
2672
|
+
hasValues = parameters?.hasValues.map((item) => $literalFactory.number(item));
|
|
2673
|
+
}
|
|
2674
|
+
else if ($isReadonlyStringArray(parameters?.hasValues)) {
|
|
2675
|
+
hasValues = parameters?.hasValues.map((item) => $literalFactory.string(item));
|
|
2676
|
+
}
|
|
2677
|
+
else {
|
|
2678
|
+
hasValues = parameters?.hasValues;
|
|
2679
|
+
}
|
|
2680
|
+
let ignoredProperties;
|
|
2681
|
+
if (Maybe.isMaybe(parameters?.ignoredProperties)) {
|
|
2682
|
+
ignoredProperties = parameters?.ignoredProperties;
|
|
2683
|
+
}
|
|
2684
|
+
else if ($isReadonlyObjectArray(parameters?.ignoredProperties)) {
|
|
2685
|
+
ignoredProperties = Maybe.of(parameters?.ignoredProperties);
|
|
2686
|
+
}
|
|
2687
|
+
else if ($isReadonlyStringArray(parameters?.ignoredProperties)) {
|
|
2688
|
+
ignoredProperties = Maybe.of(parameters?.ignoredProperties.map((item) => dataFactory.namedNode(item)));
|
|
2689
|
+
}
|
|
2690
|
+
else if (parameters?.ignoredProperties === undefined) {
|
|
2691
|
+
ignoredProperties = Maybe.empty();
|
|
2692
|
+
}
|
|
2693
|
+
else {
|
|
2694
|
+
ignoredProperties = parameters?.ignoredProperties;
|
|
2695
|
+
}
|
|
2696
|
+
let in_;
|
|
2697
|
+
if (Maybe.isMaybe(parameters?.in_)) {
|
|
2698
|
+
in_ = parameters?.in_;
|
|
2699
|
+
}
|
|
2700
|
+
else if ($isReadonlyObjectArray(parameters?.in_)) {
|
|
2701
|
+
in_ = Maybe.of(parameters?.in_);
|
|
2702
|
+
}
|
|
2703
|
+
else if ($isReadonlyBigIntArray(parameters?.in_)) {
|
|
2704
|
+
in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.bigint(item)));
|
|
2705
|
+
}
|
|
2706
|
+
else if ($isReadonlyBooleanArray(parameters?.in_)) {
|
|
2707
|
+
in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.boolean(item)));
|
|
2708
|
+
}
|
|
2709
|
+
else if ($isReadonlyNumberArray(parameters?.in_)) {
|
|
2710
|
+
in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.number(item)));
|
|
2711
|
+
}
|
|
2712
|
+
else if ($isReadonlyStringArray(parameters?.in_)) {
|
|
2713
|
+
in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.string(item)));
|
|
2714
|
+
}
|
|
2715
|
+
else if (parameters?.in_ === undefined) {
|
|
2716
|
+
in_ = Maybe.empty();
|
|
2717
|
+
}
|
|
2718
|
+
else {
|
|
2719
|
+
in_ = parameters?.in_;
|
|
2720
|
+
}
|
|
2721
|
+
let isDefinedBy;
|
|
2722
|
+
if (Maybe.isMaybe(parameters?.isDefinedBy)) {
|
|
2723
|
+
isDefinedBy = parameters?.isDefinedBy;
|
|
2724
|
+
}
|
|
2725
|
+
else if (typeof parameters?.isDefinedBy === "object") {
|
|
2726
|
+
isDefinedBy = Maybe.of(parameters?.isDefinedBy);
|
|
2727
|
+
}
|
|
2728
|
+
else if (typeof parameters?.isDefinedBy === "string") {
|
|
2729
|
+
isDefinedBy = Maybe.of(dataFactory.namedNode(parameters?.isDefinedBy));
|
|
2730
|
+
}
|
|
2731
|
+
else if (parameters?.isDefinedBy === undefined) {
|
|
2732
|
+
isDefinedBy = Maybe.empty();
|
|
2733
|
+
}
|
|
2734
|
+
else {
|
|
2735
|
+
isDefinedBy = parameters?.isDefinedBy;
|
|
2736
|
+
}
|
|
2737
|
+
let label;
|
|
2738
|
+
if (Maybe.isMaybe(parameters?.label)) {
|
|
2739
|
+
label = parameters?.label;
|
|
2740
|
+
}
|
|
2741
|
+
else if (typeof parameters?.label === "string") {
|
|
2742
|
+
label = Maybe.of(parameters?.label);
|
|
2743
|
+
}
|
|
2744
|
+
else if (parameters?.label === undefined) {
|
|
2745
|
+
label = Maybe.empty();
|
|
2746
|
+
}
|
|
2747
|
+
else {
|
|
2748
|
+
label = parameters?.label;
|
|
2749
|
+
}
|
|
2750
|
+
let languageIn;
|
|
2751
|
+
if (Maybe.isMaybe(parameters?.languageIn)) {
|
|
2752
|
+
languageIn = parameters?.languageIn;
|
|
2753
|
+
}
|
|
2754
|
+
else if (typeof parameters?.languageIn === "object") {
|
|
2755
|
+
languageIn = Maybe.of(parameters?.languageIn);
|
|
2756
|
+
}
|
|
2757
|
+
else if (parameters?.languageIn === undefined) {
|
|
2758
|
+
languageIn = Maybe.empty();
|
|
2759
|
+
}
|
|
2760
|
+
else {
|
|
2761
|
+
languageIn = parameters?.languageIn;
|
|
2762
|
+
}
|
|
2763
|
+
let maxCount;
|
|
2764
|
+
if (Maybe.isMaybe(parameters?.maxCount)) {
|
|
2765
|
+
maxCount = parameters?.maxCount;
|
|
2766
|
+
}
|
|
2767
|
+
else if (typeof parameters?.maxCount === "number") {
|
|
2768
|
+
maxCount = Maybe.of(parameters?.maxCount);
|
|
2769
|
+
}
|
|
2770
|
+
else if (parameters?.maxCount === undefined) {
|
|
2771
|
+
maxCount = Maybe.empty();
|
|
2772
|
+
}
|
|
2773
|
+
else {
|
|
2774
|
+
maxCount = parameters?.maxCount;
|
|
2775
|
+
}
|
|
2776
|
+
let maxExclusive;
|
|
2777
|
+
if (Maybe.isMaybe(parameters?.maxExclusive)) {
|
|
2778
|
+
maxExclusive = parameters?.maxExclusive;
|
|
2779
|
+
}
|
|
2780
|
+
else if (typeof parameters?.maxExclusive === "bigint") {
|
|
2781
|
+
maxExclusive = Maybe.of($literalFactory.bigint(parameters?.maxExclusive));
|
|
2782
|
+
}
|
|
2783
|
+
else if (typeof parameters?.maxExclusive === "boolean") {
|
|
2784
|
+
maxExclusive = Maybe.of($literalFactory.boolean(parameters?.maxExclusive));
|
|
2785
|
+
}
|
|
2786
|
+
else if (typeof parameters?.maxExclusive === "object" &&
|
|
2787
|
+
parameters?.maxExclusive instanceof Date) {
|
|
2788
|
+
maxExclusive = Maybe.of($literalFactory.date(parameters?.maxExclusive));
|
|
2789
|
+
}
|
|
2790
|
+
else if (typeof parameters?.maxExclusive === "number") {
|
|
2791
|
+
maxExclusive = Maybe.of($literalFactory.number(parameters?.maxExclusive));
|
|
2792
|
+
}
|
|
2793
|
+
else if (typeof parameters?.maxExclusive === "string") {
|
|
2794
|
+
maxExclusive = Maybe.of($literalFactory.string(parameters?.maxExclusive));
|
|
2795
|
+
}
|
|
2796
|
+
else if (typeof parameters?.maxExclusive === "object") {
|
|
2797
|
+
maxExclusive = Maybe.of(parameters?.maxExclusive);
|
|
2798
|
+
}
|
|
2799
|
+
else if (parameters?.maxExclusive === undefined) {
|
|
2800
|
+
maxExclusive = Maybe.empty();
|
|
2801
|
+
}
|
|
2802
|
+
else {
|
|
2803
|
+
maxExclusive = parameters?.maxExclusive;
|
|
2804
|
+
}
|
|
2805
|
+
let maxInclusive;
|
|
2806
|
+
if (Maybe.isMaybe(parameters?.maxInclusive)) {
|
|
2807
|
+
maxInclusive = parameters?.maxInclusive;
|
|
2808
|
+
}
|
|
2809
|
+
else if (typeof parameters?.maxInclusive === "bigint") {
|
|
2810
|
+
maxInclusive = Maybe.of($literalFactory.bigint(parameters?.maxInclusive));
|
|
2811
|
+
}
|
|
2812
|
+
else if (typeof parameters?.maxInclusive === "boolean") {
|
|
2813
|
+
maxInclusive = Maybe.of($literalFactory.boolean(parameters?.maxInclusive));
|
|
2814
|
+
}
|
|
2815
|
+
else if (typeof parameters?.maxInclusive === "object" &&
|
|
2816
|
+
parameters?.maxInclusive instanceof Date) {
|
|
2817
|
+
maxInclusive = Maybe.of($literalFactory.date(parameters?.maxInclusive));
|
|
2818
|
+
}
|
|
2819
|
+
else if (typeof parameters?.maxInclusive === "number") {
|
|
2820
|
+
maxInclusive = Maybe.of($literalFactory.number(parameters?.maxInclusive));
|
|
2821
|
+
}
|
|
2822
|
+
else if (typeof parameters?.maxInclusive === "string") {
|
|
2823
|
+
maxInclusive = Maybe.of($literalFactory.string(parameters?.maxInclusive));
|
|
2824
|
+
}
|
|
2825
|
+
else if (typeof parameters?.maxInclusive === "object") {
|
|
2826
|
+
maxInclusive = Maybe.of(parameters?.maxInclusive);
|
|
2827
|
+
}
|
|
2828
|
+
else if (parameters?.maxInclusive === undefined) {
|
|
2829
|
+
maxInclusive = Maybe.empty();
|
|
2830
|
+
}
|
|
2831
|
+
else {
|
|
2832
|
+
maxInclusive = parameters?.maxInclusive;
|
|
2833
|
+
}
|
|
2834
|
+
let maxLength;
|
|
2835
|
+
if (Maybe.isMaybe(parameters?.maxLength)) {
|
|
2836
|
+
maxLength = parameters?.maxLength;
|
|
2837
|
+
}
|
|
2838
|
+
else if (typeof parameters?.maxLength === "number") {
|
|
2839
|
+
maxLength = Maybe.of(parameters?.maxLength);
|
|
2840
|
+
}
|
|
2841
|
+
else if (parameters?.maxLength === undefined) {
|
|
2842
|
+
maxLength = Maybe.empty();
|
|
2843
|
+
}
|
|
2844
|
+
else {
|
|
2845
|
+
maxLength = parameters?.maxLength;
|
|
2846
|
+
}
|
|
2847
|
+
let minCount;
|
|
2848
|
+
if (Maybe.isMaybe(parameters?.minCount)) {
|
|
2849
|
+
minCount = parameters?.minCount;
|
|
2850
|
+
}
|
|
2851
|
+
else if (typeof parameters?.minCount === "number") {
|
|
2852
|
+
minCount = Maybe.of(parameters?.minCount);
|
|
2853
|
+
}
|
|
2854
|
+
else if (parameters?.minCount === undefined) {
|
|
2855
|
+
minCount = Maybe.empty();
|
|
2856
|
+
}
|
|
2857
|
+
else {
|
|
2858
|
+
minCount = parameters?.minCount;
|
|
2859
|
+
}
|
|
2860
|
+
let minExclusive;
|
|
2861
|
+
if (Maybe.isMaybe(parameters?.minExclusive)) {
|
|
2862
|
+
minExclusive = parameters?.minExclusive;
|
|
2863
|
+
}
|
|
2864
|
+
else if (typeof parameters?.minExclusive === "bigint") {
|
|
2865
|
+
minExclusive = Maybe.of($literalFactory.bigint(parameters?.minExclusive));
|
|
2866
|
+
}
|
|
2867
|
+
else if (typeof parameters?.minExclusive === "boolean") {
|
|
2868
|
+
minExclusive = Maybe.of($literalFactory.boolean(parameters?.minExclusive));
|
|
2869
|
+
}
|
|
2870
|
+
else if (typeof parameters?.minExclusive === "object" &&
|
|
2871
|
+
parameters?.minExclusive instanceof Date) {
|
|
2872
|
+
minExclusive = Maybe.of($literalFactory.date(parameters?.minExclusive));
|
|
2873
|
+
}
|
|
2874
|
+
else if (typeof parameters?.minExclusive === "number") {
|
|
2875
|
+
minExclusive = Maybe.of($literalFactory.number(parameters?.minExclusive));
|
|
2876
|
+
}
|
|
2877
|
+
else if (typeof parameters?.minExclusive === "string") {
|
|
2878
|
+
minExclusive = Maybe.of($literalFactory.string(parameters?.minExclusive));
|
|
2879
|
+
}
|
|
2880
|
+
else if (typeof parameters?.minExclusive === "object") {
|
|
2881
|
+
minExclusive = Maybe.of(parameters?.minExclusive);
|
|
2882
|
+
}
|
|
2883
|
+
else if (parameters?.minExclusive === undefined) {
|
|
2884
|
+
minExclusive = Maybe.empty();
|
|
2885
|
+
}
|
|
2886
|
+
else {
|
|
2887
|
+
minExclusive = parameters?.minExclusive;
|
|
2888
|
+
}
|
|
2889
|
+
let minInclusive;
|
|
2890
|
+
if (Maybe.isMaybe(parameters?.minInclusive)) {
|
|
2891
|
+
minInclusive = parameters?.minInclusive;
|
|
2892
|
+
}
|
|
2893
|
+
else if (typeof parameters?.minInclusive === "bigint") {
|
|
2894
|
+
minInclusive = Maybe.of($literalFactory.bigint(parameters?.minInclusive));
|
|
2895
|
+
}
|
|
2896
|
+
else if (typeof parameters?.minInclusive === "boolean") {
|
|
2897
|
+
minInclusive = Maybe.of($literalFactory.boolean(parameters?.minInclusive));
|
|
2898
|
+
}
|
|
2899
|
+
else if (typeof parameters?.minInclusive === "object" &&
|
|
2900
|
+
parameters?.minInclusive instanceof Date) {
|
|
2901
|
+
minInclusive = Maybe.of($literalFactory.date(parameters?.minInclusive));
|
|
2902
|
+
}
|
|
2903
|
+
else if (typeof parameters?.minInclusive === "number") {
|
|
2904
|
+
minInclusive = Maybe.of($literalFactory.number(parameters?.minInclusive));
|
|
2905
|
+
}
|
|
2906
|
+
else if (typeof parameters?.minInclusive === "string") {
|
|
2907
|
+
minInclusive = Maybe.of($literalFactory.string(parameters?.minInclusive));
|
|
2908
|
+
}
|
|
2909
|
+
else if (typeof parameters?.minInclusive === "object") {
|
|
2910
|
+
minInclusive = Maybe.of(parameters?.minInclusive);
|
|
2911
|
+
}
|
|
2912
|
+
else if (parameters?.minInclusive === undefined) {
|
|
2913
|
+
minInclusive = Maybe.empty();
|
|
2914
|
+
}
|
|
2915
|
+
else {
|
|
2916
|
+
minInclusive = parameters?.minInclusive;
|
|
2917
|
+
}
|
|
2918
|
+
let minLength;
|
|
2919
|
+
if (Maybe.isMaybe(parameters?.minLength)) {
|
|
2920
|
+
minLength = parameters?.minLength;
|
|
2921
|
+
}
|
|
2922
|
+
else if (typeof parameters?.minLength === "number") {
|
|
2923
|
+
minLength = Maybe.of(parameters?.minLength);
|
|
2924
|
+
}
|
|
2925
|
+
else if (parameters?.minLength === undefined) {
|
|
2926
|
+
minLength = Maybe.empty();
|
|
2927
|
+
}
|
|
2928
|
+
else {
|
|
2929
|
+
minLength = parameters?.minLength;
|
|
2930
|
+
}
|
|
2931
|
+
let nodeKind;
|
|
2932
|
+
if (Maybe.isMaybe(parameters?.nodeKind)) {
|
|
2933
|
+
nodeKind = parameters?.nodeKind;
|
|
2934
|
+
}
|
|
2935
|
+
else if (typeof parameters?.nodeKind === "object") {
|
|
2936
|
+
nodeKind = Maybe.of(parameters?.nodeKind);
|
|
2937
|
+
}
|
|
2938
|
+
else if (typeof parameters?.nodeKind === "string") {
|
|
2939
|
+
nodeKind = Maybe.of(dataFactory.namedNode(parameters?.nodeKind));
|
|
2940
|
+
}
|
|
2941
|
+
else if (parameters?.nodeKind === undefined) {
|
|
2942
|
+
nodeKind = Maybe.empty();
|
|
2943
|
+
}
|
|
2944
|
+
else {
|
|
2945
|
+
nodeKind = parameters?.nodeKind;
|
|
2946
|
+
}
|
|
2947
|
+
let nodes;
|
|
2948
|
+
if (parameters?.nodes === undefined) {
|
|
2949
|
+
nodes = [];
|
|
2950
|
+
}
|
|
2951
|
+
else if ($isReadonlyObjectArray(parameters?.nodes)) {
|
|
2952
|
+
nodes = parameters?.nodes;
|
|
2953
|
+
}
|
|
2954
|
+
else if ($isReadonlyStringArray(parameters?.nodes)) {
|
|
2955
|
+
nodes = parameters?.nodes.map((item) => dataFactory.namedNode(item));
|
|
2956
|
+
}
|
|
2957
|
+
else {
|
|
2958
|
+
nodes = parameters?.nodes;
|
|
2959
|
+
}
|
|
2960
|
+
let not;
|
|
2961
|
+
if (parameters?.not === undefined) {
|
|
2962
|
+
not = [];
|
|
2963
|
+
}
|
|
2964
|
+
else if ($isReadonlyObjectArray(parameters?.not)) {
|
|
2965
|
+
not = parameters?.not;
|
|
2966
|
+
}
|
|
2967
|
+
else if ($isReadonlyStringArray(parameters?.not)) {
|
|
2968
|
+
not = parameters?.not.map((item) => dataFactory.namedNode(item));
|
|
2969
|
+
}
|
|
2970
|
+
else {
|
|
2971
|
+
not = parameters?.not;
|
|
2972
|
+
}
|
|
2973
|
+
let or;
|
|
2974
|
+
if (Maybe.isMaybe(parameters?.or)) {
|
|
2975
|
+
or = parameters?.or;
|
|
2976
|
+
}
|
|
2977
|
+
else if ($isReadonlyObjectArray(parameters?.or)) {
|
|
2978
|
+
or = Maybe.of(parameters?.or);
|
|
2979
|
+
}
|
|
2980
|
+
else if ($isReadonlyStringArray(parameters?.or)) {
|
|
2981
|
+
or = Maybe.of(parameters?.or.map((item) => dataFactory.namedNode(item)));
|
|
2982
|
+
}
|
|
2983
|
+
else if (parameters?.or === undefined) {
|
|
2984
|
+
or = Maybe.empty();
|
|
2985
|
+
}
|
|
2986
|
+
else {
|
|
2987
|
+
or = parameters?.or;
|
|
2988
|
+
}
|
|
2989
|
+
let patterns;
|
|
2990
|
+
if (parameters?.patterns === undefined) {
|
|
2991
|
+
patterns = [];
|
|
2992
|
+
}
|
|
2993
|
+
else if (typeof parameters?.patterns === "object") {
|
|
2994
|
+
patterns = parameters?.patterns;
|
|
2995
|
+
}
|
|
2996
|
+
else {
|
|
2997
|
+
patterns = parameters?.patterns;
|
|
2998
|
+
}
|
|
2999
|
+
let properties;
|
|
3000
|
+
if (parameters?.properties === undefined) {
|
|
3001
|
+
properties = [];
|
|
3002
|
+
}
|
|
3003
|
+
else if ($isReadonlyObjectArray(parameters?.properties)) {
|
|
3004
|
+
properties = parameters?.properties;
|
|
3005
|
+
}
|
|
3006
|
+
else if ($isReadonlyStringArray(parameters?.properties)) {
|
|
3007
|
+
properties = parameters?.properties.map((item) => dataFactory.namedNode(item));
|
|
3008
|
+
}
|
|
3009
|
+
else {
|
|
3010
|
+
properties = parameters?.properties;
|
|
3011
|
+
}
|
|
3012
|
+
let subClassOf;
|
|
3013
|
+
if (parameters?.subClassOf === undefined) {
|
|
3014
|
+
subClassOf = [];
|
|
3015
|
+
}
|
|
3016
|
+
else if ($isReadonlyObjectArray(parameters?.subClassOf)) {
|
|
3017
|
+
subClassOf = parameters?.subClassOf;
|
|
3018
|
+
}
|
|
3019
|
+
else if ($isReadonlyStringArray(parameters?.subClassOf)) {
|
|
3020
|
+
subClassOf = parameters?.subClassOf.map((item) => dataFactory.namedNode(item));
|
|
3021
|
+
}
|
|
3022
|
+
else {
|
|
3023
|
+
subClassOf = parameters?.subClassOf;
|
|
3024
|
+
}
|
|
3025
|
+
let types;
|
|
3026
|
+
if (parameters?.types === undefined) {
|
|
3027
|
+
types = [];
|
|
3028
|
+
}
|
|
3029
|
+
else if ($isReadonlyObjectArray(parameters?.types)) {
|
|
3030
|
+
types = parameters?.types;
|
|
3031
|
+
}
|
|
3032
|
+
else if ($isReadonlyStringArray(parameters?.types)) {
|
|
3033
|
+
types = parameters?.types.map((item) => dataFactory.namedNode(item));
|
|
3034
|
+
}
|
|
3035
|
+
else {
|
|
3036
|
+
types = parameters?.types;
|
|
3037
|
+
}
|
|
3038
|
+
let xone;
|
|
3039
|
+
if (Maybe.isMaybe(parameters?.xone)) {
|
|
3040
|
+
xone = parameters?.xone;
|
|
3041
|
+
}
|
|
3042
|
+
else if ($isReadonlyObjectArray(parameters?.xone)) {
|
|
3043
|
+
xone = Maybe.of(parameters?.xone);
|
|
3044
|
+
}
|
|
3045
|
+
else if ($isReadonlyStringArray(parameters?.xone)) {
|
|
3046
|
+
xone = Maybe.of(parameters?.xone.map((item) => dataFactory.namedNode(item)));
|
|
3047
|
+
}
|
|
3048
|
+
else if (parameters?.xone === undefined) {
|
|
3049
|
+
xone = Maybe.empty();
|
|
3050
|
+
}
|
|
3051
|
+
else {
|
|
3052
|
+
xone = parameters?.xone;
|
|
3053
|
+
}
|
|
3054
|
+
return {
|
|
3055
|
+
$identifier,
|
|
3056
|
+
$type,
|
|
3057
|
+
and,
|
|
3058
|
+
classes,
|
|
3059
|
+
closed,
|
|
3060
|
+
comment,
|
|
3061
|
+
datatype,
|
|
3062
|
+
deactivated,
|
|
3063
|
+
flags,
|
|
3064
|
+
hasValues,
|
|
3065
|
+
ignoredProperties,
|
|
3066
|
+
in_,
|
|
3067
|
+
isDefinedBy,
|
|
3068
|
+
label,
|
|
3069
|
+
languageIn,
|
|
3070
|
+
maxCount,
|
|
3071
|
+
maxExclusive,
|
|
3072
|
+
maxInclusive,
|
|
3073
|
+
maxLength,
|
|
3074
|
+
minCount,
|
|
3075
|
+
minExclusive,
|
|
3076
|
+
minInclusive,
|
|
3077
|
+
minLength,
|
|
3078
|
+
nodeKind,
|
|
3079
|
+
nodes,
|
|
3080
|
+
not,
|
|
3081
|
+
or,
|
|
3082
|
+
patterns,
|
|
3083
|
+
properties,
|
|
3084
|
+
subClassOf,
|
|
3085
|
+
types,
|
|
3086
|
+
xone,
|
|
3087
|
+
};
|
|
1865
3088
|
}
|
|
1866
|
-
|
|
1867
|
-
})(Ontology || (Ontology = {}));
|
|
1868
|
-
export var NodeShape;
|
|
1869
|
-
(function (NodeShape) {
|
|
3089
|
+
NodeShape.$create = $create;
|
|
1870
3090
|
let $Identifier;
|
|
1871
3091
|
(function ($Identifier) {
|
|
1872
3092
|
$Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
|
|
@@ -1878,7 +3098,7 @@ export var NodeShape;
|
|
|
1878
3098
|
return false;
|
|
1879
3099
|
}
|
|
1880
3100
|
if (filter.and !== undefined &&
|
|
1881
|
-
!$
|
|
3101
|
+
!$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
|
|
1882
3102
|
return false;
|
|
1883
3103
|
}
|
|
1884
3104
|
if (filter.classes !== undefined &&
|
|
@@ -1974,7 +3194,7 @@ export var NodeShape;
|
|
|
1974
3194
|
return false;
|
|
1975
3195
|
}
|
|
1976
3196
|
if (filter.or !== undefined &&
|
|
1977
|
-
!$
|
|
3197
|
+
!$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
|
|
1978
3198
|
return false;
|
|
1979
3199
|
}
|
|
1980
3200
|
if (filter.patterns !== undefined &&
|
|
@@ -1985,8 +3205,16 @@ export var NodeShape;
|
|
|
1985
3205
|
!$filterArray($filterIdentifier)(filter.properties, value.properties)) {
|
|
1986
3206
|
return false;
|
|
1987
3207
|
}
|
|
3208
|
+
if (filter.subClassOf !== undefined &&
|
|
3209
|
+
!$filterArray($filterIri)(filter.subClassOf, value.subClassOf)) {
|
|
3210
|
+
return false;
|
|
3211
|
+
}
|
|
3212
|
+
if (filter.types !== undefined &&
|
|
3213
|
+
!$filterArray($filterIri)(filter.types, value.types)) {
|
|
3214
|
+
return false;
|
|
3215
|
+
}
|
|
1988
3216
|
if (filter.xone !== undefined &&
|
|
1989
|
-
!$
|
|
3217
|
+
!$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
|
|
1990
3218
|
return false;
|
|
1991
3219
|
}
|
|
1992
3220
|
return true;
|
|
@@ -2057,12 +3285,13 @@ export var NodeShape;
|
|
|
2057
3285
|
values: valueList.toArray(),
|
|
2058
3286
|
})).chain((values) => values.chainMap((value) => value.toIdentifier()))))
|
|
2059
3287
|
.map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
|
|
2060
|
-
.map((values) => values.
|
|
2061
|
-
.map((
|
|
2062
|
-
|
|
2063
|
-
|
|
2064
|
-
|
|
2065
|
-
|
|
3288
|
+
.map((values) => values.length > 0
|
|
3289
|
+
? values.map((value) => Maybe.of(value))
|
|
3290
|
+
: Resource.Values.fromValue({
|
|
3291
|
+
focusResource: $resource,
|
|
3292
|
+
propertyPath: PropertyShape.$schema.properties.and.path,
|
|
3293
|
+
value: Maybe.empty(),
|
|
3294
|
+
})),
|
|
2066
3295
|
}).chain((and) => $shaclPropertyFromRdf({
|
|
2067
3296
|
graph: _$options.graph,
|
|
2068
3297
|
resource: $resource,
|
|
@@ -2500,16 +3729,18 @@ export var NodeShape;
|
|
|
2500
3729
|
values: valueList.toArray(),
|
|
2501
3730
|
})).chain((values) => values.chainMap((value) => value.toIdentifier()))))
|
|
2502
3731
|
.map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
|
|
2503
|
-
.map((values) => values.
|
|
2504
|
-
|
|
2505
|
-
|
|
2506
|
-
|
|
2507
|
-
|
|
2508
|
-
|
|
2509
|
-
|
|
2510
|
-
|
|
2511
|
-
|
|
2512
|
-
|
|
3732
|
+
.map((values) => values.length >
|
|
3733
|
+
0
|
|
3734
|
+
? values.map((value) => Maybe.of(value))
|
|
3735
|
+
: Resource.Values.fromValue({
|
|
3736
|
+
focusResource: $resource,
|
|
3737
|
+
propertyPath: PropertyShape
|
|
3738
|
+
.$schema
|
|
3739
|
+
.properties
|
|
3740
|
+
.or
|
|
3741
|
+
.path,
|
|
3742
|
+
value: Maybe.empty(),
|
|
3743
|
+
})),
|
|
2513
3744
|
}).chain((or) => $shaclPropertyFromRdf({
|
|
2514
3745
|
graph: _$options.graph,
|
|
2515
3746
|
resource: $resource,
|
|
@@ -2548,6 +3779,42 @@ export var NodeShape;
|
|
|
2548
3779
|
value: valuesArray,
|
|
2549
3780
|
})),
|
|
2550
3781
|
}).chain((properties) => $shaclPropertyFromRdf({
|
|
3782
|
+
graph: _$options.graph,
|
|
3783
|
+
resource: $resource,
|
|
3784
|
+
propertySchema: NodeShape.$schema
|
|
3785
|
+
.properties
|
|
3786
|
+
.subClassOf,
|
|
3787
|
+
typeFromRdf: (resourceValues) => resourceValues
|
|
3788
|
+
.chain((values) => values.chainMap((value) => value.toIri()))
|
|
3789
|
+
.map((values) => values.toArray())
|
|
3790
|
+
.map((valuesArray) => Resource.Values.fromValue({
|
|
3791
|
+
focusResource: $resource,
|
|
3792
|
+
propertyPath: NodeShape
|
|
3793
|
+
.$schema
|
|
3794
|
+
.properties
|
|
3795
|
+
.subClassOf
|
|
3796
|
+
.path,
|
|
3797
|
+
value: valuesArray,
|
|
3798
|
+
})),
|
|
3799
|
+
}).chain((subClassOf) => $shaclPropertyFromRdf({
|
|
3800
|
+
graph: _$options.graph,
|
|
3801
|
+
resource: $resource,
|
|
3802
|
+
propertySchema: NodeShape.$schema
|
|
3803
|
+
.properties
|
|
3804
|
+
.types,
|
|
3805
|
+
typeFromRdf: (resourceValues) => resourceValues
|
|
3806
|
+
.chain((values) => values.chainMap((value) => value.toIri()))
|
|
3807
|
+
.map((values) => values.toArray())
|
|
3808
|
+
.map((valuesArray) => Resource.Values.fromValue({
|
|
3809
|
+
focusResource: $resource,
|
|
3810
|
+
propertyPath: NodeShape
|
|
3811
|
+
.$schema
|
|
3812
|
+
.properties
|
|
3813
|
+
.types
|
|
3814
|
+
.path,
|
|
3815
|
+
value: valuesArray,
|
|
3816
|
+
})),
|
|
3817
|
+
}).chain((types) => $shaclPropertyFromRdf({
|
|
2551
3818
|
graph: _$options.graph,
|
|
2552
3819
|
resource: $resource,
|
|
2553
3820
|
propertySchema: NodeShape.$schema
|
|
@@ -2567,16 +3834,18 @@ export var NodeShape;
|
|
|
2567
3834
|
values: valueList.toArray(),
|
|
2568
3835
|
})).chain((values) => values.chainMap((value) => value.toIdentifier()))))
|
|
2569
3836
|
.map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
|
|
2570
|
-
.map((values) => values.
|
|
2571
|
-
|
|
2572
|
-
|
|
2573
|
-
|
|
2574
|
-
|
|
2575
|
-
|
|
2576
|
-
|
|
2577
|
-
|
|
2578
|
-
|
|
2579
|
-
|
|
3837
|
+
.map((values) => values.length >
|
|
3838
|
+
0
|
|
3839
|
+
? values.map((value) => Maybe.of(value))
|
|
3840
|
+
: Resource.Values.fromValue({
|
|
3841
|
+
focusResource: $resource,
|
|
3842
|
+
propertyPath: PropertyShape
|
|
3843
|
+
.$schema
|
|
3844
|
+
.properties
|
|
3845
|
+
.xone
|
|
3846
|
+
.path,
|
|
3847
|
+
value: Maybe.empty(),
|
|
3848
|
+
})),
|
|
2580
3849
|
}).map((xone) => ({
|
|
2581
3850
|
$identifier,
|
|
2582
3851
|
$type,
|
|
@@ -2607,8 +3876,10 @@ export var NodeShape;
|
|
|
2607
3876
|
or,
|
|
2608
3877
|
patterns,
|
|
2609
3878
|
properties,
|
|
3879
|
+
subClassOf,
|
|
3880
|
+
types,
|
|
2610
3881
|
xone,
|
|
2611
|
-
}))))))))))))))))))))))))))))))));
|
|
3882
|
+
}))))))))))))))))))))))))))))))))));
|
|
2612
3883
|
};
|
|
2613
3884
|
NodeShape.$schema = {
|
|
2614
3885
|
properties: {
|
|
@@ -2626,7 +3897,7 @@ export var NodeShape;
|
|
|
2626
3897
|
and: {
|
|
2627
3898
|
kind: "Shacl",
|
|
2628
3899
|
type: () => ({
|
|
2629
|
-
kind: "
|
|
3900
|
+
kind: "Maybe",
|
|
2630
3901
|
item: () => ({
|
|
2631
3902
|
kind: "List",
|
|
2632
3903
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -2840,7 +4111,7 @@ export var NodeShape;
|
|
|
2840
4111
|
or: {
|
|
2841
4112
|
kind: "Shacl",
|
|
2842
4113
|
type: () => ({
|
|
2843
|
-
kind: "
|
|
4114
|
+
kind: "Maybe",
|
|
2844
4115
|
item: () => ({
|
|
2845
4116
|
kind: "List",
|
|
2846
4117
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -2864,10 +4135,26 @@ export var NodeShape;
|
|
|
2864
4135
|
}),
|
|
2865
4136
|
path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
|
|
2866
4137
|
},
|
|
2867
|
-
|
|
4138
|
+
subClassOf: {
|
|
4139
|
+
kind: "Shacl",
|
|
4140
|
+
type: () => ({
|
|
4141
|
+
kind: "Set",
|
|
4142
|
+
item: () => ({ kind: "Iri" }),
|
|
4143
|
+
}),
|
|
4144
|
+
path: $RdfVocabularies.rdfs.subClassOf,
|
|
4145
|
+
},
|
|
4146
|
+
types: {
|
|
2868
4147
|
kind: "Shacl",
|
|
2869
4148
|
type: () => ({
|
|
2870
4149
|
kind: "Set",
|
|
4150
|
+
item: () => ({ kind: "Iri" }),
|
|
4151
|
+
}),
|
|
4152
|
+
path: $RdfVocabularies.rdf.type,
|
|
4153
|
+
},
|
|
4154
|
+
xone: {
|
|
4155
|
+
kind: "Shacl",
|
|
4156
|
+
type: () => ({
|
|
4157
|
+
kind: "Maybe",
|
|
2871
4158
|
item: () => ({
|
|
2872
4159
|
kind: "List",
|
|
2873
4160
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -2884,9 +4171,9 @@ export var NodeShape;
|
|
|
2884
4171
|
if (!options?.ignoreRdfType) {
|
|
2885
4172
|
resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), options?.graph);
|
|
2886
4173
|
}
|
|
2887
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _nodeShape.and.flatMap((
|
|
2888
|
-
|
|
2889
|
-
?
|
|
4174
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _nodeShape.and.toList().flatMap((value) => [
|
|
4175
|
+
value.length > 0
|
|
4176
|
+
? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
|
|
2890
4177
|
if (itemIndex === 0) {
|
|
2891
4178
|
currentSubListResource = listResource;
|
|
2892
4179
|
}
|
|
@@ -3020,9 +4307,9 @@ export var NodeShape;
|
|
|
3020
4307
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _nodeShape.nodeKind.toList(), options?.graph);
|
|
3021
4308
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _nodeShape.nodes.flatMap((item) => [item]), options?.graph);
|
|
3022
4309
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _nodeShape.not.flatMap((item) => [item]), options?.graph);
|
|
3023
|
-
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.flatMap((
|
|
3024
|
-
|
|
3025
|
-
?
|
|
4310
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.toList().flatMap((value) => [
|
|
4311
|
+
value.length > 0
|
|
4312
|
+
? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
|
|
3026
4313
|
if (itemIndex === 0) {
|
|
3027
4314
|
currentSubListResource = listResource;
|
|
3028
4315
|
}
|
|
@@ -3044,9 +4331,11 @@ export var NodeShape;
|
|
|
3044
4331
|
]), options?.graph);
|
|
3045
4332
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), _nodeShape.patterns.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
|
|
3046
4333
|
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), _nodeShape.properties.flatMap((item) => [item]), options?.graph);
|
|
3047
|
-
resource.add(
|
|
3048
|
-
|
|
3049
|
-
|
|
4334
|
+
resource.add($RdfVocabularies.rdfs.subClassOf, _nodeShape.subClassOf.flatMap((item) => [item]), options?.graph);
|
|
4335
|
+
resource.add($RdfVocabularies.rdf.type, _nodeShape.types.flatMap((item) => [item]), options?.graph);
|
|
4336
|
+
resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _nodeShape.xone.toList().flatMap((value) => [
|
|
4337
|
+
value.length > 0
|
|
4338
|
+
? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
|
|
3050
4339
|
if (itemIndex === 0) {
|
|
3051
4340
|
currentSubListResource = listResource;
|
|
3052
4341
|
}
|
|
@@ -3138,7 +4427,7 @@ export var Shape;
|
|
|
3138
4427
|
and: {
|
|
3139
4428
|
kind: "Shacl",
|
|
3140
4429
|
type: () => ({
|
|
3141
|
-
kind: "
|
|
4430
|
+
kind: "Maybe",
|
|
3142
4431
|
item: () => ({
|
|
3143
4432
|
kind: "List",
|
|
3144
4433
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -3333,7 +4622,7 @@ export var Shape;
|
|
|
3333
4622
|
or: {
|
|
3334
4623
|
kind: "Shacl",
|
|
3335
4624
|
type: () => ({
|
|
3336
|
-
kind: "
|
|
4625
|
+
kind: "Maybe",
|
|
3337
4626
|
item: () => ({
|
|
3338
4627
|
kind: "List",
|
|
3339
4628
|
item: () => ({ kind: "Identifier" }),
|
|
@@ -3352,7 +4641,7 @@ export var Shape;
|
|
|
3352
4641
|
xone: {
|
|
3353
4642
|
kind: "Shacl",
|
|
3354
4643
|
type: () => ({
|
|
3355
|
-
kind: "
|
|
4644
|
+
kind: "Maybe",
|
|
3356
4645
|
item: () => ({
|
|
3357
4646
|
kind: "List",
|
|
3358
4647
|
item: () => ({ kind: "Identifier" }),
|