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

1

import type {

19✔

2

        Expression,

19✔

3

        TypeNode,

19✔

4

} from 'typescript';

19✔

5

import {

19✔

6

        SyntaxKind,

19✔

7

} from 'typescript';

19✔

8

19✔

9

import type {

19✔

10

        SchemaDefinitionDefinitionWith$defs,

19✔

11

        SchemalessTypeOptions,

19✔

12

} from './Type.ts';

19✔

13

import {

19✔

14

        $defs_schema,

19✔

15

        Type,

19✔

16

} from './Type.ts';

19✔

17

19✔

18

import {

19✔

19

        PositiveIntegerGuard,

19✔

20

        PositiveIntegerOrZeroGuard,

19✔

21

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

19✔

22

} from '../guarded.ts';

19✔

23

19✔

24

import type {

19✔

25

        ObjectOfSchemas,

19✔

26

        PositiveInteger,

19✔

27

        SchemaObject,

19✔

28

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

19✔

29

} from '../types.ts';

19✔

30

19✔

31

import type {

19✔

32

        ArrayLiteralExpression,

19✔

33

        ArrayTypeNode,

19✔

34

        TupleTypeNode,

19✔

35

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

19✔

36

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

19✔

37

19✔

38

import type {

19✔

39

        SchemaParser,

19✔

40

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

19✔

41

} from '../SchemaParser.ts';

19✔

42

19✔

43

import {

19✔

44

        factory,

19✔

45

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

19✔

46

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

19✔

47

19✔

48

import {

19✔

49

        SchemaValidationError,

19✔

50

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

19✔

51

} from '../SchemaValidationError.ts';

19✔

52

19✔

53

type array_mode = 'items'|'prefixItems';

19✔

54

19✔

55

type specified_mode = 'specified'|'unspecified';

19✔

56

19✔

57

type unique_items_mode = 'yes'|'no';

19✔

58

19✔

59

type MinItemsType_mode = 'with'|'optional';

19✔

60

19✔

61

type MinItemsType = ReturnType<typeof PositiveIntegerOrZeroGuard<number>>;

19✔

62

type MaxItemsType = ReturnType<typeof PositiveIntegerOrZeroGuard<number>>;

19✔

63

19✔

64

type array_options<

19✔

65

        ArrayMode extends array_mode = array_mode,

19✔

66

        SpecifiedMode extends specified_mode = specified_mode,

19✔

67

        UniqueItems_mode extends unique_items_mode = unique_items_mode,

19✔

68

        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,

19✔

69

        Items extends SchemaObject = SchemaObject,

19✔

70

        PrefixItems extends [

19✔

71

                SchemaObject,

19✔

72

                ...SchemaObject[],

19✔

73

        ] = [

19✔

74

                SchemaObject,

19✔

75

                ...SchemaObject[],

19✔

76

],

19✔

77

        T1 extends unknown[] = unknown[],

19✔

78

        T4 extends Expression = Expression,

19✔

79

        T5 extends T4[] = T4[],

19✔

80

> = (

19✔

81

& {

19✔

82

                $defs?: ObjectOfSchemas,

19✔

83

                array_mode: ArrayMode,

19✔

84

                specified_mode: SpecifiedMode,

19✔

85

                unique_items_mode: UniqueItems_mode,

19✔

86

                min_items_mode: MinItems_mode,

19✔

87

                expression_at_index_verifier?: ExpressionAtIndexVerifier<T1, T4, T5>,

19✔

88

19✔

89

& (

19✔

90

                ArrayMode extends 'items'

19✔

91

? (

19✔

92

                                SpecifiedMode extends 'specified'

19✔

93

? (

19✔

94

                                                MinItems_mode extends 'with'

19✔

95

? {

19✔

96

                                                                minItems: MinItemsType,

19✔

97

                                                                maxItems?: MaxItemsType,

19✔

98

19✔

99

: {

19✔

100

                                                                minItems?: MinItemsType,

19✔

101

                                                                maxItems?: MaxItemsType,

19✔

102

19✔

103

19✔

104

: {

19✔

105

                                                minItems?: undefined,

19✔

106

                                                maxItems?: undefined,

19✔

107

19✔

108

19✔

109

: (

19✔

110

                                SpecifiedMode extends 'specified'

19✔

111

? {

19✔

112

                                                minItems?: undefined,

19✔

113

                                                maxItems?: undefined,

19✔

114

19✔

115

: {

19✔

116

                                                minItems: MinItemsType,

19✔

117

                                                maxItems?: MaxItemsType,

19✔

118

19✔

119

19✔

120

19✔

121

& (

19✔

122

                ArrayMode extends 'items'

19✔

123

? (

19✔

124

                                SpecifiedMode extends 'specified'

19✔

125

? {

19✔

126

                                                items: Items,

19✔

127

19✔

128

: {

19✔

129

                                                items?: undefined,

19✔

130

19✔

131

19✔

132

: (

19✔

133

                                SpecifiedMode extends 'specified'

19✔

134

? {

19✔

135

                                                items?: false,

19✔

136

                                                prefixItems: PrefixItems,

19✔

137

19✔

138

: {

19✔

139

                                                items?: undefined,

19✔

140

19✔

141

19✔

142

19✔

143

);

19✔

144

19✔

145

type ExpressionAtIndexVerifier<

19✔

146

        Data extends unknown[],

19✔

147

        T1 extends Expression,

19✔

148

        Result extends T1[],

19✔

149

        Index extends ReturnType<

19✔

150

                typeof PositiveIntegerOrZeroGuard<number>

19✔

151

        > = ReturnType<

19✔

152

                typeof PositiveIntegerOrZeroGuard<number>

19✔

153

>,

19✔

154

> = (

19✔

155

        data: Data,

19✔

156

        expression: Expression,

19✔

157

        index: Index,

19✔

158

) => expression is Result[Index];

19✔

159

19✔

160

function expression_at_index_verifier_default<

116✔

161

        T extends unknown[],

116✔

162

        ArrayMode extends array_mode = array_mode,

116✔

163

        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,

116✔

164

        T4 extends Expression = Expression,

116✔

165

        T5 extends {

116✔

166

                items: {

116✔

167

                        with: [T4, ...T4[]],

116✔

168

                        optional: T4[],

116✔

169

                }[MinItems_mode],

116✔

170

                prefixItems: [T4, ...T4[]],

116✔

171

        }[ArrayMode] = {

116✔

172

                items: {

116✔

173

                        with: [T4, ...T4[]],

116✔

174

                        optional: T4[],

116✔

175

                }[MinItems_mode],

116✔

176

                prefixItems: [T4, ...T4[]],

116✔

177

        }[ArrayMode],

116✔

178

        Index extends ReturnType<

116✔

179

                typeof PositiveIntegerOrZeroGuard<number>

116✔

180

        > = ReturnType<

116✔

181

                typeof PositiveIntegerOrZeroGuard<number>

116✔

182

>,

116✔

183

>(

116✔

184

        data: T,

116✔

185

        expression: Expression,

116✔

186

): expression is T5[Index] {

116✔

187

        return true;

116✔

188

116✔

189

19✔

190

type array_type<

19✔

191

        ArrayMode extends array_mode = array_mode,

19✔

192

        SpecifiedMode extends specified_mode = specified_mode,

19✔

193

        UniqueItems_mode extends unique_items_mode = unique_items_mode,

19✔

194

        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,

19✔

195

        Items extends SchemaObject = SchemaObject,

19✔

196

        PrefixItems extends [

19✔

197

                SchemaObject,

19✔

198

                ...SchemaObject[],

19✔

199

        ] = [

19✔

200

                SchemaObject,

19✔

201

                ...SchemaObject[],

19✔

202

],

19✔

203

> = (

19✔

204

& {

19✔

205

                $schema?: 'https://json-schema.org/draft/2020-12/schema',

19✔

206

                $id?: Exclude<string, ''>,

19✔

207

                $defs?: ObjectOfSchemas,

19✔

208

                type: 'array',

19✔

209

                uniqueItems: {

19✔

210

                        yes: true,

19✔

211

                        no: false,

19✔

212

                }[UniqueItems_mode],

19✔

213

                items: (

19✔

214

& (

19✔

215

                                SpecifiedMode extends 'unspecified'

19✔

216

                                        ? (SchemaObject & {})

19✔

217

: (

19✔

218

                                                ArrayMode extends 'items'

19✔

219

                                                        ? Items

19✔

220

                                                        : false

19✔

221

19✔

222

19✔

223

),

19✔

224

19✔

225

& {

19✔

226

                items: {

19✔

227

                        specified: (

19✔

228

& {

19✔

229

                                        maxItems?: MaxItemsType,

19✔

230

19✔

231

& {

19✔

232

                                        with: {

19✔

233

                                                minItems: MinItemsType,

19✔

234

},

19✔

235

                                        optional: {

19✔

236

                                                minItems?: MinItemsType,

19✔

237

},

19✔

238

                                }[MinItems_mode]

19✔

239

),

19✔

240

                        unspecified: (

19✔

241

& {

19✔

242

                                        maxItems?: MaxItemsType,

19✔

243

19✔

244

& {

19✔

245

                                        with: {

19✔

246

                                                minItems: MinItemsType,

19✔

247

},

19✔

248

                                        optional: {

19✔

249

                                                minItems?: MinItemsType,

19✔

250

},

19✔

251

                                }[MinItems_mode]

19✔

252

),

19✔

253

},

19✔

254

                prefixItems: {

19✔

255

                        specified: {

19✔

256

                                prefixItems: PrefixItems,

19✔

257

                                minItems: PositiveInteger<number>,

19✔

258

},

19✔

259

                        unspecified: {

19✔

260

                                prefixItems?: undefined,

19✔

261

                                minItems: PositiveInteger<number>,

19✔

262

                                maxItems?: MaxItemsType,

19✔

263

},

19✔

264

},

19✔

265

        }[ArrayMode][SpecifiedMode]

19✔

266

);

19✔

267

19✔

268

type array_schema_properties<

19✔

269

        ArrayMode extends array_mode,

19✔

270

        SpecifiedMode extends specified_mode = specified_mode,

19✔

271

        UniqueItems_mode extends unique_items_mode = unique_items_mode,

19✔

272

        Items extends SchemaObject = SchemaObject,

19✔

273

        PrefixItems extends [

19✔

274

                SchemaObject,

19✔

275

                ...SchemaObject[],

19✔

276

        ] = [

19✔

277

                SchemaObject,

19✔

278

                ...SchemaObject[],

19✔

279

],

19✔

280

> = (

19✔

281

& {

19✔

282

                $schema: {

19✔

283

                        type: 'string',

19✔

284

                        enum: [

19✔

285

                                'https://json-schema.org/draft/2020-12/schema',

19✔

286

],

19✔

287

},

19✔

288

                $id: {

19✔

289

                        type: 'string',

19✔

290

                        minLength: 1,

19✔

291

},

19✔

292

                type: {

19✔

293

                        type: 'string',

19✔

294

                        const: 'array',

19✔

295

},

19✔

296

                uniqueItems: {

19✔

297

                        type: 'boolean',

19✔

298

                        const: {

19✔

299

                                yes: true,

19✔

300

                                no: false,

19✔

301

                        }[UniqueItems_mode],

19✔

302

},

19✔

303

19✔

304

& {

19✔

305

                items: {

19✔

306

                        items: {

19✔

307

                                specified: Items,

19✔

308

                                unspecified: {

19✔

309

                                        type: 'object',

19✔

310

                                        minProperties: 0,

19✔

311

},

19✔

312

                        }[SpecifiedMode],

19✔

313

                        minItems: {

19✔

314

                                type: 'integer',

19✔

315

                                minimum: 0,

19✔

316

},

19✔

317

                        maxItems: {

19✔

318

                                type: 'integer',

19✔

319

                                minimum: 0,

19✔

320

},

19✔

321

},

19✔

322

                prefixItems: {

19✔

323

                        specified: {

19✔

324

                                items: {

19✔

325

                                        type: 'boolean',

19✔

326

                                        const: false,

19✔

327

},

19✔

328

                                prefixItems: {

19✔

329

                                        type: 'array',

19✔

330

                                        const: PrefixItems,

19✔

331

},

19✔

332

},

19✔

333

                        unspecified: {

19✔

334

                                items: {

19✔

335

                                        type: 'boolean',

19✔

336

                                        const: false,

19✔

337

},

19✔

338

                                prefixItems: {

19✔

339

                                        type: 'array',

19✔

340

                                        minItems: 1,

19✔

341

                                        items: {

19✔

342

                                                type: 'object',

19✔

343

                                                minProperties: 1,

19✔

344

},

19✔

345

},

19✔

346

},

19✔

347

                }[SpecifiedMode],

19✔

348

        }[ArrayMode]

19✔

349

);

19✔

350

19✔

351

type array_schema<

19✔

352

        ArrayMode extends array_mode = array_mode,

19✔

353

        SpecifiedMode extends specified_mode = specified_mode,

19✔

354

        UniqueItems_mode extends unique_items_mode = unique_items_mode,

19✔

355

        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,

19✔

356

        Items extends SchemaObject = SchemaObject,

19✔

357

        PrefixItems extends [

19✔

358

                SchemaObject,

19✔

359

                ...SchemaObject[],

19✔

360

        ] = [

19✔

361

                SchemaObject,

19✔

362

                ...SchemaObject[],

19✔

363

],

19✔

364

> = SchemaDefinitionDefinitionWith$defs<

19✔

365

19✔

366

                items: {

19✔

367

                        with: {

19✔

368

                                yes: [

19✔

369

                                        'type',

19✔

370

                                        'items',

19✔

371

                                        'minItems',

19✔

372

                                        'uniqueItems',

19✔

373

],

19✔

374

                                no: [

19✔

375

                                        'type',

19✔

376

                                        'items',

19✔

377

                                        'minItems',

19✔

378

],

19✔

379

                        }[UniqueItems_mode],

19✔

380

                        optional: {

19✔

381

                                yes: [

19✔

382

                                        'type',

19✔

383

                                        'items',

19✔

384

                                        'uniqueItems',

19✔

385

],

19✔

386

                                no: [

19✔

387

                                        'type',

19✔

388

                                        'items',

19✔

389

],

19✔

390

                        }[UniqueItems_mode],

19✔

391

                }[MinItems_mode],

19✔

392

                prefixItems: {

19✔

393

                        specified: {

19✔

394

                                yes: [

19✔

395

                                        'type',

19✔

396

                                        'items',

19✔

397

                                        'prefixItems',

19✔

398

                                        'uniqueItems',

19✔

399

],

19✔

400

                                no: [

19✔

401

                                        'type',

19✔

402

                                        'items',

19✔

403

                                        'prefixItems',

19✔

404

],

19✔

405

                        }[UniqueItems_mode],

19✔

406

                        unspecified: {

19✔

407

                                yes: [

19✔

408

                                        'type',

19✔

409

                                        'items',

19✔

410

                                        'prefixItems',

19✔

411

                                        'uniqueItems',

19✔

412

],

19✔

413

                                no: [

19✔

414

                                        'type',

19✔

415

                                        'items',

19✔

416

                                        'prefixItems',

19✔

417

],

19✔

418

                        }[UniqueItems_mode],

19✔

419

                }[SpecifiedMode],

19✔

420

        }[ArrayMode],

19✔

421

        ObjectOfSchemas & array_schema_properties<

19✔

422

                ArrayMode,

19✔

423

                SpecifiedMode,

19✔

424

                UniqueItems_mode,

19✔

425

                Items,

19✔

426

                PrefixItems

19✔

427

19✔

428

>;

19✔

429

19✔

430

class ArrayType<

19✔

431

        ArrayMode extends array_mode = array_mode,

19✔

432

        SpecifiedMode extends specified_mode = specified_mode,

19✔

433

        UniqueItems_mode extends unique_items_mode = unique_items_mode,

19✔

434

        MinItems_mode extends MinItemsType_mode = MinItemsType_mode,

19✔

435

        Items extends SchemaObject = SchemaObject,

19✔

436

        PrefixItems extends [

19✔

437

                SchemaObject,

19✔

438

                ...SchemaObject[],

19✔

439

        ] = [

19✔

440

                SchemaObject,

19✔

441

                ...SchemaObject[],

19✔

442

],

19✔

443

        T1 extends {

19✔

444

                items: unknown[],

19✔

445

                prefixItems: [unknown, ...unknown[]],

19✔

446

        }[ArrayMode] = {

19✔

447

                items: unknown[],

19✔

448

                prefixItems: [unknown, ...unknown[]],

19✔

449

        }[ArrayMode],

19✔

450

        T2 extends TypeNode = TypeNode,

19✔

451

        T3 extends [T2, ...T2[]] = [T2, ...T2[]],

19✔

452

        T4 extends Expression = Expression,

19✔

453

        T5 extends {

19✔

454

                items: {

19✔

455

                        with: [T4, ...T4[]],

19✔

456

                        optional: T4[],

19✔

457

                }[MinItems_mode],

19✔

458

                prefixItems: [T4, ...T4[]],

19✔

459

        }[ArrayMode] = {

19✔

460

                items: {

19✔

461

                        with: [T4, ...T4[]],

19✔

462

                        optional: T4[],

19✔

463

                }[MinItems_mode],

19✔

464

                prefixItems: [T4, ...T4[]],

19✔

465

        }[ArrayMode],

19✔

466

> extends

19✔

467

        Type<

19✔

468

T1,

19✔

469

                array_type<

19✔

470

                        ArrayMode,

19✔

471

                        SpecifiedMode,

19✔

472

                        UniqueItems_mode,

19✔

473

                        MinItems_mode,

19✔

474

                        Items,

19✔

475

                        PrefixItems

19✔

476

>,

19✔

477

                array_options<

19✔

478

                        ArrayMode,

19✔

479

                        SpecifiedMode,

19✔

480

                        UniqueItems_mode,

19✔

481

                        MinItems_mode,

19✔

482

                        Items,

19✔

483

                        PrefixItems

19✔

484

>,

19✔

485

                array_schema<

19✔

486

                        ArrayMode,

19✔

487

                        SpecifiedMode,

19✔

488

                        UniqueItems_mode,

19✔

489

                        MinItems_mode

19✔

490

>,

19✔

491

                array_options<

19✔

492

                        ArrayMode,

19✔

493

                        SpecifiedMode,

19✔

494

                        UniqueItems_mode,

19✔

495

                        MinItems_mode,

19✔

496

                        Items,

19✔

497

                        PrefixItems

19✔

498

>,

19✔

499

19✔

500

                        items: {

19✔

501

                                with: TupleTypeNode<T2, T3>,

19✔

502

                                optional: ArrayTypeNode<T2>,

19✔

503

                        }[MinItems_mode],

19✔

504

                        prefixItems: TupleTypeNode<T2, T3>,

19✔

505

                }[ArrayMode],

19✔

506

                ArrayLiteralExpression<T4, T5, true>

19✔

507

> {

19✔

508

        #expression_at_index_verifier: ExpressionAtIndexVerifier<T1, T4, T5>;

19✔

509

19✔

510

        constructor(

19✔

511

                options: SchemalessTypeOptions,

1,310✔

512

1,310✔

513

                        array_options,

1,310✔

514

                        // eslint-disable-next-line @stylistic/max-len

1,310✔

515

                        expression_at_index_verifier = expression_at_index_verifier_default<

1,310✔

516

T1,

1,310✔

517

                                ArrayMode,

1,310✔

518

                                MinItems_mode,

1,310✔

519

T4,

1,310✔

520

T5

1,310✔

521

>,

1,310✔

522

                }: {

1,310✔

523

                        array_options: array_options<

1,310✔

524

                                ArrayMode,

1,310✔

525

                                SpecifiedMode,

1,310✔

526

                                UniqueItems_mode,

1,310✔

527

                                MinItems_mode,

1,310✔

528

                                Items,

1,310✔

529

                                PrefixItems

1,310✔

530

>,

1,310✔

531

                        expression_at_index_verifier?: ExpressionAtIndexVerifier<

1,310✔

532

T1,

1,310✔

533

T4,

1,310✔

534

T5

1,310✔

535

>,

1,310✔

536

},

1,310✔

537

) {

1,310✔

538

                super({

1,310✔

539

                        ...options,

1,310✔

540

                        type_definition: array_options,

1,310✔

541

                        schema_definition: array_options,

1,310✔

542

});

1,310✔

543

1,310✔

544

                this.#expression_at_index_verifier = expression_at_index_verifier;

1,310✔

545

1,310✔

546

19✔

547

        generate_typescript_data(

19✔

548

                data: T1,

50✔

549

                schema_parser: SchemaParser,

50✔

550

                schema: array_type<

50✔

551

                        ArrayMode,

50✔

552

                        SpecifiedMode,

50✔

553

                        UniqueItems_mode,

50✔

554

                        MinItems_mode,

50✔

555

                        Items,

50✔

556

                        PrefixItems

50✔

557

>,

50✔

558

        ): ArrayLiteralExpression<T4, T5, true> {

50✔

559

                if (!(this.check_type(data))) {

50✔

560

                        throw new TypeError('data does not pass type check!');

1✔

561

1✔

562

49✔

563

                return factory.createArrayLiteralExpression(

49✔

564

                        data.map((value, i): T4 => {

49✔

565

                                const index = PositiveIntegerOrZeroGuard(i);

120✔

566

                                const element = ArrayType.#convert(

120✔

567

                                        value,

120✔

568

                                        index,

120✔

569

                                        schema,

120✔

570

                                        schema_parser,

120✔

571

);

120✔

572

120✔

573

                                if (!(this.#expression_at_index_verifier(

120✔

574

                                        data,

120✔

575

                                        element,

120✔

576

                                        index,

120✔

577

                                ))) {

120✔

578

                                        throw new TypeError(

2✔

579

                                                `Element at index ${

2✔

580

                                                        index

2✔

581

                                                } was not of expected type!`,

2✔

582

);

2✔

583

2✔

584

116✔

585

                                return element;

116✔

586

}),

49✔

587

                        true,

49✔

588

);

49✔

589

50✔

590

19✔

591

        generate_typescript_type({

19✔

592

                data,

105✔

593

                schema,

105✔

594

                schema_parser,

105✔

595

        }: {

105✔

596

                data: T1,

105✔

597

                schema: array_type<

105✔

598

                        ArrayMode,

105✔

599

                        SpecifiedMode,

105✔

600

                        UniqueItems_mode,

105✔

601

                        MinItems_mode,

105✔

602

                        Items,

105✔

603

                        PrefixItems

105✔

604

>,

105✔

605

                schema_parser: SchemaParser,

105✔

606

        }): Promise<{

105✔

607

                items: {

105✔

608

                        with: TupleTypeNode<T2, T3>,

105✔

609

                        optional: ArrayTypeNode<T2>,

105✔

610

                }[MinItems_mode],

105✔

611

                prefixItems: TupleTypeNode<T2, T3>,

105✔

612

        }[ArrayMode]> {

105✔

613

                let result: Promise<{

105✔

614

                        items: {

105✔

615

                                with: TupleTypeNode<T2, T3>,

105✔

616

                                optional: ArrayTypeNode<T2>,

105✔

617

                        }[MinItems_mode],

105✔

618

                        prefixItems: TupleTypeNode<T2, T3>,

105✔

619

                }[ArrayMode]>;

105✔

620

105✔

621

                if (!ArrayType.#is_items_type_schema(schema)) {

105✔

622

                        const sanity_check: Promise<

68✔

623

                                TupleTypeNode<T2, T3>

68✔

624

                        > = ArrayType.#generate_typescript_type_has_prefixItems(

68✔

625

                                data,

68✔

626

                                schema as array_type<

68✔

627

                                        'prefixItems',

68✔

628

                                        'specified'

68✔

629

>,

68✔

630

                                schema_parser,

68✔

631

);

68✔

632

68✔

633

                        result = sanity_check as typeof result;

68✔

634

                } else {

105✔

635

                        const sanity_check: Promise<{

37✔

636

                                items: {

37✔

637

                                        with: TupleTypeNode<T2, T3>,

37✔

638

                                        optional: ArrayTypeNode<T2>,

37✔

639

                                }[MinItems_mode],

37✔

640

                                prefixItems: TupleTypeNode<T2, T3>,

37✔

641

                        }[ArrayMode]> = ArrayType.#generate_typescript_type_has_items(

37✔

642

                                data,

37✔

643

                                schema,

37✔

644

                                schema_parser,

37✔

645

);

37✔

646

37✔

647

                        result = sanity_check as unknown as typeof result;

37✔

648

37✔

649

105✔

650

                return result;

105✔

651

105✔

652

19✔

653

        static generate_schema_definition<

19✔

654

                ArrayMode extends array_mode,

1,310✔

655

                SpecifiedMode extends specified_mode,

1,310✔

656

                UniqueItems_mode extends unique_items_mode,

1,310✔

657

                MinItems_mode extends MinItemsType_mode,

1,310✔

658

                Items extends SchemaObject,

1,310✔

659

                PrefixItems extends [

1,310✔

660

                        SchemaObject,

1,310✔

661

                        ...SchemaObject[],

1,310✔

662

],

1,310✔

663

>(

1,310✔

664

                options: array_options<

1,310✔

665

                        ArrayMode,

1,310✔

666

                        SpecifiedMode,

1,310✔

667

                        UniqueItems_mode,

1,310✔

668

                        MinItems_mode,

1,310✔

669

                        Items,

1,310✔

670

                        PrefixItems

1,310✔

671

>,

1,310✔

672

        ): Readonly<array_schema<

1,310✔

673

                ArrayMode,

1,310✔

674

                SpecifiedMode,

1,310✔

675

                UniqueItems_mode,

1,310✔

676

                MinItems_mode,

1,310✔

677

                Items,

1,310✔

678

                PrefixItems

1,310✔

679

        >> {

1,310✔

680

                const required: array_schema<

1,310✔

681

                        ArrayMode,

1,310✔

682

                        SpecifiedMode,

1,310✔

683

                        UniqueItems_mode,

1,310✔

684

                        MinItems_mode,

1,310✔

685

                        Items,

1,310✔

686

                        PrefixItems

1,310✔

687

                >['required'] = this.#generate_schema_definition_required(

1,310✔

688

                        options,

1,310✔

689

);

1,310✔

690

1,310✔

691

                const properties: array_schema<

1,310✔

692

                        ArrayMode,

1,310✔

693

                        SpecifiedMode,

1,310✔

694

                        UniqueItems_mode,

1,310✔

695

                        MinItems_mode,

1,310✔

696

                        Items,

1,310✔

697

                        PrefixItems

1,310✔

698

                >['properties'] = this.#generate_schema_definition_properties(

1,310✔

699

                        options,

1,310✔

700

);

1,310✔

701

1,310✔

702

                const result: array_schema<

1,310✔

703

                        ArrayMode,

1,310✔

704

                        SpecifiedMode,

1,310✔

705

                        UniqueItems_mode,

1,310✔

706

                        MinItems_mode,

1,310✔

707

                        Items,

1,310✔

708

                        PrefixItems

1,310✔

709

                > = {

1,310✔

710

                        type: 'object',

1,310✔

711

                        additionalProperties: false,

1,310✔

712

                        required,

1,310✔

713

                        properties,

1,310✔

714

};

1,310✔

715

1,310✔

716

                if (options.$defs) {

1,310✔

717

                        result.$defs = options.$defs;

4✔

718

4✔

719

1,310✔

720

                return Object.freeze(result);

1,310✔

721

1,310✔

722

19✔

723

        static generate_type_definition<

19✔

724

                ArrayMode extends array_mode,

1,310✔

725

                SpecifiedMode extends specified_mode,

1,310✔

726

                UniqueItems_mode extends unique_items_mode,

1,310✔

727

                MinItems_mode extends MinItemsType_mode,

1,310✔

728

                Items extends SchemaObject,

1,310✔

729

                PrefixItems extends [

1,310✔

730

                        SchemaObject,

1,310✔

731

                        ...SchemaObject[],

1,310✔

732

],

1,310✔

733

>(

1,310✔

734

                options: array_options<

1,310✔

735

                        ArrayMode,

1,310✔

736

                        SpecifiedMode,

1,310✔

737

                        UniqueItems_mode,

1,310✔

738

                        MinItems_mode,

1,310✔

739

                        Items,

1,310✔

740

                        PrefixItems

1,310✔

741

>,

1,310✔

742

        ): Readonly<array_type<

1,310✔

743

                ArrayMode,

1,310✔

744

                SpecifiedMode,

1,310✔

745

                UniqueItems_mode,

1,310✔

746

                MinItems_mode,

1,310✔

747

                Items,

1,310✔

748

                PrefixItems

1,310✔

749

        >> {

1,310✔

750

                let result: array_type<

1,310✔

751

                        ArrayMode,

1,310✔

752

                        SpecifiedMode,

1,310✔

753

                        UniqueItems_mode,

1,310✔

754

                        MinItems_mode,

1,310✔

755

                        Items,

1,310✔

756

                        PrefixItems

1,310✔

757

>;

1,310✔

758

1,310✔

759

                if ('items' === options.array_mode) {

1,310✔

760

                        if (options.items) {

648✔

761

                                const sanity_check: array_type<

17✔

762

                                        'items',

17✔

763

                                        'specified',

17✔

764

                                        unique_items_mode,

17✔

765

                                        'optional',

17✔

766

                                        Items,

17✔

767

                                        [SchemaObject, ...SchemaObject[]]

17✔

768

                                > = {

17✔

769

                                        type: 'array',

17✔

770

                                        items: options.items,

17✔

771

                                        uniqueItems: 'yes' === options.unique_items_mode,

17✔

772

};

17✔

773

17✔

774

                                if ('number' === typeof options.minItems) {

17✔

775

                                        sanity_check.minItems = options.minItems;

6✔

776

6✔

777

17✔

778

                                if ('number' === typeof options.maxItems) {

17✔

779

                                        sanity_check.maxItems = options.maxItems;

6✔

780

6✔

781

17✔

782

                                result = sanity_check as typeof result;

17✔

783

                        } else {

648✔

784

                                const sanity_check: array_type<

631✔

785

                                        'items',

631✔

786

                                        'unspecified',

631✔

787

                                        unique_items_mode,

631✔

788

                                        'optional',

631✔

789

                                        Items,

631✔

790

                                        [SchemaObject, ...SchemaObject[]]

631✔

791

                                > = {

631✔

792

                                        type: 'array',

631✔

793

                                        items: {},

631✔

794

                                        uniqueItems: 'yes' === options.unique_items_mode,

631✔

795

};

631✔

796

631✔

797

                                if ('number' === typeof options.minItems) {

631✔

798

                                        sanity_check.minItems = options.minItems;

36✔

799

36✔

800

631✔

801

                                if ('number' === typeof options.maxItems) {

631✔

802

                                        sanity_check.maxItems = options.maxItems;

36✔

803

36✔

804

631✔

805

                                result = sanity_check as typeof result;

631✔

806

631✔

807

                } else {

1,310✔

808

                        let uniqueItems: array_type<

662✔

809

                                'prefixItems',

662✔

810

                                specified_mode,

662✔

811

                                UniqueItems_mode,

662✔

812

                                MinItemsType_mode,

662✔

813

                                SchemaObject,

662✔

814

                                PrefixItems

662✔

815

                        >['uniqueItems'];

662✔

816

662✔

817

                        if ('yes' === options.unique_items_mode) {

662✔

818

                                const sanity_check: array_type<

360✔

819

                                        'prefixItems',

360✔

820

                                        specified_mode,

360✔

821

                                        'yes',

360✔

822

                                        MinItemsType_mode,

360✔

823

                                        SchemaObject,

360✔

824

                                        PrefixItems

360✔

825

                                >['uniqueItems'] = true;

360✔

826

360✔

827

                                uniqueItems = sanity_check as typeof uniqueItems;

360✔

828

                        } else {

491✔

829

                                const sanity_check: array_type<

302✔

830

                                        'prefixItems',

302✔

831

                                        specified_mode,

302✔

832

                                        'no',

302✔

833

                                        MinItemsType_mode,

302✔

834

                                        SchemaObject,

302✔

835

                                        PrefixItems

302✔

836

                                >['uniqueItems'] = false;

302✔

837

302✔

838

                                uniqueItems = sanity_check as typeof uniqueItems;

302✔

839

302✔

840

662✔

841

662✔

842

                        if (this.#is_specified_prefixItems_options(options)) {

662✔

843

                                const sanity_check: array_type<

64✔

844

                                        'prefixItems',

64✔

845

                                        'specified',

64✔

846

                                        UniqueItems_mode,

64✔

847

                                        MinItemsType_mode,

64✔

848

                                        SchemaObject,

64✔

849

                                        PrefixItems

64✔

850

                                > = {

64✔

851

                                        type: 'array',

64✔

852

                                        items: false,

64✔

853

                                        prefixItems: options.prefixItems,

64✔

854

                                        minItems: PositiveIntegerGuard(options.prefixItems.length),

64✔

855

                                        uniqueItems,

64✔

856

};

64✔

857

64✔

858

                                result = sanity_check as unknown as typeof result;

64✔

859

                        } else {

662✔

860

                                const sanity_check: array_type<

598✔

861

                                        'prefixItems',

598✔

862

                                        'unspecified',

598✔

863

                                        unique_items_mode,

598✔

864

                                        'optional',

598✔

865

                                        SchemaObject,

598✔

866

                                        PrefixItems

598✔

867

                                > = {

598✔

868

                                        type: 'array',

598✔

869

                                        uniqueItems: 'yes' === options.unique_items_mode,

598✔

870

                                        items: {},

598✔

871

                                        minItems: PositiveIntegerGuard(1),

598✔

872

};

598✔

873

598✔

874

                                if (options.minItems) {

598✔

875

                                        sanity_check.minItems = options.minItems;

594✔

876

594✔

877

598✔

878

                                if ('number' === typeof options.maxItems) {

598✔

879

                                        sanity_check.maxItems = options.maxItems;

2✔

880

2✔

881

598✔

882

                                result = sanity_check as typeof result;

598✔

883

598✔

884

662✔

885

1,310✔

886

                if (options.$defs) {

1,310✔

887

                        result.$defs = options.$defs;

4✔

888

4✔

889

1,310✔

890

                return Object.freeze<array_type<

1,310✔

891

                        ArrayMode,

1,310✔

892

                        SpecifiedMode,

1,310✔

893

                        UniqueItems_mode,

1,310✔

894

                        MinItems_mode,

1,310✔

895

                        Items,

1,310✔

896

                        PrefixItems

1,310✔

897

                >>(result);

1,310✔

898

1,310✔

899

19✔

900

        static #convert<

19✔

901

                ArrayMode extends array_mode,

120✔

902

                SpecifiedMode extends specified_mode,

120✔

903

                UniqueItems_mode extends unique_items_mode,

120✔

904

                MinItems_mode extends MinItemsType_mode,

120✔

905

                Items extends SchemaObject,

120✔

906

                PrefixItems extends [

120✔

907

                        SchemaObject,

120✔

908

                        ...SchemaObject[],

120✔

909

],

120✔

910

                N extends number = number,

120✔

911

>(

120✔

912

                value: unknown,

120✔

913

                index: ReturnType<typeof PositiveIntegerOrZeroGuard<N>>,

120✔

914

                schema: array_type<

120✔

915

                        ArrayMode,

120✔

916

                        SpecifiedMode,

120✔

917

                        UniqueItems_mode,

120✔

918

                        MinItems_mode,

120✔

919

                        Items,

120✔

920

                        PrefixItems

120✔

921

>,

120✔

922

                schema_parser: SchemaParser,

120✔

923

        ): Expression {

120✔

924

                const sub_schema = ArrayType.maybe_add_$defs(

120✔

925

                        schema,

120✔

926

                        this.#sub_schema_for_value(

120✔

927

                                index,

120✔

928

                                schema,

120✔

929

),

120✔

930

);

120✔

931

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

120✔

932

                const validator = ajv.compile(sub_schema);

120✔

933

120✔

934

                const validates = validator(value);

120✔

935

120✔

936

                if (!validates) {

120✔

937

                        throw new SchemaValidationError(

1✔

938

                                'Supplied value not supported by index!',

1✔

939

                                validator,

1✔

940

);

1✔

941

1✔

942

118✔

943

                const matched_type = Object.keys(sub_schema).length > 0

118✔

944

                        ? schema_parser.parse(

120✔

945

                                sub_schema,

96✔

946

96✔

947

                        : schema_parser.parse_by_type(value);

120✔

948

120✔

949

                return matched_type.generate_typescript_data(

120✔

950

                        value,

120✔

951

                        schema_parser,

120✔

952

                        sub_schema,

120✔

953

);

120✔

954

120✔

955

19✔

956

        static #generate_schema_definition_properties<

19✔

957

                ArrayMode extends array_mode,

1,310✔

958

                SpecifiedMode extends specified_mode,

1,310✔

959

                UniqueItems_mode extends unique_items_mode,

1,310✔

960

                MinItems_mode extends MinItemsType_mode,

1,310✔

961

                Items extends SchemaObject,

1,310✔

962

                PrefixItems extends [

1,310✔

963

                        SchemaObject,

1,310✔

964

                        ...SchemaObject[],

1,310✔

965

],

1,310✔

966

>(

1,310✔

967

                options: array_options<

1,310✔

968

                        ArrayMode,

1,310✔

969

                        SpecifiedMode,

1,310✔

970

                        UniqueItems_mode,

1,310✔

971

                        MinItems_mode,

1,310✔

972

                        Items,

1,310✔

973

                        PrefixItems

1,310✔

974

>,

1,310✔

975

        ): array_schema<

1,310✔

976

                ArrayMode,

1,310✔

977

                SpecifiedMode,

1,310✔

978

                UniqueItems_mode,

1,310✔

979

                MinItems_mode,

1,310✔

980

                Items,

1,310✔

981

                PrefixItems

1,310✔

982

        >['properties'] {

1,310✔

983

                let result: array_schema<

1,310✔

984

                        ArrayMode,

1,310✔

985

                        SpecifiedMode,

1,310✔

986

                        UniqueItems_mode,

1,310✔

987

                        MinItems_mode,

1,310✔

988

                        Items,

1,310✔

989

                        PrefixItems

1,310✔

990

                >['properties'];

1,310✔

991

1,310✔

992

                if ('items' === options.array_mode) {

1,310✔

993

                        const sanity_check: array_schema<

648✔

994

                                'items',

648✔

995

                                SpecifiedMode,

648✔

996

                                UniqueItems_mode,

648✔

997

                                MinItems_mode,

648✔

998

                                Items,

648✔

999

                                [SchemaObject, ...SchemaObject[]]

648✔

1000

>[

648✔

1001

                                'properties'

648✔

1002

                        ] = this.#generate_schema_definition_properties_items(

648✔

1003

                                options as array_options<

648✔

1004

                                        'items',

648✔

1005

                                        SpecifiedMode,

648✔

1006

                                        UniqueItems_mode,

648✔

1007

                                        MinItems_mode,

648✔

1008

                                        Items,

648✔

1009

                                        [SchemaObject, ...SchemaObject[]]

648✔

1010

>,

648✔

1011

);

648✔

1012

648✔

1013

                        result = sanity_check as typeof result;

648✔

1014

                } else {

978✔

1015

                        const sanity_check: array_schema<

662✔

1016

                                'prefixItems',

662✔

1017

                                SpecifiedMode,

662✔

1018

                                UniqueItems_mode,

662✔

1019

                                MinItems_mode,

662✔

1020

                                Items,

662✔

1021

                                [SchemaObject, ...SchemaObject[]]

662✔

1022

>[

662✔

1023

                                'properties'

662✔

1024

                        ] = this.#generate_schema_definition_properties_prefixItems(

662✔

1025

                                options as array_options<

662✔

1026

                                        'prefixItems',

662✔

1027

                                        SpecifiedMode,

662✔

1028

                                        UniqueItems_mode,

662✔

1029

                                        MinItems_mode,

662✔

1030

                                        Items,

662✔

1031

                                        [SchemaObject, ...SchemaObject[]]

662✔

1032

>,

662✔

1033

);

662✔

1034

662✔

1035

                        result = sanity_check as typeof result;

662✔

1036

662✔

1037

1,310✔

1038

                return result;

1,310✔

1039

1,310✔

1040

19✔

1041

        static #generate_schema_definition_properties_base<

19✔

1042

                UniqueItems_mode extends unique_items_mode,

1,310✔

1043

>(

1,310✔

1044

                options: array_options<

1,310✔

1045

                        array_mode,

1,310✔

1046

                        specified_mode,

1,310✔

1047

                        UniqueItems_mode,

1,310✔

1048

                        MinItemsType_mode

1,310✔

1049

>,

1,310✔

1050

        ): Pick<

1,310✔

1051

                array_schema<

1,310✔

1052

                        array_mode,

1,310✔

1053

                        specified_mode,

1,310✔

1054

                        UniqueItems_mode,

1,310✔

1055

                        MinItemsType_mode

1,310✔

1056

                >['properties'],

1,310✔

1057

1,310✔

1058

                        | '$schema'

1,310✔

1059

                        | '$id'

1,310✔

1060

                        | '$defs'

1,310✔

1061

                        | 'type'

1,310✔

1062

                        | 'uniqueItems'

1,310✔

1063

1,310✔

1064

> {

1,310✔

1065

                let base: Pick<

1,310✔

1066

                        array_schema<

1,310✔

1067

                                array_mode,

1,310✔

1068

                                specified_mode,

1,310✔

1069

                                UniqueItems_mode,

1,310✔

1070

                                MinItemsType_mode

1,310✔

1071

                        >['properties'],

1,310✔

1072

1,310✔

1073

                                | '$schema'

1,310✔

1074

                                | '$id'

1,310✔

1075

                                | '$defs'

1,310✔

1076

                                | 'type'

1,310✔

1077

                                | 'uniqueItems'

1,310✔

1078

1,310✔

1079

>;

1,310✔

1080

1,310✔

1081

                if ('yes' === options.unique_items_mode) {

1,310✔

1082

                        const sanity_check: Pick<

678✔

1083

                                array_schema<

678✔

1084

                                        array_mode,

678✔

1085

                                        specified_mode,

678✔

1086

                                        'yes',

678✔

1087

                                        MinItemsType_mode

678✔

1088

                                >['properties'],

678✔

1089

678✔

1090

                                        | '$schema'

678✔

1091

                                        | '$id'

678✔

1092

                                        | 'type'

678✔

1093

                                        | 'uniqueItems'

678✔

1094

678✔

1095

                        > = {

678✔

1096

                                $schema: {

678✔

1097

                                        type: 'string',

678✔

1098

                                        enum: [

678✔

1099

                                                'https://json-schema.org/draft/2020-12/schema',

678✔

1100

],

678✔

1101

},

678✔

1102

                                $id: {

678✔

1103

                                        type: 'string',

678✔

1104

                                        minLength: 1,

678✔

1105

},

678✔

1106

                                type: {

678✔

1107

                                        type: 'string',

678✔

1108

                                        const: 'array',

678✔

1109

},

678✔

1110

                                uniqueItems: {

678✔

1111

                                        type: 'boolean',

678✔

1112

                                        const: true,

678✔

1113

},

678✔

1114

};

678✔

1115

678✔

1116

                        base = sanity_check as typeof base;

678✔

1117

                } else {

978✔

1118

                        const sanity_check: Pick<

632✔

1119

                                array_schema<

632✔

1120

                                        array_mode,

632✔

1121

                                        specified_mode,

632✔

1122

                                        'no',

632✔

1123

                                        MinItemsType_mode

632✔

1124

                                >['properties'],

632✔

1125

632✔

1126

                                        | '$schema'

632✔

1127

                                        | '$id'

632✔

1128

                                        | 'type'

632✔

1129

                                        | 'uniqueItems'

632✔

1130

632✔

1131

                        > = {

632✔

1132

                                $schema: {

632✔

1133

                                        type: 'string',

632✔

1134

                                        enum: [

632✔

1135

                                                'https://json-schema.org/draft/2020-12/schema',

632✔

1136

],

632✔

1137

},

632✔

1138

                                $id: {

632✔

1139

                                        type: 'string',

632✔

1140

                                        minLength: 1,

632✔

1141

},

632✔

1142

                                type: {

632✔

1143

                                        type: 'string',

632✔

1144

                                        const: 'array',

632✔

1145

},

632✔

1146

                                uniqueItems: {

632✔

1147

                                        type: 'boolean',

632✔

1148

                                        const: false,

632✔

1149

},

632✔

1150

};

632✔

1151

632✔

1152

                        base = sanity_check as typeof base;

632✔

1153

632✔

1154

1,310✔

1155

                if (options.$defs) {

1,310✔

1156

                        base.$defs = {

4✔

1157

                                type: 'object',

4✔

1158

                                const: {

4✔

1159

                                        ...options.$defs,

4✔

1160

},

4✔

1161

};

4✔

1162

                } else {

1,310✔

1163

                        base.$defs = $defs_schema.properties.$defs;

1,306✔

1164

1,306✔

1165

1,310✔

1166

                return base;

1,310✔

1167

1,310✔

1168

19✔

1169

        static #generate_schema_definition_properties_items<

19✔

1170

                SpecifiedMode extends specified_mode,

648✔

1171

                UniqueItems_mode extends unique_items_mode,

648✔

1172

                MinItems_mode extends MinItemsType_mode,

648✔

1173

                Items extends SchemaObject,

648✔

1174

>(

648✔

1175

                options: array_options<

648✔

1176

                        'items',

648✔

1177

                        SpecifiedMode,

648✔

1178

                        UniqueItems_mode,

648✔

1179

                        MinItems_mode,

648✔

1180

                        Items,

648✔

1181

                        [SchemaObject, ...SchemaObject[]]

648✔

1182

>,

648✔

1183

        ): Readonly<array_schema<

648✔

1184

                'items',

648✔

1185

                SpecifiedMode,

648✔

1186

                UniqueItems_mode,

648✔

1187

                MinItems_mode,

648✔

1188

                Items,

648✔

1189

                [SchemaObject, ...SchemaObject[]]

648✔

1190

        >['properties']> {

648✔

1191

                let result: array_schema<

648✔

1192

                        'items',

648✔

1193

                        SpecifiedMode,

648✔

1194

                        UniqueItems_mode,

648✔

1195

                        MinItems_mode,

648✔

1196

                        Items,

648✔

1197

                        [SchemaObject, ...SchemaObject[]]

648✔

1198

                >['properties'];

648✔

1199

648✔

1200

                const base = {

648✔

1201

                        ...this.#generate_schema_definition_properties_base(options),

648✔

1202

                        minItems: {

648✔

1203

                                type: 'integer',

648✔

1204

                                minimum: 0,

648✔

1205

                        } as const,

648✔

1206

                        maxItems: {

648✔

1207

                                type: 'integer',

648✔

1208

                                minimum: 0,

648✔

1209

                        } as const,

648✔

1210

};

648✔

1211

648✔

1212

                if (options.items) {

648✔

1213

                        const sanity_check: array_schema<

17✔

1214

                                'items',

17✔

1215

                                'specified',

17✔

1216

                                UniqueItems_mode,

17✔

1217

                                MinItems_mode,

17✔

1218

                                Items,

17✔

1219

                                [SchemaObject, ...SchemaObject[]]

17✔

1220

                        >['properties'] = {

17✔

1221

                                ...base,

17✔

1222

                                items: options.items,

17✔

1223

};

17✔

1224

17✔

1225

                        result = sanity_check as typeof result;

17✔

1226

                } else {

648✔

1227

                        const sanity_check: array_schema<

631✔

1228

                                'items',

631✔

1229

                                'unspecified',

631✔

1230

                                UniqueItems_mode,

631✔

1231

                                MinItems_mode,

631✔

1232

                                Items,

631✔

1233

                                [SchemaObject, ...SchemaObject[]]

631✔

1234

                        >['properties'] = {

631✔

1235

                                ...base,

631✔

1236

                                items: {

631✔

1237

                                        type: 'object',

631✔

1238

                                        minProperties: 0,

631✔

1239

},

631✔

1240

};

631✔

1241

631✔

1242

                        result = sanity_check as typeof result;

631✔

1243

631✔

1244

648✔

1245

                return Object.freeze(result);

648✔

1246

648✔

1247

19✔

1248

        static #generate_schema_definition_properties_prefixItems<

19✔

1249

                SpecifiedMode extends specified_mode,

662✔

1250

                UniqueItems_mode extends unique_items_mode,

662✔

1251

                MinItems_mode extends MinItemsType_mode,

662✔

1252

                PrefixItems extends [

662✔

1253

                        SchemaObject,

662✔

1254

                        ...SchemaObject[],

662✔

1255

],

662✔

1256

>(

662✔

1257

                options: array_options<

662✔

1258

                        'prefixItems',

662✔

1259

                        SpecifiedMode,

662✔

1260

                        UniqueItems_mode,

662✔

1261

                        MinItems_mode,

662✔

1262

                        SchemaObject,

662✔

1263

                        PrefixItems

662✔

1264

>,

662✔

1265

        ): array_schema<

662✔

1266

                'prefixItems',

662✔

1267

                SpecifiedMode,

662✔

1268

                UniqueItems_mode,

662✔

1269

                MinItems_mode,

662✔

1270

                SchemaObject,

662✔

1271

                PrefixItems

662✔

1272

        >['properties'] {

662✔

1273

                let result: array_schema<

662✔

1274

                        'prefixItems',

662✔

1275

                        SpecifiedMode,

662✔

1276

                        UniqueItems_mode,

662✔

1277

                        MinItems_mode,

662✔

1278

                        SchemaObject,

662✔

1279

                        PrefixItems

662✔

1280

                >['properties'];

662✔

1281

662✔

1282

                const base = {

662✔

1283

                        ...this.#generate_schema_definition_properties_base(options),

662✔

1284

                        minItems: {

662✔

1285

                                type: 'integer',

662✔

1286

                                minimum: 0,

662✔

1287

                        } as const,

662✔

1288

                        maxItems: {

662✔

1289

                                type: 'integer',

662✔

1290

                                minimum: 1,

662✔

1291

                        } as const,

662✔

1292

};

662✔

1293

662✔

1294

                if ('prefixItems' in options) {

662✔

1295

                        const sanity_check: array_schema<

64✔

1296

                                'prefixItems',

64✔

1297

                                'specified',

64✔

1298

                                UniqueItems_mode,

64✔

1299

                                MinItems_mode,

64✔

1300

                                SchemaObject,

64✔

1301

                                PrefixItems

64✔

1302

                        >['properties'] = {

64✔

1303

                                ...base,

64✔

1304

                                items: {

64✔

1305

                                        type: 'boolean',

64✔

1306

                                        const: false,

64✔

1307

},

64✔

1308

                                prefixItems: {

64✔

1309

                                        type: 'array',

64✔

1310

                                        const: options.prefixItems,

64✔

1311

},

64✔

1312

};

64✔

1313

64✔

1314

                        result = sanity_check as typeof result;

64✔

1315

                } else {

662✔

1316

                        const sanity_check: array_schema<

598✔

1317

                                'prefixItems',

598✔

1318

                                'unspecified',

598✔

1319

                                UniqueItems_mode,

598✔

1320

                                MinItems_mode,

598✔

1321

                                SchemaObject & {},

598✔

1322

                                [SchemaObject, ...SchemaObject[]]

598✔

1323

                        >['properties'] = {

598✔

1324

                                ...base,

598✔

1325

                                items: {

598✔

1326

                                        type: 'boolean',

598✔

1327

                                        const: false,

598✔

1328

},

598✔

1329

                                prefixItems: {

598✔

1330

                                        type: 'array',

598✔

1331

                                        minItems: 1,

598✔

1332

                                        items: {

598✔

1333

                                                type: 'object',

598✔

1334

                                                minProperties: 1,

598✔

1335

},

598✔

1336

},

598✔

1337

};

598✔

1338

598✔

1339

                        result = sanity_check as typeof result;

598✔

1340

598✔

1341

662✔

1342

                return result;

662✔

1343

662✔

1344

19✔

1345

        static #generate_schema_definition_required<

19✔

1346

                ArrayMode extends array_mode,

1,310✔

1347

                SpecifiedMode extends specified_mode,

1,310✔

1348

                UniqueItems_mode extends unique_items_mode,

1,310✔

1349

                MinItems_mode extends MinItemsType_mode,

1,310✔

1350

                Items extends SchemaObject,

1,310✔

1351

                PrefixItems extends [

1,310✔

1352

                        SchemaObject,

1,310✔

1353

                        ...SchemaObject[],

1,310✔

1354

],

1,310✔

1355

>(

1,310✔

1356

                options: array_options<

1,310✔

1357

                        ArrayMode,

1,310✔

1358

                        SpecifiedMode,

1,310✔

1359

                        UniqueItems_mode,

1,310✔

1360

                        MinItems_mode,

1,310✔

1361

                        Items,

1,310✔

1362

                        PrefixItems

1,310✔

1363

>,

1,310✔

1364

        ): array_schema<

1,310✔

1365

                ArrayMode,

1,310✔

1366

                SpecifiedMode,

1,310✔

1367

                UniqueItems_mode,

1,310✔

1368

                MinItems_mode,

1,310✔

1369

                Items,

1,310✔

1370

                PrefixItems

1,310✔

1371

        >['required'] {

1,310✔

1372

                let result: array_schema<

1,310✔

1373

                        ArrayMode,

1,310✔

1374

                        SpecifiedMode,

1,310✔

1375

                        UniqueItems_mode,

1,310✔

1376

                        MinItems_mode,

1,310✔

1377

                        Items,

1,310✔

1378

                        PrefixItems

1,310✔

1379

                >['required'];

1,310✔

1380

1,310✔

1381

                if (this.#is_any_items_options(options)) {

1,310✔

1382

                        const sanity_check: array_schema<

648✔

1383

                                'items',

648✔

1384

                                SpecifiedMode

648✔

1385

                        >['required'] = this.#generate_schema_definition_required_items(

648✔

1386

                                options,

648✔

1387

);

648✔

1388

648✔

1389

                        result = sanity_check as typeof result;

648✔

1390

                } else {

978✔

1391

                        const sanity_check: array_schema<

662✔

1392

                                'prefixItems',

662✔

1393

                                SpecifiedMode

662✔

1394

>[

662✔

1395

                                'required'

662✔

1396

                        ] = this.#generate_schema_definition_required_prefixItems<

662✔

1397

                                SpecifiedMode

662✔

1398

>(

662✔

1399

                                options as array_options<'prefixItems', SpecifiedMode>,

662✔

1400

);

662✔

1401

662✔

1402

                        result = sanity_check as typeof result;

662✔

1403

662✔

1404

1,310✔

1405

                return result;

1,310✔

1406

1,310✔

1407

19✔

1408

        static #generate_schema_definition_required_items<

19✔

1409

                SpecifiedMode extends specified_mode,

648✔

1410

>(

648✔

1411

                options: array_options<

648✔

1412

                        'items'

648✔

1413

>,

648✔

1414

        ): array_schema<

648✔

1415

                'items'

648✔

1416

        >['required'] {

648✔

1417

                let required: array_schema<

648✔

1418

                        'items',

648✔

1419

                        SpecifiedMode

648✔

1420

                >['required'];

648✔

1421

648✔

1422

                if ('with' === options.min_items_mode) {

648✔

1423

                        if ('yes' === options.unique_items_mode) {

12✔

1424

                                const sanity_check: array_schema<

6✔

1425

                                        'items',

6✔

1426

                                        specified_mode,

6✔

1427

                                        'yes',

6✔

1428

                                        'with'

6✔

1429

                                >['required'] = [

6✔

1430

                                        'type',

6✔

1431

                                        'items',

6✔

1432

                                        'minItems',

6✔

1433

                                        'uniqueItems',

6✔

1434

];

6✔

1435

6✔

1436

                                required = sanity_check as typeof required;

6✔

1437

                        } else {

6✔

1438

                                const sanity_check: array_schema<

6✔

1439

                                        'items',

6✔

1440

                                        specified_mode,

6✔

1441

                                        'no',

6✔

1442

                                        'with'

6✔

1443

                                >['required'] = [

6✔

1444

                                        'type',

6✔

1445

                                        'items',

6✔

1446

                                        'minItems',

6✔

1447

];

6✔

1448

6✔

1449

                                required = sanity_check as typeof required;

6✔

1450

6✔

1451

                } else {

648✔

1452

                        if ('yes' === options.unique_items_mode) {

636✔

1453

                                const sanity_check: array_schema<

312✔

1454

                                        'items',

312✔

1455

                                        specified_mode,

312✔

1456

                                        'yes',

312✔

1457

                                        'optional'

312✔

1458

                                >['required'] = [

312✔

1459

                                        'type',

312✔

1460

                                        'items',

312✔

1461

                                        'uniqueItems',

312✔

1462

];

312✔

1463

312✔

1464

                                required = sanity_check as typeof required;

312✔

1465

                        } else {

470✔

1466

                                const sanity_check: array_schema<

324✔

1467

                                        'items',

324✔

1468

                                        specified_mode,

324✔

1469

                                        'no',

324✔

1470

                                        'optional'

324✔

1471

                                >['required'] = [

324✔

1472

                                        'type',

324✔

1473

                                        'items',

324✔

1474

];

324✔

1475

324✔

1476

                                required = sanity_check as typeof required;

324✔

1477

324✔

1478

636✔

1479

648✔

1480

                return required;

648✔

1481

648✔

1482

19✔

1483

        static #generate_schema_definition_required_prefixItems<

19✔

1484

                SpecifiedMode extends specified_mode,

662✔

1485

>(

662✔

1486

                options: array_options<

662✔

1487

                        'prefixItems',

662✔

1488

                        SpecifiedMode

662✔

1489

>,

662✔

1490

        ): array_schema<

662✔

1491

                'prefixItems',

662✔

1492

                SpecifiedMode

662✔

1493

        >['required'] {

662✔

1494

                let required: array_schema<

662✔

1495

                        'prefixItems',

662✔

1496

                        SpecifiedMode

662✔

1497

                >['required'];

662✔

1498

662✔

1499

                if ('specified' === options.specified_mode) {

662✔

1500

                        if ('yes' === options.unique_items_mode) {

64✔

1501

                                const sanity_check: array_schema<

62✔

1502

                                        'prefixItems',

62✔

1503

                                        'specified',

62✔

1504

                                        'yes',

62✔

1505

                                        MinItemsType_mode

62✔

1506

                                >['required'] = [

62✔

1507

                                        'type',

62✔

1508

                                        'items',

62✔

1509

                                        'prefixItems',

62✔

1510

                                        'uniqueItems',

62✔

1511

];

62✔

1512

62✔

1513

                                required = sanity_check as typeof required;

62✔

1514

                        } else {

64✔

1515

                                const sanity_check: array_schema<

2✔

1516

                                        'prefixItems',

2✔

1517

                                        'specified',

2✔

1518

                                        'no',

2✔

1519

                                        MinItemsType_mode

2✔

1520

                                >['required'] = [

2✔

1521

                                        'type',

2✔

1522

                                        'items',

2✔

1523

                                        'prefixItems',

2✔

1524

];

2✔

1525

2✔

1526

                                required = sanity_check as typeof required;

2✔

1527

2✔

1528

                } else {

662✔

1529

                        if ('yes' === options.unique_items_mode) {

598✔

1530

                                const sanity_check: array_schema<

298✔

1531

                                        'prefixItems',

298✔

1532

                                        'unspecified',

298✔

1533

                                        'yes',

298✔

1534

                                        MinItemsType_mode

298✔

1535

                                >['required'] = [

298✔

1536

                                        'type',

298✔

1537

                                        'items',

298✔

1538

                                        'prefixItems',

298✔

1539

                                        'uniqueItems',

298✔

1540

];

298✔

1541

298✔

1542

                                required = sanity_check as typeof required;

298✔

1543

                        } else {

427✔

1544

                                const sanity_check: array_schema<

300✔

1545

                                        'prefixItems',

300✔

1546

                                        'unspecified',

300✔

1547

                                        'no',

300✔

1548

                                        MinItemsType_mode

300✔

1549

                                >['required'] = [

300✔

1550

                                        'type',

300✔

1551

                                        'items',

300✔

1552

                                        'prefixItems',

300✔

1553

];

300✔

1554

300✔

1555

                                required = sanity_check as typeof required;

300✔

1556

300✔

1557

598✔

1558

662✔

1559

                return required;

662✔

1560

662✔

1561

19✔

1562

        static async #generate_typescript_type_has_items<

19✔

1563

                T1 extends unknown[],

37✔

1564

                T2 extends TypeNode,

37✔

1565

                T3 extends [T2, ...T2[]],

37✔

1566

                ArrayMode extends array_mode,

37✔

1567

                MinItems_mode extends MinItemsType_mode,

37✔

1568

>(

37✔

1569

                data: T1,

37✔

1570

                schema: (

37✔

1571

                        | array_type<

37✔

1572

                                'items'

37✔

1573

37✔

1574

                        | array_type<

37✔

1575

                                'prefixItems',

37✔

1576

                                'unspecified'

37✔

1577

37✔

1578

),

37✔

1579

                schema_parser: SchemaParser,

37✔

1580

        ): Promise<{

37✔

1581

                items: {

37✔

1582

                        with: TupleTypeNode<T2, T3>,

37✔

1583

                        optional: ArrayTypeNode<T2>,

37✔

1584

                }[MinItems_mode],

37✔

1585

                prefixItems: TupleTypeNode<T2, T3>,

37✔

1586

        }[ArrayMode]> {

37✔

1587

                let result = Promise<{

37✔

1588

                        items: {

37✔

1589

                                with: TupleTypeNode<T2, T3>,

37✔

1590

                                optional: ArrayTypeNode<T2>,

37✔

1591

                        }[MinItems_mode],

37✔

1592

                        prefixItems: TupleTypeNode<T2, T3>,

37✔

1593

                }[ArrayMode]>;

37✔

1594

37✔

1595

                if (this.#is_type_with_minItems(schema)) {

37✔

1596

                        const sanity_check: Promise<

19✔

1597

                                TupleTypeNode<T2, T3>

19✔

1598

                        > = this.#generate_typescript_type_has_items_and_minItems(

19✔

1599

                                data,

19✔

1600

                                schema,

19✔

1601

                                schema_parser,

19✔

1602

);

19✔

1603

19✔

1604

                        result = sanity_check as unknown as typeof result;

19✔

1605

                } else {

37✔

1606

                        const sanity_check: Promise<

18✔

1607

                                ArrayTypeNode<T2>

18✔

1608

                        > = this.#generate_typescript_type_has_items_only(

18✔

1609

                                data,

18✔

1610

                                schema,

18✔

1611

                                schema_parser,

18✔

1612

);

18✔

1613

18✔

1614

                        result = sanity_check as unknown as typeof result;

18✔

1615

18✔

1616

37✔

1617

                return result as unknown as Promise<{

37✔

1618

                        items: {

37✔

1619

                                with: TupleTypeNode<T2, T3>,

37✔

1620

                                optional: ArrayTypeNode<T2>,

37✔

1621

                        }[MinItems_mode],

37✔

1622

                        prefixItems: TupleTypeNode<T2, T3>,

37✔

1623

                }[ArrayMode]>;

37✔

1624

37✔

1625

19✔

1626

        static async #generate_typescript_type_has_items_and_minItems<

19✔

1627

                T1 extends unknown[],

19✔

1628

                T2 extends TypeNode,

19✔

1629

                T3 extends [T2, ...T2[]],

19✔

1630

                SpecifiedMode extends specified_mode,

19✔

1631

                UniqueItems_mode extends unique_items_mode,

19✔

1632

                Items extends SchemaObject,

19✔

1633

                PrefixItems extends [

19✔

1634

                        SchemaObject,

19✔

1635

                        ...SchemaObject[],

19✔

1636

                ] = [

19✔

1637

                        SchemaObject,

19✔

1638

                        ...SchemaObject[],

19✔

1639

],

19✔

1640

>(

19✔

1641

                data: T1,

19✔

1642

                schema: array_type<

19✔

1643

                        'items',

19✔

1644

                        SpecifiedMode,

19✔

1645

                        UniqueItems_mode,

19✔

1646

                        'with',

19✔

1647

                        Items,

19✔

1648

                        PrefixItems

19✔

1649

>,

19✔

1650

                schema_parser: SchemaParser,

19✔

1651

        ): Promise<TupleTypeNode<T2, T3>> {

19✔

1652

                const tuple_members: TypeNode[] = [];

19✔

1653

                const sub_type = schema_parser.parse(ArrayType.maybe_add_$defs(

19✔

1654

                        schema,

19✔

1655

                        schema.items,

19✔

1656

));

19✔

1657

19✔

1658

                let i = 0;

19✔

1659

                while (tuple_members.length < schema.minItems && i < data?.length) {

19✔

1660

                        tuple_members.push(

19✔

1661

                                await sub_type.generate_typescript_type({

19✔

1662

                                        data: data[i],

19✔

1663

                                        schema: schema.items,

19✔

1664

                                        schema_parser,

19✔

1665

}),

19✔

1666

);

19✔

1667

                        ++i;

19✔

1668

19✔

1669

19✔

1670

                tuple_members.push(factory.createRestTypeNode(

19✔

1671

                        factory.createArrayTypeNode(

19✔

1672

                                await sub_type.generate_typescript_type({

19✔

1673

                                        data: schema.items,

19✔

1674

                                        schema: schema.items,

19✔

1675

                                        schema_parser,

19✔

1676

}),

19✔

1677

),

19✔

1678

));

19✔

1679

19✔

1680

                return factory.createTupleTypeNode<T2, T3>(tuple_members as T3);

19✔

1681

19✔

1682

19✔

1683

        static async #generate_typescript_type_has_items_only<

19✔

1684

                T1 extends unknown[],

18✔

1685

                T2 extends TypeNode,

18✔

1686

                SpecifiedMode extends specified_mode,

18✔

1687

                UniqueItems_mode extends unique_items_mode,

18✔

1688

                Items extends SchemaObject,

18✔

1689

                PrefixItems extends [

18✔

1690

                        SchemaObject,

18✔

1691

                        ...SchemaObject[],

18✔

1692

                ] = [

18✔

1693

                        SchemaObject,

18✔

1694

                        ...SchemaObject[],

18✔

1695

],

18✔

1696

>(

18✔

1697

                data: T1,

18✔

1698

                schema: array_type<

18✔

1699

                        'items',

18✔

1700

                        SpecifiedMode,

18✔

1701

                        UniqueItems_mode,

18✔

1702

                        'optional',

18✔

1703

                        Items,

18✔

1704

                        PrefixItems

18✔

1705

>,

18✔

1706

                schema_parser: SchemaParser,

18✔

1707

        ): Promise<ArrayTypeNode<T2>> {

18✔

1716

7✔

1717

                        return factory.createArrayTypeNode(

7✔

1718

                                factory.createUnionTypeNode(

7✔

1719

                                        await Promise.all(

7✔

1720

                                                data.map(

7✔

1721

                                                        (sub_data) => schema_parser

7✔

1722

                                                                .parse_by_type(sub_data)

21✔

1723

                                                                .generate_typescript_type({

21✔

1724

                                                                        data: sub_data,

21✔

1725

                                                                        schema: {},

21✔

1726

                                                                        schema_parser,

21✔

1727

}),

7✔

1728

),

7✔

1729

),

7✔

1730

                                ) as unknown as T2,

7✔

1731

);

7✔

1732

7✔

1733

11✔

1734

                const sub_type = schema_parser.parse(ArrayType.maybe_add_$defs(

11✔

1735

                        schema,

11✔

1736

                        schema.items,

11✔

1737

));

11✔

1738

11✔

1739

                return factory.createArrayTypeNode(

11✔

1740

                        await sub_type.generate_typescript_type({

11✔

1741

                                data: data,

11✔

1742

                                schema: schema.items,

11✔

1743

                                schema_parser,

11✔

1744

                        }) as T2,

11✔

1745

);

11✔

1746

18✔

1747

19✔

1748

        static async #generate_typescript_type_has_prefixItems<

19✔

1749

                T1 extends unknown[],

68✔

1750

                T2 extends TypeNode,

68✔

1751

                T3 extends [T2, ...T2[]],

68✔

1752

>(

68✔

1753

                data: T1|undefined,

68✔

1754

                schema: array_type<

68✔

1755

                        'prefixItems',

68✔

1756

                        'specified'

68✔

1757

>,

68✔

1758

                schema_parser: SchemaParser,

68✔

1759

        ): Promise<TupleTypeNode<T2, T3>> {

68✔

1760

                if (undefined !== data && data.length !== schema.prefixItems.length) {

68✔

1761

                        throw new TypeError('Data does not match schema length!');

30✔

1762

30✔

1763

38✔

1764

                const tuple_members: TypeNode[] = [];

38✔

1765

38✔

1766

                let i = 0;

38✔

1767

                for (const sub_schema of schema.prefixItems) {

68✔

1768

                        const maybe_modified = ArrayType.maybe_add_$defs(

111✔

1769

                                schema,

111✔

1770

                                sub_schema,

111✔

1771

);

111✔

1772

                        const sub_type = await schema_parser.parse(

111✔

1773

                                maybe_modified,

111✔

1774

                        ).generate_typescript_type({

111✔

1775

                                data: undefined === data ? undefined : data[i],

111✔

1776

                                schema: maybe_modified,

111✔

1777

                                schema_parser,

111✔

1778

});

111✔

1779

111✔

1780

                        ++i;

111✔

1781

111✔

1782

                        tuple_members.push(sub_type);

111✔

1783

111✔

1784

38✔

1785

                return factory.createTupleTypeNode<T2, T3>(tuple_members as T3);

38✔

1786

68✔

1787

19✔

1788

        static #is_any_items_options(

19✔

1789

                options: array_options,

1,310✔

1790

        ): options is array_options<

1,310✔

1791

                'items'

1,310✔

1792

> {

1,310✔

1793

                return 'items' === options.array_mode;

1,310✔

1794

1,310✔

1795

19✔

1796

        static #is_type_with_minItems<

19✔

1797

                SpecifiedMode extends specified_mode,

37✔

1798

                UniqueItems_mode extends unique_items_mode,

37✔

1799

                Items extends SchemaObject,

37✔

1800

                PrefixItems extends [

37✔

1801

                        SchemaObject,

37✔

1802

                        ...SchemaObject[],

37✔

1803

                ] = [

37✔

1804

                        SchemaObject,

37✔

1805

                        ...SchemaObject[],

37✔

1806

],

37✔

1807

>(

37✔

1808

                schema: array_type<

37✔

1809

                        'items',

37✔

1810

                        SpecifiedMode,

37✔

1811

                        UniqueItems_mode,

37✔

1812

                        MinItemsType_mode,

37✔

1813

                        Items,

37✔

1814

                        PrefixItems

37✔

1815

>,

37✔

1816

        ): schema is array_type<

37✔

1817

                'items',

37✔

1818

                SpecifiedMode,

37✔

1819

                UniqueItems_mode,

37✔

1820

                'with',

37✔

1821

                Items,

37✔

1822

                PrefixItems

37✔

1823

> {

37✔

1824

                return 'minItems' in schema;

37✔

1825

37✔

1826

19✔

1827

        static #is_specified_prefixItems_options<

19✔

1828

                UniqueItems_mode extends unique_items_mode,

662✔

1829

                PrefixItems extends [

662✔

1830

                        SchemaObject,

662✔

1831

                        ...SchemaObject[],

662✔

1832

],

662✔

1833

        >(options: array_options<

662✔

1834

                array_mode,

662✔

1835

                specified_mode,

662✔

1836

                UniqueItems_mode,

662✔

1837

                MinItemsType_mode,

662✔

1838

                SchemaObject,

662✔

1839

                PrefixItems

662✔

1840

        >): options is array_options<

662✔

1841

                'prefixItems',

662✔

1842

                'specified',

662✔

1843

                UniqueItems_mode,

662✔

1844

                MinItemsType_mode,

662✔

1845

                SchemaObject,

662✔

1846

                PrefixItems

662✔

1847

> {

662✔

1848

                return (

662✔

1849

                        'prefixItems' === options.array_mode

662✔

1850

                        && 'specified' === options.specified_mode

662✔

1851

);

662✔

1852

662✔

1853

19✔

1854

        static #is_items_type_schema(schema: array_type<

19✔

1855

                array_mode,

105✔

1856

                specified_mode

105✔

1857

        >): schema is (

105✔

1858

                | array_type<'items'>

105✔

1859

                | array_type<'prefixItems', 'unspecified'>

105✔

1860

) {

105✔

1861

                return !('prefixItems' in schema);

105✔

1862

105✔

1863

19✔

1864

        static #sub_schema_for_value<

19✔

1865

                ArrayMode extends array_mode,

120✔

1866

                SpecifiedMode extends specified_mode,

120✔

1867

                UniqueItems_mode extends unique_items_mode,

120✔

1868

                MinItems_mode extends MinItemsType_mode,

120✔

1869

                Items extends SchemaObject,

120✔

1870

                PrefixItems extends [

120✔

1871

                        SchemaObject,

120✔

1872

                        ...SchemaObject[],

120✔

1873

],

120✔

1874

                N extends number,

120✔

1875

>(

120✔

1876

                index: ReturnType<typeof PositiveIntegerOrZeroGuard<N>>,

120✔

1877

                schema: array_type<

120✔

1878

                        ArrayMode,

120✔

1879

                        SpecifiedMode,

120✔

1880

                        UniqueItems_mode,

120✔

1881

                        MinItems_mode,

120✔

1882

                        Items,

120✔

1883

                        PrefixItems

120✔

1884

>,

120✔

1885

        ): SchemaObject {

120✔

1886

                if (

120✔

1887

                        'prefixItems' in schema

120✔

1888

                        && undefined !== schema.prefixItems

120✔

1889

                        && index < schema.prefixItems.length

120✔

1890

) {

120✔

1891

                        return schema.prefixItems[index];

24✔

1892

                } else if (false !== schema.items) {

120✔

1893

                        return schema.items;

95✔

1894

95✔

1895

1✔

1896

                throw new TypeError('Invalid schema detected!');

1✔

1897

120✔

1898

19✔

1899

19✔

1900

export type {

19✔

1901

        array_mode,

19✔

1902

        specified_mode,

19✔

1903

        unique_items_mode,

19✔

1904

        MinItemsType_mode,

19✔

1905

        array_options,

19✔

1906

        array_type,

19✔

1907

        array_schema,

19✔

1908

};

19✔

1909

19✔

1910

export {

19✔

1911

        ArrayType,

19✔

1912

};

19✔

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