@module-federation/enhanced 0.5.2 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/dist/package.json +1 -1
  2. package/dist/src/lib/container/ModuleFederationPlugin.js +0 -9
  3. package/dist/src/lib/container/ModuleFederationPlugin.js.map +1 -1
  4. package/dist/src/lib/container/runtime/FederationRuntimePlugin.js +11 -3
  5. package/dist/src/lib/container/runtime/FederationRuntimePlugin.js.map +1 -1
  6. package/package.json +9 -9
  7. package/dist/src/schemas/container/ModuleFederationPlugin.check.js +0 -4001
  8. package/dist/src/schemas/container/ModuleFederationPlugin.check.js.map +0 -1
  9. package/dist/src/schemas/container/ModuleFederationPlugin.d.ts +0 -678
  10. package/dist/src/schemas/container/ModuleFederationPlugin.js +0 -774
  11. package/dist/src/schemas/container/ModuleFederationPlugin.js.map +0 -1
package/dist/src/schemas/container/ModuleFederationPlugin.check.js DELETED
@@ -1,4001 +0,0 @@
1
- "use strict";
2
- Object.defineProperty(exports, "__esModule", { value: true });
3
- /* eslint-disable */
4
- //@ts-nocheck
5
- /*
6
- * This file was automatically generated.
7
- * DO NOT MODIFY BY HAND.
8
- * Run `yarn special-lint-fix` to update
9
- */
10
- const absolutePathRegExp = /^(?:[A-Za-z]:[\\/]|\\\\|\/)/;
11
- ('use strict');
12
- const runtimePlugin = {
13
- type: 'array',
14
- items: {
15
- anyOf: [
16
- {
17
- type: 'string',
18
- minLength: 1,
19
- description: 'Runtime Plugin File Path.',
20
- },
21
- {
22
- type: 'object',
23
- required: ['import', 'async'],
24
- properties: {
25
- import: {
26
- type: 'string',
27
- minLength: 1,
28
- description: 'Runtime Plugin File Path.',
29
- },
30
- async: {
31
- type: 'boolean',
32
- },
33
- },
34
- additionalProperties: false,
35
- },
36
- ],
37
- },
38
- };
39
- const schema51 = {
40
- definitions: {
41
- AmdContainer: {
42
- type: 'string',
43
- minLength: 1,
44
- },
45
- AuxiliaryComment: {
46
- anyOf: [
47
- {
48
- type: 'string',
49
- },
50
- {
51
- $ref: '#/definitions/LibraryCustomUmdCommentObject',
52
- },
53
- ],
54
- },
55
- EntryRuntime: {
56
- anyOf: [
57
- {
58
- enum: [false],
59
- },
60
- {
61
- type: 'string',
62
- minLength: 1,
63
- },
64
- ],
65
- },
66
- Exposes: {
67
- anyOf: [
68
- {
69
- type: 'array',
70
- items: {
71
- anyOf: [
72
- {
73
- $ref: '#/definitions/ExposesItem',
74
- },
75
- {
76
- $ref: '#/definitions/ExposesObject',
77
- },
78
- ],
79
- },
80
- },
81
- {
82
- $ref: '#/definitions/ExposesObject',
83
- },
84
- ],
85
- },
86
- ExposesConfig: {
87
- type: 'object',
88
- additionalProperties: false,
89
- properties: {
90
- import: {
91
- anyOf: [
92
- {
93
- $ref: '#/definitions/ExposesItem',
94
- },
95
- {
96
- $ref: '#/definitions/ExposesItems',
97
- },
98
- ],
99
- },
100
- name: {
101
- type: 'string',
102
- },
103
- },
104
- required: ['import'],
105
- },
106
- ExposesItem: {
107
- type: 'string',
108
- minLength: 1,
109
- },
110
- ExposesItems: {
111
- type: 'array',
112
- items: {
113
- $ref: '#/definitions/ExposesItem',
114
- },
115
- },
116
- ExposesObject: {
117
- type: 'object',
118
- additionalProperties: {
119
- anyOf: [
120
- {
121
- $ref: '#/definitions/ExposesConfig',
122
- },
123
- {
124
- $ref: '#/definitions/ExposesItem',
125
- },
126
- {
127
- $ref: '#/definitions/ExposesItems',
128
- },
129
- ],
130
- },
131
- },
132
- ExternalsType: {
133
- enum: [
134
- 'var',
135
- 'module',
136
- 'assign',
137
- 'this',
138
- 'window',
139
- 'self',
140
- 'global',
141
- 'commonjs',
142
- 'commonjs2',
143
- 'commonjs-module',
144
- 'commonjs-static',
145
- 'amd',
146
- 'amd-require',
147
- 'umd',
148
- 'umd2',
149
- 'jsonp',
150
- 'system',
151
- 'promise',
152
- 'import',
153
- 'script',
154
- 'node-commonjs',
155
- ],
156
- },
157
- LibraryCustomUmdCommentObject: {
158
- type: 'object',
159
- additionalProperties: false,
160
- properties: {
161
- amd: {
162
- type: 'string',
163
- },
164
- commonjs: {
165
- type: 'string',
166
- },
167
- commonjs2: {
168
- type: 'string',
169
- },
170
- root: {
171
- type: 'string',
172
- },
173
- },
174
- },
175
- LibraryCustomUmdObject: {
176
- type: 'object',
177
- additionalProperties: false,
178
- properties: {
179
- amd: {
180
- type: 'string',
181
- minLength: 1,
182
- },
183
- commonjs: {
184
- type: 'string',
185
- minLength: 1,
186
- },
187
- root: {
188
- anyOf: [
189
- {
190
- type: 'array',
191
- items: {
192
- type: 'string',
193
- minLength: 1,
194
- },
195
- },
196
- {
197
- type: 'string',
198
- minLength: 1,
199
- },
200
- ],
201
- },
202
- },
203
- },
204
- LibraryExport: {
205
- anyOf: [
206
- {
207
- type: 'array',
208
- items: {
209
- type: 'string',
210
- minLength: 1,
211
- },
212
- },
213
- {
214
- type: 'string',
215
- minLength: 1,
216
- },
217
- ],
218
- },
219
- LibraryName: {
220
- anyOf: [
221
- {
222
- type: 'array',
223
- items: {
224
- type: 'string',
225
- minLength: 1,
226
- },
227
- minItems: 1,
228
- },
229
- {
230
- type: 'string',
231
- minLength: 1,
232
- },
233
- {
234
- $ref: '#/definitions/LibraryCustomUmdObject',
235
- },
236
- ],
237
- },
238
- LibraryOptions: {
239
- type: 'object',
240
- additionalProperties: false,
241
- properties: {
242
- amdContainer: {
243
- $ref: '#/definitions/AmdContainer',
244
- },
245
- auxiliaryComment: {
246
- $ref: '#/definitions/AuxiliaryComment',
247
- },
248
- export: {
249
- $ref: '#/definitions/LibraryExport',
250
- },
251
- name: {
252
- $ref: '#/definitions/LibraryName',
253
- },
254
- type: {
255
- $ref: '#/definitions/LibraryType',
256
- },
257
- umdNamedDefine: {
258
- $ref: '#/definitions/UmdNamedDefine',
259
- },
260
- },
261
- required: ['type'],
262
- },
263
- LibraryType: {
264
- anyOf: [
265
- {
266
- enum: [
267
- 'var',
268
- 'module',
269
- 'assign',
270
- 'assign-properties',
271
- 'this',
272
- 'window',
273
- 'self',
274
- 'global',
275
- 'commonjs',
276
- 'commonjs2',
277
- 'commonjs-module',
278
- 'commonjs-static',
279
- 'amd',
280
- 'amd-require',
281
- 'umd',
282
- 'umd2',
283
- 'jsonp',
284
- 'system',
285
- ],
286
- },
287
- {
288
- type: 'string',
289
- },
290
- ],
291
- },
292
- Remotes: {
293
- anyOf: [
294
- {
295
- type: 'array',
296
- items: {
297
- anyOf: [
298
- {
299
- $ref: '#/definitions/RemotesItem',
300
- },
301
- {
302
- $ref: '#/definitions/RemotesObject',
303
- },
304
- ],
305
- },
306
- },
307
- {
308
- $ref: '#/definitions/RemotesObject',
309
- },
310
- ],
311
- },
312
- RemotesConfig: {
313
- type: 'object',
314
- additionalProperties: false,
315
- properties: {
316
- external: {
317
- anyOf: [
318
- {
319
- $ref: '#/definitions/RemotesItem',
320
- },
321
- {
322
- $ref: '#/definitions/RemotesItems',
323
- },
324
- ],
325
- },
326
- shareScope: {
327
- type: 'string',
328
- minLength: 1,
329
- },
330
- },
331
- required: ['external'],
332
- },
333
- RemotesItem: {
334
- type: 'string',
335
- minLength: 1,
336
- },
337
- RemotesItems: {
338
- type: 'array',
339
- items: {
340
- $ref: '#/definitions/RemotesItem',
341
- },
342
- },
343
- RemotesObject: {
344
- type: 'object',
345
- additionalProperties: {
346
- anyOf: [
347
- {
348
- $ref: '#/definitions/RemotesConfig',
349
- },
350
- {
351
- $ref: '#/definitions/RemotesItem',
352
- },
353
- {
354
- $ref: '#/definitions/RemotesItems',
355
- },
356
- ],
357
- },
358
- },
359
- Shared: {
360
- anyOf: [
361
- {
362
- type: 'array',
363
- items: {
364
- anyOf: [
365
- {
366
- $ref: '#/definitions/SharedItem',
367
- },
368
- {
369
- $ref: '#/definitions/SharedObject',
370
- },
371
- ],
372
- },
373
- },
374
- {
375
- $ref: '#/definitions/SharedObject',
376
- },
377
- ],
378
- },
379
- SharedConfig: {
380
- type: 'object',
381
- additionalProperties: false,
382
- properties: {
383
- eager: {
384
- type: 'boolean',
385
- },
386
- import: {
387
- anyOf: [
388
- {
389
- enum: [false],
390
- },
391
- {
392
- $ref: '#/definitions/SharedItem',
393
- },
394
- ],
395
- },
396
- packageName: {
397
- type: 'string',
398
- minLength: 1,
399
- },
400
- requiredVersion: {
401
- anyOf: [
402
- {
403
- enum: [false],
404
- },
405
- {
406
- type: 'string',
407
- },
408
- ],
409
- },
410
- shareKey: {
411
- type: 'string',
412
- minLength: 1,
413
- },
414
- shareScope: {
415
- type: 'string',
416
- minLength: 1,
417
- },
418
- singleton: {
419
- type: 'boolean',
420
- },
421
- strictVersion: {
422
- type: 'boolean',
423
- },
424
- version: {
425
- anyOf: [
426
- {
427
- enum: [false],
428
- },
429
- {
430
- type: 'string',
431
- },
432
- ],
433
- },
434
- },
435
- },
436
- SharedItem: {
437
- type: 'string',
438
- minLength: 1,
439
- },
440
- SharedObject: {
441
- type: 'object',
442
- additionalProperties: {
443
- anyOf: [
444
- {
445
- $ref: '#/definitions/SharedConfig',
446
- },
447
- {
448
- $ref: '#/definitions/SharedItem',
449
- },
450
- ],
451
- },
452
- },
453
- UmdNamedDefine: {
454
- type: 'boolean',
455
- },
456
- },
457
- type: 'object',
458
- additionalProperties: false,
459
- properties: {
460
- exposes: {
461
- $ref: '#/definitions/Exposes',
462
- },
463
- filename: {
464
- type: 'string',
465
- absolutePath: false,
466
- },
467
- implementation: {
468
- type: 'string',
469
- minLength: 1,
470
- },
471
- library: {
472
- $ref: '#/definitions/LibraryOptions',
473
- },
474
- name: {
475
- type: 'string',
476
- },
477
- remoteType: {
478
- oneOf: [
479
- {
480
- $ref: '#/definitions/ExternalsType',
481
- },
482
- ],
483
- },
484
- remotes: {
485
- $ref: '#/definitions/Remotes',
486
- },
487
- runtime: {
488
- $ref: '#/definitions/EntryRuntime',
489
- },
490
- runtimePlugins: runtimePlugin,
491
- shareScope: {
492
- type: 'string',
493
- minLength: 1,
494
- },
495
- shared: {
496
- $ref: '#/definitions/Shared',
497
- },
498
- },
499
- };
500
- const schema69 = {
501
- enum: [
502
- 'var',
503
- 'module',
504
- 'assign',
505
- 'this',
506
- 'window',
507
- 'self',
508
- 'global',
509
- 'commonjs',
510
- 'commonjs2',
511
- 'commonjs-module',
512
- 'commonjs-static',
513
- 'amd',
514
- 'amd-require',
515
- 'umd',
516
- 'umd2',
517
- 'jsonp',
518
- 'system',
519
- 'promise',
520
- 'import',
521
- 'script',
522
- 'node-commonjs',
523
- ],
524
- };
525
- const schema78 = {
526
- anyOf: [
527
- {
528
- enum: [false],
529
- },
530
- {
531
- type: 'string',
532
- minLength: 1,
533
- },
534
- ],
535
- };
536
- const func2 = Object.prototype.hasOwnProperty;
537
- const schema52 = {
538
- anyOf: [
539
- {
540
- type: 'array',
541
- items: {
542
- anyOf: [
543
- {
544
- $ref: '#/definitions/ExposesItem',
545
- },
546
- {
547
- $ref: '#/definitions/ExposesObject',
548
- },
549
- ],
550
- },
551
- },
552
- {
553
- $ref: '#/definitions/ExposesObject',
554
- },
555
- ],
556
- };
557
- const schema53 = {
558
- type: 'string',
559
- minLength: 1,
560
- };
561
- const schema54 = {
562
- type: 'object',
563
- additionalProperties: {
564
- anyOf: [
565
- {
566
- $ref: '#/definitions/ExposesConfig',
567
- },
568
- {
569
- $ref: '#/definitions/ExposesItem',
570
- },
571
- {
572
- $ref: '#/definitions/ExposesItems',
573
- },
574
- ],
575
- },
576
- };
577
- const schema55 = {
578
- type: 'object',
579
- additionalProperties: false,
580
- properties: {
581
- import: {
582
- anyOf: [
583
- {
584
- $ref: '#/definitions/ExposesItem',
585
- },
586
- {
587
- $ref: '#/definitions/ExposesItems',
588
- },
589
- ],
590
- },
591
- name: {
592
- type: 'string',
593
- },
594
- },
595
- required: ['import'],
596
- };
597
- const schema57 = {
598
- type: 'array',
599
- items: {
600
- $ref: '#/definitions/ExposesItem',
601
- },
602
- };
603
- function validate52(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
604
- let vErrors = null;
605
- let errors = 0;
606
- if (errors === 0) {
607
- if (Array.isArray(data)) {
608
- var valid0 = true;
609
- const len0 = data.length;
610
- for (let i0 = 0; i0 < len0; i0++) {
611
- let data0 = data[i0];
612
- const _errs1 = errors;
613
- const _errs2 = errors;
614
- if (errors === _errs2) {
615
- if (typeof data0 === 'string') {
616
- if (data0.length < 1) {
617
- validate52.errors = [
618
- {
619
- params: {},
620
- },
621
- ];
622
- return false;
623
- }
624
- }
625
- else {
626
- validate52.errors = [
627
- {
628
- params: {
629
- type: 'string',
630
- },
631
- },
632
- ];
633
- return false;
634
- }
635
- }
636
- var valid0 = _errs1 === errors;
637
- if (!valid0) {
638
- break;
639
- }
640
- }
641
- }
642
- else {
643
- validate52.errors = [
644
- {
645
- params: {
646
- type: 'array',
647
- },
648
- },
649
- ];
650
- return false;
651
- }
652
- }
653
- validate52.errors = vErrors;
654
- return errors === 0;
655
- }
656
- function validate51(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
657
- let vErrors = null;
658
- let errors = 0;
659
- if (errors === 0) {
660
- if (data && typeof data == 'object' && !Array.isArray(data)) {
661
- let missing0;
662
- if (data.import === undefined && (missing0 = 'import')) {
663
- validate51.errors = [
664
- {
665
- params: {
666
- missingProperty: missing0,
667
- },
668
- },
669
- ];
670
- return false;
671
- }
672
- else {
673
- const _errs1 = errors;
674
- for (const key0 in data) {
675
- if (!(key0 === 'import' || key0 === 'name')) {
676
- validate51.errors = [
677
- {
678
- params: {
679
- additionalProperty: key0,
680
- },
681
- },
682
- ];
683
- return false;
684
- break;
685
- }
686
- }
687
- if (_errs1 === errors) {
688
- if (data.import !== undefined) {
689
- let data0 = data.import;
690
- const _errs2 = errors;
691
- const _errs3 = errors;
692
- let valid1 = false;
693
- const _errs4 = errors;
694
- const _errs5 = errors;
695
- if (errors === _errs5) {
696
- if (typeof data0 === 'string') {
697
- if (data0.length < 1) {
698
- const err0 = {
699
- params: {},
700
- };
701
- if (vErrors === null) {
702
- vErrors = [err0];
703
- }
704
- else {
705
- vErrors.push(err0);
706
- }
707
- errors++;
708
- }
709
- }
710
- else {
711
- const err1 = {
712
- params: {
713
- type: 'string',
714
- },
715
- };
716
- if (vErrors === null) {
717
- vErrors = [err1];
718
- }
719
- else {
720
- vErrors.push(err1);
721
- }
722
- errors++;
723
- }
724
- }
725
- var _valid0 = _errs4 === errors;
726
- valid1 = valid1 || _valid0;
727
- if (!valid1) {
728
- const _errs7 = errors;
729
- if (!validate52(data0, {
730
- instancePath: instancePath + '/import',
731
- parentData: data,
732
- parentDataProperty: 'import',
733
- rootData,
734
- })) {
735
- vErrors =
736
- vErrors === null
737
- ? validate52.errors
738
- : vErrors.concat(validate52.errors);
739
- errors = vErrors.length;
740
- }
741
- var _valid0 = _errs7 === errors;
742
- valid1 = valid1 || _valid0;
743
- }
744
- if (!valid1) {
745
- const err2 = {
746
- params: {},
747
- };
748
- if (vErrors === null) {
749
- vErrors = [err2];
750
- }
751
- else {
752
- vErrors.push(err2);
753
- }
754
- errors++;
755
- validate51.errors = vErrors;
756
- return false;
757
- }
758
- else {
759
- errors = _errs3;
760
- if (vErrors !== null) {
761
- if (_errs3) {
762
- vErrors.length = _errs3;
763
- }
764
- else {
765
- vErrors = null;
766
- }
767
- }
768
- }
769
- var valid0 = _errs2 === errors;
770
- }
771
- else {
772
- var valid0 = true;
773
- }
774
- if (valid0) {
775
- if (data.name !== undefined) {
776
- const _errs8 = errors;
777
- if (typeof data.name !== 'string') {
778
- validate51.errors = [
779
- {
780
- params: {
781
- type: 'string',
782
- },
783
- },
784
- ];
785
- return false;
786
- }
787
- var valid0 = _errs8 === errors;
788
- }
789
- else {
790
- var valid0 = true;
791
- }
792
- }
793
- }
794
- }
795
- }
796
- else {
797
- validate51.errors = [
798
- {
799
- params: {
800
- type: 'object',
801
- },
802
- },
803
- ];
804
- return false;
805
- }
806
- }
807
- validate51.errors = vErrors;
808
- return errors === 0;
809
- }
810
- function validate50(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
811
- let vErrors = null;
812
- let errors = 0;
813
- if (errors === 0) {
814
- if (data && typeof data == 'object' && !Array.isArray(data)) {
815
- for (const key0 in data) {
816
- let data0 = data[key0];
817
- const _errs2 = errors;
818
- const _errs3 = errors;
819
- let valid1 = false;
820
- const _errs4 = errors;
821
- if (!validate51(data0, {
822
- instancePath: instancePath +
823
- '/' +
824
- key0.replace(/~/g, '~0').replace(/\//g, '~1'),
825
- parentData: data,
826
- parentDataProperty: key0,
827
- rootData,
828
- })) {
829
- vErrors =
830
- vErrors === null
831
- ? validate51.errors
832
- : vErrors.concat(validate51.errors);
833
- errors = vErrors.length;
834
- }
835
- var _valid0 = _errs4 === errors;
836
- valid1 = valid1 || _valid0;
837
- if (!valid1) {
838
- const _errs5 = errors;
839
- const _errs6 = errors;
840
- if (errors === _errs6) {
841
- if (typeof data0 === 'string') {
842
- if (data0.length < 1) {
843
- const err0 = {
844
- params: {},
845
- };
846
- if (vErrors === null) {
847
- vErrors = [err0];
848
- }
849
- else {
850
- vErrors.push(err0);
851
- }
852
- errors++;
853
- }
854
- }
855
- else {
856
- const err1 = {
857
- params: {
858
- type: 'string',
859
- },
860
- };
861
- if (vErrors === null) {
862
- vErrors = [err1];
863
- }
864
- else {
865
- vErrors.push(err1);
866
- }
867
- errors++;
868
- }
869
- }
870
- var _valid0 = _errs5 === errors;
871
- valid1 = valid1 || _valid0;
872
- if (!valid1) {
873
- const _errs8 = errors;
874
- if (!validate52(data0, {
875
- instancePath: instancePath +
876
- '/' +
877
- key0.replace(/~/g, '~0').replace(/\//g, '~1'),
878
- parentData: data,
879
- parentDataProperty: key0,
880
- rootData,
881
- })) {
882
- vErrors =
883
- vErrors === null
884
- ? validate52.errors
885
- : vErrors.concat(validate52.errors);
886
- errors = vErrors.length;
887
- }
888
- var _valid0 = _errs8 === errors;
889
- valid1 = valid1 || _valid0;
890
- }
891
- }
892
- if (!valid1) {
893
- const err2 = {
894
- params: {},
895
- };
896
- if (vErrors === null) {
897
- vErrors = [err2];
898
- }
899
- else {
900
- vErrors.push(err2);
901
- }
902
- errors++;
903
- validate50.errors = vErrors;
904
- return false;
905
- }
906
- else {
907
- errors = _errs3;
908
- if (vErrors !== null) {
909
- if (_errs3) {
910
- vErrors.length = _errs3;
911
- }
912
- else {
913
- vErrors = null;
914
- }
915
- }
916
- }
917
- var valid0 = _errs2 === errors;
918
- if (!valid0) {
919
- break;
920
- }
921
- }
922
- }
923
- else {
924
- validate50.errors = [
925
- {
926
- params: {
927
- type: 'object',
928
- },
929
- },
930
- ];
931
- return false;
932
- }
933
- }
934
- validate50.errors = vErrors;
935
- return errors === 0;
936
- }
937
- function validate49(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
938
- let vErrors = null;
939
- let errors = 0;
940
- const _errs0 = errors;
941
- let valid0 = false;
942
- const _errs1 = errors;
943
- if (errors === _errs1) {
944
- if (Array.isArray(data)) {
945
- var valid1 = true;
946
- const len0 = data.length;
947
- for (let i0 = 0; i0 < len0; i0++) {
948
- let data0 = data[i0];
949
- const _errs3 = errors;
950
- const _errs4 = errors;
951
- let valid2 = false;
952
- const _errs5 = errors;
953
- const _errs6 = errors;
954
- if (errors === _errs6) {
955
- if (typeof data0 === 'string') {
956
- if (data0.length < 1) {
957
- const err0 = {
958
- params: {},
959
- };
960
- if (vErrors === null) {
961
- vErrors = [err0];
962
- }
963
- else {
964
- vErrors.push(err0);
965
- }
966
- errors++;
967
- }
968
- }
969
- else {
970
- const err1 = {
971
- params: {
972
- type: 'string',
973
- },
974
- };
975
- if (vErrors === null) {
976
- vErrors = [err1];
977
- }
978
- else {
979
- vErrors.push(err1);
980
- }
981
- errors++;
982
- }
983
- }
984
- var _valid1 = _errs5 === errors;
985
- valid2 = valid2 || _valid1;
986
- if (!valid2) {
987
- const _errs8 = errors;
988
- if (!validate50(data0, {
989
- instancePath: instancePath + '/' + i0,
990
- parentData: data,
991
- parentDataProperty: i0,
992
- rootData,
993
- })) {
994
- vErrors =
995
- vErrors === null
996
- ? validate50.errors
997
- : vErrors.concat(validate50.errors);
998
- errors = vErrors.length;
999
- }
1000
- var _valid1 = _errs8 === errors;
1001
- valid2 = valid2 || _valid1;
1002
- }
1003
- if (!valid2) {
1004
- const err2 = {
1005
- params: {},
1006
- };
1007
- if (vErrors === null) {
1008
- vErrors = [err2];
1009
- }
1010
- else {
1011
- vErrors.push(err2);
1012
- }
1013
- errors++;
1014
- }
1015
- else {
1016
- errors = _errs4;
1017
- if (vErrors !== null) {
1018
- if (_errs4) {
1019
- vErrors.length = _errs4;
1020
- }
1021
- else {
1022
- vErrors = null;
1023
- }
1024
- }
1025
- }
1026
- var valid1 = _errs3 === errors;
1027
- if (!valid1) {
1028
- break;
1029
- }
1030
- }
1031
- }
1032
- else {
1033
- const err3 = {
1034
- params: {
1035
- type: 'array',
1036
- },
1037
- };
1038
- if (vErrors === null) {
1039
- vErrors = [err3];
1040
- }
1041
- else {
1042
- vErrors.push(err3);
1043
- }
1044
- errors++;
1045
- }
1046
- }
1047
- var _valid0 = _errs1 === errors;
1048
- valid0 = valid0 || _valid0;
1049
- if (!valid0) {
1050
- const _errs9 = errors;
1051
- if (!validate50(data, {
1052
- instancePath,
1053
- parentData,
1054
- parentDataProperty,
1055
- rootData,
1056
- })) {
1057
- vErrors =
1058
- vErrors === null
1059
- ? validate50.errors
1060
- : vErrors.concat(validate50.errors);
1061
- errors = vErrors.length;
1062
- }
1063
- var _valid0 = _errs9 === errors;
1064
- valid0 = valid0 || _valid0;
1065
- }
1066
- if (!valid0) {
1067
- const err4 = {
1068
- params: {},
1069
- };
1070
- if (vErrors === null) {
1071
- vErrors = [err4];
1072
- }
1073
- else {
1074
- vErrors.push(err4);
1075
- }
1076
- errors++;
1077
- validate49.errors = vErrors;
1078
- return false;
1079
- }
1080
- else {
1081
- errors = _errs0;
1082
- if (vErrors !== null) {
1083
- if (_errs0) {
1084
- vErrors.length = _errs0;
1085
- }
1086
- else {
1087
- vErrors = null;
1088
- }
1089
- }
1090
- }
1091
- validate49.errors = vErrors;
1092
- return errors === 0;
1093
- }
1094
- const schema60 = {
1095
- type: 'object',
1096
- additionalProperties: false,
1097
- properties: {
1098
- amdContainer: {
1099
- $ref: '#/definitions/AmdContainer',
1100
- },
1101
- auxiliaryComment: {
1102
- $ref: '#/definitions/AuxiliaryComment',
1103
- },
1104
- export: {
1105
- $ref: '#/definitions/LibraryExport',
1106
- },
1107
- name: {
1108
- $ref: '#/definitions/LibraryName',
1109
- },
1110
- type: {
1111
- $ref: '#/definitions/LibraryType',
1112
- },
1113
- umdNamedDefine: {
1114
- $ref: '#/definitions/UmdNamedDefine',
1115
- },
1116
- },
1117
- required: ['type'],
1118
- };
1119
- const schema61 = {
1120
- type: 'string',
1121
- minLength: 1,
1122
- };
1123
- const schema64 = {
1124
- anyOf: [
1125
- {
1126
- type: 'array',
1127
- items: {
1128
- type: 'string',
1129
- minLength: 1,
1130
- },
1131
- },
1132
- {
1133
- type: 'string',
1134
- minLength: 1,
1135
- },
1136
- ],
1137
- };
1138
- const schema67 = {
1139
- anyOf: [
1140
- {
1141
- enum: [
1142
- 'var',
1143
- 'module',
1144
- 'assign',
1145
- 'assign-properties',
1146
- 'this',
1147
- 'window',
1148
- 'self',
1149
- 'global',
1150
- 'commonjs',
1151
- 'commonjs2',
1152
- 'commonjs-module',
1153
- 'commonjs-static',
1154
- 'amd',
1155
- 'amd-require',
1156
- 'umd',
1157
- 'umd2',
1158
- 'jsonp',
1159
- 'system',
1160
- ],
1161
- },
1162
- {
1163
- type: 'string',
1164
- },
1165
- ],
1166
- };
1167
- const schema68 = {
1168
- type: 'boolean',
1169
- };
1170
- const schema62 = {
1171
- anyOf: [
1172
- {
1173
- type: 'string',
1174
- },
1175
- {
1176
- $ref: '#/definitions/LibraryCustomUmdCommentObject',
1177
- },
1178
- ],
1179
- };
1180
- const schema63 = {
1181
- type: 'object',
1182
- additionalProperties: false,
1183
- properties: {
1184
- amd: {
1185
- type: 'string',
1186
- },
1187
- commonjs: {
1188
- type: 'string',
1189
- },
1190
- commonjs2: {
1191
- type: 'string',
1192
- },
1193
- root: {
1194
- type: 'string',
1195
- },
1196
- },
1197
- };
1198
- function validate60(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
1199
- let vErrors = null;
1200
- let errors = 0;
1201
- const _errs0 = errors;
1202
- let valid0 = false;
1203
- const _errs1 = errors;
1204
- if (typeof data !== 'string') {
1205
- const err0 = {
1206
- params: {
1207
- type: 'string',
1208
- },
1209
- };
1210
- if (vErrors === null) {
1211
- vErrors = [err0];
1212
- }
1213
- else {
1214
- vErrors.push(err0);
1215
- }
1216
- errors++;
1217
- }
1218
- var _valid0 = _errs1 === errors;
1219
- valid0 = valid0 || _valid0;
1220
- if (!valid0) {
1221
- const _errs3 = errors;
1222
- const _errs4 = errors;
1223
- if (errors === _errs4) {
1224
- if (data && typeof data == 'object' && !Array.isArray(data)) {
1225
- const _errs6 = errors;
1226
- for (const key0 in data) {
1227
- if (!(key0 === 'amd' ||
1228
- key0 === 'commonjs' ||
1229
- key0 === 'commonjs2' ||
1230
- key0 === 'root')) {
1231
- const err1 = {
1232
- params: {
1233
- additionalProperty: key0,
1234
- },
1235
- };
1236
- if (vErrors === null) {
1237
- vErrors = [err1];
1238
- }
1239
- else {
1240
- vErrors.push(err1);
1241
- }
1242
- errors++;
1243
- break;
1244
- }
1245
- }
1246
- if (_errs6 === errors) {
1247
- if (data.amd !== undefined) {
1248
- const _errs7 = errors;
1249
- if (typeof data.amd !== 'string') {
1250
- const err2 = {
1251
- params: {
1252
- type: 'string',
1253
- },
1254
- };
1255
- if (vErrors === null) {
1256
- vErrors = [err2];
1257
- }
1258
- else {
1259
- vErrors.push(err2);
1260
- }
1261
- errors++;
1262
- }
1263
- var valid2 = _errs7 === errors;
1264
- }
1265
- else {
1266
- var valid2 = true;
1267
- }
1268
- if (valid2) {
1269
- if (data.commonjs !== undefined) {
1270
- const _errs9 = errors;
1271
- if (typeof data.commonjs !== 'string') {
1272
- const err3 = {
1273
- params: {
1274
- type: 'string',
1275
- },
1276
- };
1277
- if (vErrors === null) {
1278
- vErrors = [err3];
1279
- }
1280
- else {
1281
- vErrors.push(err3);
1282
- }
1283
- errors++;
1284
- }
1285
- var valid2 = _errs9 === errors;
1286
- }
1287
- else {
1288
- var valid2 = true;
1289
- }
1290
- if (valid2) {
1291
- if (data.commonjs2 !== undefined) {
1292
- const _errs11 = errors;
1293
- if (typeof data.commonjs2 !== 'string') {
1294
- const err4 = {
1295
- params: {
1296
- type: 'string',
1297
- },
1298
- };
1299
- if (vErrors === null) {
1300
- vErrors = [err4];
1301
- }
1302
- else {
1303
- vErrors.push(err4);
1304
- }
1305
- errors++;
1306
- }
1307
- var valid2 = _errs11 === errors;
1308
- }
1309
- else {
1310
- var valid2 = true;
1311
- }
1312
- if (valid2) {
1313
- if (data.root !== undefined) {
1314
- const _errs13 = errors;
1315
- if (typeof data.root !== 'string') {
1316
- const err5 = {
1317
- params: {
1318
- type: 'string',
1319
- },
1320
- };
1321
- if (vErrors === null) {
1322
- vErrors = [err5];
1323
- }
1324
- else {
1325
- vErrors.push(err5);
1326
- }
1327
- errors++;
1328
- }
1329
- var valid2 = _errs13 === errors;
1330
- }
1331
- else {
1332
- var valid2 = true;
1333
- }
1334
- }
1335
- }
1336
- }
1337
- }
1338
- }
1339
- else {
1340
- const err6 = {
1341
- params: {
1342
- type: 'object',
1343
- },
1344
- };
1345
- if (vErrors === null) {
1346
- vErrors = [err6];
1347
- }
1348
- else {
1349
- vErrors.push(err6);
1350
- }
1351
- errors++;
1352
- }
1353
- }
1354
- var _valid0 = _errs3 === errors;
1355
- valid0 = valid0 || _valid0;
1356
- }
1357
- if (!valid0) {
1358
- const err7 = {
1359
- params: {},
1360
- };
1361
- if (vErrors === null) {
1362
- vErrors = [err7];
1363
- }
1364
- else {
1365
- vErrors.push(err7);
1366
- }
1367
- errors++;
1368
- validate60.errors = vErrors;
1369
- return false;
1370
- }
1371
- else {
1372
- errors = _errs0;
1373
- if (vErrors !== null) {
1374
- if (_errs0) {
1375
- vErrors.length = _errs0;
1376
- }
1377
- else {
1378
- vErrors = null;
1379
- }
1380
- }
1381
- }
1382
- validate60.errors = vErrors;
1383
- return errors === 0;
1384
- }
1385
- const schema65 = {
1386
- anyOf: [
1387
- {
1388
- type: 'array',
1389
- items: {
1390
- type: 'string',
1391
- minLength: 1,
1392
- },
1393
- minItems: 1,
1394
- },
1395
- {
1396
- type: 'string',
1397
- minLength: 1,
1398
- },
1399
- {
1400
- $ref: '#/definitions/LibraryCustomUmdObject',
1401
- },
1402
- ],
1403
- };
1404
- const schema66 = {
1405
- type: 'object',
1406
- additionalProperties: false,
1407
- properties: {
1408
- amd: {
1409
- type: 'string',
1410
- minLength: 1,
1411
- },
1412
- commonjs: {
1413
- type: 'string',
1414
- minLength: 1,
1415
- },
1416
- root: {
1417
- anyOf: [
1418
- {
1419
- type: 'array',
1420
- items: {
1421
- type: 'string',
1422
- minLength: 1,
1423
- },
1424
- },
1425
- {
1426
- type: 'string',
1427
- minLength: 1,
1428
- },
1429
- ],
1430
- },
1431
- },
1432
- };
1433
- function validate62(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
1434
- let vErrors = null;
1435
- let errors = 0;
1436
- const _errs0 = errors;
1437
- let valid0 = false;
1438
- const _errs1 = errors;
1439
- if (errors === _errs1) {
1440
- if (Array.isArray(data)) {
1441
- if (data.length < 1) {
1442
- const err0 = {
1443
- params: {
1444
- limit: 1,
1445
- },
1446
- };
1447
- if (vErrors === null) {
1448
- vErrors = [err0];
1449
- }
1450
- else {
1451
- vErrors.push(err0);
1452
- }
1453
- errors++;
1454
- }
1455
- else {
1456
- var valid1 = true;
1457
- const len0 = data.length;
1458
- for (let i0 = 0; i0 < len0; i0++) {
1459
- let data0 = data[i0];
1460
- const _errs3 = errors;
1461
- if (errors === _errs3) {
1462
- if (typeof data0 === 'string') {
1463
- if (data0.length < 1) {
1464
- const err1 = {
1465
- params: {},
1466
- };
1467
- if (vErrors === null) {
1468
- vErrors = [err1];
1469
- }
1470
- else {
1471
- vErrors.push(err1);
1472
- }
1473
- errors++;
1474
- }
1475
- }
1476
- else {
1477
- const err2 = {
1478
- params: {
1479
- type: 'string',
1480
- },
1481
- };
1482
- if (vErrors === null) {
1483
- vErrors = [err2];
1484
- }
1485
- else {
1486
- vErrors.push(err2);
1487
- }
1488
- errors++;
1489
- }
1490
- }
1491
- var valid1 = _errs3 === errors;
1492
- if (!valid1) {
1493
- break;
1494
- }
1495
- }
1496
- }
1497
- }
1498
- else {
1499
- const err3 = {
1500
- params: {
1501
- type: 'array',
1502
- },
1503
- };
1504
- if (vErrors === null) {
1505
- vErrors = [err3];
1506
- }
1507
- else {
1508
- vErrors.push(err3);
1509
- }
1510
- errors++;
1511
- }
1512
- }
1513
- var _valid0 = _errs1 === errors;
1514
- valid0 = valid0 || _valid0;
1515
- if (!valid0) {
1516
- const _errs5 = errors;
1517
- if (errors === _errs5) {
1518
- if (typeof data === 'string') {
1519
- if (data.length < 1) {
1520
- const err4 = {
1521
- params: {},
1522
- };
1523
- if (vErrors === null) {
1524
- vErrors = [err4];
1525
- }
1526
- else {
1527
- vErrors.push(err4);
1528
- }
1529
- errors++;
1530
- }
1531
- }
1532
- else {
1533
- const err5 = {
1534
- params: {
1535
- type: 'string',
1536
- },
1537
- };
1538
- if (vErrors === null) {
1539
- vErrors = [err5];
1540
- }
1541
- else {
1542
- vErrors.push(err5);
1543
- }
1544
- errors++;
1545
- }
1546
- }
1547
- var _valid0 = _errs5 === errors;
1548
- valid0 = valid0 || _valid0;
1549
- if (!valid0) {
1550
- const _errs7 = errors;
1551
- const _errs8 = errors;
1552
- if (errors === _errs8) {
1553
- if (data && typeof data == 'object' && !Array.isArray(data)) {
1554
- const _errs10 = errors;
1555
- for (const key0 in data) {
1556
- if (!(key0 === 'amd' || key0 === 'commonjs' || key0 === 'root')) {
1557
- const err6 = {
1558
- params: {
1559
- additionalProperty: key0,
1560
- },
1561
- };
1562
- if (vErrors === null) {
1563
- vErrors = [err6];
1564
- }
1565
- else {
1566
- vErrors.push(err6);
1567
- }
1568
- errors++;
1569
- break;
1570
- }
1571
- }
1572
- if (_errs10 === errors) {
1573
- if (data.amd !== undefined) {
1574
- let data1 = data.amd;
1575
- const _errs11 = errors;
1576
- if (errors === _errs11) {
1577
- if (typeof data1 === 'string') {
1578
- if (data1.length < 1) {
1579
- const err7 = {
1580
- params: {},
1581
- };
1582
- if (vErrors === null) {
1583
- vErrors = [err7];
1584
- }
1585
- else {
1586
- vErrors.push(err7);
1587
- }
1588
- errors++;
1589
- }
1590
- }
1591
- else {
1592
- const err8 = {
1593
- params: {
1594
- type: 'string',
1595
- },
1596
- };
1597
- if (vErrors === null) {
1598
- vErrors = [err8];
1599
- }
1600
- else {
1601
- vErrors.push(err8);
1602
- }
1603
- errors++;
1604
- }
1605
- }
1606
- var valid3 = _errs11 === errors;
1607
- }
1608
- else {
1609
- var valid3 = true;
1610
- }
1611
- if (valid3) {
1612
- if (data.commonjs !== undefined) {
1613
- let data2 = data.commonjs;
1614
- const _errs13 = errors;
1615
- if (errors === _errs13) {
1616
- if (typeof data2 === 'string') {
1617
- if (data2.length < 1) {
1618
- const err9 = {
1619
- params: {},
1620
- };
1621
- if (vErrors === null) {
1622
- vErrors = [err9];
1623
- }
1624
- else {
1625
- vErrors.push(err9);
1626
- }
1627
- errors++;
1628
- }
1629
- }
1630
- else {
1631
- const err10 = {
1632
- params: {
1633
- type: 'string',
1634
- },
1635
- };
1636
- if (vErrors === null) {
1637
- vErrors = [err10];
1638
- }
1639
- else {
1640
- vErrors.push(err10);
1641
- }
1642
- errors++;
1643
- }
1644
- }
1645
- var valid3 = _errs13 === errors;
1646
- }
1647
- else {
1648
- var valid3 = true;
1649
- }
1650
- if (valid3) {
1651
- if (data.root !== undefined) {
1652
- let data3 = data.root;
1653
- const _errs15 = errors;
1654
- const _errs16 = errors;
1655
- let valid4 = false;
1656
- const _errs17 = errors;
1657
- if (errors === _errs17) {
1658
- if (Array.isArray(data3)) {
1659
- var valid5 = true;
1660
- const len1 = data3.length;
1661
- for (let i1 = 0; i1 < len1; i1++) {
1662
- let data4 = data3[i1];
1663
- const _errs19 = errors;
1664
- if (errors === _errs19) {
1665
- if (typeof data4 === 'string') {
1666
- if (data4.length < 1) {
1667
- const err11 = {
1668
- params: {},
1669
- };
1670
- if (vErrors === null) {
1671
- vErrors = [err11];
1672
- }
1673
- else {
1674
- vErrors.push(err11);
1675
- }
1676
- errors++;
1677
- }
1678
- }
1679
- else {
1680
- const err12 = {
1681
- params: {
1682
- type: 'string',
1683
- },
1684
- };
1685
- if (vErrors === null) {
1686
- vErrors = [err12];
1687
- }
1688
- else {
1689
- vErrors.push(err12);
1690
- }
1691
- errors++;
1692
- }
1693
- }
1694
- var valid5 = _errs19 === errors;
1695
- if (!valid5) {
1696
- break;
1697
- }
1698
- }
1699
- }
1700
- else {
1701
- const err13 = {
1702
- params: {
1703
- type: 'array',
1704
- },
1705
- };
1706
- if (vErrors === null) {
1707
- vErrors = [err13];
1708
- }
1709
- else {
1710
- vErrors.push(err13);
1711
- }
1712
- errors++;
1713
- }
1714
- }
1715
- var _valid1 = _errs17 === errors;
1716
- valid4 = valid4 || _valid1;
1717
- if (!valid4) {
1718
- const _errs21 = errors;
1719
- if (errors === _errs21) {
1720
- if (typeof data3 === 'string') {
1721
- if (data3.length < 1) {
1722
- const err14 = {
1723
- params: {},
1724
- };
1725
- if (vErrors === null) {
1726
- vErrors = [err14];
1727
- }
1728
- else {
1729
- vErrors.push(err14);
1730
- }
1731
- errors++;
1732
- }
1733
- }
1734
- else {
1735
- const err15 = {
1736
- params: {
1737
- type: 'string',
1738
- },
1739
- };
1740
- if (vErrors === null) {
1741
- vErrors = [err15];
1742
- }
1743
- else {
1744
- vErrors.push(err15);
1745
- }
1746
- errors++;
1747
- }
1748
- }
1749
- var _valid1 = _errs21 === errors;
1750
- valid4 = valid4 || _valid1;
1751
- }
1752
- if (!valid4) {
1753
- const err16 = {
1754
- params: {},
1755
- };
1756
- if (vErrors === null) {
1757
- vErrors = [err16];
1758
- }
1759
- else {
1760
- vErrors.push(err16);
1761
- }
1762
- errors++;
1763
- }
1764
- else {
1765
- errors = _errs16;
1766
- if (vErrors !== null) {
1767
- if (_errs16) {
1768
- vErrors.length = _errs16;
1769
- }
1770
- else {
1771
- vErrors = null;
1772
- }
1773
- }
1774
- }
1775
- var valid3 = _errs15 === errors;
1776
- }
1777
- else {
1778
- var valid3 = true;
1779
- }
1780
- }
1781
- }
1782
- }
1783
- }
1784
- else {
1785
- const err17 = {
1786
- params: {
1787
- type: 'object',
1788
- },
1789
- };
1790
- if (vErrors === null) {
1791
- vErrors = [err17];
1792
- }
1793
- else {
1794
- vErrors.push(err17);
1795
- }
1796
- errors++;
1797
- }
1798
- }
1799
- var _valid0 = _errs7 === errors;
1800
- valid0 = valid0 || _valid0;
1801
- }
1802
- }
1803
- if (!valid0) {
1804
- const err18 = {
1805
- params: {},
1806
- };
1807
- if (vErrors === null) {
1808
- vErrors = [err18];
1809
- }
1810
- else {
1811
- vErrors.push(err18);
1812
- }
1813
- errors++;
1814
- validate62.errors = vErrors;
1815
- return false;
1816
- }
1817
- else {
1818
- errors = _errs0;
1819
- if (vErrors !== null) {
1820
- if (_errs0) {
1821
- vErrors.length = _errs0;
1822
- }
1823
- else {
1824
- vErrors = null;
1825
- }
1826
- }
1827
- }
1828
- validate62.errors = vErrors;
1829
- return errors === 0;
1830
- }
1831
- function validate59(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
1832
- let vErrors = null;
1833
- let errors = 0;
1834
- if (errors === 0) {
1835
- if (data && typeof data == 'object' && !Array.isArray(data)) {
1836
- let missing0;
1837
- if (data.type === undefined && (missing0 = 'type')) {
1838
- validate59.errors = [
1839
- {
1840
- params: {
1841
- missingProperty: missing0,
1842
- },
1843
- },
1844
- ];
1845
- return false;
1846
- }
1847
- else {
1848
- const _errs1 = errors;
1849
- for (const key0 in data) {
1850
- if (!(key0 === 'amdContainer' ||
1851
- key0 === 'auxiliaryComment' ||
1852
- key0 === 'export' ||
1853
- key0 === 'name' ||
1854
- key0 === 'type' ||
1855
- key0 === 'umdNamedDefine')) {
1856
- validate59.errors = [
1857
- {
1858
- params: {
1859
- additionalProperty: key0,
1860
- },
1861
- },
1862
- ];
1863
- return false;
1864
- break;
1865
- }
1866
- }
1867
- if (_errs1 === errors) {
1868
- if (data.amdContainer !== undefined) {
1869
- let data0 = data.amdContainer;
1870
- const _errs2 = errors;
1871
- const _errs3 = errors;
1872
- if (errors === _errs3) {
1873
- if (typeof data0 === 'string') {
1874
- if (data0.length < 1) {
1875
- validate59.errors = [
1876
- {
1877
- params: {},
1878
- },
1879
- ];
1880
- return false;
1881
- }
1882
- }
1883
- else {
1884
- validate59.errors = [
1885
- {
1886
- params: {
1887
- type: 'string',
1888
- },
1889
- },
1890
- ];
1891
- return false;
1892
- }
1893
- }
1894
- var valid0 = _errs2 === errors;
1895
- }
1896
- else {
1897
- var valid0 = true;
1898
- }
1899
- if (valid0) {
1900
- if (data.auxiliaryComment !== undefined) {
1901
- const _errs5 = errors;
1902
- if (!validate60(data.auxiliaryComment, {
1903
- instancePath: instancePath + '/auxiliaryComment',
1904
- parentData: data,
1905
- parentDataProperty: 'auxiliaryComment',
1906
- rootData,
1907
- })) {
1908
- vErrors =
1909
- vErrors === null
1910
- ? validate60.errors
1911
- : vErrors.concat(validate60.errors);
1912
- errors = vErrors.length;
1913
- }
1914
- var valid0 = _errs5 === errors;
1915
- }
1916
- else {
1917
- var valid0 = true;
1918
- }
1919
- if (valid0) {
1920
- if (data.export !== undefined) {
1921
- let data2 = data.export;
1922
- const _errs6 = errors;
1923
- const _errs8 = errors;
1924
- let valid3 = false;
1925
- const _errs9 = errors;
1926
- if (errors === _errs9) {
1927
- if (Array.isArray(data2)) {
1928
- var valid4 = true;
1929
- const len0 = data2.length;
1930
- for (let i0 = 0; i0 < len0; i0++) {
1931
- let data3 = data2[i0];
1932
- const _errs11 = errors;
1933
- if (errors === _errs11) {
1934
- if (typeof data3 === 'string') {
1935
- if (data3.length < 1) {
1936
- const err0 = {
1937
- params: {},
1938
- };
1939
- if (vErrors === null) {
1940
- vErrors = [err0];
1941
- }
1942
- else {
1943
- vErrors.push(err0);
1944
- }
1945
- errors++;
1946
- }
1947
- }
1948
- else {
1949
- const err1 = {
1950
- params: {
1951
- type: 'string',
1952
- },
1953
- };
1954
- if (vErrors === null) {
1955
- vErrors = [err1];
1956
- }
1957
- else {
1958
- vErrors.push(err1);
1959
- }
1960
- errors++;
1961
- }
1962
- }
1963
- var valid4 = _errs11 === errors;
1964
- if (!valid4) {
1965
- break;
1966
- }
1967
- }
1968
- }
1969
- else {
1970
- const err2 = {
1971
- params: {
1972
- type: 'array',
1973
- },
1974
- };
1975
- if (vErrors === null) {
1976
- vErrors = [err2];
1977
- }
1978
- else {
1979
- vErrors.push(err2);
1980
- }
1981
- errors++;
1982
- }
1983
- }
1984
- var _valid0 = _errs9 === errors;
1985
- valid3 = valid3 || _valid0;
1986
- if (!valid3) {
1987
- const _errs13 = errors;
1988
- if (errors === _errs13) {
1989
- if (typeof data2 === 'string') {
1990
- if (data2.length < 1) {
1991
- const err3 = {
1992
- params: {},
1993
- };
1994
- if (vErrors === null) {
1995
- vErrors = [err3];
1996
- }
1997
- else {
1998
- vErrors.push(err3);
1999
- }
2000
- errors++;
2001
- }
2002
- }
2003
- else {
2004
- const err4 = {
2005
- params: {
2006
- type: 'string',
2007
- },
2008
- };
2009
- if (vErrors === null) {
2010
- vErrors = [err4];
2011
- }
2012
- else {
2013
- vErrors.push(err4);
2014
- }
2015
- errors++;
2016
- }
2017
- }
2018
- var _valid0 = _errs13 === errors;
2019
- valid3 = valid3 || _valid0;
2020
- }
2021
- if (!valid3) {
2022
- const err5 = {
2023
- params: {},
2024
- };
2025
- if (vErrors === null) {
2026
- vErrors = [err5];
2027
- }
2028
- else {
2029
- vErrors.push(err5);
2030
- }
2031
- errors++;
2032
- validate59.errors = vErrors;
2033
- return false;
2034
- }
2035
- else {
2036
- errors = _errs8;
2037
- if (vErrors !== null) {
2038
- if (_errs8) {
2039
- vErrors.length = _errs8;
2040
- }
2041
- else {
2042
- vErrors = null;
2043
- }
2044
- }
2045
- }
2046
- var valid0 = _errs6 === errors;
2047
- }
2048
- else {
2049
- var valid0 = true;
2050
- }
2051
- if (valid0) {
2052
- if (data.name !== undefined) {
2053
- const _errs15 = errors;
2054
- if (!validate62(data.name, {
2055
- instancePath: instancePath + '/name',
2056
- parentData: data,
2057
- parentDataProperty: 'name',
2058
- rootData,
2059
- })) {
2060
- vErrors =
2061
- vErrors === null
2062
- ? validate62.errors
2063
- : vErrors.concat(validate62.errors);
2064
- errors = vErrors.length;
2065
- }
2066
- var valid0 = _errs15 === errors;
2067
- }
2068
- else {
2069
- var valid0 = true;
2070
- }
2071
- if (valid0) {
2072
- if (data.type !== undefined) {
2073
- let data5 = data.type;
2074
- const _errs16 = errors;
2075
- const _errs18 = errors;
2076
- let valid6 = false;
2077
- const _errs19 = errors;
2078
- if (data5 !== 'var' &&
2079
- data5 !== 'module' &&
2080
- data5 !== 'assign' &&
2081
- data5 !== 'assign-properties' &&
2082
- data5 !== 'this' &&
2083
- data5 !== 'window' &&
2084
- data5 !== 'self' &&
2085
- data5 !== 'global' &&
2086
- data5 !== 'commonjs' &&
2087
- data5 !== 'commonjs2' &&
2088
- data5 !== 'commonjs-module' &&
2089
- data5 !== 'commonjs-static' &&
2090
- data5 !== 'amd' &&
2091
- data5 !== 'amd-require' &&
2092
- data5 !== 'umd' &&
2093
- data5 !== 'umd2' &&
2094
- data5 !== 'jsonp' &&
2095
- data5 !== 'system') {
2096
- const err6 = {
2097
- params: {},
2098
- };
2099
- if (vErrors === null) {
2100
- vErrors = [err6];
2101
- }
2102
- else {
2103
- vErrors.push(err6);
2104
- }
2105
- errors++;
2106
- }
2107
- var _valid1 = _errs19 === errors;
2108
- valid6 = valid6 || _valid1;
2109
- if (!valid6) {
2110
- const _errs20 = errors;
2111
- if (typeof data5 !== 'string') {
2112
- const err7 = {
2113
- params: {
2114
- type: 'string',
2115
- },
2116
- };
2117
- if (vErrors === null) {
2118
- vErrors = [err7];
2119
- }
2120
- else {
2121
- vErrors.push(err7);
2122
- }
2123
- errors++;
2124
- }
2125
- var _valid1 = _errs20 === errors;
2126
- valid6 = valid6 || _valid1;
2127
- }
2128
- if (!valid6) {
2129
- const err8 = {
2130
- params: {},
2131
- };
2132
- if (vErrors === null) {
2133
- vErrors = [err8];
2134
- }
2135
- else {
2136
- vErrors.push(err8);
2137
- }
2138
- errors++;
2139
- validate59.errors = vErrors;
2140
- return false;
2141
- }
2142
- else {
2143
- errors = _errs18;
2144
- if (vErrors !== null) {
2145
- if (_errs18) {
2146
- vErrors.length = _errs18;
2147
- }
2148
- else {
2149
- vErrors = null;
2150
- }
2151
- }
2152
- }
2153
- var valid0 = _errs16 === errors;
2154
- }
2155
- else {
2156
- var valid0 = true;
2157
- }
2158
- if (valid0) {
2159
- if (data.umdNamedDefine !== undefined) {
2160
- const _errs22 = errors;
2161
- if (typeof data.umdNamedDefine !== 'boolean') {
2162
- validate59.errors = [
2163
- {
2164
- params: {
2165
- type: 'boolean',
2166
- },
2167
- },
2168
- ];
2169
- return false;
2170
- }
2171
- var valid0 = _errs22 === errors;
2172
- }
2173
- else {
2174
- var valid0 = true;
2175
- }
2176
- }
2177
- }
2178
- }
2179
- }
2180
- }
2181
- }
2182
- }
2183
- }
2184
- else {
2185
- validate59.errors = [
2186
- {
2187
- params: {
2188
- type: 'object',
2189
- },
2190
- },
2191
- ];
2192
- return false;
2193
- }
2194
- }
2195
- validate59.errors = vErrors;
2196
- return errors === 0;
2197
- }
2198
- const schema70 = {
2199
- anyOf: [
2200
- {
2201
- type: 'array',
2202
- items: {
2203
- anyOf: [
2204
- {
2205
- $ref: '#/definitions/RemotesItem',
2206
- },
2207
- {
2208
- $ref: '#/definitions/RemotesObject',
2209
- },
2210
- ],
2211
- },
2212
- },
2213
- {
2214
- $ref: '#/definitions/RemotesObject',
2215
- },
2216
- ],
2217
- };
2218
- const schema71 = {
2219
- type: 'string',
2220
- minLength: 1,
2221
- };
2222
- const schema72 = {
2223
- type: 'object',
2224
- additionalProperties: {
2225
- anyOf: [
2226
- {
2227
- $ref: '#/definitions/RemotesConfig',
2228
- },
2229
- {
2230
- $ref: '#/definitions/RemotesItem',
2231
- },
2232
- {
2233
- $ref: '#/definitions/RemotesItems',
2234
- },
2235
- ],
2236
- },
2237
- };
2238
- const schema73 = {
2239
- type: 'object',
2240
- additionalProperties: false,
2241
- properties: {
2242
- external: {
2243
- anyOf: [
2244
- {
2245
- $ref: '#/definitions/RemotesItem',
2246
- },
2247
- {
2248
- $ref: '#/definitions/RemotesItems',
2249
- },
2250
- ],
2251
- },
2252
- shareScope: {
2253
- type: 'string',
2254
- minLength: 1,
2255
- },
2256
- },
2257
- required: ['external'],
2258
- };
2259
- const schema75 = {
2260
- type: 'array',
2261
- items: {
2262
- $ref: '#/definitions/RemotesItem',
2263
- },
2264
- };
2265
- function validate68(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
2266
- let vErrors = null;
2267
- let errors = 0;
2268
- if (errors === 0) {
2269
- if (Array.isArray(data)) {
2270
- var valid0 = true;
2271
- const len0 = data.length;
2272
- for (let i0 = 0; i0 < len0; i0++) {
2273
- let data0 = data[i0];
2274
- const _errs1 = errors;
2275
- const _errs2 = errors;
2276
- if (errors === _errs2) {
2277
- if (typeof data0 === 'string') {
2278
- if (data0.length < 1) {
2279
- validate68.errors = [
2280
- {
2281
- params: {},
2282
- },
2283
- ];
2284
- return false;
2285
- }
2286
- }
2287
- else {
2288
- validate68.errors = [
2289
- {
2290
- params: {
2291
- type: 'string',
2292
- },
2293
- },
2294
- ];
2295
- return false;
2296
- }
2297
- }
2298
- var valid0 = _errs1 === errors;
2299
- if (!valid0) {
2300
- break;
2301
- }
2302
- }
2303
- }
2304
- else {
2305
- validate68.errors = [
2306
- {
2307
- params: {
2308
- type: 'array',
2309
- },
2310
- },
2311
- ];
2312
- return false;
2313
- }
2314
- }
2315
- validate68.errors = vErrors;
2316
- return errors === 0;
2317
- }
2318
- function validate67(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
2319
- let vErrors = null;
2320
- let errors = 0;
2321
- if (errors === 0) {
2322
- if (data && typeof data == 'object' && !Array.isArray(data)) {
2323
- let missing0;
2324
- if (data.external === undefined && (missing0 = 'external')) {
2325
- validate67.errors = [
2326
- {
2327
- params: {
2328
- missingProperty: missing0,
2329
- },
2330
- },
2331
- ];
2332
- return false;
2333
- }
2334
- else {
2335
- const _errs1 = errors;
2336
- for (const key0 in data) {
2337
- if (!(key0 === 'external' || key0 === 'shareScope')) {
2338
- validate67.errors = [
2339
- {
2340
- params: {
2341
- additionalProperty: key0,
2342
- },
2343
- },
2344
- ];
2345
- return false;
2346
- break;
2347
- }
2348
- }
2349
- if (_errs1 === errors) {
2350
- if (data.external !== undefined) {
2351
- let data0 = data.external;
2352
- const _errs2 = errors;
2353
- const _errs3 = errors;
2354
- let valid1 = false;
2355
- const _errs4 = errors;
2356
- const _errs5 = errors;
2357
- if (errors === _errs5) {
2358
- if (typeof data0 === 'string') {
2359
- if (data0.length < 1) {
2360
- const err0 = {
2361
- params: {},
2362
- };
2363
- if (vErrors === null) {
2364
- vErrors = [err0];
2365
- }
2366
- else {
2367
- vErrors.push(err0);
2368
- }
2369
- errors++;
2370
- }
2371
- }
2372
- else {
2373
- const err1 = {
2374
- params: {
2375
- type: 'string',
2376
- },
2377
- };
2378
- if (vErrors === null) {
2379
- vErrors = [err1];
2380
- }
2381
- else {
2382
- vErrors.push(err1);
2383
- }
2384
- errors++;
2385
- }
2386
- }
2387
- var _valid0 = _errs4 === errors;
2388
- valid1 = valid1 || _valid0;
2389
- if (!valid1) {
2390
- const _errs7 = errors;
2391
- if (!validate68(data0, {
2392
- instancePath: instancePath + '/external',
2393
- parentData: data,
2394
- parentDataProperty: 'external',
2395
- rootData,
2396
- })) {
2397
- vErrors =
2398
- vErrors === null
2399
- ? validate68.errors
2400
- : vErrors.concat(validate68.errors);
2401
- errors = vErrors.length;
2402
- }
2403
- var _valid0 = _errs7 === errors;
2404
- valid1 = valid1 || _valid0;
2405
- }
2406
- if (!valid1) {
2407
- const err2 = {
2408
- params: {},
2409
- };
2410
- if (vErrors === null) {
2411
- vErrors = [err2];
2412
- }
2413
- else {
2414
- vErrors.push(err2);
2415
- }
2416
- errors++;
2417
- validate67.errors = vErrors;
2418
- return false;
2419
- }
2420
- else {
2421
- errors = _errs3;
2422
- if (vErrors !== null) {
2423
- if (_errs3) {
2424
- vErrors.length = _errs3;
2425
- }
2426
- else {
2427
- vErrors = null;
2428
- }
2429
- }
2430
- }
2431
- var valid0 = _errs2 === errors;
2432
- }
2433
- else {
2434
- var valid0 = true;
2435
- }
2436
- if (valid0) {
2437
- if (data.shareScope !== undefined) {
2438
- let data1 = data.shareScope;
2439
- const _errs8 = errors;
2440
- if (errors === _errs8) {
2441
- if (typeof data1 === 'string') {
2442
- if (data1.length < 1) {
2443
- validate67.errors = [
2444
- {
2445
- params: {},
2446
- },
2447
- ];
2448
- return false;
2449
- }
2450
- }
2451
- else {
2452
- validate67.errors = [
2453
- {
2454
- params: {
2455
- type: 'string',
2456
- },
2457
- },
2458
- ];
2459
- return false;
2460
- }
2461
- }
2462
- var valid0 = _errs8 === errors;
2463
- }
2464
- else {
2465
- var valid0 = true;
2466
- }
2467
- }
2468
- }
2469
- }
2470
- }
2471
- else {
2472
- validate67.errors = [
2473
- {
2474
- params: {
2475
- type: 'object',
2476
- },
2477
- },
2478
- ];
2479
- return false;
2480
- }
2481
- }
2482
- validate67.errors = vErrors;
2483
- return errors === 0;
2484
- }
2485
- function validate66(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
2486
- let vErrors = null;
2487
- let errors = 0;
2488
- if (errors === 0) {
2489
- if (data && typeof data == 'object' && !Array.isArray(data)) {
2490
- for (const key0 in data) {
2491
- let data0 = data[key0];
2492
- const _errs2 = errors;
2493
- const _errs3 = errors;
2494
- let valid1 = false;
2495
- const _errs4 = errors;
2496
- if (!validate67(data0, {
2497
- instancePath: instancePath +
2498
- '/' +
2499
- key0.replace(/~/g, '~0').replace(/\//g, '~1'),
2500
- parentData: data,
2501
- parentDataProperty: key0,
2502
- rootData,
2503
- })) {
2504
- vErrors =
2505
- vErrors === null
2506
- ? validate67.errors
2507
- : vErrors.concat(validate67.errors);
2508
- errors = vErrors.length;
2509
- }
2510
- var _valid0 = _errs4 === errors;
2511
- valid1 = valid1 || _valid0;
2512
- if (!valid1) {
2513
- const _errs5 = errors;
2514
- const _errs6 = errors;
2515
- if (errors === _errs6) {
2516
- if (typeof data0 === 'string') {
2517
- if (data0.length < 1) {
2518
- const err0 = {
2519
- params: {},
2520
- };
2521
- if (vErrors === null) {
2522
- vErrors = [err0];
2523
- }
2524
- else {
2525
- vErrors.push(err0);
2526
- }
2527
- errors++;
2528
- }
2529
- }
2530
- else {
2531
- const err1 = {
2532
- params: {
2533
- type: 'string',
2534
- },
2535
- };
2536
- if (vErrors === null) {
2537
- vErrors = [err1];
2538
- }
2539
- else {
2540
- vErrors.push(err1);
2541
- }
2542
- errors++;
2543
- }
2544
- }
2545
- var _valid0 = _errs5 === errors;
2546
- valid1 = valid1 || _valid0;
2547
- if (!valid1) {
2548
- const _errs8 = errors;
2549
- if (!validate68(data0, {
2550
- instancePath: instancePath +
2551
- '/' +
2552
- key0.replace(/~/g, '~0').replace(/\//g, '~1'),
2553
- parentData: data,
2554
- parentDataProperty: key0,
2555
- rootData,
2556
- })) {
2557
- vErrors =
2558
- vErrors === null
2559
- ? validate68.errors
2560
- : vErrors.concat(validate68.errors);
2561
- errors = vErrors.length;
2562
- }
2563
- var _valid0 = _errs8 === errors;
2564
- valid1 = valid1 || _valid0;
2565
- }
2566
- }
2567
- if (!valid1) {
2568
- const err2 = {
2569
- params: {},
2570
- };
2571
- if (vErrors === null) {
2572
- vErrors = [err2];
2573
- }
2574
- else {
2575
- vErrors.push(err2);
2576
- }
2577
- errors++;
2578
- validate66.errors = vErrors;
2579
- return false;
2580
- }
2581
- else {
2582
- errors = _errs3;
2583
- if (vErrors !== null) {
2584
- if (_errs3) {
2585
- vErrors.length = _errs3;
2586
- }
2587
- else {
2588
- vErrors = null;
2589
- }
2590
- }
2591
- }
2592
- var valid0 = _errs2 === errors;
2593
- if (!valid0) {
2594
- break;
2595
- }
2596
- }
2597
- }
2598
- else {
2599
- validate66.errors = [
2600
- {
2601
- params: {
2602
- type: 'object',
2603
- },
2604
- },
2605
- ];
2606
- return false;
2607
- }
2608
- }
2609
- validate66.errors = vErrors;
2610
- return errors === 0;
2611
- }
2612
- function validate65(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
2613
- let vErrors = null;
2614
- let errors = 0;
2615
- const _errs0 = errors;
2616
- let valid0 = false;
2617
- const _errs1 = errors;
2618
- if (errors === _errs1) {
2619
- if (Array.isArray(data)) {
2620
- var valid1 = true;
2621
- const len0 = data.length;
2622
- for (let i0 = 0; i0 < len0; i0++) {
2623
- let data0 = data[i0];
2624
- const _errs3 = errors;
2625
- const _errs4 = errors;
2626
- let valid2 = false;
2627
- const _errs5 = errors;
2628
- const _errs6 = errors;
2629
- if (errors === _errs6) {
2630
- if (typeof data0 === 'string') {
2631
- if (data0.length < 1) {
2632
- const err0 = {
2633
- params: {},
2634
- };
2635
- if (vErrors === null) {
2636
- vErrors = [err0];
2637
- }
2638
- else {
2639
- vErrors.push(err0);
2640
- }
2641
- errors++;
2642
- }
2643
- }
2644
- else {
2645
- const err1 = {
2646
- params: {
2647
- type: 'string',
2648
- },
2649
- };
2650
- if (vErrors === null) {
2651
- vErrors = [err1];
2652
- }
2653
- else {
2654
- vErrors.push(err1);
2655
- }
2656
- errors++;
2657
- }
2658
- }
2659
- var _valid1 = _errs5 === errors;
2660
- valid2 = valid2 || _valid1;
2661
- if (!valid2) {
2662
- const _errs8 = errors;
2663
- if (!validate66(data0, {
2664
- instancePath: instancePath + '/' + i0,
2665
- parentData: data,
2666
- parentDataProperty: i0,
2667
- rootData,
2668
- })) {
2669
- vErrors =
2670
- vErrors === null
2671
- ? validate66.errors
2672
- : vErrors.concat(validate66.errors);
2673
- errors = vErrors.length;
2674
- }
2675
- var _valid1 = _errs8 === errors;
2676
- valid2 = valid2 || _valid1;
2677
- }
2678
- if (!valid2) {
2679
- const err2 = {
2680
- params: {},
2681
- };
2682
- if (vErrors === null) {
2683
- vErrors = [err2];
2684
- }
2685
- else {
2686
- vErrors.push(err2);
2687
- }
2688
- errors++;
2689
- }
2690
- else {
2691
- errors = _errs4;
2692
- if (vErrors !== null) {
2693
- if (_errs4) {
2694
- vErrors.length = _errs4;
2695
- }
2696
- else {
2697
- vErrors = null;
2698
- }
2699
- }
2700
- }
2701
- var valid1 = _errs3 === errors;
2702
- if (!valid1) {
2703
- break;
2704
- }
2705
- }
2706
- }
2707
- else {
2708
- const err3 = {
2709
- params: {
2710
- type: 'array',
2711
- },
2712
- };
2713
- if (vErrors === null) {
2714
- vErrors = [err3];
2715
- }
2716
- else {
2717
- vErrors.push(err3);
2718
- }
2719
- errors++;
2720
- }
2721
- }
2722
- var _valid0 = _errs1 === errors;
2723
- valid0 = valid0 || _valid0;
2724
- if (!valid0) {
2725
- const _errs9 = errors;
2726
- if (!validate66(data, {
2727
- instancePath,
2728
- parentData,
2729
- parentDataProperty,
2730
- rootData,
2731
- })) {
2732
- vErrors =
2733
- vErrors === null
2734
- ? validate66.errors
2735
- : vErrors.concat(validate66.errors);
2736
- errors = vErrors.length;
2737
- }
2738
- var _valid0 = _errs9 === errors;
2739
- valid0 = valid0 || _valid0;
2740
- }
2741
- if (!valid0) {
2742
- const err4 = {
2743
- params: {},
2744
- };
2745
- if (vErrors === null) {
2746
- vErrors = [err4];
2747
- }
2748
- else {
2749
- vErrors.push(err4);
2750
- }
2751
- errors++;
2752
- validate65.errors = vErrors;
2753
- return false;
2754
- }
2755
- else {
2756
- errors = _errs0;
2757
- if (vErrors !== null) {
2758
- if (_errs0) {
2759
- vErrors.length = _errs0;
2760
- }
2761
- else {
2762
- vErrors = null;
2763
- }
2764
- }
2765
- }
2766
- validate65.errors = vErrors;
2767
- return errors === 0;
2768
- }
2769
- const schema79 = {
2770
- anyOf: [
2771
- {
2772
- type: 'array',
2773
- items: {
2774
- anyOf: [
2775
- {
2776
- $ref: '#/definitions/SharedItem',
2777
- },
2778
- {
2779
- $ref: '#/definitions/SharedObject',
2780
- },
2781
- ],
2782
- },
2783
- },
2784
- {
2785
- $ref: '#/definitions/SharedObject',
2786
- },
2787
- ],
2788
- };
2789
- const schema80 = {
2790
- type: 'string',
2791
- minLength: 1,
2792
- };
2793
- const schema81 = {
2794
- type: 'object',
2795
- additionalProperties: {
2796
- anyOf: [
2797
- {
2798
- $ref: '#/definitions/SharedConfig',
2799
- },
2800
- {
2801
- $ref: '#/definitions/SharedItem',
2802
- },
2803
- ],
2804
- },
2805
- };
2806
- const schema82 = {
2807
- type: 'object',
2808
- additionalProperties: false,
2809
- properties: {
2810
- eager: {
2811
- type: 'boolean',
2812
- },
2813
- import: {
2814
- anyOf: [
2815
- {
2816
- enum: [false],
2817
- },
2818
- {
2819
- $ref: '#/definitions/SharedItem',
2820
- },
2821
- ],
2822
- },
2823
- packageName: {
2824
- type: 'string',
2825
- minLength: 1,
2826
- },
2827
- requiredVersion: {
2828
- anyOf: [
2829
- {
2830
- enum: [false],
2831
- },
2832
- {
2833
- type: 'string',
2834
- },
2835
- ],
2836
- },
2837
- shareKey: {
2838
- type: 'string',
2839
- minLength: 1,
2840
- },
2841
- shareScope: {
2842
- type: 'string',
2843
- minLength: 1,
2844
- },
2845
- singleton: {
2846
- type: 'boolean',
2847
- },
2848
- strictVersion: {
2849
- type: 'boolean',
2850
- },
2851
- version: {
2852
- anyOf: [
2853
- {
2854
- enum: [false],
2855
- },
2856
- {
2857
- type: 'string',
2858
- },
2859
- ],
2860
- },
2861
- },
2862
- };
2863
- function validate77(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
2864
- let vErrors = null;
2865
- let errors = 0;
2866
- if (errors === 0) {
2867
- if (data && typeof data == 'object' && !Array.isArray(data)) {
2868
- const _errs1 = errors;
2869
- for (const key0 in data) {
2870
- if (!func2.call(schema82.properties, key0)) {
2871
- validate77.errors = [
2872
- {
2873
- params: {
2874
- additionalProperty: key0,
2875
- },
2876
- },
2877
- ];
2878
- return false;
2879
- break;
2880
- }
2881
- }
2882
- if (_errs1 === errors) {
2883
- if (data.eager !== undefined) {
2884
- const _errs2 = errors;
2885
- if (typeof data.eager !== 'boolean') {
2886
- validate77.errors = [
2887
- {
2888
- params: {
2889
- type: 'boolean',
2890
- },
2891
- },
2892
- ];
2893
- return false;
2894
- }
2895
- var valid0 = _errs2 === errors;
2896
- }
2897
- else {
2898
- var valid0 = true;
2899
- }
2900
- if (valid0) {
2901
- if (data.import !== undefined) {
2902
- let data1 = data.import;
2903
- const _errs4 = errors;
2904
- const _errs5 = errors;
2905
- let valid1 = false;
2906
- const _errs6 = errors;
2907
- if (data1 !== false) {
2908
- const err0 = {
2909
- params: {},
2910
- };
2911
- if (vErrors === null) {
2912
- vErrors = [err0];
2913
- }
2914
- else {
2915
- vErrors.push(err0);
2916
- }
2917
- errors++;
2918
- }
2919
- var _valid0 = _errs6 === errors;
2920
- valid1 = valid1 || _valid0;
2921
- if (!valid1) {
2922
- const _errs7 = errors;
2923
- const _errs8 = errors;
2924
- if (errors === _errs8) {
2925
- if (typeof data1 === 'string') {
2926
- if (data1.length < 1) {
2927
- const err1 = {
2928
- params: {},
2929
- };
2930
- if (vErrors === null) {
2931
- vErrors = [err1];
2932
- }
2933
- else {
2934
- vErrors.push(err1);
2935
- }
2936
- errors++;
2937
- }
2938
- }
2939
- else {
2940
- const err2 = {
2941
- params: {
2942
- type: 'string',
2943
- },
2944
- };
2945
- if (vErrors === null) {
2946
- vErrors = [err2];
2947
- }
2948
- else {
2949
- vErrors.push(err2);
2950
- }
2951
- errors++;
2952
- }
2953
- }
2954
- var _valid0 = _errs7 === errors;
2955
- valid1 = valid1 || _valid0;
2956
- }
2957
- if (!valid1) {
2958
- const err3 = {
2959
- params: {},
2960
- };
2961
- if (vErrors === null) {
2962
- vErrors = [err3];
2963
- }
2964
- else {
2965
- vErrors.push(err3);
2966
- }
2967
- errors++;
2968
- validate77.errors = vErrors;
2969
- return false;
2970
- }
2971
- else {
2972
- errors = _errs5;
2973
- if (vErrors !== null) {
2974
- if (_errs5) {
2975
- vErrors.length = _errs5;
2976
- }
2977
- else {
2978
- vErrors = null;
2979
- }
2980
- }
2981
- }
2982
- var valid0 = _errs4 === errors;
2983
- }
2984
- else {
2985
- var valid0 = true;
2986
- }
2987
- if (valid0) {
2988
- if (data.packageName !== undefined) {
2989
- let data2 = data.packageName;
2990
- const _errs10 = errors;
2991
- if (errors === _errs10) {
2992
- if (typeof data2 === 'string') {
2993
- if (data2.length < 1) {
2994
- validate77.errors = [
2995
- {
2996
- params: {},
2997
- },
2998
- ];
2999
- return false;
3000
- }
3001
- }
3002
- else {
3003
- validate77.errors = [
3004
- {
3005
- params: {
3006
- type: 'string',
3007
- },
3008
- },
3009
- ];
3010
- return false;
3011
- }
3012
- }
3013
- var valid0 = _errs10 === errors;
3014
- }
3015
- else {
3016
- var valid0 = true;
3017
- }
3018
- if (valid0) {
3019
- if (data.requiredVersion !== undefined) {
3020
- let data3 = data.requiredVersion;
3021
- const _errs12 = errors;
3022
- const _errs13 = errors;
3023
- let valid3 = false;
3024
- const _errs14 = errors;
3025
- if (data3 !== false) {
3026
- const err4 = {
3027
- params: {},
3028
- };
3029
- if (vErrors === null) {
3030
- vErrors = [err4];
3031
- }
3032
- else {
3033
- vErrors.push(err4);
3034
- }
3035
- errors++;
3036
- }
3037
- var _valid1 = _errs14 === errors;
3038
- valid3 = valid3 || _valid1;
3039
- if (!valid3) {
3040
- const _errs15 = errors;
3041
- if (typeof data3 !== 'string') {
3042
- const err5 = {
3043
- params: {
3044
- type: 'string',
3045
- },
3046
- };
3047
- if (vErrors === null) {
3048
- vErrors = [err5];
3049
- }
3050
- else {
3051
- vErrors.push(err5);
3052
- }
3053
- errors++;
3054
- }
3055
- var _valid1 = _errs15 === errors;
3056
- valid3 = valid3 || _valid1;
3057
- }
3058
- if (!valid3) {
3059
- const err6 = {
3060
- params: {},
3061
- };
3062
- if (vErrors === null) {
3063
- vErrors = [err6];
3064
- }
3065
- else {
3066
- vErrors.push(err6);
3067
- }
3068
- errors++;
3069
- validate77.errors = vErrors;
3070
- return false;
3071
- }
3072
- else {
3073
- errors = _errs13;
3074
- if (vErrors !== null) {
3075
- if (_errs13) {
3076
- vErrors.length = _errs13;
3077
- }
3078
- else {
3079
- vErrors = null;
3080
- }
3081
- }
3082
- }
3083
- var valid0 = _errs12 === errors;
3084
- }
3085
- else {
3086
- var valid0 = true;
3087
- }
3088
- if (valid0) {
3089
- if (data.shareKey !== undefined) {
3090
- let data4 = data.shareKey;
3091
- const _errs17 = errors;
3092
- if (errors === _errs17) {
3093
- if (typeof data4 === 'string') {
3094
- if (data4.length < 1) {
3095
- validate77.errors = [
3096
- {
3097
- params: {},
3098
- },
3099
- ];
3100
- return false;
3101
- }
3102
- }
3103
- else {
3104
- validate77.errors = [
3105
- {
3106
- params: {
3107
- type: 'string',
3108
- },
3109
- },
3110
- ];
3111
- return false;
3112
- }
3113
- }
3114
- var valid0 = _errs17 === errors;
3115
- }
3116
- else {
3117
- var valid0 = true;
3118
- }
3119
- if (valid0) {
3120
- if (data.shareScope !== undefined) {
3121
- let data5 = data.shareScope;
3122
- const _errs19 = errors;
3123
- if (errors === _errs19) {
3124
- if (typeof data5 === 'string') {
3125
- if (data5.length < 1) {
3126
- validate77.errors = [
3127
- {
3128
- params: {},
3129
- },
3130
- ];
3131
- return false;
3132
- }
3133
- }
3134
- else {
3135
- validate77.errors = [
3136
- {
3137
- params: {
3138
- type: 'string',
3139
- },
3140
- },
3141
- ];
3142
- return false;
3143
- }
3144
- }
3145
- var valid0 = _errs19 === errors;
3146
- }
3147
- else {
3148
- var valid0 = true;
3149
- }
3150
- if (valid0) {
3151
- if (data.singleton !== undefined) {
3152
- const _errs21 = errors;
3153
- if (typeof data.singleton !== 'boolean') {
3154
- validate77.errors = [
3155
- {
3156
- params: {
3157
- type: 'boolean',
3158
- },
3159
- },
3160
- ];
3161
- return false;
3162
- }
3163
- var valid0 = _errs21 === errors;
3164
- }
3165
- else {
3166
- var valid0 = true;
3167
- }
3168
- if (valid0) {
3169
- if (data.strictVersion !== undefined) {
3170
- const _errs23 = errors;
3171
- if (typeof data.strictVersion !== 'boolean') {
3172
- validate77.errors = [
3173
- {
3174
- params: {
3175
- type: 'boolean',
3176
- },
3177
- },
3178
- ];
3179
- return false;
3180
- }
3181
- var valid0 = _errs23 === errors;
3182
- }
3183
- else {
3184
- var valid0 = true;
3185
- }
3186
- if (valid0) {
3187
- if (data.version !== undefined) {
3188
- let data8 = data.version;
3189
- const _errs25 = errors;
3190
- const _errs26 = errors;
3191
- let valid4 = false;
3192
- const _errs27 = errors;
3193
- if (data8 !== false) {
3194
- const err7 = {
3195
- params: {},
3196
- };
3197
- if (vErrors === null) {
3198
- vErrors = [err7];
3199
- }
3200
- else {
3201
- vErrors.push(err7);
3202
- }
3203
- errors++;
3204
- }
3205
- var _valid2 = _errs27 === errors;
3206
- valid4 = valid4 || _valid2;
3207
- if (!valid4) {
3208
- const _errs28 = errors;
3209
- if (typeof data8 !== 'string') {
3210
- const err8 = {
3211
- params: {
3212
- type: 'string',
3213
- },
3214
- };
3215
- if (vErrors === null) {
3216
- vErrors = [err8];
3217
- }
3218
- else {
3219
- vErrors.push(err8);
3220
- }
3221
- errors++;
3222
- }
3223
- var _valid2 = _errs28 === errors;
3224
- valid4 = valid4 || _valid2;
3225
- }
3226
- if (!valid4) {
3227
- const err9 = {
3228
- params: {},
3229
- };
3230
- if (vErrors === null) {
3231
- vErrors = [err9];
3232
- }
3233
- else {
3234
- vErrors.push(err9);
3235
- }
3236
- errors++;
3237
- validate77.errors = vErrors;
3238
- return false;
3239
- }
3240
- else {
3241
- errors = _errs26;
3242
- if (vErrors !== null) {
3243
- if (_errs26) {
3244
- vErrors.length = _errs26;
3245
- }
3246
- else {
3247
- vErrors = null;
3248
- }
3249
- }
3250
- }
3251
- var valid0 = _errs25 === errors;
3252
- }
3253
- else {
3254
- var valid0 = true;
3255
- }
3256
- }
3257
- }
3258
- }
3259
- }
3260
- }
3261
- }
3262
- }
3263
- }
3264
- }
3265
- }
3266
- else {
3267
- validate77.errors = [
3268
- {
3269
- params: {
3270
- type: 'object',
3271
- },
3272
- },
3273
- ];
3274
- return false;
3275
- }
3276
- }
3277
- validate77.errors = vErrors;
3278
- return errors === 0;
3279
- }
3280
- function validate76(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
3281
- let vErrors = null;
3282
- let errors = 0;
3283
- if (errors === 0) {
3284
- if (data && typeof data == 'object' && !Array.isArray(data)) {
3285
- for (const key0 in data) {
3286
- let data0 = data[key0];
3287
- const _errs2 = errors;
3288
- const _errs3 = errors;
3289
- let valid1 = false;
3290
- const _errs4 = errors;
3291
- if (!validate77(data0, {
3292
- instancePath: instancePath +
3293
- '/' +
3294
- key0.replace(/~/g, '~0').replace(/\//g, '~1'),
3295
- parentData: data,
3296
- parentDataProperty: key0,
3297
- rootData,
3298
- })) {
3299
- vErrors =
3300
- vErrors === null
3301
- ? validate77.errors
3302
- : vErrors.concat(validate77.errors);
3303
- errors = vErrors.length;
3304
- }
3305
- var _valid0 = _errs4 === errors;
3306
- valid1 = valid1 || _valid0;
3307
- if (!valid1) {
3308
- const _errs5 = errors;
3309
- const _errs6 = errors;
3310
- if (errors === _errs6) {
3311
- if (typeof data0 === 'string') {
3312
- if (data0.length < 1) {
3313
- const err0 = {
3314
- params: {},
3315
- };
3316
- if (vErrors === null) {
3317
- vErrors = [err0];
3318
- }
3319
- else {
3320
- vErrors.push(err0);
3321
- }
3322
- errors++;
3323
- }
3324
- }
3325
- else {
3326
- const err1 = {
3327
- params: {
3328
- type: 'string',
3329
- },
3330
- };
3331
- if (vErrors === null) {
3332
- vErrors = [err1];
3333
- }
3334
- else {
3335
- vErrors.push(err1);
3336
- }
3337
- errors++;
3338
- }
3339
- }
3340
- var _valid0 = _errs5 === errors;
3341
- valid1 = valid1 || _valid0;
3342
- }
3343
- if (!valid1) {
3344
- const err2 = {
3345
- params: {},
3346
- };
3347
- if (vErrors === null) {
3348
- vErrors = [err2];
3349
- }
3350
- else {
3351
- vErrors.push(err2);
3352
- }
3353
- errors++;
3354
- validate76.errors = vErrors;
3355
- return false;
3356
- }
3357
- else {
3358
- errors = _errs3;
3359
- if (vErrors !== null) {
3360
- if (_errs3) {
3361
- vErrors.length = _errs3;
3362
- }
3363
- else {
3364
- vErrors = null;
3365
- }
3366
- }
3367
- }
3368
- var valid0 = _errs2 === errors;
3369
- if (!valid0) {
3370
- break;
3371
- }
3372
- }
3373
- }
3374
- else {
3375
- validate76.errors = [
3376
- {
3377
- params: {
3378
- type: 'object',
3379
- },
3380
- },
3381
- ];
3382
- return false;
3383
- }
3384
- }
3385
- validate76.errors = vErrors;
3386
- return errors === 0;
3387
- }
3388
- function validate75(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
3389
- let vErrors = null;
3390
- let errors = 0;
3391
- const _errs0 = errors;
3392
- let valid0 = false;
3393
- const _errs1 = errors;
3394
- if (errors === _errs1) {
3395
- if (Array.isArray(data)) {
3396
- var valid1 = true;
3397
- const len0 = data.length;
3398
- for (let i0 = 0; i0 < len0; i0++) {
3399
- let data0 = data[i0];
3400
- const _errs3 = errors;
3401
- const _errs4 = errors;
3402
- let valid2 = false;
3403
- const _errs5 = errors;
3404
- const _errs6 = errors;
3405
- if (errors === _errs6) {
3406
- if (typeof data0 === 'string') {
3407
- if (data0.length < 1) {
3408
- const err0 = {
3409
- params: {},
3410
- };
3411
- if (vErrors === null) {
3412
- vErrors = [err0];
3413
- }
3414
- else {
3415
- vErrors.push(err0);
3416
- }
3417
- errors++;
3418
- }
3419
- }
3420
- else {
3421
- const err1 = {
3422
- params: {
3423
- type: 'string',
3424
- },
3425
- };
3426
- if (vErrors === null) {
3427
- vErrors = [err1];
3428
- }
3429
- else {
3430
- vErrors.push(err1);
3431
- }
3432
- errors++;
3433
- }
3434
- }
3435
- var _valid1 = _errs5 === errors;
3436
- valid2 = valid2 || _valid1;
3437
- if (!valid2) {
3438
- const _errs8 = errors;
3439
- if (!validate76(data0, {
3440
- instancePath: instancePath + '/' + i0,
3441
- parentData: data,
3442
- parentDataProperty: i0,
3443
- rootData,
3444
- })) {
3445
- vErrors =
3446
- vErrors === null
3447
- ? validate76.errors
3448
- : vErrors.concat(validate76.errors);
3449
- errors = vErrors.length;
3450
- }
3451
- var _valid1 = _errs8 === errors;
3452
- valid2 = valid2 || _valid1;
3453
- }
3454
- if (!valid2) {
3455
- const err2 = {
3456
- params: {},
3457
- };
3458
- if (vErrors === null) {
3459
- vErrors = [err2];
3460
- }
3461
- else {
3462
- vErrors.push(err2);
3463
- }
3464
- errors++;
3465
- }
3466
- else {
3467
- errors = _errs4;
3468
- if (vErrors !== null) {
3469
- if (_errs4) {
3470
- vErrors.length = _errs4;
3471
- }
3472
- else {
3473
- vErrors = null;
3474
- }
3475
- }
3476
- }
3477
- var valid1 = _errs3 === errors;
3478
- if (!valid1) {
3479
- break;
3480
- }
3481
- }
3482
- }
3483
- else {
3484
- const err3 = {
3485
- params: {
3486
- type: 'array',
3487
- },
3488
- };
3489
- if (vErrors === null) {
3490
- vErrors = [err3];
3491
- }
3492
- else {
3493
- vErrors.push(err3);
3494
- }
3495
- errors++;
3496
- }
3497
- }
3498
- var _valid0 = _errs1 === errors;
3499
- valid0 = valid0 || _valid0;
3500
- if (!valid0) {
3501
- const _errs9 = errors;
3502
- if (!validate76(data, {
3503
- instancePath,
3504
- parentData,
3505
- parentDataProperty,
3506
- rootData,
3507
- })) {
3508
- vErrors =
3509
- vErrors === null
3510
- ? validate76.errors
3511
- : vErrors.concat(validate76.errors);
3512
- errors = vErrors.length;
3513
- }
3514
- var _valid0 = _errs9 === errors;
3515
- valid0 = valid0 || _valid0;
3516
- }
3517
- if (!valid0) {
3518
- const err4 = {
3519
- params: {},
3520
- };
3521
- if (vErrors === null) {
3522
- vErrors = [err4];
3523
- }
3524
- else {
3525
- vErrors.push(err4);
3526
- }
3527
- errors++;
3528
- validate75.errors = vErrors;
3529
- return false;
3530
- }
3531
- else {
3532
- errors = _errs0;
3533
- if (vErrors !== null) {
3534
- if (_errs0) {
3535
- vErrors.length = _errs0;
3536
- }
3537
- else {
3538
- vErrors = null;
3539
- }
3540
- }
3541
- }
3542
- validate75.errors = vErrors;
3543
- return errors === 0;
3544
- }
3545
- function validate48(data, { instancePath = '', parentData, parentDataProperty, rootData = data } = {}) {
3546
- /*# sourceURL="" */ let vErrors = null;
3547
- let errors = 0;
3548
- if (errors === 0) {
3549
- if (data && typeof data == 'object' && !Array.isArray(data)) {
3550
- const _errs1 = errors;
3551
- for (const key0 in data) {
3552
- if (!func2.call(schema51.properties, key0)) {
3553
- validate48.errors = [
3554
- {
3555
- params: {
3556
- additionalProperty: key0,
3557
- },
3558
- },
3559
- ];
3560
- return false;
3561
- break;
3562
- }
3563
- }
3564
- if (_errs1 === errors) {
3565
- if (data.exposes !== undefined) {
3566
- const _errs2 = errors;
3567
- if (!validate49(data.exposes, {
3568
- instancePath: instancePath + '/exposes',
3569
- parentData: data,
3570
- parentDataProperty: 'exposes',
3571
- rootData,
3572
- })) {
3573
- vErrors =
3574
- vErrors === null
3575
- ? validate49.errors
3576
- : vErrors.concat(validate49.errors);
3577
- errors = vErrors.length;
3578
- }
3579
- var valid0 = _errs2 === errors;
3580
- }
3581
- else {
3582
- var valid0 = true;
3583
- }
3584
- if (valid0) {
3585
- if (data.filename !== undefined) {
3586
- let data1 = data.filename;
3587
- const _errs3 = errors;
3588
- if (errors === _errs3) {
3589
- if (typeof data1 === 'string') {
3590
- if (data1.includes('!') ||
3591
- absolutePathRegExp.test(data1) !== false) {
3592
- validate48.errors = [
3593
- {
3594
- params: {},
3595
- },
3596
- ];
3597
- return false;
3598
- }
3599
- }
3600
- else {
3601
- validate48.errors = [
3602
- {
3603
- params: {
3604
- type: 'string',
3605
- },
3606
- },
3607
- ];
3608
- return false;
3609
- }
3610
- }
3611
- var valid0 = _errs3 === errors;
3612
- }
3613
- else {
3614
- var valid0 = true;
3615
- }
3616
- if (valid0) {
3617
- if (data.implementation !== undefined) {
3618
- let data2 = data.implementation;
3619
- const _errs5 = errors;
3620
- if (errors === _errs5) {
3621
- if (typeof data2 === 'string') {
3622
- if (data2.length < 1) {
3623
- validate48.errors = [
3624
- {
3625
- params: {},
3626
- },
3627
- ];
3628
- return false;
3629
- }
3630
- }
3631
- else {
3632
- validate48.errors = [
3633
- {
3634
- params: {
3635
- type: 'string',
3636
- },
3637
- },
3638
- ];
3639
- return false;
3640
- }
3641
- }
3642
- var valid0 = _errs5 === errors;
3643
- }
3644
- else {
3645
- var valid0 = true;
3646
- }
3647
- if (valid0) {
3648
- if (data.library !== undefined) {
3649
- const _errs7 = errors;
3650
- if (!validate59(data.library, {
3651
- instancePath: instancePath + '/library',
3652
- parentData: data,
3653
- parentDataProperty: 'library',
3654
- rootData,
3655
- })) {
3656
- vErrors =
3657
- vErrors === null
3658
- ? validate59.errors
3659
- : vErrors.concat(validate59.errors);
3660
- errors = vErrors.length;
3661
- }
3662
- var valid0 = _errs7 === errors;
3663
- }
3664
- else {
3665
- var valid0 = true;
3666
- }
3667
- if (valid0) {
3668
- if (data.name !== undefined) {
3669
- const _errs8 = errors;
3670
- if (typeof data.name !== 'string') {
3671
- validate48.errors = [
3672
- {
3673
- params: {
3674
- type: 'string',
3675
- },
3676
- },
3677
- ];
3678
- return false;
3679
- }
3680
- var valid0 = _errs8 === errors;
3681
- }
3682
- else {
3683
- var valid0 = true;
3684
- }
3685
- if (valid0) {
3686
- if (data.remoteType !== undefined) {
3687
- let data5 = data.remoteType;
3688
- const _errs10 = errors;
3689
- const _errs11 = errors;
3690
- let valid1 = false;
3691
- let passing0 = null;
3692
- const _errs12 = errors;
3693
- if (data5 !== 'var' &&
3694
- data5 !== 'module' &&
3695
- data5 !== 'assign' &&
3696
- data5 !== 'this' &&
3697
- data5 !== 'window' &&
3698
- data5 !== 'self' &&
3699
- data5 !== 'global' &&
3700
- data5 !== 'commonjs' &&
3701
- data5 !== 'commonjs2' &&
3702
- data5 !== 'commonjs-module' &&
3703
- data5 !== 'commonjs-static' &&
3704
- data5 !== 'amd' &&
3705
- data5 !== 'amd-require' &&
3706
- data5 !== 'umd' &&
3707
- data5 !== 'umd2' &&
3708
- data5 !== 'jsonp' &&
3709
- data5 !== 'system' &&
3710
- data5 !== 'promise' &&
3711
- data5 !== 'import' &&
3712
- data5 !== 'script' &&
3713
- data5 !== 'node-commonjs') {
3714
- const err0 = {
3715
- params: {},
3716
- };
3717
- if (vErrors === null) {
3718
- vErrors = [err0];
3719
- }
3720
- else {
3721
- vErrors.push(err0);
3722
- }
3723
- errors++;
3724
- }
3725
- var _valid0 = _errs12 === errors;
3726
- if (_valid0) {
3727
- valid1 = true;
3728
- passing0 = 0;
3729
- }
3730
- if (!valid1) {
3731
- const err1 = {
3732
- params: {
3733
- passingSchemas: passing0,
3734
- },
3735
- };
3736
- if (vErrors === null) {
3737
- vErrors = [err1];
3738
- }
3739
- else {
3740
- vErrors.push(err1);
3741
- }
3742
- errors++;
3743
- validate48.errors = vErrors;
3744
- return false;
3745
- }
3746
- else {
3747
- errors = _errs11;
3748
- if (vErrors !== null) {
3749
- if (_errs11) {
3750
- vErrors.length = _errs11;
3751
- }
3752
- else {
3753
- vErrors = null;
3754
- }
3755
- }
3756
- }
3757
- var valid0 = _errs10 === errors;
3758
- }
3759
- else {
3760
- var valid0 = true;
3761
- }
3762
- if (valid0) {
3763
- if (data.remotes !== undefined) {
3764
- const _errs14 = errors;
3765
- if (!validate65(data.remotes, {
3766
- instancePath: instancePath + '/remotes',
3767
- parentData: data,
3768
- parentDataProperty: 'remotes',
3769
- rootData,
3770
- })) {
3771
- vErrors =
3772
- vErrors === null
3773
- ? validate65.errors
3774
- : vErrors.concat(validate65.errors);
3775
- errors = vErrors.length;
3776
- }
3777
- var valid0 = _errs14 === errors;
3778
- }
3779
- else {
3780
- var valid0 = true;
3781
- }
3782
- if (valid0) {
3783
- if (data.runtime !== undefined) {
3784
- let data7 = data.runtime;
3785
- const _errs15 = errors;
3786
- const _errs17 = errors;
3787
- let valid4 = false;
3788
- const _errs18 = errors;
3789
- if (data7 !== false) {
3790
- const err2 = {
3791
- params: {},
3792
- };
3793
- if (vErrors === null) {
3794
- vErrors = [err2];
3795
- }
3796
- else {
3797
- vErrors.push(err2);
3798
- }
3799
- errors++;
3800
- }
3801
- var _valid1 = _errs18 === errors;
3802
- valid4 = valid4 || _valid1;
3803
- if (!valid4) {
3804
- const _errs19 = errors;
3805
- if (errors === _errs19) {
3806
- if (typeof data7 === 'string') {
3807
- if (data7.length < 1) {
3808
- const err3 = {
3809
- params: {},
3810
- };
3811
- if (vErrors === null) {
3812
- vErrors = [err3];
3813
- }
3814
- else {
3815
- vErrors.push(err3);
3816
- }
3817
- errors++;
3818
- }
3819
- }
3820
- else {
3821
- const err4 = {
3822
- params: {
3823
- type: 'string',
3824
- },
3825
- };
3826
- if (vErrors === null) {
3827
- vErrors = [err4];
3828
- }
3829
- else {
3830
- vErrors.push(err4);
3831
- }
3832
- errors++;
3833
- }
3834
- }
3835
- var _valid1 = _errs19 === errors;
3836
- valid4 = valid4 || _valid1;
3837
- }
3838
- if (!valid4) {
3839
- const err5 = {
3840
- params: {},
3841
- };
3842
- if (vErrors === null) {
3843
- vErrors = [err5];
3844
- }
3845
- else {
3846
- vErrors.push(err5);
3847
- }
3848
- errors++;
3849
- validate48.errors = vErrors;
3850
- return false;
3851
- }
3852
- else {
3853
- errors = _errs17;
3854
- if (vErrors !== null) {
3855
- if (_errs17) {
3856
- vErrors.length = _errs17;
3857
- }
3858
- else {
3859
- vErrors = null;
3860
- }
3861
- }
3862
- }
3863
- var valid0 = _errs15 === errors;
3864
- }
3865
- else {
3866
- var valid0 = true;
3867
- }
3868
- if (valid0) {
3869
- if (data.runtimePlugins !== undefined) {
3870
- let data8 = data.runtimePlugins;
3871
- const _errs21 = errors;
3872
- if (errors === _errs21) {
3873
- if (Array.isArray(data8)) {
3874
- var valid5 = true;
3875
- const len0 = data8.length;
3876
- for (let i0 = 0; i0 < len0; i0++) {
3877
- let data9 = data8[i0];
3878
- const _errs23 = errors;
3879
- if (errors === _errs23) {
3880
- if (typeof data9 === 'string') {
3881
- if (data9.length < 1) {
3882
- validate48.errors = [
3883
- {
3884
- params: {},
3885
- },
3886
- ];
3887
- return false;
3888
- }
3889
- }
3890
- else {
3891
- validate48.errors = [
3892
- {
3893
- params: {
3894
- type: 'string',
3895
- },
3896
- },
3897
- ];
3898
- return false;
3899
- }
3900
- }
3901
- var valid5 = _errs23 === errors;
3902
- if (!valid5) {
3903
- break;
3904
- }
3905
- }
3906
- }
3907
- else {
3908
- validate48.errors = [
3909
- {
3910
- params: {
3911
- type: 'array',
3912
- },
3913
- },
3914
- ];
3915
- return false;
3916
- }
3917
- }
3918
- var valid0 = _errs21 === errors;
3919
- }
3920
- else {
3921
- var valid0 = true;
3922
- }
3923
- if (valid0) {
3924
- if (data.shareScope !== undefined) {
3925
- let data10 = data.shareScope;
3926
- const _errs25 = errors;
3927
- if (errors === _errs25) {
3928
- if (typeof data10 === 'string') {
3929
- if (data10.length < 1) {
3930
- validate48.errors = [
3931
- {
3932
- params: {},
3933
- },
3934
- ];
3935
- return false;
3936
- }
3937
- }
3938
- else {
3939
- validate48.errors = [
3940
- {
3941
- params: {
3942
- type: 'string',
3943
- },
3944
- },
3945
- ];
3946
- return false;
3947
- }
3948
- }
3949
- var valid0 = _errs25 === errors;
3950
- }
3951
- else {
3952
- var valid0 = true;
3953
- }
3954
- if (valid0) {
3955
- if (data.shared !== undefined) {
3956
- const _errs27 = errors;
3957
- if (!validate75(data.shared, {
3958
- instancePath: instancePath + '/shared',
3959
- parentData: data,
3960
- parentDataProperty: 'shared',
3961
- rootData,
3962
- })) {
3963
- vErrors =
3964
- vErrors === null
3965
- ? validate75.errors
3966
- : vErrors.concat(validate75.errors);
3967
- errors = vErrors.length;
3968
- }
3969
- var valid0 = _errs27 === errors;
3970
- }
3971
- else {
3972
- var valid0 = true;
3973
- }
3974
- }
3975
- }
3976
- }
3977
- }
3978
- }
3979
- }
3980
- }
3981
- }
3982
- }
3983
- }
3984
- }
3985
- }
3986
- else {
3987
- validate48.errors = [
3988
- {
3989
- params: {
3990
- type: 'object',
3991
- },
3992
- },
3993
- ];
3994
- return false;
3995
- }
3996
- }
3997
- validate48.errors = vErrors;
3998
- return errors === 0;
3999
- }
4000
- exports.default = validate48;
4001
- //# sourceMappingURL=ModuleFederationPlugin.check.js.map