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

1

import type {

19✔

2

        ComputedPropertyName,

19✔

3

        IndexSignatureDeclaration,

19✔

4

        ObjectLiteralExpression,

19✔

5

        PropertySignature,

19✔

6

        TypeNode,

19✔

7

} from 'typescript';

19✔

8

import {

19✔

9

        SyntaxKind,

19✔

10

} from 'typescript';

19✔

11

19✔

12

import type {

19✔

13

        SchemaDefinitionDefinition,

19✔

14

        SchemaDefinitionDefinitionWith$defs,

19✔

15

        TypeDefinitionSchema,

19✔

16

        TypeOptions,

19✔

17

} from './Type.ts';

19✔

18

import {

19✔

19

        $defs_schema,

19✔

20

        Type,

19✔

21

} from './Type.ts';

19✔

22

19✔

23

import type {

19✔

24

        ExternalRef,

19✔

25

        LocalRef,

19✔

26

        pattern_either,

19✔

27

} from './Ref.ts';

19✔

28

19✔

29

import {

19✔

30

        $ref,

19✔

31

} from './Ref.ts';

19✔

32

19✔

33

import type {

19✔

34

        unknown_type,

19✔

35

} from './Unknown.ts';

19✔

36

19✔

37

import type {

19✔

38

        ObjectOfSchemas,

19✔

39

        SchemaObject,

19✔

40

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

41

} from '../types.ts';

19✔

42

19✔

43

import type {

19✔

44

        IntersectionTypeNode,

19✔

45

        TypeLiteralNode,

19✔

46

        TypeReferenceNode,

19✔

47

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

48

} from '../typescript/types.ts';

19✔

49

19✔

50

import {

19✔

51

        factory,

19✔

52

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

53

} from '../typescript/factory.ts';

19✔

54

19✔

55

import type {

19✔

56

        SchemaParser,

19✔

57

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

58

} from '../SchemaParser.ts';

19✔

59

19✔

60

type object_properties_mode = (

19✔

61

        | 'neither'

19✔

62

        | 'both'

19✔

63

        | 'properties'

19✔

64

        | 'pattern'

19✔

65

);

19✔

66

19✔

67

type object_type_base<

19✔

68

        PropertiesMode extends object_properties_mode,

19✔

69

        Defs extends SchemaObject,

19✔

70

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

19✔

71

        Properties extends ObjectOfSchemas,

19✔

72

        PatternProperties extends ObjectOfSchemas,

19✔

73

> = (

19✔

74

& {

19✔

75

                $defs?: Defs,

19✔

76

                $ref?: LocalRef|ExternalRef,

19✔

77

                type: 'object',

19✔

78

                required?: Required,

19✔

79

                additionalProperties?: boolean,

19✔

80

                unevaluatedProperties?: boolean,

19✔

81

19✔

82

        & Omit<

19✔

83

19✔

84

                        properties: Properties,

19✔

85

                        patternProperties: PatternProperties,

19✔

86

},

19✔

87

19✔

88

                        both: '',

19✔

89

                        neither: 'properties'|'patternProperties',

19✔

90

                        properties: 'patternProperties',

19✔

91

                        pattern: 'properties',

19✔

92

                }[PropertiesMode]

19✔

93

19✔

94

);

19✔

95

19✔

96

type object_type<

19✔

97

        PropertiesMode extends object_properties_mode,

19✔

98

        Defs extends SchemaObject,

19✔

99

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

19✔

100

        Properties extends ObjectOfSchemas,

19✔

101

        PatternProperties extends ObjectOfSchemas,

19✔

102

> = (

19✔

103

        | object_type_base<

19✔

104

                PropertiesMode,

19✔

105

                Defs,

19✔

106

                Required,

19✔

107

                Properties,

19✔

108

                PatternProperties

19✔

109

19✔

110

| {

19✔

111

                type: 'object',

19✔

112

                $defs: Defs,

19✔

113

                $ref: LocalRef|ExternalRef,

19✔

114

19✔

115

);

19✔

116

19✔

117

type object_schema_required<

19✔

118

        PropertiesMode extends object_properties_mode,

19✔

119

> = (

19✔

120

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

19✔

121

& [

19✔

122

                'type',

19✔

123

                ...{

19✔

124

                        neither: readonly string[],

19✔

125

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

19✔

126

                        properties: readonly ['properties'],

19✔

127

                        pattern: readonly ['patternProperties'],

19✔

128

                }[PropertiesMode],

19✔

129

19✔

130

);

19✔

131

19✔

132

type object_schema_properties_base = {

19✔

133

        type: {

19✔

134

                type: 'string',

19✔

135

                const: 'object',

19✔

136

},

19✔

137

        required: {

19✔

138

                type: 'array',

19✔

139

                minItems: 1,

19✔

140

                items: {

19✔

141

                        type: 'string',

19✔

142

                        minLength: 1,

19✔

143

},

19✔

144

},

19✔

145

        $ref: {

19✔

146

                type: 'string',

19✔

147

                pattern: pattern_either,

19✔

148

},

19✔

149

        additionalProperties: {

19✔

150

                type: 'boolean',

19✔

151

},

19✔

152

        unevaluatedProperties: {

19✔

153

                type: 'boolean',

19✔

154

},

19✔

155

};

19✔

156

19✔

157

type object_schema_properties_properties = {

19✔

158

        properties: {

19✔

159

                type: 'object',

19✔

160

                minProperties: 1,

19✔

161

                additionalProperties: {

19✔

162

                        type: 'object',

19✔

163

},

19✔

164

},

19✔

165

};

19✔

166

19✔

167

type object_schema_properties_pattern = {

19✔

168

        patternProperties: {

19✔

169

                type: 'object',

19✔

170

                minProperties: 1,

19✔

171

                additionalProperties: {

19✔

172

                        type: 'object',

19✔

173

},

19✔

174

},

19✔

175

};

19✔

176

19✔

177

type object_properties_by_mode<

19✔

178

        PropertiesMode extends object_properties_mode,

19✔

179

> = {

19✔

180

        both: (

19✔

181

                & object_schema_properties_properties

19✔

182

                & object_schema_properties_pattern

19✔

183

),

19✔

184

        properties: object_schema_properties_properties,

19✔

185

        pattern: object_schema_properties_pattern,

19✔

186

        neither: {

19✔

187

                additionalProperties: {

19✔

188

                        type: 'boolean',

19✔

189

                        const: false,

19✔

190

},

19✔

191

                maxProperties: {

19✔

192

                        type: 'integer',

19✔

193

                        const: 0,

19✔

194

},

19✔

195

},

19✔

196

}[PropertiesMode];

19✔

197

19✔

198

type object_schema<

19✔

199

        PropertiesMode extends object_properties_mode,

19✔

200

> = SchemaDefinitionDefinitionWith$defs<

19✔

201

        object_schema_required<PropertiesMode>,

19✔

202

19✔

203

                & ObjectOfSchemas

19✔

204

                & object_schema_properties_base

19✔

205

                & object_properties_by_mode<PropertiesMode>

19✔

206

19✔

207

>;

19✔

208

19✔

209

type object_TypeLiteralNode<

19✔

210

        PropertiesMode extends object_properties_mode,

19✔

211

> = {

19✔

212

        ['neither']: TypeLiteralNode<

19✔

213

                IndexSignatureDeclaration

19✔

214

>,

19✔

215

        ['both']: IntersectionTypeNode<[

19✔

216

                TypeLiteralNode<PropertySignature>,

19✔

217

                TypeLiteralNode<IndexSignatureDeclaration>,

19✔

218

]>,

19✔

219

        ['properties']: TypeLiteralNode<PropertySignature>,

19✔

220

        ['pattern']: TypeLiteralNode<

19✔

221

                IndexSignatureDeclaration

19✔

222

>,

19✔

223

}[PropertiesMode];

19✔

224

19✔

225

type object_TypeLiteralNode_possibly_extended<

19✔

226

        PropertiesMode extends object_properties_mode,

19✔

227

> = (

19✔

228

        | object_TypeLiteralNode<PropertiesMode>

19✔

229

        | IntersectionTypeNode<[

19✔

230

                TypeReferenceNode,

19✔

231

                object_TypeLiteralNode<PropertiesMode>,

19✔

232

]>

19✔

233

);

19✔

234

19✔

235

type ObjectUncertain_options<

19✔

236

        SchemaDefinition extends (

19✔

237

                SchemaDefinitionDefinition

19✔

238

        ) = (

19✔

239

                SchemaDefinitionDefinition

19✔

240

),

19✔

241

        TypeDefinition extends TypeDefinitionSchema = TypeDefinitionSchema,

19✔

242

> = (

19✔

243

        & Omit<

19✔

244

                TypeOptions<SchemaDefinition, TypeDefinition>,

19✔

245

19✔

246

                        | 'schema_definition'

19✔

247

                        | 'type_definition'

19✔

248

19✔

249

19✔

250

);

19✔

251

19✔

252

class ObjectUnspecified<

19✔

253

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

19✔

254

        PropertiesMode extends object_properties_mode,

19✔

255

        Defs extends SchemaObject = SchemaObject,

19✔

256

        Required extends (

19✔

257

                readonly [string, ...string[]]

19✔

258

        ) = (

19✔

259

                readonly [string, ...string[]]

19✔

260

),

19✔

261

        Properties extends ObjectOfSchemas = ObjectOfSchemas,

19✔

262

        PatternProperties extends ObjectOfSchemas = ObjectOfSchemas,

19✔

263

> extends

19✔

264

        Type<

19✔

265

T,

19✔

266

                object_type<

19✔

267

                        PropertiesMode,

19✔

268

                        Defs,

19✔

269

                        Required,

19✔

270

                        Properties,

19✔

271

                        PatternProperties

19✔

272

>,

19✔

273

19✔

274

                        properties_mode: PropertiesMode,

19✔

275

                        $defs?: Defs,

19✔

276

                        required?: Required,

19✔

277

                        properties?: Properties,

19✔

278

                        patternProperties?: PatternProperties,

19✔

279

},

19✔

280

                object_schema<

19✔

281

                        PropertiesMode

19✔

282

>,

19✔

283

19✔

284

                        properties_mode: PropertiesMode,

19✔

285

},

19✔

286

19✔

287

                        | object_TypeLiteralNode<PropertiesMode>

19✔

288

                        | IntersectionTypeNode<[

19✔

289

                                TypeReferenceNode,

19✔

290

                                object_TypeLiteralNode<PropertiesMode>,

19✔

291

]>

19✔

292

),

19✔

293

                ObjectLiteralExpression

19✔

294

> {

19✔

295

        readonly properties_mode: PropertiesMode;

19✔

296

19✔

297

        constructor(

19✔

298

                options: {

1,239✔

299

                        properties_mode: PropertiesMode,

1,239✔

300

                        $defs?: Defs,

1,239✔

301

                        required?: Required,

1,239✔

302

                        properties?: Properties,

1,239✔

303

                        patternProperties?: PatternProperties,

1,239✔

304

},

1,239✔

305

1,239✔

306

                        ajv,

1,239✔

307

                }: ObjectUncertain_options<

1,239✔

308

                        object_schema<

1,239✔

309

                                PropertiesMode

1,239✔

310

>,

1,239✔

311

                        object_type<

1,239✔

312

                                PropertiesMode,

1,239✔

313

                                Defs,

1,239✔

314

                                Required,

1,239✔

315

                                Properties,

1,239✔

316

                                PatternProperties

1,239✔

317

1,239✔

318

>,

1,239✔

319

) {

1,239✔

320

                super({

1,239✔

321

                        ajv,

1,239✔

322

                        type_definition: options,

1,239✔

323

                        schema_definition: options,

1,239✔

324

});

1,239✔

325

                this.properties_mode = options.properties_mode;

1,239✔

326

1,239✔

327

19✔

328

        generate_typescript_data(

19✔

329

                data: T,

99✔

330

                schema_parser: SchemaParser,

99✔

331

                schema: object_type<

99✔

332

                        PropertiesMode,

99✔

333

                        Defs,

99✔

334

                        Required,

99✔

335

                        Properties,

99✔

336

                        PatternProperties

99✔

337

>,

99✔

338

        ): ObjectLiteralExpression {

99✔

339

                return ObjectUnspecified.#createObjectLiteralExpression(

99✔

340

                        this.properties_mode,

99✔

341

                        data,

99✔

342

                        schema,

99✔

343

                        schema_parser,

99✔

344

);

99✔

345

99✔

346

19✔

347

        async generate_typescript_type(

19✔

348

35✔

349

                        schema,

35✔

350

                        schema_parser,

35✔

351

                }: {

35✔

352

                        schema: object_type<

35✔

353

                                PropertiesMode,

35✔

354

                                Defs,

35✔

355

                                Required,

35✔

356

                                Properties,

35✔

357

                                PatternProperties

35✔

358

>,

35✔

359

                        schema_parser: SchemaParser,

35✔

360

},

35✔

361

        ): Promise<object_TypeLiteralNode_possibly_extended<PropertiesMode>> {

35✔

362

                let object_type: (

35✔

363

                        | Promise<object_TypeLiteralNode<PropertiesMode>>

35✔

364

                        | IntersectionTypeNode<[

35✔

365

                                TypeReferenceNode,

35✔

366

                                object_TypeLiteralNode<PropertiesMode>,

35✔

367

]>

35✔

368

                ) = ObjectUnspecified.#createTypeNode(

35✔

369

                        this.properties_mode,

35✔

370

                        schema,

35✔

371

                        schema_parser,

35✔

372

);

35✔

373

35✔

374

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

35✔

375

                        const $ref_instance = schema_parser.parse_by_type({

9✔

376

                                $ref: schema.$ref,

9✔

377

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

9✔

378

9✔

379

                        object_type = factory.createIntersectionTypeNode([

9✔

380

                                await $ref_instance.generate_typescript_type({

9✔

381

                                        schema: {

9✔

382

                                                $ref: schema.$ref,

9✔

383

},

9✔

384

}),

9✔

385

                                await object_type,

9✔

386

]);

9✔

387

9✔

388

35✔

389

                return object_type;

35✔

390

35✔

391

19✔

392

        static #computedProperty_or_string(

19✔

393

                property: string,

162✔

394

        ): ComputedPropertyName|string {

162✔

395

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

162✔

396

                        ? factory.createComputedPropertyName(

162✔

397

                                factory.createStringLiteral(property),

4✔

398

4✔

399

                        : property;

162✔

400

162✔

401

19✔

402

        static generate_schema_definition<

19✔

403

                PropertiesMode extends object_properties_mode,

1,243✔

404

>({

1,243✔

405

                properties_mode,

1,243✔

406

        }: {

1,243✔

407

                properties_mode: PropertiesMode,

1,243✔

408

        }): Readonly<object_schema<

1,243✔

409

                PropertiesMode

1,243✔

410

        >> {

1,243✔

411

                const required_for_partial = (

1,243✔

412

                        this.#generate_schema_definition_required(

1,243✔

413

                                properties_mode,

1,243✔

414

1,243✔

415

);

1,243✔

416

1,243✔

417

                const properties_for_partial: Partial<

1,243✔

418

                        object_schema<'both'>['properties']

1,243✔

419

                > = {

1,243✔

420

                        ...$defs_schema.properties,

1,243✔

421

                        type: {

1,243✔

422

                                type: 'string',

1,243✔

423

                                const: 'object',

1,243✔

424

},

1,243✔

425

                        $ref: {

1,243✔

426

                                type: 'string',

1,243✔

427

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

1,243✔

428

},

1,243✔

429

                        additionalProperties: {

1,243✔

430

                                type: 'boolean',

1,243✔

431

},

1,243✔

432

                        unevaluatedProperties: {

1,243✔

433

                                type: 'boolean',

1,243✔

434

},

1,243✔

435

};

1,243✔

436

1,243✔

437

                properties_for_partial.required = {

1,243✔

438

                        type: 'array',

1,243✔

439

                        minItems: 1,

1,243✔

440

                        items: {

1,243✔

441

                                type: 'string',

1,243✔

442

                                minLength: 1,

1,243✔

443

},

1,243✔

444

};

1,243✔

445

1,243✔

446

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

1,243✔

447

                        const properties: (

631✔

448

                                object_schema<

631✔

449

                                        'properties'

631✔

450

                                >['properties']['properties']

631✔

451

                        ) = {

631✔

452

                                type: 'object',

631✔

453

                                minProperties: 1,

631✔

454

                                additionalProperties: {

631✔

455

                                        type: 'object',

631✔

456

},

631✔

457

};

631✔

458

                        properties_for_partial.properties = properties;

631✔

459

631✔

460

                if (

1,243✔

461

                        'properties' !== properties_mode

1,243✔

462

                        && 'neither' !== properties_mode

1,243✔

463

) {

1,243✔

464

                        const properties: (

610✔

465

                                object_schema<

610✔

466

                                        'pattern'

610✔

467

                                >['properties']['patternProperties']

610✔

468

                        ) = {

610✔

469

                                type: 'object',

610✔

470

                                minProperties: 1,

610✔

471

                                additionalProperties: {

610✔

472

                                        type: 'object',

610✔

473

},

610✔

474

};

610✔

475

                        properties_for_partial.patternProperties = properties;

610✔

476

610✔

477

1,243✔

478

                if ('neither' === properties_mode) {

1,243✔

479

307✔

480

                                properties_for_partial as Partial<

307✔

481

                                        object_schema<'neither'>['properties']

307✔

482

307✔

483

                        ).additionalProperties = {

307✔

484

                                type: 'boolean',

307✔

485

                                const: false,

307✔

486

};

307✔

487

307✔

488

                                properties_for_partial as Partial<

307✔

489

                                        object_schema<'neither'>['properties']

307✔

490

307✔

491

                        ).maxProperties = {

307✔

492

                                type: 'integer',

307✔

493

                                const: 0,

307✔

494

};

307✔

495

307✔

496

1,243✔

497

                const unpartial_properties: object_schema<

1,243✔

498

                        PropertiesMode

1,243✔

499

                >['properties'] = properties_for_partial as object_schema<

1,243✔

500

                        PropertiesMode

1,243✔

501

                >['properties'];

1,243✔

502

1,243✔

503

                const partial_required: object_schema<

1,243✔

504

                        PropertiesMode

1,243✔

505

                >['required'] = required_for_partial;

1,243✔

506

                const partial_properties: object_schema<

1,243✔

507

                        PropertiesMode

1,243✔

508

                >['properties'] = unpartial_properties;

1,243✔

509

1,243✔

510

                const result: object_schema<

1,243✔

511

                        PropertiesMode

1,243✔

512

                > = {

1,243✔

513

                        type: 'object',

1,243✔

514

                        required: partial_required,

1,243✔

515

                        additionalProperties: false,

1,243✔

516

                        properties: partial_properties,

1,243✔

517

                } as object_schema<

1,243✔

518

                        PropertiesMode

1,243✔

519

>;

1,243✔

520

1,243✔

521

                return Object.freeze(result);

1,243✔

522

1,243✔

523

19✔

524

        static #generate_schema_definition_required<

19✔

525

                PropertiesMode extends object_properties_mode,

1,243✔

526

>(

1,243✔

527

                properties_mode: PropertiesMode,

1,243✔

528

        ): object_schema<

1,243✔

529

                PropertiesMode

1,243✔

530

        >['required'] {

1,243✔

531

                const values_for_properties_mode: {

1,243✔

532

                        neither: readonly string[],

1,243✔

533

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

1,243✔

534

                        properties: readonly ['properties'],

1,243✔

535

                        pattern: readonly ['patternProperties'],

1,243✔

536

                }[PropertiesMode] = {

1,243✔

537

                        neither: [] as readonly string[],

1,243✔

538

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

1,243✔

539

                        properties: ['properties'] as const,

1,243✔

540

                        pattern: ['patternProperties'] as const,

1,243✔

541

                }[properties_mode];

1,243✔

542

1,243✔

543

                const required: object_schema<

1,243✔

544

                        PropertiesMode

1,243✔

545

                >['required'] = [

1,243✔

546

                        ...['type'],

1,243✔

547

                        ...values_for_properties_mode,

1,243✔

548

                ] as object_schema<

1,243✔

549

                        PropertiesMode

1,243✔

550

                >['required'];

1,243✔

551

1,243✔

552

                return required;

1,243✔

553

1,243✔

554

19✔

555

        static generate_type_definition<

19✔

556

                PropertiesMode extends object_properties_mode,

1,239✔

557

                Defs extends SchemaObject,

1,239✔

558

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

1,239✔

559

                Properties extends ObjectOfSchemas,

1,239✔

560

                PatternProperties extends ObjectOfSchemas,

1,239✔

561

>({

1,239✔

562

                properties_mode,

1,239✔

563

                $defs,

1,239✔

564

                required,

1,239✔

565

                properties,

1,239✔

566

                patternProperties,

1,239✔

567

        }: {

1,239✔

568

                properties_mode: PropertiesMode,

1,239✔

569

                $defs?: Defs,

1,239✔

570

                required?: Required,

1,239✔

571

                properties?: Properties,

1,239✔

572

                patternProperties?: PatternProperties,

1,239✔

573

        }): Readonly<object_type_base<

1,239✔

574

                PropertiesMode,

1,239✔

575

                Defs,

1,239✔

576

                Required,

1,239✔

577

                Properties,

1,239✔

578

                PatternProperties

1,239✔

579

        >> {

1,239✔

580

                const partial: Partial<object_type_base<

1,239✔

581

                        'both',

1,239✔

582

                        Defs,

1,239✔

583

                        Required,

1,239✔

584

                        Properties,

1,239✔

585

                        PatternProperties

1,239✔

586

                >> = {

1,239✔

587

                        type: 'object',

1,239✔

588

};

1,239✔

589

1,239✔

590

                if ($defs) {

1,239✔

591

                        partial.$defs = $defs;

8✔

592

8✔

593

1,239✔

594

                if (required) {

1,239✔

595

                        partial.required = required;

4✔

596

4✔

597

1,239✔

598

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

1,239✔

599

                        partial.properties = properties;

629✔

600

629✔

601

1,239✔

602

                if (

1,239✔

603

                        'both' === properties_mode

1,239✔

604

                        || 'pattern' === properties_mode

1,239✔

605

) {

1,239✔

606

                        partial.patternProperties = patternProperties;

608✔

607

608✔

608

1,239✔

609

                const frozen = Object.freeze(partial as object_type_base<

1,239✔

610

                        PropertiesMode,

1,239✔

611

                        Defs,

1,239✔

612

                        Required,

1,239✔

613

                        Properties,

1,239✔

614

                        PatternProperties

1,239✔

615

>);

1,239✔

616

1,239✔

617

                return frozen;

1,239✔

618

1,239✔

619

19✔

620

        static #is_schema_with_some_type_of_properties<

19✔

621

                Defs extends SchemaObject,

35✔

622

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

35✔

623

                Properties extends ObjectOfSchemas,

35✔

624

                PatternProperties extends ObjectOfSchemas,

35✔

625

>(

35✔

626

                schema: object_type<

35✔

627

                        object_properties_mode,

35✔

628

                        Defs,

35✔

629

                        Required,

35✔

630

                        Properties,

35✔

631

                        PatternProperties

35✔

632

>,

35✔

633

        ): schema is object_type<

35✔

634

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

35✔

635

                Defs,

35✔

636

                Required,

35✔

637

                Properties,

35✔

638

                PatternProperties

35✔

639

> {

35✔

640

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

35✔

641

35✔

642

19✔

643

        static #is_schema_with_properties<

19✔

644

                Defs extends SchemaObject,

817✔

645

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

817✔

646

                Properties extends ObjectOfSchemas,

817✔

647

                PatternProperties extends ObjectOfSchemas,

817✔

648

>(

817✔

649

                schema: SchemaObject|object_type<

817✔

650

                        object_properties_mode,

817✔

651

                        Defs,

817✔

652

                        Required,

817✔

653

                        Properties,

817✔

654

                        PatternProperties

817✔

655

>,

817✔

656

        ): schema is object_type_base<

817✔

657

                'both' | 'properties',

817✔

658

                Defs,

817✔

659

                Required,

817✔

660

                Properties,

817✔

661

                PatternProperties

817✔

662

> {

817✔

663

                return 'properties' in schema;

817✔

664

817✔

665

19✔

666

        static #is_schema_with_pattern_properties<

19✔

667

                Defs extends SchemaObject,

526✔

668

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

526✔

669

                Properties extends ObjectOfSchemas,

526✔

670

                PatternProperties extends ObjectOfSchemas,

526✔

671

>(

526✔

672

                schema: SchemaObject|object_type<

526✔

673

                        object_properties_mode,

526✔

674

                        Defs,

526✔

675

                        Required,

526✔

676

                        Properties,

526✔

677

                        PatternProperties

526✔

678

>,

526✔

679

        ): schema is object_type_base<

526✔

680

                'both'|'pattern',

526✔

681

                Defs,

526✔

682

                Required,

526✔

683

                Properties,

526✔

684

                PatternProperties

526✔

685

> {

526✔

686

                return 'patternProperties' in schema;

526✔

687

526✔

688

19✔

689

        static #is_schema_with_required<

19✔

690

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

34✔

691

>(

34✔

692

                schema: object_type<

34✔

693

                        object_properties_mode,

34✔

694

                        SchemaObject,

34✔

695

                        Required,

34✔

696

                        ObjectOfSchemas,

34✔

697

                        ObjectOfSchemas

34✔

698

>,

34✔

699

        ): schema is object_type<

34✔

700

                object_properties_mode,

34✔

701

                SchemaObject,

34✔

702

                Required,

34✔

703

                ObjectOfSchemas,

34✔

704

                ObjectOfSchemas

34✔

705

        > & {required: Required} {

34✔

706

                return 'required' in schema;

34✔

707

34✔

708

19✔

709

        static #convert<

19✔

710

T,

164✔

711

                PropertiesMode extends object_properties_mode,

164✔

712

                Defs extends SchemaObject,

164✔

713

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

164✔

714

                Properties extends ObjectOfSchemas,

164✔

715

                PatternProperties extends ObjectOfSchemas,

164✔

716

>(

164✔

717

                properties_mode: PropertiesMode,

164✔

718

                value: unknown,

164✔

719

                property: string,

164✔

720

                schema: object_type<

164✔

721

                        PropertiesMode,

164✔

722

                        Defs,

164✔

723

                        Required,

164✔

724

                        Properties,

164✔

725

                        PatternProperties

164✔

726

>,

164✔

727

                schema_parser: SchemaParser,

164✔

728

) {

164✔

729

                const sub_schema = this.#sub_schema_for_property(

164✔

730

                        schema_parser,

164✔

731

                        properties_mode,

164✔

732

                        property,

164✔

733

                        schema,

164✔

734

{},

164✔

735

);

164✔

736

164✔

737

                const maybe_modified = ObjectUnspecified.maybe_add_$defs(

164✔

738

                        schema,

164✔

739

                        sub_schema,

164✔

740

);

164✔

741

164✔

742

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

164✔

743

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

164✔

744

164✔

745

                if (!(validator(value))) {

164✔

746

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

30✔

747

30✔

748

131✔

749

                let instance: Type<unknown>;

131✔

750

131✔

751

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

164✔

752

                        instance = schema_parser.parse_by_type(value);

4✔

753

                } else {

164✔

754

                        instance = schema_parser.parse(

127✔

755

                                maybe_modified,

127✔

756

);

127✔

757

127✔

758

131✔

759

                return instance.generate_typescript_data(

131✔

760

                        value,

131✔

761

                        schema_parser,

131✔

762

                        maybe_modified,

131✔

763

);

131✔

764

164✔

765

19✔

766

        static #createObjectLiteralExpression<

19✔

767

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

99✔

768

                PropertiesMode extends object_properties_mode,

99✔

769

                Defs extends SchemaObject,

99✔

770

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

99✔

771

                Properties extends ObjectOfSchemas,

99✔

772

                PatternProperties extends ObjectOfSchemas,

99✔

773

>(

99✔

774

                properties_mode: PropertiesMode,

99✔

775

                data: T,

99✔

776

                schema: object_type<

99✔

777

                        PropertiesMode,

99✔

778

                        Defs,

99✔

779

                        Required,

99✔

780

                        Properties,

99✔

781

                        PatternProperties

99✔

782

>,

99✔

783

                schema_parser: SchemaParser,

99✔

784

        ): ObjectLiteralExpression {

99✔

785

                return factory.createObjectLiteralExpression(

99✔

786

                        Object.entries(

99✔

787

                                data,

99✔

788

                        ).map(([

99✔

789

                                property,

164✔

790

                                value,

164✔

791

                        ]) => {

164✔

792

                                const type = this.#convert(

164✔

793

                                        properties_mode,

164✔

794

                                        value,

164✔

795

                                        property,

164✔

796

                                        schema,

164✔

797

                                        schema_parser,

164✔

798

);

164✔

799

164✔

800

                                return factory.createPropertyAssignment(

164✔

801

                                        this.#computedProperty_or_string(property),

164✔

802

                                        type,

164✔

803

);

164✔

804

}),

99✔

805

                        true,

99✔

806

);

99✔

807

99✔

808

19✔

809

        static async #createTypeNode<

19✔

810

                PropertiesMode extends object_properties_mode,

35✔

811

                Defs extends SchemaObject,

35✔

812

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

35✔

813

                Properties extends ObjectOfSchemas,

35✔

814

                PatternProperties extends ObjectOfSchemas,

35✔

815

>(

35✔

816

                properties_mode: PropertiesMode,

35✔

817

                schema: object_type<

35✔

818

                        PropertiesMode,

35✔

819

                        Defs,

35✔

820

                        Required,

35✔

821

                        Properties,

35✔

822

                        PatternProperties

35✔

823

>,

35✔

824

                schema_parser: SchemaParser,

35✔

825

        ): Promise<object_TypeLiteralNode<PropertiesMode>> {

35✔

826

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

35✔

827

                        return factory.createTypeLiteralNode([

4✔

828

                                factory.createIndexSignature(

4✔

829

                                        undefined,

4✔

830

4✔

831

                                                factory.createParameterDeclaration(

4✔

832

                                                        undefined,

4✔

833

                                                        undefined,

4✔

834

                                                        factory.createIdentifier('key'),

4✔

835

                                                        undefined,

4✔

836

                                                        factory.createToken(SyntaxKind.StringKeyword),

4✔

837

),

4✔

838

],

4✔

839

                                        factory.createToken(SyntaxKind.UnknownKeyword),

4✔

840

),

4✔

841

                        ]) as object_TypeLiteralNode<PropertiesMode>;

4✔

842

4✔

843

31✔

844

                let properties: PropertySignature[] = [];

31✔

845

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

31✔

846

31✔

847

                if (this.#is_schema_with_properties(schema)) {

35✔

848

                        properties = await Promise.all(Object.keys(

27✔

849

                                schema.properties,

27✔

850

                        ).map(async (

27✔

851

                                property,

34✔

852

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

34✔

853

                                undefined,

34✔

854

                                this.#computedProperty_or_string(property),

34✔

855

34✔

856

34✔

857

                                                this.#is_schema_with_required(schema)

34✔

858

                                                && schema.required.includes(property)

34✔

859

34✔

860

                                                ? undefined

34✔

861

                                                : factory.createToken(SyntaxKind.QuestionToken)

34✔

862

),

34✔

863

                                await this.#generate_type(

34✔

864

                                        properties_mode,

34✔

865

                                        property,

34✔

866

                                        schema,

34✔

867

                                        schema_parser,

34✔

868

),

34✔

869

                        )));

27✔

870

27✔

871

31✔

872

                if (this.#is_schema_with_pattern_properties(schema)) {

35✔

873

                        patterned = await Promise.all(

6✔

874

6✔

875

                                        Object.values(

6✔

876

                                                schema.patternProperties,

6✔

877

6✔

878

                                ).map(

6✔

879

                                        (sub_schema) => {

6✔

880

                                                return schema_parser.parse(

10✔

881

                                                        ObjectUnspecified.maybe_add_$defs(

10✔

882

                                                                schema,

10✔

883

                                                                sub_schema,

10✔

884

),

10✔

885

                                                ).generate_typescript_type({

10✔

886

                                                        data: sub_schema,

10✔

887

                                                        schema: sub_schema,

10✔

888

                                                        schema_parser,

10✔

889

});

10✔

890

},

6✔

891

),

6✔

892

);

6✔

893

6✔

894

31✔

895

                let result: object_TypeLiteralNode<

31✔

896

                        Exclude<

31✔

897

                                object_properties_mode,

31✔

898

                                'neither'

31✔

899

31✔

900

>;

31✔

901

31✔

902

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

35✔

903

                        result = factory.createIntersectionTypeNode([

2✔

904

                                factory.createTypeLiteralNode(properties),

2✔

905

                                this.#patterned_literal_node(

2✔

906

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

2✔

907

),

2✔

908

]);

2✔

909

                } else if (properties.length > 0) {

35✔

910

                        result = factory.createTypeLiteralNode(properties);

25✔

911

                } else {

29✔

912

                        result = this.#patterned_literal_node(

4✔

913

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

4✔

914

);

4✔

915

4✔

916

31✔

917

                return result as object_TypeLiteralNode<PropertiesMode>;

31✔

918

35✔

919

19✔

920

        static async #generate_type<

19✔

921

                PropertiesMode extends object_properties_mode,

34✔

922

                Defs extends SchemaObject,

34✔

923

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

34✔

924

                Properties extends ObjectOfSchemas,

34✔

925

                PatternProperties extends ObjectOfSchemas,

34✔

926

>(

34✔

927

                properties_mode: PropertiesMode,

34✔

928

                property: string,

34✔

929

                schema: object_type<

34✔

930

                        PropertiesMode,

34✔

931

                        Defs,

34✔

932

                        Required,

34✔

933

                        Properties,

34✔

934

                        PatternProperties

34✔

935

>,

34✔

936

                schema_parser: SchemaParser,

34✔

937

) {

34✔

938

                const sub_schema = this.#sub_schema_for_property(

34✔

939

                        schema_parser,

34✔

940

                        properties_mode,

34✔

941

                        property,

34✔

942

                        schema,

34✔

943

{},

34✔

944

);

34✔

945

34✔

946

                let matched: (

34✔

947

                        | undefined

34✔

948

                        | Type<unknown>

34✔

949

                ) = schema_parser.maybe_parse_by_type<

34✔

950

                        $ref

34✔

951

>(

34✔

952

                        sub_schema,

34✔

953

34✔

954

                                maybe: unknown,

167✔

955

                        ): maybe is $ref => {

167✔

956

                                return $ref.is_a(maybe);

167✔

957

},

34✔

958

);

34✔

959

34✔

960

                if (undefined === matched) {

34✔

961

                        matched = schema_parser.parse(sub_schema);

19✔

962

                } else {

33✔

963

                        return matched.generate_typescript_type({

15✔

964

                                data: sub_schema,

15✔

965

                                schema: sub_schema,

15✔

966

                                schema_parser,

15✔

967

});

15✔

968

15✔

969

19✔

970

                return matched.generate_typescript_type({

19✔

971

                        schema: sub_schema,

19✔

972

                        schema_parser,

19✔

973

});

19✔

974

34✔

975

19✔

976

        static #patterned_literal_node(

19✔

977

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

6✔

978

        ): TypeLiteralNode<IndexSignatureDeclaration> {

6✔

979

                return factory.createTypeLiteralNode([

6✔

980

                        factory.createIndexSignature(

6✔

981

                                undefined,

6✔

982

6✔

983

                                        factory.createParameterDeclaration(

6✔

984

                                                undefined,

6✔

985

                                                undefined,

6✔

986

                                                'key',

6✔

987

                                                undefined,

6✔

988

                                                factory.createKeywordTypeNode(

6✔

989

                                                        SyntaxKind.StringKeyword,

6✔

990

),

6✔

991

                                                undefined,

6✔

992

),

6✔

993

],

6✔

994

                                1 === value.length

6✔

995

                                        ? value[0]

6✔

996

                                        : factory.createUnionTypeNode(

6✔

997

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

4✔

998

),

6✔

999

),

6✔

1000

]);

6✔

1001

6✔

1002

19✔

1003

        static #sub_schema_for_property<

19✔

1004

                PropertiesMode extends object_properties_mode,

220✔

1005

                Defs extends SchemaObject,

220✔

1006

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

220✔

1007

                Properties extends ObjectOfSchemas,

220✔

1008

                PatternProperties extends ObjectOfSchemas,

220✔

1009

>(

220✔

1010

                schema_parser: SchemaParser,

220✔

1011

                properties_mode: PropertiesMode,

220✔

1012

                property: string,

220✔

1013

                schema: SchemaObject|object_type<

220✔

1014

                        PropertiesMode,

220✔

1015

                        Defs,

220✔

1016

                        Required,

220✔

1017

                        Properties,

220✔

1018

                        PatternProperties

220✔

1019

>,

220✔

1020

                fallback_if_neither: Record<string, never>|unknown_type,

220✔

1021

        ): SchemaObject {

220✔

1022

                if (

220✔

1023

                        !this.#is_schema_with_pattern_properties(schema)

220✔

1024

                        && !this.#is_schema_with_properties(schema)

220✔

1025

                        && '$ref' in schema

220✔

1026

) {

220✔

1027

                        const maybe = this.#sub_schema_for_property_resolve_$ref(

26✔

1028

                                schema_parser,

26✔

1029

                                schema as SchemaObject & {

26✔

1030

                                        $ref: string,

26✔

1031

},

26✔

1032

);

26✔

1033

26✔

1034

                        if (maybe) {

26✔

1035

                                schema = maybe;

26✔

1036

26✔

1037

26✔

1038

220✔

1039

                if (

220✔

1040

                        !this.#is_schema_with_pattern_properties(schema)

220✔

1041

                        && !this.#is_schema_with_properties(schema)

220✔

1042

                        && 'allOf' in schema

220✔

1069

220✔

1070

                if (

220✔

1071

                        this.#is_schema_with_properties(schema)

220✔

1072

                        && !(property in schema.properties)

220✔

1073

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

220✔

1074

) {

220✔

1075

                        let checking_schema: (

30✔

1076

                                | SchemaObject

30✔

1077

                                | undefined

30✔

1078

                        ) = schema;

30✔

1079

30✔

1080

                        while (

30✔

1081

                                undefined !== checking_schema

30✔

1082

                                && !(property in checking_schema.properties)

30✔

1083

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

30✔

1084

) {

30✔

1085

                                checking_schema = this.#sub_schema_for_property_resolve_$ref(

54✔

1086

                                        schema_parser,

54✔

1087

                                        checking_schema as SchemaObject & {

54✔

1088

                                                $ref: string,

54✔

1089

},

54✔

1090

);

54✔

1091

54✔

1092

                                if (

54✔

1093

                                        checking_schema

54✔

1094

                                        && 'allOf' in checking_schema

54✔

1095

                                        && undefined !== checking_schema.allOf

54✔

1096

) {

54✔

1097

                                        const matching = this.#sub_schema_for_property_from_allOf(

10✔

1098

                                                schema_parser,

10✔

1099

                                                properties_mode,

10✔

1100

                                                property,

10✔

1101

                                                checking_schema as SchemaObject & {

10✔

1102

                                                        allOf: [

10✔

1103

                                                                SchemaObject,

10✔

1104

                                                                SchemaObject,

10✔

1105

                                                                ...SchemaObject[],

10✔

1106

],

10✔

1107

},

10✔

1108

                                                fallback_if_neither,

10✔

1109

);

10✔

1110

10✔

1111

                                        if (matching) {

10✔

1112

                                                return matching;

10✔

1113

10✔

1114

10✔

1115

54✔

1116

20✔

1117

                        if (checking_schema !== undefined) {

30✔

1118

                                const maybe_type = schema_parser.parse_by_type<

18✔

1119

                                        ObjectUnspecified<

18✔

1120

                                                {[key: string]: unknown},

18✔

1121

                                                'properties'

18✔

1122

18✔

1123

>(

18✔

1124

                                        checking_schema,

18✔

1125

                                        (maybe): maybe is ObjectUnspecified<

18✔

1126

                                                {[key: string]: unknown},

18✔

1127

                                                'properties'

18✔

1128

                                        > => ObjectUnspecified.is_a<ObjectUnspecified<

18✔

1129

                                                {[key: string]: unknown},

18✔

1130

                                                'properties'

18✔

1131

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

18✔

1132

);

18✔

1133

18✔

1134

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

18✔

1135

                                        schema = checking_schema as typeof schema;

18✔

1136

18✔

1137

18✔

1138

30✔

1139

210✔

1140

                if (

210✔

1141

                        this.#is_schema_with_properties(schema)

210✔

1142

                        && property in schema.properties

220✔

1143

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

220✔

1144

) {

220✔

1145

                        return this.maybe_add_$defs(

155✔

1146

                                schema,

155✔

1147

                                schema.properties[property],

155✔

1148

);

155✔

1149

155✔

1150

55✔

1151

                if (

55✔

1152

                        this.#is_schema_with_pattern_properties(schema)

55✔

1153

) {

206✔

1154

                        const matching = Object.keys(

36✔

1155

                                schema.patternProperties,

36✔

1156

                        ).find((maybe) => {

36✔

1157

                                return (

52✔

1158

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

52✔

1159

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

52✔

1160

);

52✔

1161

});

36✔

1162

36✔

1163

                        if (matching) {

36✔

1164

                                return schema.patternProperties[matching];

36✔

1165

36✔

1166

36✔

1167

19✔

1168

                if ('neither' === properties_mode) {

206✔

1169

                        return fallback_if_neither;

4✔

1170

4✔

1171

15✔

1172

                throw new TypeError(

15✔

1173

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

15✔

1174

);

15✔

1175

220✔

1176

19✔

1177

        static #sub_schema_for_property_resolve_$ref(

19✔

1178

                schema_parser: SchemaParser,

80✔

1179

                schema: SchemaObject & {$ref: string},

80✔

1180

        ): SchemaObject|undefined {

80✔

1181

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

80✔

1182

                        const [

13✔

1183

                                other_schema_id,

13✔

1184

                                other_schema_ref_id,

13✔

1185

                        ] = schema.$ref.split(

13✔

1186

                                '#/$defs/',

13✔

1187

                        ) as [string, string];

13✔

1188

13✔

1189

                        const other_schema = schema_parser.get_schema(

13✔

1190

                                other_schema_id,

13✔

1191

);

13✔

1192

13✔

1193

                        if (

13✔

1194

                                other_schema

13✔

1195

                                && '$defs' in other_schema

13✔

1196

                                && undefined !== other_schema.$defs

13✔

1197

                                && other_schema_ref_id in other_schema.$defs

13✔

1198

) {

13✔

1199

                                return this.maybe_add_$defs(

12✔

1200

                                        other_schema,

12✔

1201

                                        other_schema.$defs[other_schema_ref_id],

12✔

1202

);

12✔

1203

12✔

1204

                } else {

80✔

1205

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

67✔

1206

67✔

1207

                        if (

67✔

1208

                                '$defs' in schema

67✔

1209

                                && undefined !== schema.$defs

67✔

1210

                                && $ref_id in schema.$defs

67✔

1211

) {

67✔

1212

                                return this.maybe_add_$defs(

66✔

1213

                                        schema,

66✔

1214

                                        schema.$defs[$ref_id],

66✔

1215

);

66✔

1216

66✔

1217

67✔

1218

2✔

1219

                return undefined;

2✔

1220

80✔

1221

19✔

1222

        static #sub_schema_for_property_from_allOf<

19✔

1223

                PropertiesMode extends object_properties_mode,

10✔

1224

>(

10✔

1225

                schema_parser: SchemaParser,

10✔

1226

                properties_mode: PropertiesMode,

10✔

1227

                property: string,

10✔

1228

                schema: SchemaObject & {

10✔

1229

                        allOf: [

10✔

1230

                                SchemaObject,

10✔

1231

                                SchemaObject,

10✔

1232

                                ...SchemaObject[],

10✔

1233

],

10✔

1234

},

10✔

1235

                fallback_if_neither: Record<string, never>|unknown_type,

10✔

1236

        ): SchemaObject|undefined {

10✔

1237

                let matching: SchemaObject|undefined;

10✔

1238

10✔

1239

                for (const candidate of schema.allOf) {

10✔

1240

                        try {

22✔

1241

                                const maybe = this.#sub_schema_for_property(

22✔

1242

                                        schema_parser,

22✔

1243

                                        properties_mode,

22✔

1244

                                        property,

22✔

1245

                                        this.maybe_add_$defs(

22✔

1246

                                                schema,

22✔

1247

                                                candidate,

22✔

1248

),

22✔

1249

                                        fallback_if_neither,

22✔

1250

);

22✔

1251

22✔

1252

                                if (undefined !== maybe) {

22✔

1253

                                        matching = maybe;

10✔

1254

10✔

1255

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

22✔

1256

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

22✔

1257

22✔

1258

10✔

1259

                return matching;

10✔

1260

10✔

1261

19✔

1262

19✔

1263

export type {

19✔

1264

        object_properties_mode,

19✔

1265

        object_type,

19✔

1266

        object_type_base,

19✔

1267

        object_schema,

19✔

1268

        object_TypeLiteralNode,

19✔

1269

        object_TypeLiteralNode_possibly_extended,

19✔

1270

};

19✔

1271

19✔

1272

export {

19✔

1273

        ObjectUnspecified,

19✔

1274

};

19✔

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19434745916

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

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19434745916

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