SignpostMarv/JSON-Schema-TypeScript-CodeGen | Build 19111837150 | 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,101✔

284

        readonly properties_mode: PropertiesMode;

19✔

285

19✔

286

        constructor(

19✔

287

                options: {

1,101✔

288

                        adjust_name?: adjust_name_callback,

1,101✔

289

                        properties_mode: PropertiesMode,

1,101✔

290

                        $defs?: Defs,

1,101✔

291

                        required?: Required,

1,101✔

292

                        properties?: Properties,

1,101✔

293

                        patternProperties?: PatternProperties,

1,101✔

294

},

1,101✔

295

1,101✔

296

                        ajv,

1,101✔

297

                }: ObjectUncertain_options<

1,101✔

298

                        object_schema<

1,101✔

299

                                PropertiesMode

1,101✔

300

>,

1,101✔

301

                        object_type<

1,101✔

302

                                PropertiesMode,

1,101✔

303

                                Defs,

1,101✔

304

                                Required,

1,101✔

305

                                Properties,

1,101✔

306

                                PatternProperties

1,101✔

307

1,101✔

308

>,

1,101✔

309

) {

1,101✔

310

                super({

1,101✔

311

                        ajv,

1,101✔

312

                        type_definition: options,

1,101✔

313

                        schema_definition: options,

1,101✔

314

});

1,101✔

315

1,101✔

316

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

1,101✔

317

                this.properties_mode = options.properties_mode;

1,101✔

318

1,101✔

319

19✔

320

        generate_typescript_data(

19✔

321

                data: T,

68✔

322

                schema_parser: SchemaParser,

68✔

323

                schema: object_type<

68✔

324

                        PropertiesMode,

68✔

325

                        Defs,

68✔

326

                        Required,

68✔

327

                        Properties,

68✔

328

                        PatternProperties

68✔

329

>,

68✔

330

        ): ObjectLiteralExpression {

68✔

331

                return ObjectUnspecified.#createObjectLiteralExpression(

68✔

332

                        this.properties_mode,

68✔

333

                        data,

68✔

334

                        schema,

68✔

335

                        schema_parser,

68✔

336

                        this.#adjust_name,

68✔

337

);

68✔

338

68✔

339

19✔

340

        async generate_typescript_type(

19✔

341

30✔

342

                        schema,

30✔

343

                        schema_parser,

30✔

344

                }: {

30✔

345

                        schema: object_type<

30✔

346

                                PropertiesMode,

30✔

347

                                Defs,

30✔

348

                                Required,

30✔

349

                                Properties,

30✔

350

                                PatternProperties

30✔

351

>,

30✔

352

                        schema_parser: SchemaParser,

30✔

353

},

30✔

354

        ): Promise<object_TypeLiteralNode_possibly_extended<PropertiesMode>> {

30✔

355

                let object_type: (

30✔

356

                        | Promise<object_TypeLiteralNode<PropertiesMode>>

30✔

357

                        | IntersectionTypeNode<[

30✔

358

                                TypeReferenceNode,

30✔

359

                                object_TypeLiteralNode<PropertiesMode>,

30✔

360

]>

30✔

361

                ) = ObjectUnspecified.#createTypeNode(

30✔

362

                        this.properties_mode,

30✔

363

                        schema,

30✔

364

                        schema_parser,

30✔

365

);

30✔

366

30✔

367

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

30✔

368

                        const $ref_instance = schema_parser.parse_by_type({

5✔

369

                                $ref: schema.$ref,

5✔

370

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

5✔

371

5✔

372

                        object_type = factory.createIntersectionTypeNode([

5✔

373

                                await $ref_instance.generate_typescript_type({

5✔

374

                                        schema: {

5✔

375

                                                $ref: schema.$ref,

5✔

376

},

5✔

377

}),

5✔

378

                                await object_type,

5✔

379

]);

5✔

380

5✔

381

30✔

382

                return object_type;

30✔

383

30✔

384

19✔

385

        static generate_schema_definition<

19✔

386

                PropertiesMode extends object_properties_mode,

1,105✔

387

>({

1,105✔

388

                properties_mode,

1,105✔

389

        }: {

1,105✔

390

                properties_mode: PropertiesMode,

1,105✔

391

        }): Readonly<object_schema<

1,105✔

392

                PropertiesMode

1,105✔

393

        >> {

1,105✔

394

                const required_for_partial = (

1,105✔

395

                        this.#generate_schema_definition_required(

1,105✔

396

                                properties_mode,

1,105✔

397

1,105✔

398

);

1,105✔

399

1,105✔

400

                const properties_for_partial: Partial<

1,105✔

401

                        object_schema<'both'>['properties']

1,105✔

402

                > = {

1,105✔

403

                        ...$defs_schema.properties,

1,105✔

404

                        type: {

1,105✔

405

                                type: 'string',

1,105✔

406

                                const: 'object',

1,105✔

407

},

1,105✔

408

                        $ref: {

1,105✔

409

                                type: 'string',

1,105✔

410

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

1,105✔

411

},

1,105✔

412

                        additionalProperties: {

1,105✔

413

                                type: 'boolean',

1,105✔

414

},

1,105✔

415

                        unevaluatedProperties: {

1,105✔

416

                                type: 'boolean',

1,105✔

417

},

1,105✔

418

};

1,105✔

419

1,105✔

420

                properties_for_partial.required = {

1,105✔

421

                        type: 'array',

1,105✔

422

                        minItems: 1,

1,105✔

423

                        items: {

1,105✔

424

                                type: 'string',

1,105✔

425

                                minLength: 1,

1,105✔

426

},

1,105✔

427

};

1,105✔

428

1,105✔

429

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

1,105✔

430

                        const properties: (

561✔

431

                                object_schema<

561✔

432

                                        'properties'

561✔

433

                                >['properties']['properties']

561✔

434

                        ) = {

561✔

435

                                type: 'object',

561✔

436

                                minProperties: 1,

561✔

437

                                additionalProperties: {

561✔

438

                                        type: 'object',

561✔

439

},

561✔

440

};

561✔

441

                        properties_for_partial.properties = properties;

561✔

442

561✔

443

                if (

1,105✔

444

                        'properties' !== properties_mode

1,105✔

445

                        && 'neither' !== properties_mode

1,105✔

446

) {

1,105✔

447

                        const properties: (

544✔

448

                                object_schema<

544✔

449

                                        'pattern'

544✔

450

                                >['properties']['patternProperties']

544✔

451

                        ) = {

544✔

452

                                type: 'object',

544✔

453

                                minProperties: 1,

544✔

454

                                additionalProperties: {

544✔

455

                                        type: 'object',

544✔

456

},

544✔

457

};

544✔

458

                        properties_for_partial.patternProperties = properties;

544✔

459

544✔

460

1,105✔

461

                if ('neither' === properties_mode) {

1,105✔

462

272✔

463

                                properties_for_partial as Partial<

272✔

464

                                        object_schema<'neither'>['properties']

272✔

465

272✔

466

                        ).additionalProperties = {

272✔

467

                                type: 'boolean',

272✔

468

                                const: false,

272✔

469

};

272✔

470

272✔

471

                                properties_for_partial as Partial<

272✔

472

                                        object_schema<'neither'>['properties']

272✔

473

272✔

474

                        ).maxProperties = {

272✔

475

                                type: 'integer',

272✔

476

                                const: 0,

272✔

477

};

272✔

478

272✔

479

1,105✔

480

                const unpartial_properties: object_schema<

1,105✔

481

                        PropertiesMode

1,105✔

482

                >['properties'] = properties_for_partial as object_schema<

1,105✔

483

                        PropertiesMode

1,105✔

484

                >['properties'];

1,105✔

485

1,105✔

486

                const partial_required: object_schema<

1,105✔

487

                        PropertiesMode

1,105✔

488

                >['required'] = required_for_partial;

1,105✔

489

                const partial_properties: object_schema<

1,105✔

490

                        PropertiesMode

1,105✔

491

                >['properties'] = unpartial_properties;

1,105✔

492

1,105✔

493

                const result: object_schema<

1,105✔

494

                        PropertiesMode

1,105✔

495

                > = {

1,105✔

496

                        type: 'object',

1,105✔

497

                        required: partial_required,

1,105✔

498

                        additionalProperties: false,

1,105✔

499

                        properties: partial_properties,

1,105✔

500

                } as object_schema<

1,105✔

501

                        PropertiesMode

1,105✔

502

>;

1,105✔

503

1,105✔

504

                return Object.freeze(result);

1,105✔

505

1,105✔

506

19✔

507

        static #generate_schema_definition_required<

19✔

508

                PropertiesMode extends object_properties_mode,

1,105✔

509

>(

1,105✔

510

                properties_mode: PropertiesMode,

1,105✔

511

        ): object_schema<

1,105✔

512

                PropertiesMode

1,105✔

513

        >['required'] {

1,105✔

514

                const values_for_properties_mode: {

1,105✔

515

                        neither: readonly string[],

1,105✔

516

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

1,105✔

517

                        properties: readonly ['properties'],

1,105✔

518

                        pattern: readonly ['patternProperties'],

1,105✔

519

                }[PropertiesMode] = {

1,105✔

520

                        neither: [] as readonly string[],

1,105✔

521

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

1,105✔

522

                        properties: ['properties'] as const,

1,105✔

523

                        pattern: ['patternProperties'] as const,

1,105✔

524

                }[properties_mode];

1,105✔

525

1,105✔

526

                const required: object_schema<

1,105✔

527

                        PropertiesMode

1,105✔

528

                >['required'] = [

1,105✔

529

                        ...['type'],

1,105✔

530

                        ...values_for_properties_mode,

1,105✔

531

                ] as object_schema<

1,105✔

532

                        PropertiesMode

1,105✔

533

                >['required'];

1,105✔

534

1,105✔

535

                return required;

1,105✔

536

1,105✔

537

19✔

538

        static generate_type_definition<

19✔

539

                PropertiesMode extends object_properties_mode,

1,101✔

540

                Defs extends SchemaObject,

1,101✔

541

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

1,101✔

542

                Properties extends ObjectOfSchemas,

1,101✔

543

                PatternProperties extends ObjectOfSchemas,

1,101✔

544

>({

1,101✔

545

                properties_mode,

1,101✔

546

                $defs,

1,101✔

547

                required,

1,101✔

548

                properties,

1,101✔

549

                patternProperties,

1,101✔

550

        }: {

1,101✔

551

                properties_mode: PropertiesMode,

1,101✔

552

                $defs?: Defs,

1,101✔

553

                required?: Required,

1,101✔

554

                properties?: Properties,

1,101✔

555

                patternProperties?: PatternProperties,

1,101✔

556

        }): Readonly<object_type<

1,101✔

557

                PropertiesMode,

1,101✔

558

                Defs,

1,101✔

559

                Required,

1,101✔

560

                Properties,

1,101✔

561

                PatternProperties

1,101✔

562

        >> {

1,101✔

563

                const partial: Partial<object_type<

1,101✔

564

                        'both',

1,101✔

565

                        Defs,

1,101✔

566

                        Required,

1,101✔

567

                        Properties,

1,101✔

568

                        PatternProperties

1,101✔

569

                >> = {

1,101✔

570

                        type: 'object',

1,101✔

571

};

1,101✔

572

1,101✔

573

                if ($defs) {

1,101✔

574

                        partial.$defs = $defs;

8✔

575

8✔

576

1,101✔

577

                if (required) {

1,101✔

578

                        partial.required = required;

4✔

579

4✔

580

1,101✔

581

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

1,101✔

582

                        partial.properties = properties;

559✔

583

559✔

584

1,101✔

585

                if (

1,101✔

586

                        'both' === properties_mode

1,101✔

587

                        || 'pattern' === properties_mode

1,101✔

588

) {

1,101✔

589

                        partial.patternProperties = patternProperties;

542✔

590

542✔

591

1,101✔

592

                const frozen = Object.freeze(partial as object_type<

1,101✔

593

                        PropertiesMode,

1,101✔

594

                        Defs,

1,101✔

595

                        Required,

1,101✔

596

                        Properties,

1,101✔

597

                        PatternProperties

1,101✔

598

>);

1,101✔

599

1,101✔

600

                return frozen;

1,101✔

601

1,101✔

602

19✔

603

        static #is_schema_with_some_type_of_properties<

19✔

604

                Defs extends SchemaObject,

30✔

605

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

30✔

606

                Properties extends ObjectOfSchemas,

30✔

607

                PatternProperties extends ObjectOfSchemas,

30✔

608

>(

30✔

609

                schema: object_type<

30✔

610

                        object_properties_mode,

30✔

611

                        Defs,

30✔

612

                        Required,

30✔

613

                        Properties,

30✔

614

                        PatternProperties

30✔

615

>,

30✔

616

        ): schema is object_type<

30✔

617

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

30✔

618

                Defs,

30✔

619

                Required,

30✔

620

                Properties,

30✔

621

                PatternProperties

30✔

622

> {

30✔

623

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

30✔

624

30✔

625

19✔

626

        static #is_schema_with_properties<

19✔

627

                Defs extends SchemaObject,

608✔

628

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

608✔

629

                Properties extends ObjectOfSchemas,

608✔

630

                PatternProperties extends ObjectOfSchemas,

608✔

631

>(

608✔

632

                schema: SchemaObject|object_type<

608✔

633

                        object_properties_mode,

608✔

634

                        Defs,

608✔

635

                        Required,

608✔

636

                        Properties,

608✔

637

                        PatternProperties

608✔

638

>,

608✔

639

        ): schema is object_type<

608✔

640

                'both' | 'properties',

608✔

641

                Defs,

608✔

642

                Required,

608✔

643

                Properties,

608✔

644

                PatternProperties

608✔

645

> {

608✔

646

                return 'properties' in schema;

608✔

647

608✔

648

19✔

649

        static #is_schema_with_pattern_properties<

19✔

650

                Defs extends SchemaObject,

411✔

651

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

411✔

652

                Properties extends ObjectOfSchemas,

411✔

653

                PatternProperties extends ObjectOfSchemas,

411✔

654

>(

411✔

655

                schema: SchemaObject|object_type<

411✔

656

                        object_properties_mode,

411✔

657

                        Defs,

411✔

658

                        Required,

411✔

659

                        Properties,

411✔

660

                        PatternProperties

411✔

661

>,

411✔

662

        ): schema is object_type<

411✔

663

                'both'|'pattern',

411✔

664

                Defs,

411✔

665

                Required,

411✔

666

                Properties,

411✔

667

                PatternProperties

411✔

668

> {

411✔

669

                return 'patternProperties' in schema;

411✔

670

411✔

671

19✔

672

        static #is_schema_with_required<

19✔

673

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

31✔

674

>(

31✔

675

                schema: object_type<

31✔

676

                        object_properties_mode,

31✔

677

                        SchemaObject,

31✔

678

                        Required,

31✔

679

                        ObjectOfSchemas,

31✔

680

                        ObjectOfSchemas

31✔

681

>,

31✔

682

        ): schema is object_type<

31✔

683

                object_properties_mode,

31✔

684

                SchemaObject,

31✔

685

                Required,

31✔

686

                ObjectOfSchemas,

31✔

687

                ObjectOfSchemas

31✔

688

        > & {required: Required} {

31✔

689

                return 'required' in schema;

31✔

690

31✔

691

19✔

692

        static #convert<

19✔

693

T,

127✔

694

                PropertiesMode extends object_properties_mode,

127✔

695

                Defs extends SchemaObject,

127✔

696

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

127✔

697

                Properties extends ObjectOfSchemas,

127✔

698

                PatternProperties extends ObjectOfSchemas,

127✔

699

>(

127✔

700

                properties_mode: PropertiesMode,

127✔

701

                value: unknown,

127✔

702

                property: string,

127✔

703

                schema: object_type<

127✔

704

                        PropertiesMode,

127✔

705

                        Defs,

127✔

706

                        Required,

127✔

707

                        Properties,

127✔

708

                        PatternProperties

127✔

709

>,

127✔

710

                schema_parser: SchemaParser,

127✔

711

) {

127✔

712

                const sub_schema = this.#sub_schema_for_property(

127✔

713

                        schema_parser,

127✔

714

                        properties_mode,

127✔

715

                        property,

127✔

716

                        schema,

127✔

717

{},

127✔

718

);

127✔

719

127✔

720

                let maybe_modified = ObjectUnspecified.maybe_add_$defs(

127✔

721

                        schema,

127✔

722

                        sub_schema,

127✔

723

);

127✔

724

127✔

725

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

127✔

726

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

127✔

727

127✔

728

                if (!(validator(value))) {

127✔

729

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

26✔

730

26✔

731

98✔

732

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

127✔

733

                        maybe_modified = {

4✔

734

                                type: 'object',

4✔

735

                                additionalProperties: false,

4✔

736

                                maxProperties: 0,

4✔

737

};

4✔

738

4✔

739

98✔

740

                const instance = schema_parser.parse(

98✔

741

                        maybe_modified,

98✔

742

);

98✔

743

98✔

744

                return instance.generate_typescript_data(

98✔

745

                        value,

98✔

746

                        schema_parser,

98✔

747

                        maybe_modified,

98✔

748

);

98✔

749

127✔

750

19✔

751

        static #createObjectLiteralExpression<

19✔

752

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

68✔

753

                PropertiesMode extends object_properties_mode,

68✔

754

                Defs extends SchemaObject,

68✔

755

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

68✔

756

                Properties extends ObjectOfSchemas,

68✔

757

                PatternProperties extends ObjectOfSchemas,

68✔

758

>(

68✔

759

                properties_mode: PropertiesMode,

68✔

760

                data: T,

68✔

761

                schema: object_type<

68✔

762

                        PropertiesMode,

68✔

763

                        Defs,

68✔

764

                        Required,

68✔

765

                        Properties,

68✔

766

                        PatternProperties

68✔

767

>,

68✔

768

                schema_parser: SchemaParser,

68✔

769

                adjust_name: adjust_name_callback,

68✔

770

        ): ObjectLiteralExpression {

68✔

771

                return factory.createObjectLiteralExpression(

68✔

772

                        Object.entries(

68✔

773

                                data,

68✔

774

                        ).map(([

68✔

775

                                property,

127✔

776

                                value,

127✔

777

                        ]) => {

127✔

778

                                const type = this.#convert(

127✔

779

                                        properties_mode,

127✔

780

                                        value,

127✔

781

                                        property,

127✔

782

                                        schema,

127✔

783

                                        schema_parser,

127✔

784

);

127✔

785

127✔

786

                                return factory.createPropertyAssignment(

127✔

787

                                        adjust_name(property),

127✔

788

                                        type,

127✔

789

);

127✔

790

}),

68✔

791

);

68✔

792

68✔

793

19✔

794

        static async #createTypeNode<

19✔

795

                PropertiesMode extends object_properties_mode,

30✔

796

                Defs extends SchemaObject,

30✔

797

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

30✔

798

                Properties extends ObjectOfSchemas,

30✔

799

                PatternProperties extends ObjectOfSchemas,

30✔

800

>(

30✔

801

                properties_mode: PropertiesMode,

30✔

802

                schema: object_type<

30✔

803

                        PropertiesMode,

30✔

804

                        Defs,

30✔

805

                        Required,

30✔

806

                        Properties,

30✔

807

                        PatternProperties

30✔

808

>,

30✔

809

                schema_parser: SchemaParser,

30✔

810

        ): Promise<object_TypeLiteralNode<PropertiesMode>> {

30✔

811

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

30✔

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

28✔

829

                let properties: PropertySignature[] = [];

28✔

830

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

28✔

831

28✔

832

                if (this.#is_schema_with_properties(schema)) {

30✔

833

                        properties = await Promise.all(Object.keys(

24✔

834

                                schema.properties,

24✔

835

                        ).map(async (

24✔

836

                                property,

31✔

837

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

31✔

838

                                undefined,

31✔

839

31✔

840

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

31✔

841

                                                ? factory.createComputedPropertyName(

31✔

842

                                                        factory.createStringLiteral(property),

2✔

843

2✔

844

                                                : property

31✔

845

),

31✔

846

31✔

847

31✔

848

                                                this.#is_schema_with_required(schema)

31✔

849

                                                && schema.required.includes(property)

31✔

850

31✔

851

                                                ? undefined

31✔

852

                                                : factory.createToken(SyntaxKind.QuestionToken)

31✔

853

),

31✔

854

                                await this.#generate_type(

31✔

855

                                        properties_mode,

31✔

856

                                        property,

31✔

857

                                        schema,

31✔

858

                                        schema_parser,

31✔

859

),

31✔

860

                        )));

24✔

861

24✔

862

28✔

863

                if (this.#is_schema_with_pattern_properties(schema)) {

30✔

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

28✔

886

                let result: object_TypeLiteralNode<

28✔

887

                        Exclude<

28✔

888

                                object_properties_mode,

28✔

889

                                'neither'

28✔

890

28✔

891

>;

28✔

892

28✔

893

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

30✔

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) {

30✔

901

                        result = factory.createTypeLiteralNode(properties);

22✔

902

                } else {

26✔

903

                        result = this.#patterned_literal_node(

4✔

904

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

4✔

905

);

4✔

906

4✔

907

28✔

908

                return result as object_TypeLiteralNode<PropertiesMode>;

28✔

909

30✔

910

19✔

911

        static async #generate_type<

19✔

912

                PropertiesMode extends object_properties_mode,

31✔

913

                Defs extends SchemaObject,

31✔

914

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

31✔

915

                Properties extends ObjectOfSchemas,

31✔

916

                PatternProperties extends ObjectOfSchemas,

31✔

917

>(

31✔

918

                properties_mode: PropertiesMode,

31✔

919

                property: string,

31✔

920

                schema: object_type<

31✔

921

                        PropertiesMode,

31✔

922

                        Defs,

31✔

923

                        Required,

31✔

924

                        Properties,

31✔

925

                        PatternProperties

31✔

926

>,

31✔

927

                schema_parser: SchemaParser,

31✔

928

) {

31✔

929

                const sub_schema = this.#sub_schema_for_property(

31✔

930

                        schema_parser,

31✔

931

                        properties_mode,

31✔

932

                        property,

31✔

933

                        schema,

31✔

934

{},

31✔

935

);

31✔

936

31✔

937

                let matched: (

31✔

938

                        | undefined

31✔

939

                        | Type<unknown>

31✔

940

                ) = schema_parser.maybe_parse_by_type<

31✔

941

                        $ref

31✔

942

>(

31✔

943

                        sub_schema,

31✔

944

31✔

945

                                maybe: unknown,

164✔

946

                        ): maybe is $ref => {

164✔

947

                                return $ref.is_a(maybe);

164✔

948

},

31✔

949

);

31✔

950

31✔

951

                if (undefined === matched) {

31✔

952

                        matched = schema_parser.parse(sub_schema);

19✔

953

                } else {

31✔

954

                        return matched.generate_typescript_type({

12✔

955

                                data: sub_schema,

12✔

956

                                schema: sub_schema,

12✔

957

                                schema_parser,

12✔

958

});

12✔

959

12✔

960

19✔

961

                return matched.generate_typescript_type({

19✔

962

                        schema: sub_schema,

19✔

963

                        schema_parser,

19✔

964

});

19✔

965

31✔

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,

174✔

996

                Defs extends SchemaObject,

174✔

997

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

174✔

998

                Properties extends ObjectOfSchemas,

174✔

999

                PatternProperties extends ObjectOfSchemas,

174✔

1000

>(

174✔

1001

                schema_parser: SchemaParser,

174✔

1002

                properties_mode: PropertiesMode,

174✔

1003

                property: string,

174✔

1004

                schema: SchemaObject|object_type<

174✔

1005

                        PropertiesMode,

174✔

1006

                        Defs,

174✔

1007

                        Required,

174✔

1008

                        Properties,

174✔

1009

                        PatternProperties

174✔

1010

>,

174✔

1011

                fallback_if_neither: Record<string, never>|unknown_type,

174✔

1012

        ): SchemaObject {

174✔

1013

                if (

174✔

1014

                        !this.#is_schema_with_pattern_properties(schema)

174✔

1015

                        && !this.#is_schema_with_properties(schema)

174✔

1016

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

174✔

1017

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

174✔

1018

                        && '$defs' in schema

174✔

1019

) {

174✔

1020

                        const maybe_replace_schema = (

16✔

1021

                                this.#sub_schema_for_property_resolve_$ref(

16✔

1022

                                        schema_parser,

16✔

1023

                                        schema as SchemaObject & {

16✔

1024

                                                $ref: string,

16✔

1025

},

16✔

1026

16✔

1027

);

16✔

1028

16✔

1029

                        if (maybe_replace_schema) {

16✔

1030

                                schema = maybe_replace_schema;

16✔

1031

16✔

1032

                } else if (

174✔

1033

                        !this.#is_schema_with_pattern_properties(schema)

158✔

1034

                        && !this.#is_schema_with_properties(schema)

158✔

1035

                        && 'allOf' in schema

158✔

1036

                        && undefined !== schema.allOf

158✔

1037

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

158✔

1038

                        && '$defs' in schema

158✔

1039

) {

158✔

1040

                        const matching = this.#sub_schema_for_property_from_allOf(

8✔

1041

                                schema_parser,

8✔

1042

                                properties_mode,

8✔

1043

                                property,

8✔

1044

                                schema as SchemaObject & {

8✔

1045

                                        allOf: [

8✔

1046

                                                SchemaObject,

8✔

1047

                                                SchemaObject,

8✔

1048

                                                ...SchemaObject[],

8✔

1049

],

8✔

1050

},

8✔

1051

                                fallback_if_neither,

8✔

1052

);

8✔

1053

8✔

1054

                        if (matching) {

8✔

1055

                                return matching;

8✔

1056

8✔

1062

166✔

1063

                if (

166✔

1064

                        this.#is_schema_with_properties(schema)

166✔

1065

                        && !(property in schema.properties)

174✔

1066

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

174✔

1067

) {

174✔

1068

                        let checking_schema: (

20✔

1069

                                | SchemaObject

20✔

1070

                                | undefined

20✔

1071

                        ) = schema;

20✔

1072

20✔

1073

                        while (

20✔

1074

                                undefined !== checking_schema

20✔

1075

                                && !(property in checking_schema.properties)

20✔

1076

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

20✔

1077

) {

20✔

1078

                                checking_schema = this.#sub_schema_for_property_resolve_$ref(

44✔

1079

                                        schema_parser,

44✔

1080

                                        checking_schema as SchemaObject & {

44✔

1081

                                                $ref: string,

44✔

1082

},

44✔

1083

);

44✔

1084

44✔

1085

                                if (

44✔

1086

                                        checking_schema

44✔

1087

                                        && 'allOf' in checking_schema

44✔

1110

44✔

1111

20✔

1112

                        if (checking_schema !== undefined) {

20✔

1113

                                const maybe_type = schema_parser.parse_by_type<

18✔

1114

                                        ObjectUnspecified<

18✔

1115

                                                {[key: string]: unknown},

18✔

1116

                                                'properties'

18✔

1117

18✔

1118

>(

18✔

1119

                                        checking_schema,

18✔

1120

                                        (maybe): maybe is ObjectUnspecified<

18✔

1121

                                                {[key: string]: unknown},

18✔

1122

                                                'properties'

18✔

1123

                                        > => ObjectUnspecified.is_a<ObjectUnspecified<

18✔

1124

                                                {[key: string]: unknown},

18✔

1125

                                                'properties'

18✔

1126

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

18✔

1127

);

18✔

1128

18✔

1129

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

18✔

1130

                                        schema = checking_schema as typeof schema;

18✔

1131

18✔

1132

18✔

1133

20✔

1134

166✔

1135

                if (

166✔

1136

                        this.#is_schema_with_properties(schema)

166✔

1137

                        && property in schema.properties

174✔

1138

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

174✔

1139

) {

174✔

1140

                        return this.maybe_add_$defs(

115✔

1141

                                schema,

115✔

1142

                                schema.properties[property],

115✔

1143

);

115✔

1144

115✔

1145

51✔

1146

                if (

51✔

1147

                        this.#is_schema_with_pattern_properties(schema)

51✔

1148

) {

171✔

1149

                        const matching = Object.keys(

36✔

1150

                                schema.patternProperties,

36✔

1151

                        ).find((maybe) => {

36✔

1152

                                return (

52✔

1153

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

52✔

1154

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

52✔

1155

);

52✔

1156

});

36✔

1157

36✔

1158

                        if (matching) {

36✔

1159

                                return schema.patternProperties[matching];

36✔

1160

36✔

1161

36✔

1162

15✔

1163

                if ('neither' === properties_mode) {

171✔

1164

                        return fallback_if_neither;

4✔

1165

4✔

1166

11✔

1167

                throw new TypeError(

11✔

1168

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

11✔

1169

);

11✔

1170

174✔

1171

19✔

1172

        static #sub_schema_for_property_resolve_$ref(

19✔

1173

                schema_parser: SchemaParser,

60✔

1174

                schema: SchemaObject & {$ref: string},

60✔

1175

        ): SchemaObject|undefined {

60✔

1176

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

60✔

1177

                        const [

13✔

1178

                                other_schema_id,

13✔

1179

                                other_schema_ref_id,

13✔

1180

                        ] = schema.$ref.split(

13✔

1181

                                '#/$defs/',

13✔

1182

                        ) as [string, string];

13✔

1183

13✔

1184

                        const other_schema = schema_parser.get_schema(

13✔

1185

                                other_schema_id,

13✔

1186

);

13✔

1187

13✔

1188

                        if (

13✔

1189

                                other_schema

13✔

1190

                                && '$defs' in other_schema

13✔

1191

                                && undefined !== other_schema.$defs

13✔

1192

                                && other_schema_ref_id in other_schema.$defs

13✔

1193

) {

13✔

1194

                                return this.maybe_add_$defs(

12✔

1195

                                        other_schema,

12✔

1196

                                        other_schema.$defs[other_schema_ref_id],

12✔

1197

);

12✔

1198

12✔

1199

                } else {

60✔

1200

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

47✔

1201

47✔

1202

                        if (

47✔

1203

                                '$defs' in schema

47✔

1204

                                && undefined !== schema.$defs

47✔

1205

                                && $ref_id in schema.$defs

47✔

1206

) {

47✔

1207

                                return this.maybe_add_$defs(

46✔

1208

                                        schema,

46✔

1209

                                        schema.$defs[$ref_id],

46✔

1210

);

46✔

1211

46✔

1212

47✔

1213

2✔

1214

                return undefined;

2✔

1215

60✔

1216

19✔

1217

        static #sub_schema_for_property_from_allOf<

19✔

1218

                PropertiesMode extends object_properties_mode,

8✔

1219

>(

8✔

1220

                schema_parser: SchemaParser,

8✔

1221

                properties_mode: PropertiesMode,

8✔

1222

                property: string,

8✔

1223

                schema: SchemaObject & {

8✔

1224

                        allOf: [

8✔

1225

                                SchemaObject,

8✔

1226

                                SchemaObject,

8✔

1227

                                ...SchemaObject[],

8✔

1228

],

8✔

1229

},

8✔

1230

                fallback_if_neither: Record<string, never>|unknown_type,

8✔

1231

        ): SchemaObject|undefined {

8✔

1232

                let matching: SchemaObject|undefined;

8✔

1233

8✔

1234

                for (const candidate of schema.allOf) {

8✔

1235

                        try {

16✔

1236

                                const maybe = this.#sub_schema_for_property(

16✔

1237

                                        schema_parser,

16✔

1238

                                        properties_mode,

16✔

1239

                                        property,

16✔

1240

                                        this.maybe_add_$defs(

16✔

1241

                                                schema,

16✔

1242

                                                candidate,

16✔

1243

),

16✔

1244

                                        fallback_if_neither,

16✔

1245

);

16✔

1246

16✔

1247

                                if (undefined !== maybe) {

16✔

1248

                                        matching = maybe;

8✔

1249

8✔

1250

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

16✔

1251

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

16✔

1252

16✔

1253

8✔

1254

                return matching;

8✔

1255

8✔

1256

19✔

1257

19✔

1258

export type {

19✔

1259

        object_properties_mode,

19✔

1260

        object_type,

19✔

1261

        object_schema,

19✔

1262

        object_TypeLiteralNode,

19✔

1263

        object_TypeLiteralNode_possibly_extended,

19✔

1264

};

19✔

1265

19✔

1266

export {

19✔

1267

        ObjectUnspecified,

19✔

1268

};

19✔

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19111837150

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

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19111837150

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