docusaurus-plugin-openapi-docs 4.0.0 → 4.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +14 -3
- package/lib/markdown/createCallbackMethodEndpoint.d.ts +1 -0
- package/lib/markdown/createCallbackMethodEndpoint.js +21 -0
- package/lib/markdown/createCallbacks.js +2 -2
- package/lib/markdown/createDeprecationNotice.js +5 -6
- package/lib/markdown/createMethodEndpoint.js +8 -1
- package/lib/markdown/createParamsDetails.js +10 -4
- package/lib/markdown/createSchema.js +32 -22
- package/lib/markdown/createSchema.test.js +535 -0
- package/lib/markdown/utils.d.ts +4 -0
- package/lib/openapi/openapi.js +13 -13
- package/lib/openapi/types.d.ts +3 -0
- package/lib/openapi/utils/services/OpenAPIParser.js +1 -1
- package/lib/options.js +4 -0
- package/lib/sidebars/index.js +32 -26
- package/lib/types.d.ts +9 -0
- package/package.json +6 -6
- package/src/markdown/__snapshots__/createSchema.test.ts.snap +1091 -0
- package/src/markdown/createCallbackMethodEndpoint.ts +19 -0
- package/src/markdown/createCallbacks.ts +2 -2
- package/src/markdown/createDeprecationNotice.ts +3 -2
- package/src/markdown/createMethodEndpoint.ts +8 -1
- package/src/markdown/createParamsDetails.ts +12 -5
- package/src/markdown/createSchema.test.ts +673 -0
- package/src/markdown/createSchema.ts +39 -26
- package/src/markdown/utils.ts +4 -0
- package/src/openapi/openapi.ts +1 -1
- package/src/openapi/types.ts +3 -0
- package/src/openapi/utils/services/OpenAPIParser.ts +1 -0
- package/src/options.ts +5 -0
- package/src/sidebars/index.ts +47 -40
- package/src/types.ts +11 -0
|
@@ -368,6 +368,825 @@ Array [
|
|
|
368
368
|
]
|
|
369
369
|
`;
|
|
370
370
|
|
|
371
|
+
exports[`createNodes anyOf should render oneOf within anyOf 1`] = `
|
|
372
|
+
Array [
|
|
373
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
374
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
375
|
+
<summary style={{}}>
|
|
376
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
377
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
378
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
379
|
+
</span>
|
|
380
|
+
</summary>
|
|
381
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
382
|
+
<div>
|
|
383
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
384
|
+
anyOf
|
|
385
|
+
</span>
|
|
386
|
+
<SchemaTabs>
|
|
387
|
+
<TabItem label={\\"An int or a bool\\"} value={\\"0-item-properties\\"}>
|
|
388
|
+
<div>
|
|
389
|
+
<span
|
|
390
|
+
className={\\"badge badge--info\\"}
|
|
391
|
+
style={{ marginBottom: \\"1rem\\" }}
|
|
392
|
+
>
|
|
393
|
+
oneOf
|
|
394
|
+
</span>
|
|
395
|
+
<SchemaTabs>
|
|
396
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
397
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
398
|
+
integer
|
|
399
|
+
</div>
|
|
400
|
+
</TabItem>
|
|
401
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
402
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
403
|
+
boolean
|
|
404
|
+
</div>
|
|
405
|
+
</TabItem>
|
|
406
|
+
</SchemaTabs>
|
|
407
|
+
</div>
|
|
408
|
+
</TabItem>
|
|
409
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
410
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
411
|
+
string
|
|
412
|
+
</div>
|
|
413
|
+
</TabItem>
|
|
414
|
+
</SchemaTabs>
|
|
415
|
+
</div>
|
|
416
|
+
</div>
|
|
417
|
+
</details>
|
|
418
|
+
</SchemaItem>;
|
|
419
|
+
",
|
|
420
|
+
]
|
|
421
|
+
`;
|
|
422
|
+
|
|
423
|
+
exports[`createNodes anyOf should render primitives within anyOf 1`] = `
|
|
424
|
+
Array [
|
|
425
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
426
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
427
|
+
<summary style={{}}>
|
|
428
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
429
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
430
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
431
|
+
</span>
|
|
432
|
+
</summary>
|
|
433
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
434
|
+
<div>
|
|
435
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
436
|
+
anyOf
|
|
437
|
+
</span>
|
|
438
|
+
<SchemaTabs>
|
|
439
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
440
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
441
|
+
integer
|
|
442
|
+
</div>
|
|
443
|
+
</TabItem>
|
|
444
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
445
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
446
|
+
boolean
|
|
447
|
+
</div>
|
|
448
|
+
</TabItem>
|
|
449
|
+
</SchemaTabs>
|
|
450
|
+
</div>
|
|
451
|
+
</div>
|
|
452
|
+
</details>
|
|
453
|
+
</SchemaItem>;
|
|
454
|
+
",
|
|
455
|
+
]
|
|
456
|
+
`;
|
|
457
|
+
|
|
458
|
+
exports[`createNodes discriminator should handle basic discriminator with mapping 1`] = `
|
|
459
|
+
Array [
|
|
460
|
+
"<div>
|
|
461
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
462
|
+
oneOf
|
|
463
|
+
</span>
|
|
464
|
+
<SchemaTabs>
|
|
465
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
466
|
+
<SchemaItem
|
|
467
|
+
collapsible={false}
|
|
468
|
+
name={\\"type\\"}
|
|
469
|
+
required={true}
|
|
470
|
+
schemaName={\\"string\\"}
|
|
471
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
472
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
473
|
+
></SchemaItem>
|
|
474
|
+
<SchemaItem
|
|
475
|
+
collapsible={false}
|
|
476
|
+
name={\\"propA\\"}
|
|
477
|
+
required={false}
|
|
478
|
+
schemaName={\\"string\\"}
|
|
479
|
+
qualifierMessage={undefined}
|
|
480
|
+
schema={{ type: \\"string\\" }}
|
|
481
|
+
></SchemaItem>
|
|
482
|
+
</TabItem>
|
|
483
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
484
|
+
<SchemaItem
|
|
485
|
+
collapsible={false}
|
|
486
|
+
name={\\"type\\"}
|
|
487
|
+
required={true}
|
|
488
|
+
schemaName={\\"string\\"}
|
|
489
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
490
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
491
|
+
></SchemaItem>
|
|
492
|
+
<SchemaItem
|
|
493
|
+
collapsible={false}
|
|
494
|
+
name={\\"propB\\"}
|
|
495
|
+
required={false}
|
|
496
|
+
schemaName={\\"number\\"}
|
|
497
|
+
qualifierMessage={undefined}
|
|
498
|
+
schema={{ type: \\"number\\" }}
|
|
499
|
+
></SchemaItem>
|
|
500
|
+
</TabItem>
|
|
501
|
+
</SchemaTabs>
|
|
502
|
+
</div>;
|
|
503
|
+
",
|
|
504
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
505
|
+
<div>
|
|
506
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
507
|
+
<strong
|
|
508
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
509
|
+
>
|
|
510
|
+
type
|
|
511
|
+
</strong>
|
|
512
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
513
|
+
</span>
|
|
514
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
515
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
516
|
+
</div>
|
|
517
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
518
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
519
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
520
|
+
#/definitions/TypeA
|
|
521
|
+
</div>
|
|
522
|
+
</TabItem>
|
|
523
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
524
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
525
|
+
#/definitions/TypeB
|
|
526
|
+
</div>
|
|
527
|
+
</TabItem>
|
|
528
|
+
</DiscriminatorTabs>
|
|
529
|
+
</div>
|
|
530
|
+
</div>;
|
|
531
|
+
",
|
|
532
|
+
]
|
|
533
|
+
`;
|
|
534
|
+
|
|
535
|
+
exports[`createNodes discriminator should handle basic discriminator with oneOf 1`] = `
|
|
536
|
+
Array [
|
|
537
|
+
"<div>
|
|
538
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
539
|
+
oneOf
|
|
540
|
+
</span>
|
|
541
|
+
<SchemaTabs>
|
|
542
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
543
|
+
<SchemaItem
|
|
544
|
+
collapsible={false}
|
|
545
|
+
name={\\"type\\"}
|
|
546
|
+
required={true}
|
|
547
|
+
schemaName={\\"string\\"}
|
|
548
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
549
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
550
|
+
></SchemaItem>
|
|
551
|
+
<SchemaItem
|
|
552
|
+
collapsible={false}
|
|
553
|
+
name={\\"propA\\"}
|
|
554
|
+
required={false}
|
|
555
|
+
schemaName={\\"string\\"}
|
|
556
|
+
qualifierMessage={undefined}
|
|
557
|
+
schema={{ type: \\"string\\" }}
|
|
558
|
+
></SchemaItem>
|
|
559
|
+
</TabItem>
|
|
560
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
561
|
+
<SchemaItem
|
|
562
|
+
collapsible={false}
|
|
563
|
+
name={\\"type\\"}
|
|
564
|
+
required={true}
|
|
565
|
+
schemaName={\\"string\\"}
|
|
566
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
567
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
568
|
+
></SchemaItem>
|
|
569
|
+
<SchemaItem
|
|
570
|
+
collapsible={false}
|
|
571
|
+
name={\\"propB\\"}
|
|
572
|
+
required={false}
|
|
573
|
+
schemaName={\\"number\\"}
|
|
574
|
+
qualifierMessage={undefined}
|
|
575
|
+
schema={{ type: \\"number\\" }}
|
|
576
|
+
></SchemaItem>
|
|
577
|
+
</TabItem>
|
|
578
|
+
</SchemaTabs>
|
|
579
|
+
</div>;
|
|
580
|
+
",
|
|
581
|
+
"<SchemaItem
|
|
582
|
+
collapsible={false}
|
|
583
|
+
name={\\"type\\"}
|
|
584
|
+
required={false}
|
|
585
|
+
schemaName={\\"string\\"}
|
|
586
|
+
qualifierMessage={undefined}
|
|
587
|
+
schema={{ type: \\"string\\" }}
|
|
588
|
+
></SchemaItem>;
|
|
589
|
+
",
|
|
590
|
+
]
|
|
591
|
+
`;
|
|
592
|
+
|
|
593
|
+
exports[`createNodes discriminator should handle discriminator with additional properties 1`] = `
|
|
594
|
+
Array [
|
|
595
|
+
"<div>
|
|
596
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
597
|
+
oneOf
|
|
598
|
+
</span>
|
|
599
|
+
<SchemaTabs>
|
|
600
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
601
|
+
<SchemaItem
|
|
602
|
+
collapsible={false}
|
|
603
|
+
name={\\"type\\"}
|
|
604
|
+
required={true}
|
|
605
|
+
schemaName={\\"string\\"}
|
|
606
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
607
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
608
|
+
></SchemaItem>
|
|
609
|
+
<SchemaItem
|
|
610
|
+
collapsible={false}
|
|
611
|
+
name={\\"propA\\"}
|
|
612
|
+
required={false}
|
|
613
|
+
schemaName={\\"string\\"}
|
|
614
|
+
qualifierMessage={undefined}
|
|
615
|
+
schema={{ type: \\"string\\" }}
|
|
616
|
+
></SchemaItem>
|
|
617
|
+
</TabItem>
|
|
618
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
619
|
+
<SchemaItem
|
|
620
|
+
collapsible={false}
|
|
621
|
+
name={\\"type\\"}
|
|
622
|
+
required={true}
|
|
623
|
+
schemaName={\\"string\\"}
|
|
624
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
625
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
626
|
+
></SchemaItem>
|
|
627
|
+
<SchemaItem
|
|
628
|
+
collapsible={false}
|
|
629
|
+
name={\\"propB\\"}
|
|
630
|
+
required={false}
|
|
631
|
+
schemaName={\\"number\\"}
|
|
632
|
+
qualifierMessage={undefined}
|
|
633
|
+
schema={{ type: \\"number\\" }}
|
|
634
|
+
></SchemaItem>
|
|
635
|
+
</TabItem>
|
|
636
|
+
</SchemaTabs>
|
|
637
|
+
</div>;
|
|
638
|
+
",
|
|
639
|
+
"<SchemaItem
|
|
640
|
+
collapsible={false}
|
|
641
|
+
name={\\"type\\"}
|
|
642
|
+
required={false}
|
|
643
|
+
schemaName={\\"string\\"}
|
|
644
|
+
qualifierMessage={undefined}
|
|
645
|
+
schema={{ type: \\"string\\" }}
|
|
646
|
+
></SchemaItem>;
|
|
647
|
+
",
|
|
648
|
+
]
|
|
649
|
+
`;
|
|
650
|
+
|
|
651
|
+
exports[`createNodes discriminator should handle discriminator with allOf 1`] = `
|
|
652
|
+
Array [
|
|
653
|
+
"<SchemaItem
|
|
654
|
+
collapsible={false}
|
|
655
|
+
name={\\"type\\"}
|
|
656
|
+
required={false}
|
|
657
|
+
schemaName={\\"string\\"}
|
|
658
|
+
qualifierMessage={undefined}
|
|
659
|
+
schema={{ type: \\"string\\" }}
|
|
660
|
+
></SchemaItem>;
|
|
661
|
+
",
|
|
662
|
+
"<div>
|
|
663
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
664
|
+
oneOf
|
|
665
|
+
</span>
|
|
666
|
+
<SchemaTabs>
|
|
667
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
668
|
+
<SchemaItem
|
|
669
|
+
collapsible={false}
|
|
670
|
+
name={\\"type\\"}
|
|
671
|
+
required={true}
|
|
672
|
+
schemaName={\\"string\\"}
|
|
673
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
674
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
675
|
+
></SchemaItem>
|
|
676
|
+
<SchemaItem
|
|
677
|
+
collapsible={false}
|
|
678
|
+
name={\\"propA\\"}
|
|
679
|
+
required={false}
|
|
680
|
+
schemaName={\\"string\\"}
|
|
681
|
+
qualifierMessage={undefined}
|
|
682
|
+
schema={{ type: \\"string\\" }}
|
|
683
|
+
></SchemaItem>
|
|
684
|
+
</TabItem>
|
|
685
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
686
|
+
<SchemaItem
|
|
687
|
+
collapsible={false}
|
|
688
|
+
name={\\"type\\"}
|
|
689
|
+
required={true}
|
|
690
|
+
schemaName={\\"string\\"}
|
|
691
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
692
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
693
|
+
></SchemaItem>
|
|
694
|
+
<SchemaItem
|
|
695
|
+
collapsible={false}
|
|
696
|
+
name={\\"propB\\"}
|
|
697
|
+
required={false}
|
|
698
|
+
schemaName={\\"number\\"}
|
|
699
|
+
qualifierMessage={undefined}
|
|
700
|
+
schema={{ type: \\"number\\" }}
|
|
701
|
+
></SchemaItem>
|
|
702
|
+
</TabItem>
|
|
703
|
+
</SchemaTabs>
|
|
704
|
+
</div>;
|
|
705
|
+
",
|
|
706
|
+
"<SchemaItem
|
|
707
|
+
collapsible={false}
|
|
708
|
+
name={\\"sharedProp\\"}
|
|
709
|
+
required={false}
|
|
710
|
+
schemaName={\\"string\\"}
|
|
711
|
+
qualifierMessage={undefined}
|
|
712
|
+
schema={{ type: \\"string\\" }}
|
|
713
|
+
></SchemaItem>;
|
|
714
|
+
",
|
|
715
|
+
]
|
|
716
|
+
`;
|
|
717
|
+
|
|
718
|
+
exports[`createNodes discriminator should handle discriminator with allOf and mapping 1`] = `
|
|
719
|
+
Array [
|
|
720
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
721
|
+
<div>
|
|
722
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
723
|
+
<strong
|
|
724
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
725
|
+
>
|
|
726
|
+
type
|
|
727
|
+
</strong>
|
|
728
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
729
|
+
</span>
|
|
730
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
731
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
732
|
+
</div>
|
|
733
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
734
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
735
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
736
|
+
#/definitions/TypeA
|
|
737
|
+
</div>
|
|
738
|
+
</TabItem>
|
|
739
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
740
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
741
|
+
#/definitions/TypeB
|
|
742
|
+
</div>
|
|
743
|
+
</TabItem>
|
|
744
|
+
</DiscriminatorTabs>
|
|
745
|
+
</div>
|
|
746
|
+
</div>;
|
|
747
|
+
",
|
|
748
|
+
"<div>
|
|
749
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
750
|
+
oneOf
|
|
751
|
+
</span>
|
|
752
|
+
<SchemaTabs>
|
|
753
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
754
|
+
<SchemaItem
|
|
755
|
+
collapsible={false}
|
|
756
|
+
name={\\"type\\"}
|
|
757
|
+
required={true}
|
|
758
|
+
schemaName={\\"string\\"}
|
|
759
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
760
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
761
|
+
></SchemaItem>
|
|
762
|
+
<SchemaItem
|
|
763
|
+
collapsible={false}
|
|
764
|
+
name={\\"propA\\"}
|
|
765
|
+
required={false}
|
|
766
|
+
schemaName={\\"string\\"}
|
|
767
|
+
qualifierMessage={undefined}
|
|
768
|
+
schema={{ type: \\"string\\" }}
|
|
769
|
+
></SchemaItem>
|
|
770
|
+
</TabItem>
|
|
771
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
772
|
+
<SchemaItem
|
|
773
|
+
collapsible={false}
|
|
774
|
+
name={\\"type\\"}
|
|
775
|
+
required={true}
|
|
776
|
+
schemaName={\\"string\\"}
|
|
777
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
778
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
779
|
+
></SchemaItem>
|
|
780
|
+
<SchemaItem
|
|
781
|
+
collapsible={false}
|
|
782
|
+
name={\\"propB\\"}
|
|
783
|
+
required={false}
|
|
784
|
+
schemaName={\\"number\\"}
|
|
785
|
+
qualifierMessage={undefined}
|
|
786
|
+
schema={{ type: \\"number\\" }}
|
|
787
|
+
></SchemaItem>
|
|
788
|
+
</TabItem>
|
|
789
|
+
</SchemaTabs>
|
|
790
|
+
</div>;
|
|
791
|
+
",
|
|
792
|
+
"<SchemaItem
|
|
793
|
+
collapsible={false}
|
|
794
|
+
name={\\"sharedProp\\"}
|
|
795
|
+
required={false}
|
|
796
|
+
schemaName={\\"string\\"}
|
|
797
|
+
qualifierMessage={undefined}
|
|
798
|
+
schema={{ type: \\"string\\" }}
|
|
799
|
+
></SchemaItem>;
|
|
800
|
+
",
|
|
801
|
+
]
|
|
802
|
+
`;
|
|
803
|
+
|
|
804
|
+
exports[`createNodes discriminator should handle discriminator with nested schemas 1`] = `
|
|
805
|
+
Array [
|
|
806
|
+
"<div>
|
|
807
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
808
|
+
oneOf
|
|
809
|
+
</span>
|
|
810
|
+
<SchemaTabs>
|
|
811
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
812
|
+
<SchemaItem
|
|
813
|
+
collapsible={false}
|
|
814
|
+
name={\\"type\\"}
|
|
815
|
+
required={true}
|
|
816
|
+
schemaName={\\"string\\"}
|
|
817
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
818
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
819
|
+
></SchemaItem>
|
|
820
|
+
<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
821
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
822
|
+
<summary style={{}}>
|
|
823
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
824
|
+
<strong className={\\"openapi-schema__property\\"}>nestedA</strong>
|
|
825
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
826
|
+
</span>
|
|
827
|
+
</summary>
|
|
828
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
829
|
+
<SchemaItem
|
|
830
|
+
collapsible={false}
|
|
831
|
+
name={\\"propA1\\"}
|
|
832
|
+
required={false}
|
|
833
|
+
schemaName={\\"string\\"}
|
|
834
|
+
qualifierMessage={undefined}
|
|
835
|
+
schema={{ type: \\"string\\" }}
|
|
836
|
+
></SchemaItem>
|
|
837
|
+
<SchemaItem
|
|
838
|
+
collapsible={false}
|
|
839
|
+
name={\\"propA2\\"}
|
|
840
|
+
required={false}
|
|
841
|
+
schemaName={\\"number\\"}
|
|
842
|
+
qualifierMessage={undefined}
|
|
843
|
+
schema={{ type: \\"number\\" }}
|
|
844
|
+
></SchemaItem>
|
|
845
|
+
</div>
|
|
846
|
+
</details>
|
|
847
|
+
</SchemaItem>
|
|
848
|
+
</TabItem>
|
|
849
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
850
|
+
<SchemaItem
|
|
851
|
+
collapsible={false}
|
|
852
|
+
name={\\"type\\"}
|
|
853
|
+
required={true}
|
|
854
|
+
schemaName={\\"string\\"}
|
|
855
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
856
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
857
|
+
></SchemaItem>
|
|
858
|
+
<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
859
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
860
|
+
<summary style={{}}>
|
|
861
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
862
|
+
<strong className={\\"openapi-schema__property\\"}>nestedB</strong>
|
|
863
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
864
|
+
</span>
|
|
865
|
+
</summary>
|
|
866
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
867
|
+
<SchemaItem
|
|
868
|
+
collapsible={false}
|
|
869
|
+
name={\\"propB1\\"}
|
|
870
|
+
required={false}
|
|
871
|
+
schemaName={\\"string\\"}
|
|
872
|
+
qualifierMessage={undefined}
|
|
873
|
+
schema={{ type: \\"string\\" }}
|
|
874
|
+
></SchemaItem>
|
|
875
|
+
<SchemaItem
|
|
876
|
+
collapsible={false}
|
|
877
|
+
name={\\"propB2\\"}
|
|
878
|
+
required={false}
|
|
879
|
+
schemaName={\\"boolean\\"}
|
|
880
|
+
qualifierMessage={undefined}
|
|
881
|
+
schema={{ type: \\"boolean\\" }}
|
|
882
|
+
></SchemaItem>
|
|
883
|
+
</div>
|
|
884
|
+
</details>
|
|
885
|
+
</SchemaItem>
|
|
886
|
+
</TabItem>
|
|
887
|
+
</SchemaTabs>
|
|
888
|
+
</div>;
|
|
889
|
+
",
|
|
890
|
+
"<SchemaItem
|
|
891
|
+
collapsible={false}
|
|
892
|
+
name={\\"type\\"}
|
|
893
|
+
required={false}
|
|
894
|
+
schemaName={\\"string\\"}
|
|
895
|
+
qualifierMessage={undefined}
|
|
896
|
+
schema={{ type: \\"string\\" }}
|
|
897
|
+
></SchemaItem>;
|
|
898
|
+
",
|
|
899
|
+
]
|
|
900
|
+
`;
|
|
901
|
+
|
|
902
|
+
exports[`createNodes discriminator should handle discriminator with required properties 1`] = `
|
|
903
|
+
Array [
|
|
904
|
+
"<div>
|
|
905
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
906
|
+
oneOf
|
|
907
|
+
</span>
|
|
908
|
+
<SchemaTabs>
|
|
909
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
910
|
+
<SchemaItem
|
|
911
|
+
collapsible={false}
|
|
912
|
+
name={\\"type\\"}
|
|
913
|
+
required={true}
|
|
914
|
+
schemaName={\\"string\\"}
|
|
915
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
916
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
917
|
+
></SchemaItem>
|
|
918
|
+
<SchemaItem
|
|
919
|
+
collapsible={false}
|
|
920
|
+
name={\\"propA\\"}
|
|
921
|
+
required={true}
|
|
922
|
+
schemaName={\\"string\\"}
|
|
923
|
+
qualifierMessage={undefined}
|
|
924
|
+
schema={{ type: \\"string\\" }}
|
|
925
|
+
></SchemaItem>
|
|
926
|
+
</TabItem>
|
|
927
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
928
|
+
<SchemaItem
|
|
929
|
+
collapsible={false}
|
|
930
|
+
name={\\"type\\"}
|
|
931
|
+
required={true}
|
|
932
|
+
schemaName={\\"string\\"}
|
|
933
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
934
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
935
|
+
></SchemaItem>
|
|
936
|
+
<SchemaItem
|
|
937
|
+
collapsible={false}
|
|
938
|
+
name={\\"propB\\"}
|
|
939
|
+
required={true}
|
|
940
|
+
schemaName={\\"number\\"}
|
|
941
|
+
qualifierMessage={undefined}
|
|
942
|
+
schema={{ type: \\"number\\" }}
|
|
943
|
+
></SchemaItem>
|
|
944
|
+
</TabItem>
|
|
945
|
+
</SchemaTabs>
|
|
946
|
+
</div>;
|
|
947
|
+
",
|
|
948
|
+
"<SchemaItem
|
|
949
|
+
collapsible={false}
|
|
950
|
+
name={\\"type\\"}
|
|
951
|
+
required={false}
|
|
952
|
+
schemaName={\\"string\\"}
|
|
953
|
+
qualifierMessage={undefined}
|
|
954
|
+
schema={{ type: \\"string\\" }}
|
|
955
|
+
></SchemaItem>;
|
|
956
|
+
",
|
|
957
|
+
]
|
|
958
|
+
`;
|
|
959
|
+
|
|
960
|
+
exports[`createNodes discriminator should handle discriminator with required properties and mapping 1`] = `
|
|
961
|
+
Array [
|
|
962
|
+
"<div>
|
|
963
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
964
|
+
oneOf
|
|
965
|
+
</span>
|
|
966
|
+
<SchemaTabs>
|
|
967
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
968
|
+
<SchemaItem
|
|
969
|
+
collapsible={false}
|
|
970
|
+
name={\\"type\\"}
|
|
971
|
+
required={true}
|
|
972
|
+
schemaName={\\"string\\"}
|
|
973
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
974
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
975
|
+
></SchemaItem>
|
|
976
|
+
<SchemaItem
|
|
977
|
+
collapsible={false}
|
|
978
|
+
name={\\"propA\\"}
|
|
979
|
+
required={true}
|
|
980
|
+
schemaName={\\"string\\"}
|
|
981
|
+
qualifierMessage={undefined}
|
|
982
|
+
schema={{ type: \\"string\\" }}
|
|
983
|
+
></SchemaItem>
|
|
984
|
+
</TabItem>
|
|
985
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
986
|
+
<SchemaItem
|
|
987
|
+
collapsible={false}
|
|
988
|
+
name={\\"type\\"}
|
|
989
|
+
required={true}
|
|
990
|
+
schemaName={\\"string\\"}
|
|
991
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
992
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
993
|
+
></SchemaItem>
|
|
994
|
+
<SchemaItem
|
|
995
|
+
collapsible={false}
|
|
996
|
+
name={\\"propB\\"}
|
|
997
|
+
required={true}
|
|
998
|
+
schemaName={\\"number\\"}
|
|
999
|
+
qualifierMessage={undefined}
|
|
1000
|
+
schema={{ type: \\"number\\" }}
|
|
1001
|
+
></SchemaItem>
|
|
1002
|
+
</TabItem>
|
|
1003
|
+
</SchemaTabs>
|
|
1004
|
+
</div>;
|
|
1005
|
+
",
|
|
1006
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
1007
|
+
<div>
|
|
1008
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1009
|
+
<strong
|
|
1010
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
1011
|
+
>
|
|
1012
|
+
type
|
|
1013
|
+
</strong>
|
|
1014
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
1015
|
+
</span>
|
|
1016
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
1017
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
1018
|
+
</div>
|
|
1019
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
1020
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
1021
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1022
|
+
#/definitions/TypeA
|
|
1023
|
+
</div>
|
|
1024
|
+
</TabItem>
|
|
1025
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
1026
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1027
|
+
#/definitions/TypeB
|
|
1028
|
+
</div>
|
|
1029
|
+
</TabItem>
|
|
1030
|
+
</DiscriminatorTabs>
|
|
1031
|
+
</div>
|
|
1032
|
+
</div>;
|
|
1033
|
+
",
|
|
1034
|
+
]
|
|
1035
|
+
`;
|
|
1036
|
+
|
|
1037
|
+
exports[`createNodes discriminator should handle discriminator with shared properties 1`] = `
|
|
1038
|
+
Array [
|
|
1039
|
+
"<div>
|
|
1040
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1041
|
+
oneOf
|
|
1042
|
+
</span>
|
|
1043
|
+
<SchemaTabs>
|
|
1044
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1045
|
+
<SchemaItem
|
|
1046
|
+
collapsible={false}
|
|
1047
|
+
name={\\"type\\"}
|
|
1048
|
+
required={true}
|
|
1049
|
+
schemaName={\\"string\\"}
|
|
1050
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
1051
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
1052
|
+
></SchemaItem>
|
|
1053
|
+
<SchemaItem
|
|
1054
|
+
collapsible={false}
|
|
1055
|
+
name={\\"propA\\"}
|
|
1056
|
+
required={false}
|
|
1057
|
+
schemaName={\\"string\\"}
|
|
1058
|
+
qualifierMessage={undefined}
|
|
1059
|
+
schema={{ type: \\"string\\" }}
|
|
1060
|
+
></SchemaItem>
|
|
1061
|
+
</TabItem>
|
|
1062
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1063
|
+
<SchemaItem
|
|
1064
|
+
collapsible={false}
|
|
1065
|
+
name={\\"type\\"}
|
|
1066
|
+
required={true}
|
|
1067
|
+
schemaName={\\"string\\"}
|
|
1068
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
1069
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
1070
|
+
></SchemaItem>
|
|
1071
|
+
<SchemaItem
|
|
1072
|
+
collapsible={false}
|
|
1073
|
+
name={\\"propB\\"}
|
|
1074
|
+
required={false}
|
|
1075
|
+
schemaName={\\"number\\"}
|
|
1076
|
+
qualifierMessage={undefined}
|
|
1077
|
+
schema={{ type: \\"number\\" }}
|
|
1078
|
+
></SchemaItem>
|
|
1079
|
+
</TabItem>
|
|
1080
|
+
</SchemaTabs>
|
|
1081
|
+
</div>;
|
|
1082
|
+
",
|
|
1083
|
+
"<SchemaItem
|
|
1084
|
+
collapsible={false}
|
|
1085
|
+
name={\\"type\\"}
|
|
1086
|
+
required={false}
|
|
1087
|
+
schemaName={\\"string\\"}
|
|
1088
|
+
qualifierMessage={undefined}
|
|
1089
|
+
schema={{ type: \\"string\\" }}
|
|
1090
|
+
></SchemaItem>;
|
|
1091
|
+
",
|
|
1092
|
+
"<SchemaItem
|
|
1093
|
+
collapsible={false}
|
|
1094
|
+
name={\\"sharedProp\\"}
|
|
1095
|
+
required={false}
|
|
1096
|
+
schemaName={\\"string\\"}
|
|
1097
|
+
qualifierMessage={undefined}
|
|
1098
|
+
schema={{ type: \\"string\\" }}
|
|
1099
|
+
></SchemaItem>;
|
|
1100
|
+
",
|
|
1101
|
+
]
|
|
1102
|
+
`;
|
|
1103
|
+
|
|
1104
|
+
exports[`createNodes discriminator should handle discriminator with shared properties and mapping 1`] = `
|
|
1105
|
+
Array [
|
|
1106
|
+
"<div>
|
|
1107
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1108
|
+
oneOf
|
|
1109
|
+
</span>
|
|
1110
|
+
<SchemaTabs>
|
|
1111
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1112
|
+
<SchemaItem
|
|
1113
|
+
collapsible={false}
|
|
1114
|
+
name={\\"type\\"}
|
|
1115
|
+
required={true}
|
|
1116
|
+
schemaName={\\"string\\"}
|
|
1117
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
1118
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
1119
|
+
></SchemaItem>
|
|
1120
|
+
<SchemaItem
|
|
1121
|
+
collapsible={false}
|
|
1122
|
+
name={\\"propA\\"}
|
|
1123
|
+
required={false}
|
|
1124
|
+
schemaName={\\"string\\"}
|
|
1125
|
+
qualifierMessage={undefined}
|
|
1126
|
+
schema={{ type: \\"string\\" }}
|
|
1127
|
+
></SchemaItem>
|
|
1128
|
+
</TabItem>
|
|
1129
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1130
|
+
<SchemaItem
|
|
1131
|
+
collapsible={false}
|
|
1132
|
+
name={\\"type\\"}
|
|
1133
|
+
required={true}
|
|
1134
|
+
schemaName={\\"string\\"}
|
|
1135
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
1136
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
1137
|
+
></SchemaItem>
|
|
1138
|
+
<SchemaItem
|
|
1139
|
+
collapsible={false}
|
|
1140
|
+
name={\\"propB\\"}
|
|
1141
|
+
required={false}
|
|
1142
|
+
schemaName={\\"number\\"}
|
|
1143
|
+
qualifierMessage={undefined}
|
|
1144
|
+
schema={{ type: \\"number\\" }}
|
|
1145
|
+
></SchemaItem>
|
|
1146
|
+
</TabItem>
|
|
1147
|
+
</SchemaTabs>
|
|
1148
|
+
</div>;
|
|
1149
|
+
",
|
|
1150
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
1151
|
+
<div>
|
|
1152
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1153
|
+
<strong
|
|
1154
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
1155
|
+
>
|
|
1156
|
+
type
|
|
1157
|
+
</strong>
|
|
1158
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
1159
|
+
</span>
|
|
1160
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
1161
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
1162
|
+
</div>
|
|
1163
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
1164
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
1165
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1166
|
+
#/definitions/TypeA
|
|
1167
|
+
</div>
|
|
1168
|
+
</TabItem>
|
|
1169
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
1170
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1171
|
+
#/definitions/TypeB
|
|
1172
|
+
</div>
|
|
1173
|
+
</TabItem>
|
|
1174
|
+
</DiscriminatorTabs>
|
|
1175
|
+
</div>
|
|
1176
|
+
</div>;
|
|
1177
|
+
",
|
|
1178
|
+
"<SchemaItem
|
|
1179
|
+
collapsible={false}
|
|
1180
|
+
name={\\"sharedProp\\"}
|
|
1181
|
+
required={false}
|
|
1182
|
+
schemaName={\\"string\\"}
|
|
1183
|
+
qualifierMessage={undefined}
|
|
1184
|
+
schema={{ type: \\"string\\" }}
|
|
1185
|
+
></SchemaItem>;
|
|
1186
|
+
",
|
|
1187
|
+
]
|
|
1188
|
+
`;
|
|
1189
|
+
|
|
371
1190
|
exports[`createNodes oneOf should create readable MODs for oneOf primitive properties 1`] = `
|
|
372
1191
|
Array [
|
|
373
1192
|
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
@@ -457,3 +1276,275 @@ Array [
|
|
|
457
1276
|
",
|
|
458
1277
|
]
|
|
459
1278
|
`;
|
|
1279
|
+
|
|
1280
|
+
exports[`createNodes oneOf should handle nested oneOf clauses 1`] = `
|
|
1281
|
+
Array [
|
|
1282
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
1283
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
1284
|
+
<summary style={{}}>
|
|
1285
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1286
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
1287
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
1288
|
+
</span>
|
|
1289
|
+
</summary>
|
|
1290
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
1291
|
+
<div>
|
|
1292
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1293
|
+
oneOf
|
|
1294
|
+
</span>
|
|
1295
|
+
<SchemaTabs>
|
|
1296
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1297
|
+
<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
1298
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
1299
|
+
<summary style={{}}>
|
|
1300
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1301
|
+
<strong className={\\"openapi-schema__property\\"}>
|
|
1302
|
+
nestedOneOfProp
|
|
1303
|
+
</strong>
|
|
1304
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
1305
|
+
</span>
|
|
1306
|
+
</summary>
|
|
1307
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
1308
|
+
<div>
|
|
1309
|
+
<span
|
|
1310
|
+
className={\\"badge badge--info\\"}
|
|
1311
|
+
style={{ marginBottom: \\"1rem\\" }}
|
|
1312
|
+
>
|
|
1313
|
+
oneOf
|
|
1314
|
+
</span>
|
|
1315
|
+
<SchemaTabs>
|
|
1316
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1317
|
+
<div
|
|
1318
|
+
style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}
|
|
1319
|
+
>
|
|
1320
|
+
string
|
|
1321
|
+
</div>
|
|
1322
|
+
</TabItem>
|
|
1323
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1324
|
+
<div
|
|
1325
|
+
style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}
|
|
1326
|
+
>
|
|
1327
|
+
number
|
|
1328
|
+
</div>
|
|
1329
|
+
</TabItem>
|
|
1330
|
+
</SchemaTabs>
|
|
1331
|
+
</div>
|
|
1332
|
+
</div>
|
|
1333
|
+
</details>
|
|
1334
|
+
</SchemaItem>
|
|
1335
|
+
</TabItem>
|
|
1336
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1337
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1338
|
+
boolean
|
|
1339
|
+
</div>
|
|
1340
|
+
</TabItem>
|
|
1341
|
+
</SchemaTabs>
|
|
1342
|
+
</div>
|
|
1343
|
+
</div>
|
|
1344
|
+
</details>
|
|
1345
|
+
</SchemaItem>;
|
|
1346
|
+
",
|
|
1347
|
+
]
|
|
1348
|
+
`;
|
|
1349
|
+
|
|
1350
|
+
exports[`createNodes oneOf should handle oneOf with complex types 1`] = `
|
|
1351
|
+
Array [
|
|
1352
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
1353
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
1354
|
+
<summary style={{}}>
|
|
1355
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1356
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
1357
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
1358
|
+
</span>
|
|
1359
|
+
</summary>
|
|
1360
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
1361
|
+
<div>
|
|
1362
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1363
|
+
oneOf
|
|
1364
|
+
</span>
|
|
1365
|
+
<SchemaTabs>
|
|
1366
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1367
|
+
<SchemaItem
|
|
1368
|
+
collapsible={false}
|
|
1369
|
+
name={\\"objectProp\\"}
|
|
1370
|
+
required={false}
|
|
1371
|
+
schemaName={\\"string\\"}
|
|
1372
|
+
qualifierMessage={undefined}
|
|
1373
|
+
schema={{ type: \\"string\\" }}
|
|
1374
|
+
></SchemaItem>
|
|
1375
|
+
</TabItem>
|
|
1376
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1377
|
+
<li>
|
|
1378
|
+
<div
|
|
1379
|
+
style={{
|
|
1380
|
+
fontSize: \\"var(--ifm-code-font-size)\\",
|
|
1381
|
+
opacity: \\"0.6\\",
|
|
1382
|
+
marginLeft: \\"-.5rem\\",
|
|
1383
|
+
paddingBottom: \\".5rem\\",
|
|
1384
|
+
}}
|
|
1385
|
+
>
|
|
1386
|
+
Array [
|
|
1387
|
+
</div>
|
|
1388
|
+
</li>
|
|
1389
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1390
|
+
number
|
|
1391
|
+
</div>
|
|
1392
|
+
<li>
|
|
1393
|
+
<div
|
|
1394
|
+
style={{
|
|
1395
|
+
fontSize: \\"var(--ifm-code-font-size)\\",
|
|
1396
|
+
opacity: \\"0.6\\",
|
|
1397
|
+
marginLeft: \\"-.5rem\\",
|
|
1398
|
+
}}
|
|
1399
|
+
>
|
|
1400
|
+
]
|
|
1401
|
+
</div>
|
|
1402
|
+
</li>
|
|
1403
|
+
</TabItem>
|
|
1404
|
+
</SchemaTabs>
|
|
1405
|
+
</div>
|
|
1406
|
+
</div>
|
|
1407
|
+
</details>
|
|
1408
|
+
</SchemaItem>;
|
|
1409
|
+
",
|
|
1410
|
+
]
|
|
1411
|
+
`;
|
|
1412
|
+
|
|
1413
|
+
exports[`createNodes oneOf should handle oneOf with different primitive types 1`] = `
|
|
1414
|
+
Array [
|
|
1415
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
1416
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
1417
|
+
<summary style={{}}>
|
|
1418
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1419
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
1420
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
1421
|
+
</span>
|
|
1422
|
+
</summary>
|
|
1423
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
1424
|
+
<div>
|
|
1425
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1426
|
+
oneOf
|
|
1427
|
+
</span>
|
|
1428
|
+
<SchemaTabs>
|
|
1429
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1430
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1431
|
+
string
|
|
1432
|
+
</div>
|
|
1433
|
+
</TabItem>
|
|
1434
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1435
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1436
|
+
number
|
|
1437
|
+
</div>
|
|
1438
|
+
</TabItem>
|
|
1439
|
+
<TabItem label={\\"MOD3\\"} value={\\"2-item-properties\\"}>
|
|
1440
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
1441
|
+
boolean
|
|
1442
|
+
</div>
|
|
1443
|
+
</TabItem>
|
|
1444
|
+
</SchemaTabs>
|
|
1445
|
+
</div>
|
|
1446
|
+
</div>
|
|
1447
|
+
</details>
|
|
1448
|
+
</SchemaItem>;
|
|
1449
|
+
",
|
|
1450
|
+
]
|
|
1451
|
+
`;
|
|
1452
|
+
|
|
1453
|
+
exports[`createNodes oneOf should handle oneOf with required properties 1`] = `
|
|
1454
|
+
Array [
|
|
1455
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
1456
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
1457
|
+
<summary style={{}}>
|
|
1458
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1459
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
1460
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
1461
|
+
</span>
|
|
1462
|
+
</summary>
|
|
1463
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
1464
|
+
<div>
|
|
1465
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1466
|
+
oneOf
|
|
1467
|
+
</span>
|
|
1468
|
+
<SchemaTabs>
|
|
1469
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1470
|
+
<SchemaItem
|
|
1471
|
+
collapsible={false}
|
|
1472
|
+
name={\\"requiredPropA\\"}
|
|
1473
|
+
required={true}
|
|
1474
|
+
schemaName={\\"string\\"}
|
|
1475
|
+
qualifierMessage={undefined}
|
|
1476
|
+
schema={{ type: \\"string\\" }}
|
|
1477
|
+
></SchemaItem>
|
|
1478
|
+
</TabItem>
|
|
1479
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1480
|
+
<SchemaItem
|
|
1481
|
+
collapsible={false}
|
|
1482
|
+
name={\\"requiredPropB\\"}
|
|
1483
|
+
required={true}
|
|
1484
|
+
schemaName={\\"number\\"}
|
|
1485
|
+
qualifierMessage={undefined}
|
|
1486
|
+
schema={{ type: \\"number\\" }}
|
|
1487
|
+
></SchemaItem>
|
|
1488
|
+
</TabItem>
|
|
1489
|
+
</SchemaTabs>
|
|
1490
|
+
</div>
|
|
1491
|
+
</div>
|
|
1492
|
+
</details>
|
|
1493
|
+
</SchemaItem>;
|
|
1494
|
+
",
|
|
1495
|
+
]
|
|
1496
|
+
`;
|
|
1497
|
+
|
|
1498
|
+
exports[`createNodes oneOf should handle oneOf with shared properties 1`] = `
|
|
1499
|
+
Array [
|
|
1500
|
+
"<SchemaItem
|
|
1501
|
+
collapsible={false}
|
|
1502
|
+
name={\\"sharedProp\\"}
|
|
1503
|
+
required={false}
|
|
1504
|
+
schemaName={\\"string\\"}
|
|
1505
|
+
qualifierMessage={undefined}
|
|
1506
|
+
schema={{ type: \\"string\\" }}
|
|
1507
|
+
></SchemaItem>;
|
|
1508
|
+
",
|
|
1509
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
1510
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
1511
|
+
<summary style={{}}>
|
|
1512
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
1513
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
1514
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
1515
|
+
</span>
|
|
1516
|
+
</summary>
|
|
1517
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
1518
|
+
<div>
|
|
1519
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
1520
|
+
oneOf
|
|
1521
|
+
</span>
|
|
1522
|
+
<SchemaTabs>
|
|
1523
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
1524
|
+
<SchemaItem
|
|
1525
|
+
collapsible={false}
|
|
1526
|
+
name={\\"specificPropA\\"}
|
|
1527
|
+
required={false}
|
|
1528
|
+
schemaName={\\"string\\"}
|
|
1529
|
+
qualifierMessage={undefined}
|
|
1530
|
+
schema={{ type: \\"string\\" }}
|
|
1531
|
+
></SchemaItem>
|
|
1532
|
+
</TabItem>
|
|
1533
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
1534
|
+
<SchemaItem
|
|
1535
|
+
collapsible={false}
|
|
1536
|
+
name={\\"specificPropB\\"}
|
|
1537
|
+
required={false}
|
|
1538
|
+
schemaName={\\"number\\"}
|
|
1539
|
+
qualifierMessage={undefined}
|
|
1540
|
+
schema={{ type: \\"number\\" }}
|
|
1541
|
+
></SchemaItem>
|
|
1542
|
+
</TabItem>
|
|
1543
|
+
</SchemaTabs>
|
|
1544
|
+
</div>
|
|
1545
|
+
</div>
|
|
1546
|
+
</details>
|
|
1547
|
+
</SchemaItem>;
|
|
1548
|
+
",
|
|
1549
|
+
]
|
|
1550
|
+
`;
|