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

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19133596245

06 Nov 2025 11:06AM UTC coverage: 99.84% (-0.2%) from 100.0%
19133596245

push

github

SignpostMarv
hoisting $ref check

576 of 579 branches covered (99.48%)

Branch coverage included in aggregate %.

17 of 17 new or added lines in 1 file covered. (100.0%)

12 existing lines in 1 file now uncovered.

8794 of 8806 relevant lines covered (99.86%)

505.31 hits per line

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

98.95
/src/JSONSchema/Object.ts
1
import type {
19✔
2
        IndexSignatureDeclaration,
19✔
3
        ObjectLiteralExpression,
19✔
4
        PropertySignature,
19✔
5
        TypeNode,
19✔
6
} from 'typescript';
19✔
7
import {
19✔
8
        SyntaxKind,
19✔
9
} from 'typescript';
19✔
10

19✔
11
import type {
19✔
12
        SchemaDefinitionDefinition,
19✔
13
        SchemaDefinitionDefinitionWith$defs,
19✔
14
        TypeDefinitionSchema,
19✔
15
        TypeOptions,
19✔
16
} from './Type.ts';
19✔
17
import {
19✔
18
        $defs_schema,
19✔
19
        Type,
19✔
20
} from './Type.ts';
19✔
21

19✔
22
import type {
19✔
23
        ExternalRef,
19✔
24
        LocalRef,
19✔
25
        pattern_either,
19✔
26
} from './Ref.ts';
19✔
27

19✔
28
import {
19✔
29
        $ref,
19✔
30
} from './Ref.ts';
19✔
31

19✔
32
import type {
19✔
33
        unknown_type,
19✔
34
} from './Unknown.ts';
19✔
35

19✔
36
import type {
19✔
37
        ObjectOfSchemas,
19✔
38
        SchemaObject,
19✔
39
// eslint-disable-next-line imports/no-relative-parent-imports
19✔
40
} from '../types.ts';
19✔
41

19✔
42
import type {
19✔
43
        IntersectionTypeNode,
19✔
44
        TypeLiteralNode,
19✔
45
        TypeReferenceNode,
19✔
46
// eslint-disable-next-line imports/no-relative-parent-imports
19✔
47
} from '../typescript/types.ts';
19✔
48

19✔
49
import type {
19✔
50
        adjust_name_callback,
19✔
51
// eslint-disable-next-line imports/no-relative-parent-imports
19✔
52
} from '../coercions.ts';
19✔
53
import {
19✔
54
        adjust_name_default,
19✔
55
// eslint-disable-next-line imports/no-relative-parent-imports
19✔
56
} from '../coercions.ts';
19✔
57

19✔
58
import {
19✔
59
        factory,
19✔
60
// eslint-disable-next-line imports/no-relative-parent-imports
19✔
61
} from '../typescript/factory.ts';
19✔
62

19✔
63
import type {
19✔
64
        SchemaParser,
19✔
65
// eslint-disable-next-line imports/no-relative-parent-imports
19✔
66
} from '../SchemaParser.ts';
19✔
67

19✔
68
type object_properties_mode = (
19✔
69
        | 'neither'
19✔
70
        | 'both'
19✔
71
        | 'properties'
19✔
72
        | 'pattern'
19✔
73
);
19✔
74

19✔
75
type object_type_base<
19✔
76
        PropertiesMode extends object_properties_mode,
19✔
77
        Defs extends SchemaObject,
19✔
78
        Required extends readonly [string, ...string[]],
19✔
79
        Properties extends ObjectOfSchemas,
19✔
80
        PatternProperties extends ObjectOfSchemas,
19✔
81
> = (
19✔
82
        & {
19✔
83
                $defs?: Defs,
19✔
84
                $ref?: LocalRef|ExternalRef,
19✔
85
                type: 'object',
19✔
86
                required?: Required,
19✔
87
                additionalProperties?: boolean,
19✔
88
                unevaluatedProperties?: boolean,
19✔
89
        }
19✔
90
        & Omit<
19✔
91
                {
19✔
92
                        properties: Properties,
19✔
93
                        patternProperties: PatternProperties,
19✔
94
                },
19✔
95
                {
19✔
96
                        both: '',
19✔
97
                        neither: 'properties'|'patternProperties',
19✔
98
                        properties: 'patternProperties',
19✔
99
                        pattern: 'properties',
19✔
100
                }[PropertiesMode]
19✔
101
        >
19✔
102
);
19✔
103

19✔
104
type object_type<
19✔
105
        PropertiesMode extends object_properties_mode,
19✔
106
        Defs extends SchemaObject,
19✔
107
        Required extends readonly [string, ...string[]],
19✔
108
        Properties extends ObjectOfSchemas,
19✔
109
        PatternProperties extends ObjectOfSchemas,
19✔
110
> = (
19✔
111
        | object_type_base<
19✔
112
                PropertiesMode,
19✔
113
                Defs,
19✔
114
                Required,
19✔
115
                Properties,
19✔
116
                PatternProperties
19✔
117
        >
19✔
118
        | {
19✔
119
                type: 'object',
19✔
120
                $defs: Defs,
19✔
121
                $ref: LocalRef|ExternalRef,
19✔
122
        }
19✔
123
);
19✔
124

19✔
125
type object_schema_required<
19✔
126
        PropertiesMode extends object_properties_mode,
19✔
127
> = (
19✔
128
        & readonly [string, ...string[]]
19✔
129
        & [
19✔
130
                'type',
19✔
131
                ...{
19✔
132
                        neither: readonly string[],
19✔
133
                        both: readonly ['properties', 'patternProperties'],
19✔
134
                        properties: readonly ['properties'],
19✔
135
                        pattern: readonly ['patternProperties'],
19✔
136
                }[PropertiesMode],
19✔
137
        ]
19✔
138
);
19✔
139

19✔
140
type object_schema_properties_base = {
19✔
141
        type: {
19✔
142
                type: 'string',
19✔
143
                const: 'object',
19✔
144
        },
19✔
145
        required: {
19✔
146
                type: 'array',
19✔
147
                minItems: 1,
19✔
148
                items: {
19✔
149
                        type: 'string',
19✔
150
                        minLength: 1,
19✔
151
                },
19✔
152
        },
19✔
153
        $ref: {
19✔
154
                type: 'string',
19✔
155
                pattern: pattern_either,
19✔
156
        },
19✔
157
        additionalProperties: {
19✔
158
                type: 'boolean',
19✔
159
        },
19✔
160
        unevaluatedProperties: {
19✔
161
                type: 'boolean',
19✔
162
        },
19✔
163
};
19✔
164

19✔
165
type object_schema_properties_properties = {
19✔
166
        properties: {
19✔
167
                type: 'object',
19✔
168
                minProperties: 1,
19✔
169
                additionalProperties: {
19✔
170
                        type: 'object',
19✔
171
                },
19✔
172
        },
19✔
173
};
19✔
174

19✔
175
type object_schema_properties_pattern = {
19✔
176
        patternProperties: {
19✔
177
                type: 'object',
19✔
178
                minProperties: 1,
19✔
179
                additionalProperties: {
19✔
180
                        type: 'object',
19✔
181
                },
19✔
182
        },
19✔
183
};
19✔
184

19✔
185
type object_properties_by_mode<
19✔
186
        PropertiesMode extends object_properties_mode,
19✔
187
> = {
19✔
188
        both: (
19✔
189
                & object_schema_properties_properties
19✔
190
                & object_schema_properties_pattern
19✔
191
        ),
19✔
192
        properties: object_schema_properties_properties,
19✔
193
        pattern: object_schema_properties_pattern,
19✔
194
        neither: {
19✔
195
                additionalProperties: {
19✔
196
                        type: 'boolean',
19✔
197
                        const: false,
19✔
198
                },
19✔
199
                maxProperties: {
19✔
200
                        type: 'integer',
19✔
201
                        const: 0,
19✔
202
                },
19✔
203
        },
19✔
204
}[PropertiesMode];
19✔
205

19✔
206
type object_schema<
19✔
207
        PropertiesMode extends object_properties_mode,
19✔
208
> = SchemaDefinitionDefinitionWith$defs<
19✔
209
        object_schema_required<PropertiesMode>,
19✔
210
        (
19✔
211
                & ObjectOfSchemas
19✔
212
                & object_schema_properties_base
19✔
213
                & object_properties_by_mode<PropertiesMode>
19✔
214
        )
19✔
215
>;
19✔
216

19✔
217
type object_TypeLiteralNode<
19✔
218
        PropertiesMode extends object_properties_mode,
19✔
219
> = {
19✔
220
        ['neither']: TypeLiteralNode<
19✔
221
                IndexSignatureDeclaration
19✔
222
        >,
19✔
223
        ['both']: IntersectionTypeNode<[
19✔
224
                TypeLiteralNode<PropertySignature>,
19✔
225
                TypeLiteralNode<IndexSignatureDeclaration>,
19✔
226
        ]>,
19✔
227
        ['properties']: TypeLiteralNode<PropertySignature>,
19✔
228
        ['pattern']: TypeLiteralNode<
19✔
229
                IndexSignatureDeclaration
19✔
230
        >,
19✔
231
}[PropertiesMode];
19✔
232

19✔
233
type object_TypeLiteralNode_possibly_extended<
19✔
234
        PropertiesMode extends object_properties_mode,
19✔
235
> = (
19✔
236
        | object_TypeLiteralNode<PropertiesMode>
19✔
237
        | IntersectionTypeNode<[
19✔
238
                TypeReferenceNode,
19✔
239
                object_TypeLiteralNode<PropertiesMode>,
19✔
240
        ]>
19✔
241
);
19✔
242

19✔
243
type ObjectUncertain_options<
19✔
244
        SchemaDefinition extends (
19✔
245
                SchemaDefinitionDefinition
19✔
246
        ) = (
19✔
247
                SchemaDefinitionDefinition
19✔
248
        ),
19✔
249
        TypeDefinition extends TypeDefinitionSchema = TypeDefinitionSchema,
19✔
250
> = (
19✔
251
        & Omit<
19✔
252
                TypeOptions<SchemaDefinition, TypeDefinition>,
19✔
253
                (
19✔
254
                        | 'schema_definition'
19✔
255
                        | 'type_definition'
19✔
256
                )
19✔
257
        >
19✔
258
);
19✔
259

19✔
260
class ObjectUnspecified<
19✔
261
        T extends {[key: string]: unknown},
19✔
262
        PropertiesMode extends object_properties_mode,
19✔
263
        Defs extends SchemaObject = SchemaObject,
19✔
264
        Required extends (
19✔
265
                readonly [string, ...string[]]
19✔
266
        ) = (
19✔
267
                readonly [string, ...string[]]
19✔
268
        ),
19✔
269
        Properties extends ObjectOfSchemas = ObjectOfSchemas,
19✔
270
        PatternProperties extends ObjectOfSchemas = ObjectOfSchemas,
19✔
271
> extends
19✔
272
        Type<
19✔
273
                T,
19✔
274
                object_type<
19✔
275
                        PropertiesMode,
19✔
276
                        Defs,
19✔
277
                        Required,
19✔
278
                        Properties,
19✔
279
                        PatternProperties
19✔
280
                >,
19✔
281
                {
19✔
282
                        properties_mode: PropertiesMode,
19✔
283
                        $defs?: Defs,
19✔
284
                        required?: Required,
19✔
285
                        properties?: Properties,
19✔
286
                        patternProperties?: PatternProperties,
19✔
287
                },
19✔
288
                object_schema<
19✔
289
                        PropertiesMode
19✔
290
                >,
19✔
291
                {
19✔
292
                        properties_mode: PropertiesMode,
19✔
293
                },
19✔
294
                (
19✔
295
                        | object_TypeLiteralNode<PropertiesMode>
19✔
296
                        | IntersectionTypeNode<[
19✔
297
                                TypeReferenceNode,
19✔
298
                                object_TypeLiteralNode<PropertiesMode>,
19✔
299
                        ]>
19✔
300
                ),
19✔
301
                ObjectLiteralExpression
19✔
302
        > {
19✔
303
        #adjust_name: adjust_name_callback;
19✔
304

1,142✔
305
        readonly properties_mode: PropertiesMode;
19✔
306

19✔
307
        constructor(
19✔
308
                options: {
1,142✔
309
                        adjust_name?: adjust_name_callback,
1,142✔
310
                        properties_mode: PropertiesMode,
1,142✔
311
                        $defs?: Defs,
1,142✔
312
                        required?: Required,
1,142✔
313
                        properties?: Properties,
1,142✔
314
                        patternProperties?: PatternProperties,
1,142✔
315
                },
1,142✔
316
                {
1,142✔
317
                        ajv,
1,142✔
318
                }: ObjectUncertain_options<
1,142✔
319
                        object_schema<
1,142✔
320
                                PropertiesMode
1,142✔
321
                        >,
1,142✔
322
                        object_type<
1,142✔
323
                                PropertiesMode,
1,142✔
324
                                Defs,
1,142✔
325
                                Required,
1,142✔
326
                                Properties,
1,142✔
327
                                PatternProperties
1,142✔
328
                        >
1,142✔
329
                >,
1,142✔
330
        ) {
1,142✔
331
                super({
1,142✔
332
                        ajv,
1,142✔
333
                        type_definition: options,
1,142✔
334
                        schema_definition: options,
1,142✔
335
                });
1,142✔
336

1,142✔
337
                this.#adjust_name = options?.adjust_name || adjust_name_default;
1,142✔
338
                this.properties_mode = options.properties_mode;
1,142✔
339
        }
1,142✔
340

19✔
341
        generate_typescript_data(
19✔
342
                data: T,
80✔
343
                schema_parser: SchemaParser,
80✔
344
                schema: object_type<
80✔
345
                        PropertiesMode,
80✔
346
                        Defs,
80✔
347
                        Required,
80✔
348
                        Properties,
80✔
349
                        PatternProperties
80✔
350
                >,
80✔
351
        ): ObjectLiteralExpression {
80✔
352
                return ObjectUnspecified.#createObjectLiteralExpression(
80✔
353
                        this.properties_mode,
80✔
354
                        data,
80✔
355
                        schema,
80✔
356
                        schema_parser,
80✔
357
                        this.#adjust_name,
80✔
358
                );
80✔
359
        }
80✔
360

19✔
361
        async generate_typescript_type(
19✔
362
                {
34✔
363
                        schema,
34✔
364
                        schema_parser,
34✔
365
                }: {
34✔
366
                        schema: object_type<
34✔
367
                                PropertiesMode,
34✔
368
                                Defs,
34✔
369
                                Required,
34✔
370
                                Properties,
34✔
371
                                PatternProperties
34✔
372
                        >,
34✔
373
                        schema_parser: SchemaParser,
34✔
374
                },
34✔
375
        ): Promise<object_TypeLiteralNode_possibly_extended<PropertiesMode>> {
34✔
376
                let object_type: (
34✔
377
                        | Promise<object_TypeLiteralNode<PropertiesMode>>
34✔
378
                        | IntersectionTypeNode<[
34✔
379
                                TypeReferenceNode,
34✔
380
                                object_TypeLiteralNode<PropertiesMode>,
34✔
381
                        ]>
34✔
382
                ) = ObjectUnspecified.#createTypeNode(
34✔
383
                        this.properties_mode,
34✔
384
                        schema,
34✔
385
                        schema_parser,
34✔
386
                );
34✔
387

34✔
388
                if ('string' === typeof schema?.$ref) {
34✔
389
                        const $ref_instance = schema_parser.parse_by_type({
9✔
390
                                $ref: schema.$ref,
9✔
391
                        }, (maybe): maybe is $ref => $ref.is_a(maybe));
9✔
392

9✔
393
                        object_type = factory.createIntersectionTypeNode([
9✔
394
                                await $ref_instance.generate_typescript_type({
9✔
395
                                        schema: {
9✔
396
                                                $ref: schema.$ref,
9✔
397
                                        },
9✔
398
                                }),
9✔
399
                                await object_type,
9✔
400
                        ]);
9✔
401
                }
9✔
402

34✔
403
                return object_type;
34✔
404
        }
34✔
405

19✔
406
        static generate_schema_definition<
19✔
407
                PropertiesMode extends object_properties_mode,
1,146✔
408
        >({
1,146✔
409
                properties_mode,
1,146✔
410
        }: {
1,146✔
411
                properties_mode: PropertiesMode,
1,146✔
412
        }): Readonly<object_schema<
1,146✔
413
                PropertiesMode
1,146✔
414
        >> {
1,146✔
415
                const required_for_partial = (
1,146✔
416
                        this.#generate_schema_definition_required(
1,146✔
417
                                properties_mode,
1,146✔
418
                        )
1,146✔
419
                );
1,146✔
420

1,146✔
421
                const properties_for_partial: Partial<
1,146✔
422
                        object_schema<'both'>['properties']
1,146✔
423
                > = {
1,146✔
424
                        ...$defs_schema.properties,
1,146✔
425
                        type: {
1,146✔
426
                                type: 'string',
1,146✔
427
                                const: 'object',
1,146✔
428
                        },
1,146✔
429
                        $ref: {
1,146✔
430
                                type: 'string',
1,146✔
431
                                pattern: '^(.+)?#\\/\\$defs\\/(.+)$',
1,146✔
432
                        },
1,146✔
433
                        additionalProperties: {
1,146✔
434
                                type: 'boolean',
1,146✔
435
                        },
1,146✔
436
                        unevaluatedProperties: {
1,146✔
437
                                type: 'boolean',
1,146✔
438
                        },
1,146✔
439
                };
1,146✔
440

1,146✔
441
                properties_for_partial.required = {
1,146✔
442
                        type: 'array',
1,146✔
443
                        minItems: 1,
1,146✔
444
                        items: {
1,146✔
445
                                type: 'string',
1,146✔
446
                                minLength: 1,
1,146✔
447
                        },
1,146✔
448
                };
1,146✔
449

1,146✔
450
                if ('pattern' !== properties_mode && 'neither' !== properties_mode) {
1,146✔
451
                        const properties: (
582✔
452
                                object_schema<
582✔
453
                                        'properties'
582✔
454
                                >['properties']['properties']
582✔
455
                        ) = {
582✔
456
                                type: 'object',
582✔
457
                                minProperties: 1,
582✔
458
                                additionalProperties: {
582✔
459
                                        type: 'object',
582✔
460
                                },
582✔
461
                        };
582✔
462
                        properties_for_partial.properties = properties;
582✔
463
                }
582✔
464
                if (
1,146✔
465
                        'properties' !== properties_mode
1,146✔
466
                        && 'neither' !== properties_mode
1,146✔
467
                ) {
1,146✔
468
                        const properties: (
562✔
469
                                object_schema<
562✔
470
                                        'pattern'
562✔
471
                                >['properties']['patternProperties']
562✔
472
                        ) = {
562✔
473
                                type: 'object',
562✔
474
                                minProperties: 1,
562✔
475
                                additionalProperties: {
562✔
476
                                        type: 'object',
562✔
477
                                },
562✔
478
                        };
562✔
479
                        properties_for_partial.patternProperties = properties;
562✔
480
                }
562✔
481

1,146✔
482
                if ('neither' === properties_mode) {
1,146✔
483
                        (
283✔
484
                                properties_for_partial as Partial<
283✔
485
                                        object_schema<'neither'>['properties']
283✔
486
                                >
283✔
487
                        ).additionalProperties = {
283✔
488
                                type: 'boolean',
283✔
489
                                const: false,
283✔
490
                        };
283✔
491
                        (
283✔
492
                                properties_for_partial as Partial<
283✔
493
                                        object_schema<'neither'>['properties']
283✔
494
                                >
283✔
495
                        ).maxProperties = {
283✔
496
                                type: 'integer',
283✔
497
                                const: 0,
283✔
498
                        };
283✔
499
                }
283✔
500

1,146✔
501
                const unpartial_properties: object_schema<
1,146✔
502
                        PropertiesMode
1,146✔
503
                >['properties'] = properties_for_partial as object_schema<
1,146✔
504
                        PropertiesMode
1,146✔
505
                >['properties'];
1,146✔
506

1,146✔
507
                const partial_required: object_schema<
1,146✔
508
                        PropertiesMode
1,146✔
509
                >['required'] = required_for_partial;
1,146✔
510
                const partial_properties: object_schema<
1,146✔
511
                        PropertiesMode
1,146✔
512
                >['properties'] = unpartial_properties;
1,146✔
513

1,146✔
514
                const result: object_schema<
1,146✔
515
                        PropertiesMode
1,146✔
516
                > = {
1,146✔
517
                        type: 'object',
1,146✔
518
                        required: partial_required,
1,146✔
519
                        additionalProperties: false,
1,146✔
520
                        properties: partial_properties,
1,146✔
521
                } as object_schema<
1,146✔
522
                        PropertiesMode
1,146✔
523
                >;
1,146✔
524

1,146✔
525
                return Object.freeze(result);
1,146✔
526
        }
1,146✔
527

19✔
528
        static #generate_schema_definition_required<
19✔
529
                PropertiesMode extends object_properties_mode,
1,146✔
530
        >(
1,146✔
531
                properties_mode: PropertiesMode,
1,146✔
532
        ): object_schema<
1,146✔
533
                PropertiesMode
1,146✔
534
        >['required'] {
1,146✔
535
                const values_for_properties_mode: {
1,146✔
536
                        neither: readonly string[],
1,146✔
537
                        both: readonly ['properties', 'patternProperties'],
1,146✔
538
                        properties: readonly ['properties'],
1,146✔
539
                        pattern: readonly ['patternProperties'],
1,146✔
540
                }[PropertiesMode] = {
1,146✔
541
                        neither: [] as readonly string[],
1,146✔
542
                        both: ['properties', 'patternProperties'] as const,
1,146✔
543
                        properties: ['properties'] as const,
1,146✔
544
                        pattern: ['patternProperties'] as const,
1,146✔
545
                }[properties_mode];
1,146✔
546

1,146✔
547
                const required: object_schema<
1,146✔
548
                        PropertiesMode
1,146✔
549
                >['required'] = [
1,146✔
550
                        ...['type'],
1,146✔
551
                        ...values_for_properties_mode,
1,146✔
552
                ] as object_schema<
1,146✔
553
                        PropertiesMode
1,146✔
554
                >['required'];
1,146✔
555

1,146✔
556
                return required;
1,146✔
557
        }
1,146✔
558

19✔
559
        static generate_type_definition<
19✔
560
                PropertiesMode extends object_properties_mode,
1,142✔
561
                Defs extends SchemaObject,
1,142✔
562
                Required extends readonly [string, ...string[]],
1,142✔
563
                Properties extends ObjectOfSchemas,
1,142✔
564
                PatternProperties extends ObjectOfSchemas,
1,142✔
565
        >({
1,142✔
566
                properties_mode,
1,142✔
567
                $defs,
1,142✔
568
                required,
1,142✔
569
                properties,
1,142✔
570
                patternProperties,
1,142✔
571
        }: {
1,142✔
572
                properties_mode: PropertiesMode,
1,142✔
573
                $defs?: Defs,
1,142✔
574
                required?: Required,
1,142✔
575
                properties?: Properties,
1,142✔
576
                patternProperties?: PatternProperties,
1,142✔
577
        }): Readonly<object_type_base<
1,142✔
578
                PropertiesMode,
1,142✔
579
                Defs,
1,142✔
580
                Required,
1,142✔
581
                Properties,
1,142✔
582
                PatternProperties
1,142✔
583
        >> {
1,142✔
584
                const partial: Partial<object_type_base<
1,142✔
585
                        'both',
1,142✔
586
                        Defs,
1,142✔
587
                        Required,
1,142✔
588
                        Properties,
1,142✔
589
                        PatternProperties
1,142✔
590
                >> = {
1,142✔
591
                        type: 'object',
1,142✔
592
                };
1,142✔
593

1,142✔
594
                if ($defs) {
1,142✔
595
                        partial.$defs = $defs;
8✔
596
                }
8✔
597

1,142✔
598
                if (required) {
1,142✔
599
                        partial.required = required;
4✔
600
                }
4✔
601

1,142✔
602
                if ('both' === properties_mode || 'properties' === properties_mode) {
1,142✔
603
                        partial.properties = properties;
580✔
604
                }
580✔
605

1,142✔
606
                if (
1,142✔
607
                        'both' === properties_mode
1,142✔
608
                        || 'pattern' === properties_mode
1,142✔
609
                ) {
1,142✔
610
                        partial.patternProperties = patternProperties;
560✔
611
                }
560✔
612

1,142✔
613
                const frozen = Object.freeze(partial as object_type_base<
1,142✔
614
                        PropertiesMode,
1,142✔
615
                        Defs,
1,142✔
616
                        Required,
1,142✔
617
                        Properties,
1,142✔
618
                        PatternProperties
1,142✔
619
                >);
1,142✔
620

1,142✔
621
                return frozen;
1,142✔
622
        }
1,142✔
623

19✔
624
        static #is_schema_with_some_type_of_properties<
19✔
625
                Defs extends SchemaObject,
34✔
626
                Required extends readonly [string, ...string[]],
34✔
627
                Properties extends ObjectOfSchemas,
34✔
628
                PatternProperties extends ObjectOfSchemas,
34✔
629
        >(
34✔
630
                schema: object_type<
34✔
631
                        object_properties_mode,
34✔
632
                        Defs,
34✔
633
                        Required,
34✔
634
                        Properties,
34✔
635
                        PatternProperties
34✔
636
                >,
34✔
637
        ): schema is object_type<
34✔
638
                'both'|'properties'|'pattern',
34✔
639
                Defs,
34✔
640
                Required,
34✔
641
                Properties,
34✔
642
                PatternProperties
34✔
643
        > {
34✔
644
                return ('properties' in schema) || ('patternProperties' in schema);
34✔
645
        }
34✔
646

19✔
647
        static #is_schema_with_properties<
19✔
648
                Defs extends SchemaObject,
1,006✔
649
                Required extends readonly [string, ...string[]],
1,006✔
650
                Properties extends ObjectOfSchemas,
1,006✔
651
                PatternProperties extends ObjectOfSchemas,
1,006✔
652
        >(
1,006✔
653
                schema: SchemaObject|object_type<
1,006✔
654
                        object_properties_mode,
1,006✔
655
                        Defs,
1,006✔
656
                        Required,
1,006✔
657
                        Properties,
1,006✔
658
                        PatternProperties
1,006✔
659
                >,
1,006✔
660
        ): schema is object_type_base<
1,006✔
661
                'both' | 'properties',
1,006✔
662
                Defs,
1,006✔
663
                Required,
1,006✔
664
                Properties,
1,006✔
665
                PatternProperties
1,006✔
666
        > {
1,006✔
667
                return 'properties' in schema;
1,006✔
668
        }
1,006✔
669

19✔
670
        static #is_schema_with_pattern_properties<
19✔
671
                Defs extends SchemaObject,
781✔
672
                Required extends readonly [string, ...string[]],
781✔
673
                Properties extends ObjectOfSchemas,
781✔
674
                PatternProperties extends ObjectOfSchemas,
781✔
675
        >(
781✔
676
                schema: SchemaObject|object_type<
781✔
677
                        object_properties_mode,
781✔
678
                        Defs,
781✔
679
                        Required,
781✔
680
                        Properties,
781✔
681
                        PatternProperties
781✔
682
                >,
781✔
683
        ): schema is object_type_base<
781✔
684
                'both'|'pattern',
781✔
685
                Defs,
781✔
686
                Required,
781✔
687
                Properties,
781✔
688
                PatternProperties
781✔
689
        > {
781✔
690
                return 'patternProperties' in schema;
781✔
691
        }
781✔
692

19✔
693
        static #is_schema_with_required<
19✔
694
                Required extends readonly [string, ...string[]],
33✔
695
        >(
33✔
696
                schema: object_type<
33✔
697
                        object_properties_mode,
33✔
698
                        SchemaObject,
33✔
699
                        Required,
33✔
700
                        ObjectOfSchemas,
33✔
701
                        ObjectOfSchemas
33✔
702
                >,
33✔
703
        ): schema is object_type<
33✔
704
                object_properties_mode,
33✔
705
                SchemaObject,
33✔
706
                Required,
33✔
707
                ObjectOfSchemas,
33✔
708
                ObjectOfSchemas
33✔
709
        > & {required: Required} {
33✔
710
                return 'required' in schema;
33✔
711
        }
33✔
712

19✔
713
        static #convert<
19✔
714
                T,
149✔
715
                PropertiesMode extends object_properties_mode,
149✔
716
                Defs extends SchemaObject,
149✔
717
                Required extends readonly [string, ...string[]],
149✔
718
                Properties extends ObjectOfSchemas,
149✔
719
                PatternProperties extends ObjectOfSchemas,
149✔
720
        >(
149✔
721
                properties_mode: PropertiesMode,
149✔
722
                value: unknown,
149✔
723
                property: string,
149✔
724
                schema: object_type<
149✔
725
                        PropertiesMode,
149✔
726
                        Defs,
149✔
727
                        Required,
149✔
728
                        Properties,
149✔
729
                        PatternProperties
149✔
730
                >,
149✔
731
                schema_parser: SchemaParser,
149✔
732
        ) {
149✔
733
                const sub_schema = this.#sub_schema_for_property(
149✔
734
                        schema_parser,
149✔
735
                        properties_mode,
149✔
736
                        property,
149✔
737
                        schema,
149✔
738
                        {},
149✔
739
                );
149✔
740

149✔
741
                let maybe_modified = ObjectUnspecified.maybe_add_$defs(
149✔
742
                        schema,
149✔
743
                        sub_schema,
149✔
744
                );
149✔
745

149✔
746
                const ajv = schema_parser.share_ajv((ajv) => ajv);
149✔
747
                const validator = ajv.compile<T>(maybe_modified);
149✔
748

149✔
749
                if (!(validator(value))) {
149✔
750
                        throw new TypeError('Supplied value not supported by property!');
30✔
751
                }
30✔
752

115✔
753
                if (0 === Object.keys(sub_schema).length) {
149✔
754
                        maybe_modified = {
4✔
755
                                type: 'object',
4✔
756
                                additionalProperties: false,
4✔
757
                                maxProperties: 0,
4✔
758
                        };
4✔
759
                }
4✔
760

115✔
761
                const instance = schema_parser.parse(
115✔
762
                        maybe_modified,
115✔
763
                );
115✔
764

115✔
765
                return instance.generate_typescript_data(
115✔
766
                        value,
115✔
767
                        schema_parser,
115✔
768
                        maybe_modified,
115✔
769
                );
115✔
770
        }
149✔
771

19✔
772
        static #createObjectLiteralExpression<
19✔
773
                T extends {[key: string]: unknown},
80✔
774
                PropertiesMode extends object_properties_mode,
80✔
775
                Defs extends SchemaObject,
80✔
776
                Required extends readonly [string, ...string[]],
80✔
777
                Properties extends ObjectOfSchemas,
80✔
778
                PatternProperties extends ObjectOfSchemas,
80✔
779
        >(
80✔
780
                properties_mode: PropertiesMode,
80✔
781
                data: T,
80✔
782
                schema: object_type<
80✔
783
                        PropertiesMode,
80✔
784
                        Defs,
80✔
785
                        Required,
80✔
786
                        Properties,
80✔
787
                        PatternProperties
80✔
788
                >,
80✔
789
                schema_parser: SchemaParser,
80✔
790
                adjust_name: adjust_name_callback,
80✔
791
        ): ObjectLiteralExpression {
80✔
792
                return factory.createObjectLiteralExpression(
80✔
793
                        Object.entries(
80✔
794
                                data,
80✔
795
                        ).map(([
80✔
796
                                property,
149✔
797
                                value,
149✔
798
                        ]) => {
149✔
799
                                const type = this.#convert(
149✔
800
                                        properties_mode,
149✔
801
                                        value,
149✔
802
                                        property,
149✔
803
                                        schema,
149✔
804
                                        schema_parser,
149✔
805
                                );
149✔
806

149✔
807
                                return factory.createPropertyAssignment(
149✔
808
                                        adjust_name(property),
149✔
809
                                        type,
149✔
810
                                );
149✔
811
                        }),
80✔
812
                );
80✔
813
        }
80✔
814

19✔
815
        static async #createTypeNode<
19✔
816
                PropertiesMode extends object_properties_mode,
34✔
817
                Defs extends SchemaObject,
34✔
818
                Required extends readonly [string, ...string[]],
34✔
819
                Properties extends ObjectOfSchemas,
34✔
820
                PatternProperties extends ObjectOfSchemas,
34✔
821
        >(
34✔
822
                properties_mode: PropertiesMode,
34✔
823
                schema: object_type<
34✔
824
                        PropertiesMode,
34✔
825
                        Defs,
34✔
826
                        Required,
34✔
827
                        Properties,
34✔
828
                        PatternProperties
34✔
829
                >,
34✔
830
                schema_parser: SchemaParser,
34✔
831
        ): Promise<object_TypeLiteralNode<PropertiesMode>> {
34✔
832
                if (!this.#is_schema_with_some_type_of_properties(schema)) {
34✔
833
                        return factory.createTypeLiteralNode([
4✔
834
                                factory.createIndexSignature(
4✔
835
                                        undefined,
4✔
836
                                        [
4✔
837
                                                factory.createParameterDeclaration(
4✔
838
                                                        undefined,
4✔
839
                                                        undefined,
4✔
840
                                                        factory.createIdentifier('key'),
4✔
841
                                                        undefined,
4✔
842
                                                        factory.createToken(SyntaxKind.StringKeyword),
4✔
843
                                                ),
4✔
844
                                        ],
4✔
845
                                        factory.createToken(SyntaxKind.UnknownKeyword),
4✔
846
                                ),
4✔
847
                        ]) as object_TypeLiteralNode<PropertiesMode>;
4✔
848
                }
4✔
849

30✔
850
                let properties: PropertySignature[] = [];
30✔
851
                let patterned: [TypeNode, ...TypeNode[]]|never[] = [];
30✔
852

30✔
853
                if (this.#is_schema_with_properties(schema)) {
34✔
854
                        properties = await Promise.all(Object.keys(
26✔
855
                                schema.properties,
26✔
856
                        ).map(async (
26✔
857
                                property,
33✔
858
                        ): Promise<PropertySignature> => factory.createPropertySignature(
33✔
859
                                undefined,
33✔
860
                                (
33✔
861
                                        /[?[\] ]/.test(property)
33✔
862
                                                ? factory.createComputedPropertyName(
33✔
863
                                                        factory.createStringLiteral(property),
2✔
864
                                                )
2✔
865
                                                : property
33✔
866
                                ),
33✔
867
                                (
33✔
868
                                        (
33✔
869
                                                this.#is_schema_with_required(schema)
33✔
870
                                                && schema.required.includes(property)
33✔
871
                                        )
33✔
872
                                                ? undefined
33✔
873
                                                : factory.createToken(SyntaxKind.QuestionToken)
33✔
874
                                ),
33✔
875
                                await this.#generate_type(
33✔
876
                                        properties_mode,
33✔
877
                                        property,
33✔
878
                                        schema,
33✔
879
                                        schema_parser,
33✔
880
                                ),
33✔
881
                        )));
26✔
882
                }
26✔
883

30✔
884
                if (this.#is_schema_with_pattern_properties(schema)) {
34✔
885
                        patterned = await Promise.all(
6✔
886
                                (
6✔
887
                                        Object.values(
6✔
888
                                                schema.patternProperties,
6✔
889
                                        )
6✔
890
                                ).map(
6✔
891
                                        (sub_schema) => {
6✔
892
                                                return schema_parser.parse(
10✔
893
                                                        ObjectUnspecified.maybe_add_$defs(
10✔
894
                                                                schema,
10✔
895
                                                                sub_schema,
10✔
896
                                                        ),
10✔
897
                                                ).generate_typescript_type({
10✔
898
                                                        data: sub_schema,
10✔
899
                                                        schema: sub_schema,
10✔
900
                                                        schema_parser,
10✔
901
                                                });
10✔
902
                                        },
6✔
903
                                ),
6✔
904
                        );
6✔
905
                }
6✔
906

30✔
907
                let result: object_TypeLiteralNode<
30✔
908
                        Exclude<
30✔
909
                                object_properties_mode,
30✔
910
                                'neither'
30✔
911
                        >
30✔
912
                >;
30✔
913

30✔
914
                if (properties.length > 0 && patterned.length > 0) {
34✔
915
                        result = factory.createIntersectionTypeNode([
2✔
916
                                factory.createTypeLiteralNode(properties),
2✔
917
                                this.#patterned_literal_node(
2✔
918
                                        patterned as [TypeNode, ...TypeNode[]],
2✔
919
                                ),
2✔
920
                        ]);
2✔
921
                } else if (properties.length > 0) {
34✔
922
                        result = factory.createTypeLiteralNode(properties);
24✔
923
                } else {
28✔
924
                        result = this.#patterned_literal_node(
4✔
925
                                patterned as [TypeNode, ...TypeNode[]],
4✔
926
                        );
4✔
927
                }
4✔
928

30✔
929
                return result as object_TypeLiteralNode<PropertiesMode>;
30✔
930
        }
34✔
931

19✔
932
        static async #generate_type<
19✔
933
                PropertiesMode extends object_properties_mode,
33✔
934
                Defs extends SchemaObject,
33✔
935
                Required extends readonly [string, ...string[]],
33✔
936
                Properties extends ObjectOfSchemas,
33✔
937
                PatternProperties extends ObjectOfSchemas,
33✔
938
        >(
33✔
939
                properties_mode: PropertiesMode,
33✔
940
                property: string,
33✔
941
                schema: object_type<
33✔
942
                        PropertiesMode,
33✔
943
                        Defs,
33✔
944
                        Required,
33✔
945
                        Properties,
33✔
946
                        PatternProperties
33✔
947
                >,
33✔
948
                schema_parser: SchemaParser,
33✔
949
        ) {
33✔
950
                const sub_schema = this.#sub_schema_for_property(
33✔
951
                        schema_parser,
33✔
952
                        properties_mode,
33✔
953
                        property,
33✔
954
                        schema,
33✔
955
                        {},
33✔
956
                );
33✔
957

33✔
958
                let matched: (
33✔
959
                        | undefined
33✔
960
                        | Type<unknown>
33✔
961
                ) = schema_parser.maybe_parse_by_type<
33✔
962
                        $ref
33✔
963
                >(
33✔
964
                        sub_schema,
33✔
965
                        (
33✔
966
                                maybe: unknown,
166✔
967
                        ): maybe is $ref => {
166✔
968
                                return $ref.is_a(maybe);
166✔
969
                        },
33✔
970
                );
33✔
971

33✔
972
                if (undefined === matched) {
33✔
973
                        matched = schema_parser.parse(sub_schema);
19✔
974
                } else {
33✔
975
                        return matched.generate_typescript_type({
14✔
976
                                data: sub_schema,
14✔
977
                                schema: sub_schema,
14✔
978
                                schema_parser,
14✔
979
                        });
14✔
980
                }
14✔
981

19✔
982
                return matched.generate_typescript_type({
19✔
983
                        schema: sub_schema,
19✔
984
                        schema_parser,
19✔
985
                });
19✔
986
        }
33✔
987

19✔
988
        static #patterned_literal_node(
19✔
989
                value: [TypeNode, ...TypeNode[]],
6✔
990
        ): TypeLiteralNode<IndexSignatureDeclaration> {
6✔
991
                return factory.createTypeLiteralNode([
6✔
992
                        factory.createIndexSignature(
6✔
993
                                undefined,
6✔
994
                                [
6✔
995
                                        factory.createParameterDeclaration(
6✔
996
                                                undefined,
6✔
997
                                                undefined,
6✔
998
                                                'key',
6✔
999
                                                undefined,
6✔
1000
                                                factory.createKeywordTypeNode(
6✔
1001
                                                        SyntaxKind.StringKeyword,
6✔
1002
                                                ),
6✔
1003
                                                undefined,
6✔
1004
                                        ),
6✔
1005
                                ],
6✔
1006
                                1 === value.length
6✔
1007
                                        ? value[0]
6✔
1008
                                        : factory.createUnionTypeNode(
6✔
1009
                                                value as [TypeNode, TypeNode, ...TypeNode[]],
4✔
1010
                                        ),
6✔
1011
                        ),
6✔
1012
                ]);
6✔
1013
        }
6✔
1014

19✔
1015
        static #sub_schema_for_property<
19✔
1016
                PropertiesMode extends object_properties_mode,
228✔
1017
                Defs extends SchemaObject,
228✔
1018
                Required extends readonly [string, ...string[]],
228✔
1019
                Properties extends ObjectOfSchemas,
228✔
1020
                PatternProperties extends ObjectOfSchemas,
228✔
1021
        >(
228✔
1022
                schema_parser: SchemaParser,
228✔
1023
                properties_mode: PropertiesMode,
228✔
1024
                property: string,
228✔
1025
                schema: SchemaObject|object_type<
228✔
1026
                        PropertiesMode,
228✔
1027
                        Defs,
228✔
1028
                        Required,
228✔
1029
                        Properties,
228✔
1030
                        PatternProperties
228✔
1031
                >,
228✔
1032
                fallback_if_neither: Record<string, never>|unknown_type,
228✔
1033
        ): SchemaObject {
228✔
1034
                if (
228✔
1035
                        !this.#is_schema_with_pattern_properties(schema)
228✔
1036
                        && !this.#is_schema_with_properties(schema)
228✔
1037
                        && '$ref' in schema
228✔
1038
                ) {
228✔
1039
                        const maybe = this.#sub_schema_for_property_resolve_$ref(
50✔
1040
                                schema_parser,
50✔
1041
                                schema as SchemaObject & {
50✔
1042
                                        $ref: string,
50✔
1043
                                },
50✔
1044
                        );
50✔
1045

50✔
1046
                        if (maybe) {
50✔
1047
                                schema = maybe;
50✔
1048
                        }
50✔
1049
                }
50✔
1050

228✔
1051
                if (
228✔
1052
                        !this.#is_schema_with_pattern_properties(schema)
228✔
1053
                        && !this.#is_schema_with_properties(schema)
228✔
1054
                        && 'string' === typeof schema.$ref
228✔
1055
                        && 2 === Object.keys(schema).length
228!
1056
                        && '$defs' in schema
228!
1057
                ) {
228!
UNCOV
1058
                        const maybe_replace_schema = (
×
UNCOV
1059
                                this.#sub_schema_for_property_resolve_$ref(
×
UNCOV
1060
                                        schema_parser,
×
UNCOV
1061
                                        schema as SchemaObject & {
×
UNCOV
1062
                                                $ref: string,
×
UNCOV
1063
                                        },
×
UNCOV
1064
                                )
×
UNCOV
1065
                        );
×
UNCOV
1066

×
UNCOV
1067
                        if (maybe_replace_schema) {
×
UNCOV
1068
                                schema = maybe_replace_schema;
×
UNCOV
1069
                        }
×
1070
                } else if (
228✔
1071
                        !this.#is_schema_with_pattern_properties(schema)
228✔
1072
                        && !this.#is_schema_with_properties(schema)
228✔
1073
                        && 'allOf' in schema
228✔
1074
                        && undefined !== schema.allOf
228✔
1075
                        && 2 === Object.keys(schema).length
228✔
1076
                        && '$defs' in schema
228✔
1077
                ) {
228✔
1078
                        const matching = this.#sub_schema_for_property_from_allOf(
15✔
1079
                                schema_parser,
15✔
1080
                                properties_mode,
15✔
1081
                                property,
15✔
1082
                                schema as SchemaObject & {
15✔
1083
                                        allOf: [
15✔
1084
                                                SchemaObject,
15✔
1085
                                                SchemaObject,
15✔
1086
                                                ...SchemaObject[],
15✔
1087
                                        ],
15✔
1088
                                },
15✔
1089
                                fallback_if_neither,
15✔
1090
                        );
15✔
1091

15✔
1092
                        if (matching) {
15✔
1093
                                return matching;
14✔
1094
                        }
14✔
1095

1✔
1096
                        throw new TypeError(
1✔
1097
                                `Property "${property}" has no match on the specified schema!`,
1✔
1098
                        );
1✔
1099
                }
1✔
1100

213✔
1101
                if (
213✔
1102
                        this.#is_schema_with_properties(schema)
213✔
1103
                        && !(property in schema.properties)
228✔
1104
                        && 'string' === typeof schema?.$ref
228✔
1105
                ) {
228✔
1106
                        let checking_schema: (
28✔
1107
                                | SchemaObject
28✔
1108
                                | undefined
28✔
1109
                        ) = schema;
28✔
1110

28✔
1111
                        while (
28✔
1112
                                undefined !== checking_schema
28✔
1113
                                && !(property in checking_schema.properties)
28✔
1114
                                && 'string' === typeof checking_schema.$ref
28✔
1115
                        ) {
28✔
1116
                                checking_schema = this.#sub_schema_for_property_resolve_$ref(
52✔
1117
                                        schema_parser,
52✔
1118
                                        checking_schema as SchemaObject & {
52✔
1119
                                                $ref: string,
52✔
1120
                                        },
52✔
1121
                                );
52✔
1122

52✔
1123
                                if (
52✔
1124
                                        checking_schema
52✔
1125
                                        && 'allOf' in checking_schema
52✔
1126
                                        && undefined !== checking_schema.allOf
52✔
1127
                                ) {
52✔
1128
                                        const matching = this.#sub_schema_for_property_from_allOf(
8✔
1129
                                                schema_parser,
8✔
1130
                                                properties_mode,
8✔
1131
                                                property,
8✔
1132
                                                checking_schema as SchemaObject & {
8✔
1133
                                                        allOf: [
8✔
1134
                                                                SchemaObject,
8✔
1135
                                                                SchemaObject,
8✔
1136
                                                                ...SchemaObject[],
8✔
1137
                                                        ],
8✔
1138
                                                },
8✔
1139
                                                fallback_if_neither,
8✔
1140
                                        );
8✔
1141

8✔
1142
                                        if (matching) {
8✔
1143
                                                return matching;
8✔
1144
                                        }
8✔
1145
                                }
8✔
1146
                        }
52✔
1147

20✔
1148
                        if (checking_schema !== undefined) {
28✔
1149
                                const maybe_type = schema_parser.parse_by_type<
18✔
1150
                                        ObjectUnspecified<
18✔
1151
                                                {[key: string]: unknown},
18✔
1152
                                                'properties'
18✔
1153
                                        >
18✔
1154
                                >(
18✔
1155
                                        checking_schema,
18✔
1156
                                        (maybe): maybe is ObjectUnspecified<
18✔
1157
                                                {[key: string]: unknown},
18✔
1158
                                                'properties'
18✔
1159
                                        > => ObjectUnspecified.is_a<ObjectUnspecified<
18✔
1160
                                                {[key: string]: unknown},
18✔
1161
                                                'properties'
18✔
1162
                                        >>(maybe) && 'properties' === maybe.properties_mode,
18✔
1163
                                );
18✔
1164

18✔
1165
                                if (maybe_type && maybe_type.check_type(checking_schema)) {
18✔
1166
                                        schema = checking_schema as typeof schema;
18✔
1167
                                }
18✔
1168
                        }
18✔
1169
                }
28✔
1170

205✔
1171
                if (
205✔
1172
                        this.#is_schema_with_properties(schema)
205✔
1173
                        && property in schema.properties
228✔
1174
                        && undefined !== schema.properties[property]
228✔
1175
                ) {
228✔
1176
                        return this.maybe_add_$defs(
138✔
1177
                                schema,
138✔
1178
                                schema.properties[property],
138✔
1179
                        );
138✔
1180
                }
138✔
1181

67✔
1182
                if (
67✔
1183
                        this.#is_schema_with_pattern_properties(schema)
67✔
1184
                ) {
225✔
1185
                        const matching = Object.keys(
36✔
1186
                                schema.patternProperties,
36✔
1187
                        ).find((maybe) => {
36✔
1188
                                return (
52✔
1189
                                        (new RegExp(maybe)).test(property)
52✔
1190
                                        && undefined !== schema.patternProperties[maybe]
52✔
1191
                                );
52✔
1192
                        });
36✔
1193

36✔
1194
                        if (matching) {
36✔
1195
                                return schema.patternProperties[matching];
36✔
1196
                        }
36✔
1197
                }
36✔
1198

31✔
1199
                if ('neither' === properties_mode) {
225✔
1200
                        return fallback_if_neither;
4✔
1201
                }
4✔
1202

27✔
1203
                throw new TypeError(
27✔
1204
                        `Property "${property}" has no match on the specified schema!`,
27✔
1205
                );
27✔
1206
        }
228✔
1207

19✔
1208
        static #sub_schema_for_property_resolve_$ref(
19✔
1209
                schema_parser: SchemaParser,
102✔
1210
                schema: SchemaObject & {$ref: string},
102✔
1211
        ): SchemaObject|undefined {
102✔
1212
                if (!schema.$ref.startsWith('#/$defs/')) {
102✔
1213
                        const [
13✔
1214
                                other_schema_id,
13✔
1215
                                other_schema_ref_id,
13✔
1216
                        ] = schema.$ref.split(
13✔
1217
                                '#/$defs/',
13✔
1218
                        ) as [string, string];
13✔
1219

13✔
1220
                        const other_schema = schema_parser.get_schema(
13✔
1221
                                other_schema_id,
13✔
1222
                        );
13✔
1223

13✔
1224
                        if (
13✔
1225
                                other_schema
13✔
1226
                                && '$defs' in other_schema
13✔
1227
                                && undefined !== other_schema.$defs
13✔
1228
                                && other_schema_ref_id in other_schema.$defs
13✔
1229
                        ) {
13✔
1230
                                return this.maybe_add_$defs(
12✔
1231
                                        other_schema,
12✔
1232
                                        other_schema.$defs[other_schema_ref_id],
12✔
1233
                                );
12✔
1234
                        }
12✔
1235
                } else {
102✔
1236
                        const $ref_id = schema.$ref.split('#/$defs/')[1];
89✔
1237

89✔
1238
                        if (
89✔
1239
                                '$defs' in schema
89✔
1240
                                && undefined !== schema.$defs
89✔
1241
                                && $ref_id in schema.$defs
89✔
1242
                        ) {
89✔
1243
                                return this.maybe_add_$defs(
88✔
1244
                                        schema,
88✔
1245
                                        schema.$defs[$ref_id],
88✔
1246
                                );
88✔
1247
                        }
88✔
1248
                }
89✔
1249

2✔
1250
                return undefined;
2✔
1251
        }
102✔
1252

19✔
1253
        static #sub_schema_for_property_from_allOf<
19✔
1254
                PropertiesMode extends object_properties_mode,
23✔
1255
        >(
23✔
1256
                schema_parser: SchemaParser,
23✔
1257
                properties_mode: PropertiesMode,
23✔
1258
                property: string,
23✔
1259
                schema: SchemaObject & {
23✔
1260
                        allOf: [
23✔
1261
                                SchemaObject,
23✔
1262
                                SchemaObject,
23✔
1263
                                ...SchemaObject[],
23✔
1264
                        ],
23✔
1265
                },
23✔
1266
                fallback_if_neither: Record<string, never>|unknown_type,
23✔
1267
        ): SchemaObject|undefined {
23✔
1268
                let matching: SchemaObject|undefined;
23✔
1269

23✔
1270
                for (const candidate of schema.allOf) {
23✔
1271
                        try {
46✔
1272
                                const maybe = this.#sub_schema_for_property(
46✔
1273
                                        schema_parser,
46✔
1274
                                        properties_mode,
46✔
1275
                                        property,
46✔
1276
                                        this.maybe_add_$defs(
46✔
1277
                                                schema,
46✔
1278
                                                candidate,
46✔
1279
                                        ),
46✔
1280
                                        fallback_if_neither,
46✔
1281
                                );
46✔
1282

46✔
1283
                                if (undefined !== maybe) {
46✔
1284
                                        matching = maybe;
22✔
1285
                                }
22✔
1286
                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
46✔
1287
                        } catch (err) { /* empty */ }
46✔
1288
                }
46✔
1289

23✔
1290
                return matching;
23✔
1291
        }
23✔
1292
}
19✔
1293

19✔
1294
export type {
19✔
1295
        object_properties_mode,
19✔
1296
        object_type,
19✔
1297
        object_type_base,
19✔
1298
        object_schema,
19✔
1299
        object_TypeLiteralNode,
19✔
1300
        object_TypeLiteralNode_possibly_extended,
19✔
1301
};
19✔
1302

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

© 2026 Coveralls, Inc