SignpostMarv/JSON-Schema-TypeScript-CodeGen | Build 19116883256 | src/JSONSchema/Object.ts | Coveralls

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<

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_schema_required<

19✔

105

        PropertiesMode extends object_properties_mode,

19✔

106

> = (

19✔

107

        & readonly [string, ...string[]]

19✔

108

& [

19✔

109

                'type',

19✔

110

                ...{

19✔

111

                        neither: readonly string[],

19✔

112

                        both: readonly ['properties', 'patternProperties'],

19✔

113

                        properties: readonly ['properties'],

19✔

114

                        pattern: readonly ['patternProperties'],

19✔

115

                }[PropertiesMode],

19✔

116

19✔

117

);

19✔

118

19✔

119

type object_schema_properties_base = {

19✔

120

        type: {

19✔

121

                type: 'string',

19✔

122

                const: 'object',

19✔

123

},

19✔

124

        required: {

19✔

125

                type: 'array',

19✔

126

                minItems: 1,

19✔

127

                items: {

19✔

128

                        type: 'string',

19✔

129

                        minLength: 1,

19✔

130

},

19✔

131

},

19✔

132

        $ref: {

19✔

133

                type: 'string',

19✔

134

                pattern: pattern_either,

19✔

135

},

19✔

136

        additionalProperties: {

19✔

137

                type: 'boolean',

19✔

138

},

19✔

139

        unevaluatedProperties: {

19✔

140

                type: 'boolean',

19✔

141

},

19✔

142

};

19✔

143

19✔

144

type object_schema_properties_properties = {

19✔

145

        properties: {

19✔

146

                type: 'object',

19✔

147

                minProperties: 1,

19✔

148

                additionalProperties: {

19✔

149

                        type: 'object',

19✔

150

},

19✔

151

},

19✔

152

};

19✔

153

19✔

154

type object_schema_properties_pattern = {

19✔

155

        patternProperties: {

19✔

156

                type: 'object',

19✔

157

                minProperties: 1,

19✔

158

                additionalProperties: {

19✔

159

                        type: 'object',

19✔

160

},

19✔

161

},

19✔

162

};

19✔

163

19✔

164

type object_properties_by_mode<

19✔

165

        PropertiesMode extends object_properties_mode,

19✔

166

> = {

19✔

167

        both: (

19✔

168

                & object_schema_properties_properties

19✔

169

                & object_schema_properties_pattern

19✔

170

),

19✔

171

        properties: object_schema_properties_properties,

19✔

172

        pattern: object_schema_properties_pattern,

19✔

173

        neither: {

19✔

174

                additionalProperties: {

19✔

175

                        type: 'boolean',

19✔

176

                        const: false,

19✔

177

},

19✔

178

                maxProperties: {

19✔

179

                        type: 'integer',

19✔

180

                        const: 0,

19✔

181

},

19✔

182

},

19✔

183

}[PropertiesMode];

19✔

184

19✔

185

type object_schema<

19✔

186

        PropertiesMode extends object_properties_mode,

19✔

187

> = SchemaDefinitionDefinitionWith$defs<

19✔

188

        object_schema_required<PropertiesMode>,

19✔

189

19✔

190

                & ObjectOfSchemas

19✔

191

                & object_schema_properties_base

19✔

192

                & object_properties_by_mode<PropertiesMode>

19✔

193

19✔

194

>;

19✔

195

19✔

196

type object_TypeLiteralNode<

19✔

197

        PropertiesMode extends object_properties_mode,

19✔

198

> = {

19✔

199

        ['neither']: TypeLiteralNode<

19✔

200

                IndexSignatureDeclaration

19✔

201

>,

19✔

202

        ['both']: IntersectionTypeNode<[

19✔

203

                TypeLiteralNode<PropertySignature>,

19✔

204

                TypeLiteralNode<IndexSignatureDeclaration>,

19✔

205

]>,

19✔

206

        ['properties']: TypeLiteralNode<PropertySignature>,

19✔

207

        ['pattern']: TypeLiteralNode<

19✔

208

                IndexSignatureDeclaration

19✔

209

>,

19✔

210

}[PropertiesMode];

19✔

211

19✔

212

type object_TypeLiteralNode_possibly_extended<

19✔

213

        PropertiesMode extends object_properties_mode,

19✔

214

> = (

19✔

215

        | object_TypeLiteralNode<PropertiesMode>

19✔

216

        | IntersectionTypeNode<[

19✔

217

                TypeReferenceNode,

19✔

218

                object_TypeLiteralNode<PropertiesMode>,

19✔

219

]>

19✔

220

);

19✔

221

19✔

222

type ObjectUncertain_options<

19✔

223

        SchemaDefinition extends (

19✔

224

                SchemaDefinitionDefinition

19✔

225

        ) = (

19✔

226

                SchemaDefinitionDefinition

19✔

227

),

19✔

228

        TypeDefinition extends TypeDefinitionSchema = TypeDefinitionSchema,

19✔

229

> = (

19✔

230

        & Omit<

19✔

231

                TypeOptions<SchemaDefinition, TypeDefinition>,

19✔

232

19✔

233

                        | 'schema_definition'

19✔

234

                        | 'type_definition'

19✔

235

19✔

236

19✔

237

);

19✔

238

19✔

239

class ObjectUnspecified<

19✔

240

        T extends {[key: string]: unknown},

19✔

241

        PropertiesMode extends object_properties_mode,

19✔

242

        Defs extends SchemaObject = SchemaObject,

19✔

243

        Required extends (

19✔

244

                readonly [string, ...string[]]

19✔

245

        ) = (

19✔

246

                readonly [string, ...string[]]

19✔

247

),

19✔

248

        Properties extends ObjectOfSchemas = ObjectOfSchemas,

19✔

249

        PatternProperties extends ObjectOfSchemas = ObjectOfSchemas,

19✔

250

> extends

19✔

251

        Type<

19✔

252

T,

19✔

253

                object_type<

19✔

254

                        PropertiesMode,

19✔

255

                        Defs,

19✔

256

                        Required,

19✔

257

                        Properties,

19✔

258

                        PatternProperties

19✔

259

>,

19✔

260

19✔

261

                        properties_mode: PropertiesMode,

19✔

262

                        $defs?: Defs,

19✔

263

                        required?: Required,

19✔

264

                        properties?: Properties,

19✔

265

                        patternProperties?: PatternProperties,

19✔

266

},

19✔

267

                object_schema<

19✔

268

                        PropertiesMode

19✔

269

>,

19✔

270

19✔

271

                        properties_mode: PropertiesMode,

19✔

272

},

19✔

273

19✔

274

                        | object_TypeLiteralNode<PropertiesMode>

19✔

275

                        | IntersectionTypeNode<[

19✔

276

                                TypeReferenceNode,

19✔

277

                                object_TypeLiteralNode<PropertiesMode>,

19✔

278

]>

19✔

279

),

19✔

280

                ObjectLiteralExpression

19✔

281

> {

19✔

282

        #adjust_name: adjust_name_callback;

19✔

283

1,124✔

284

        readonly properties_mode: PropertiesMode;

19✔

285

19✔

286

        constructor(

19✔

287

                options: {

1,124✔

288

                        adjust_name?: adjust_name_callback,

1,124✔

289

                        properties_mode: PropertiesMode,

1,124✔

290

                        $defs?: Defs,

1,124✔

291

                        required?: Required,

1,124✔

292

                        properties?: Properties,

1,124✔

293

                        patternProperties?: PatternProperties,

1,124✔

294

},

1,124✔

295

1,124✔

296

                        ajv,

1,124✔

297

                }: ObjectUncertain_options<

1,124✔

298

                        object_schema<

1,124✔

299

                                PropertiesMode

1,124✔

300

>,

1,124✔

301

                        object_type<

1,124✔

302

                                PropertiesMode,

1,124✔

303

                                Defs,

1,124✔

304

                                Required,

1,124✔

305

                                Properties,

1,124✔

306

                                PatternProperties

1,124✔

307

1,124✔

308

>,

1,124✔

309

) {

1,124✔

310

                super({

1,124✔

311

                        ajv,

1,124✔

312

                        type_definition: options,

1,124✔

313

                        schema_definition: options,

1,124✔

314

});

1,124✔

315

1,124✔

316

                this.#adjust_name = options?.adjust_name || adjust_name_default;

1,124✔

317

                this.properties_mode = options.properties_mode;

1,124✔

318

1,124✔

319

19✔

320

        generate_typescript_data(

19✔

321

                data: T,

76✔

322

                schema_parser: SchemaParser,

76✔

323

                schema: object_type<

76✔

324

                        PropertiesMode,

76✔

325

                        Defs,

76✔

326

                        Required,

76✔

327

                        Properties,

76✔

328

                        PatternProperties

76✔

329

>,

76✔

330

        ): ObjectLiteralExpression {

76✔

331

                return ObjectUnspecified.#createObjectLiteralExpression(

76✔

332

                        this.properties_mode,

76✔

333

                        data,

76✔

334

                        schema,

76✔

335

                        schema_parser,

76✔

336

                        this.#adjust_name,

76✔

337

);

76✔

338

76✔

339

19✔

340

        async generate_typescript_type(

19✔

341

32✔

342

                        schema,

32✔

343

                        schema_parser,

32✔

344

                }: {

32✔

345

                        schema: object_type<

32✔

346

                                PropertiesMode,

32✔

347

                                Defs,

32✔

348

                                Required,

32✔

349

                                Properties,

32✔

350

                                PatternProperties

32✔

351

>,

32✔

352

                        schema_parser: SchemaParser,

32✔

353

},

32✔

354

        ): Promise<object_TypeLiteralNode_possibly_extended<PropertiesMode>> {

32✔

355

                let object_type: (

32✔

356

                        | Promise<object_TypeLiteralNode<PropertiesMode>>

32✔

357

                        | IntersectionTypeNode<[

32✔

358

                                TypeReferenceNode,

32✔

359

                                object_TypeLiteralNode<PropertiesMode>,

32✔

360

]>

32✔

361

                ) = ObjectUnspecified.#createTypeNode(

32✔

362

                        this.properties_mode,

32✔

363

                        schema,

32✔

364

                        schema_parser,

32✔

365

);

32✔

366

32✔

367

                if ('string' === typeof schema?.$ref) {

32✔

368

                        const $ref_instance = schema_parser.parse_by_type({

7✔

369

                                $ref: schema.$ref,

7✔

370

                        }, (maybe): maybe is $ref => $ref.is_a(maybe));

7✔

371

7✔

372

                        object_type = factory.createIntersectionTypeNode([

7✔

373

                                await $ref_instance.generate_typescript_type({

7✔

374

                                        schema: {

7✔

375

                                                $ref: schema.$ref,

7✔

376

},

7✔

377

}),

7✔

378

                                await object_type,

7✔

379

]);

7✔

380

7✔

381

32✔

382

                return object_type;

32✔

383

32✔

384

19✔

385

        static generate_schema_definition<

19✔

386

                PropertiesMode extends object_properties_mode,

1,128✔

387

>({

1,128✔

388

                properties_mode,

1,128✔

389

        }: {

1,128✔

390

                properties_mode: PropertiesMode,

1,128✔

391

        }): Readonly<object_schema<

1,128✔

392

                PropertiesMode

1,128✔

393

        >> {

1,128✔

394

                const required_for_partial = (

1,128✔

395

                        this.#generate_schema_definition_required(

1,128✔

396

                                properties_mode,

1,128✔

397

1,128✔

398

);

1,128✔

399

1,128✔

400

                const properties_for_partial: Partial<

1,128✔

401

                        object_schema<'both'>['properties']

1,128✔

402

                > = {

1,128✔

403

                        ...$defs_schema.properties,

1,128✔

404

                        type: {

1,128✔

405

                                type: 'string',

1,128✔

406

                                const: 'object',

1,128✔

407

},

1,128✔

408

                        $ref: {

1,128✔

409

                                type: 'string',

1,128✔

410

                                pattern: '^(.+)?#\\/\\$defs\\/(.+)$',

1,128✔

411

},

1,128✔

412

                        additionalProperties: {

1,128✔

413

                                type: 'boolean',

1,128✔

414

},

1,128✔

415

                        unevaluatedProperties: {

1,128✔

416

                                type: 'boolean',

1,128✔

417

},

1,128✔

418

};

1,128✔

419

1,128✔

420

                properties_for_partial.required = {

1,128✔

421

                        type: 'array',

1,128✔

422

                        minItems: 1,

1,128✔

423

                        items: {

1,128✔

424

                                type: 'string',

1,128✔

425

                                minLength: 1,

1,128✔

426

},

1,128✔

427

};

1,128✔

428

1,128✔

429

                if ('pattern' !== properties_mode && 'neither' !== properties_mode) {

1,128✔

430

                        const properties: (

574✔

431

                                object_schema<

574✔

432

                                        'properties'

574✔

433

                                >['properties']['properties']

574✔

434

                        ) = {

574✔

435

                                type: 'object',

574✔

436

                                minProperties: 1,

574✔

437

                                additionalProperties: {

574✔

438

                                        type: 'object',

574✔

439

},

574✔

440

};

574✔

441

                        properties_for_partial.properties = properties;

574✔

442

574✔

443

                if (

1,128✔

444

                        'properties' !== properties_mode

1,128✔

445

                        && 'neither' !== properties_mode

1,128✔

446

) {

1,128✔

447

                        const properties: (

554✔

448

                                object_schema<

554✔

449

                                        'pattern'

554✔

450

                                >['properties']['patternProperties']

554✔

451

                        ) = {

554✔

452

                                type: 'object',

554✔

453

                                minProperties: 1,

554✔

454

                                additionalProperties: {

554✔

455

                                        type: 'object',

554✔

456

},

554✔

457

};

554✔

458

                        properties_for_partial.patternProperties = properties;

554✔

459

554✔

460

1,128✔

461

                if ('neither' === properties_mode) {

1,128✔

462

277✔

463

                                properties_for_partial as Partial<

277✔

464

                                        object_schema<'neither'>['properties']

277✔

465

277✔

466

                        ).additionalProperties = {

277✔

467

                                type: 'boolean',

277✔

468

                                const: false,

277✔

469

};

277✔

470

277✔

471

                                properties_for_partial as Partial<

277✔

472

                                        object_schema<'neither'>['properties']

277✔

473

277✔

474

                        ).maxProperties = {

277✔

475

                                type: 'integer',

277✔

476

                                const: 0,

277✔

477

};

277✔

478

277✔

479

1,128✔

480

                const unpartial_properties: object_schema<

1,128✔

481

                        PropertiesMode

1,128✔

482

                >['properties'] = properties_for_partial as object_schema<

1,128✔

483

                        PropertiesMode

1,128✔

484

                >['properties'];

1,128✔

485

1,128✔

486

                const partial_required: object_schema<

1,128✔

487

                        PropertiesMode

1,128✔

488

                >['required'] = required_for_partial;

1,128✔

489

                const partial_properties: object_schema<

1,128✔

490

                        PropertiesMode

1,128✔

491

                >['properties'] = unpartial_properties;

1,128✔

492

1,128✔

493

                const result: object_schema<

1,128✔

494

                        PropertiesMode

1,128✔

495

                > = {

1,128✔

496

                        type: 'object',

1,128✔

497

                        required: partial_required,

1,128✔

498

                        additionalProperties: false,

1,128✔

499

                        properties: partial_properties,

1,128✔

500

                } as object_schema<

1,128✔

501

                        PropertiesMode

1,128✔

502

>;

1,128✔

503

1,128✔

504

                return Object.freeze(result);

1,128✔

505

1,128✔

506

19✔

507

        static #generate_schema_definition_required<

19✔

508

                PropertiesMode extends object_properties_mode,

1,128✔

509

>(

1,128✔

510

                properties_mode: PropertiesMode,

1,128✔

511

        ): object_schema<

1,128✔

512

                PropertiesMode

1,128✔

513

        >['required'] {

1,128✔

514

                const values_for_properties_mode: {

1,128✔

515

                        neither: readonly string[],

1,128✔

516

                        both: readonly ['properties', 'patternProperties'],

1,128✔

517

                        properties: readonly ['properties'],

1,128✔

518

                        pattern: readonly ['patternProperties'],

1,128✔

519

                }[PropertiesMode] = {

1,128✔

520

                        neither: [] as readonly string[],

1,128✔

521

                        both: ['properties', 'patternProperties'] as const,

1,128✔

522

                        properties: ['properties'] as const,

1,128✔

523

                        pattern: ['patternProperties'] as const,

1,128✔

524

                }[properties_mode];

1,128✔

525

1,128✔

526

                const required: object_schema<

1,128✔

527

                        PropertiesMode

1,128✔

528

                >['required'] = [

1,128✔

529

                        ...['type'],

1,128✔

530

                        ...values_for_properties_mode,

1,128✔

531

                ] as object_schema<

1,128✔

532

                        PropertiesMode

1,128✔

533

                >['required'];

1,128✔

534

1,128✔

535

                return required;

1,128✔

536

1,128✔

537

19✔

538

        static generate_type_definition<

19✔

539

                PropertiesMode extends object_properties_mode,

1,124✔

540

                Defs extends SchemaObject,

1,124✔

541

                Required extends readonly [string, ...string[]],

1,124✔

542

                Properties extends ObjectOfSchemas,

1,124✔

543

                PatternProperties extends ObjectOfSchemas,

1,124✔

544

>({

1,124✔

545

                properties_mode,

1,124✔

546

                $defs,

1,124✔

547

                required,

1,124✔

548

                properties,

1,124✔

549

                patternProperties,

1,124✔

550

        }: {

1,124✔

551

                properties_mode: PropertiesMode,

1,124✔

552

                $defs?: Defs,

1,124✔

553

                required?: Required,

1,124✔

554

                properties?: Properties,

1,124✔

555

                patternProperties?: PatternProperties,

1,124✔

556

        }): Readonly<object_type<

1,124✔

557

                PropertiesMode,

1,124✔

558

                Defs,

1,124✔

559

                Required,

1,124✔

560

                Properties,

1,124✔

561

                PatternProperties

1,124✔

562

        >> {

1,124✔

563

                const partial: Partial<object_type<

1,124✔

564

                        'both',

1,124✔

565

                        Defs,

1,124✔

566

                        Required,

1,124✔

567

                        Properties,

1,124✔

568

                        PatternProperties

1,124✔

569

                >> = {

1,124✔

570

                        type: 'object',

1,124✔

571

};

1,124✔

572

1,124✔

573

                if ($defs) {

1,124✔

574

                        partial.$defs = $defs;

8✔

575

8✔

576

1,124✔

577

                if (required) {

1,124✔

578

                        partial.required = required;

4✔

579

4✔

580

1,124✔

581

                if ('both' === properties_mode || 'properties' === properties_mode) {

1,124✔

582

                        partial.properties = properties;

572✔

583

572✔

584

1,124✔

585

                if (

1,124✔

586

                        'both' === properties_mode

1,124✔

587

                        || 'pattern' === properties_mode

1,124✔

588

) {

1,124✔

589

                        partial.patternProperties = patternProperties;

552✔

590

552✔

591

1,124✔

592

                const frozen = Object.freeze(partial as object_type<

1,124✔

593

                        PropertiesMode,

1,124✔

594

                        Defs,

1,124✔

595

                        Required,

1,124✔

596

                        Properties,

1,124✔

597

                        PatternProperties

1,124✔

598

>);

1,124✔

599

1,124✔

600

                return frozen;

1,124✔

601

1,124✔

602

19✔

603

        static #is_schema_with_some_type_of_properties<

19✔

604

                Defs extends SchemaObject,

32✔

605

                Required extends readonly [string, ...string[]],

32✔

606

                Properties extends ObjectOfSchemas,

32✔

607

                PatternProperties extends ObjectOfSchemas,

32✔

608

>(

32✔

609

                schema: object_type<

32✔

610

                        object_properties_mode,

32✔

611

                        Defs,

32✔

612

                        Required,

32✔

613

                        Properties,

32✔

614

                        PatternProperties

32✔

615

>,

32✔

616

        ): schema is object_type<

32✔

617

                'both'|'properties'|'pattern',

32✔

618

                Defs,

32✔

619

                Required,

32✔

620

                Properties,

32✔

621

                PatternProperties

32✔

622

> {

32✔

623

                return ('properties' in schema) || ('patternProperties' in schema);

32✔

624

32✔

625

19✔

626

        static #is_schema_with_properties<

19✔

627

                Defs extends SchemaObject,

879✔

628

                Required extends readonly [string, ...string[]],

879✔

629

                Properties extends ObjectOfSchemas,

879✔

630

                PatternProperties extends ObjectOfSchemas,

879✔

631

>(

879✔

632

                schema: SchemaObject|object_type<

879✔

633

                        object_properties_mode,

879✔

634

                        Defs,

879✔

635

                        Required,

879✔

636

                        Properties,

879✔

637

                        PatternProperties

879✔

638

>,

879✔

639

        ): schema is object_type<

879✔

640

                'both' | 'properties',

879✔

641

                Defs,

879✔

642

                Required,

879✔

643

                Properties,

879✔

644

                PatternProperties

879✔

645

> {

879✔

646

                return 'properties' in schema;

879✔

647

879✔

648

19✔

649

        static #is_schema_with_pattern_properties<

19✔

650

                Defs extends SchemaObject,

662✔

651

                Required extends readonly [string, ...string[]],

662✔

652

                Properties extends ObjectOfSchemas,

662✔

653

                PatternProperties extends ObjectOfSchemas,

662✔

654

>(

662✔

655

                schema: SchemaObject|object_type<

662✔

656

                        object_properties_mode,

662✔

657

                        Defs,

662✔

658

                        Required,

662✔

659

                        Properties,

662✔

660

                        PatternProperties

662✔

661

>,

662✔

662

        ): schema is object_type<

662✔

663

                'both'|'pattern',

662✔

664

                Defs,

662✔

665

                Required,

662✔

666

                Properties,

662✔

667

                PatternProperties

662✔

668

> {

662✔

669

                return 'patternProperties' in schema;

662✔

670

662✔

671

19✔

672

        static #is_schema_with_required<

19✔

673

                Required extends readonly [string, ...string[]],

33✔

674

>(

33✔

675

                schema: object_type<

33✔

676

                        object_properties_mode,

33✔

677

                        SchemaObject,

33✔

678

                        Required,

33✔

679

                        ObjectOfSchemas,

33✔

680

                        ObjectOfSchemas

33✔

681

>,

33✔

682

        ): schema is object_type<

33✔

683

                object_properties_mode,

33✔

684

                SchemaObject,

33✔

685

                Required,

33✔

686

                ObjectOfSchemas,

33✔

687

                ObjectOfSchemas

33✔

688

        > & {required: Required} {

33✔

689

                return 'required' in schema;

33✔

690

33✔

691

19✔

692

        static #convert<

19✔

693

T,

145✔

694

                PropertiesMode extends object_properties_mode,

145✔

695

                Defs extends SchemaObject,

145✔

696

                Required extends readonly [string, ...string[]],

145✔

697

                Properties extends ObjectOfSchemas,

145✔

698

                PatternProperties extends ObjectOfSchemas,

145✔

699

>(

145✔

700

                properties_mode: PropertiesMode,

145✔

701

                value: unknown,

145✔

702

                property: string,

145✔

703

                schema: object_type<

145✔

704

                        PropertiesMode,

145✔

705

                        Defs,

145✔

706

                        Required,

145✔

707

                        Properties,

145✔

708

                        PatternProperties

145✔

709

>,

145✔

710

                schema_parser: SchemaParser,

145✔

711

) {

145✔

712

                const sub_schema = this.#sub_schema_for_property(

145✔

713

                        schema_parser,

145✔

714

                        properties_mode,

145✔

715

                        property,

145✔

716

                        schema,

145✔

717

{},

145✔

718

);

145✔

719

145✔

720

                let maybe_modified = ObjectUnspecified.maybe_add_$defs(

145✔

721

                        schema,

145✔

722

                        sub_schema,

145✔

723

);

145✔

724

145✔

725

                const ajv = schema_parser.share_ajv((ajv) => ajv);

145✔

726

                const validator = ajv.compile<T>(maybe_modified);

145✔

727

145✔

728

                if (!(validator(value))) {

145✔

729

                        throw new TypeError('Supplied value not supported by property!');

28✔

730

28✔

731

113✔

732

                if (0 === Object.keys(sub_schema).length) {

145✔

733

                        maybe_modified = {

4✔

734

                                type: 'object',

4✔

735

                                additionalProperties: false,

4✔

736

                                maxProperties: 0,

4✔

737

};

4✔

738

4✔

739

113✔

740

                const instance = schema_parser.parse(

113✔

741

                        maybe_modified,

113✔

742

);

113✔

743

113✔

744

                return instance.generate_typescript_data(

113✔

745

                        value,

113✔

746

                        schema_parser,

113✔

747

                        maybe_modified,

113✔

748

);

113✔

749

145✔

750

19✔

751

        static #createObjectLiteralExpression<

19✔

752

                T extends {[key: string]: unknown},

76✔

753

                PropertiesMode extends object_properties_mode,

76✔

754

                Defs extends SchemaObject,

76✔

755

                Required extends readonly [string, ...string[]],

76✔

756

                Properties extends ObjectOfSchemas,

76✔

757

                PatternProperties extends ObjectOfSchemas,

76✔

758

>(

76✔

759

                properties_mode: PropertiesMode,

76✔

760

                data: T,

76✔

761

                schema: object_type<

76✔

762

                        PropertiesMode,

76✔

763

                        Defs,

76✔

764

                        Required,

76✔

765

                        Properties,

76✔

766

                        PatternProperties

76✔

767

>,

76✔

768

                schema_parser: SchemaParser,

76✔

769

                adjust_name: adjust_name_callback,

76✔

770

        ): ObjectLiteralExpression {

76✔

771

                return factory.createObjectLiteralExpression(

76✔

772

                        Object.entries(

76✔

773

                                data,

76✔

774

                        ).map(([

76✔

775

                                property,

145✔

776

                                value,

145✔

777

                        ]) => {

145✔

778

                                const type = this.#convert(

145✔

779

                                        properties_mode,

145✔

780

                                        value,

145✔

781

                                        property,

145✔

782

                                        schema,

145✔

783

                                        schema_parser,

145✔

784

);

145✔

785

145✔

786

                                return factory.createPropertyAssignment(

145✔

787

                                        adjust_name(property),

145✔

788

                                        type,

145✔

789

);

145✔

790

}),

76✔

791

);

76✔

792

76✔

793

19✔

794

        static async #createTypeNode<

19✔

795

                PropertiesMode extends object_properties_mode,

32✔

796

                Defs extends SchemaObject,

32✔

797

                Required extends readonly [string, ...string[]],

32✔

798

                Properties extends ObjectOfSchemas,

32✔

799

                PatternProperties extends ObjectOfSchemas,

32✔

800

>(

32✔

801

                properties_mode: PropertiesMode,

32✔

802

                schema: object_type<

32✔

803

                        PropertiesMode,

32✔

804

                        Defs,

32✔

805

                        Required,

32✔

806

                        Properties,

32✔

807

                        PatternProperties

32✔

808

>,

32✔

809

                schema_parser: SchemaParser,

32✔

810

        ): Promise<object_TypeLiteralNode<PropertiesMode>> {

32✔

811

                if (!this.#is_schema_with_some_type_of_properties(schema)) {

32✔

812

                        return factory.createTypeLiteralNode([

2✔

813

                                factory.createIndexSignature(

2✔

814

                                        undefined,

2✔

815

2✔

816

                                                factory.createParameterDeclaration(

2✔

817

                                                        undefined,

2✔

818

                                                        undefined,

2✔

819

                                                        factory.createIdentifier('key'),

2✔

820

                                                        undefined,

2✔

821

                                                        factory.createToken(SyntaxKind.StringKeyword),

2✔

822

),

2✔

823

],

2✔

824

                                        factory.createToken(SyntaxKind.UnknownKeyword),

2✔

825

),

2✔

826

                        ]) as object_TypeLiteralNode<PropertiesMode>;

2✔

827

2✔

828

30✔

829

                let properties: PropertySignature[] = [];

30✔

830

                let patterned: [TypeNode, ...TypeNode[]]|never[] = [];

30✔

831

30✔

832

                if (this.#is_schema_with_properties(schema)) {

32✔

833

                        properties = await Promise.all(Object.keys(

26✔

834

                                schema.properties,

26✔

835

                        ).map(async (

26✔

836

                                property,

33✔

837

                        ): Promise<PropertySignature> => factory.createPropertySignature(

33✔

838

                                undefined,

33✔

839

33✔

840

                                        /[?[\] ]/.test(property)

33✔

841

                                                ? factory.createComputedPropertyName(

33✔

842

                                                        factory.createStringLiteral(property),

2✔

843

2✔

844

                                                : property

33✔

845

),

33✔

846

33✔

847

33✔

848

                                                this.#is_schema_with_required(schema)

33✔

849

                                                && schema.required.includes(property)

33✔

850

33✔

851

                                                ? undefined

33✔

852

                                                : factory.createToken(SyntaxKind.QuestionToken)

33✔

853

),

33✔

854

                                await this.#generate_type(

33✔

855

                                        properties_mode,

33✔

856

                                        property,

33✔

857

                                        schema,

33✔

858

                                        schema_parser,

33✔

859

),

33✔

860

                        )));

26✔

861

26✔

862

30✔

863

                if (this.#is_schema_with_pattern_properties(schema)) {

32✔

864

                        patterned = await Promise.all(

6✔

865

6✔

866

                                        Object.values(

6✔

867

                                                schema.patternProperties,

6✔

868

6✔

869

                                ).map(

6✔

870

                                        (sub_schema) => {

6✔

871

                                                return schema_parser.parse(

10✔

872

                                                        ObjectUnspecified.maybe_add_$defs(

10✔

873

                                                                schema,

10✔

874

                                                                sub_schema,

10✔

875

),

10✔

876

                                                ).generate_typescript_type({

10✔

877

                                                        data: sub_schema,

10✔

878

                                                        schema: sub_schema,

10✔

879

                                                        schema_parser,

10✔

880

});

10✔

881

},

6✔

882

),

6✔

883

);

6✔

884

6✔

885

30✔

886

                let result: object_TypeLiteralNode<

30✔

887

                        Exclude<

30✔

888

                                object_properties_mode,

30✔

889

                                'neither'

30✔

890

30✔

891

>;

30✔

892

30✔

893

                if (properties.length > 0 && patterned.length > 0) {

32✔

894

                        result = factory.createIntersectionTypeNode([

2✔

895

                                factory.createTypeLiteralNode(properties),

2✔

896

                                this.#patterned_literal_node(

2✔

897

                                        patterned as [TypeNode, ...TypeNode[]],

2✔

898

),

2✔

899

]);

2✔

900

                } else if (properties.length > 0) {

32✔

901

                        result = factory.createTypeLiteralNode(properties);

24✔

902

                } else {

28✔

903

                        result = this.#patterned_literal_node(

4✔

904

                                patterned as [TypeNode, ...TypeNode[]],

4✔

905

);

4✔

906

4✔

907

30✔

908

                return result as object_TypeLiteralNode<PropertiesMode>;

30✔

909

32✔

910

19✔

911

        static async #generate_type<

19✔

912

                PropertiesMode extends object_properties_mode,

33✔

913

                Defs extends SchemaObject,

33✔

914

                Required extends readonly [string, ...string[]],

33✔

915

                Properties extends ObjectOfSchemas,

33✔

916

                PatternProperties extends ObjectOfSchemas,

33✔

917

>(

33✔

918

                properties_mode: PropertiesMode,

33✔

919

                property: string,

33✔

920

                schema: object_type<

33✔

921

                        PropertiesMode,

33✔

922

                        Defs,

33✔

923

                        Required,

33✔

924

                        Properties,

33✔

925

                        PatternProperties

33✔

926

>,

33✔

927

                schema_parser: SchemaParser,

33✔

928

) {

33✔

929

                const sub_schema = this.#sub_schema_for_property(

33✔

930

                        schema_parser,

33✔

931

                        properties_mode,

33✔

932

                        property,

33✔

933

                        schema,

33✔

934

{},

33✔

935

);

33✔

936

33✔

937

                let matched: (

33✔

938

                        | undefined

33✔

939

                        | Type<unknown>

33✔

940

                ) = schema_parser.maybe_parse_by_type<

33✔

941

                        $ref

33✔

942

>(

33✔

943

                        sub_schema,

33✔

944

33✔

945

                                maybe: unknown,

166✔

946

                        ): maybe is $ref => {

166✔

947

                                return $ref.is_a(maybe);

166✔

948

},

33✔

949

);

33✔

950

33✔

951

                if (undefined === matched) {

33✔

952

                        matched = schema_parser.parse(sub_schema);

19✔

953

                } else {

33✔

954

                        return matched.generate_typescript_type({

14✔

955

                                data: sub_schema,

14✔

956

                                schema: sub_schema,

14✔

957

                                schema_parser,

14✔

958

});

14✔

959

14✔

960

19✔

961

                return matched.generate_typescript_type({

19✔

962

                        schema: sub_schema,

19✔

963

                        schema_parser,

19✔

964

});

19✔

965

33✔

966

19✔

967

        static #patterned_literal_node(

19✔

968

                value: [TypeNode, ...TypeNode[]],

6✔

969

        ): TypeLiteralNode<IndexSignatureDeclaration> {

6✔

970

                return factory.createTypeLiteralNode([

6✔

971

                        factory.createIndexSignature(

6✔

972

                                undefined,

6✔

973

6✔

974

                                        factory.createParameterDeclaration(

6✔

975

                                                undefined,

6✔

976

                                                undefined,

6✔

977

                                                'key',

6✔

978

                                                undefined,

6✔

979

                                                factory.createKeywordTypeNode(

6✔

980

                                                        SyntaxKind.StringKeyword,

6✔

981

),

6✔

982

                                                undefined,

6✔

983

),

6✔

984

],

6✔

985

                                1 === value.length

6✔

986

                                        ? value[0]

6✔

987

                                        : factory.createUnionTypeNode(

6✔

988

                                                value as [TypeNode, TypeNode, ...TypeNode[]],

4✔

989

),

6✔

990

),

6✔

991

]);

6✔

992

6✔

993

19✔

994

        static #sub_schema_for_property<

19✔

995

                PropertiesMode extends object_properties_mode,

224✔

996

                Defs extends SchemaObject,

224✔

997

                Required extends readonly [string, ...string[]],

224✔

998

                Properties extends ObjectOfSchemas,

224✔

999

                PatternProperties extends ObjectOfSchemas,

224✔

1000

>(

224✔

1001

                schema_parser: SchemaParser,

224✔

1002

                properties_mode: PropertiesMode,

224✔

1003

                property: string,

224✔

1004

                schema: SchemaObject|object_type<

224✔

1005

                        PropertiesMode,

224✔

1006

                        Defs,

224✔

1007

                        Required,

224✔

1008

                        Properties,

224✔

1009

                        PatternProperties

224✔

1010

>,

224✔

1011

                fallback_if_neither: Record<string, never>|unknown_type,

224✔

1012

        ): SchemaObject {

224✔

1013

                if (

224✔

1014

                        !this.#is_schema_with_pattern_properties(schema)

224✔

1015

                        && !this.#is_schema_with_properties(schema)

224✔

1016

                        && 'string' === typeof schema.$ref

224✔

1017

                        && 2 === Object.keys(schema).length

224✔

1018

                        && '$defs' in schema

224✔

1019

) {

224✔

1020

                        const maybe_replace_schema = (

46✔

1021

                                this.#sub_schema_for_property_resolve_$ref(

46✔

1022

                                        schema_parser,

46✔

1023

                                        schema as SchemaObject & {

46✔

1024

                                                $ref: string,

46✔

1025

},

46✔

1026

46✔

1027

);

46✔

1028

46✔

1029

                        if (maybe_replace_schema) {

46✔

1030

                                schema = maybe_replace_schema;

46✔

1031

46✔

1032

                } else if (

224✔

1033

                        !this.#is_schema_with_pattern_properties(schema)

178✔

1034

                        && !this.#is_schema_with_properties(schema)

178✔

1035

                        && 'allOf' in schema

178✔

1036

                        && undefined !== schema.allOf

178✔

1037

                        && 2 === Object.keys(schema).length

178✔

1038

                        && '$defs' in schema

178✔

1039

) {

178✔

1040

                        const matching = this.#sub_schema_for_property_from_allOf(

15✔

1041

                                schema_parser,

15✔

1042

                                properties_mode,

15✔

1043

                                property,

15✔

1044

                                schema as SchemaObject & {

15✔

1045

                                        allOf: [

15✔

1046

                                                SchemaObject,

15✔

1047

                                                SchemaObject,

15✔

1048

                                                ...SchemaObject[],

15✔

1049

],

15✔

1050

},

15✔

1051

                                fallback_if_neither,

15✔

1052

);

15✔

1053

15✔

1054

                        if (matching) {

15✔

1055

                                return matching;

14✔

1056

14✔

1057

1✔

1058

                        throw new TypeError(

1✔

1059

                                `Property "${property}" has no match on the specified schema!`,

1✔

1060

);

1✔

1061

                } else if (

178✔

1062

                        !this.#is_schema_with_pattern_properties(schema)

163✔

1063

                        && !this.#is_schema_with_properties(schema)

163✔

1064

                        && '$ref' in schema

163✔

1077

209✔

1078

                if (

209✔

1079

                        this.#is_schema_with_properties(schema)

209✔

1080

                        && !(property in schema.properties)

224✔

1081

                        && 'string' === typeof schema?.$ref

224✔

1082

) {

224✔

1083

                        let checking_schema: (

28✔

1084

                                | SchemaObject

28✔

1085

                                | undefined

28✔

1086

                        ) = schema;

28✔

1087

28✔

1088

                        while (

28✔

1089

                                undefined !== checking_schema

28✔

1090

                                && !(property in checking_schema.properties)

28✔

1091

                                && 'string' === typeof checking_schema.$ref

28✔

1092

) {

28✔

1093

                                checking_schema = this.#sub_schema_for_property_resolve_$ref(

52✔

1094

                                        schema_parser,

52✔

1095

                                        checking_schema as SchemaObject & {

52✔

1096

                                                $ref: string,

52✔

1097

},

52✔

1098

);

52✔

1099

52✔

1100

                                if (

52✔

1101

                                        checking_schema

52✔

1102

                                        && 'allOf' in checking_schema

52✔

1103

                                        && undefined !== checking_schema.allOf

52✔

1104

) {

52✔

1105

                                        const matching = this.#sub_schema_for_property_from_allOf(

8✔

1106

                                                schema_parser,

8✔

1107

                                                properties_mode,

8✔

1108

                                                property,

8✔

1109

                                                checking_schema as SchemaObject & {

8✔

1110

                                                        allOf: [

8✔

1111

                                                                SchemaObject,

8✔

1112

                                                                SchemaObject,

8✔

1113

                                                                ...SchemaObject[],

8✔

1114

],

8✔

1115

},

8✔

1116

                                                fallback_if_neither,

8✔

1117

);

8✔

1118

8✔

1119

                                        if (matching) {

8✔

1120

                                                return matching;

8✔

1121

8✔

1122

8✔

1123

52✔

1124

20✔

1125

                        if (checking_schema !== undefined) {

28✔

1126

                                const maybe_type = schema_parser.parse_by_type<

18✔

1127

                                        ObjectUnspecified<

18✔

1128

                                                {[key: string]: unknown},

18✔

1129

                                                'properties'

18✔

1130

18✔

1131

>(

18✔

1132

                                        checking_schema,

18✔

1133

                                        (maybe): maybe is ObjectUnspecified<

18✔

1134

                                                {[key: string]: unknown},

18✔

1135

                                                'properties'

18✔

1136

                                        > => ObjectUnspecified.is_a<ObjectUnspecified<

18✔

1137

                                                {[key: string]: unknown},

18✔

1138

                                                'properties'

18✔

1139

                                        >>(maybe) && 'properties' === maybe.properties_mode,

18✔

1140

);

18✔

1141

18✔

1142

                                if (maybe_type && maybe_type.check_type(checking_schema)) {

18✔

1143

                                        schema = checking_schema as typeof schema;

18✔

1144

18✔

1145

18✔

1146

28✔

1147

201✔

1148

                if (

201✔

1149

                        this.#is_schema_with_properties(schema)

201✔

1150

                        && property in schema.properties

224✔

1151

                        && undefined !== schema.properties[property]

224✔

1152

) {

224✔

1153

                        return this.maybe_add_$defs(

134✔

1154

                                schema,

134✔

1155

                                schema.properties[property],

134✔

1156

);

134✔

1157

134✔

1158

67✔

1159

                if (

67✔

1160

                        this.#is_schema_with_pattern_properties(schema)

67✔

1161

) {

221✔

1162

                        const matching = Object.keys(

36✔

1163

                                schema.patternProperties,

36✔

1164

                        ).find((maybe) => {

36✔

1165

                                return (

52✔

1166

                                        (new RegExp(maybe)).test(property)

52✔

1167

                                        && undefined !== schema.patternProperties[maybe]

52✔

1168

);

52✔

1169

});

36✔

1170

36✔

1171

                        if (matching) {

36✔

1172

                                return schema.patternProperties[matching];

36✔

1173

36✔

1174

36✔

1175

31✔

1176

                if ('neither' === properties_mode) {

221✔

1177

                        return fallback_if_neither;

4✔

1178

4✔

1179

27✔

1180

                throw new TypeError(

27✔

1181

                        `Property "${property}" has no match on the specified schema!`,

27✔

1182

);

27✔

1183

224✔

1184

19✔

1185

        static #sub_schema_for_property_resolve_$ref(

19✔

1186

                schema_parser: SchemaParser,

98✔

1187

                schema: SchemaObject & {$ref: string},

98✔

1188

        ): SchemaObject|undefined {

98✔

1189

                if (!schema.$ref.startsWith('#/$defs/')) {

98✔

1190

                        const [

13✔

1191

                                other_schema_id,

13✔

1192

                                other_schema_ref_id,

13✔

1193

                        ] = schema.$ref.split(

13✔

1194

                                '#/$defs/',

13✔

1195

                        ) as [string, string];

13✔

1196

13✔

1197

                        const other_schema = schema_parser.get_schema(

13✔

1198

                                other_schema_id,

13✔

1199

);

13✔

1200

13✔

1201

                        if (

13✔

1202

                                other_schema

13✔

1203

                                && '$defs' in other_schema

13✔

1204

                                && undefined !== other_schema.$defs

13✔

1205

                                && other_schema_ref_id in other_schema.$defs

13✔

1206

) {

13✔

1207

                                return this.maybe_add_$defs(

12✔

1208

                                        other_schema,

12✔

1209

                                        other_schema.$defs[other_schema_ref_id],

12✔

1210

);

12✔

1211

12✔

1212

                } else {

98✔

1213

                        const $ref_id = schema.$ref.split('#/$defs/')[1];

85✔

1214

85✔

1215

                        if (

85✔

1216

                                '$defs' in schema

85✔

1217

                                && undefined !== schema.$defs

85✔

1218

                                && $ref_id in schema.$defs

85✔

1219

) {

85✔

1220

                                return this.maybe_add_$defs(

84✔

1221

                                        schema,

84✔

1222

                                        schema.$defs[$ref_id],

84✔

1223

);

84✔

1224

84✔

1225

85✔

1226

2✔

1227

                return undefined;

2✔

1228

98✔

1229

19✔

1230

        static #sub_schema_for_property_from_allOf<

19✔

1231

                PropertiesMode extends object_properties_mode,

23✔

1232

>(

23✔

1233

                schema_parser: SchemaParser,

23✔

1234

                properties_mode: PropertiesMode,

23✔

1235

                property: string,

23✔

1236

                schema: SchemaObject & {

23✔

1237

                        allOf: [

23✔

1238

                                SchemaObject,

23✔

1239

                                SchemaObject,

23✔

1240

                                ...SchemaObject[],

23✔

1241

],

23✔

1242

},

23✔

1243

                fallback_if_neither: Record<string, never>|unknown_type,

23✔

1244

        ): SchemaObject|undefined {

23✔

1245

                let matching: SchemaObject|undefined;

23✔

1246

23✔

1247

                for (const candidate of schema.allOf) {

23✔

1248

                        try {

46✔

1249

                                const maybe = this.#sub_schema_for_property(

46✔

1250

                                        schema_parser,

46✔

1251

                                        properties_mode,

46✔

1252

                                        property,

46✔

1253

                                        this.maybe_add_$defs(

46✔

1254

                                                schema,

46✔

1255

                                                candidate,

46✔

1256

),

46✔

1257

                                        fallback_if_neither,

46✔

1258

);

46✔

1259

46✔

1260

                                if (undefined !== maybe) {

46✔

1261

                                        matching = maybe;

22✔

1262

22✔

1263

                        // eslint-disable-next-line @typescript-eslint/no-unused-vars

46✔

1264

                        } catch (err) { /* empty */ }

46✔

1265

46✔

1266

23✔

1267

                return matching;

23✔

1268

23✔

1269

19✔

1270

19✔

1271

export type {

19✔

1272

        object_properties_mode,

19✔

1273

        object_type,

19✔

1274

        object_schema,

19✔

1275

        object_TypeLiteralNode,

19✔

1276

        object_TypeLiteralNode_possibly_extended,

19✔

1277

};

19✔

1278

19✔

1279

export {

19✔

1280

        ObjectUnspecified,

19✔

1281

};

19✔

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19116883256

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

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19116883256

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

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