Repository: glideapps/quicktype
Branch: master
Commit: 41950205609a
Files: 777
Total size: 13.8 MB
Directory structure:
gitextract_n0pnx0cj/
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── config.yml
│ │ └── feature_request.md
│ ├── dependabot.yml
│ ├── pull_request_template.md
│ └── workflows/
│ ├── master.yaml
│ ├── setup/
│ │ └── action.yaml
│ └── test-pr.yaml
├── .gitignore
├── .nvmrc
├── .vscode/
│ ├── extensions.json
│ ├── launch.json
│ └── settings.json
├── FAQ.md
├── LICENSE
├── README.md
├── biome.json
├── data/
│ └── lib.d.ts
├── doc/
│ ├── CustomRenderer.md
│ ├── PostmanCollection.schema
│ ├── Templates.md
│ └── Transformers.md
├── package.json
├── packages/
│ ├── quicktype-core/
│ │ ├── env.sh
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── Annotation.ts
│ │ │ ├── ConvenienceRenderer.ts
│ │ │ ├── CycleBreaker.ts
│ │ │ ├── DateTime.ts
│ │ │ ├── DeclarationIR.ts
│ │ │ ├── EncodedMarkovChain.ts
│ │ │ ├── GatherNames.ts
│ │ │ ├── Graph.ts
│ │ │ ├── GraphRewriting.ts
│ │ │ ├── Inference.ts
│ │ │ ├── MakeTransformations.ts
│ │ │ ├── MarkovChain.ts
│ │ │ ├── Messages.ts
│ │ │ ├── Naming.ts
│ │ │ ├── Renderer.ts
│ │ │ ├── RendererOptions/
│ │ │ │ ├── index.ts
│ │ │ │ └── types.ts
│ │ │ ├── Run.ts
│ │ │ ├── Source.ts
│ │ │ ├── TargetLanguage.ts
│ │ │ ├── Transformers.ts
│ │ │ ├── Type/
│ │ │ │ ├── ProvenanceTypeAttributeKind.ts
│ │ │ │ ├── TransformedStringType.ts
│ │ │ │ ├── Type.ts
│ │ │ │ ├── TypeBuilder.ts
│ │ │ │ ├── TypeBuilderUtils.ts
│ │ │ │ ├── TypeGraph.ts
│ │ │ │ ├── TypeGraphUtils.ts
│ │ │ │ ├── TypeRef.ts
│ │ │ │ ├── TypeUtils.ts
│ │ │ │ └── index.ts
│ │ │ ├── UnifyClasses.ts
│ │ │ ├── UnionBuilder.ts
│ │ │ ├── attributes/
│ │ │ │ ├── AccessorNames.ts
│ │ │ │ ├── Constraints.ts
│ │ │ │ ├── Description.ts
│ │ │ │ ├── EnumValues.ts
│ │ │ │ ├── StringTypes.ts
│ │ │ │ ├── TypeAttributes.ts
│ │ │ │ ├── TypeNames.ts
│ │ │ │ └── URIAttributes.ts
│ │ │ ├── index.ts
│ │ │ ├── input/
│ │ │ │ ├── CompressedJSON.ts
│ │ │ │ ├── FetchingJSONSchemaStore.ts
│ │ │ │ ├── Inference.ts
│ │ │ │ ├── Inputs.ts
│ │ │ │ ├── JSONSchemaInput.ts
│ │ │ │ ├── JSONSchemaStore.ts
│ │ │ │ ├── PathElement.ts
│ │ │ │ ├── PostmanCollection.ts
│ │ │ │ └── io/
│ │ │ │ ├── $fetch.ci.ts
│ │ │ │ ├── $fetch.ts
│ │ │ │ ├── NodeIO.ts
│ │ │ │ └── get-stream/
│ │ │ │ ├── buffer-stream.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── license
│ │ │ ├── language/
│ │ │ │ ├── All.ts
│ │ │ │ ├── CJSON/
│ │ │ │ │ ├── CJSONRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── CPlusPlus/
│ │ │ │ │ ├── CPlusPlusRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── CSharp/
│ │ │ │ │ ├── CSharpRenderer.ts
│ │ │ │ │ ├── NewtonSoftCSharpRenderer.ts
│ │ │ │ │ ├── SystemTextJsonCSharpRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Crystal/
│ │ │ │ │ ├── CrystalRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Dart/
│ │ │ │ │ ├── DartRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Elixir/
│ │ │ │ │ ├── ElixirRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Elm/
│ │ │ │ │ ├── ElmRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Golang/
│ │ │ │ │ ├── GolangRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Haskell/
│ │ │ │ │ ├── HaskellRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── JSONSchema/
│ │ │ │ │ ├── JSONSchemaRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Java/
│ │ │ │ │ ├── DateTimeProvider.ts
│ │ │ │ │ ├── JavaJacksonRenderer.ts
│ │ │ │ │ ├── JavaRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── JavaScript/
│ │ │ │ │ ├── JavaScriptRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ ├── unicodeMaps.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── JavaScriptPropTypes/
│ │ │ │ │ ├── JavaScriptPropTypesRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── language.ts
│ │ │ │ ├── Kotlin/
│ │ │ │ │ ├── KotlinJacksonRenderer.ts
│ │ │ │ │ ├── KotlinKlaxonRenderer.ts
│ │ │ │ │ ├── KotlinRenderer.ts
│ │ │ │ │ ├── KotlinXRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Objective-C/
│ │ │ │ │ ├── ObjectiveCRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Php/
│ │ │ │ │ ├── PhpRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Pike/
│ │ │ │ │ ├── PikeRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Python/
│ │ │ │ │ ├── JSONPythonRenderer.ts
│ │ │ │ │ ├── PythonRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Ruby/
│ │ │ │ │ ├── RubyRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Rust/
│ │ │ │ │ ├── RustRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Scala3/
│ │ │ │ │ ├── CirceRenderer.ts
│ │ │ │ │ ├── Scala3Renderer.ts
│ │ │ │ │ ├── UpickleRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Smithy4s/
│ │ │ │ │ ├── Smithy4sRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── Swift/
│ │ │ │ │ ├── SwiftRenderer.ts
│ │ │ │ │ ├── constants.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── TypeScriptEffectSchema/
│ │ │ │ │ ├── TypeScriptEffectSchemaRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── language.ts
│ │ │ │ ├── TypeScriptFlow/
│ │ │ │ │ ├── FlowRenderer.ts
│ │ │ │ │ ├── TypeScriptFlowBaseRenderer.ts
│ │ │ │ │ ├── TypeScriptRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── language.ts
│ │ │ │ │ └── utils.ts
│ │ │ │ ├── TypeScriptZod/
│ │ │ │ │ ├── TypeScriptZodRenderer.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── language.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── options.types.ts
│ │ │ │ └── types.ts
│ │ │ ├── rewrites/
│ │ │ │ ├── CombineClasses.ts
│ │ │ │ ├── ExpandStrings.ts
│ │ │ │ ├── FlattenStrings.ts
│ │ │ │ ├── FlattenUnions.ts
│ │ │ │ ├── InferMaps.ts
│ │ │ │ ├── ReplaceObjectType.ts
│ │ │ │ └── ResolveIntersections.ts
│ │ │ ├── support/
│ │ │ │ ├── Acronyms.const.ts
│ │ │ │ ├── Acronyms.ts
│ │ │ │ ├── Chance.ts
│ │ │ │ ├── Comments.ts
│ │ │ │ ├── Converters.ts
│ │ │ │ ├── Strings.ts
│ │ │ │ └── Support.ts
│ │ │ └── types.ts
│ │ └── tsconfig.json
│ ├── quicktype-graphql-input/
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── GraphQLSchema.ts
│ │ │ └── index.ts
│ │ └── tsconfig.json
│ ├── quicktype-typescript-input/
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── EncodedDefaultTypeScriptLibrary.ts
│ │ │ └── index.ts
│ │ └── tsconfig.json
│ └── quicktype-vscode/
│ ├── .gitignore
│ ├── .vscodeignore
│ ├── LICENSE
│ ├── README.md
│ ├── package.json
│ ├── quicktype-23.0.122.vsix
│ ├── src/
│ │ └── extension.ts
│ └── tsconfig.json
├── script/
│ ├── dev
│ ├── dev.ps1
│ ├── homebrew-update.sh
│ ├── make-encoded-markov-chain.sh
│ ├── make-encoded-ts-lib.sh
│ ├── patch-npm-version.ts
│ ├── publish.sh
│ ├── quickesttype
│ ├── quicktype
│ ├── test
│ └── watch
├── src/
│ ├── CompressedJSONFromStream.ts
│ ├── GraphQLIntrospection.ts
│ ├── TypeSource.ts
│ ├── URLGrammar.ts
│ └── index.ts
├── test/
│ ├── .gitignore
│ ├── acronyms.txt
│ ├── awesome-json-datasets
│ ├── buildkite.ts
│ ├── compare-all.sh
│ ├── fixtures/
│ │ ├── cjson/
│ │ │ └── main.c
│ │ ├── cplusplus/
│ │ │ ├── Generators.hpp
│ │ │ └── main.cpp
│ │ ├── crystal/
│ │ │ └── main.cr
│ │ ├── csharp/
│ │ │ ├── .gitignore
│ │ │ ├── .vscode/
│ │ │ │ ├── launch.json
│ │ │ │ └── tasks.json
│ │ │ ├── Program.cs
│ │ │ └── test.csproj
│ │ ├── csharp-SystemTextJson/
│ │ │ ├── .gitignore
│ │ │ ├── .vscode/
│ │ │ │ ├── launch.json
│ │ │ │ └── tasks.json
│ │ │ ├── Program.cs
│ │ │ └── test.csproj
│ │ ├── dart/
│ │ │ └── parser.dart
│ │ ├── elixir/
│ │ │ ├── .gitignore
│ │ │ ├── main.exs
│ │ │ └── mix.exs
│ │ ├── elm/
│ │ │ ├── .gitignore
│ │ │ ├── Main.elm
│ │ │ ├── elm-package.json
│ │ │ └── runner.js
│ │ ├── flow/
│ │ │ ├── .flowconfig
│ │ │ └── main.js
│ │ ├── golang/
│ │ │ └── main.go
│ │ ├── haskell/
│ │ │ ├── .gitignore
│ │ │ ├── Main.hs
│ │ │ ├── QuickType.hs
│ │ │ ├── Setup.hs
│ │ │ ├── package.yaml
│ │ │ └── stack.yaml
│ │ ├── java/
│ │ │ ├── .classpath
│ │ │ ├── .project
│ │ │ ├── .settings/
│ │ │ │ ├── org.eclipse.jdt.core.prefs
│ │ │ │ └── org.eclipse.m2e.core.prefs
│ │ │ ├── pom.xml
│ │ │ └── src/
│ │ │ └── main/
│ │ │ └── java/
│ │ │ └── io/
│ │ │ └── quicktype/
│ │ │ ├── App.java
│ │ │ ├── Converter.java
│ │ │ └── TopLevel.java
│ │ ├── java-lombok/
│ │ │ ├── .classpath
│ │ │ ├── .project
│ │ │ ├── .settings/
│ │ │ │ ├── org.eclipse.jdt.core.prefs
│ │ │ │ └── org.eclipse.m2e.core.prefs
│ │ │ ├── pom.xml
│ │ │ └── src/
│ │ │ └── main/
│ │ │ └── java/
│ │ │ └── io/
│ │ │ └── quicktype/
│ │ │ ├── App.java
│ │ │ ├── Converter.java
│ │ │ └── TopLevel.java
│ │ ├── javascript/
│ │ │ └── main.js
│ │ ├── javascript-prop-types/
│ │ │ ├── main.js
│ │ │ └── package.json
│ │ ├── kotlin/
│ │ │ ├── .gitignore
│ │ │ ├── TopLevel.kt
│ │ │ ├── build.sh
│ │ │ ├── klaxon-3.0.1.jar
│ │ │ ├── main.kt
│ │ │ ├── run.sh
│ │ │ └── sample.json
│ │ ├── kotlin-jackson/
│ │ │ ├── .gitignore
│ │ │ ├── build.sh
│ │ │ ├── jackson-annotations-2.9.0.jar
│ │ │ ├── jackson-core-2.9.7.jar
│ │ │ ├── jackson-databind-2.9.7.jar
│ │ │ ├── jackson-module-kotlin-2.9.7.jar
│ │ │ ├── main.kt
│ │ │ ├── run.sh
│ │ │ └── runfixture.sh
│ │ ├── objective-c/
│ │ │ ├── ObjectiveCFixture.xcodeproj/
│ │ │ │ ├── project.pbxproj
│ │ │ │ ├── project.xcworkspace/
│ │ │ │ │ └── contents.xcworkspacedata
│ │ │ │ └── xcuserdata/
│ │ │ │ └── david.xcuserdatad/
│ │ │ │ └── xcschemes/
│ │ │ │ ├── ObjectiveCFixture.xcscheme
│ │ │ │ └── xcschememanagement.plist
│ │ │ ├── QTTopLevel.h
│ │ │ ├── QTTopLevel.m
│ │ │ ├── main.m
│ │ │ └── sample.json
│ │ ├── php/
│ │ │ └── main.php
│ │ ├── pike/
│ │ │ └── main.pike
│ │ ├── python/
│ │ │ ├── main.py
│ │ │ └── run.sh
│ │ ├── ruby/
│ │ │ ├── .gitignore
│ │ │ ├── Gemfile
│ │ │ └── main.rb
│ │ ├── rust/
│ │ │ ├── Cargo.toml
│ │ │ └── main.rs
│ │ ├── scala3/
│ │ │ ├── .gitignore
│ │ │ ├── circe.scala
│ │ │ ├── rename/
│ │ │ │ ├── debug.scala
│ │ │ │ └── upickle.scala
│ │ │ └── run.sh
│ │ ├── swift/
│ │ │ ├── .gitignore
│ │ │ ├── SwiftFixture.xcodeproj/
│ │ │ │ └── project.pbxproj
│ │ │ ├── main.swift
│ │ │ └── quicktype.swift
│ │ ├── typescript/
│ │ │ ├── main.ts
│ │ │ └── tsconfig.json
│ │ ├── typescript-effect-schema/
│ │ │ ├── main.ts
│ │ │ ├── package.json
│ │ │ └── tsconfig.json
│ │ └── typescript-zod/
│ │ ├── main.ts
│ │ ├── package.json
│ │ └── tsconfig.json
│ ├── fixtures.ts
│ ├── generate-json.py
│ ├── generate-markov-corpus.py
│ ├── inputs/
│ │ ├── graphql/
│ │ │ ├── github.gqlschema
│ │ │ ├── github1.1.json
│ │ │ ├── github1.graphql
│ │ │ ├── github2.1.json
│ │ │ ├── github2.graphql
│ │ │ ├── github3.1.json
│ │ │ ├── github3.graphql
│ │ │ ├── github4.1.json
│ │ │ ├── github4.graphql
│ │ │ ├── github5.1.json
│ │ │ ├── github5.2.json
│ │ │ ├── github5.graphql
│ │ │ ├── github6.1.json
│ │ │ ├── github6.graphql
│ │ │ ├── github7.1.json
│ │ │ ├── github7.graphql
│ │ │ ├── github8.1.json
│ │ │ ├── github8.graphql
│ │ │ ├── github9.1.json
│ │ │ └── github9.graphql
│ │ ├── json/
│ │ │ ├── misc/
│ │ │ │ ├── 00c36.json
│ │ │ │ ├── 00ec5.json
│ │ │ │ ├── 010b1.json
│ │ │ │ ├── 016af.json
│ │ │ │ ├── 033b1.json
│ │ │ │ ├── 050b0.json
│ │ │ │ ├── 06bee.json
│ │ │ │ ├── 07540.json
│ │ │ │ ├── 0779f.json
│ │ │ │ ├── 07c75.json
│ │ │ │ ├── 09f54.json
│ │ │ │ ├── 0a358.json
│ │ │ │ ├── 0a91a.json
│ │ │ │ ├── 0b91a.json
│ │ │ │ ├── 0cffa.json
│ │ │ │ ├── 0e0c2.json
│ │ │ │ ├── 0fecf.json
│ │ │ │ ├── 10be4.json
│ │ │ │ ├── 112b5.json
│ │ │ │ ├── 127a1.json
│ │ │ │ ├── 13d8d.json
│ │ │ │ ├── 14d38.json
│ │ │ │ ├── 167d6.json
│ │ │ │ ├── 16bc5.json
│ │ │ │ ├── 176f1.json
│ │ │ │ ├── 1a7f5.json
│ │ │ │ ├── 1b28c.json
│ │ │ │ ├── 1b409.json
│ │ │ │ ├── 2465e.json
│ │ │ │ ├── 24f52.json
│ │ │ │ ├── 262f0.json
│ │ │ │ ├── 26b49.json
│ │ │ │ ├── 26c9c.json
│ │ │ │ ├── 27332.json
│ │ │ │ ├── 29f47.json
│ │ │ │ ├── 2d4e2.json
│ │ │ │ ├── 2df80.json
│ │ │ │ ├── 31189.json
│ │ │ │ ├── 32431.json
│ │ │ │ ├── 32d5c.json
│ │ │ │ ├── 337ed.json
│ │ │ │ ├── 33d2e.json
│ │ │ │ ├── 34702.json
│ │ │ │ ├── 3536b.json
│ │ │ │ ├── 3659d.json
│ │ │ │ ├── 36d5d.json
│ │ │ │ ├── 3a6b3.json
│ │ │ │ ├── 3e9a3.json
│ │ │ │ ├── 3f1ce.json
│ │ │ │ ├── 421d4.json
│ │ │ │ ├── 437e7.json
│ │ │ │ ├── 43970.json
│ │ │ │ ├── 43eaf.json
│ │ │ │ ├── 458db.json
│ │ │ │ ├── 4961a.json
│ │ │ │ ├── 4a0d7.json
│ │ │ │ ├── 4a455.json
│ │ │ │ ├── 4c547.json
│ │ │ │ ├── 4d6fb.json
│ │ │ │ ├── 4e336.json
│ │ │ │ ├── 54147.json
│ │ │ │ ├── 54d32.json
│ │ │ │ ├── 570ec.json
│ │ │ │ ├── 5dd0d.json
│ │ │ │ ├── 5eae5.json
│ │ │ │ ├── 5eb20.json
│ │ │ │ ├── 5f3a1.json
│ │ │ │ ├── 5f7fe.json
│ │ │ │ ├── 617e8.json
│ │ │ │ ├── 61b66.json
│ │ │ │ ├── 6260a.json
│ │ │ │ ├── 65dec.json
│ │ │ │ ├── 66121.json
│ │ │ │ ├── 6617c.json
│ │ │ │ ├── 67c03.json
│ │ │ │ ├── 68c30.json
│ │ │ │ ├── 6c155.json
│ │ │ │ ├── 6de06.json
│ │ │ │ ├── 6dec6.json
│ │ │ │ ├── 6eb00.json
│ │ │ │ ├── 70c77.json
│ │ │ │ ├── 734ad.json
│ │ │ │ ├── 75912.json
│ │ │ │ ├── 7681c.json
│ │ │ │ ├── 76ae1.json
│ │ │ │ ├── 77392.json
│ │ │ │ ├── 7d397.json
│ │ │ │ ├── 7d722.json
│ │ │ │ ├── 7df41.json
│ │ │ │ ├── 7dfa6.json
│ │ │ │ ├── 7eb30.json
│ │ │ │ ├── 7f568.json
│ │ │ │ ├── 7fbfb.json
│ │ │ │ ├── 80aff.json
│ │ │ │ ├── 82509.json
│ │ │ │ ├── 8592b.json
│ │ │ │ ├── 88130.json
│ │ │ │ ├── 8a62c.json
│ │ │ │ ├── 908db.json
│ │ │ │ ├── 9617f.json
│ │ │ │ ├── 96f7c.json
│ │ │ │ ├── 9847b.json
│ │ │ │ ├── 9929c.json
│ │ │ │ ├── 996bd.json
│ │ │ │ ├── 9a503.json
│ │ │ │ ├── 9ac3b.json
│ │ │ │ ├── 9eed5.json
│ │ │ │ ├── a0496.json
│ │ │ │ ├── a1eca.json
│ │ │ │ ├── a3d8c.json
│ │ │ │ ├── a45b0.json
│ │ │ │ ├── a71df.json
│ │ │ │ ├── a9691.json
│ │ │ │ ├── ab0d1.json
│ │ │ │ ├── abb4b.json
│ │ │ │ ├── ac944.json
│ │ │ │ ├── ad8be.json
│ │ │ │ ├── ae7f0.json
│ │ │ │ ├── ae9ca.json
│ │ │ │ ├── af2d1.json
│ │ │ │ ├── b4865.json
│ │ │ │ ├── b6f2c.json
│ │ │ │ ├── b6fe5.json
│ │ │ │ ├── b9f64.json
│ │ │ │ ├── bb1ec.json
│ │ │ │ ├── be234.json
│ │ │ │ ├── c0356.json
│ │ │ │ ├── c0a3a.json
│ │ │ │ ├── c3303.json
│ │ │ │ ├── c6cfd.json
│ │ │ │ ├── c8c7e.json
│ │ │ │ ├── cb0cc.json
│ │ │ │ ├── cb81e.json
│ │ │ │ ├── ccd18.json
│ │ │ │ ├── cd238.json
│ │ │ │ ├── cd463.json
│ │ │ │ ├── cda6c.json
│ │ │ │ ├── cf0d8.json
│ │ │ │ ├── cfbce.json
│ │ │ │ ├── d0908.json
│ │ │ │ ├── d23d5.json
│ │ │ │ ├── dbfb3.json
│ │ │ │ ├── dc44f.json
│ │ │ │ ├── dd1ce.json
│ │ │ │ ├── dec3a.json
│ │ │ │ ├── df957.json
│ │ │ │ ├── e0ac7.json
│ │ │ │ ├── e2915.json
│ │ │ │ ├── e2a58.json
│ │ │ │ ├── e324e.json
│ │ │ │ ├── e53b5.json
│ │ │ │ ├── e64a0.json
│ │ │ │ ├── e8a0b.json
│ │ │ │ ├── e8b04.json
│ │ │ │ ├── ed095.json
│ │ │ │ ├── f22f5.json
│ │ │ │ ├── f3139.json
│ │ │ │ ├── f3edf.json
│ │ │ │ ├── f466a.json
│ │ │ │ ├── f6a65.json
│ │ │ │ ├── f74d5.json
│ │ │ │ ├── f82d9.json
│ │ │ │ ├── f974d.json
│ │ │ │ ├── faff5.json
│ │ │ │ ├── fcca3.json
│ │ │ │ └── fd329.json
│ │ │ ├── priority/
│ │ │ │ ├── blns-object.json
│ │ │ │ ├── bug427.json
│ │ │ │ ├── bug790.json
│ │ │ │ ├── bug855-short.json
│ │ │ │ ├── bug863.json
│ │ │ │ ├── coin-pairs.json
│ │ │ │ ├── combinations1.json
│ │ │ │ ├── combinations2.json
│ │ │ │ ├── combinations3.json
│ │ │ │ ├── combinations4.json
│ │ │ │ ├── combined-enum.json
│ │ │ │ ├── direct-recursive.json
│ │ │ │ ├── empty-enum.json
│ │ │ │ ├── identifiers.json
│ │ │ │ ├── keywords.json
│ │ │ │ ├── list.json
│ │ │ │ ├── name-style.json
│ │ │ │ ├── nbl-stats.json
│ │ │ │ ├── no-classes.json
│ │ │ │ ├── nst-test-suite.json
│ │ │ │ ├── number-map.json
│ │ │ │ ├── optional-union.json
│ │ │ │ ├── recursive.json
│ │ │ │ ├── simple-identifiers.json
│ │ │ │ ├── union-constructor-clash.json
│ │ │ │ ├── unions.json
│ │ │ │ └── url.json
│ │ │ └── samples/
│ │ │ ├── bitcoin-block.json
│ │ │ ├── getting-started.json
│ │ │ ├── github-events.json
│ │ │ ├── kitchen-sink.json
│ │ │ ├── null-safe.json
│ │ │ ├── pokedex.json
│ │ │ ├── reddit.json
│ │ │ ├── simple-object.json
│ │ │ ├── spotify-album.json
│ │ │ ├── us-avg-temperatures.json
│ │ │ └── us-senators.json
│ │ ├── schema/
│ │ │ ├── a/
│ │ │ │ └── test2.json
│ │ │ ├── accessors.1.json
│ │ │ ├── accessors.schema
│ │ │ ├── any.1.json
│ │ │ ├── any.2.json
│ │ │ ├── any.3.json
│ │ │ ├── any.schema
│ │ │ ├── b/
│ │ │ │ └── test3.json
│ │ │ ├── bool-string.1.fail.bool-string.json
│ │ │ ├── bool-string.1.json
│ │ │ ├── bool-string.1.out.bool-string.json
│ │ │ ├── bool-string.2.json
│ │ │ ├── bool-string.3.json
│ │ │ ├── bool-string.schema
│ │ │ ├── camelCase.schema
│ │ │ ├── camelCase1.json
│ │ │ ├── class-map-union.1.fail.union.json
│ │ │ ├── class-map-union.1.json
│ │ │ ├── class-map-union.2.json
│ │ │ ├── class-map-union.3.json
│ │ │ ├── class-map-union.4.json
│ │ │ ├── class-map-union.schema
│ │ │ ├── class-with-additional.1.fail.union.json
│ │ │ ├── class-with-additional.1.json
│ │ │ ├── class-with-additional.schema
│ │ │ ├── constructor.1.json
│ │ │ ├── constructor.schema
│ │ │ ├── cut-enum.1.json
│ │ │ ├── cut-enum.schema
│ │ │ ├── date-time-or-string.schema
│ │ │ ├── date-time.1.fail.date-time.json
│ │ │ ├── date-time.1.json
│ │ │ ├── date-time.schema
│ │ │ ├── description-with-double-quotes.json
│ │ │ ├── description-with-double-quotes.schema
│ │ │ ├── description.1.json
│ │ │ ├── description.2.json
│ │ │ ├── description.schema
│ │ │ ├── direct-union.1.json
│ │ │ ├── direct-union.schema
│ │ │ ├── enum-with-null.1.json
│ │ │ ├── enum-with-null.2.json
│ │ │ ├── enum-with-null.schema
│ │ │ ├── enum-with-values.schema
│ │ │ ├── enum.1.fail.enum.json
│ │ │ ├── enum.1.json
│ │ │ ├── enum.2.json
│ │ │ ├── enum.3.json
│ │ │ ├── enum.4.json
│ │ │ ├── enum.schema
│ │ │ ├── go-schema-pattern-properties.1.fail.json
│ │ │ ├── go-schema-pattern-properties.1.json
│ │ │ ├── go-schema-pattern-properties.schema
│ │ │ ├── id-no-address.1.json
│ │ │ ├── id-no-address.schema
│ │ │ ├── id-root.1.json
│ │ │ ├── id-root.schema
│ │ │ ├── implicit-all-of.1.json
│ │ │ ├── implicit-all-of.schema
│ │ │ ├── implicit-class-array-union.1.fail.union.json
│ │ │ ├── implicit-class-array-union.1.json
│ │ │ ├── implicit-class-array-union.2.fail.union.json
│ │ │ ├── implicit-class-array-union.2.json
│ │ │ ├── implicit-class-array-union.3.json
│ │ │ ├── implicit-class-array-union.4.json
│ │ │ ├── implicit-class-array-union.5.json
│ │ │ ├── implicit-class-array-union.schema
│ │ │ ├── implicit-one-of.1.json
│ │ │ ├── implicit-one-of.2.json
│ │ │ ├── implicit-one-of.schema
│ │ │ ├── integer-float-union.1.json
│ │ │ ├── integer-float-union.2.json
│ │ │ ├── integer-float-union.schema
│ │ │ ├── integer-string.1.fail.integer-string.json
│ │ │ ├── integer-string.1.json
│ │ │ ├── integer-string.1.out.integer-string.json
│ │ │ ├── integer-string.2.json
│ │ │ ├── integer-string.3.json
│ │ │ ├── integer-string.schema
│ │ │ ├── intersection-nested.schema
│ │ │ ├── intersection.1.fail.no-defaults.json
│ │ │ ├── intersection.1.json
│ │ │ ├── intersection.2.json
│ │ │ ├── intersection.schema
│ │ │ ├── keyword-enum.1.json
│ │ │ ├── keyword-enum.schema
│ │ │ ├── keyword-unions.1.json
│ │ │ ├── keyword-unions.2.json
│ │ │ ├── keyword-unions.schema
│ │ │ ├── list.1.json
│ │ │ ├── list.2.json
│ │ │ ├── list.3.json
│ │ │ ├── list.schema
│ │ │ ├── minmax-integer.1.fail.minmaxInteger.json
│ │ │ ├── minmax-integer.1.json
│ │ │ ├── minmax-integer.schema
│ │ │ ├── minmax.1.fail.minmax.json
│ │ │ ├── minmax.1.json
│ │ │ ├── minmax.schema
│ │ │ ├── minmaxlength.1.fail.minmaxlength.json
│ │ │ ├── minmaxlength.1.json
│ │ │ ├── minmaxlength.schema
│ │ │ ├── multi-type-enum.1.fail.union.json
│ │ │ ├── multi-type-enum.1.json
│ │ │ ├── multi-type-enum.2.json
│ │ │ ├── multi-type-enum.3.json
│ │ │ ├── multi-type-enum.schema
│ │ │ ├── mutually-recursive.1.json
│ │ │ ├── mutually-recursive.2.json
│ │ │ ├── mutually-recursive.schema
│ │ │ ├── non-standard-ref.1.json
│ │ │ ├── non-standard-ref.schema
│ │ │ ├── object-type-required.1.json
│ │ │ ├── object-type-required.2.json
│ │ │ ├── object-type-required.schema
│ │ │ ├── optional-any.1.json
│ │ │ ├── optional-any.2.json
│ │ │ ├── optional-any.schema
│ │ │ ├── pattern.1.fail.pattern.json
│ │ │ ├── pattern.1.json
│ │ │ ├── pattern.schema
│ │ │ ├── postman-collection.1.json
│ │ │ ├── postman-collection.2.json
│ │ │ ├── postman-collection.schema
│ │ │ ├── ref-id-files.1.json
│ │ │ ├── ref-id-files.schema
│ │ │ ├── ref-remote.1.json
│ │ │ ├── ref-remote.2.json
│ │ │ ├── ref-remote.3.json
│ │ │ ├── ref-remote.schema
│ │ │ ├── renaming-bug.schema
│ │ │ ├── required-draft3.schema
│ │ │ ├── required-non-properties.1.json
│ │ │ ├── required-non-properties.schema
│ │ │ ├── required.1.fail.no-defaults.json
│ │ │ ├── required.schema
│ │ │ ├── simple-ref.1.json
│ │ │ ├── simple-ref.1.ref
│ │ │ ├── simple-ref.2.json
│ │ │ ├── simple-ref.3.json
│ │ │ ├── simple-ref.schema
│ │ │ ├── strict-optional.1.fail.strict-optional.json
│ │ │ ├── strict-optional.schema
│ │ │ ├── top-level-enum.1.json
│ │ │ ├── top-level-enum.schema
│ │ │ ├── top-level-primitive.schema
│ │ │ ├── tuple.1.json
│ │ │ ├── tuple.schema
│ │ │ ├── union-list.1.json
│ │ │ ├── union-list.2.json
│ │ │ ├── union-list.3.json
│ │ │ ├── union-list.schema
│ │ │ ├── union.1.json
│ │ │ ├── union.schema
│ │ │ ├── uuid.1.fail.uuid.json
│ │ │ ├── uuid.1.json
│ │ │ ├── uuid.2.json
│ │ │ ├── uuid.schema
│ │ │ └── vega-lite.schema
│ │ ├── spotify-api/
│ │ │ ├── Album/
│ │ │ │ ├── She's So Unusual.json
│ │ │ │ └── The Best of Keane (Deluxe Edition).json
│ │ │ ├── Artist.json
│ │ │ ├── Playlist.json
│ │ │ ├── Track.json
│ │ │ └── UserProfile.json
│ │ └── urls/
│ │ └── github.json
│ ├── keywords.py
│ ├── keywords.txt
│ ├── languages.ts
│ ├── lib/
│ │ ├── deepEquals.ts
│ │ └── multicore.ts
│ ├── make-keyword-tests.sh
│ ├── run-for-all.sh
│ ├── test-awesome.py
│ ├── test.ts
│ ├── tsconfig.json
│ └── utils.ts
└── tsconfig.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
*.sh text eol=lf
scripts/* eol=lf
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
github: quicktype
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: New Bug Report
about: Use this template for reporting new bugs.
title: "[BUG]: bug description here"
labels: bug
---
## Issue Type
## Context (Environment, Version, Language)
Input Format:
Output Language:
CLI, npm, or app.quicktype.io:
Version:
## Description
## Input Data
## Expected Behaviour / Output
## Current Behaviour / Output
## Steps to Reproduce
1.
2.
3.
4.
## Possible Solution
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: false
# contact_links:
# - name: GitHub Community Support
# url: https://github.com/orgs/community/discussions
# about: Please ask and answer questions here.
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature Request
about: Use this template for requesting new features.
title: "[FEATURE]: feature description here"
labels: enhancement
---
## Context (Input, Language)
Input Format:
Output Language:
## Description
## Current Behaviour / Output
## Proposed Behaviour / Output
## Solution
## Alternatives
## Context
================================================
FILE: .github/dependabot.yml
================================================
# To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options:
# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
version: 2
updates:
- package-ecosystem: "npm"
directory: "/"
schedule:
interval: "weekly"
================================================
FILE: .github/pull_request_template.md
================================================
## Description
## Related Issue
## Motivation and Context
## Previous Behaviour / Output
## New Behaviour / Output
## How Has This Been Tested?
## Screenshots (if appropriate):
================================================
FILE: .github/workflows/master.yaml
================================================
name: Build and Release
on:
push:
branches:
- master
jobs:
publish:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v3
- uses: ./.github/workflows/setup
env:
PUBLISH: true
- run: npm run pub
env:
NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
VSCE_TOKEN: ${{ secrets.VSCE_TOKEN }}
================================================
FILE: .github/workflows/setup/action.yaml
================================================
name: Setup
description: Setup common stuff for jobs
runs:
using: "composite"
steps:
- name: Setup environment
shell: bash
run: |
NODE_VERSION=$(cat .nvmrc | xargs)
echo "node_version=$NODE_VERSION" >> $GITHUB_ENV
# Create keys to control caching
BASE_KEY="${{ runner.os }}"
NODE_MODULES_KEY="$BASE_KEY-${{ hashFiles('package-lock.json') }}"
echo "node_modules_key=$NODE_MODULES_KEY" >> $GITHUB_ENV
SOURCE_KEY="$NODE_MODULES_KEY-${{ hashFiles('src/**') }}"
echo "source_key=$SOURCE_KEY" >> $GITHUB_ENV
- name: Setup node
uses: actions/setup-node@v4
with:
node-version: ${{ env.node_version }}
cache: npm
registry-url: "https://registry.npmjs.org"
- name: Install Dependencies
run: npm ci
shell: bash
- name: Build Packages
run: npm run build
shell: bash
================================================
FILE: .github/workflows/test-pr.yaml
================================================
name: Test PR
on:
pull_request:
branches:
- master
- "release/**"
jobs:
build:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v3
- uses: ./.github/workflows/setup
test:
needs: [build]
runs-on: ${{ matrix.runs-on }}
strategy:
fail-fast: true
matrix:
fixture:
- typescript,typescript-zod,typescript-effect-schema
- javascript,schema-javascript
- golang,schema-golang
- cjson,schema-cjson
- cplusplus,schema-cplusplus
- flow,schema-flow
- java,schema-java
- python,schema-python
- haskell,schema-haskell
- csharp,schema-csharp,schema-json-csharp,graphql-csharp,csharp-SystemTextJson
- json-ts-csharp
- dart,schema-dart
# - swift,schema-swift # pgp issue
- javascript-prop-types
- ruby
- php
- scala3,schema-scala3
- elixir,schema-elixir,graphql-elixir
# Partially working
# - schema-typescript # TODO Unify with typescript once fixed
# Implementation is too outdated to test in GitHub Actions
# - elm,schema-elm
# Language is too niche / obscure to test easily on ubuntu-22.04
# - pike,schema-pike
# Not yet started
# @schani can you help me understand this fixture?
# It looks like it tests 13+ languages?
# - graphql
# Never tested?
# - crystal
runs-on: [ubuntu-22.04]
include:
# Rust is very slow, so we use a larger runner
- fixture: rust,schema-rust
runs-on: ubuntu-latest-16-cores
# Kotlin is also slow
- fixture: kotlin,schema-kotlin,kotlin-jackson,schema-kotlin-jackson
runs-on: ubuntu-latest-16-cores
# - fixture: objective-c # segfault on compiled test cmd
# runs-on: macos-latest
name: ${{ matrix.fixture }}
steps:
- uses: actions/checkout@v3
- uses: ./.github/workflows/setup
- name: Setup PHP
if: ${{ contains(matrix.fixture, 'php') }}
uses: shivammathur/setup-php@v2
with:
php-version: "8.2"
- name: Setup Dart
if: ${{ contains(matrix.fixture, 'dart') }}
uses: dart-lang/setup-dart@v1.3
with:
sdk: 2.14.4
- name: Setup Swift
if: ${{ contains(matrix.fixture, 'swift') }}
uses: swift-actions/setup-swift@v1
with:
swift-version: "5.7.2"
- name: Install Ruby
uses: ruby/setup-ruby@v1
if: ${{ contains(matrix.fixture, 'ruby') }}
with:
ruby-version: "3.2.0"
- name: Setup .NET Core SDK
if: ${{ contains(matrix.fixture, 'csharp') }}
uses: actions/setup-dotnet@v3
with:
dotnet-version: 6
- name: Install Rust
if: ${{ contains(matrix.fixture, 'rust') }}
uses: actions-rs/toolchain@v1
with:
toolchain: stable
- name: Install Elm
if: ${{ contains(matrix.fixture, 'elm') }}
run: |
curl -L -o elm.gz https://github.com/elm/compiler/releases/download/0.19.1/binary-for-linux-64-bit.gz
gunzip elm.gz
chmod +x elm
sudo mv elm /usr/local/bin/
- name: Install Haskell
if: ${{ contains(matrix.fixture, 'haskell') }}
run: |
if ! command -v stack > /dev/null 2>&1; then
curl -sL "https://get.haskellstack.org/" | sh
fi
- name: Install Python 3.7
if: ${{ contains(matrix.fixture, 'python') }}
uses: actions/setup-python@v4
with:
python-version: 3.7
- name: Install Python Dependencies
if: ${{ contains(matrix.fixture, 'python') }}
run: |
pip3.7 install mypy python-dateutil types-python-dateutil
- name: Install flow
if: ${{ contains(matrix.fixture, 'flow') }}
run: |
npm install -g flow-bin@0.66.0 flow-remove-types@1.2.3
- name: Install Java
if: ${{ matrix.fixture == 'java,schema-java' || contains(matrix.fixture, 'kotlin') }}
uses: actions/setup-java@v3
with:
java-version: "11"
distribution: "adopt"
- name: Install Maven
if: ${{ matrix.fixture == 'java,schema-java' }}
uses: stCarolas/setup-maven@v4.5
with:
maven-version: 3.8.2
- name: Install Kotlin
if: ${{ contains(matrix.fixture, 'kotlin') }}
uses: fwilhe2/setup-kotlin@main
- name: Install go
if: ${{ contains(matrix.fixture, 'golang') }}
uses: actions/setup-go@v3
with:
go-version: 1.15
- name: Install C
if: ${{ contains(matrix.fixture, 'cjson') }}
run: |
sudo apt-get update
sudo apt-get -y install build-essential valgrind
- name: Install C++
if: ${{ contains(matrix.fixture, 'cplusplus') }}
run: |
sudo apt-get update
sudo apt-get -y install libboost-all-dev software-properties-common g++ --assume-yes
- name: Install scala
if: ${{ contains(matrix.fixture, 'scala3') }}
uses: VirtusLab/scala-cli-setup@main
- run: echo '@main def hello() = println("We need this spam print statement for bloop to exit correctly...")' | scala-cli _
if: ${{ contains(matrix.fixture, 'scala3') }}
- name: Install Elixir
if: ${{ contains(matrix.fixture, 'elixir') }}
uses: erlef/setup-beam@v1
with:
elixir-version: "1.15.7"
otp-version: "26.0"
- run: QUICKTEST=true FIXTURE=${{ matrix.fixture }} npm test
test-complete:
if: ${{ cancelled() || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'failure') }}
needs: test
runs-on: ubuntu-22.04
steps:
- run: |
echo "Some workflows have failed!"
exit 1
================================================
FILE: .gitignore
================================================
node_modules/
/test/awesome-json-results/
npm-debug.log
yarn.lock
shrinkwrap.yaml
test/csharp/QuickType.cs
test/golang/quicktype.go
test/golang/schema.json
test/golang/schema-from-schema.json
test/elm/elm-stuff/
test/elm/elm.js
test/elm/QuickType.elm
test/fixtures/cjson/cJSON.*
test/fixtures/cjson/hashtable.*
test/fixtures/cjson/list.*
test/fixtures/rust/target
test/fixtures/java/target
test/fixtures/java-lombok/target
packages/*/dist
packages/*/node_modules
*.log
/test/elm/libsysconfcpus/
/test/runs
test/fixtures/cplusplus/json.hpp
/dist
test/fixtures/objective-c/quicktype
*.xcbkptlist
*.xcuserstate
/bin
/.node-persist
/.vs
.idea
.DS_Store
/.bsp
.metals
.scala-build
================================================
FILE: .nvmrc
================================================
v22.14.0
================================================
FILE: .vscode/extensions.json
================================================
{
// See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": ["esbenp.prettier-vscode", "dbaeumer.vscode-eslint"]
}
================================================
FILE: .vscode/launch.json
================================================
{
// Use IntelliSense to learn about possible Node.js debug attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "quicktype",
"type": "node",
"request": "launch",
"program": "${workspaceRoot}/node_modules/ts-node/dist/_bin.js",
"runtimeArgs": ["--nolazy"],
"args": [
"--project",
"src/cli/tsconfig.json",
"src/cli/index.ts",
"--lang",
"dart",
"--src-lang",
"json",
"./test/inputs/json/priority/blns-object.json"
],
"cwd": "${workspaceRoot}",
"protocol": "inspector"
},
{
"name": "test",
"type": "node",
"request": "launch",
"program": "${workspaceRoot}/node_modules/ts-node/dist/_bin.js",
"args": ["--project", "test/tsconfig.json", "test/test.ts"],
"cwd": "${workspaceRoot}",
"protocol": "inspector",
"env": {
"CPUs": "1",
"FIXTURE": "golang"
}
}
]
}
================================================
FILE: .vscode/settings.json
================================================
{
// Place your settings in this file to overwrite default and user settings.
"editor.formatOnSave": true,
"search.exclude": {
"**/.git": true,
"**/node_modules": true,
"**/bower_components": true,
"**/tmp": true,
"output": true,
"**/obj": true,
"**/bin": true,
"test/inputs": true,
"test/runs": true,
"app/build": true,
"elm-stuff": true,
"dist": true
},
"explorer.excludeGitIgnore": false,
"java.configuration.updateBuildConfiguration": "automatic",
"files.associations": {
"*.schema": "jsonc"
},
"[json]": {
"editor.defaultFormatter": "biomejs.biome",
"editor.wordWrap": "on",
"editor.insertSpaces": true,
"editor.tabSize": 4,
"editor.detectIndentation": false
},
"[jsonc]": {
"editor.defaultFormatter": "esbenp.prettier-vscode",
"editor.wordWrap": "on",
"editor.insertSpaces": true,
"editor.tabSize": 4,
"editor.detectIndentation": false
}
}
================================================
FILE: FAQ.md
================================================
# The quicktype FAQ
- [What is this?](#what-is-this)
- [How does this work?](#how-does-this-work)
- [How do I use this with my code?](#how-do-i-use-this-with-my-code)
- [No code appears when I paste my JSON](#why-does-quicktype-complain-about-my-json)
- [I think I found a bug!](#i-think-i-found-a-bug)
- [When will you support my favorite language?](#when-will-you-support-my-favorite-language)
- [Why do my types have weird names?](#why-do-my-types-have-weird-names)
- [I'd like the output to be a little different.](#id-like-the-output-to-be-a-little-different)
- [Am I allowed to use the generated code in my software?](#am-i-allowed-to-use-the-generated-code-in-my-software)
- [This map/dictionary should be a class!](#this-mapdictionary-should-be-a-class)
- [This class should be a map/dictionary!](#this-class-should-be-a-mapdictionary)
- [Where can I learn more about JSON Schema?](#where-can-i-learn-more-about-json-schema)
- [I'd like to customize the output for my particular application.](#id-like-to-customize-the-output-for-my-particular-application)
- [How can I control the property order in JSON Schema?](#how-can-i-control-the-property-order-in-json-schema)
- [quicktype is awesome, I'd like to support it!](#quicktype-is-awesome-id-like-to-support-it)
- [How is this different from other JSON converters?](#how-is-quicktype-different-from-other-json-converters)
## What is this?
[quicktype](https://app.quicktype.io) produces nice types and JSON (de)serializers for many programming languages. It can infer types from JSON but also takes types from JSON Schema, TypeScript, and GraphQL.
## How does this work?
You paste JSON on the left, and code appears on the right. [This video](https://www.youtube.com/watch?v=19bMU7jZ27w) gives a quick demonstration.
## How is this different from other JSON converters?
`quicktype` is superior to other JSON converters in many important ways:
- **Type inference**: quicktype infers optionals, dates, UUIDs, enums, integers, and unions. It also infers maps (versus objects) using a Markov chain.
- **Careful naming**: quicktype’s naming system creates nice, legal, unique names for types and properties, handling reserved words and tricky corner cases (e.g. `{ “”: “this is legal”, “null”: “so is this”, "1;DROP TABLE users”: “and this" }`).
- **Heterogeneous data**: JSON data is often heterogenous. quicktype infers this, and creates union types in languages that support them, or synthetic union types in languages that don’t (e.g. try quicktyping `[0, “zero”]` as Swift and Go).
- **Type unification**. This works across multiple samples, so you can quicktype a directory of API data, for example, and unify types across all responses (e.g. you’ll get just one `Customer` type, even if customer data occurs in many samples). You can also provide multiple samples for the same type for better coverage.
- **Marshalling code**: In addition to types, quicktype generates functions for marshalling your types to and from JSON.
- Supports dynamic languages: quicktype can add dynamic typechecks for JavaScript, TypeScript, Flow, Python, and Ruby.
- **Convenient CLI**: Run `quicktype https://blockchain.info/latestblock -o LatestBlock.ts` to quicktype a Bitcoin API in TypeScript.
- **Client-side**: [The web version of quicktype](https://app.quicktype.io/) runs on the client, so servers never see your data (most JSON converters send your JSON to their server)
- **Typed input**: Feed quicktype TypeScript or JSON Schema instead of JSON for better control over generated types.
- **Code quality**: quicktype emits clean code
## How do I use this with my code?
The generated code has comments at the start with a short code sample that shows how to convert a JSON string to instances of the generated types. You can also go the other way, which is very easy, too, but you'll have to look at the generated code to see how it works.
## No code appears when I paste my JSON
This is probably because your JSON is invalid. The most common issues we're seeing are
- Trailing commas in arrays and objects: `[1, 2, 3]` is valid JSON, while `[1, 2, 3,]` is not.
- Unquoted property keys in objects: `{ "name": "Mark" }` is valid JSON, while `{ name: "Mark" }` is not.
- Comments: JSON does not support comments.
If you're unsure whether your JSON is valid, please use [JSONLint](https://jsonlint.com).
## I think I found a bug!
Please [file an issue on GitHub](https://github.com/quicktype/quicktype/issues). Give as much context as you can so that we can reproduce it. Assume we know nothing about what you're trying to do (because we don't).
## When will you support my favorite language?
Please check whether there is [a pull request](https://github.com/quicktype/quicktype/pulls) that adds support for your language. If there is, please consider helping it along. If there isn't, please consider contributing one.
## Why do my types have weird names?
Sometimes quicktype has trouble giving names to your types. There are a couple of causes for this:
- The name quicktype would like to give to your type conflicts with a name that's already used in the target language, such as `String` in C#.
- Two or more types in your data have the same name.
- A type has so many potential names that quicktype can't find a commonality between them.
If you're using JSON Schema, you can use the `title` property to give a type a name that quicktype tries hard to use.
## I'd like the output to be a little different.
Check out the "Language" and "Other" tabs in the options panel. What you're looking for might just be there:
If it isn't, then depending on your coding skills, you might be able to [customize the output](https://blog.quicktype.io/customizing-quicktype/).
## Am I allowed to use the generated code in my software?
Yes, there are no intellectual property restrictions on the code that quicktype generates.
## This map/dictionary should be a class!
quicktype has [advanced heuristics](https://blog.quicktype.io/markov/) to decide whether a JSON object should be represented by a class or a map, but sometimes it gets it wrong. If it generates a map, but you'd rather have a class, you can disable map detection in the options panel:
## This class should be a map/dictionary!
quicktype has [advanced heuristics](https://blog.quicktype.io/markov/) to decide whether a JSON object should be represented by a class or a map, but sometimes it gets it wrong. If it generates a class, but you need a map, first make sure that you have the "Detect maps" option set in the options panel. Also, check that all properties in the object have the same exact type because quicktype only makes a map if that's the case. If that still doesn't do it, you have two options:
- Duplicate some of the properties and/or change the property names to look more random.
- Output JSON Schema, modify it to produce a map, and then use the schema as the input to quicktype.
## Where can I learn more about JSON Schema?
The [JSON Schema homepage](http://json-schema.org) contains many links and resources.
## I'd like to customize the output for my particular application.
We have [a blog post](https://blog.quicktype.io/customizing-quicktype/) on that very topic.
## How can I control the property order in JSON Schema?
There is a custom schema field `quicktypePropertyOrder` which can be used to specify the order of properties for quicktype.
For example:
```json
...
"Location": {
"quicktypePropertyOrder": [ "latitude", "longitude" ],
"type": "object",
"properties": {
"latitude": {
"type": "number",
"description": "The latitude component of the location",
"example": -32.204754
},
...
},
"required": [ "latitude", "longitude" ]
},
...
```
## quicktype is awesome, I'd like to support it!
There are many ways you can support quicktype:
- Tell all your friends about it! Show it around, tweet about it, write a blog post, present it at a lightning talk.
- quicktype is open source - please contribute! We need documentation at least as much as code, so you don't need strong coding skills to make an impact. If you do, we have [lots of open issues](https://github.com/quicktype/quicktype/issues) that need resolving, almost all of our target languages can be improved, and there are many, many programming languages that quicktype doesn't support yet. Talk to us [on Slack](http://slack.quicktype.io) if you're interested - we're always happy to help.
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================

[](https://badge.fury.io/js/quicktype)

`quicktype` generates strongly-typed models and serializers from JSON, JSON Schema, TypeScript, and [GraphQL queries](https://blog.quicktype.io/graphql-with-quicktype/), making it a breeze to work with JSON type-safely in many programming languages.
- [Try `quicktype` in your browser](https://app.quicktype.io).
- Read ['A first look at quicktype'](http://blog.quicktype.io/first-look/) for more introduction.
- If you have any questions, check out the [FAQ](FAQ.md) first.
### Supported Inputs
| JSON | JSON API URLs | [JSON Schema](https://app.quicktype.io/#s=coordinate) |
| ---- | ------------- | ----------------------------------------------------- |
| TypeScript | GraphQL queries |
| ---------- | --------------- |
### Target Languages
| [Ruby](https://app.quicktype.io/#l=ruby) | [JavaScript](https://app.quicktype.io/#l=js) | [Flow](https://app.quicktype.io/#l=flow) | [Rust](https://app.quicktype.io/#l=rust) | [Kotlin](https://app.quicktype.io/#l=kotlin) |
| ---------------------------------------- | -------------------------------------------- | ---------------------------------------- | ---------------------------------------- | -------------------------------------------- |
| [Dart](https://app.quicktype.io/#l=dart) | [Python](https://app.quicktype.io/#l=python) | [C#](https://app.quicktype.io/#l=cs) | [Go](https://app.quicktype.io/#l=go) | [C++](https://app.quicktype.io/#l=cpp) |
| ---------------------------------------- | -------------------------------------------- | ------------------------------------ | ------------------------------------ | -------------------------------------- |
| [Java](https://app.quicktype.io/#l=java) | [Scala](https://app.quicktype.io/#l=scala3) | [TypeScript](https://app.quicktype.io/#l=ts) | [Swift](https://app.quicktype.io/#l=swift) | [Objective-C](https://app.quicktype.io/#l=objc) | [Elm](https://app.quicktype.io/#l=elm) |
| ---------------------------------------- | ------------------------------------------- | -------------------------------------------- | ------------------------------------------ | ----------------------------------------------- | -------------------------------------- |
| [JSON Schema](https://app.quicktype.io/#l=schema) | [Pike](https://app.quicktype.io/#l=pike) | [Prop-Types](https://app.quicktype.io/#l=javascript-prop-types) | [Haskell](https://app.quicktype.io/#l=haskell) | [PHP](https://app.quicktype.io/#l=php) |
| ------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------------- | ---------------------------------------------- | -------------------------------------- |
_Missing your favorite language? Please implement it!_
## Installation
There are many ways to use `quicktype`. [app.quicktype.io](https://app.quicktype.io) is the most powerful and complete UI. The web app also works offline and doesn't send your sample data over the Internet, so paste away!
For the best CLI, we recommend installing `quicktype` globally via `npm`:
```bash
npm install -g quicktype
```
## Using `quicktype`
```bash
# Run quicktype without arguments for help and options
quicktype
# quicktype a simple JSON object in C#
echo '{ "name": "David" }' | quicktype -l csharp
# quicktype a top-level array and save as Go source
echo '[1, 2, 3]' | quicktype -o ints.go
# quicktype a sample JSON file in Swift
quicktype person.json -o Person.swift
# A verbose way to do the same thing
quicktype \
--src person.json \
--src-lang json \
--lang swift \
--top-level Person \
--out Person.swift
# quicktype a directory of samples as a C++ program
# Suppose ./blockchain is a directory with files:
# latest-block.json transactions.json marketcap.json
quicktype ./blockchain -o blockchain-api.cpp
# quicktype a live JSON API as a Java program
quicktype https://api.somewhere.com/data -o Data.java
```
### Generating code from JSON schema
The recommended way to use `quicktype` is to generate a JSON schema from sample data, review and edit the schema, commit the schema to your project repo, then generate code from the schema as part of your build process:
```bash
# First, infer a JSON schema from a sample.
quicktype pokedex.json -l schema -o schema.json
# Review the schema, make changes,
# and commit it to your project repo.
# Finally, generate model code from schema in your
# build process for whatever languages you need:
quicktype -s schema schema.json -o src/ios/models.swift
quicktype -s schema schema.json -o src/android/Models.java
quicktype -s schema schema.json -o src/nodejs/Models.ts
# All of these models will serialize to and from the same
# JSON, so different programs in your stack can communicate
# seamlessly.
```
### Generating code from TypeScript (Experimental)
You can achieve a similar result by writing or generating a [TypeScript](http://www.typescriptlang.org/) file, then quicktyping it. TypeScript is a typed superset of JavaScript with simple, succinct syntax for defining types:
```typescript
interface Person {
name: string;
nickname?: string; // an optional property
luckyNumber: number;
}
```
You can use TypeScript just like JSON schema was used in the last example:
```bash
# First, infer a TypeScript file from a sample (or just write one!)
quicktype pokedex.json -o pokedex.ts --just-types
# Review the TypeScript, make changes, etc.
quicktype pokedex.ts -o src/ios/models.swift
```
### Calling `quicktype` from JavaScript
You can use `quicktype` as a JavaScript function within `node` or browsers. First add the `quicktype-core` package:
```bash
$ npm install quicktype-core
```
In general, first you create an `InputData` value with one or more JSON samples, JSON schemas, TypeScript sources, or other supported input types. Then you call `quicktype`, passing that `InputData` value and any options you want.
```javascript
import {
quicktype,
InputData,
jsonInputForTargetLanguage,
JSONSchemaInput,
FetchingJSONSchemaStore
} from "quicktype-core";
async function quicktypeJSON(targetLanguage, typeName, jsonString) {
const jsonInput = jsonInputForTargetLanguage(targetLanguage);
// We could add multiple samples for the same desired
// type, or many sources for other types. Here we're
// just making one type from one piece of sample JSON.
await jsonInput.addSource({
name: typeName,
samples: [jsonString]
});
const inputData = new InputData();
inputData.addInput(jsonInput);
return await quicktype({
inputData,
lang: targetLanguage
});
}
async function quicktypeJSONSchema(targetLanguage, typeName, jsonSchemaString) {
const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
// We could add multiple schemas for multiple types,
// but here we're just making one type from JSON schema.
await schemaInput.addSource({ name: typeName, schema: jsonSchemaString });
const inputData = new InputData();
inputData.addInput(schemaInput);
return await quicktype({
inputData,
lang: targetLanguage
});
}
async function main() {
const { lines: swiftPerson } = await quicktypeJSON("swift", "Person", jsonString);
console.log(swiftPerson.join("\n"));
const { lines: pythonPerson } = await quicktypeJSONSchema("python", "Person", jsonSchemaString);
console.log(pythonPerson.join("\n"));
}
main();
```
The argument to `quicktype` is a complex object with many optional properties. [Explore its definition](https://github.com/quicktype/quicktype/blob/master/packages/quicktype-core/src/Run.ts#L637) to understand what options are allowed.
### Adding Custom logic or Rendering:
Quicktype supports creating your own custom languages and rendering output, you can extend existing classes or create your own to be using by the `quicktype function`.
Check out [this guide](./doc/CustomRenderer.md) for more info.
## Contributing
`quicktype` is [Open Source](LICENSE) and we love contributors! In fact, we have a [list of issues](https://github.com/quicktype/quicktype/issues?utf8=✓&q=is%3Aissue+is%3Aopen+label%3Ahelp-wanted) that are low-priority for us, but for which we'd happily accept contributions. Support for new target languages is also strongly desired. If you'd like to contribute, need help with anything at all, or would just like to talk things over, come [join us on Slack](http://slack.quicktype.io/).
### Setup, Build, Run
`quicktype` is implemented in TypeScript and requires `nodejs` and `npm` to build and run.
First, install `typescript` globally via `npm`:
Clone this repo and do:
#### macOS / Linux
```bash
nvm use
npm install
script/quicktype # rebuild (slow) and run (fast)
```
#### Windows
```bash
npm install --ignore-scripts # Install dependencies
npm install -g typescript # Install typescript globally
tsc --project src/cli # Rebuild
node dist\cli\index.js # Run
```
### Edit
Install [Visual Studio Code](https://code.visualstudio.com/), open this
workspace, and install the recommended extensions:
```bash
code . # opens in VS Code
```
### Live-reloading for quick feedback
When working on an output language, you'll want to view generated
output as you edit. Use `npm start` to watch for changes and
recompile and rerun `quicktype` for live feedback. For example, if you're
developing a new renderer for `fortran`, you could use the following command to
rebuild and reinvoke `quicktype` as you implement your renderer:
```bash
npm start -- "--lang fortran pokedex.json"
```
The command in quotes is passed to `quicktype`, so you can render local `.json`
files, URLs, or add other options.
### Test
```bash
# Run full test suite
npm run test
# Test a specific language (see test/languages.ts)
FIXTURE=golang npm test
# Test a single sample or directory
FIXTURE=swift npm test -- pokedex.json
FIXTURE=swift npm test -- test/inputs/json/samples
```
================================================
FILE: biome.json
================================================
{
"files": {
"ignore": [
"test/runs",
"test/inputs",
"dist",
"node_modules",
"packages/*/dist",
"packages/*/node_modules"
]
},
"formatter": {
"indentStyle": "space",
"indentWidth": 4
}
}
================================================
FILE: data/lib.d.ts
================================================
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
///
/////////////////////////////
/// ECMAScript APIs
/////////////////////////////
declare const NaN: number;
declare const Infinity: number;
declare function eval(x: string): any;
declare function parseInt(s: string, radix?: number): number;
declare function parseFloat(string: string): number;
declare function isNaN(number: number): boolean;
declare function isFinite(number: number): boolean;
declare function decodeURI(encodedURI: string): string;
declare function decodeURIComponent(encodedURIComponent: string): string;
declare function encodeURI(uri: string): string;
declare function encodeURIComponent(uriComponent: string): string;
interface PropertyDescriptor {
configurable?: boolean;
enumerable?: boolean;
value?: any;
writable?: boolean;
get?(): any;
set?(v: any): void;
}
interface PropertyDescriptorMap {
[s: string]: PropertyDescriptor;
}
interface Object {
constructor: Function;
toString(): string;
toLocaleString(): string;
valueOf(): Object;
hasOwnProperty(v: string): boolean;
isPrototypeOf(v: Object): boolean;
propertyIsEnumerable(v: string): boolean;
}
interface ObjectConstructor {
new (value?: any): Object;
(): any;
(value: any): any;
readonly prototype: Object;
getPrototypeOf(o: any): any;
getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor | undefined;
getOwnPropertyNames(o: any): string[];
create(o: object | null): any;
create(o: object | null, properties: PropertyDescriptorMap & ThisType): any;
defineProperty(o: any, p: string, attributes: PropertyDescriptor & ThisType): any;
defineProperties(o: any, properties: PropertyDescriptorMap & ThisType): any;
seal(o: T): T;
freeze(a: T[]): ReadonlyArray;
freeze(f: T): T;
freeze(o: T): Readonly;
preventExtensions(o: T): T;
isSealed(o: any): boolean;
isFrozen(o: any): boolean;
isExtensible(o: any): boolean;
keys(o: {}): string[];
}
declare const Object: ObjectConstructor;
interface Function {
apply(this: Function, thisArg: any, argArray?: any): any;
call(this: Function, thisArg: any, ...argArray: any[]): any;
bind(this: Function, thisArg: any, ...argArray: any[]): any;
toString(): string;
prototype: any;
readonly length: number;
// Non-standard extensions
arguments: any;
caller: Function;
}
interface FunctionConstructor {
new (...args: string[]): Function;
(...args: string[]): Function;
readonly prototype: Function;
}
declare const Function: FunctionConstructor;
interface IArguments {
[index: number]: any;
length: number;
callee: Function;
}
interface String {
toString(): string;
charAt(pos: number): string;
charCodeAt(index: number): number;
concat(...strings: string[]): string;
indexOf(searchString: string, position?: number): number;
lastIndexOf(searchString: string, position?: number): number;
localeCompare(that: string): number;
match(regexp: string | RegExp): RegExpMatchArray | null;
replace(searchValue: string | RegExp, replaceValue: string): string;
replace(searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
search(regexp: string | RegExp): number;
slice(start?: number, end?: number): string;
split(separator: string | RegExp, limit?: number): string[];
substring(start: number, end?: number): string;
toLowerCase(): string;
toLocaleLowerCase(): string;
toUpperCase(): string;
toLocaleUpperCase(): string;
trim(): string;
readonly length: number;
// IE extensions
substr(from: number, length?: number): string;
valueOf(): string;
readonly [index: number]: string;
}
interface StringConstructor {
new (value?: any): String;
(value?: any): string;
readonly prototype: String;
fromCharCode(...codes: number[]): string;
}
declare const String: StringConstructor;
interface Boolean {
valueOf(): boolean;
}
interface BooleanConstructor {
new (value?: any): Boolean;
(value?: any): boolean;
readonly prototype: Boolean;
}
declare const Boolean: BooleanConstructor;
interface Number {
toString(radix?: number): string;
toFixed(fractionDigits?: number): string;
toExponential(fractionDigits?: number): string;
toPrecision(precision?: number): string;
valueOf(): number;
}
interface NumberConstructor {
new (value?: any): Number;
(value?: any): number;
readonly prototype: Number;
readonly MAX_VALUE: number;
readonly MIN_VALUE: number;
readonly NaN: number;
readonly NEGATIVE_INFINITY: number;
readonly POSITIVE_INFINITY: number;
}
declare const Number: NumberConstructor;
interface TemplateStringsArray extends ReadonlyArray {
readonly raw: ReadonlyArray;
}
interface Math {
readonly E: number;
readonly LN10: number;
readonly LN2: number;
readonly LOG2E: number;
readonly LOG10E: number;
readonly PI: number;
readonly SQRT1_2: number;
readonly SQRT2: number;
abs(x: number): number;
acos(x: number): number;
asin(x: number): number;
atan(x: number): number;
atan2(y: number, x: number): number;
ceil(x: number): number;
cos(x: number): number;
exp(x: number): number;
floor(x: number): number;
log(x: number): number;
max(...values: number[]): number;
min(...values: number[]): number;
pow(x: number, y: number): number;
random(): number;
round(x: number): number;
sin(x: number): number;
sqrt(x: number): number;
tan(x: number): number;
}
declare const Math: Math;
interface Date {
toString(): string;
toDateString(): string;
toTimeString(): string;
toLocaleString(): string;
toLocaleDateString(): string;
toLocaleTimeString(): string;
valueOf(): number;
getTime(): number;
getFullYear(): number;
getUTCFullYear(): number;
getMonth(): number;
getUTCMonth(): number;
getDate(): number;
getUTCDate(): number;
getDay(): number;
getUTCDay(): number;
getHours(): number;
getUTCHours(): number;
getMinutes(): number;
getUTCMinutes(): number;
getSeconds(): number;
getUTCSeconds(): number;
getMilliseconds(): number;
getUTCMilliseconds(): number;
getTimezoneOffset(): number;
setTime(time: number): number;
setMilliseconds(ms: number): number;
setUTCMilliseconds(ms: number): number;
setSeconds(sec: number, ms?: number): number;
setUTCSeconds(sec: number, ms?: number): number;
setMinutes(min: number, sec?: number, ms?: number): number;
setUTCMinutes(min: number, sec?: number, ms?: number): number;
setHours(hours: number, min?: number, sec?: number, ms?: number): number;
setUTCHours(hours: number, min?: number, sec?: number, ms?: number): number;
setDate(date: number): number;
setUTCDate(date: number): number;
setMonth(month: number, date?: number): number;
setUTCMonth(month: number, date?: number): number;
setFullYear(year: number, month?: number, date?: number): number;
setUTCFullYear(year: number, month?: number, date?: number): number;
toUTCString(): string;
toISOString(): string;
toJSON(key?: any): string;
}
interface DateConstructor {
new (): Date;
new (value: number): Date;
new (value: string): Date;
new (
year: number,
month: number,
date?: number,
hours?: number,
minutes?: number,
seconds?: number,
ms?: number
): Date;
(): string;
readonly prototype: Date;
parse(s: string): number;
UTC(
year: number,
month: number,
date?: number,
hours?: number,
minutes?: number,
seconds?: number,
ms?: number
): number;
now(): number;
}
declare const Date: DateConstructor;
interface RegExpMatchArray extends Array {
index?: number;
input?: string;
}
interface RegExpExecArray extends Array {
index: number;
input: string;
}
interface RegExp {
exec(string: string): RegExpExecArray | null;
test(string: string): boolean;
readonly source: string;
readonly global: boolean;
readonly ignoreCase: boolean;
readonly multiline: boolean;
lastIndex: number;
// Non-standard extensions
compile(): this;
}
interface RegExpConstructor {
new (pattern: RegExp | string): RegExp;
new (pattern: string, flags?: string): RegExp;
(pattern: RegExp | string): RegExp;
(pattern: string, flags?: string): RegExp;
readonly prototype: RegExp;
// Non-standard extensions
$1: string;
$2: string;
$3: string;
$4: string;
$5: string;
$6: string;
$7: string;
$8: string;
$9: string;
lastMatch: string;
}
declare const RegExp: RegExpConstructor;
interface Error {
name: string;
message: string;
stack?: string;
}
interface ErrorConstructor {
new (message?: string): Error;
(message?: string): Error;
readonly prototype: Error;
}
declare const Error: ErrorConstructor;
interface EvalError extends Error {}
interface EvalErrorConstructor {
new (message?: string): EvalError;
(message?: string): EvalError;
readonly prototype: EvalError;
}
declare const EvalError: EvalErrorConstructor;
interface RangeError extends Error {}
interface RangeErrorConstructor {
new (message?: string): RangeError;
(message?: string): RangeError;
readonly prototype: RangeError;
}
declare const RangeError: RangeErrorConstructor;
interface ReferenceError extends Error {}
interface ReferenceErrorConstructor {
new (message?: string): ReferenceError;
(message?: string): ReferenceError;
readonly prototype: ReferenceError;
}
declare const ReferenceError: ReferenceErrorConstructor;
interface SyntaxError extends Error {}
interface SyntaxErrorConstructor {
new (message?: string): SyntaxError;
(message?: string): SyntaxError;
readonly prototype: SyntaxError;
}
declare const SyntaxError: SyntaxErrorConstructor;
interface TypeError extends Error {}
interface TypeErrorConstructor {
new (message?: string): TypeError;
(message?: string): TypeError;
readonly prototype: TypeError;
}
declare const TypeError: TypeErrorConstructor;
interface URIError extends Error {}
interface URIErrorConstructor {
new (message?: string): URIError;
(message?: string): URIError;
readonly prototype: URIError;
}
declare const URIError: URIErrorConstructor;
interface JSON {
parse(text: string, reviver?: (key: any, value: any) => any): any;
stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string;
stringify(value: any, replacer?: (number | string)[] | null, space?: string | number): string;
}
declare const JSON: JSON;
/////////////////////////////
/// ECMAScript Array API (specially handled by compiler)
/////////////////////////////
interface ReadonlyArray {
readonly length: number;
toString(): string;
toLocaleString(): string;
concat(...items: ReadonlyArray[]): T[];
concat(...items: (T | ReadonlyArray)[]): T[];
join(separator?: string): string;
slice(start?: number, end?: number): T[];
indexOf(searchElement: T, fromIndex?: number): number;
lastIndexOf(searchElement: T, fromIndex?: number): number;
every(callbackfn: (value: T, index: number, array: ReadonlyArray) => boolean, thisArg?: any): boolean;
some(callbackfn: (value: T, index: number, array: ReadonlyArray) => boolean, thisArg?: any): boolean;
forEach(callbackfn: (value: T, index: number, array: ReadonlyArray) => void, thisArg?: any): void;
map(callbackfn: (value: T, index: number, array: ReadonlyArray) => U, thisArg?: any): U[];
filter(
callbackfn: (value: T, index: number, array: ReadonlyArray) => value is S,
thisArg?: any
): S[];
filter(callbackfn: (value: T, index: number, array: ReadonlyArray) => any, thisArg?: any): T[];
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray) => T): T;
reduce(
callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray) => T,
initialValue: T
): T;
reduce(
callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: ReadonlyArray) => U,
initialValue: U
): U;
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray) => T): T;
reduceRight(
callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray) => T,
initialValue: T
): T;
reduceRight(
callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: ReadonlyArray) => U,
initialValue: U
): U;
readonly [n: number]: T;
}
interface Array {
length: number;
toString(): string;
toLocaleString(): string;
push(...items: T[]): number;
pop(): T | undefined;
concat(...items: ReadonlyArray[]): T[];
concat(...items: (T | ReadonlyArray)[]): T[];
join(separator?: string): string;
reverse(): T[];
shift(): T | undefined;
slice(start?: number, end?: number): T[];
sort(compareFn?: (a: T, b: T) => number): this;
splice(start: number, deleteCount?: number): T[];
splice(start: number, deleteCount: number, ...items: T[]): T[];
unshift(...items: T[]): number;
indexOf(searchElement: T, fromIndex?: number): number;
lastIndexOf(searchElement: T, fromIndex?: number): number;
every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
map(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
filter(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
filter(callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[];
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
reduce(
callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U,
initialValue: U
): U;
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
reduceRight(
callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T,
initialValue: T
): T;
reduceRight(
callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U,
initialValue: U
): U;
[n: number]: T;
}
interface ArrayConstructor {
new (arrayLength?: number): any[];
new (arrayLength: number): T[];
new (...items: T[]): T[];
(arrayLength?: number): any[];
(arrayLength: number): T[];
(...items: T[]): T[];
isArray(arg: any): arg is Array;
readonly prototype: Array;
}
declare const Array: ArrayConstructor;
interface TypedPropertyDescriptor {
enumerable?: boolean;
configurable?: boolean;
writable?: boolean;
value?: T;
get?: () => T;
set?: (value: T) => void;
}
declare type ClassDecorator = (target: TFunction) => TFunction | void;
declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
declare type MethodDecorator = (
target: Object,
propertyKey: string | symbol,
descriptor: TypedPropertyDescriptor
) => TypedPropertyDescriptor | void;
declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
declare type PromiseConstructorLike = new (
executor: (resolve: (value?: T | PromiseLike) => void, reject: (reason?: any) => void) => void
) => PromiseLike;
interface PromiseLike {
then(
onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null,
onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null
): PromiseLike;
}
interface Promise {
then(
onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null,
onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null
): Promise;
catch(
onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null
): Promise;
}
interface ArrayLike {
readonly length: number;
readonly [n: number]: T;
}
type Partial = {
[P in keyof T]?: T[P];
};
type Readonly = {
readonly [P in keyof T]: T[P];
};
type Pick = {
[P in K]: T[P];
};
type Record = {
[P in K]: T;
};
interface ThisType {}
interface ArrayBuffer {
readonly byteLength: number;
slice(begin: number, end?: number): ArrayBuffer;
}
interface ArrayBufferTypes {
ArrayBuffer: ArrayBuffer;
}
type ArrayBufferLike = ArrayBufferTypes[keyof ArrayBufferTypes];
interface ArrayBufferConstructor {
readonly prototype: ArrayBuffer;
new (byteLength: number): ArrayBuffer;
isView(arg: any): arg is ArrayBufferView;
}
declare const ArrayBuffer: ArrayBufferConstructor;
interface ArrayBufferView {
buffer: ArrayBufferLike;
byteLength: number;
byteOffset: number;
}
interface DataView {
readonly buffer: ArrayBuffer;
readonly byteLength: number;
readonly byteOffset: number;
getFloat32(byteOffset: number, littleEndian?: boolean): number;
getFloat64(byteOffset: number, littleEndian?: boolean): number;
getInt8(byteOffset: number): number;
getInt16(byteOffset: number, littleEndian?: boolean): number;
getInt32(byteOffset: number, littleEndian?: boolean): number;
getUint8(byteOffset: number): number;
getUint16(byteOffset: number, littleEndian?: boolean): number;
getUint32(byteOffset: number, littleEndian?: boolean): number;
setFloat32(byteOffset: number, value: number, littleEndian?: boolean): void;
setFloat64(byteOffset: number, value: number, littleEndian?: boolean): void;
setInt8(byteOffset: number, value: number): void;
setInt16(byteOffset: number, value: number, littleEndian?: boolean): void;
setInt32(byteOffset: number, value: number, littleEndian?: boolean): void;
setUint8(byteOffset: number, value: number): void;
setUint16(byteOffset: number, value: number, littleEndian?: boolean): void;
setUint32(byteOffset: number, value: number, littleEndian?: boolean): void;
}
interface DataViewConstructor {
new (buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number): DataView;
}
declare const DataView: DataViewConstructor;
interface Int8Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Int8Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Int8Array) => any, thisArg?: any): Int8Array;
find(predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Int8Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Int8Array) => number, thisArg?: any): Int8Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U,
initialValue: U
): U;
reverse(): Int8Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Int8Array;
some(callbackfn: (value: number, index: number, array: Int8Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Int8Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Int8ArrayConstructor {
readonly prototype: Int8Array;
new (length: number): Int8Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Int8Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Int8Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Int8Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;
}
declare const Int8Array: Int8ArrayConstructor;
interface Uint8Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Uint8Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Uint8Array) => any, thisArg?: any): Uint8Array;
find(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Uint8Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Uint8Array) => number, thisArg?: any): Uint8Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U,
initialValue: U
): U;
reverse(): Uint8Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Uint8Array;
some(callbackfn: (value: number, index: number, array: Uint8Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Uint8Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Uint8ArrayConstructor {
readonly prototype: Uint8Array;
new (length: number): Uint8Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Uint8Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Uint8Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Uint8Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;
}
declare const Uint8Array: Uint8ArrayConstructor;
interface Uint8ClampedArray {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(
callbackfn: (value: number, index: number, array: Uint8ClampedArray) => any,
thisArg?: any
): Uint8ClampedArray;
find(
predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean,
thisArg?: any
): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(
callbackfn: (value: number, index: number, array: Uint8ClampedArray) => number,
thisArg?: any
): Uint8ClampedArray;
reduce(
callbackfn: (
previousValue: number,
currentValue: number,
currentIndex: number,
array: Uint8ClampedArray
) => number
): number;
reduce(
callbackfn: (
previousValue: number,
currentValue: number,
currentIndex: number,
array: Uint8ClampedArray
) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (
previousValue: number,
currentValue: number,
currentIndex: number,
array: Uint8ClampedArray
) => number
): number;
reduceRight(
callbackfn: (
previousValue: number,
currentValue: number,
currentIndex: number,
array: Uint8ClampedArray
) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U,
initialValue: U
): U;
reverse(): Uint8ClampedArray;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Uint8ClampedArray;
some(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Uint8ClampedArray;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Uint8ClampedArrayConstructor {
readonly prototype: Uint8ClampedArray;
new (length: number): Uint8ClampedArray;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Uint8ClampedArray;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Uint8ClampedArray;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Uint8ClampedArray;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;
}
declare const Uint8ClampedArray: Uint8ClampedArrayConstructor;
interface Int16Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Int16Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Int16Array) => any, thisArg?: any): Int16Array;
find(predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Int16Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Int16Array) => number, thisArg?: any): Int16Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U,
initialValue: U
): U;
reverse(): Int16Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Int16Array;
some(callbackfn: (value: number, index: number, array: Int16Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Int16Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Int16ArrayConstructor {
readonly prototype: Int16Array;
new (length: number): Int16Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Int16Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Int16Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Int16Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;
}
declare const Int16Array: Int16ArrayConstructor;
interface Uint16Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Uint16Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Uint16Array) => any, thisArg?: any): Uint16Array;
find(predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Uint16Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Uint16Array) => number, thisArg?: any): Uint16Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U,
initialValue: U
): U;
reverse(): Uint16Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Uint16Array;
some(callbackfn: (value: number, index: number, array: Uint16Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Uint16Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Uint16ArrayConstructor {
readonly prototype: Uint16Array;
new (length: number): Uint16Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Uint16Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Uint16Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Uint16Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;
}
declare const Uint16Array: Uint16ArrayConstructor;
interface Int32Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Int32Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Int32Array) => any, thisArg?: any): Int32Array;
find(predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Int32Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Int32Array) => number, thisArg?: any): Int32Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U,
initialValue: U
): U;
reverse(): Int32Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Int32Array;
some(callbackfn: (value: number, index: number, array: Int32Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Int32Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Int32ArrayConstructor {
readonly prototype: Int32Array;
new (length: number): Int32Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Int32Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Int32Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Int32Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;
}
declare const Int32Array: Int32ArrayConstructor;
interface Uint32Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Uint32Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Uint32Array) => any, thisArg?: any): Uint32Array;
find(predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Uint32Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Uint32Array) => number, thisArg?: any): Uint32Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U,
initialValue: U
): U;
reverse(): Uint32Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Uint32Array;
some(callbackfn: (value: number, index: number, array: Uint32Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Uint32Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Uint32ArrayConstructor {
readonly prototype: Uint32Array;
new (length: number): Uint32Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Uint32Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Uint32Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Uint32Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;
}
declare const Uint32Array: Uint32ArrayConstructor;
interface Float32Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Float32Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Float32Array) => any, thisArg?: any): Float32Array;
find(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Float32Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Float32Array) => number, thisArg?: any): Float32Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U,
initialValue: U
): U;
reverse(): Float32Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Float32Array;
some(callbackfn: (value: number, index: number, array: Float32Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Float32Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Float32ArrayConstructor {
readonly prototype: Float32Array;
new (length: number): Float32Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Float32Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Float32Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Float32Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;
}
declare const Float32Array: Float32ArrayConstructor;
interface Float64Array {
readonly BYTES_PER_ELEMENT: number;
readonly buffer: ArrayBufferLike;
readonly byteLength: number;
readonly byteOffset: number;
copyWithin(target: number, start: number, end?: number): this;
every(callbackfn: (value: number, index: number, array: Float64Array) => boolean, thisArg?: any): boolean;
fill(value: number, start?: number, end?: number): this;
filter(callbackfn: (value: number, index: number, array: Float64Array) => any, thisArg?: any): Float64Array;
find(predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number | undefined;
findIndex(predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number;
forEach(callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any): void;
indexOf(searchElement: number, fromIndex?: number): number;
join(separator?: string): string;
lastIndexOf(searchElement: number, fromIndex?: number): number;
readonly length: number;
map(callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any): Float64Array;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number
): number;
reduce(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number,
initialValue: number
): number;
reduce(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U,
initialValue: U
): U;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number
): number;
reduceRight(
callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number,
initialValue: number
): number;
reduceRight(
callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U,
initialValue: U
): U;
reverse(): Float64Array;
set(array: ArrayLike, offset?: number): void;
slice(start?: number, end?: number): Float64Array;
some(callbackfn: (value: number, index: number, array: Float64Array) => boolean, thisArg?: any): boolean;
sort(compareFn?: (a: number, b: number) => number): this;
subarray(begin: number, end?: number): Float64Array;
toLocaleString(): string;
toString(): string;
[index: number]: number;
}
interface Float64ArrayConstructor {
readonly prototype: Float64Array;
new (length: number): Float64Array;
new (arrayOrArrayBuffer: ArrayLike | ArrayBufferLike): Float64Array;
new (buffer: ArrayBufferLike, byteOffset: number, length?: number): Float64Array;
readonly BYTES_PER_ELEMENT: number;
of(...items: number[]): Float64Array;
from(arrayLike: ArrayLike, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
}
declare const Float64Array: Float64ArrayConstructor;
================================================
FILE: doc/CustomRenderer.md
================================================
# Extending quicktype functionality with a Custom Renderer
## quicktype Interface
To customise your rendering output, you can extend existing quicktype classes and override existing methods to achieve the behaviour you want.
This process requires 3 main steps:
1. [Extending a `Renderer` Class](#creating-a-custom-renderer)
2. [Wrapping your `Renderer` in a `TargetLanguage` Class](#creating-a-targetlanguage)
3. [Using your new classes in the `quicktype` function](#using-your-custom-language)
4. [Advanced Usage: Creating an entirely new Language](#creating-a-new-language)
## Creating a custom `Renderer`
Adding custom render logic for an existing language often involves extending a Renderer class and simply overriding or amending one of the `emit` methods:
```ts
// MyCustomRenderer.ts
import { CSharpRenderer } from "quicktype-core";
export class MyCustomRenderer extends CSharpRenderer {
// Add your custom logic here, feel free to reference the source code for how existing methods work
//
// ex.
protected superclassForType(t: Type): Sourcelike | undefined {
// if the type is a class, it should extend `GameObject` when rendered in C#
if (t instanceof ClassType) {
return "GameObject";
}
return undefined;
}
// See: http://blog.quicktype.io/customizing-quicktype/ for more context
}
```
## Creating a `TargetLanguage`
If you just want to change the rendering logic for an existing language, you can just extend an exported Language class (`CSharpTargetLanguage` in this example) and override the `makeRenderer` method:
```ts
// MyCustomLanguage.ts
import { CSharpTargetLanguage } from "quicktype-core";
import { MyCustomRenderer } from "./MyCustomRenderer";
export class MyCustomLanguage extends CSharpTargetLanguage {
// `makeRenderer` instantiates the Renderer class for the TargetLanguage
protected makeRenderer(
renderContext: RenderContext,
untypedOptionValues: Record
): MyCustomRenderer {
// use your new custom renderer class here
return new MyCustomRenderer(this, renderContext, getOptionValues(cSharpOptions, untypedOptionValues));
}
}
```
## Using your custom Language
```ts
import { quicktype } from "quicktype-core";
import { MyCustomLanguage } from './MyCustomLanguage';
const lang = new MyCustomLanguage();
const lines = await quicktype({
lang: lang, // use your new TargetLanguage in the `lang` field here
...
});
console.log(lines);
```
## Creating a new Language
If none of the existing `quicktype` Language classes suit your needs, you can creating your own `TargetLanguge` and `Renderer` classes from scratch. If this satisfies your use cases for a language we don't currently support, please consider opening a PR with your new language and we'd love to take a look.
If you run into any issues, you can open a GitHub issue and we'll help you take a look.
### Creating a `TargetLanguage` from scratch
Instead of just extending an existing language, a new Language requires two additional steps:
- Defining the language config
- Adding any language-specific options
```ts
import { TargetLanguage, BooleanOption } from "quicktype-core";
// language config
const brandNewLanguageConfig = {
displayName: "Scratch", // these can be the same
names: ["scratch"], // these can be the same
extension: "sb" // the file extension that this language commonly has
} as const;
// language options
const brandNewLanguageOptions = {
allowFoo: new BooleanOption(
"allow-foo", // option name
"Allows Foo", // description
true // default value
)
// The default available Option classes are: StringOption, BooleanOption, EnumOption
// Please visit the source code for more examples and usage
};
class BrandNewLanguage extends TargetLanguage {
public constructor() {
super(brandNewLanguageConfig);
}
public getOptions(): typeof brandNewLanguageOptions {
return brandNewLanguageOptions;
}
protected makeRenderer(
renderContext: RenderContext,
untypedOptionValues: Record
): BrandNewRenderer {
return new BrandNewRenderer(this, renderContext, getOptionValues(brandNewLanguageOptions, untypedOptionValues));
}
}
```
### Creating a `Renderer` from scratch
Creating a brand new `Renderer` class is very similar to extending an existing class:
```ts
export class BrandNewRenderer extends ConvenienceRenderer {
public constructor(targetLanguage: TargetLanguage, renderContext: RenderContext) {
super(targetLanguage, renderContext);
}
// Additional render methods go here
// Please reference existing Renderer classes and open a GitHub issue if you need help
}
```
## Links
Blog post with an older example: http://blog.quicktype.io/customizing-quicktype/
================================================
FILE: doc/PostmanCollection.schema
================================================
{
"$schema": "http://json-schema.org/draft-06/schema#",
"description": "Postman collection",
"$ref": "#/definitions/collection",
"definitions": {
"group": {
"type": "object",
"properties": {
"item": {
"type": "array",
"items": {
"$ref": "#/definitions/collection"
}
}
}
},
"item": {
"type": "object",
"properties": {
"name": { "type": "string" },
"response": {
"type": "array",
"items": {
"$ref": "#/definitions/response"
}
}
}
},
"response": {
"type": "object",
"properties": {
"body": { "type": "string" }
}
},
"collection": {
"oneOf": [
{ "$ref": "#/definitions/group" },
{ "$ref": "#/definitions/item" }
]
}
}
}
================================================
FILE: doc/Templates.md
================================================
# NOTE
This was a prototype that we've since removed from quicktype. If you'd like to play with it, please use commit `8eba491ac167a51203eaa6100609ec73ad553236`. If you find it useful and would like us to bring it back, please let us know - it's probably fairly easy.
# Templates
quicktype allows the processing of [Handlebars](http://handlebarsjs.com) templates based on the types specified in or inferred from the input. Templates are always processed in the context of a specific target language, which makes it possible for their output to interact with the types generated for that target language.
## Invocation
quicktype --lang csharp --template TEMPLATE-FILE ./test/inputs/json/samples/kitchen-sink.json
## Example
```
{{#each namedTypes}}
{{#if_eq type.kind "class"}}
public partial class {{{assignedName}}} {
{{#each properties}}
[JsonProperty("{{{string_escape @key}}}")]
public {{{csType}}} {{{assignedName}}} { get; set; }
{{/each}}
}
{{/if_eq}}
{{#if_eq type.kind "enum"}}
public enum {{{assignedName}}} {
{{#each cases}}{{#unless @first}}, {{/unless}}{{{assignedName}}}{{/each}}
}
{{/if_eq}}
{{#if_eq type.kind "union"}}
public partial struct {{{assignedName}}}
{
{{#each members}}
public {{{nullableCSType}}} {{{assignedName}}};
{{/each}}
}
{{/if_eq}}
{{/each}}
{{#each topLevels}}
public partial class {{{assignedTopLevelName}}} {
public static {{{csType}}} FromJson(string json) => JsonConvert.DeserializeObject<{{{csType}}}>(json, Converter.Settings);
}
{{/each}}
{{#each namedTypes}}{{#if_eq type.kind "enum"}}
static class {{{extensionsName}}}
{
public static {{{assignedName}}}? ValueForString(string str)
{
switch (str)
{
{{#each cases}}
case "{{{string_escape @key}}}": return {{{../assignedName}}}.{{{assignedName}}};
{{/each}}
default: return null;
}
}
public static {{{assignedName}}} ReadJson(JsonReader reader, JsonSerializer serializer)
{
var str = serializer.Deserialize(reader);
var maybeValue = ValueForString(str);
if (maybeValue.HasValue) return maybeValue.Value;
throw new Exception("Unknown enum case " + str);
}
public static void WriteJson(this {{{assignedName}}} value, JsonWriter writer, JsonSerializer serializer)
{
switch (value)
{
{{#each cases}}
case {{{../assignedName}}}.{{{assignedName}}}: serializer.Serialize(writer, "{{{string_escape @key}}}"); break;
{{/each}}
}
}
}
{{/if_eq}}{{/each}}
public static class Serialize {
{{#each topLevels}}
public static string ToJson(this {{{csType}}} self) => JsonConvert.SerializeObject(self, Converter.Settings);
{{/each}}
}
public class Converter
{
public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
DateParseHandling = DateParseHandling.None,
};
}
```
================================================
FILE: doc/Transformers.md
================================================
# Transformed string types
quicktype has facilities for transforming JSON strings into other data types, provided a given target language implementation supports it. Right now the most advanced target language in that regard is C#, which supports data/time types and stringified integers.
There are two different sorts of transformed string types:
- Those that transform strings into other JSON-representable types, such as stringified integers.
- Those that transform into types that are not directly representable in JSON (other than as strings), such as date/time types.
Several pieces need to be implemented to add a new transformed string type:
1. `TransformedStringTypeTargets` have to be added for the new type kind in the object `transformedStringTypeTargetTypeKinds` in `Type.ts`. The property names of that object are the internal primitive type names. Adding a new property automatically adds a new type.
2. `inferTransformedStringTypeKindForString` in `StringTypes.ts` can optionally be amended to automatically infer the new transformed type from a given string in JSON input. If this isn't done, the only way to use the new type is through JSON Schema. If it is done, a CLI option to turn it off has to be added. This is currently still more complicated than it needs to be, since it also involves changing the options to `quicktype-core`.
3. The target languages that should support the new type have to be amended. Currently C# is the only one that allows this easily. See `CSharp.ts` and search for `date-time`.
4. Test cases have to be added. See `test/inputs/schema/date-time*`, for example. If JSON inference is implemented, there should be at least one JSON test file with a string of that type.
5. In `fixtures.ts`, `ajv`, which we use to validate JSON against schemas, has to be told about the new JSON Schema string format. Search for `date-time`.
## Stuff we need to improve
- Automatic generation of tests. We should have a test generator that produces test files with all string types in all reasonable combinations.
- One CLI option for all string types. No CLI option work should be necessary to implement a new string type.
- The AJV thing should be automated, too. We have almost all the validation code necessary in `StringTypes.ts` anyway.
================================================
FILE: package.json
================================================
{
"name": "quicktype",
"version": "23.2.0",
"license": "Apache-2.0",
"main": "dist/index.js",
"types": "dist/index.d.ts",
"repository": "https://github.com/quicktype/quicktype",
"engines": {
"node": ">=18.12.0"
},
"scripts": {
"pub": "script/publish.sh",
"build": "npm run clean && npm run build --workspaces --if-present && tsc",
"test": "script/test",
"start": "script/watch",
"clean": "rm -rf dist *~ packages/*/{dist,out}",
"debug": "node --inspect-brk --max-old-space-size=4096 ./dist/index.js",
"lint": "eslint src/** packages/*/src/**",
"lint:fix": "eslint --fix src/** packages/*/src/**"
},
"workspaces": [
"./packages/quicktype-core",
"./packages/quicktype-graphql-input",
"./packages/quicktype-typescript-input",
"./packages/quicktype-vscode"
],
"dependencies": {
"@glideapps/ts-necessities": "^2.2.3",
"chalk": "^4.1.2",
"collection-utils": "^1.0.1",
"command-line-args": "^5.2.1",
"command-line-usage": "^7.0.1",
"cross-fetch": "^4.0.0",
"graphql": "^0.11.7",
"lodash": "^4.17.21",
"moment": "^2.30.1",
"quicktype-core": "20.0.12",
"quicktype-graphql-input": "20.0.2",
"quicktype-typescript-input": "20.0.2",
"readable-stream": "^4.5.2",
"stream-json": "1.8.0",
"string-to-stream": "^3.0.1",
"typescript": "~5.8.3"
},
"devDependencies": {
"@biomejs/biome": "^1.9.4",
"@tsconfig/node18": "^1.0.1",
"@types/command-line-args": "^5.2.0",
"@types/command-line-usage": "^5.0.4",
"@types/graphql": "^0.11.7",
"@types/lodash": "^4.17.0",
"@types/semver": "^7.5.0",
"@types/shelljs": "^0.8.15",
"@types/stream-json": "^1.7.3",
"@types/urijs": "^1.19.25",
"@types/wordwrap": "^1.0.3",
"@typescript-eslint/eslint-plugin": "^6.3.0",
"@typescript-eslint/parser": "^6.3.0",
"ajv": "^5.5.2",
"deep-equal": "^2.2.3",
"esbuild": "^0.20.2",
"exit": "^0.1.2",
"promise-timeout": "^1.3.0",
"semver": "^7.5.4",
"shelljs": "^0.8.5",
"ts-node": "^10.9.2",
"watch": "^1.0.2"
},
"overrides": {
"cross-fetch": {
"node-fetch": {
"whatwg-url": "^13.0.0"
}
}
},
"files": ["dist"],
"bin": "dist/index.js"
}
================================================
FILE: packages/quicktype-core/env.sh
================================================
#!/usr/bin/env bash
if [[ $PUBLISH == true ]]; then
echo 'HAS PUBLISH, exit'
exit 0
fi
if [[ $CI ]]; then
if [[ "$OSTYPE" == "darwin"* ]]; then
grep -rl '$fetch' src | xargs sed -i '' -e 's/$fetch/$fetch.ci/g'
else
grep -rl '$fetch' src | xargs sed -i -e 's/$fetch/$fetch.ci/g'
fi
fi
================================================
FILE: packages/quicktype-core/package.json
================================================
{
"name": "quicktype-core",
"version": "18.0.15",
"description": "The quicktype engine as a library",
"license": "Apache-2.0",
"main": "dist/index.js",
"types": "dist/index.d.ts",
"repository": "https://github.com/quicktype/quicktype",
"scripts": {
"clean": "rm -rf dist node_modules *~",
"build": "./env.sh && tsc"
},
"dependencies": {
"@glideapps/ts-necessities": "2.2.3",
"browser-or-node": "^3.0.0",
"collection-utils": "^1.0.1",
"cross-fetch": "^4.0.0",
"is-url": "^1.2.4",
"js-base64": "^3.7.7",
"lodash": "^4.17.21",
"pako": "^1.0.6",
"pluralize": "^8.0.0",
"readable-stream": "4.5.2",
"unicode-properties": "^1.4.1",
"urijs": "^1.19.1",
"wordwrap": "^1.0.0",
"yaml": "^2.4.1"
},
"devDependencies": {
"@types/browser-or-node": "^1.3.2",
"@types/is-url": "^1.2.32",
"@types/node": "~22.14.0",
"@types/pako": "^1.0.0",
"@types/pluralize": "0.0.30",
"@types/readable-stream": "4.0.10",
"@types/unicode-properties": "^1.3.0",
"@types/urijs": "^1.19.25",
"@types/wordwrap": "^1.0.3",
"command-line-args": "^5.2.1",
"typescript": "~5.8.3"
},
"overrides": {
"cross-fetch": {
"node-fetch": {
"whatwg-url": "^13.0.0"
}
}
},
"files": ["dist"],
"browser": {
"fs": false
}
}
================================================
FILE: packages/quicktype-core/src/Annotation.ts
================================================
// eslint-disable-next-line @typescript-eslint/no-extraneous-class
export class AnnotationData {}
export class IssueAnnotationData extends AnnotationData {
public constructor(public readonly message: string) {
super();
}
}
export const anyTypeIssueAnnotation = new IssueAnnotationData(
"quicktype cannot infer this type because there is no data about it in the input.",
);
export const nullTypeIssueAnnotation = new IssueAnnotationData(
"The only value for this in the input is null, which means you probably need a more complete input sample.",
);
================================================
FILE: packages/quicktype-core/src/ConvenienceRenderer.ts
================================================
import {
iterableEnumerate,
iterableSome,
mapFilter,
mapFilterMap,
mapSome,
mapSortBy,
setFilter,
setUnion,
} from "collection-utils";
import _wordwrap from "wordwrap";
import {
enumCaseNames,
getAccessorName,
objectPropertyNames,
unionMemberName,
} from "./attributes/AccessorNames";
import {
descriptionTypeAttributeKind,
propertyDescriptionsTypeAttributeKind,
} from "./attributes/Description";
import { TypeAttributeKind } from "./attributes/TypeAttributes";
import {
type Declaration,
type DeclarationIR,
cycleBreakerTypesForGraph,
declarationsForGraph,
} from "./DeclarationIR";
import {
DependencyName,
FixedName,
type Name,
type Namer,
Namespace,
SimpleName,
keywordNamespace,
} from "./Naming";
import {
type BlankLineConfig,
type ForEachPosition,
type RenderContext,
Renderer,
} from "./Renderer";
import {
type Sourcelike,
serializeRenderResult,
sourcelikeToSource,
} from "./Source";
import {
type Comment,
type CommentOptions,
isStringComment,
} from "./support/Comments";
import { trimEnd } from "./support/Strings";
import { assert, defined, nonNull, panic } from "./support/Support";
import type { TargetLanguage } from "./TargetLanguage";
import {
type Transformation,
followTargetType,
transformationForType,
} from "./Transformers";
import {
type ClassProperty,
ClassType,
EnumType,
MapType,
ObjectType,
type Type,
type TypeKind,
UnionType,
} from "./Type";
import { TypeAttributeStoreView } from "./Type/TypeGraph";
import {
isNamedType,
matchTypeExhaustive,
nullableFromUnion,
separateNamedTypes,
} from "./Type/TypeUtils";
const wordWrap: (s: string) => string = _wordwrap(90);
export const topLevelNameOrder = 1;
const givenNameOrder = 10;
export const inferredNameOrder = 30;
const classPropertyNameOrder = 20;
const assignedClassPropertyNameOrder = 10;
const enumCaseNameOrder = 20;
const assignedEnumCaseNameOrder = 10;
const unionMemberNameOrder = 40;
function splitDescription(
descriptions: Iterable | undefined,
): string[] | undefined {
if (descriptions === undefined) return undefined;
const description = Array.from(descriptions).join("\n\n").trim();
if (description === "") return undefined;
return wordWrap(description)
.split("\n")
.map((l) => l.trim());
}
export interface ForbiddenWordsInfo {
includeGlobalForbidden: boolean;
names: Array;
}
const assignedNameAttributeKind = new TypeAttributeKind("assignedName");
const assignedPropertyNamesAttributeKind = new TypeAttributeKind<
ReadonlyMap
>("assignedPropertyNames");
const assignedMemberNamesAttributeKind = new TypeAttributeKind<
ReadonlyMap
>("assignedMemberNames");
const assignedCaseNamesAttributeKind = new TypeAttributeKind<
ReadonlyMap
>("assignedCaseNames");
export abstract class ConvenienceRenderer extends Renderer {
private _globalForbiddenNamespace: Namespace | undefined;
private _otherForbiddenNamespaces: Map | undefined;
private _globalNamespace: Namespace | undefined;
private _nameStoreView: TypeAttributeStoreView | undefined;
private _propertyNamesStoreView:
| TypeAttributeStoreView>
| undefined;
private _memberNamesStoreView:
| TypeAttributeStoreView>
| undefined;
private _caseNamesStoreView:
| TypeAttributeStoreView>
| undefined;
private _namesForTransformations: Map | undefined;
private _namedTypeNamer: Namer | undefined;
// @ts-expect-error: FIXME: Make this `Namer | undefined`
private _unionMemberNamer: Namer | null;
// @ts-expect-error: FIXME: Make this `Namer | undefined`
private _enumCaseNamer: Namer | null;
private _declarationIR: DeclarationIR | undefined;
private _namedTypes: readonly Type[] | undefined;
private _namedObjects: Set | undefined;
private _namedEnums: Set | undefined;
private _namedUnions: Set | undefined;
private _haveUnions: boolean | undefined;
private _haveMaps: boolean | undefined;
private _haveOptionalProperties: boolean | undefined;
private _cycleBreakerTypes?: Set | undefined;
private _alphabetizeProperties = false;
public constructor(
targetLanguage: TargetLanguage,
renderContext: RenderContext,
) {
super(targetLanguage, renderContext);
}
public get topLevels(): ReadonlyMap {
return this.typeGraph.topLevels;
}
/**
* Return an array of strings which are not allowed as names in the global
* namespace. Since names of generated types are in the global namespace,
* this will include anything built into the language or default libraries
* that can conflict with that, such as reserved keywords or common type
* names.
*/
protected forbiddenNamesForGlobalNamespace(): readonly string[] {
return [];
}
/**
* Returns which names are forbidden for the property names of an object
* type. `names` can contain strings as well as `Name`s. In some
* languages, the class name can't be used as the name for a property, for
* example, in which case `_className` would have to be return in `names`.
* If `includeGlobalForbidden` is set, then all names that are forbidden
* in the global namespace will also be forbidden for the properties.
* Note: That doesn't mean that the names in the global namespace will be
* forbidden, too!
*/
protected forbiddenForObjectProperties(
_o: ObjectType,
_className: Name,
): ForbiddenWordsInfo {
return { names: [], includeGlobalForbidden: false };
}
protected forbiddenForUnionMembers(
_u: UnionType,
_unionName: Name,
): ForbiddenWordsInfo {
return { names: [], includeGlobalForbidden: false };
}
protected forbiddenForEnumCases(
_e: EnumType,
_enumName: Name,
): ForbiddenWordsInfo {
return { names: [], includeGlobalForbidden: false };
}
protected makeTopLevelDependencyNames(
_t: Type,
_topLevelName: Name,
): DependencyName[] {
return [];
}
protected makeNamedTypeDependencyNames(
_t: Type,
_name: Name,
): DependencyName[] {
return [];
}
protected abstract makeNamedTypeNamer(): Namer;
protected abstract namerForObjectProperty(
o: ObjectType,
p: ClassProperty,
): Namer | null;
protected abstract makeUnionMemberNamer(): Namer | null;
protected abstract makeEnumCaseNamer(): Namer | null;
protected abstract emitSourceStructure(givenOutputFilename: string): void;
protected makeNameForTransformation(
_xf: Transformation,
_typeName: Name | undefined,
): Name | undefined {
return undefined;
}
protected namedTypeToNameForTopLevel(type: Type): Type | undefined {
if (isNamedType(type)) {
return type;
}
return undefined;
}
protected get unionMembersInGlobalNamespace(): boolean {
return false;
}
protected get enumCasesInGlobalNamespace(): boolean {
return false;
}
protected get needsTypeDeclarationBeforeUse(): boolean {
return false;
}
protected canBeForwardDeclared(_t: Type): boolean {
return panic(
"If needsTypeDeclarationBeforeUse returns true, canBeForwardDeclared must be implemented",
);
}
protected unionNeedsName(u: UnionType): boolean {
return nullableFromUnion(u) === null;
}
private get globalNamespace(): Namespace {
return defined(this._globalNamespace);
}
private get nameStoreView(): TypeAttributeStoreView {
return defined(this._nameStoreView);
}
protected descriptionForType(t: Type): string[] | undefined {
const description = this.typeGraph.attributeStore.tryGet(
descriptionTypeAttributeKind,
t,
);
return splitDescription(description);
}
protected descriptionForClassProperty(
o: ObjectType,
name: string,
): string[] | undefined {
const descriptions = this.typeGraph.attributeStore.tryGet(
propertyDescriptionsTypeAttributeKind,
o,
);
if (descriptions === undefined) return undefined;
return splitDescription(descriptions.get(name));
}
protected setUpNaming(): ReadonlySet {
this._nameStoreView = new TypeAttributeStoreView(
this.typeGraph.attributeStore,
assignedNameAttributeKind,
);
this._propertyNamesStoreView = new TypeAttributeStoreView(
this.typeGraph.attributeStore,
assignedPropertyNamesAttributeKind,
);
this._memberNamesStoreView = new TypeAttributeStoreView(
this.typeGraph.attributeStore,
assignedMemberNamesAttributeKind,
);
this._caseNamesStoreView = new TypeAttributeStoreView(
this.typeGraph.attributeStore,
assignedCaseNamesAttributeKind,
);
this._namesForTransformations = new Map();
this._namedTypeNamer = this.makeNamedTypeNamer();
this._unionMemberNamer = this.makeUnionMemberNamer();
this._enumCaseNamer = this.makeEnumCaseNamer();
this._globalForbiddenNamespace = keywordNamespace(
"forbidden",
this.forbiddenNamesForGlobalNamespace(),
);
this._otherForbiddenNamespaces = new Map();
this._globalNamespace = new Namespace(
"global",
undefined,
[this._globalForbiddenNamespace],
[],
);
const { objects, enums, unions } =
this.typeGraph.allNamedTypesSeparated();
const namedUnions = setFilter(unions, (u) => this.unionNeedsName(u));
for (const [name, t] of this.topLevels) {
this.nameStoreView.setForTopLevel(
name,
this.addNameForTopLevel(t, name),
);
}
for (const o of objects) {
const name = this.addNameForNamedType(o);
this.addPropertyNames(o, name);
}
for (const e of enums) {
const name = this.addNameForNamedType(e);
this.addEnumCaseNames(e, name);
}
for (const u of namedUnions) {
const name = this.addNameForNamedType(u);
this.addUnionMemberNames(u, name);
}
for (const t of this.typeGraph.allTypesUnordered()) {
this.addNameForTransformation(t);
}
return setUnion(
[this._globalForbiddenNamespace, this._globalNamespace],
this._otherForbiddenNamespaces.values(),
);
}
private addDependenciesForNamedType(type: Type, named: Name): void {
const dependencyNames = this.makeNamedTypeDependencyNames(type, named);
for (const dn of dependencyNames) {
this.globalNamespace.add(dn);
}
}
protected makeNameForTopLevel(
_t: Type,
givenName: string,
_maybeNamedType: Type | undefined,
): Name {
return new SimpleName(
[givenName],
defined(this._namedTypeNamer),
topLevelNameOrder,
);
}
private addNameForTopLevel(type: Type, givenName: string): Name {
const maybeNamedType = this.namedTypeToNameForTopLevel(type);
const name = this.makeNameForTopLevel(type, givenName, maybeNamedType);
this.globalNamespace.add(name);
const dependencyNames = this.makeTopLevelDependencyNames(type, name);
for (const dn of dependencyNames) {
this.globalNamespace.add(dn);
}
if (maybeNamedType !== undefined) {
this.addDependenciesForNamedType(maybeNamedType, name);
this.nameStoreView.set(maybeNamedType, name);
}
return name;
}
private makeNameForType(
t: Type,
namer: Namer,
givenOrder: number,
inferredOrder: number,
): Name {
const names = t.getNames();
const order = names.areInferred ? inferredOrder : givenOrder;
return new SimpleName(names.proposedNames, namer, order);
}
protected makeNameForNamedType(t: Type): Name {
return this.makeNameForType(
t,
defined(this._namedTypeNamer),
givenNameOrder,
inferredNameOrder,
);
}
private addNameForNamedType(type: Type): Name {
const existing = this.nameStoreView.tryGet(type);
if (existing !== undefined) return existing;
const name = this.globalNamespace.add(this.makeNameForNamedType(type));
this.addDependenciesForNamedType(type, name);
this.nameStoreView.set(type, name);
return name;
}
protected get typesWithNamedTransformations(): ReadonlyMap {
return defined(this._namesForTransformations);
}
protected nameForTransformation(t: Type): Name | undefined {
const xf = transformationForType(t);
if (xf === undefined) return undefined;
const name = defined(this._namesForTransformations).get(t);
if (name === undefined) {
return panic("No name for transformation");
}
return name;
}
private addNameForTransformation(t: Type): void {
const xf = transformationForType(t);
if (xf === undefined) return;
assert(
defined(this._namesForTransformations).get(t) === undefined,
"Tried to give two names to the same transformation",
);
const name = this.makeNameForTransformation(
xf,
this.nameStoreView.tryGet(xf.targetType),
);
if (name === undefined) return;
this.globalNamespace.add(name);
defined(this._namesForTransformations).set(t, name);
}
private processForbiddenWordsInfo(
info: ForbiddenWordsInfo,
namespaceName: string,
): {
forbiddenNames: ReadonlySet;
forbiddenNamespaces: ReadonlySet;
} {
const forbiddenNames: Name[] = [];
const forbiddenStrings: string[] = [];
for (const nameOrString of info.names) {
if (typeof nameOrString === "string") {
forbiddenStrings.push(nameOrString);
} else {
forbiddenNames.push(nameOrString);
}
}
let namespace = defined(this._otherForbiddenNamespaces).get(
namespaceName,
);
if (forbiddenStrings.length > 0 && namespace === undefined) {
namespace = keywordNamespace(namespaceName, forbiddenStrings);
this._otherForbiddenNamespaces = defined(
this._otherForbiddenNamespaces,
).set(namespaceName, namespace);
}
let forbiddenNamespaces = new Set();
if (info.includeGlobalForbidden) {
forbiddenNamespaces = forbiddenNamespaces.add(
defined(this._globalForbiddenNamespace),
);
}
if (namespace !== undefined) {
forbiddenNamespaces = forbiddenNamespaces.add(namespace);
}
return { forbiddenNames: new Set(forbiddenNames), forbiddenNamespaces };
}
protected makeNameForProperty(
o: ObjectType,
_className: Name,
p: ClassProperty,
jsonName: string,
assignedName: string | undefined,
): Name | undefined {
const namer = this.namerForObjectProperty(o, p);
if (namer === null) return undefined;
// FIXME: This alternative should really depend on what the
// actual name of the class ends up being. We can do this
// with a DependencyName.
// Also, we currently don't have any languages where properties
// are global, so collisions here could only occur where two
// properties of the same class have the same name, in which case
// the alternative would also be the same, i.e. useless. But
// maybe we'll need global properties for some weird language at
// some point.
const alternative = `${o.getCombinedName()}_${jsonName}`;
const order =
assignedName === undefined
? classPropertyNameOrder
: assignedClassPropertyNameOrder;
const names =
assignedName === undefined
? [jsonName, alternative]
: [assignedName];
return new SimpleName(names, namer, order);
}
protected makePropertyDependencyNames(
_o: ObjectType,
_className: Name,
_p: ClassProperty,
_jsonName: string,
_name: Name,
): Name[] {
return [];
}
private addPropertyNames(o: ObjectType, className: Name): void {
const { forbiddenNames, forbiddenNamespaces } =
this.processForbiddenWordsInfo(
this.forbiddenForObjectProperties(o, className),
"forbidden-for-properties",
);
let ns: Namespace | undefined;
const accessorNames = objectPropertyNames(o, this.targetLanguage.name);
const names = mapFilterMap(o.getSortedProperties(), (p, jsonName) => {
const [assignedName, isFixed] = getAccessorName(
accessorNames,
jsonName,
);
let name: Name | undefined;
if (isFixed) {
name = new FixedName(defined(assignedName));
} else {
name = this.makeNameForProperty(
o,
className,
p,
jsonName,
assignedName,
);
}
if (name === undefined) return undefined;
if (ns === undefined) {
ns = new Namespace(
o.getCombinedName(),
this.globalNamespace,
forbiddenNamespaces,
forbiddenNames,
);
}
ns.add(name);
for (const depName of this.makePropertyDependencyNames(
o,
className,
p,
jsonName,
name,
)) {
ns.add(depName);
}
return name;
});
defined(this._propertyNamesStoreView).set(o, names);
}
protected makeNameForUnionMember(
u: UnionType,
unionName: Name,
t: Type,
): Name {
const [assignedName, isFixed] = unionMemberName(
u,
t,
this.targetLanguage.name,
);
if (isFixed) {
return new FixedName(defined(assignedName));
}
return new DependencyName(
nonNull(this._unionMemberNamer),
unionMemberNameOrder,
(lookup) => {
if (assignedName !== undefined) return assignedName;
return this.proposeUnionMemberName(u, unionName, t, lookup);
},
);
}
private addUnionMemberNames(u: UnionType, unionName: Name): void {
const memberNamer = this._unionMemberNamer;
if (memberNamer === null) return;
const { forbiddenNames, forbiddenNamespaces } =
this.processForbiddenWordsInfo(
this.forbiddenForUnionMembers(u, unionName),
"forbidden-for-union-members",
);
let ns: Namespace;
if (this.unionMembersInGlobalNamespace) {
ns = this.globalNamespace;
} else {
ns = new Namespace(
u.getCombinedName(),
this.globalNamespace,
forbiddenNamespaces,
forbiddenNames,
);
}
const names = new Map();
for (const t of u.members) {
const name = this.makeNameForUnionMember(
u,
unionName,
followTargetType(t),
);
names.set(t, ns.add(name));
}
defined(this._memberNamesStoreView).set(u, names);
}
protected makeNameForEnumCase(
e: EnumType,
_enumName: Name,
caseName: string,
assignedName: string | undefined,
): Name {
// FIXME: See the FIXME in `makeNameForProperty`. We do have global
// enum cases, though (in Go), so this is actually useful already.
const alternative = `${e.getCombinedName()}_${caseName}`;
const order =
assignedName === undefined
? enumCaseNameOrder
: assignedEnumCaseNameOrder;
const names =
assignedName === undefined
? [caseName, alternative]
: [assignedName];
return new SimpleName(names, nonNull(this._enumCaseNamer), order);
}
// FIXME: this is very similar to addPropertyNameds and addUnionMemberNames
private addEnumCaseNames(e: EnumType, enumName: Name): void {
if (this._enumCaseNamer === null) return;
const { forbiddenNames, forbiddenNamespaces } =
this.processForbiddenWordsInfo(
this.forbiddenForEnumCases(e, enumName),
"forbidden-for-enum-cases",
);
let ns: Namespace;
if (this.enumCasesInGlobalNamespace) {
ns = this.globalNamespace;
} else {
ns = new Namespace(
e.getCombinedName(),
this.globalNamespace,
forbiddenNamespaces,
forbiddenNames,
);
}
const names = new Map();
const accessorNames = enumCaseNames(e, this.targetLanguage.name);
for (const caseName of e.cases) {
const [assignedName, isFixed] = getAccessorName(
accessorNames,
caseName,
);
let name: Name;
if (isFixed) {
name = new FixedName(defined(assignedName));
} else {
name = this.makeNameForEnumCase(
e,
enumName,
caseName,
assignedName,
);
}
names.set(caseName, ns.add(name));
}
defined(this._caseNamesStoreView).set(e, names);
}
private childrenOfType(t: Type): ReadonlySet {
const names = this.names;
if (t instanceof ClassType) {
const propertyNameds = defined(this._propertyNamesStoreView).get(t);
const filteredMap = mapFilterMap(t.getProperties(), (p, n) => {
if (propertyNameds.get(n) === undefined) return undefined;
return p.type;
});
const sortedMap = mapSortBy(filteredMap, (_, n) =>
defined(names.get(defined(propertyNameds.get(n)))),
);
return new Set(sortedMap.values());
}
return t.getChildren();
}
protected get namedUnions(): ReadonlySet {
return defined(this._namedUnions);
}
protected get haveNamedUnions(): boolean {
return this.namedUnions.size > 0;
}
protected get haveNamedTypes(): boolean {
return defined(this._namedTypes).length > 0;
}
protected get haveUnions(): boolean {
return defined(this._haveUnions);
}
protected get haveMaps(): boolean {
return defined(this._haveMaps);
}
protected get haveOptionalProperties(): boolean {
return defined(this._haveOptionalProperties);
}
// FIXME: Inconsistently named, though technically correct. Right now all enums are named,
// but this should really be called `namedEnums`.
protected get enums(): ReadonlySet {
return defined(this._namedEnums);
}
protected get haveEnums(): boolean {
return this.enums.size > 0;
}
protected proposedUnionMemberNameForTypeKind(
_kind: TypeKind,
): string | null {
return null;
}
protected proposeUnionMemberName(
_u: UnionType,
_unionName: Name,
fieldType: Type,
lookup: (n: Name) => string,
): string {
const simpleName = this.proposedUnionMemberNameForTypeKind(
fieldType.kind,
);
if (simpleName !== null) {
return simpleName;
}
const typeNameForUnionMember = (t: Type): string =>
matchTypeExhaustive(
t,
(_noneType) => {
return panic("none type should have been replaced");
},
(_anyType) => "anything",
(_nullType) => "null",
(_boolType) => "bool",
(_integerType) => "integer",
(_doubleType) => "double",
(_stringType) => "string",
(arrayType) =>
typeNameForUnionMember(arrayType.items) + "_array",
(classType) => lookup(this.nameForNamedType(classType)),
(mapType) => typeNameForUnionMember(mapType.values) + "_map",
(objectType) => {
assert(
this.targetLanguage.supportsFullObjectType,
"Object type should have been replaced in `replaceObjectType`",
);
return lookup(this.nameForNamedType(objectType));
},
(_enumType) => "enum",
(_unionType) => "union",
(transformedType) => transformedType.kind.replace("-", "_"),
);
return typeNameForUnionMember(fieldType);
}
protected nameForNamedType(t: Type): Name {
return this.nameStoreView.get(t);
}
protected isForwardDeclaredType(t: Type): boolean {
return defined(this._declarationIR).forwardedTypes.has(t);
}
protected isImplicitCycleBreaker(_t: Type): boolean {
return panic(
"A renderer that invokes isCycleBreakerType must implement isImplicitCycleBreaker",
);
}
protected canBreakCycles(_t: Type): boolean {
return true;
}
protected isCycleBreakerType(t: Type): boolean {
if (this._cycleBreakerTypes === undefined) {
this._cycleBreakerTypes = cycleBreakerTypesForGraph(
this.typeGraph,
(s) => this.isImplicitCycleBreaker(s),
(s) => this.canBreakCycles(s),
);
}
return this._cycleBreakerTypes.has(t);
}
protected forEachTopLevel(
blankLocations: BlankLineConfig,
f: (t: Type, name: Name, position: ForEachPosition) => void,
predicate?: (t: Type) => boolean,
): boolean {
let topLevels: ReadonlyMap;
if (predicate !== undefined) {
topLevels = mapFilter(this.topLevels, predicate);
} else {
topLevels = this.topLevels;
}
return this.forEachWithBlankLines(
topLevels,
blankLocations,
(t, name, pos) =>
f(t, this.nameStoreView.getForTopLevel(name), pos),
);
}
protected forEachDeclaration(
blankLocations: BlankLineConfig,
f: (decl: Declaration, position: ForEachPosition) => void,
): void {
this.forEachWithBlankLines(
iterableEnumerate(defined(this._declarationIR).declarations),
blankLocations,
(decl, _, pos) => f(decl, pos),
);
}
public setAlphabetizeProperties(value: boolean): void {
this._alphabetizeProperties = value;
}
protected getAlphabetizeProperties(): boolean {
return this._alphabetizeProperties;
}
// Returns the number of properties defined for the specified object type.
protected propertyCount(o: ObjectType): number {
const propertyNames = defined(this._propertyNamesStoreView).get(o);
return propertyNames.size;
}
protected sortClassProperties(
properties: ReadonlyMap,
propertyNames: ReadonlyMap,
): ReadonlyMap {
if (this._alphabetizeProperties) {
return mapSortBy(
properties,
(_p: ClassProperty, jsonName: string) => {
const name = defined(propertyNames.get(jsonName));
return defined(this.names.get(name));
},
);
}
return properties;
}
protected forEachClassProperty(
o: ObjectType,
blankLocations: BlankLineConfig,
f: (
name: Name,
jsonName: string,
p: ClassProperty,
position: ForEachPosition,
) => void,
): void {
const propertyNames = defined(this._propertyNamesStoreView).get(o);
const sortedProperties = this.sortClassProperties(
o.getProperties(),
propertyNames,
);
this.forEachWithBlankLines(
sortedProperties,
blankLocations,
(p, jsonName, pos) => {
const name = defined(propertyNames.get(jsonName));
f(name, jsonName, p, pos);
},
);
}
protected nameForUnionMember(u: UnionType, t: Type): Name {
return defined(defined(this._memberNamesStoreView).get(u).get(t));
}
protected nameForEnumCase(e: EnumType, caseName: string): Name {
const caseNames = defined(this._caseNamesStoreView).get(e);
return defined(caseNames.get(caseName));
}
protected forEachUnionMember(
u: UnionType,
members: ReadonlySet | null,
blankLocations: BlankLineConfig,
sortOrder: ((n: Name, t: Type) => string) | null,
f: (name: Name, t: Type, position: ForEachPosition) => void,
): void {
const iterateMembers = members ?? u.members;
if (sortOrder === null) {
sortOrder = (n): string => defined(this.names.get(n));
}
const memberNames = mapFilter(
defined(this._memberNamesStoreView).get(u),
(_, t) => iterateMembers.has(t),
);
const sortedMemberNames = mapSortBy(memberNames, sortOrder);
this.forEachWithBlankLines(sortedMemberNames, blankLocations, f);
}
protected forEachEnumCase(
e: EnumType,
blankLocations: BlankLineConfig,
f: (name: Name, jsonName: string, position: ForEachPosition) => void,
): void {
const caseNames = defined(this._caseNamesStoreView).get(e);
const sortedCaseNames = mapSortBy(caseNames, (n) =>
defined(this.names.get(n)),
);
this.forEachWithBlankLines(sortedCaseNames, blankLocations, f);
}
protected forEachTransformation(
blankLocations: BlankLineConfig,
f: (n: Name, t: Type, position: ForEachPosition) => void,
): void {
this.forEachWithBlankLines(
defined(this._namesForTransformations),
blankLocations,
f,
);
}
protected forEachSpecificNamedType(
blankLocations: BlankLineConfig,
types: Iterable<[T, T]>,
f: (t: T, name: Name, position: ForEachPosition) => void,
): void {
this.forEachWithBlankLines(types, blankLocations, (t, _, pos) =>
f(t, this.nameForNamedType(t), pos),
);
}
protected forEachObject(
blankLocations: BlankLineConfig,
f:
| ((
c: ClassType,
className: Name,
position: ForEachPosition,
) => void)
| ((
o: ObjectType,
objectName: Name,
position: ForEachPosition,
) => void),
): void {
// FIXME: This is ugly.
this.forEachSpecificNamedType(
blankLocations,
defined(this._namedObjects).entries(),
f,
);
}
protected forEachEnum(
blankLocations: BlankLineConfig,
f: (u: EnumType, enumName: Name, position: ForEachPosition) => void,
): void {
this.forEachSpecificNamedType(blankLocations, this.enums.entries(), f);
}
protected forEachUnion(
blankLocations: BlankLineConfig,
f: (u: UnionType, unionName: Name, position: ForEachPosition) => void,
): void {
this.forEachSpecificNamedType(
blankLocations,
this.namedUnions.entries(),
f,
);
}
protected forEachUniqueUnion(
blankLocations: BlankLineConfig,
uniqueValue: (u: UnionType) => T,
f: (firstUnion: UnionType, value: T, position: ForEachPosition) => void,
): void {
const firstUnionByValue = new Map();
for (const u of this.namedUnions) {
const v = uniqueValue(u);
if (!firstUnionByValue.has(v)) {
firstUnionByValue.set(v, u);
}
}
this.forEachWithBlankLines(firstUnionByValue, blankLocations, f);
}
protected forEachNamedType(
blankLocations: BlankLineConfig,
objectFunc:
| ((
c: ClassType,
className: Name,
position: ForEachPosition,
) => void)
| ((
o: ObjectType,
objectName: Name,
position: ForEachPosition,
) => void),
enumFunc: (
e: EnumType,
enumName: Name,
position: ForEachPosition,
) => void,
unionFunc: (
u: UnionType,
unionName: Name,
position: ForEachPosition,
) => void,
): void {
this.forEachWithBlankLines(
defined(this._namedTypes).entries(),
blankLocations,
(t, _, pos) => {
const name = this.nameForNamedType(t);
if (t instanceof ObjectType) {
// FIXME: This is ugly. We can't runtime check that the function
// takes full object types if we have them.
objectFunc(t, name, pos);
} else if (t instanceof EnumType) {
enumFunc(t, name, pos);
} else if (t instanceof UnionType) {
unionFunc(t, name, pos);
} else {
return panic("Named type that's neither a class nor union");
}
},
);
}
// You should never have to use this to produce parts of your generated
// code. If you need to modify a Name, for example to change its casing,
// use `modifySource`.
protected sourcelikeToString(src: Sourcelike): string {
return serializeRenderResult(
sourcelikeToSource(src),
this.names,
"",
).lines.join("\n");
}
protected get commentLineStart(): string {
return "// ";
}
protected emitComments(comments: Comment[]): void {
comments.forEach((comment) => {
if (isStringComment(comment)) {
this.emitCommentLines([comment]);
} else if ("lines" in comment) {
this.emitCommentLines(comment.lines);
} else if ("descriptionBlock" in comment) {
this.emitDescriptionBlock(comment.descriptionBlock);
} else {
this.emitCommentLines(comment.customLines, comment);
}
this.ensureBlankLine();
});
}
protected emitCommentLines(
lines: Sourcelike[],
{
lineStart = this.commentLineStart,
firstLineStart = lineStart,
lineEnd,
beforeComment,
afterComment,
}: CommentOptions = {},
): void {
if (beforeComment !== undefined) {
this.emitLine(beforeComment);
}
let first = true;
for (const line of lines) {
let start = first ? firstLineStart : lineStart;
first = false;
if (this.sourcelikeToString(line) === "") {
start = trimEnd(start);
}
if (lineEnd) {
this.emitLine(start, line, lineEnd);
} else {
this.emitLine(start, line);
}
}
if (afterComment !== undefined) {
this.emitLine(afterComment);
}
}
protected emitDescription(description: Sourcelike[] | undefined): void {
if (description === undefined) return;
// FIXME: word-wrap
this.emitDescriptionBlock(description);
}
protected emitDescriptionBlock(lines: Sourcelike[]): void {
this.emitCommentLines(lines);
}
protected emitPropertyTable(
c: ClassType,
makePropertyRow: (
name: Name,
jsonName: string,
p: ClassProperty,
) => Sourcelike[],
): void {
let table: Sourcelike[][] = [];
const emitTable = (): void => {
if (table.length === 0) return;
this.emitTable(table);
table = [];
};
this.forEachClassProperty(c, "none", (name, jsonName, p) => {
const description = this.descriptionForClassProperty(c, jsonName);
if (description !== undefined) {
emitTable();
this.emitDescription(description);
}
table.push(makePropertyRow(name, jsonName, p));
});
emitTable();
}
private processGraph(): void {
this._declarationIR = declarationsForGraph(
this.typeGraph,
this.needsTypeDeclarationBeforeUse
? (t): boolean => this.canBeForwardDeclared(t)
: undefined,
(t) => this.childrenOfType(t),
(t) => {
if (t instanceof UnionType) {
return this.unionNeedsName(t);
}
return isNamedType(t);
},
);
const types = this.typeGraph.allTypesUnordered();
this._haveUnions = iterableSome(types, (t) => t instanceof UnionType);
this._haveMaps = iterableSome(types, (t) => t instanceof MapType);
const classTypes = setFilter(
types,
(t) => t instanceof ClassType,
) as Set;
this._haveOptionalProperties = iterableSome(classTypes, (c) =>
mapSome(c.getProperties(), (p) => p.isOptional),
);
this._namedTypes = this._declarationIR.declarations
.filter((d) => d.kind === "define")
.map((d) => d.type);
const { objects, enums, unions } = separateNamedTypes(this._namedTypes);
this._namedObjects = new Set(objects);
this._namedEnums = new Set(enums);
this._namedUnions = new Set(unions);
}
protected emitSource(givenOutputFilename: string): void {
this.processGraph();
this.emitSourceStructure(givenOutputFilename);
}
protected forEachType(
process: (t: Type) => TResult,
): Set {
const visitedTypes = new Set();
const processed = new Set();
const queue = Array.from(this.typeGraph.topLevels.values());
function visit(t: Type): void {
if (visitedTypes.has(t)) return;
for (const c of t.getChildren()) {
queue.push(c);
}
visitedTypes.add(t);
processed.add(process(t));
}
for (;;) {
const maybeType = queue.pop();
if (maybeType === undefined) {
break;
}
visit(maybeType);
}
return processed;
}
}
================================================
FILE: packages/quicktype-core/src/CycleBreaker.ts
================================================
import { assert, panic } from "./support/Support";
export function breakCycles(
outEdges: number[][],
chooseBreaker: (cycle: number[]) => [number, T],
): Array<[number, T]> {
const numNodes = outEdges.length;
const inEdges: number[][] = [];
const inDegree: number[] = [];
const outDegree: number[] = [];
const done: boolean[] = [];
const results: Array<[number, T]> = [];
for (let i = 0; i < numNodes; i++) {
inEdges.push([]);
inDegree.push(0);
outDegree.push(outEdges[i].length);
done.push(false);
}
for (let i = 0; i < numNodes; i++) {
for (const n of outEdges[i]) {
inEdges[n].push(i);
inDegree[n] += 1;
}
}
const workList: number[] = [];
for (let i = 0; i < numNodes; i++) {
if (inDegree[i] === 0 || outDegree[i] === 0) {
workList.push(i);
}
}
function removeNode(node: number): void {
for (const n of outEdges[node]) {
assert(inDegree[n] > 0);
inDegree[n] -= 1;
if (inDegree[n] === 0) {
workList.push(n);
}
}
for (const n of inEdges[node]) {
assert(outDegree[n] > 0);
outDegree[n] -= 1;
if (outDegree[n] === 0) {
workList.push(n);
}
}
done[node] = true;
}
for (;;) {
const i = workList.pop();
if (i !== undefined) {
if (done[i] || (inDegree[i] === 0 && outDegree[i] === 0)) {
done[i] = true;
continue;
}
assert(
inDegree[i] === 0 || outDegree[i] === 0,
"Can't have nodes in the worklist with in and out edges",
);
removeNode(i);
continue;
}
let n = done.indexOf(false);
if (n < 0) {
// We're done!
break;
}
// There's a cycle
const path: number[] = [n];
for (;;) {
// FIXME: We look an arbitrary node that's still in the graph and follow it
// until we see a cycle. This cycle might not be the first cycle the needs to
// be broken. For example, imagine two cycles that are connected via an edge,
// i.e. one cycle depends on the other cycle. The dependee cycle should be
// broken up first.
//
// We could count the number of reachable nodes for all nodes in the graph,
// and then pick one of the nodes with the lowest number, which would pick
// the dependee cycle.
const maybeEdge = outEdges[n].find((x) => !done[x]);
if (maybeEdge === undefined) {
return panic("Presumed cycle is not a cycle");
}
const maybeFirst = path.indexOf(maybeEdge);
if (maybeFirst === undefined) {
// No cycle yet, continue
n = maybeEdge;
path.push(n);
continue;
}
// We found a cycle - break it
const cycle = path.slice(maybeFirst);
const [breakNode, info] = chooseBreaker(cycle);
assert(cycle.includes(breakNode), "Breaker chose an invalid node");
removeNode(breakNode);
results.push([breakNode, info]);
break;
}
continue;
}
return results;
}
================================================
FILE: packages/quicktype-core/src/DateTime.ts
================================================
/* eslint-disable */
// https://github.com/epoberezkin/ajv/blob/4d76c6fb813b136b6ec4fe74990bc97233d75dea/lib/compile/formats.js
/*
The MIT License (MIT)
Copyright (c) 2015 Evgeny Poberezkin
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
const DAYS = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
const TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d:\d\d)?$/i;
export interface DateTimeRecognizer {
isDate: (s: string) => boolean;
isDateTime: (s: string) => boolean;
isTime: (s: string) => boolean;
}
const DATE_TIME_SEPARATOR = /t|\s/i;
export class DefaultDateTimeRecognizer implements DateTimeRecognizer {
isDate(str: string) {
// full-date from http://tools.ietf.org/html/rfc3339#section-5.6
const matches = DATE.exec(str);
if (matches === null) return false;
const month = +matches[2];
const day = +matches[3];
return month >= 1 && month <= 12 && day >= 1 && day <= DAYS[month];
}
isTime(str: string): boolean {
const matches = TIME.exec(str);
if (matches === null) return false;
const hour = +matches[1];
const minute = +matches[2];
const second = +matches[3];
return hour <= 23 && minute <= 59 && second <= 59;
}
isDateTime(str: string): boolean {
// http://tools.ietf.org/html/rfc3339#section-5.6
const dateTime = str.split(DATE_TIME_SEPARATOR);
return (
dateTime.length === 2 &&
this.isDate(dateTime[0]) &&
this.isTime(dateTime[1])
);
}
}
================================================
FILE: packages/quicktype-core/src/DeclarationIR.ts
================================================
import {
iterableFirst,
setFilter,
setIntersect,
setSubtract,
setUnionInto,
} from "collection-utils";
import { Graph } from "./Graph";
import { messageError } from "./Messages";
import { assert, defined, panic } from "./support/Support";
import type { Type } from "./Type/Type";
import type { TypeGraph } from "./Type/TypeGraph";
export type DeclarationKind = "forward" | "define";
export interface Declaration {
readonly kind: DeclarationKind;
readonly type: Type;
}
export class DeclarationIR {
public readonly declarations: readonly Declaration[];
public constructor(
declarations: Iterable,
public readonly forwardedTypes: Set,
) {
this.declarations = Array.from(declarations);
}
}
function findBreaker(
t: Type,
path: readonly Type[],
canBreak: ((t: Type) => boolean) | undefined,
): Type | undefined {
const index = path.indexOf(t);
if (index < 0) return undefined;
if (canBreak === undefined) {
return path[index];
}
const potentialBreakers = path.slice(0, index + 1).reverse();
const maybeBreaker = potentialBreakers.find(canBreak);
if (maybeBreaker === undefined) {
return panic("Found a cycle that cannot be broken");
}
return maybeBreaker;
}
export function cycleBreakerTypesForGraph(
graph: TypeGraph,
isImplicitCycleBreaker: (t: Type) => boolean,
canBreakCycles: (t: Type) => boolean,
): Set {
const visitedTypes = new Set();
const cycleBreakerTypes = new Set();
const queue: Type[] = Array.from(graph.topLevels.values());
function visit(t: Type, path: Type[]): void {
if (visitedTypes.has(t)) return;
if (isImplicitCycleBreaker(t)) {
for (const c of t.getChildren()) {
queue.push(c);
}
} else {
const maybeBreaker = findBreaker(t, path, canBreakCycles);
if (maybeBreaker !== undefined) {
cycleBreakerTypes.add(maybeBreaker);
return;
}
for (const c of t.getChildren()) {
path.unshift(t);
visit(c, path);
path.shift();
}
}
visitedTypes.add(t);
}
for (;;) {
const maybeType = queue.pop();
if (maybeType === undefined) break;
const path: Type[] = [];
visit(maybeType, path);
assert(path.length === 0);
}
return cycleBreakerTypes;
}
export function declarationsForGraph(
typeGraph: TypeGraph,
canBeForwardDeclared: ((t: Type) => boolean) | undefined,
childrenOfType: (t: Type) => ReadonlySet,
needsDeclaration: (t: Type) => boolean,
): DeclarationIR {
/*
function nodeTitle(t: Type): string {
const indexAndKind = `${t.typeRef.index} ${t.kind}`;
if (t.hasNames) {
return `${indexAndKind} ${t.getCombinedName()}`;
} else {
return indexAndKind;
}
}
function componentName(c: Iterable): string {
return Array.from(c).map(nodeTitle).join(", ");
}
*/
const topDown = canBeForwardDeclared === undefined;
const declarations: Declaration[] = [];
const forwardedTypes = new Set();
const visitedComponents = new Set>();
function processGraph(graph: Graph, _writeComponents: boolean): void {
const componentsGraph = graph.stronglyConnectedComponents();
function visitComponent(component: ReadonlySet): void {
if (visitedComponents.has(component)) return;
visitedComponents.add(component);
// console.log(`visiting component ${componentName(component)}`);
const declarationNeeded = setFilter(component, needsDeclaration);
// 1. Only one node in the cycle needs a declaration, in which
// case it's the breaker, and no forward declaration is necessary.
if (declarationNeeded.size === 1) {
declarations.push({
kind: "define",
type: defined(iterableFirst(declarationNeeded)),
});
return;
}
// 2. No node in the cycle needs a declaration, but it's also
// the only node, so we don't actually need a declaration at all.
if (declarationNeeded.size === 0 && component.size === 1) {
return;
}
// 3. No node in the cycle needs a declaration, but there's more.
// than one node total. We have to pick a node to make a
// declaration, so we can pick any one. This is not a forward
// declaration, either.
if (declarationNeeded.size === 0) {
declarations.push({
kind: "define",
type: defined(iterableFirst(component)),
});
return;
}
// 4. More than one node needs a declaration, and we don't need
// forward declarations. Just declare all of them and be done
// with it.
if (canBeForwardDeclared === undefined) {
for (const t of declarationNeeded) {
declarations.push({ kind: "define", type: t });
}
return;
}
// 5. More than one node needs a declaration, and we have
// to make forward declarations. We do the simple thing and first
// forward-declare all forward-declarable types in the SCC. If
// there are none, we're stuck. If there are, we take them out of
// the component and try the whole thing again recursively. Then
// we declare the types we previously forward-declared.
const forwardDeclarable = setFilter(
component,
canBeForwardDeclared,
);
if (forwardDeclarable.size === 0) {
messageError("IRNoForwardDeclarableTypeInCycle", {});
}
for (const t of forwardDeclarable) {
declarations.push({ kind: "forward", type: t });
}
setUnionInto(forwardedTypes, forwardDeclarable);
const rest = setSubtract(component, forwardDeclarable);
const restGraph = new Graph(rest, true, (t) =>
setIntersect(childrenOfType(t), rest),
);
processGraph(restGraph, false);
for (const t of forwardDeclarable) {
declarations.push({ kind: "define", type: t });
}
return;
}
/*
if (_writeComponents) {
componentsGraph.nodes.forEach(types => {
console.log(
`scc: ${types
.filter(t => t instanceof ClassType)
.map(t => t.getCombinedName())
.join(", ")}`
);
});
}
*/
const rootsUnordered = componentsGraph.findRoots();
const roots = rootsUnordered;
for (const component of roots) {
componentsGraph.dfsTraversal(component, topDown, visitComponent);
}
}
const fullGraph = typeGraph.makeGraph(false, childrenOfType);
// fs.writeFileSync("graph.dot", fullGraph.makeDot(t => !(t instanceof PrimitiveType), nodeTitle));
processGraph(fullGraph, true);
return new DeclarationIR(declarations, forwardedTypes);
}
================================================
FILE: packages/quicktype-core/src/EncodedMarkovChain.ts
================================================
export const encodedMarkovChain =
"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";
================================================
FILE: packages/quicktype-core/src/GatherNames.ts
================================================
import { setMap, setSortBy, setUnion } from "collection-utils";
import * as pluralize from "pluralize";
import {
TooManyTypeNames,
TypeNames,
namesTypeAttributeKind,
tooManyNamesThreshold,
} from "./attributes/TypeNames";
import { assert, defined, panic } from "./support/Support";
import { transformationForType } from "./Transformers";
import { ObjectType, type Type } from "./Type/Type";
import type { TypeGraph } from "./Type/TypeGraph";
import { matchCompoundType, nullableFromUnion } from "./Type/TypeUtils";
class UniqueQueue {
private readonly _present = new Set();
private _queue: Array = [];
private _front = 0;
public get size(): number {
return this._queue.length - this._front;
}
public get isEmpty(): boolean {
return this.size <= 0;
}
public push(v: T): void {
if (this._present.has(v)) return;
this._queue.push(v);
this._present.add(v);
}
public unshift(): T {
assert(!this.isEmpty, "Trying to unshift from an empty queue");
const v = this._queue[this._front];
if (v === undefined) {
return panic("Value should have been present in queue");
}
this._queue[this._front] = undefined;
this._front += 1;
this._present.delete(v);
if (this._front > this.size) {
this._queue = this._queue.slice(this._front);
this._front = 0;
}
return v;
}
}
// `gatherNames` infers names from given names and property names.
//
// 1. Propagate type and property names down to children. Let's say
// we start with JSON like this, and we name the top-level `TopLevel`:
//
// {
// "foos": [ [ { "bar": 123 } ] ]
// }
//
// We use a work-list algorithm to first add the name `TopLevel` to
// the outermost class type. Then we propagate the property name
// `foos` to the outer array, which in turn propagates its singular
// `foo` to the inner array type. That tries to singularize `foo`,
// but it's already singular, so `foo` is added as a name for the
// inner class. We also then add `bar` to the name of the integer
// type.
//
// 2. Add "ancestor" alternatives and some "direct" alternatives.
// Direct alternatives are those that don't contain any ancestor
// names, whereas ancestor alternatives do. What we do here is add
// names of the form `TopLevel_foo` and `TopLevel_foo_class` as
// ancestor alternatives to the inner class, and `foo_element` as
// a direct alternative, the latter because it's an element in an
// array.
//
// 3. Add more direct alternatives to the type names. The reason we're
// doing this separately from step 2 is because step 2 only requires
// iterating over the types, wheras this step iterates over
// ancestor/descendant relationships. In this case we would add
// `TopLevel_class`, and `foo_class` to the outer and inner classes,
// respectively. We do similar stuff for all the other types.
//
// 4. For each type, set its inferred names to what we gathered in
// step 1, and its alternatives to a union of its direct and ancestor
// alternatives, gathered in steps 2 and 3.
export function gatherNames(
graph: TypeGraph,
destructive: boolean,
debugPrint: boolean,
): void {
function setNames(t: Type, tn: TypeNames): void {
graph.attributeStore.set(namesTypeAttributeKind, t, tn);
}
if (destructive) {
for (const t of graph.allTypesUnordered()) {
if (t.hasNames) {
setNames(t, t.getNames().clearInferred());
}
}
}
const queue = new UniqueQueue();
// null means there are too many
const namesForType = new Map | null>();
function addNames(t: Type, names: ReadonlySet | null): void {
// Always use the type's given names if it has some
if (t.hasNames) {
const originalNames = t.getNames();
if (!originalNames.areInferred) {
names = originalNames.names;
}
}
const oldNames = namesForType.get(t);
if (oldNames === null) return;
let newNames: ReadonlySet | null;
if (oldNames === undefined) {
newNames = names;
} else if (names === null) {
newNames = null;
} else {
newNames = setUnion(oldNames, names);
}
if (newNames !== null && newNames.size >= tooManyNamesThreshold) {
newNames = null;
}
namesForType.set(t, newNames);
const transformation = transformationForType(t);
if (transformation !== undefined) {
addNames(transformation.targetType, names);
}
if (oldNames !== undefined && newNames !== null) {
if (oldNames.size === newNames.size) {
return;
}
} else if (oldNames === newNames) {
return;
}
queue.push(t);
}
for (const [name, t] of graph.topLevels) {
addNames(t, new Set([name]));
}
while (!queue.isEmpty) {
const t = queue.unshift();
const names = defined(namesForType.get(t));
if (t instanceof ObjectType) {
const properties = t.getSortedProperties();
for (const [propertyName, property] of properties) {
addNames(property.type, new Set([propertyName]));
}
const values = t.getAdditionalProperties();
if (values !== undefined) {
addNames(
values,
names === null ? null : setMap(names, pluralize.singular),
);
}
} else {
matchCompoundType(
t,
(arrayType) => {
addNames(
arrayType.items,
names === null
? null
: setMap(names, pluralize.singular),
);
},
(_classType) => panic("We handled this above"),
(_mapType) => panic("We handled this above"),
(_objectType) => panic("We handled this above"),
(unionType) => {
const members = setSortBy(
unionType.members,
(member) => member.kind,
);
for (const memberType of members) {
addNames(memberType, names);
}
},
);
}
}
if (debugPrint) {
for (const t of graph.allTypesUnordered()) {
const names = namesForType.get(t);
if (names === undefined) return;
const index = t.index;
console.log(
`${index}: ${names === null ? "*** too many ***" : Array.from(names).join(" ")}`,
);
}
}
// null means there are too many
const directAlternativesForType = new Map<
Type,
ReadonlySet | null
>();
const ancestorAlternativesForType = new Map<
Type,
ReadonlySet | null
>();
const pairsProcessed = new Map>();
function addAlternatives(
existing: ReadonlySet | undefined,
alternatives: string[],
): ReadonlySet | undefined | null {
if (alternatives.length === 0) {
return existing;
}
if (existing === undefined) {
existing = new Set();
}
existing = setUnion(existing, alternatives);
if (existing.size < tooManyNamesThreshold) {
return existing;
}
return null;
}
function processType(
ancestor: Type | undefined,
t: Type,
alternativeSuffix: string | undefined,
): void {
const names = defined(namesForType.get(t));
let processedEntry = pairsProcessed.get(ancestor);
if (processedEntry === undefined) processedEntry = new Set();
if (processedEntry.has(t)) return;
processedEntry.add(t);
pairsProcessed.set(ancestor, processedEntry);
const transformation = transformationForType(t);
if (transformation !== undefined) {
processType(ancestor, transformation.targetType, alternativeSuffix);
}
let ancestorAlternatives = ancestorAlternativesForType.get(t);
let directAlternatives = directAlternativesForType.get(t);
if (names === null) {
ancestorAlternatives = null;
directAlternatives = null;
} else {
if (ancestor !== undefined && ancestorAlternatives !== null) {
const ancestorNames = namesForType.get(ancestor);
if (ancestorNames === null) {
ancestorAlternatives = null;
} else if (ancestorNames !== undefined) {
const alternatives: string[] = [];
for (const name of names) {
alternatives.push(
...Array.from(ancestorNames).map(
(an) => `${an}_${name}`,
),
);
// FIXME: add alternatives with the suffix here, too?
alternatives.push(
...Array.from(ancestorNames).map(
(an) => `${an}_${name}_${t.kind}`,
),
);
// FIXME: add alternatives with the suffix here, too?
}
ancestorAlternatives = addAlternatives(
ancestorAlternatives,
alternatives,
);
}
}
if (
alternativeSuffix !== undefined &&
directAlternatives !== null
) {
const alternatives: string[] = [];
for (const name of names) {
// FIXME: we should only add these for names we couldn't singularize
alternatives.push(`${name}_${alternativeSuffix}`);
}
directAlternatives = addAlternatives(
directAlternatives,
alternatives,
);
}
}
if (ancestorAlternatives !== undefined) {
ancestorAlternativesForType.set(t, ancestorAlternatives);
}
if (directAlternatives !== undefined) {
directAlternativesForType.set(t, directAlternatives);
}
if (t instanceof ObjectType) {
const properties = t.getSortedProperties();
for (const [, property] of properties) {
processType(t, property.type, undefined);
}
const values = t.getAdditionalProperties();
if (values !== undefined) {
processType(
properties.size === 0 ? ancestor : t,
values,
"value",
);
}
} else {
matchCompoundType(
t,
(arrayType) => {
processType(ancestor, arrayType.items, "element");
},
(_classType) => panic("We handled this above"),
(_mapType) => panic("We handled this above"),
(_objectType) => panic("We handled this above"),
(unionType) => {
const members = setSortBy(
unionType.members,
(member) => member.kind,
);
const unionHasGivenName =
unionType.hasNames && !unionType.getNames().areInferred;
const unionIsAncestor =
unionHasGivenName ||
nullableFromUnion(unionType) === null;
const ancestorForMembers = unionIsAncestor
? unionType
: ancestor;
for (const memberType of members) {
processType(ancestorForMembers, memberType, undefined);
}
},
);
}
}
for (const [, t] of graph.topLevels) {
processType(undefined, t, undefined);
}
for (const t of graph.allTypesUnordered()) {
const names = namesForType.get(t);
if (names === undefined) continue;
if (names === null) {
directAlternativesForType.set(t, null);
continue;
}
let alternatives = directAlternativesForType.get(t);
if (alternatives === null) continue;
if (alternatives === undefined) {
alternatives = new Set();
}
alternatives = setUnion(
alternatives,
setMap(names, (name) => `${name}_${t.kind}`),
);
directAlternativesForType.set(t, alternatives);
}
for (const t of graph.allTypesUnordered()) {
const names = namesForType.get(t);
if (names === undefined) continue;
let typeNames: TypeNames;
if (names === null) {
typeNames = new TooManyTypeNames(1);
} else {
const ancestorAlternatives = ancestorAlternativesForType.get(t);
const directAlternatives = directAlternativesForType.get(t);
let alternatives: ReadonlySet | undefined;
if (ancestorAlternatives === null && directAlternatives === null) {
alternatives = undefined;
} else {
if (
directAlternatives !== null &&
directAlternatives !== undefined
) {
alternatives = directAlternatives;
} else {
alternatives = new Set();
}
if (
ancestorAlternatives !== null &&
ancestorAlternatives !== undefined
) {
alternatives = setUnion(alternatives, ancestorAlternatives);
}
}
typeNames = TypeNames.makeWithDistance(
names,
alternatives,
destructive ? 1 : 10,
);
}
setNames(t, t.hasNames ? t.getNames().add([typeNames]) : typeNames);
}
}
================================================
FILE: packages/quicktype-core/src/Graph.ts
================================================
import { setMap } from "collection-utils";
import { assert, defined, repeated, repeatedCall } from "./support/Support";
function countComponentGraphNodes(components: number[][]): number {
if (components.length === 0) return 0;
let largest = -1;
let count = 0;
for (const c of components) {
assert(c.length > 0, "Empty component not allowed");
for (const v of c) {
assert(v >= 0, "Negative vertex index is invalid");
largest = Math.max(largest, v);
count += 1;
}
}
assert(largest + 1 === count, "Vertex indexes and count don't match up");
return count;
}
// https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
function stronglyConnectedComponents(successors: number[][]): number[][] {
let index = 0;
const stack: number[] = [];
const numNodes = successors.length;
const indexes: number[] = repeated(numNodes, -1);
const lowLinks: number[] = repeated(numNodes, -1);
const onStack: boolean[] = repeated(numNodes, false);
const sccs: number[][] = [];
function strongconnect(v: number): void {
// Set the depth index for v to the smallest unused index
indexes[v] = index;
lowLinks[v] = index;
index += 1;
stack.push(v);
onStack[v] = true;
// Consider successors of v
for (const w of successors[v]) {
if (indexes[w] < 0) {
// Successor w has not yet been visited; recurse on it
strongconnect(w);
lowLinks[v] = Math.min(lowLinks[v], lowLinks[w]);
} else if (onStack[w]) {
// Successor w is in stack and hence in the current SCC
// If w is not on stack, then (v, w) is a cross-edge in the DFS tree and must be ignored
// Note: The next line may look odd - but is correct.
// It says w.index not w.lowlink; that is deliberate and from the original paper
lowLinks[v] = Math.min(lowLinks[v], indexes[w]);
}
}
// If v is a root node, pop the stack and generate an SCC
if (lowLinks[v] === indexes[v]) {
const scc: number[] = [];
let w: number;
do {
w = defined(stack.pop());
onStack[w] = false;
scc.push(w);
} while (w !== v);
sccs.push(scc);
}
}
for (let v = 0; v < numNodes; v++) {
if (indexes[v] < 0) {
strongconnect(v);
}
}
assert(
countComponentGraphNodes(sccs) === numNodes,
"We didn't put all the nodes into SCCs",
);
return sccs;
}
function buildComponentOfNodeMap(
successors: number[][],
components: number[][],
): number[] {
const numComponents = components.length;
const numNodes = successors.length;
assert(
numNodes === countComponentGraphNodes(components),
"Components don't match up with graph",
);
const componentOfNode: number[] = repeated(numNodes, -1);
for (let c = 0; c < numComponents; c++) {
for (const n of components[c]) {
assert(
componentOfNode[n] < 0,
"We have a node that's in two components",
);
componentOfNode[n] = c;
}
}
return componentOfNode;
}
function buildMetaSuccessors(
successors: number[][],
components: number[][],
): number[][] {
const numComponents = components.length;
const componentOfNode = buildComponentOfNodeMap(successors, components);
const componentAdded: boolean[] = repeated(numComponents, false);
const metaSuccessors: number[][] = [];
for (let c = 0; c < numComponents; c++) {
const succ: number[] = [];
for (const n of components[c]) {
for (const s of successors[n]) {
const ms = componentOfNode[s];
if (ms === c || componentAdded[ms]) continue;
succ.push(ms);
componentAdded[ms] = true;
}
}
// reset bookkeeping
for (const ms of succ) {
assert(componentAdded[ms]);
componentAdded[ms] = false;
}
metaSuccessors.push(succ);
}
return metaSuccessors;
}
function invertEdges(successors: number[][]): number[][] {
const numNodes = successors.length;
const predecessors: number[][] = repeatedCall(numNodes, () => []);
for (let s = 0; s < numNodes; s++) {
for (const v of successors[s]) {
predecessors[v].push(s);
}
}
return predecessors;
}
function calculateInDegrees(successors: number[][]): number[] {
const numNodes = successors.length;
const inDegrees: number[] = repeated(numNodes, 0);
for (const s of successors) {
for (const v of s) {
inDegrees[v] += 1;
}
}
return inDegrees;
}
function findRoots(successors: number[][]): number[] {
const numNodes = successors.length;
const inDegrees = calculateInDegrees(successors);
const roots: number[] = [];
for (let v = 0; v < numNodes; v++) {
if (inDegrees[v] === 0) {
roots.push(v);
}
}
return roots;
}
export class Graph {
private readonly _nodes: readonly T[];
private readonly _indexByNode: ReadonlyMap;
private readonly _successors: number[][];
public constructor(
nodes: Iterable,
invertDirection: boolean,
edges: number[][] | ((node: T) => ReadonlySet),
) {
this._nodes = Array.from(nodes);
this._indexByNode = new Map(
this._nodes.map((n, i): [T, number] => [n, i]),
);
let edgesArray: number[][];
if (Array.isArray(edges)) {
edgesArray = edges;
} else {
edgesArray = this._nodes.map((n) =>
Array.from(edges(n)).map((s) =>
defined(this._indexByNode.get(s)),
),
);
}
if (invertDirection) {
edgesArray = invertEdges(edgesArray);
}
this._successors = edgesArray;
}
public get size(): number {
return this._nodes.length;
}
public get nodes(): readonly T[] {
return this._nodes;
}
public findRoots(): ReadonlySet {
const roots = findRoots(this._successors);
return new Set(roots.map((n) => this._nodes[n]));
}
// The subgraph starting at `root` must be acyclic.
public dfsTraversal(
root: T,
preOrder: boolean,
process: (node: T) => void,
): void {
const visited = repeated(this.size, false);
const visit = (v: number): void => {
if (visited[v]) return;
visited[v] = true;
if (preOrder) {
process(this._nodes[v]);
}
for (const w of this._successors[v]) {
visit(w);
}
if (!preOrder) {
process(this._nodes[v]);
}
};
visit(defined(this._indexByNode.get(root)));
}
public stronglyConnectedComponents(): Graph> {
const components = stronglyConnectedComponents(this._successors);
const componentSuccessors = buildMetaSuccessors(
this._successors,
components,
);
return new Graph(
components.map((ns) => setMap(ns, (n) => this._nodes[n])),
false,
componentSuccessors,
);
}
public makeDot(
includeNode: (n: T) => boolean,
nodeLabel: (n: T) => string,
): string {
const lines: string[] = [];
lines.push("digraph G {");
lines.push(" ordering = out;");
lines.push("");
for (let i = 0; i < this.size; i++) {
const n = this._nodes[i];
if (!includeNode(n)) continue;
lines.push(` node${i} [label="${nodeLabel(n)}"];`);
}
for (let i = 0; i < this.size; i++) {
if (!includeNode(this._nodes[i])) continue;
for (const j of this._successors[i]) {
if (!includeNode(this._nodes[j])) continue;
lines.push(` node${i} -> node${j};`);
}
}
lines.push("}");
lines.push("");
return lines.join("\n");
}
}
================================================
FILE: packages/quicktype-core/src/GraphRewriting.ts
================================================
import { EqualityMap, mapMap } from "collection-utils";
import {
type TypeAttributes,
combineTypeAttributes,
emptyTypeAttributes,
} from "./attributes/TypeAttributes";
import { assert, indentationString, panic } from "./support/Support";
import type {
ClassProperty,
MaybeTypeIdentity,
PrimitiveTypeKind,
Type,
} from "./Type";
import { TypeBuilder } from "./Type/TypeBuilder";
import type { StringTypeMapping } from "./Type/TypeBuilderUtils";
import type { TypeGraph } from "./Type/TypeGraph";
import {
type TypeRef,
assertTypeRefGraph,
derefTypeRef,
isTypeRef,
typeAndAttributesForTypeRef,
typeRefIndex,
} from "./Type/TypeRef";
import { combineTypeAttributesOfTypes } from "./Type/TypeUtils";
export interface TypeLookerUp {
lookupTypeRefs: (
typeRefs: TypeRef[],
forwardingRef?: TypeRef,
) => TypeRef | undefined;
reconstituteTypeRef: (
typeRef: TypeRef,
attributes?: TypeAttributes,
forwardingRef?: TypeRef,
) => TypeRef;
}
export class TypeReconstituter {
private _wasUsed = false;
private _typeRef: TypeRef | undefined = undefined;
public constructor(
private readonly _typeBuilder: TBuilder,
private readonly _makeClassUnique: boolean,
private readonly _typeAttributes: TypeAttributes,
private readonly _forwardingRef: TypeRef | undefined,
private readonly _register: (tref: TypeRef) => void,
) {}
private builderForNewType(): TBuilder {
assert(!this._wasUsed, "TypeReconstituter used more than once");
this._wasUsed = true;
return this._typeBuilder;
}
private builderForSetting(): TBuilder {
assert(
this._wasUsed && this._typeRef !== undefined,
"Can't set type members before constructing a type",
);
return this._typeBuilder;
}
public getResult(): TypeRef {
if (this._typeRef === undefined) {
return panic("Type was not reconstituted");
}
return this._typeRef;
}
// FIXME: Do registration automatically.
private register(tref: TypeRef): void {
assert(this._typeRef === undefined, "Cannot register a type twice");
this._typeRef = tref;
this._register(tref);
}
private registerAndAddAttributes(tref: TypeRef): void {
this._typeBuilder.addAttributes(tref, this._typeAttributes);
this.register(tref);
}
public lookup(tref: TypeRef): TypeRef | undefined;
public lookup(trefs: Iterable): readonly TypeRef[] | undefined;
public lookup(
trefs: TypeRef | Iterable,
): TypeRef | readonly TypeRef[] | undefined {
assert(
!this._wasUsed,
"Cannot lookup constituents after building type",
);
if (isTypeRef(trefs)) {
return this._typeBuilder.lookupTypeRefs([trefs], undefined, false);
}
const maybeRefs = Array.from(trefs).map((tref) =>
this._typeBuilder.lookupTypeRefs([tref], undefined, false),
);
if (maybeRefs.some((tref) => tref === undefined)) {
return undefined;
}
return maybeRefs as readonly TypeRef[];
}
public lookupMap(
trefs: ReadonlyMap,
): ReadonlyMap | undefined {
const resultValues = this.lookup(trefs.values());
if (resultValues === undefined) return undefined;
assert(
resultValues.length === trefs.size,
"Didn't get back the correct number of types",
);
const result = new Map();
let i = 0;
for (const k of trefs.keys()) {
result.set(k, resultValues[i]);
i += 1;
}
return result;
}
public reconstitute(tref: TypeRef): TypeRef;
public reconstitute(trefs: Iterable): readonly TypeRef[];
public reconstitute(
trefs: TypeRef | Iterable,
): TypeRef | readonly TypeRef[] {
assert(
this._wasUsed,
"Cannot reconstitute constituents before building type",
);
if (isTypeRef(trefs)) {
return this._typeBuilder.reconstituteTypeRef(trefs);
}
return Array.from(trefs).map((tref) =>
this._typeBuilder.reconstituteTypeRef(tref),
);
}
public reconstituteMap(
trefs: ReadonlyMap,
): ReadonlyMap {
return mapMap(trefs, (tref) =>
this._typeBuilder.reconstituteTypeRef(tref),
);
}
public getPrimitiveType(kind: PrimitiveTypeKind): void {
this.register(
this.builderForNewType().getPrimitiveType(
kind,
this._typeAttributes,
this._forwardingRef,
),
);
}
public getEnumType(cases: ReadonlySet): void {
this.register(
this.builderForNewType().getEnumType(
this._typeAttributes,
cases,
this._forwardingRef,
),
);
}
public getUniqueMapType(): void {
this.registerAndAddAttributes(
this.builderForNewType().getUniqueMapType(this._forwardingRef),
);
}
public getMapType(values: TypeRef): void {
this.register(
this.builderForNewType().getMapType(
this._typeAttributes,
values,
this._forwardingRef,
),
);
}
public getUniqueArrayType(): void {
this.registerAndAddAttributes(
this.builderForNewType().getUniqueArrayType(this._forwardingRef),
);
}
public getArrayType(items: TypeRef): void {
this.register(
this.builderForNewType().getArrayType(
this._typeAttributes,
items,
this._forwardingRef,
),
);
}
public setArrayItems(items: TypeRef): void {
this.builderForSetting().setArrayItems(this.getResult(), items);
}
public makeClassProperty(
tref: TypeRef,
isOptional: boolean,
): ClassProperty {
return this._typeBuilder.makeClassProperty(tref, isOptional);
}
public getObjectType(
properties: ReadonlyMap,
additionalProperties: TypeRef | undefined,
): void {
this.register(
this.builderForNewType().getUniqueObjectType(
this._typeAttributes,
properties,
additionalProperties,
this._forwardingRef,
),
);
}
public getUniqueObjectType(
properties: ReadonlyMap | undefined,
additionalProperties: TypeRef | undefined,
): void {
this.register(
this.builderForNewType().getUniqueObjectType(
this._typeAttributes,
properties,
additionalProperties,
this._forwardingRef,
),
);
}
public getClassType(properties: ReadonlyMap): void {
if (this._makeClassUnique) {
this.getUniqueClassType(false, properties);
return;
}
this.register(
this.builderForNewType().getClassType(
this._typeAttributes,
properties,
this._forwardingRef,
),
);
}
public getUniqueClassType(
isFixed: boolean,
properties: ReadonlyMap | undefined,
): void {
this.register(
this.builderForNewType().getUniqueClassType(
this._typeAttributes,
isFixed,
properties,
this._forwardingRef,
),
);
}
public setObjectProperties(
properties: ReadonlyMap,
additionalProperties: TypeRef | undefined,
): void {
this.builderForSetting().setObjectProperties(
this.getResult(),
properties,
additionalProperties,
);
}
public getUnionType(members: ReadonlySet): void {
this.register(
this.builderForNewType().getUnionType(
this._typeAttributes,
members,
this._forwardingRef,
),
);
}
public getUniqueUnionType(): void {
this.register(
this.builderForNewType().getUniqueUnionType(
this._typeAttributes,
undefined,
this._forwardingRef,
),
);
}
public getIntersectionType(members: ReadonlySet): void {
this.register(
this.builderForNewType().getIntersectionType(
this._typeAttributes,
members,
this._forwardingRef,
),
);
}
public getUniqueIntersectionType(members?: ReadonlySet): void {
this.register(
this.builderForNewType().getUniqueIntersectionType(
this._typeAttributes,
members,
this._forwardingRef,
),
);
}
public setSetOperationMembers(members: ReadonlySet): void {
this.builderForSetting().setSetOperationMembers(
this.getResult(),
members,
);
}
}
export abstract class BaseGraphRewriteBuilder
extends TypeBuilder
implements TypeLookerUp
{
protected readonly reconstitutedTypes: Map = new Map();
private _lostTypeAttributes = false;
private _printIndent = 0;
public constructor(
public readonly originalGraph: TypeGraph,
stringTypeMapping: StringTypeMapping,
alphabetizeProperties: boolean,
graphHasProvenanceAttributes: boolean,
protected readonly debugPrint: boolean,
) {
super(
stringTypeMapping,
alphabetizeProperties,
false,
false,
graphHasProvenanceAttributes,
);
}
public withForwardingRef(
maybeForwardingRef: TypeRef | undefined,
typeCreator: (forwardingRef: TypeRef) => TypeRef,
): TypeRef {
if (maybeForwardingRef !== undefined) {
return typeCreator(maybeForwardingRef);
}
const forwardingRef = this.reserveTypeRef();
const actualRef = typeCreator(forwardingRef);
assert(
actualRef === forwardingRef,
"Type creator didn't return its forwarding ref",
);
return actualRef;
}
public reconstituteType(
t: Type,
attributes?: TypeAttributes,
forwardingRef?: TypeRef,
): TypeRef {
return this.reconstituteTypeRef(t.typeRef, attributes, forwardingRef);
}
public abstract lookupTypeRefs(
typeRefs: TypeRef[],
forwardingRef?: TypeRef,
replaceSet?: boolean,
): TypeRef | undefined;
protected abstract forceReconstituteTypeRef(
originalRef: TypeRef,
attributes?: TypeAttributes,
maybeForwardingRef?: TypeRef,
): TypeRef;
public reconstituteTypeRef(
originalRef: TypeRef,
attributes?: TypeAttributes,
maybeForwardingRef?: TypeRef,
): TypeRef {
const maybeRef = this.lookupTypeRefs([originalRef], maybeForwardingRef);
if (maybeRef !== undefined) {
if (attributes !== undefined) {
this.addAttributes(maybeRef, attributes);
}
return maybeRef;
}
return this.forceReconstituteTypeRef(
originalRef,
attributes,
maybeForwardingRef,
);
}
public reconstituteTypeAttributes(
attributes: TypeAttributes,
): TypeAttributes {
return mapMap(attributes, (v, a) => a.reconstitute(this, v));
}
protected assertTypeRefsToReconstitute(
typeRefs: TypeRef[],
forwardingRef?: TypeRef,
): void {
assert(
typeRefs.length > 0,
"Must have at least one type to reconstitute",
);
for (const originalRef of typeRefs) {
assertTypeRefGraph(originalRef, this.originalGraph);
}
if (forwardingRef !== undefined) {
assertTypeRefGraph(forwardingRef, this.typeGraph);
}
}
protected changeDebugPrintIndent(delta: number): void {
this._printIndent += delta;
}
protected get debugPrintIndentation(): string {
return indentationString(this._printIndent);
}
public finish(): TypeGraph {
for (const [name, t] of this.originalGraph.topLevels) {
this.addTopLevel(name, this.reconstituteType(t));
}
return super.finish();
}
public setLostTypeAttributes(): void {
this._lostTypeAttributes = true;
}
public get lostTypeAttributes(): boolean {
return this._lostTypeAttributes;
}
}
export class GraphRemapBuilder extends BaseGraphRewriteBuilder {
private readonly _attributeSources: Map = new Map();
public constructor(
originalGraph: TypeGraph,
stringTypeMapping: StringTypeMapping,
alphabetizeProperties: boolean,
graphHasProvenanceAttributes: boolean,
private readonly _map: ReadonlyMap,
debugPrintRemapping: boolean,
) {
super(
originalGraph,
stringTypeMapping,
alphabetizeProperties,
graphHasProvenanceAttributes,
debugPrintRemapping,
);
for (const [source, target] of _map) {
let maybeSources = this._attributeSources.get(target);
if (maybeSources === undefined) {
maybeSources = [target];
this._attributeSources.set(target, maybeSources);
}
maybeSources.push(source);
}
}
protected makeIdentity(_maker: () => MaybeTypeIdentity): MaybeTypeIdentity {
return undefined;
}
private getMapTarget(tref: TypeRef): TypeRef {
const maybeType = this._map.get(derefTypeRef(tref, this.originalGraph));
if (maybeType === undefined) return tref;
assert(
this._map.get(maybeType) === undefined,
"We have a type that's remapped to a remapped type",
);
return maybeType.typeRef;
}
protected addForwardingIntersection(
_forwardingRef: TypeRef,
_tref: TypeRef,
): TypeRef {
return panic(
"We can't add forwarding intersections when we're removing forwarding intersections",
);
}
public lookupTypeRefs(
typeRefs: TypeRef[],
forwardingRef?: TypeRef,
): TypeRef | undefined {
assert(
forwardingRef === undefined,
"We can't have a forwarding ref when we remap",
);
this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
const first = this.reconstitutedTypes.get(
typeRefIndex(this.getMapTarget(typeRefs[0])),
);
if (first === undefined) return undefined;
for (let i = 1; i < typeRefs.length; i++) {
const other = this.reconstitutedTypes.get(
typeRefIndex(this.getMapTarget(typeRefs[i])),
);
if (first !== other) return undefined;
}
return first;
}
protected forceReconstituteTypeRef(
originalRef: TypeRef,
attributes?: TypeAttributes,
maybeForwardingRef?: TypeRef,
): TypeRef {
originalRef = this.getMapTarget(originalRef);
const index = typeRefIndex(originalRef);
assert(
this.reconstitutedTypes.get(index) === undefined,
"Type has already been reconstituted",
);
assert(
maybeForwardingRef === undefined,
"We can't have a forwarding ref when we remap",
);
return this.withForwardingRef(undefined, (forwardingRef) => {
this.reconstitutedTypes.set(index, forwardingRef);
if (this.debugPrint) {
console.log(
`${this.debugPrintIndentation}reconstituting ${index} as ${typeRefIndex(forwardingRef)}`,
);
this.changeDebugPrintIndent(1);
}
const [originalType, originalAttributes] =
typeAndAttributesForTypeRef(originalRef, this.originalGraph);
const attributeSources = this._attributeSources.get(originalType);
if (attributes === undefined) {
attributes = emptyTypeAttributes;
}
if (attributeSources === undefined) {
attributes = combineTypeAttributes(
"union",
attributes,
this.reconstituteTypeAttributes(originalAttributes),
);
} else {
attributes = combineTypeAttributes(
"union",
attributes,
this.reconstituteTypeAttributes(
combineTypeAttributesOfTypes("union", attributeSources),
),
);
}
const newAttributes = attributes;
const reconstituter = new TypeReconstituter(
this,
this.canonicalOrder,
newAttributes,
forwardingRef,
(tref) => {
assert(
tref === forwardingRef,
"Reconstituted type as a different ref",
);
if (this.debugPrint) {
this.changeDebugPrintIndent(-1);
console.log(
`${this.debugPrintIndentation}reconstituted ${index} as ${typeRefIndex(tref)}`,
);
}
},
);
originalType.reconstitute(reconstituter, this.canonicalOrder);
return reconstituter.getResult();
});
}
}
export class GraphRewriteBuilder<
T extends Type,
> extends BaseGraphRewriteBuilder {
private readonly _setsToReplaceByMember: Map>;
private readonly _reconstitutedUnions: EqualityMap, TypeRef> =
new EqualityMap();
public constructor(
originalGraph: TypeGraph,
stringTypeMapping: StringTypeMapping,
alphabetizeProperties: boolean,
graphHasProvenanceAttributes: boolean,
setsToReplace: T[][],
debugPrintReconstitution: boolean,
private readonly _replacer: (
typesToReplace: ReadonlySet,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
) => TypeRef,
) {
super(
originalGraph,
stringTypeMapping,
alphabetizeProperties,
graphHasProvenanceAttributes,
debugPrintReconstitution,
);
this._setsToReplaceByMember = new Map();
for (const types of setsToReplace) {
const set = new Set(types);
for (const t of set) {
const index = t.index;
assert(
!this._setsToReplaceByMember.has(index),
"A type is member of more than one set to be replaced",
);
this._setsToReplaceByMember.set(index, set);
}
}
}
public registerUnion(typeRefs: TypeRef[], reconstituted: TypeRef): void {
const set = new Set(typeRefs);
assert(
!this._reconstitutedUnions.has(set),
"Cannot register reconstituted set twice",
);
this._reconstitutedUnions.set(set, reconstituted);
}
private replaceSet(
typesToReplace: ReadonlySet,
maybeForwardingRef: TypeRef | undefined,
): TypeRef {
return this.withForwardingRef(maybeForwardingRef, (forwardingRef) => {
if (this.debugPrint) {
console.log(
`${this.debugPrintIndentation}replacing set ${Array.from(
typesToReplace,
)
.map((t) => t.index.toString())
.join(",")} as ${typeRefIndex(forwardingRef)}`,
);
this.changeDebugPrintIndent(1);
}
for (const t of typesToReplace) {
const originalRef = t.typeRef;
const index = typeRefIndex(originalRef);
this.reconstitutedTypes.set(index, forwardingRef);
this._setsToReplaceByMember.delete(index);
}
const result = this._replacer(typesToReplace, this, forwardingRef);
assert(
result === forwardingRef,
"The forwarding ref got lost when replacing",
);
if (this.debugPrint) {
this.changeDebugPrintIndent(-1);
console.log(
`${this.debugPrintIndentation}replaced set ${Array.from(
typesToReplace,
)
.map((t) => t.index.toString())
.join(",")} as ${typeRefIndex(forwardingRef)}`,
);
}
return result;
});
}
protected forceReconstituteTypeRef(
originalRef: TypeRef,
attributes?: TypeAttributes,
maybeForwardingRef?: TypeRef,
): TypeRef {
const [originalType, originalAttributes] = typeAndAttributesForTypeRef(
originalRef,
this.originalGraph,
);
const index = typeRefIndex(originalRef);
if (this.debugPrint) {
console.log(`${this.debugPrintIndentation}reconstituting ${index}`);
this.changeDebugPrintIndent(1);
}
if (attributes === undefined) {
attributes = this.reconstituteTypeAttributes(originalAttributes);
} else {
attributes = combineTypeAttributes(
"union",
attributes,
this.reconstituteTypeAttributes(originalAttributes),
);
}
const reconstituter = new TypeReconstituter(
this,
this.canonicalOrder,
attributes,
maybeForwardingRef,
(tref) => {
if (this.debugPrint) {
this.changeDebugPrintIndent(-1);
console.log(
`${this.debugPrintIndentation}reconstituted ${index} as ${typeRefIndex(tref)}`,
);
}
if (maybeForwardingRef !== undefined) {
assert(
tref === maybeForwardingRef,
"We didn't pass the forwarding ref",
);
}
const alreadyReconstitutedType =
this.reconstitutedTypes.get(index);
if (alreadyReconstitutedType === undefined) {
this.reconstitutedTypes.set(index, tref);
} else {
assert(
tref === alreadyReconstitutedType,
"We reconstituted a type twice differently",
);
}
},
);
originalType.reconstitute(reconstituter, this.canonicalOrder);
return reconstituter.getResult();
}
/*
public reconstituteTypeUnmodified(originalType: Type): TypeRef {
const reconstituter = new TypeReconstituter(
this,
this.alphabetizeProperties,
emptyTypeAttributes,
undefined,
() => {}
);
originalType.reconstitute(reconstituter);
return reconstituter.getResult();
}
*/
// If the union of these type refs have been, or are supposed to be, reconstituted to
// one target type, return it. Otherwise return undefined.
public lookupTypeRefs(
typeRefs: TypeRef[],
forwardingRef?: TypeRef,
replaceSet = true,
): TypeRef | undefined {
this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
// Check whether we have already reconstituted them. That means ensuring
// that they all have the same target type.
let maybeRef = this.reconstitutedTypes.get(typeRefIndex(typeRefs[0]));
if (maybeRef !== undefined && maybeRef !== forwardingRef) {
let allEqual = true;
for (let i = 1; i < typeRefs.length; i++) {
if (
this.reconstitutedTypes.get(typeRefIndex(typeRefs[i])) !==
maybeRef
) {
allEqual = false;
break;
}
}
if (allEqual) {
return this.forwardIfNecessary(forwardingRef, maybeRef);
}
}
// Has this been reconstituted as a set?
maybeRef = this._reconstitutedUnions.get(new Set(typeRefs));
if (maybeRef !== undefined && maybeRef !== forwardingRef) {
return this.forwardIfNecessary(forwardingRef, maybeRef);
}
// Is this set requested to be replaced? If not, we're out of options.
const maybeSet = this._setsToReplaceByMember.get(
typeRefIndex(typeRefs[0]),
);
if (maybeSet === undefined) {
return undefined;
}
for (let i = 1; i < typeRefs.length; i++) {
if (
this._setsToReplaceByMember.get(typeRefIndex(typeRefs[i])) !==
maybeSet
) {
return undefined;
}
}
// Yes, this set is requested to be replaced, so do it.
if (!replaceSet) return undefined;
return this.replaceSet(maybeSet, forwardingRef);
}
}
================================================
FILE: packages/quicktype-core/src/Inference.ts
================================================
import type { TransformedStringTypeKind } from "./Type";
export interface InferenceFlag {
description: string;
explanation: string;
negationDescription: string;
order: number;
stringType?: TransformedStringTypeKind;
}
export const inferenceFlagsObject = {
/** Whether to infer map types from JSON data */
inferMaps: {
description: "Detect maps",
negationDescription: "Don't infer maps, always use classes",
explanation: "Infer maps when object keys look like map keys.",
order: 1,
},
/** Whether to infer enum types from JSON data */
inferEnums: {
description: "Detect enums",
negationDescription: "Don't infer enums, always use strings",
explanation:
"If string values occur within a relatively small domain,\ninfer them as enum values.",
order: 2,
},
/** Whether to convert UUID strings to UUID objects */
inferUuids: {
description: "Detect UUIDs",
negationDescription: "Don't convert UUIDs to UUID objects",
explanation:
"Detect UUIDs like '123e4567-e89b-12d3-a456-426655440000' (partial support).",
stringType: "uuid" as TransformedStringTypeKind,
order: 3,
},
/** Whether to assume that JSON strings that look like dates are dates */
inferDateTimes: {
description: "Detect dates & times",
negationDescription: "Don't infer dates or times",
explanation: "Infer dates from strings (partial support).",
stringType: "date-time" as TransformedStringTypeKind,
order: 4,
},
/** Whether to convert stringified integers to integers */
inferIntegerStrings: {
description: "Detect integers in strings",
negationDescription: "Don't convert stringified integers to integers",
explanation:
'Automatically convert stringified integers to integers.\nFor example, "1" is converted to 1.',
stringType: "integer-string" as TransformedStringTypeKind,
order: 5,
},
/** Whether to convert stringified booleans to boolean values */
inferBooleanStrings: {
description: "Detect booleans in strings",
negationDescription: "Don't convert stringified booleans to booleans",
explanation:
'Automatically convert stringified booleans to booleans.\nFor example, "true" is converted to true.',
stringType: "bool-string" as TransformedStringTypeKind,
order: 6,
},
/** Combine similar classes. This doesn't apply to classes from a schema, only from inference. */
combineClasses: {
description: "Merge similar classes",
negationDescription: "Don't combine similar classes",
explanation:
"Combine classes with significantly overlapping properties,\ntreating contingent properties as nullable.",
order: 7,
},
/** Whether to treat $ref as references within JSON */
ignoreJsonRefs: {
description: "Don't treat $ref as a reference in JSON",
negationDescription: "Treat $ref as a reference in JSON",
explanation:
"Like in JSON Schema, allow objects like\n'{ $ref: \"#/foo/bar\" }' to refer\nto another part of the input.",
order: 8,
},
};
export type InferenceFlagName = keyof typeof inferenceFlagsObject;
export const inferenceFlagNames = Object.getOwnPropertyNames(
inferenceFlagsObject,
) as InferenceFlagName[];
export const inferenceFlags: { [F in InferenceFlagName]: InferenceFlag } =
inferenceFlagsObject;
export type InferenceFlags = { [F in InferenceFlagName]: boolean };
function makeDefaultInferenceFlags(): InferenceFlags {
const flags = {} as InferenceFlags;
for (const flag of inferenceFlagNames) {
flags[flag] = true;
}
return flags;
}
export const defaultInferenceFlags = makeDefaultInferenceFlags();
================================================
FILE: packages/quicktype-core/src/MakeTransformations.ts
================================================
import {
arraySortByInto,
iterableFirst,
iterableSome,
mapMapEntries,
setFilter,
withDefault,
} from "collection-utils";
import {
minMaxLengthForType,
minMaxValueForType,
} from "./attributes/Constraints";
import { StringTypes } from "./attributes/StringTypes";
import {
type TypeAttributes,
combineTypeAttributes,
emptyTypeAttributes,
} from "./attributes/TypeAttributes";
import type { GraphRewriteBuilder } from "./GraphRewriting";
import type { RunContext } from "./Run";
import { assert, defined, panic } from "./support/Support";
import type { TargetLanguage } from "./TargetLanguage";
import {
ArrayDecodingTransformer,
ChoiceTransformer,
DecodingChoiceTransformer,
DecodingTransformer,
MinMaxLengthCheckTransformer,
MinMaxValueTransformer,
ParseStringTransformer,
StringMatchTransformer,
StringProducerTransformer,
Transformation,
type Transformer,
UnionInstantiationTransformer,
transformationTypeAttributeKind,
} from "./Transformers";
import {
ArrayType,
EnumType,
type PrimitiveStringTypeKind,
type PrimitiveType,
type Type,
type TypeKind,
UnionType,
isNumberTypeKind,
isPrimitiveStringTypeKind,
targetTypeKindForTransformedStringTypeKind,
} from "./Type";
import type { TypeGraph } from "./Type/TypeGraph";
import { type TypeRef, typeRefIndex } from "./Type/TypeRef";
function transformationAttributes(
graph: TypeGraph,
reconstitutedTargetType: TypeRef,
transformer: Transformer,
debugPrintTransformations: boolean,
): TypeAttributes {
const transformation = new Transformation(
graph,
reconstitutedTargetType,
transformer,
);
if (debugPrintTransformations) {
console.log(
`transformation for ${typeRefIndex(reconstitutedTargetType)}:`,
);
transformation.debugPrint();
console.log("reverse:");
transformation.reverse.debugPrint();
}
return transformationTypeAttributeKind.makeAttributes(transformation);
}
function makeEnumTransformer(
graph: TypeGraph,
enumType: EnumType,
stringType: TypeRef,
continuation?: Transformer,
): Transformer {
const sortedCases = Array.from(enumType.cases).sort();
const caseTransformers = sortedCases.map(
(c) =>
new StringMatchTransformer(
graph,
stringType,
new StringProducerTransformer(
graph,
stringType,
continuation,
c,
),
c,
),
);
return new ChoiceTransformer(graph, stringType, caseTransformers);
}
function replaceUnion(
union: UnionType,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
transformedTypes: Set,
debugPrintTransformations: boolean,
): TypeRef {
const graph = builder.typeGraph;
assert(union.members.size > 0, "We can't have empty unions");
// Type attributes that we lost during reconstitution.
let additionalAttributes = emptyTypeAttributes;
function reconstituteMember(t: Type): TypeRef {
// Special handling for some transformed string type kinds: The type in
// the union must be the target type, so if one already exists, use that
// one, otherwise make a new one.
if (isPrimitiveStringTypeKind(t.kind)) {
const targetTypeKind = targetTypeKindForTransformedStringTypeKind(
t.kind,
);
if (targetTypeKind !== undefined) {
const targetTypeMember = union.findMember(targetTypeKind);
additionalAttributes = combineTypeAttributes(
"union",
additionalAttributes,
t.getAttributes(),
);
if (targetTypeMember !== undefined) {
return builder.reconstituteType(targetTypeMember);
}
return builder.getPrimitiveType(targetTypeKind);
}
}
return builder.reconstituteType(t);
}
const reconstitutedMembersByKind = mapMapEntries(
union.members.entries(),
(m) => [m.kind, reconstituteMember(m)],
);
const reconstitutedMemberSet = new Set(reconstitutedMembersByKind.values());
const haveUnion = reconstitutedMemberSet.size > 1;
if (!haveUnion) {
builder.setLostTypeAttributes();
}
const reconstitutedTargetType = haveUnion
? builder.getUnionType(union.getAttributes(), reconstitutedMemberSet)
: defined(iterableFirst(reconstitutedMemberSet));
function memberForKind(kind: TypeKind): number {
return defined(reconstitutedMembersByKind.get(kind));
}
function consumer(memberTypeRef: TypeRef): Transformer | undefined {
if (!haveUnion) return undefined;
return new UnionInstantiationTransformer(graph, memberTypeRef);
}
function transformerForKind(
kind: TypeKind,
): DecodingTransformer | undefined {
const member = union.findMember(kind);
if (member === undefined) return undefined;
const memberTypeRef = memberForKind(kind);
return new DecodingTransformer(
graph,
memberTypeRef,
consumer(memberTypeRef),
);
}
let maybeStringType: TypeRef | undefined = undefined;
function getStringType(): TypeRef {
if (maybeStringType === undefined) {
maybeStringType = builder.getStringType(
emptyTypeAttributes,
StringTypes.unrestricted,
);
}
return maybeStringType;
}
function transformerForStringType(t: Type): Transformer | undefined {
const memberRef = memberForKind(t.kind);
if (t.kind === "string") {
const minMax = minMaxLengthForType(t);
if (minMax === undefined) {
return consumer(memberRef);
}
const [min, max] = minMax;
return new MinMaxLengthCheckTransformer(
graph,
getStringType(),
consumer(memberRef),
min,
max,
);
}
if (t instanceof EnumType && transformedTypes.has(t)) {
return makeEnumTransformer(
graph,
t,
getStringType(),
consumer(memberRef),
);
}
return new ParseStringTransformer(
graph,
getStringType(),
consumer(memberRef),
);
}
const stringTypes = arraySortByInto(
Array.from(union.stringTypeMembers),
(t) => t.kind,
);
let transformerForString: Transformer | undefined;
if (stringTypes.length === 0) {
transformerForString = undefined;
} else if (stringTypes.length === 1) {
const t = stringTypes[0];
transformerForString = new DecodingTransformer(
graph,
getStringType(),
transformerForStringType(t),
);
} else {
transformerForString = new DecodingTransformer(
graph,
getStringType(),
new ChoiceTransformer(
graph,
getStringType(),
stringTypes.map((t) => defined(transformerForStringType(t))),
),
);
}
const transformerForClass = transformerForKind("class");
const transformerForMap = transformerForKind("map");
assert(
transformerForClass === undefined || transformerForMap === undefined,
"Can't have both class and map in a transformed union",
);
const transformerForObject = transformerForClass ?? transformerForMap;
const transformer = new DecodingChoiceTransformer(
graph,
builder.getPrimitiveType("any"),
transformerForKind("null"),
transformerForKind("integer"),
transformerForKind("double"),
transformerForKind("bool"),
transformerForString,
transformerForKind("array"),
transformerForObject,
);
const attributes = transformationAttributes(
graph,
reconstitutedTargetType,
transformer,
debugPrintTransformations,
);
return builder.getPrimitiveType(
"any",
combineTypeAttributes("union", attributes, additionalAttributes),
forwardingRef,
);
}
function replaceArray(
arrayType: ArrayType,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
debugPrintTransformations: boolean,
): TypeRef {
const anyType = builder.getPrimitiveType("any");
const anyArrayType = builder.getArrayType(emptyTypeAttributes, anyType);
const reconstitutedItems = builder.reconstituteType(arrayType.items);
const transformer = new ArrayDecodingTransformer(
builder.typeGraph,
anyArrayType,
undefined,
reconstitutedItems,
new DecodingTransformer(builder.typeGraph, anyType, undefined),
);
const reconstitutedArray = builder.getArrayType(
builder.reconstituteTypeAttributes(arrayType.getAttributes()),
reconstitutedItems,
);
const attributes = transformationAttributes(
builder.typeGraph,
reconstitutedArray,
transformer,
debugPrintTransformations,
);
return builder.getArrayType(attributes, anyType, forwardingRef);
}
function replaceEnum(
enumType: EnumType,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
debugPrintTransformations: boolean,
): TypeRef {
const stringType = builder.getStringType(
emptyTypeAttributes,
StringTypes.unrestricted,
);
const transformer = new DecodingTransformer(
builder.typeGraph,
stringType,
makeEnumTransformer(builder.typeGraph, enumType, stringType),
);
const reconstitutedEnum = builder.getEnumType(
enumType.getAttributes(),
enumType.cases,
);
const attributes = transformationAttributes(
builder.typeGraph,
reconstitutedEnum,
transformer,
debugPrintTransformations,
);
return builder.getStringType(
attributes,
StringTypes.unrestricted,
forwardingRef,
);
}
function replaceNumber(
t: PrimitiveType,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
debugPrintTransformations: boolean,
): TypeRef {
const stringType = builder.getStringType(
emptyTypeAttributes,
StringTypes.unrestricted,
);
const [min, max] = defined(minMaxValueForType(t));
const transformer = new DecodingTransformer(
builder.typeGraph,
stringType,
new MinMaxValueTransformer(
builder.typeGraph,
stringType,
undefined,
min,
max,
),
);
const reconstitutedAttributes = builder.reconstituteTypeAttributes(
t.getAttributes(),
);
const attributes = transformationAttributes(
builder.typeGraph,
builder.getPrimitiveType("double", reconstitutedAttributes, undefined),
transformer,
debugPrintTransformations,
);
return builder.getPrimitiveType("double", attributes, forwardingRef);
}
function replaceString(
t: PrimitiveType,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
debugPrintTransformations: boolean,
): TypeRef {
const [min, max] = defined(minMaxLengthForType(t));
const reconstitutedAttributes = builder.reconstituteTypeAttributes(
t.getAttributes(),
);
const stringType = builder.getStringType(
emptyTypeAttributes,
StringTypes.unrestricted,
);
const transformer = new DecodingTransformer(
builder.typeGraph,
stringType,
new MinMaxLengthCheckTransformer(
builder.typeGraph,
stringType,
undefined,
min,
max,
),
);
const attributes = transformationAttributes(
builder.typeGraph,
builder.getStringType(reconstitutedAttributes, undefined),
transformer,
debugPrintTransformations,
);
return builder.getStringType(
attributes,
StringTypes.unrestricted,
forwardingRef,
);
}
function replaceTransformedStringType(
t: PrimitiveType,
kind: PrimitiveStringTypeKind,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
debugPrintTransformations: boolean,
): TypeRef {
const reconstitutedAttributes = builder.reconstituteTypeAttributes(
t.getAttributes(),
);
const targetTypeKind = withDefault(
targetTypeKindForTransformedStringTypeKind(kind),
kind,
);
const stringType = builder.getStringType(
emptyTypeAttributes,
StringTypes.unrestricted,
);
const transformer = new DecodingTransformer(
builder.typeGraph,
stringType,
new ParseStringTransformer(builder.typeGraph, stringType, undefined),
);
const attributes = transformationAttributes(
builder.typeGraph,
builder.getPrimitiveType(targetTypeKind, reconstitutedAttributes),
transformer,
debugPrintTransformations,
);
return builder.getStringType(
attributes,
StringTypes.unrestricted,
forwardingRef,
);
}
export function makeTransformations(
ctx: RunContext,
graph: TypeGraph,
targetLanguage: TargetLanguage,
): TypeGraph {
const transformedTypes = setFilter(graph.allTypesUnordered(), (t) => {
if (targetLanguage.needsTransformerForType(t)) return true;
if (!(t instanceof UnionType)) return false;
const stringMembers = t.stringTypeMembers;
if (stringMembers.size <= 1) return false;
return iterableSome(stringMembers, (m) =>
targetLanguage.needsTransformerForType(m),
);
});
function replace(
setOfOneUnion: ReadonlySet,
builder: GraphRewriteBuilder,
forwardingRef: TypeRef,
): TypeRef {
const t = defined(iterableFirst(setOfOneUnion));
if (t instanceof UnionType) {
return replaceUnion(
t,
builder,
forwardingRef,
transformedTypes,
ctx.debugPrintTransformations,
);
}
if (t instanceof ArrayType) {
return replaceArray(
t,
builder,
forwardingRef,
ctx.debugPrintTransformations,
);
}
if (t instanceof EnumType) {
return replaceEnum(
t,
builder,
forwardingRef,
ctx.debugPrintTransformations,
);
}
if (t.kind === "string") {
return replaceString(
t as PrimitiveType,
builder,
forwardingRef,
ctx.debugPrintTransformations,
);
}
if (isNumberTypeKind(t.kind)) {
return replaceNumber(
t as PrimitiveType,
builder,
forwardingRef,
ctx.debugPrintTransformations,
);
}
if (isPrimitiveStringTypeKind(t.kind)) {
return replaceTransformedStringType(
t as PrimitiveType,
t.kind,
builder,
forwardingRef,
ctx.debugPrintTransformations,
);
}
return panic(`Cannot make transformation for type ${t.kind}`);
}
const groups = Array.from(transformedTypes).map((t) => [t]);
return graph.rewrite(
"make-transformations",
ctx.stringTypeMapping,
false,
groups,
ctx.debugPrintReconstitution,
replace,
);
}
================================================
FILE: packages/quicktype-core/src/MarkovChain.ts
================================================
import { encodedMarkovChain } from "./EncodedMarkovChain";
import { assert, inflateBase64, panic } from "./support/Support";
// This must be null, not undefined, because we read it from JSON.
export type SubTrie = number | null | Trie;
export interface Trie {
arr: SubTrie[];
count: number;
}
export interface MarkovChain {
depth: number;
trie: Trie;
}
function makeTrie(): Trie {
const arr: SubTrie[] = [];
for (let i = 0; i < 128; i++) {
arr.push(null);
}
return { count: 0, arr };
}
function lookup(t: Trie, seq: string, i: number): Trie | number | undefined {
if (i >= seq.length) {
return t;
}
let first = seq.charCodeAt(i);
if (first >= 128) {
first = 0;
}
const n = t.arr[first];
if (n === null) {
return undefined;
}
if (typeof n === "object") {
return lookup(n, seq, i + 1);
} else {
return n / t.count;
}
}
function increment(t: Trie, seq: string, i: number): void {
let first = seq.charCodeAt(i);
if (first >= 128) {
first = 0;
}
if (i >= seq.length - 1) {
if (typeof t !== "object") {
return panic("Malformed trie");
}
let n = t.arr[first];
if (n === null) {
n = 0;
} else if (typeof n === "object") {
return panic("Malformed trie");
}
t.arr[first] = n + 1;
t.count += 1;
return;
}
let st = t.arr[first];
if (st === null) {
t.arr[first] = st = makeTrie();
}
if (typeof st !== "object") {
return panic("Malformed trie");
}
increment(st, seq, i + 1);
}
export function train(lines: string[], depth: number): MarkovChain {
const trie = makeTrie();
for (const l of lines) {
for (let i = depth; i <= l.length; i++) {
increment(trie, l.slice(i - depth, i), 0);
}
}
return { trie, depth };
}
export function load(): MarkovChain {
return JSON.parse(inflateBase64(encodedMarkovChain));
}
export function evaluateFull(
mc: MarkovChain,
word: string,
): [number, number[]] {
const { trie, depth } = mc;
if (word.length < depth) {
return [1, []];
}
let p = 1;
const scores: number[] = [];
for (let i = depth; i <= word.length; i++) {
let cp = lookup(trie, word.slice(i - depth, i), 0);
if (typeof cp === "object") {
return panic("Did we mess up the depth?");
}
if (cp === undefined) {
cp = 0.0001;
}
scores.push(cp);
p = p * cp;
}
return [Math.pow(p, 1 / (word.length - depth + 1)), scores];
}
export function evaluate(mc: MarkovChain, word: string): number {
return evaluateFull(mc, word)[0];
}
function randomInt(lower: number, upper: number): number {
const range = upper - lower;
return lower + Math.floor(Math.random() * range);
}
export function generate(
mc: MarkovChain,
state: string,
unseenWeight: number,
): string {
assert(
state.length === mc.depth - 1,
"State and chain length don't match up",
);
const t = lookup(mc.trie, state, 0);
if (typeof t === "number") {
return panic("Wrong depth?");
}
if (t === undefined) {
return String.fromCharCode(randomInt(32, 127));
}
const counts = t.arr.map((x, i) =>
x === null ? (i === 0 ? 0 : unseenWeight) : (x as number),
);
let n = 0;
for (const c of counts) {
n += c;
}
const r = randomInt(0, n);
let sum = 0;
for (let i = 0; i < counts.length; i++) {
sum += counts[i];
if (r < sum) {
return String.fromCharCode(i);
}
}
return panic("We screwed up bookkeeping, or randomInt");
}
function testWord(mc: MarkovChain, word: string): void {
console.log(`"${word}": ${evaluate(mc, word)}`);
}
export function test(): void {
const mc = load();
testWord(mc, "url");
testWord(mc, "json");
testWord(mc, "my_property");
testWord(mc, "ordinary");
testWord(mc, "different");
testWord(mc, "189512");
testWord(mc, "2BTZIqw0ntH9MvilQ3ewNY");
testWord(mc, "0uBTNdNGb2OY5lou41iYL52LcDq2");
testWord(mc, "-KpqHmWuDOUnr1hmAhxp");
testWord(mc, "granularity");
testWord(mc, "coverage");
testWord(mc, "postingFrequency");
testWord(mc, "dataFrequency");
testWord(mc, "units");
testWord(mc, "datasetOwner");
testWord(mc, "organization");
testWord(mc, "timePeriod");
testWord(mc, "contactInformation");
testWord(
mc,
"\ud83d\udebe \ud83c\udd92 \ud83c\udd93 \ud83c\udd95 \ud83c\udd96 \ud83c\udd97 \ud83c\udd99 \ud83c\udfe7",
);
}
================================================
FILE: packages/quicktype-core/src/Messages.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
import type { Ref } from "./input/JSONSchemaInput";
import type { StringMap } from "./support/Support";
export type ErrorProperties =
| { kind: "InternalError"; properties: { message: string } }
// Misc
| {
kind: "MiscJSONParseError";
properties: { address: string; description: string; message: string };
}
| {
kind: "MiscReadError";
properties: { fileOrURL: string; message: string };
}
| { kind: "MiscUnicodeHighSurrogateWithoutLowSurrogate"; properties: {} }
| {
kind: "MiscInvalidMinMaxConstraint";
properties: { max: number; min: number };
}
// Inference
| {
kind: "InferenceJSONReferenceNotRooted";
properties: { reference: string };
}
| {
kind: "InferenceJSONReferenceToUnion";
properties: { reference: string };
}
| {
kind: "InferenceJSONReferenceWrongProperty";
properties: { reference: string };
}
| {
kind: "InferenceJSONReferenceInvalidArrayIndex";
properties: { reference: string };
}
// JSON Schema input
| { kind: "SchemaArrayIsInvalidSchema"; properties: { ref: Ref } }
| { kind: "SchemaNullIsInvalidSchema"; properties: { ref: Ref } }
| {
kind: "SchemaRefMustBeString";
properties: { actual: string; ref: Ref };
}
| { kind: "SchemaAdditionalTypesForbidRequired"; properties: { ref: Ref } }
| { kind: "SchemaNoTypeSpecified"; properties: { ref: Ref } }
| { kind: "SchemaInvalidType"; properties: { ref: Ref; type: string } }
| { kind: "SchemaFalseNotSupported"; properties: { ref: Ref } }
| {
kind: "SchemaInvalidJSONSchemaType";
properties: { ref: Ref; type: string };
}
| {
kind: "SchemaRequiredMustBeStringOrStringArray";
properties: { actual: any; ref: Ref };
}
| {
kind: "SchemaRequiredElementMustBeString";
properties: { element: any; ref: Ref };
}
| {
kind: "SchemaTypeMustBeStringOrStringArray";
properties: { actual: any };
}
| {
kind: "SchemaTypeElementMustBeString";
properties: { element: any; ref: Ref };
}
| {
kind: "SchemaArrayItemsMustBeStringOrArray";
properties: { actual: any; ref: Ref };
}
| { kind: "SchemaIDMustHaveAddress"; properties: { id: string; ref: Ref } }
| {
kind: "SchemaWrongAccessorEntryArrayLength";
properties: { operation: string; ref: Ref };
}
| {
kind: "SchemaSetOperationCasesIsNotArray";
properties: { cases: any; operation: string; ref: Ref };
}
| {
kind: "SchemaMoreThanOneUnionMemberName";
properties: { names: string[] };
}
| { kind: "SchemaCannotGetTypesFromBoolean"; properties: { ref: string } }
| {
kind: "SchemaCannotIndexArrayWithNonNumber";
properties: { actual: string; ref: Ref };
}
| { kind: "SchemaIndexNotInArray"; properties: { index: number; ref: Ref } }
| { kind: "SchemaKeyNotInObject"; properties: { key: string; ref: Ref } }
| { kind: "SchemaFetchError"; properties: { address: string; base: Ref } }
| { kind: "SchemaFetchErrorTopLevel"; properties: { address: string } }
| { kind: "SchemaFetchErrorAdditional"; properties: { address: string } }
// GraphQL input
| { kind: "GraphQLNoQueriesDefined"; properties: {} }
// Driver
| { kind: "DriverUnknownSourceLanguage"; properties: { lang: string } }
| { kind: "DriverUnknownOutputLanguage"; properties: { lang: string } }
| { kind: "DriverMoreThanOneInputGiven"; properties: { topLevel: string } }
| { kind: "DriverCannotInferNameForSchema"; properties: { uri: string } }
| { kind: "DriverNoGraphQLQueryGiven"; properties: {} }
| { kind: "DriverNoGraphQLSchemaInDir"; properties: { dir: string } }
| {
kind: "DriverMoreThanOneGraphQLSchemaInDir";
properties: { dir: string };
}
| { kind: "DriverSourceLangMustBeGraphQL"; properties: {} }
| { kind: "DriverGraphQLSchemaNeeded"; properties: {} }
| { kind: "DriverInputFileDoesNotExist"; properties: { filename: string } }
| {
kind: "DriverCannotMixJSONWithOtherSamples";
properties: { dir: string };
}
| { kind: "DriverCannotMixNonJSONInputs"; properties: { dir: string } }
| { kind: "DriverUnknownDebugOption"; properties: { option: string } }
| { kind: "DriverNoLanguageOrExtension"; properties: {} }
| { kind: "DriverCLIOptionParsingFailed"; properties: { message: string } }
// IR
| { kind: "IRNoForwardDeclarableTypeInCycle"; properties: {} }
| {
kind: "IRTypeAttributesNotPropagated";
properties: { count: number; indexes: number[] };
}
| { kind: "IRNoEmptyUnions"; properties: {} }
// Rendering
| {
kind: "RendererUnknownOptionValue";
properties: { name: string; value: string };
}
// TypeScript input
| { kind: "TypeScriptCompilerError"; properties: { message: string } };
export type ErrorKinds = ErrorProperties["kind"];
type ErrorMessages = { readonly [K in ErrorKinds]: string };
const errorMessages: ErrorMessages = {
InternalError: "Internal error: ${message}",
// Misc
MiscJSONParseError:
"Syntax error in ${description} JSON ${address}: ${message}",
MiscReadError: "Cannot read from file or URL ${fileOrURL}: ${message}",
MiscUnicodeHighSurrogateWithoutLowSurrogate:
"Malformed unicode: High surrogate not followed by low surrogate",
MiscInvalidMinMaxConstraint: "Invalid min-max constraint: ${min}-${max}",
// Inference
InferenceJSONReferenceNotRooted:
"JSON reference doesn't start with '#/': ${reference}",
InferenceJSONReferenceToUnion:
"JSON reference points to a union type: ${reference}",
InferenceJSONReferenceWrongProperty:
"JSON reference points to a non-existant property: ${reference}",
InferenceJSONReferenceInvalidArrayIndex:
"JSON reference uses invalid array index: ${reference}",
// JSON Schema input
SchemaArrayIsInvalidSchema: "An array is not a valid JSON Schema at ${ref}",
SchemaNullIsInvalidSchema: "null is not a valid JSON Schema at ${ref}",
SchemaRefMustBeString:
"$ref must be a string, but is an ${actual} at ${ref}",
SchemaAdditionalTypesForbidRequired:
"Can't have non-specified required properties but forbidden additionalTypes at ${ref}",
SchemaNoTypeSpecified:
"JSON Schema must specify at least one type at ${ref}",
SchemaInvalidType: "Invalid type ${type} in JSON Schema at ${ref}",
SchemaFalseNotSupported: 'Schema "false" is not supported at ${ref}',
SchemaInvalidJSONSchemaType:
"Value of type ${type} is not valid JSON Schema at ${ref}",
SchemaRequiredMustBeStringOrStringArray:
"`required` must be string or array of strings, but is ${actual} at ${ref}",
SchemaRequiredElementMustBeString:
"`required` must contain only strings, but it has ${element}, at ${ref}",
SchemaTypeMustBeStringOrStringArray:
"`type` must be string or array of strings, but is ${actual}",
SchemaTypeElementMustBeString:
"`type` must contain only strings, but it has ${element}",
SchemaArrayItemsMustBeStringOrArray:
"Array items must be an array or an object, but is ${actual}",
SchemaIDMustHaveAddress: "$id ${id} doesn't have an address at ${ref}",
SchemaWrongAccessorEntryArrayLength:
"Accessor entry array must have the same number of entries as the ${operation} at ${ref}",
SchemaSetOperationCasesIsNotArray:
"${operation} cases must be an array, but is ${cases}, at ${ref}",
SchemaMoreThanOneUnionMemberName:
"More than one name given for union member: ${names}",
SchemaCannotGetTypesFromBoolean:
"Schema value to get top-level types from must be an object, but is boolean, at ${ref}",
SchemaCannotIndexArrayWithNonNumber:
"Trying to index array in schema with key that is not a number, but is ${actual} at ${ref}",
SchemaIndexNotInArray:
"Index ${index} out of range of schema array at ${ref}",
SchemaKeyNotInObject: "Key ${key} not in schema object at ${ref}",
SchemaFetchError:
"Could not fetch schema ${address}, referred to from ${base}",
SchemaFetchErrorTopLevel: "Could not fetch top-level schema ${address}",
SchemaFetchErrorAdditional: "Could not fetch additional schema ${address}",
// GraphQL input
GraphQLNoQueriesDefined: "GraphQL file doesn't have any queries defined.",
// Driver
DriverUnknownSourceLanguage: "Unknown source language ${lang}",
DriverUnknownOutputLanguage: "Unknown output language ${lang}",
DriverMoreThanOneInputGiven:
"More than one input given for top-level ${topLevel}",
DriverCannotInferNameForSchema: "Cannot infer name for schema ${uri}",
DriverNoGraphQLQueryGiven:
"Please specify at least one GraphQL query as input",
DriverNoGraphQLSchemaInDir: "No GraphQL schema in ${dir}",
DriverMoreThanOneGraphQLSchemaInDir:
"More than one GraphQL schema in ${dir}",
DriverSourceLangMustBeGraphQL:
"If a GraphQL schema is specified, the source language must be GraphQL",
DriverGraphQLSchemaNeeded:
"Please specify a GraphQL schema with --graphql-schema or --graphql-introspect",
DriverInputFileDoesNotExist: "Input file ${filename} does not exist",
DriverCannotMixJSONWithOtherSamples:
"Cannot mix JSON samples with JSON Schems, GraphQL, or TypeScript in input subdirectory ${dir}",
DriverCannotMixNonJSONInputs:
"Cannot mix JSON Schema, GraphQL, and TypeScript in an input subdirectory ${dir}",
DriverUnknownDebugOption: "Unknown debug option ${option}",
DriverNoLanguageOrExtension:
"Please specify a language (--lang) or an output file extension",
DriverCLIOptionParsingFailed: "Option parsing failed: ${message}",
// IR
IRNoForwardDeclarableTypeInCycle:
"Cannot resolve cycle because it doesn't contain types that can be forward declared",
IRTypeAttributesNotPropagated:
"Type attributes for ${count} types were not carried over to the new graph: ${indexes}",
IRNoEmptyUnions:
"Trying to make an empty union - do you have an impossible type in your schema?",
// Rendering
RendererUnknownOptionValue: "Unknown value ${value} for option ${name}",
// TypeScript input
TypeScriptCompilerError: "TypeScript error: ${message}",
};
export type ErrorPropertiesForKind = Extract<
ErrorProperties,
{ kind: K }
> extends { properties: infer P }
? P
: never;
export class QuickTypeError extends Error {
public constructor(
public readonly errorMessage: string,
public readonly messageName: string,
public userMessage: string,
public readonly properties: StringMap,
) {
super(userMessage);
}
}
export function messageError(
kind: Kind,
properties: ErrorPropertiesForKind,
): never {
const message = errorMessages[kind];
let userMessage: string = message;
for (const [name, value] of Object.entries(properties as StringMap)) {
let valueString = "";
if (
typeof value === "object" &&
typeof value?.toString === "function"
) {
valueString = value.toString();
} else if (typeof value?.message === "string") {
valueString = value.message;
} else if (typeof value !== "string") {
valueString = JSON.stringify(value);
}
userMessage = userMessage.replace("${" + name + "}", valueString);
}
throw new QuickTypeError(
message,
kind,
userMessage,
properties as StringMap,
);
}
export function messageAssert(
assertion: boolean,
kind: Kind,
properties: ErrorPropertiesForKind,
): void {
if (assertion) return;
return messageError(kind, properties);
}
================================================
FILE: packages/quicktype-core/src/Naming.ts
================================================
import {
iterableEvery,
iterableFind,
iterableFirst,
iterableMinBy,
iterableSome,
mapMergeInto,
setFilter,
setFilterMap,
setGroupBy,
setMap,
setUnion,
setUnionInto,
} from "collection-utils";
import { assert, defined, panic } from "./support/Support";
export class Namespace {
public readonly forbiddenNamespaces: ReadonlySet;
public readonly additionalForbidden: ReadonlySet;
private readonly _children = new Set();
private readonly _members = new Set();
public constructor(
_name: string,
parent: Namespace | undefined,
forbiddenNamespaces: Iterable,
additionalForbidden: Iterable,
) {
this.forbiddenNamespaces = new Set(forbiddenNamespaces);
this.additionalForbidden = new Set(additionalForbidden);
if (parent !== undefined) {
parent.addChild(this);
}
}
private addChild(child: Namespace): void {
this._children.add(child);
}
public get children(): ReadonlySet {
return this._children;
}
public get members(): ReadonlySet {
return this._members;
}
public get forbiddenNameds(): ReadonlySet {
// FIXME: cache
return setUnion(
this.additionalForbidden,
...Array.from(this.forbiddenNamespaces).map((ns) => ns.members),
);
}
public add(named: TName): TName {
this._members.add(named);
return named;
}
}
export type NameStyle = (rawName: string) => string;
// `Namer`s are invoked to figure out what names to assign non-fixed `Name`s,
// and in particular to resolve conflicts. Those arise under two circumstances,
// which can also combine:
//
// 1. A proposed name is the same as an already assigned name that's forbidden
// for the name to be assigned.
// 2. There is more than one `Name` about to be assigned a name that all have
// the same proposed name.
//
// The namer is invoked with the set of all assigned, forbidden names,
// the requested name, and the `Name`s to assign names to.
//
// `Namer` is a class so that we can compare namers and put them into immutable
// collections.
export class Namer {
private readonly _prefixes: ReadonlySet;
public constructor(
public readonly name: string,
public readonly nameStyle: NameStyle,
public prefixes: string[],
) {
this._prefixes = new Set(prefixes);
}
// The namesIterable comes directly out of the context and will
// be modified if we assign
public assignNames(
names: ReadonlyMap,
forbiddenNamesIterable: Iterable,
namesToAssignIterable: Iterable,
): ReadonlyMap {
const forbiddenNames = new Set(forbiddenNamesIterable);
const namesToAssign = Array.from(namesToAssignIterable);
assert(
namesToAssign.length > 0,
"Number of names can't be less than 1",
);
const allAssignedNames = new Map