• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19434745916

17 Nov 2025 03:11PM UTC coverage: 99.427% (-0.6%) from 100.0%
19434745916

push

github

SignpostMarv
increasing coverage

639 of 649 branches covered (98.46%)

Branch coverage included in aggregate %.

9256 of 9303 relevant lines covered (99.49%)

210.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.6
/src/JSONSchema/Array.ts
1
import type {
19 ✔
2
        Expression,
19 ✔
3
        TypeNode,
19 ✔
4
} from 'typescript';
19 ✔
5
import {
19 ✔
6
        SyntaxKind,
19 ✔
7
} from 'typescript';
19 ✔
8

19 ✔
9
import type {
19 ✔
10
        SchemaDefinitionDefinitionWith$defs,
19 ✔
11
        SchemalessTypeOptions,
19 ✔
12
} from './Type.ts';
19 ✔
13
import {
19 ✔
14
        $defs_schema,
19 ✔
15
        Type,
19 ✔
16
} from './Type.ts';
19 ✔
17

19 ✔
18
import {
19 ✔
19
        PositiveIntegerGuard,
19 ✔
20
        PositiveIntegerOrZeroGuard,
19 ✔
21
// eslint-disable-next-line imports/no-relative-parent-imports
19 ✔
22
} from '../guarded.ts';
19 ✔
23

19 ✔
24
import type {
19 ✔
25
        ObjectOfSchemas,
19 ✔
26
        PositiveInteger,
19 ✔
27
        SchemaObject,
19 ✔
28
// eslint-disable-next-line imports/no-relative-parent-imports
19 ✔
29
} from '../types.ts';
19 ✔
30

19 ✔
31
import type {
19 ✔
32
        ArrayLiteralExpression,
19 ✔
33
        ArrayTypeNode,
19 ✔
34
        TupleTypeNode,
19 ✔
35
// eslint-disable-next-line imports/no-relative-parent-imports
19 ✔
36
} from '../typescript/types.ts';
19 ✔
37

19 ✔
38
import type {
19 ✔
39
        SchemaParser,
19 ✔
40
// eslint-disable-next-line imports/no-relative-parent-imports
19 ✔
41
} from '../SchemaParser.ts';
19 ✔
42

19 ✔
43
import {
19 ✔
44
        factory,
19 ✔
45
// eslint-disable-next-line imports/no-relative-parent-imports
19 ✔
46
} from '../typescript/factory.ts';
19 ✔
47

19 ✔
48
import {
19 ✔
49
        SchemaValidationError,
19 ✔
50
// eslint-disable-next-line imports/no-relative-parent-imports
19 ✔
51
} from '../SchemaValidationError.ts';
19 ✔
52

19 ✔
53
type array_mode = 'items'|'prefixItems';
19 ✔
54

19 ✔
55
type specified_mode = 'specified'|'unspecified';
19 ✔
56

19 ✔
57
type unique_items_mode = 'yes'|'no';
19 ✔
58

19 ✔
59
type MinItemsType_mode = 'with'|'optional';
19 ✔
60

19 ✔
61
type MinItemsType = ReturnType<typeof PositiveIntegerOrZeroGuard<number>>;
19 ✔
62
type MaxItemsType = ReturnType<typeof PositiveIntegerOrZeroGuard<number>>;
19 ✔
63

19 ✔
64
type array_options<
19 ✔
65
        ArrayMode extends array_mode = array_mode,
19 ✔
66
        SpecifiedMode extends specified_mode = specified_mode,
19 ✔
67
        UniqueItems_mode extends unique_items_mode = unique_items_mode,
19 ✔
68
        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,
19 ✔
69
        Items extends SchemaObject = SchemaObject,
19 ✔
70
        PrefixItems extends [
19 ✔
71
                SchemaObject,
19 ✔
72
                ...SchemaObject[],
19 ✔
73
        ] = [
19 ✔
74
                SchemaObject,
19 ✔
75
                ...SchemaObject[],
19 ✔
76
        ],
19 ✔
77
        T1 extends unknown[] = unknown[],
19 ✔
78
        T4 extends Expression = Expression,
19 ✔
79
        T5 extends T4[] = T4[],
19 ✔
80
> = (
19 ✔
81
        & {
19 ✔
82
                $defs?: ObjectOfSchemas,
19 ✔
83
                array_mode: ArrayMode,
19 ✔
84
                specified_mode: SpecifiedMode,
19 ✔
85
                unique_items_mode: UniqueItems_mode,
19 ✔
86
                min_items_mode: MinItems_mode,
19 ✔
87
                expression_at_index_verifier?: ExpressionAtIndexVerifier<T1, T4, T5>,
19 ✔
88
        }
19 ✔
89
        & (
19 ✔
90
                ArrayMode extends 'items'
19 ✔
91
                        ? (
19 ✔
92
                                SpecifiedMode extends 'specified'
19 ✔
93
                                        ? (
19 ✔
94
                                                MinItems_mode extends 'with'
19 ✔
95
                                                        ? {
19 ✔
96
                                                                minItems: MinItemsType,
19 ✔
97
                                                                maxItems?: MaxItemsType,
19 ✔
98
                                                        }
19 ✔
99
                                                        : {
19 ✔
100
                                                                minItems?: MinItemsType,
19 ✔
101
                                                                maxItems?: MaxItemsType,
19 ✔
102
                                                        }
19 ✔
103
                                        )
19 ✔
104
                                        : {
19 ✔
105
                                                minItems?: undefined,
19 ✔
106
                                                maxItems?: undefined,
19 ✔
107
                                        }
19 ✔
108
                        )
19 ✔
109
                        : (
19 ✔
110
                                SpecifiedMode extends 'specified'
19 ✔
111
                                        ? {
19 ✔
112
                                                minItems?: undefined,
19 ✔
113
                                                maxItems?: undefined,
19 ✔
114
                                        }
19 ✔
115
                                        : {
19 ✔
116
                                                minItems: MinItemsType,
19 ✔
117
                                                maxItems?: MaxItemsType,
19 ✔
118
                                        }
19 ✔
119
                        )
19 ✔
120
        )
19 ✔
121
        & (
19 ✔
122
                ArrayMode extends 'items'
19 ✔
123
                        ? (
19 ✔
124
                                SpecifiedMode extends 'specified'
19 ✔
125
                                        ? {
19 ✔
126
                                                items: Items,
19 ✔
127
                                        }
19 ✔
128
                                        : {
19 ✔
129
                                                items?: undefined,
19 ✔
130
                                        }
19 ✔
131
                        )
19 ✔
132
                        : (
19 ✔
133
                                SpecifiedMode extends 'specified'
19 ✔
134
                                        ? {
19 ✔
135
                                                items?: false,
19 ✔
136
                                                prefixItems: PrefixItems,
19 ✔
137
                                        }
19 ✔
138
                                        : {
19 ✔
139
                                                items?: undefined,
19 ✔
140
                                        }
19 ✔
141
                        )
19 ✔
142
        )
19 ✔
143
);
19 ✔
144

19 ✔
145
type ExpressionAtIndexVerifier<
19 ✔
146
        Data extends unknown[],
19 ✔
147
        T1 extends Expression,
19 ✔
148
        Result extends T1[],
19 ✔
149
        Index extends ReturnType<
19 ✔
150
                typeof PositiveIntegerOrZeroGuard<number>
19 ✔
151
        > = ReturnType<
19 ✔
152
                typeof PositiveIntegerOrZeroGuard<number>
19 ✔
153
        >,
19 ✔
154
> = (
19 ✔
155
        data: Data,
19 ✔
156
        expression: Expression,
19 ✔
157
        index: Index,
19 ✔
158
) => expression is Result[Index];
19 ✔
159

19 ✔
160
function expression_at_index_verifier_default<
116 ✔
161
        T extends unknown[],
116 ✔
162
        ArrayMode extends array_mode = array_mode,
116 ✔
163
        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,
116 ✔
164
        T4 extends Expression = Expression,
116 ✔
165
        T5 extends {
116 ✔
166
                items: {
116 ✔
167
                        with: [T4, ...T4[]],
116 ✔
168
                        optional: T4[],
116 ✔
169
                }[MinItems_mode],
116 ✔
170
                prefixItems: [T4, ...T4[]],
116 ✔
171
        }[ArrayMode] = {
116 ✔
172
                items: {
116 ✔
173
                        with: [T4, ...T4[]],
116 ✔
174
                        optional: T4[],
116 ✔
175
                }[MinItems_mode],
116 ✔
176
                prefixItems: [T4, ...T4[]],
116 ✔
177
        }[ArrayMode],
116 ✔
178
        Index extends ReturnType<
116 ✔
179
                typeof PositiveIntegerOrZeroGuard<number>
116 ✔
180
        > = ReturnType<
116 ✔
181
                typeof PositiveIntegerOrZeroGuard<number>
116 ✔
182
        >,
116 ✔
183
>(
116 ✔
184
        data: T,
116 ✔
185
        expression: Expression,
116 ✔
186
): expression is T5[Index] {
116 ✔
187
        return true;
116 ✔
188
}
116 ✔
189

19 ✔
190
type array_type<
19 ✔
191
        ArrayMode extends array_mode = array_mode,
19 ✔
192
        SpecifiedMode extends specified_mode = specified_mode,
19 ✔
193
        UniqueItems_mode extends unique_items_mode = unique_items_mode,
19 ✔
194
        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,
19 ✔
195
        Items extends SchemaObject = SchemaObject,
19 ✔
196
        PrefixItems extends [
19 ✔
197
                SchemaObject,
19 ✔
198
                ...SchemaObject[],
19 ✔
199
        ] = [
19 ✔
200
                SchemaObject,
19 ✔
201
                ...SchemaObject[],
19 ✔
202
        ],
19 ✔
203
> = (
19 ✔
204
        & {
19 ✔
205
                $schema?: 'https://json-schema.org/draft/2020-12/schema',
19 ✔
206
                $id?: Exclude<string, ''>,
19 ✔
207
                $defs?: ObjectOfSchemas,
19 ✔
208
                type: 'array',
19 ✔
209
                uniqueItems: {
19 ✔
210
                        yes: true,
19 ✔
211
                        no: false,
19 ✔
212
                }[UniqueItems_mode],
19 ✔
213
                items: (
19 ✔
214
                        & (
19 ✔
215
                                SpecifiedMode extends 'unspecified'
19 ✔
216
                                        ? (SchemaObject & {})
19 ✔
217
                                        : (
19 ✔
218
                                                ArrayMode extends 'items'
19 ✔
219
                                                        ? Items
19 ✔
220
                                                        : false
19 ✔
221
                                        )
19 ✔
222
                        )
19 ✔
223
                ),
19 ✔
224
        }
19 ✔
225
        & {
19 ✔
226
                items: {
19 ✔
227
                        specified: (
19 ✔
228
                                & {
19 ✔
229
                                        maxItems?: MaxItemsType,
19 ✔
230
                                }
19 ✔
231
                                & {
19 ✔
232
                                        with: {
19 ✔
233
                                                minItems: MinItemsType,
19 ✔
234
                                        },
19 ✔
235
                                        optional: {
19 ✔
236
                                                minItems?: MinItemsType,
19 ✔
237
                                        },
19 ✔
238
                                }[MinItems_mode]
19 ✔
239
                        ),
19 ✔
240
                        unspecified: (
19 ✔
241
                                & {
19 ✔
242
                                        maxItems?: MaxItemsType,
19 ✔
243
                                }
19 ✔
244
                                & {
19 ✔
245
                                        with: {
19 ✔
246
                                                minItems: MinItemsType,
19 ✔
247
                                        },
19 ✔
248
                                        optional: {
19 ✔
249
                                                minItems?: MinItemsType,
19 ✔
250
                                        },
19 ✔
251
                                }[MinItems_mode]
19 ✔
252
                        ),
19 ✔
253
                },
19 ✔
254
                prefixItems: {
19 ✔
255
                        specified: {
19 ✔
256
                                prefixItems: PrefixItems,
19 ✔
257
                                minItems: PositiveInteger<number>,
19 ✔
258
                        },
19 ✔
259
                        unspecified: {
19 ✔
260
                                prefixItems?: undefined,
19 ✔
261
                                minItems: PositiveInteger<number>,
19 ✔
262
                                maxItems?: MaxItemsType,
19 ✔
263
                        },
19 ✔
264
                },
19 ✔
265
        }[ArrayMode][SpecifiedMode]
19 ✔
266
);
19 ✔
267

19 ✔
268
type array_schema_properties<
19 ✔
269
        ArrayMode extends array_mode,
19 ✔
270
        SpecifiedMode extends specified_mode = specified_mode,
19 ✔
271
        UniqueItems_mode extends unique_items_mode = unique_items_mode,
19 ✔
272
        Items extends SchemaObject = SchemaObject,
19 ✔
273
        PrefixItems extends [
19 ✔
274
                SchemaObject,
19 ✔
275
                ...SchemaObject[],
19 ✔
276
        ] = [
19 ✔
277
                SchemaObject,
19 ✔
278
                ...SchemaObject[],
19 ✔
279
        ],
19 ✔
280
> = (
19 ✔
281
        & {
19 ✔
282
                $schema: {
19 ✔
283
                        type: 'string',
19 ✔
284
                        enum: [
19 ✔
285
                                'https://json-schema.org/draft/2020-12/schema',
19 ✔
286
                        ],
19 ✔
287
                },
19 ✔
288
                $id: {
19 ✔
289
                        type: 'string',
19 ✔
290
                        minLength: 1,
19 ✔
291
                },
19 ✔
292
                type: {
19 ✔
293
                        type: 'string',
19 ✔
294
                        const: 'array',
19 ✔
295
                },
19 ✔
296
                uniqueItems: {
19 ✔
297
                        type: 'boolean',
19 ✔
298
                        const: {
19 ✔
299
                                yes: true,
19 ✔
300
                                no: false,
19 ✔
301
                        }[UniqueItems_mode],
19 ✔
302
                },
19 ✔
303
        }
19 ✔
304
        & {
19 ✔
305
                items: {
19 ✔
306
                        items: {
19 ✔
307
                                specified: Items,
19 ✔
308
                                unspecified: {
19 ✔
309
                                        type: 'object',
19 ✔
310
                                        minProperties: 0,
19 ✔
311
                                },
19 ✔
312
                        }[SpecifiedMode],
19 ✔
313
                        minItems: {
19 ✔
314
                                type: 'integer',
19 ✔
315
                                minimum: 0,
19 ✔
316
                        },
19 ✔
317
                        maxItems: {
19 ✔
318
                                type: 'integer',
19 ✔
319
                                minimum: 0,
19 ✔
320
                        },
19 ✔
321
                },
19 ✔
322
                prefixItems: {
19 ✔
323
                        specified: {
19 ✔
324
                                items: {
19 ✔
325
                                        type: 'boolean',
19 ✔
326
                                        const: false,
19 ✔
327
                                },
19 ✔
328
                                prefixItems: {
19 ✔
329
                                        type: 'array',
19 ✔
330
                                        const: PrefixItems,
19 ✔
331
                                },
19 ✔
332
                        },
19 ✔
333
                        unspecified: {
19 ✔
334
                                items: {
19 ✔
335
                                        type: 'boolean',
19 ✔
336
                                        const: false,
19 ✔
337
                                },
19 ✔
338
                                prefixItems: {
19 ✔
339
                                        type: 'array',
19 ✔
340
                                        minItems: 1,
19 ✔
341
                                        items: {
19 ✔
342
                                                type: 'object',
19 ✔
343
                                                minProperties: 1,
19 ✔
344
                                        },
19 ✔
345
                                },
19 ✔
346
                        },
19 ✔
347
                }[SpecifiedMode],
19 ✔
348
        }[ArrayMode]
19 ✔
349
);
19 ✔
350

19 ✔
351
type array_schema<
19 ✔
352
        ArrayMode extends array_mode = array_mode,
19 ✔
353
        SpecifiedMode extends specified_mode = specified_mode,
19 ✔
354
        UniqueItems_mode extends unique_items_mode = unique_items_mode,
19 ✔
355
        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,
19 ✔
356
        Items extends SchemaObject = SchemaObject,
19 ✔
357
        PrefixItems extends [
19 ✔
358
                SchemaObject,
19 ✔
359
                ...SchemaObject[],
19 ✔
360
        ] = [
19 ✔
361
                SchemaObject,
19 ✔
362
                ...SchemaObject[],
19 ✔
363
        ],
19 ✔
364
> = SchemaDefinitionDefinitionWith$defs<
19 ✔
365
        {
19 ✔
366
                items: {
19 ✔
367
                        with: {
19 ✔
368
                                yes: [
19 ✔
369
                                        'type',
19 ✔
370
                                        'items',
19 ✔
371
                                        'minItems',
19 ✔
372
                                        'uniqueItems',
19 ✔
373
                                ],
19 ✔
374
                                no: [
19 ✔
375
                                        'type',
19 ✔
376
                                        'items',
19 ✔
377
                                        'minItems',
19 ✔
378
                                ],
19 ✔
379
                        }[UniqueItems_mode],
19 ✔
380
                        optional: {
19 ✔
381
                                yes: [
19 ✔
382
                                        'type',
19 ✔
383
                                        'items',
19 ✔
384
                                        'uniqueItems',
19 ✔
385
                                ],
19 ✔
386
                                no: [
19 ✔
387
                                        'type',
19 ✔
388
                                        'items',
19 ✔
389
                                ],
19 ✔
390
                        }[UniqueItems_mode],
19 ✔
391
                }[MinItems_mode],
19 ✔
392
                prefixItems: {
19 ✔
393
                        specified: {
19 ✔
394
                                yes: [
19 ✔
395
                                        'type',
19 ✔
396
                                        'items',
19 ✔
397
                                        'prefixItems',
19 ✔
398
                                        'uniqueItems',
19 ✔
399
                                ],
19 ✔
400
                                no: [
19 ✔
401
                                        'type',
19 ✔
402
                                        'items',
19 ✔
403
                                        'prefixItems',
19 ✔
404
                                ],
19 ✔
405
                        }[UniqueItems_mode],
19 ✔
406
                        unspecified: {
19 ✔
407
                                yes: [
19 ✔
408
                                        'type',
19 ✔
409
                                        'items',
19 ✔
410
                                        'prefixItems',
19 ✔
411
                                        'uniqueItems',
19 ✔
412
                                ],
19 ✔
413
                                no: [
19 ✔
414
                                        'type',
19 ✔
415
                                        'items',
19 ✔
416
                                        'prefixItems',
19 ✔
417
                                ],
19 ✔
418
                        }[UniqueItems_mode],
19 ✔
419
                }[SpecifiedMode],
19 ✔
420
        }[ArrayMode],
19 ✔
421
        ObjectOfSchemas & array_schema_properties<
19 ✔
422
                ArrayMode,
19 ✔
423
                SpecifiedMode,
19 ✔
424
                UniqueItems_mode,
19 ✔
425
                Items,
19 ✔
426
                PrefixItems
19 ✔
427
        >
19 ✔
428
>;
19 ✔
429

19 ✔
430
class ArrayType<
19 ✔
431
        ArrayMode extends array_mode = array_mode,
19 ✔
432
        SpecifiedMode extends specified_mode = specified_mode,
19 ✔
433
        UniqueItems_mode extends unique_items_mode = unique_items_mode,
19 ✔
434
        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,
19 ✔
435
        Items extends SchemaObject = SchemaObject,
19 ✔
436
        PrefixItems extends [
19 ✔
437
                SchemaObject,
19 ✔
438
                ...SchemaObject[],
19 ✔
439
        ] = [
19 ✔
440
                SchemaObject,
19 ✔
441
                ...SchemaObject[],
19 ✔
442
        ],
19 ✔
443
        T1 extends {
19 ✔
444
                items: unknown[],
19 ✔
445
                prefixItems: [unknown, ...unknown[]],
19 ✔
446
        }[ArrayMode] = {
19 ✔
447
                items: unknown[],
19 ✔
448
                prefixItems: [unknown, ...unknown[]],
19 ✔
449
        }[ArrayMode],
19 ✔
450
        T2 extends TypeNode = TypeNode,
19 ✔
451
        T3 extends [T2, ...T2[]] = [T2, ...T2[]],
19 ✔
452
        T4 extends Expression = Expression,
19 ✔
453
        T5 extends {
19 ✔
454
                items: {
19 ✔
455
                        with: [T4, ...T4[]],
19 ✔
456
                        optional: T4[],
19 ✔
457
                }[MinItems_mode],
19 ✔
458
                prefixItems: [T4, ...T4[]],
19 ✔
459
        }[ArrayMode] = {
19 ✔
460
                items: {
19 ✔
461
                        with: [T4, ...T4[]],
19 ✔
462
                        optional: T4[],
19 ✔
463
                }[MinItems_mode],
19 ✔
464
                prefixItems: [T4, ...T4[]],
19 ✔
465
        }[ArrayMode],
19 ✔
466
> extends
19 ✔
467
        Type<
19 ✔
468
                T1,
19 ✔
469
                array_type<
19 ✔
470
                        ArrayMode,
19 ✔
471
                        SpecifiedMode,
19 ✔
472
                        UniqueItems_mode,
19 ✔
473
                        MinItems_mode,
19 ✔
474
                        Items,
19 ✔
475
                        PrefixItems
19 ✔
476
                >,
19 ✔
477
                array_options<
19 ✔
478
                        ArrayMode,
19 ✔
479
                        SpecifiedMode,
19 ✔
480
                        UniqueItems_mode,
19 ✔
481
                        MinItems_mode,
19 ✔
482
                        Items,
19 ✔
483
                        PrefixItems
19 ✔
484
                >,
19 ✔
485
                array_schema<
19 ✔
486
                        ArrayMode,
19 ✔
487
                        SpecifiedMode,
19 ✔
488
                        UniqueItems_mode,
19 ✔
489
                        MinItems_mode
19 ✔
490
                >,
19 ✔
491
                array_options<
19 ✔
492
                        ArrayMode,
19 ✔
493
                        SpecifiedMode,
19 ✔
494
                        UniqueItems_mode,
19 ✔
495
                        MinItems_mode,
19 ✔
496
                        Items,
19 ✔
497
                        PrefixItems
19 ✔
498
                >,
19 ✔
499
                {
19 ✔
500
                        items: {
19 ✔
501
                                with: TupleTypeNode<T2, T3>,
19 ✔
502
                                optional: ArrayTypeNode<T2>,
19 ✔
503
                        }[MinItems_mode],
19 ✔
504
                        prefixItems: TupleTypeNode<T2, T3>,
19 ✔
505
                }[ArrayMode],
19 ✔
506
                ArrayLiteralExpression<T4, T5, true>
19 ✔
507
        > {
19 ✔
508
        #expression_at_index_verifier: ExpressionAtIndexVerifier<T1, T4, T5>;
19 ✔
509

19 ✔
510
        constructor(
19 ✔
511
                options: SchemalessTypeOptions,
1,310 ✔
512
                {
1,310 ✔
513
                        array_options,
1,310 ✔
514
                        // eslint-disable-next-line @stylistic/max-len
1,310 ✔
515
                        expression_at_index_verifier = expression_at_index_verifier_default<
1,310 ✔
516
                                T1,
1,310 ✔
517
                                ArrayMode,
1,310 ✔
518
                                MinItems_mode,
1,310 ✔
519
                                T4,
1,310 ✔
520
                                T5
1,310 ✔
521
                        >,
1,310 ✔
522
                }: {
1,310 ✔
523
                        array_options: array_options<
1,310 ✔
524
                                ArrayMode,
1,310 ✔
525
                                SpecifiedMode,
1,310 ✔
526
                                UniqueItems_mode,
1,310 ✔
527
                                MinItems_mode,
1,310 ✔
528
                                Items,
1,310 ✔
529
                                PrefixItems
1,310 ✔
530
                        >,
1,310 ✔
531
                        expression_at_index_verifier?: ExpressionAtIndexVerifier<
1,310 ✔
532
                                T1,
1,310 ✔
533
                                T4,
1,310 ✔
534
                                T5
1,310 ✔
535
                        >,
1,310 ✔
536
                },
1,310 ✔
537
        ) {
1,310 ✔
538
                super({
1,310 ✔
539
                        ...options,
1,310 ✔
540
                        type_definition: array_options,
1,310 ✔
541
                        schema_definition: array_options,
1,310 ✔
542
                });
1,310 ✔
543

1,310 ✔
544
                this.#expression_at_index_verifier = expression_at_index_verifier;
1,310 ✔
545
        }
1,310 ✔
546

19 ✔
547
        generate_typescript_data(
19 ✔
548
                data: T1,
50 ✔
549
                schema_parser: SchemaParser,
50 ✔
550
                schema: array_type<
50 ✔
551
                        ArrayMode,
50 ✔
552
                        SpecifiedMode,
50 ✔
553
                        UniqueItems_mode,
50 ✔
554
                        MinItems_mode,
50 ✔
555
                        Items,
50 ✔
556
                        PrefixItems
50 ✔
557
                >,
50 ✔
558
        ): ArrayLiteralExpression<T4, T5, true> {
50 ✔
559
                if (!(this.check_type(data))) {
50 ✔
560
                        throw new TypeError('data does not pass type check!');
1 ✔
561
                }
1 ✔
562

49 ✔
563
                return factory.createArrayLiteralExpression(
49 ✔
564
                        data.map((value, i): T4 => {
49 ✔
565
                                const index = PositiveIntegerOrZeroGuard(i);
120 ✔
566
                                const element = ArrayType.#convert(
120 ✔
567
                                        value,
120 ✔
568
                                        index,
120 ✔
569
                                        schema,
120 ✔
570
                                        schema_parser,
120 ✔
571
                                );
120 ✔
572

120 ✔
573
                                if (!(this.#expression_at_index_verifier(
120 ✔
574
                                        data,
120 ✔
575
                                        element,
120 ✔
576
                                        index,
120 ✔
577
                                ))) {
120 ✔
578
                                        throw new TypeError(
2 ✔
579
                                                `Element at index ${
2 ✔
580
                                                        index
2 ✔
581
                                                } was not of expected type!`,
2 ✔
582
                                        );
2 ✔
583
                                }
2 ✔
584

116 ✔
585
                                return element;
116 ✔
586
                        }),
49 ✔
587
                        true,
49 ✔
588
                );
49 ✔
589
        }
50 ✔
590

19 ✔
591
        generate_typescript_type({
19 ✔
592
                data,
105 ✔
593
                schema,
105 ✔
594
                schema_parser,
105 ✔
595
        }: {
105 ✔
596
                data: T1,
105 ✔
597
                schema: array_type<
105 ✔
598
                        ArrayMode,
105 ✔
599
                        SpecifiedMode,
105 ✔
600
                        UniqueItems_mode,
105 ✔
601
                        MinItems_mode,
105 ✔
602
                        Items,
105 ✔
603
                        PrefixItems
105 ✔
604
                >,
105 ✔
605
                schema_parser: SchemaParser,
105 ✔
606
        }): Promise<{
105 ✔
607
                items: {
105 ✔
608
                        with: TupleTypeNode<T2, T3>,
105 ✔
609
                        optional: ArrayTypeNode<T2>,
105 ✔
610
                }[MinItems_mode],
105 ✔
611
                prefixItems: TupleTypeNode<T2, T3>,
105 ✔
612
        }[ArrayMode]> {
105 ✔
613
                let result: Promise<{
105 ✔
614
                        items: {
105 ✔
615
                                with: TupleTypeNode<T2, T3>,
105 ✔
616
                                optional: ArrayTypeNode<T2>,
105 ✔
617
                        }[MinItems_mode],
105 ✔
618
                        prefixItems: TupleTypeNode<T2, T3>,
105 ✔
619
                }[ArrayMode]>;
105 ✔
620

105 ✔
621
                if (!ArrayType.#is_items_type_schema(schema)) {
105 ✔
622
                        const sanity_check: Promise<
68 ✔
623
                                TupleTypeNode<T2, T3>
68 ✔
624
                        > = ArrayType.#generate_typescript_type_has_prefixItems(
68 ✔
625
                                data,
68 ✔
626
                                schema as array_type<
68 ✔
627
                                        'prefixItems',
68 ✔
628
                                        'specified'
68 ✔
629
                                >,
68 ✔
630
                                schema_parser,
68 ✔
631
                        );
68 ✔
632

68 ✔
633
                        result = sanity_check as typeof result;
68 ✔
634
                } else {
105 ✔
635
                        const sanity_check: Promise<{
37 ✔
636
                                items: {
37 ✔
637
                                        with: TupleTypeNode<T2, T3>,
37 ✔
638
                                        optional: ArrayTypeNode<T2>,
37 ✔
639
                                }[MinItems_mode],
37 ✔
640
                                prefixItems: TupleTypeNode<T2, T3>,
37 ✔
641
                        }[ArrayMode]> = ArrayType.#generate_typescript_type_has_items(
37 ✔
642
                                data,
37 ✔
643
                                schema,
37 ✔
644
                                schema_parser,
37 ✔
645
                        );
37 ✔
646

37 ✔
647
                        result = sanity_check as unknown as typeof result;
37 ✔
648
                }
37 ✔
649

105 ✔
650
                return result;
105 ✔
651
        }
105 ✔
652

19 ✔
653
        static generate_schema_definition<
19 ✔
654
                ArrayMode extends array_mode,
1,310 ✔
655
                SpecifiedMode extends specified_mode,
1,310 ✔
656
                UniqueItems_mode extends unique_items_mode,
1,310 ✔
657
                MinItems_mode extends MinItemsType_mode,
1,310 ✔
658
                Items extends SchemaObject,
1,310 ✔
659
                PrefixItems extends [
1,310 ✔
660
                        SchemaObject,
1,310 ✔
661
                        ...SchemaObject[],
1,310 ✔
662
                ],
1,310 ✔
663
        >(
1,310 ✔
664
                options: array_options<
1,310 ✔
665
                        ArrayMode,
1,310 ✔
666
                        SpecifiedMode,
1,310 ✔
667
                        UniqueItems_mode,
1,310 ✔
668
                        MinItems_mode,
1,310 ✔
669
                        Items,
1,310 ✔
670
                        PrefixItems
1,310 ✔
671
                >,
1,310 ✔
672
        ): Readonly<array_schema<
1,310 ✔
673
                ArrayMode,
1,310 ✔
674
                SpecifiedMode,
1,310 ✔
675
                UniqueItems_mode,
1,310 ✔
676
                MinItems_mode,
1,310 ✔
677
                Items,
1,310 ✔
678
                PrefixItems
1,310 ✔
679
        >> {
1,310 ✔
680
                const required: array_schema<
1,310 ✔
681
                        ArrayMode,
1,310 ✔
682
                        SpecifiedMode,
1,310 ✔
683
                        UniqueItems_mode,
1,310 ✔
684
                        MinItems_mode,
1,310 ✔
685
                        Items,
1,310 ✔
686
                        PrefixItems
1,310 ✔
687
                >['required'] = this.#generate_schema_definition_required(
1,310 ✔
688
                        options,
1,310 ✔
689
                );
1,310 ✔
690

1,310 ✔
691
                const properties: array_schema<
1,310 ✔
692
                        ArrayMode,
1,310 ✔
693
                        SpecifiedMode,
1,310 ✔
694
                        UniqueItems_mode,
1,310 ✔
695
                        MinItems_mode,
1,310 ✔
696
                        Items,
1,310 ✔
697
                        PrefixItems
1,310 ✔
698
                >['properties'] = this.#generate_schema_definition_properties(
1,310 ✔
699
                        options,
1,310 ✔
700
                );
1,310 ✔
701

1,310 ✔
702
                const result: array_schema<
1,310 ✔
703
                        ArrayMode,
1,310 ✔
704
                        SpecifiedMode,
1,310 ✔
705
                        UniqueItems_mode,
1,310 ✔
706
                        MinItems_mode,
1,310 ✔
707
                        Items,
1,310 ✔
708
                        PrefixItems
1,310 ✔
709
                > = {
1,310 ✔
710
                        type: 'object',
1,310 ✔
711
                        additionalProperties: false,
1,310 ✔
712
                        required,
1,310 ✔
713
                        properties,
1,310 ✔
714
                };
1,310 ✔
715

1,310 ✔
716
                if (options.$defs) {
1,310 ✔
717
                        result.$defs = options.$defs;
4 ✔
718
                }
4 ✔
719

1,310 ✔
720
                return Object.freeze(result);
1,310 ✔
721
        }
1,310 ✔
722

19 ✔
723
        static generate_type_definition<
19 ✔
724
                ArrayMode extends array_mode,
1,310 ✔
725
                SpecifiedMode extends specified_mode,
1,310 ✔
726
                UniqueItems_mode extends unique_items_mode,
1,310 ✔
727
                MinItems_mode extends MinItemsType_mode,
1,310 ✔
728
                Items extends SchemaObject,
1,310 ✔
729
                PrefixItems extends [
1,310 ✔
730
                        SchemaObject,
1,310 ✔
731
                        ...SchemaObject[],
1,310 ✔
732
                ],
1,310 ✔
733
        >(
1,310 ✔
734
                options: array_options<
1,310 ✔
735
                        ArrayMode,
1,310 ✔
736
                        SpecifiedMode,
1,310 ✔
737
                        UniqueItems_mode,
1,310 ✔
738
                        MinItems_mode,
1,310 ✔
739
                        Items,
1,310 ✔
740
                        PrefixItems
1,310 ✔
741
                >,
1,310 ✔
742
        ): Readonly<array_type<
1,310 ✔
743
                ArrayMode,
1,310 ✔
744
                SpecifiedMode,
1,310 ✔
745
                UniqueItems_mode,
1,310 ✔
746
                MinItems_mode,
1,310 ✔
747
                Items,
1,310 ✔
748
                PrefixItems
1,310 ✔
749
        >> {
1,310 ✔
750
                let result: array_type<
1,310 ✔
751
                        ArrayMode,
1,310 ✔
752
                        SpecifiedMode,
1,310 ✔
753
                        UniqueItems_mode,
1,310 ✔
754
                        MinItems_mode,
1,310 ✔
755
                        Items,
1,310 ✔
756
                        PrefixItems
1,310 ✔
757
                >;
1,310 ✔
758

1,310 ✔
759
                if ('items' === options.array_mode) {
1,310 ✔
760
                        if (options.items) {
648 ✔
761
                                const sanity_check: array_type<
17 ✔
762
                                        'items',
17 ✔
763
                                        'specified',
17 ✔
764
                                        unique_items_mode,
17 ✔
765
                                        'optional',
17 ✔
766
                                        Items,
17 ✔
767
                                        [SchemaObject, ...SchemaObject[]]
17 ✔
768
                                > = {
17 ✔
769
                                        type: 'array',
17 ✔
770
                                        items: options.items,
17 ✔
771
                                        uniqueItems: 'yes' === options.unique_items_mode,
17 ✔
772
                                };
17 ✔
773

17 ✔
774
                                if ('number' === typeof options.minItems) {
17 ✔
775
                                        sanity_check.minItems = options.minItems;
6 ✔
776
                                }
6 ✔
777

17 ✔
778
                                if ('number' === typeof options.maxItems) {
17 ✔
779
                                        sanity_check.maxItems = options.maxItems;
6 ✔
780
                                }
6 ✔
781

17 ✔
782
                                result = sanity_check as typeof result;
17 ✔
783
                        } else {
648 ✔
784
                                const sanity_check: array_type<
631 ✔
785
                                        'items',
631 ✔
786
                                        'unspecified',
631 ✔
787
                                        unique_items_mode,
631 ✔
788
                                        'optional',
631 ✔
789
                                        Items,
631 ✔
790
                                        [SchemaObject, ...SchemaObject[]]
631 ✔
791
                                > = {
631 ✔
792
                                        type: 'array',
631 ✔
793
                                        items: {},
631 ✔
794
                                        uniqueItems: 'yes' === options.unique_items_mode,
631 ✔
795
                                };
631 ✔
796

631 ✔
797
                                if ('number' === typeof options.minItems) {
631 ✔
798
                                        sanity_check.minItems = options.minItems;
36 ✔
799
                                }
36 ✔
800

631 ✔
801
                                if ('number' === typeof options.maxItems) {
631 ✔
802
                                        sanity_check.maxItems = options.maxItems;
36 ✔
803
                                }
36 ✔
804

631 ✔
805
                                result = sanity_check as typeof result;
631 ✔
806
                        }
631 ✔
807
                } else {
1,310 ✔
808
                        let uniqueItems: array_type<
662 ✔
809
                                'prefixItems',
662 ✔
810
                                specified_mode,
662 ✔
811
                                UniqueItems_mode,
662 ✔
812
                                MinItemsType_mode,
662 ✔
813
                                SchemaObject,
662 ✔
814
                                PrefixItems
662 ✔
815
                        >['uniqueItems'];
662 ✔
816

662 ✔
817
                        if ('yes' === options.unique_items_mode) {
662 ✔
818
                                const sanity_check: array_type<
360 ✔
819
                                        'prefixItems',
360 ✔
820
                                        specified_mode,
360 ✔
821
                                        'yes',
360 ✔
822
                                        MinItemsType_mode,
360 ✔
823
                                        SchemaObject,
360 ✔
824
                                        PrefixItems
360 ✔
825
                                >['uniqueItems'] = true;
360 ✔
826

360 ✔
827
                                uniqueItems = sanity_check as typeof uniqueItems;
360 ✔
828
                        } else {
491 ✔
829
                                const sanity_check: array_type<
302 ✔
830
                                        'prefixItems',
302 ✔
831
                                        specified_mode,
302 ✔
832
                                        'no',
302 ✔
833
                                        MinItemsType_mode,
302 ✔
834
                                        SchemaObject,
302 ✔
835
                                        PrefixItems
302 ✔
836
                                >['uniqueItems'] = false;
302 ✔
837

302 ✔
838
                                uniqueItems = sanity_check as typeof uniqueItems;
302 ✔
839
                        }
302 ✔
840

662 ✔
841

662 ✔
842
                        if (this.#is_specified_prefixItems_options(options)) {
662 ✔
843
                                const sanity_check: array_type<
64 ✔
844
                                        'prefixItems',
64 ✔
845
                                        'specified',
64 ✔
846
                                        UniqueItems_mode,
64 ✔
847
                                        MinItemsType_mode,
64 ✔
848
                                        SchemaObject,
64 ✔
849
                                        PrefixItems
64 ✔
850
                                > = {
64 ✔
851
                                        type: 'array',
64 ✔
852
                                        items: false,
64 ✔
853
                                        prefixItems: options.prefixItems,
64 ✔
854
                                        minItems: PositiveIntegerGuard(options.prefixItems.length),
64 ✔
855
                                        uniqueItems,
64 ✔
856
                                };
64 ✔
857

64 ✔
858
                                result = sanity_check as unknown as typeof result;
64 ✔
859
                        } else {
662 ✔
860
                                const sanity_check: array_type<
598 ✔
861
                                        'prefixItems',
598 ✔
862
                                        'unspecified',
598 ✔
863
                                        unique_items_mode,
598 ✔
864
                                        'optional',
598 ✔
865
                                        SchemaObject,
598 ✔
866
                                        PrefixItems
598 ✔
867
                                > = {
598 ✔
868
                                        type: 'array',
598 ✔
869
                                        uniqueItems: 'yes' === options.unique_items_mode,
598 ✔
870
                                        items: {},
598 ✔
871
                                        minItems: PositiveIntegerGuard(1),
598 ✔
872
                                };
598 ✔
873

598 ✔
874
                                if (options.minItems) {
598 ✔
875
                                        sanity_check.minItems = options.minItems;
594 ✔
876
                                }
594 ✔
877

598 ✔
878
                                if ('number' === typeof options.maxItems) {
598 ✔
879
                                        sanity_check.maxItems = options.maxItems;
2 ✔
880
                                }
2 ✔
881

598 ✔
882
                                result = sanity_check as typeof result;
598 ✔
883
                        }
598 ✔
884
                }
662 ✔
885

1,310 ✔
886
                if (options.$defs) {
1,310 ✔
887
                        result.$defs = options.$defs;
4 ✔
888
                }
4 ✔
889

1,310 ✔
890
                return Object.freeze<array_type<
1,310 ✔
891
                        ArrayMode,
1,310 ✔
892
                        SpecifiedMode,
1,310 ✔
893
                        UniqueItems_mode,
1,310 ✔
894
                        MinItems_mode,
1,310 ✔
895
                        Items,
1,310 ✔
896
                        PrefixItems
1,310 ✔
897
                >>(result);
1,310 ✔
898
        }
1,310 ✔
899

19 ✔
900
        static #convert<
19 ✔
901
                ArrayMode extends array_mode,
120 ✔
902
                SpecifiedMode extends specified_mode,
120 ✔
903
                UniqueItems_mode extends unique_items_mode,
120 ✔
904
                MinItems_mode extends MinItemsType_mode,
120 ✔
905
                Items extends SchemaObject,
120 ✔
906
                PrefixItems extends [
120 ✔
907
                        SchemaObject,
120 ✔
908
                        ...SchemaObject[],
120 ✔
909
                ],
120 ✔
910
                N extends number = number,
120 ✔
911
        >(
120 ✔
912
                value: unknown,
120 ✔
913
                index: ReturnType<typeof PositiveIntegerOrZeroGuard<N>>,
120 ✔
914
                schema: array_type<
120 ✔
915
                        ArrayMode,
120 ✔
916
                        SpecifiedMode,
120 ✔
917
                        UniqueItems_mode,
120 ✔
918
                        MinItems_mode,
120 ✔
919
                        Items,
120 ✔
920
                        PrefixItems
120 ✔
921
                >,
120 ✔
922
                schema_parser: SchemaParser,
120 ✔
923
        ): Expression {
120 ✔
924
                const sub_schema = ArrayType.maybe_add_$defs(
120 ✔
925
                        schema,
120 ✔
926
                        this.#sub_schema_for_value(
120 ✔
927
                                index,
120 ✔
928
                                schema,
120 ✔
929
                        ),
120 ✔
930
                );
120 ✔
931
                const ajv = schema_parser.share_ajv((ajv) => ajv);
120 ✔
932
                const validator = ajv.compile(sub_schema);
120 ✔
933

120 ✔
934
                const validates = validator(value);
120 ✔
935

120 ✔
936
                if (!validates) {
120 ✔
937
                        throw new SchemaValidationError(
1 ✔
938
                                'Supplied value not supported by index!',
1 ✔
939
                                validator,
1 ✔
940
                        );
1 ✔
941
                }
1 ✔
942

118 ✔
943
                const matched_type = Object.keys(sub_schema).length > 0
118 ✔
944
                        ? schema_parser.parse(
120 ✔
945
                                sub_schema,
96 ✔
946
                        )
96 ✔
947
                        : schema_parser.parse_by_type(value);
120 ✔
948

120 ✔
949
                return matched_type.generate_typescript_data(
120 ✔
950
                        value,
120 ✔
951
                        schema_parser,
120 ✔
952
                        sub_schema,
120 ✔
953
                );
120 ✔
954
        }
120 ✔
955

19 ✔
956
        static #generate_schema_definition_properties<
19 ✔
957
                ArrayMode extends array_mode,
1,310 ✔
958
                SpecifiedMode extends specified_mode,
1,310 ✔
959
                UniqueItems_mode extends unique_items_mode,
1,310 ✔
960
                MinItems_mode extends MinItemsType_mode,
1,310 ✔
961
                Items extends SchemaObject,
1,310 ✔
962
                PrefixItems extends [
1,310 ✔
963
                        SchemaObject,
1,310 ✔
964
                        ...SchemaObject[],
1,310 ✔
965
                ],
1,310 ✔
966
        >(
1,310 ✔
967
                options: array_options<
1,310 ✔
968
                        ArrayMode,
1,310 ✔
969
                        SpecifiedMode,
1,310 ✔
970
                        UniqueItems_mode,
1,310 ✔
971
                        MinItems_mode,
1,310 ✔
972
                        Items,
1,310 ✔
973
                        PrefixItems
1,310 ✔
974
                >,
1,310 ✔
975
        ): array_schema<
1,310 ✔
976
                ArrayMode,
1,310 ✔
977
                SpecifiedMode,
1,310 ✔
978
                UniqueItems_mode,
1,310 ✔
979
                MinItems_mode,
1,310 ✔
980
                Items,
1,310 ✔
981
                PrefixItems
1,310 ✔
982
        >['properties'] {
1,310 ✔
983
                let result: array_schema<
1,310 ✔
984
                        ArrayMode,
1,310 ✔
985
                        SpecifiedMode,
1,310 ✔
986
                        UniqueItems_mode,
1,310 ✔
987
                        MinItems_mode,
1,310 ✔
988
                        Items,
1,310 ✔
989
                        PrefixItems
1,310 ✔
990
                >['properties'];
1,310 ✔
991

1,310 ✔
992
                if ('items' === options.array_mode) {
1,310 ✔
993
                        const sanity_check: array_schema<
648 ✔
994
                                'items',
648 ✔
995
                                SpecifiedMode,
648 ✔
996
                                UniqueItems_mode,
648 ✔
997
                                MinItems_mode,
648 ✔
998
                                Items,
648 ✔
999
                                [SchemaObject, ...SchemaObject[]]
648 ✔
1000
                        >[
648 ✔
1001
                                'properties'
648 ✔
1002
                        ] = this.#generate_schema_definition_properties_items(
648 ✔
1003
                                options as array_options<
648 ✔
1004
                                        'items',
648 ✔
1005
                                        SpecifiedMode,
648 ✔
1006
                                        UniqueItems_mode,
648 ✔
1007
                                        MinItems_mode,
648 ✔
1008
                                        Items,
648 ✔
1009
                                        [SchemaObject, ...SchemaObject[]]
648 ✔
1010
                                >,
648 ✔
1011
                        );
648 ✔
1012

648 ✔
1013
                        result = sanity_check as typeof result;
648 ✔
1014
                } else {
978 ✔
1015
                        const sanity_check: array_schema<
662 ✔
1016
                                'prefixItems',
662 ✔
1017
                                SpecifiedMode,
662 ✔
1018
                                UniqueItems_mode,
662 ✔
1019
                                MinItems_mode,
662 ✔
1020
                                Items,
662 ✔
1021
                                [SchemaObject, ...SchemaObject[]]
662 ✔
1022
                        >[
662 ✔
1023
                                'properties'
662 ✔
1024
                        ] = this.#generate_schema_definition_properties_prefixItems(
662 ✔
1025
                                options as array_options<
662 ✔
1026
                                        'prefixItems',
662 ✔
1027
                                        SpecifiedMode,
662 ✔
1028
                                        UniqueItems_mode,
662 ✔
1029
                                        MinItems_mode,
662 ✔
1030
                                        Items,
662 ✔
1031
                                        [SchemaObject, ...SchemaObject[]]
662 ✔
1032
                                >,
662 ✔
1033
                        );
662 ✔
1034

662 ✔
1035
                        result = sanity_check as typeof result;
662 ✔
1036
                }
662 ✔
1037

1,310 ✔
1038
                return result;
1,310 ✔
1039
        }
1,310 ✔
1040

19 ✔
1041
        static #generate_schema_definition_properties_base<
19 ✔
1042
                UniqueItems_mode extends unique_items_mode,
1,310 ✔
1043
        >(
1,310 ✔
1044
                options: array_options<
1,310 ✔
1045
                        array_mode,
1,310 ✔
1046
                        specified_mode,
1,310 ✔
1047
                        UniqueItems_mode,
1,310 ✔
1048
                        MinItemsType_mode
1,310 ✔
1049
                >,
1,310 ✔
1050
        ): Pick<
1,310 ✔
1051
                array_schema<
1,310 ✔
1052
                        array_mode,
1,310 ✔
1053
                        specified_mode,
1,310 ✔
1054
                        UniqueItems_mode,
1,310 ✔
1055
                        MinItemsType_mode
1,310 ✔
1056
                >['properties'],
1,310 ✔
1057
                (
1,310 ✔
1058
                        | '$schema'
1,310 ✔
1059
                        | '$id'
1,310 ✔
1060
                        | '$defs'
1,310 ✔
1061
                        | 'type'
1,310 ✔
1062
                        | 'uniqueItems'
1,310 ✔
1063
                )
1,310 ✔
1064
        > {
1,310 ✔
1065
                let base: Pick<
1,310 ✔
1066
                        array_schema<
1,310 ✔
1067
                                array_mode,
1,310 ✔
1068
                                specified_mode,
1,310 ✔
1069
                                UniqueItems_mode,
1,310 ✔
1070
                                MinItemsType_mode
1,310 ✔
1071
                        >['properties'],
1,310 ✔
1072
                        (
1,310 ✔
1073
                                | '$schema'
1,310 ✔
1074
                                | '$id'
1,310 ✔
1075
                                | '$defs'
1,310 ✔
1076
                                | 'type'
1,310 ✔
1077
                                | 'uniqueItems'
1,310 ✔
1078
                        )
1,310 ✔
1079
                >;
1,310 ✔
1080

1,310 ✔
1081
                if ('yes' === options.unique_items_mode) {
1,310 ✔
1082
                        const sanity_check: Pick<
678 ✔
1083
                                array_schema<
678 ✔
1084
                                        array_mode,
678 ✔
1085
                                        specified_mode,
678 ✔
1086
                                        'yes',
678 ✔
1087
                                        MinItemsType_mode
678 ✔
1088
                                >['properties'],
678 ✔
1089
                                (
678 ✔
1090
                                        | '$schema'
678 ✔
1091
                                        | '$id'
678 ✔
1092
                                        | 'type'
678 ✔
1093
                                        | 'uniqueItems'
678 ✔
1094
                                )
678 ✔
1095
                        > = {
678 ✔
1096
                                $schema: {
678 ✔
1097
                                        type: 'string',
678 ✔
1098
                                        enum: [
678 ✔
1099
                                                'https://json-schema.org/draft/2020-12/schema',
678 ✔
1100
                                        ],
678 ✔
1101
                                },
678 ✔
1102
                                $id: {
678 ✔
1103
                                        type: 'string',
678 ✔
1104
                                        minLength: 1,
678 ✔
1105
                                },
678 ✔
1106
                                type: {
678 ✔
1107
                                        type: 'string',
678 ✔
1108
                                        const: 'array',
678 ✔
1109
                                },
678 ✔
1110
                                uniqueItems: {
678 ✔
1111
                                        type: 'boolean',
678 ✔
1112
                                        const: true,
678 ✔
1113
                                },
678 ✔
1114
                        };
678 ✔
1115

678 ✔
1116
                        base = sanity_check as typeof base;
678 ✔
1117
                } else {
978 ✔
1118
                        const sanity_check: Pick<
632 ✔
1119
                                array_schema<
632 ✔
1120
                                        array_mode,
632 ✔
1121
                                        specified_mode,
632 ✔
1122
                                        'no',
632 ✔
1123
                                        MinItemsType_mode
632 ✔
1124
                                >['properties'],
632 ✔
1125
                                (
632 ✔
1126
                                        | '$schema'
632 ✔
1127
                                        | '$id'
632 ✔
1128
                                        | 'type'
632 ✔
1129
                                        | 'uniqueItems'
632 ✔
1130
                                )
632 ✔
1131
                        > = {
632 ✔
1132
                                $schema: {
632 ✔
1133
                                        type: 'string',
632 ✔
1134
                                        enum: [
632 ✔
1135
                                                'https://json-schema.org/draft/2020-12/schema',
632 ✔
1136
                                        ],
632 ✔
1137
                                },
632 ✔
1138
                                $id: {
632 ✔
1139
                                        type: 'string',
632 ✔
1140
                                        minLength: 1,
632 ✔
1141
                                },
632 ✔
1142
                                type: {
632 ✔
1143
                                        type: 'string',
632 ✔
1144
                                        const: 'array',
632 ✔
1145
                                },
632 ✔
1146
                                uniqueItems: {
632 ✔
1147
                                        type: 'boolean',
632 ✔
1148
                                        const: false,
632 ✔
1149
                                },
632 ✔
1150
                        };
632 ✔
1151

632 ✔
1152
                        base = sanity_check as typeof base;
632 ✔
1153
                }
632 ✔
1154

1,310 ✔
1155
                if (options.$defs) {
1,310 ✔
1156
                        base.$defs = {
4 ✔
1157
                                type: 'object',
4 ✔
1158
                                const: {
4 ✔
1159
                                        ...options.$defs,
4 ✔
1160
                                },
4 ✔
1161
                        };
4 ✔
1162
                } else {
1,310 ✔
1163
                        base.$defs = $defs_schema.properties.$defs;
1,306 ✔
1164
                }
1,306 ✔
1165

1,310 ✔
1166
                return base;
1,310 ✔
1167
        }
1,310 ✔
1168

19 ✔
1169
        static #generate_schema_definition_properties_items<
19 ✔
1170
                SpecifiedMode extends specified_mode,
648 ✔
1171
                UniqueItems_mode extends unique_items_mode,
648 ✔
1172
                MinItems_mode extends MinItemsType_mode,
648 ✔
1173
                Items extends SchemaObject,
648 ✔
1174
        >(
648 ✔
1175
                options: array_options<
648 ✔
1176
                        'items',
648 ✔
1177
                        SpecifiedMode,
648 ✔
1178
                        UniqueItems_mode,
648 ✔
1179
                        MinItems_mode,
648 ✔
1180
                        Items,
648 ✔
1181
                        [SchemaObject, ...SchemaObject[]]
648 ✔
1182
                >,
648 ✔
1183
        ): Readonly<array_schema<
648 ✔
1184
                'items',
648 ✔
1185
                SpecifiedMode,
648 ✔
1186
                UniqueItems_mode,
648 ✔
1187
                MinItems_mode,
648 ✔
1188
                Items,
648 ✔
1189
                [SchemaObject, ...SchemaObject[]]
648 ✔
1190
        >['properties']> {
648 ✔
1191
                let result: array_schema<
648 ✔
1192
                        'items',
648 ✔
1193
                        SpecifiedMode,
648 ✔
1194
                        UniqueItems_mode,
648 ✔
1195
                        MinItems_mode,
648 ✔
1196
                        Items,
648 ✔
1197
                        [SchemaObject, ...SchemaObject[]]
648 ✔
1198
                >['properties'];
648 ✔
1199

648 ✔
1200
                const base = {
648 ✔
1201
                        ...this.#generate_schema_definition_properties_base(options),
648 ✔
1202
                        minItems: {
648 ✔
1203
                                type: 'integer',
648 ✔
1204
                                minimum: 0,
648 ✔
1205
                        } as const,
648 ✔
1206
                        maxItems: {
648 ✔
1207
                                type: 'integer',
648 ✔
1208
                                minimum: 0,
648 ✔
1209
                        } as const,
648 ✔
1210
                };
648 ✔
1211

648 ✔
1212
                if (options.items) {
648 ✔
1213
                        const sanity_check: array_schema<
17 ✔
1214
                                'items',
17 ✔
1215
                                'specified',
17 ✔
1216
                                UniqueItems_mode,
17 ✔
1217
                                MinItems_mode,
17 ✔
1218
                                Items,
17 ✔
1219
                                [SchemaObject, ...SchemaObject[]]
17 ✔
1220
                        >['properties'] = {
17 ✔
1221
                                ...base,
17 ✔
1222
                                items: options.items,
17 ✔
1223
                        };
17 ✔
1224

17 ✔
1225
                        result = sanity_check as typeof result;
17 ✔
1226
                } else {
648 ✔
1227
                        const sanity_check: array_schema<
631 ✔
1228
                                'items',
631 ✔
1229
                                'unspecified',
631 ✔
1230
                                UniqueItems_mode,
631 ✔
1231
                                MinItems_mode,
631 ✔
1232
                                Items,
631 ✔
1233
                                [SchemaObject, ...SchemaObject[]]
631 ✔
1234
                        >['properties'] = {
631 ✔
1235
                                ...base,
631 ✔
1236
                                items: {
631 ✔
1237
                                        type: 'object',
631 ✔
1238
                                        minProperties: 0,
631 ✔
1239
                                },
631 ✔
1240
                        };
631 ✔
1241

631 ✔
1242
                        result = sanity_check as typeof result;
631 ✔
1243
                }
631 ✔
1244

648 ✔
1245
                return Object.freeze(result);
648 ✔
1246
        }
648 ✔
1247

19 ✔
1248
        static #generate_schema_definition_properties_prefixItems<
19 ✔
1249
                SpecifiedMode extends specified_mode,
662 ✔
1250
                UniqueItems_mode extends unique_items_mode,
662 ✔
1251
                MinItems_mode extends MinItemsType_mode,
662 ✔
1252
                PrefixItems extends [
662 ✔
1253
                        SchemaObject,
662 ✔
1254
                        ...SchemaObject[],
662 ✔
1255
                ],
662 ✔
1256
        >(
662 ✔
1257
                options: array_options<
662 ✔
1258
                        'prefixItems',
662 ✔
1259
                        SpecifiedMode,
662 ✔
1260
                        UniqueItems_mode,
662 ✔
1261
                        MinItems_mode,
662 ✔
1262
                        SchemaObject,
662 ✔
1263
                        PrefixItems
662 ✔
1264
                >,
662 ✔
1265
        ): array_schema<
662 ✔
1266
                'prefixItems',
662 ✔
1267
                SpecifiedMode,
662 ✔
1268
                UniqueItems_mode,
662 ✔
1269
                MinItems_mode,
662 ✔
1270
                SchemaObject,
662 ✔
1271
                PrefixItems
662 ✔
1272
        >['properties'] {
662 ✔
1273
                let result: array_schema<
662 ✔
1274
                        'prefixItems',
662 ✔
1275
                        SpecifiedMode,
662 ✔
1276
                        UniqueItems_mode,
662 ✔
1277
                        MinItems_mode,
662 ✔
1278
                        SchemaObject,
662 ✔
1279
                        PrefixItems
662 ✔
1280
                >['properties'];
662 ✔
1281

662 ✔
1282
                const base = {
662 ✔
1283
                        ...this.#generate_schema_definition_properties_base(options),
662 ✔
1284
                        minItems: {
662 ✔
1285
                                type: 'integer',
662 ✔
1286
                                minimum: 0,
662 ✔
1287
                        } as const,
662 ✔
1288
                        maxItems: {
662 ✔
1289
                                type: 'integer',
662 ✔
1290
                                minimum: 1,
662 ✔
1291
                        } as const,
662 ✔
1292
                };
662 ✔
1293

662 ✔
1294
                if ('prefixItems' in options) {
662 ✔
1295
                        const sanity_check: array_schema<
64 ✔
1296
                                'prefixItems',
64 ✔
1297
                                'specified',
64 ✔
1298
                                UniqueItems_mode,
64 ✔
1299
                                MinItems_mode,
64 ✔
1300
                                SchemaObject,
64 ✔
1301
                                PrefixItems
64 ✔
1302
                        >['properties'] = {
64 ✔
1303
                                ...base,
64 ✔
1304
                                items: {
64 ✔
1305
                                        type: 'boolean',
64 ✔
1306
                                        const: false,
64 ✔
1307
                                },
64 ✔
1308
                                prefixItems: {
64 ✔
1309
                                        type: 'array',
64 ✔
1310
                                        const: options.prefixItems,
64 ✔
1311
                                },
64 ✔
1312
                        };
64 ✔
1313

64 ✔
1314
                        result = sanity_check as typeof result;
64 ✔
1315
                } else {
662 ✔
1316
                        const sanity_check: array_schema<
598 ✔
1317
                                'prefixItems',
598 ✔
1318
                                'unspecified',
598 ✔
1319
                                UniqueItems_mode,
598 ✔
1320
                                MinItems_mode,
598 ✔
1321
                                SchemaObject & {},
598 ✔
1322
                                [SchemaObject, ...SchemaObject[]]
598 ✔
1323
                        >['properties'] = {
598 ✔
1324
                                ...base,
598 ✔
1325
                                items: {
598 ✔
1326
                                        type: 'boolean',
598 ✔
1327
                                        const: false,
598 ✔
1328
                                },
598 ✔
1329
                                prefixItems: {
598 ✔
1330
                                        type: 'array',
598 ✔
1331
                                        minItems: 1,
598 ✔
1332
                                        items: {
598 ✔
1333
                                                type: 'object',
598 ✔
1334
                                                minProperties: 1,
598 ✔
1335
                                        },
598 ✔
1336
                                },
598 ✔
1337
                        };
598 ✔
1338

598 ✔
1339
                        result = sanity_check as typeof result;
598 ✔
1340
                }
598 ✔
1341

662 ✔
1342
                return result;
662 ✔
1343
        }
662 ✔
1344

19 ✔
1345
        static #generate_schema_definition_required<
19 ✔
1346
                ArrayMode extends array_mode,
1,310 ✔
1347
                SpecifiedMode extends specified_mode,
1,310 ✔
1348
                UniqueItems_mode extends unique_items_mode,
1,310 ✔
1349
                MinItems_mode extends MinItemsType_mode,
1,310 ✔
1350
                Items extends SchemaObject,
1,310 ✔
1351
                PrefixItems extends [
1,310 ✔
1352
                        SchemaObject,
1,310 ✔
1353
                        ...SchemaObject[],
1,310 ✔
1354
                ],
1,310 ✔
1355
        >(
1,310 ✔
1356
                options: array_options<
1,310 ✔
1357
                        ArrayMode,
1,310 ✔
1358
                        SpecifiedMode,
1,310 ✔
1359
                        UniqueItems_mode,
1,310 ✔
1360
                        MinItems_mode,
1,310 ✔
1361
                        Items,
1,310 ✔
1362
                        PrefixItems
1,310 ✔
1363
                >,
1,310 ✔
1364
        ): array_schema<
1,310 ✔
1365
                ArrayMode,
1,310 ✔
1366
                SpecifiedMode,
1,310 ✔
1367
                UniqueItems_mode,
1,310 ✔
1368
                MinItems_mode,
1,310 ✔
1369
                Items,
1,310 ✔
1370
                PrefixItems
1,310 ✔
1371
        >['required'] {
1,310 ✔
1372
                let result: array_schema<
1,310 ✔
1373
                        ArrayMode,
1,310 ✔
1374
                        SpecifiedMode,
1,310 ✔
1375
                        UniqueItems_mode,
1,310 ✔
1376
                        MinItems_mode,
1,310 ✔
1377
                        Items,
1,310 ✔
1378
                        PrefixItems
1,310 ✔
1379
                >['required'];
1,310 ✔
1380

1,310 ✔
1381
                if (this.#is_any_items_options(options)) {
1,310 ✔
1382
                        const sanity_check: array_schema<
648 ✔
1383
                                'items',
648 ✔
1384
                                SpecifiedMode
648 ✔
1385
                        >['required'] = this.#generate_schema_definition_required_items(
648 ✔
1386
                                options,
648 ✔
1387
                        );
648 ✔
1388

648 ✔
1389
                        result = sanity_check as typeof result;
648 ✔
1390
                } else {
978 ✔
1391
                        const sanity_check: array_schema<
662 ✔
1392
                                'prefixItems',
662 ✔
1393
                                SpecifiedMode
662 ✔
1394
                        >[
662 ✔
1395
                                'required'
662 ✔
1396
                        ] = this.#generate_schema_definition_required_prefixItems<
662 ✔
1397
                                SpecifiedMode
662 ✔
1398
                        >(
662 ✔
1399
                                options as array_options<'prefixItems', SpecifiedMode>,
662 ✔
1400
                        );
662 ✔
1401

662 ✔
1402
                        result = sanity_check as typeof result;
662 ✔
1403
                }
662 ✔
1404

1,310 ✔
1405
                return result;
1,310 ✔
1406
        }
1,310 ✔
1407

19 ✔
1408
        static #generate_schema_definition_required_items<
19 ✔
1409
                SpecifiedMode extends specified_mode,
648 ✔
1410
        >(
648 ✔
1411
                options: array_options<
648 ✔
1412
                        'items'
648 ✔
1413
                >,
648 ✔
1414
        ): array_schema<
648 ✔
1415
                'items'
648 ✔
1416
        >['required'] {
648 ✔
1417
                let required: array_schema<
648 ✔
1418
                        'items',
648 ✔
1419
                        SpecifiedMode
648 ✔
1420
                >['required'];
648 ✔
1421

648 ✔
1422
                if ('with' === options.min_items_mode) {
648 ✔
1423
                        if ('yes' === options.unique_items_mode) {
12 ✔
1424
                                const sanity_check: array_schema<
6 ✔
1425
                                        'items',
6 ✔
1426
                                        specified_mode,
6 ✔
1427
                                        'yes',
6 ✔
1428
                                        'with'
6 ✔
1429
                                >['required'] = [
6 ✔
1430
                                        'type',
6 ✔
1431
                                        'items',
6 ✔
1432
                                        'minItems',
6 ✔
1433
                                        'uniqueItems',
6 ✔
1434
                                ];
6 ✔
1435

6 ✔
1436
                                required = sanity_check as typeof required;
6 ✔
1437
                        } else {
6 ✔
1438
                                const sanity_check: array_schema<
6 ✔
1439
                                        'items',
6 ✔
1440
                                        specified_mode,
6 ✔
1441
                                        'no',
6 ✔
1442
                                        'with'
6 ✔
1443
                                >['required'] = [
6 ✔
1444
                                        'type',
6 ✔
1445
                                        'items',
6 ✔
1446
                                        'minItems',
6 ✔
1447
                                ];
6 ✔
1448

6 ✔
1449
                                required = sanity_check as typeof required;
6 ✔
1450
                        }
6 ✔
1451
                } else {
648 ✔
1452
                        if ('yes' === options.unique_items_mode) {
636 ✔
1453
                                const sanity_check: array_schema<
312 ✔
1454
                                        'items',
312 ✔
1455
                                        specified_mode,
312 ✔
1456
                                        'yes',
312 ✔
1457
                                        'optional'
312 ✔
1458
                                >['required'] = [
312 ✔
1459
                                        'type',
312 ✔
1460
                                        'items',
312 ✔
1461
                                        'uniqueItems',
312 ✔
1462
                                ];
312 ✔
1463

312 ✔
1464
                                required = sanity_check as typeof required;
312 ✔
1465
                        } else {
470 ✔
1466
                                const sanity_check: array_schema<
324 ✔
1467
                                        'items',
324 ✔
1468
                                        specified_mode,
324 ✔
1469
                                        'no',
324 ✔
1470
                                        'optional'
324 ✔
1471
                                >['required'] = [
324 ✔
1472
                                        'type',
324 ✔
1473
                                        'items',
324 ✔
1474
                                ];
324 ✔
1475

324 ✔
1476
                                required = sanity_check as typeof required;
324 ✔
1477
                        }
324 ✔
1478
                }
636 ✔
1479

648 ✔
1480
                return required;
648 ✔
1481
        }
648 ✔
1482

19 ✔
1483
        static #generate_schema_definition_required_prefixItems<
19 ✔
1484
                SpecifiedMode extends specified_mode,
662 ✔
1485
        >(
662 ✔
1486
                options: array_options<
662 ✔
1487
                        'prefixItems',
662 ✔
1488
                        SpecifiedMode
662 ✔
1489
                >,
662 ✔
1490
        ): array_schema<
662 ✔
1491
                'prefixItems',
662 ✔
1492
                SpecifiedMode
662 ✔
1493
        >['required'] {
662 ✔
1494
                let required: array_schema<
662 ✔
1495
                        'prefixItems',
662 ✔
1496
                        SpecifiedMode
662 ✔
1497
                >['required'];
662 ✔
1498

662 ✔
1499
                if ('specified' === options.specified_mode) {
662 ✔
1500
                        if ('yes' === options.unique_items_mode) {
64 ✔
1501
                                const sanity_check: array_schema<
62 ✔
1502
                                        'prefixItems',
62 ✔
1503
                                        'specified',
62 ✔
1504
                                        'yes',
62 ✔
1505
                                        MinItemsType_mode
62 ✔
1506
                                >['required'] = [
62 ✔
1507
                                        'type',
62 ✔
1508
                                        'items',
62 ✔
1509
                                        'prefixItems',
62 ✔
1510
                                        'uniqueItems',
62 ✔
1511
                                ];
62 ✔
1512

62 ✔
1513
                                required = sanity_check as typeof required;
62 ✔
1514
                        } else {
64 ✔
1515
                                const sanity_check: array_schema<
2 ✔
1516
                                        'prefixItems',
2 ✔
1517
                                        'specified',
2 ✔
1518
                                        'no',
2 ✔
1519
                                        MinItemsType_mode
2 ✔
1520
                                >['required'] = [
2 ✔
1521
                                        'type',
2 ✔
1522
                                        'items',
2 ✔
1523
                                        'prefixItems',
2 ✔
1524
                                ];
2 ✔
1525

2 ✔
1526
                                required = sanity_check as typeof required;
2 ✔
1527
                        }
2 ✔
1528
                } else {
662 ✔
1529
                        if ('yes' === options.unique_items_mode) {
598 ✔
1530
                                const sanity_check: array_schema<
298 ✔
1531
                                        'prefixItems',
298 ✔
1532
                                        'unspecified',
298 ✔
1533
                                        'yes',
298 ✔
1534
                                        MinItemsType_mode
298 ✔
1535
                                >['required'] = [
298 ✔
1536
                                        'type',
298 ✔
1537
                                        'items',
298 ✔
1538
                                        'prefixItems',
298 ✔
1539
                                        'uniqueItems',
298 ✔
1540
                                ];
298 ✔
1541

298 ✔
1542
                                required = sanity_check as typeof required;
298 ✔
1543
                        } else {
427 ✔
1544
                                const sanity_check: array_schema<
300 ✔
1545
                                        'prefixItems',
300 ✔
1546
                                        'unspecified',
300 ✔
1547
                                        'no',
300 ✔
1548
                                        MinItemsType_mode
300 ✔
1549
                                >['required'] = [
300 ✔
1550
                                        'type',
300 ✔
1551
                                        'items',
300 ✔
1552
                                        'prefixItems',
300 ✔
1553
                                ];
300 ✔
1554

300 ✔
1555
                                required = sanity_check as typeof required;
300 ✔
1556
                        }
300 ✔
1557
                }
598 ✔
1558

662 ✔
1559
                return required;
662 ✔
1560
        }
662 ✔
1561

19 ✔
1562
        static async #generate_typescript_type_has_items<
19 ✔
1563
                T1 extends unknown[],
37 ✔
1564
                T2 extends TypeNode,
37 ✔
1565
                T3 extends [T2, ...T2[]],
37 ✔
1566
                ArrayMode extends array_mode,
37 ✔
1567
                MinItems_mode extends MinItemsType_mode,
37 ✔
1568
        >(
37 ✔
1569
                data: T1,
37 ✔
1570
                schema: (
37 ✔
1571
                        | array_type<
37 ✔
1572
                                'items'
37 ✔
1573
                        >
37 ✔
1574
                        | array_type<
37 ✔
1575
                                'prefixItems',
37 ✔
1576
                                'unspecified'
37 ✔
1577
                        >
37 ✔
1578
                ),
37 ✔
1579
                schema_parser: SchemaParser,
37 ✔
1580
        ): Promise<{
37 ✔
1581
                items: {
37 ✔
1582
                        with: TupleTypeNode<T2, T3>,
37 ✔
1583
                        optional: ArrayTypeNode<T2>,
37 ✔
1584
                }[MinItems_mode],
37 ✔
1585
                prefixItems: TupleTypeNode<T2, T3>,
37 ✔
1586
        }[ArrayMode]> {
37 ✔
1587
                let result = Promise<{
37 ✔
1588
                        items: {
37 ✔
1589
                                with: TupleTypeNode<T2, T3>,
37 ✔
1590
                                optional: ArrayTypeNode<T2>,
37 ✔
1591
                        }[MinItems_mode],
37 ✔
1592
                        prefixItems: TupleTypeNode<T2, T3>,
37 ✔
1593
                }[ArrayMode]>;
37 ✔
1594

37 ✔
1595
                if (this.#is_type_with_minItems(schema)) {
37 ✔
1596
                        const sanity_check: Promise<
19 ✔
1597
                                TupleTypeNode<T2, T3>
19 ✔
1598
                        > = this.#generate_typescript_type_has_items_and_minItems(
19 ✔
1599
                                data,
19 ✔
1600
                                schema,
19 ✔
1601
                                schema_parser,
19 ✔
1602
                        );
19 ✔
1603

19 ✔
1604
                        result = sanity_check as unknown as typeof result;
19 ✔
1605
                } else {
37 ✔
1606
                        const sanity_check: Promise<
18 ✔
1607
                                ArrayTypeNode<T2>
18 ✔
1608
                        > = this.#generate_typescript_type_has_items_only(
18 ✔
1609
                                data,
18 ✔
1610
                                schema,
18 ✔
1611
                                schema_parser,
18 ✔
1612
                        );
18 ✔
1613

18 ✔
1614
                        result = sanity_check as unknown as typeof result;
18 ✔
1615
                }
18 ✔
1616

37 ✔
1617
                return result as unknown as Promise<{
37 ✔
1618
                        items: {
37 ✔
1619
                                with: TupleTypeNode<T2, T3>,
37 ✔
1620
                                optional: ArrayTypeNode<T2>,
37 ✔
1621
                        }[MinItems_mode],
37 ✔
1622
                        prefixItems: TupleTypeNode<T2, T3>,
37 ✔
1623
                }[ArrayMode]>;
37 ✔
1624
        }
37 ✔
1625

19 ✔
1626
        static async #generate_typescript_type_has_items_and_minItems<
19 ✔
1627
                T1 extends unknown[],
19 ✔
1628
                T2 extends TypeNode,
19 ✔
1629
                T3 extends [T2, ...T2[]],
19 ✔
1630
                SpecifiedMode extends specified_mode,
19 ✔
1631
                UniqueItems_mode extends unique_items_mode,
19 ✔
1632
                Items extends SchemaObject,
19 ✔
1633
                PrefixItems extends [
19 ✔
1634
                        SchemaObject,
19 ✔
1635
                        ...SchemaObject[],
19 ✔
1636
                ] = [
19 ✔
1637
                        SchemaObject,
19 ✔
1638
                        ...SchemaObject[],
19 ✔
1639
                ],
19 ✔
1640
        >(
19 ✔
1641
                data: T1,
19 ✔
1642
                schema: array_type<
19 ✔
1643
                        'items',
19 ✔
1644
                        SpecifiedMode,
19 ✔
1645
                        UniqueItems_mode,
19 ✔
1646
                        'with',
19 ✔
1647
                        Items,
19 ✔
1648
                        PrefixItems
19 ✔
1649
                >,
19 ✔
1650
                schema_parser: SchemaParser,
19 ✔
1651
        ): Promise<TupleTypeNode<T2, T3>> {
19 ✔
1652
                const tuple_members: TypeNode[] = [];
19 ✔
1653
                const sub_type = schema_parser.parse(ArrayType.maybe_add_$defs(
19 ✔
1654
                        schema,
19 ✔
1655
                        schema.items,
19 ✔
1656
                ));
19 ✔
1657

19 ✔
1658
                let i = 0;
19 ✔
1659
                while (tuple_members.length < schema.minItems && i < data?.length) {
19 ✔
1660
                        tuple_members.push(
19 ✔
1661
                                await sub_type.generate_typescript_type({
19 ✔
1662
                                        data: data[i],
19 ✔
1663
                                        schema: schema.items,
19 ✔
1664
                                        schema_parser,
19 ✔
1665
                                }),
19 ✔
1666
                        );
19 ✔
1667
                        ++i;
19 ✔
1668
                }
19 ✔
1669

19 ✔
1670
                tuple_members.push(factory.createRestTypeNode(
19 ✔
1671
                        factory.createArrayTypeNode(
19 ✔
1672
                                await sub_type.generate_typescript_type({
19 ✔
1673
                                        data: schema.items,
19 ✔
1674
                                        schema: schema.items,
19 ✔
1675
                                        schema_parser,
19 ✔
1676
                                }),
19 ✔
1677
                        ),
19 ✔
1678
                ));
19 ✔
1679

19 ✔
1680
                return factory.createTupleTypeNode<T2, T3>(tuple_members as T3);
19 ✔
1681
        }
19 ✔
1682

19 ✔
1683
        static async #generate_typescript_type_has_items_only<
19 ✔
1684
                T1 extends unknown[],
18 ✔
1685
                T2 extends TypeNode,
18 ✔
1686
                SpecifiedMode extends specified_mode,
18 ✔
1687
                UniqueItems_mode extends unique_items_mode,
18 ✔
1688
                Items extends SchemaObject,
18 ✔
1689
                PrefixItems extends [
18 ✔
1690
                        SchemaObject,
18 ✔
1691
                        ...SchemaObject[],
18 ✔
1692
                ] = [
18 ✔
1693
                        SchemaObject,
18 ✔
1694
                        ...SchemaObject[],
18 ✔
1695
                ],
18 ✔
1696
        >(
18 ✔
1697
                data: T1,
18 ✔
1698
                schema: array_type<
18 ✔
1699
                        'items',
18 ✔
1700
                        SpecifiedMode,
18 ✔
1701
                        UniqueItems_mode,
18 ✔
1702
                        'optional',
18 ✔
1703
                        Items,
18 ✔
1704
                        PrefixItems
18 ✔
1705
                >,
18 ✔
1706
                schema_parser: SchemaParser,
18 ✔
1707
        ): Promise<ArrayTypeNode<T2>> {
18 ✔
1708
                if (0 === Object.keys(schema?.items || {}).length) {
18 !
1709
                        if (data.length < 0) {
7 !
1710
                                return factory.createArrayTypeNode(
×
1711
                                        factory.createKeywordTypeNode(
×
1712
                                                SyntaxKind.NeverKeyword,
×
1713
                                        ) as T2,
×
1714
                                );
×
1715
                        }
×
1716

7 ✔
1717
                        return factory.createArrayTypeNode(
7 ✔
1718
                                factory.createUnionTypeNode(
7 ✔
1719
                                        await Promise.all(
7 ✔
1720
                                                data.map(
7 ✔
1721
                                                        (sub_data) => schema_parser
7 ✔
1722
                                                                .parse_by_type(sub_data)
21 ✔
1723
                                                                .generate_typescript_type({
21 ✔
1724
                                                                        data: sub_data,
21 ✔
1725
                                                                        schema: {},
21 ✔
1726
                                                                        schema_parser,
21 ✔
1727
                                                                }),
7 ✔
1728
                                                ),
7 ✔
1729
                                        ),
7 ✔
1730
                                ) as unknown as T2,
7 ✔
1731
                        );
7 ✔
1732
                }
7 ✔
1733

11 ✔
1734
                const sub_type = schema_parser.parse(ArrayType.maybe_add_$defs(
11 ✔
1735
                        schema,
11 ✔
1736
                        schema.items,
11 ✔
1737
                ));
11 ✔
1738

11 ✔
1739
                return factory.createArrayTypeNode(
11 ✔
1740
                        await sub_type.generate_typescript_type({
11 ✔
1741
                                data: data,
11 ✔
1742
                                schema: schema.items,
11 ✔
1743
                                schema_parser,
11 ✔
1744
                        }) as T2,
11 ✔
1745
                );
11 ✔
1746
        }
18 ✔
1747

19 ✔
1748
        static async #generate_typescript_type_has_prefixItems<
19 ✔
1749
                T1 extends unknown[],
68 ✔
1750
                T2 extends TypeNode,
68 ✔
1751
                T3 extends [T2, ...T2[]],
68 ✔
1752
        >(
68 ✔
1753
                data: T1|undefined,
68 ✔
1754
                schema: array_type<
68 ✔
1755
                        'prefixItems',
68 ✔
1756
                        'specified'
68 ✔
1757
                >,
68 ✔
1758
                schema_parser: SchemaParser,
68 ✔
1759
        ): Promise<TupleTypeNode<T2, T3>> {
68 ✔
1760
                if (undefined !== data && data.length !== schema.prefixItems.length) {
68 ✔
1761
                        throw new TypeError('Data does not match schema length!');
30 ✔
1762
                }
30 ✔
1763

38 ✔
1764
                const tuple_members: TypeNode[] = [];
38 ✔
1765

38 ✔
1766
                let i = 0;
38 ✔
1767
                for (const sub_schema of schema.prefixItems) {
68 ✔
1768
                        const maybe_modified = ArrayType.maybe_add_$defs(
111 ✔
1769
                                schema,
111 ✔
1770
                                sub_schema,
111 ✔
1771
                        );
111 ✔
1772
                        const sub_type = await schema_parser.parse(
111 ✔
1773
                                maybe_modified,
111 ✔
1774
                        ).generate_typescript_type({
111 ✔
1775
                                data: undefined === data ? undefined : data[i],
111 ✔
1776
                                schema: maybe_modified,
111 ✔
1777
                                schema_parser,
111 ✔
1778
                        });
111 ✔
1779

111 ✔
1780
                        ++i;
111 ✔
1781

111 ✔
1782
                        tuple_members.push(sub_type);
111 ✔
1783
                }
111 ✔
1784

38 ✔
1785
                return factory.createTupleTypeNode<T2, T3>(tuple_members as T3);
38 ✔
1786
        }
68 ✔
1787

19 ✔
1788
        static #is_any_items_options(
19 ✔
1789
                options: array_options,
1,310 ✔
1790
        ): options is array_options<
1,310 ✔
1791
                'items'
1,310 ✔
1792
        > {
1,310 ✔
1793
                return 'items' === options.array_mode;
1,310 ✔
1794
        }
1,310 ✔
1795

19 ✔
1796
        static #is_type_with_minItems<
19 ✔
1797
                SpecifiedMode extends specified_mode,
37 ✔
1798
                UniqueItems_mode extends unique_items_mode,
37 ✔
1799
                Items extends SchemaObject,
37 ✔
1800
                PrefixItems extends [
37 ✔
1801
                        SchemaObject,
37 ✔
1802
                        ...SchemaObject[],
37 ✔
1803
                ] = [
37 ✔
1804
                        SchemaObject,
37 ✔
1805
                        ...SchemaObject[],
37 ✔
1806
                ],
37 ✔
1807
        >(
37 ✔
1808
                schema: array_type<
37 ✔
1809
                        'items',
37 ✔
1810
                        SpecifiedMode,
37 ✔
1811
                        UniqueItems_mode,
37 ✔
1812
                        MinItemsType_mode,
37 ✔
1813
                        Items,
37 ✔
1814
                        PrefixItems
37 ✔
1815
                >,
37 ✔
1816
        ): schema is array_type<
37 ✔
1817
                'items',
37 ✔
1818
                SpecifiedMode,
37 ✔
1819
                UniqueItems_mode,
37 ✔
1820
                'with',
37 ✔
1821
                Items,
37 ✔
1822
                PrefixItems
37 ✔
1823
        > {
37 ✔
1824
                return 'minItems' in schema;
37 ✔
1825
        }
37 ✔
1826

19 ✔
1827
        static #is_specified_prefixItems_options<
19 ✔
1828
                UniqueItems_mode extends unique_items_mode,
662 ✔
1829
                PrefixItems extends [
662 ✔
1830
                        SchemaObject,
662 ✔
1831
                        ...SchemaObject[],
662 ✔
1832
                ],
662 ✔
1833
        >(options: array_options<
662 ✔
1834
                array_mode,
662 ✔
1835
                specified_mode,
662 ✔
1836
                UniqueItems_mode,
662 ✔
1837
                MinItemsType_mode,
662 ✔
1838
                SchemaObject,
662 ✔
1839
                PrefixItems
662 ✔
1840
        >): options is array_options<
662 ✔
1841
                'prefixItems',
662 ✔
1842
                'specified',
662 ✔
1843
                UniqueItems_mode,
662 ✔
1844
                MinItemsType_mode,
662 ✔
1845
                SchemaObject,
662 ✔
1846
                PrefixItems
662 ✔
1847
        > {
662 ✔
1848
                return (
662 ✔
1849
                        'prefixItems' === options.array_mode
662 ✔
1850
                        && 'specified' === options.specified_mode
662 ✔
1851
                );
662 ✔
1852
        }
662 ✔
1853

19 ✔
1854
        static #is_items_type_schema(schema: array_type<
19 ✔
1855
                array_mode,
105 ✔
1856
                specified_mode
105 ✔
1857
        >): schema is (
105 ✔
1858
                | array_type<'items'>
105 ✔
1859
                | array_type<'prefixItems', 'unspecified'>
105 ✔
1860
        ) {
105 ✔
1861
                return !('prefixItems' in schema);
105 ✔
1862
        }
105 ✔
1863

19 ✔
1864
        static #sub_schema_for_value<
19 ✔
1865
                ArrayMode extends array_mode,
120 ✔
1866
                SpecifiedMode extends specified_mode,
120 ✔
1867
                UniqueItems_mode extends unique_items_mode,
120 ✔
1868
                MinItems_mode extends MinItemsType_mode,
120 ✔
1869
                Items extends SchemaObject,
120 ✔
1870
                PrefixItems extends [
120 ✔
1871
                        SchemaObject,
120 ✔
1872
                        ...SchemaObject[],
120 ✔
1873
                ],
120 ✔
1874
                N extends number,
120 ✔
1875
        >(
120 ✔
1876
                index: ReturnType<typeof PositiveIntegerOrZeroGuard<N>>,
120 ✔
1877
                schema: array_type<
120 ✔
1878
                        ArrayMode,
120 ✔
1879
                        SpecifiedMode,
120 ✔
1880
                        UniqueItems_mode,
120 ✔
1881
                        MinItems_mode,
120 ✔
1882
                        Items,
120 ✔
1883
                        PrefixItems
120 ✔
1884
                >,
120 ✔
1885
        ): SchemaObject {
120 ✔
1886
                if (
120 ✔
1887
                        'prefixItems' in schema
120 ✔
1888
                        && undefined !== schema.prefixItems
120 ✔
1889
                        && index < schema.prefixItems.length
120 ✔
1890
                ) {
120 ✔
1891
                        return schema.prefixItems[index];
24 ✔
1892
                } else if (false !== schema.items) {
120 ✔
1893
                        return schema.items;
95 ✔
1894
                }
95 ✔
1895

1 ✔
1896
                throw new TypeError('Invalid schema detected!');
1 ✔
1897
        }
120 ✔
1898
}
19 ✔
1899

19 ✔
1900
export type {
19 ✔
1901
        array_mode,
19 ✔
1902
        specified_mode,
19 ✔
1903
        unique_items_mode,
19 ✔
1904
        MinItemsType_mode,
19 ✔
1905
        array_options,
19 ✔
1906
        array_type,
19 ✔
1907
        array_schema,
19 ✔
1908
};
19 ✔
1909

19 ✔
1910
export {
19 ✔
1911
        ArrayType,
19 ✔
1912
};
19 ✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc