quicktype-core 23.0.51 → 23.0.53

package/dist/input/JSONSchemaInput.js

@@ -558,6 +558,7 @@ function addTypesInSchema(resolver, typeBuilder, references, attributeProducers)
         function convertToType(schema, loc, typeAttributes) {
             return __awaiter(this, void 0, void 0, function* () {
                 const enumArray = Array.isArray(schema.enum) ? schema.enum : undefined;
+                const isConst = schema.const !== undefined;
                 const typeSet = (0, collection_utils_1.definedMap)(schema.type, t => checkTypeList(t, loc));
                 function isTypeIncluded(name) {
                     if (typeSet !== undefined && !typeSet.has(name)) {
@@ -578,6 +579,9 @@ function addTypesInSchema(resolver, typeBuilder, references, attributeProducers)
                         }
                         return enumArray.find(predicate) !== undefined;
                     }
+                    if (isConst) {
+                        return name === "string";
+                    }
                     return true;
                 }
                 const includedTypes = (0, collection_utils_1.setFilter)(schemaTypes, isTypeIncluded);
@@ -756,8 +760,8 @@ function addTypesInSchema(resolver, typeBuilder, references, attributeProducers)
                         return unionType;
                     });
                 }
-                const includeObject = enumArray === undefined && (typeSet === undefined || typeSet.has("object"));
-                const includeArray = enumArray === undefined && (typeSet === undefined || typeSet.has("array"));
+                const includeObject = enumArray === undefined && !isConst && (typeSet === undefined || typeSet.has("object"));
+                const includeArray = enumArray === undefined && !isConst && (typeSet === undefined || typeSet.has("array"));
                 const needStringEnum = includedTypes.has("string") &&
                     enumArray !== undefined &&
                     enumArray.find((x) => typeof x === "string") !== undefined;
@@ -766,7 +770,8 @@ function addTypesInSchema(resolver, typeBuilder, references, attributeProducers)
                     schema.additionalProperties !== undefined ||
                     schema.items !== undefined ||
                     schema.required !== undefined ||
-                    enumArray !== undefined;
+                    enumArray !== undefined ||
+                    isConst;
                 const types = [];
                 if (needUnion) {
                     const unionTypes = [];
@@ -783,8 +788,10 @@ function addTypesInSchema(resolver, typeBuilder, references, attributeProducers)
                         unionTypes.push(typeBuilder.getPrimitiveType(kind, attributes));
                     }
                     const stringAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", inferredAttributes, combineProducedAttributes(({ forString }) => forString));
-                    if (needStringEnum) {
-                        const cases = enumArray.filter(x => typeof x === "string");
+                    if (needStringEnum || isConst) {
+                        const cases = isConst
+                            ? [schema.const]
+                            : enumArray.filter(x => typeof x === "string");
                         unionTypes.push(typeBuilder.getStringType(stringAttributes, StringTypes_1.StringTypes.fromCases(cases)));
                     }
                     else if (includedTypes.has("string")) {

package/dist/language/TypeScriptFlow.d.ts

@@ -17,6 +17,7 @@ export declare const tsFlowOptions: {
     declareUnions: BooleanOption;
     preferUnions: BooleanOption;
     preferTypes: BooleanOption;
+    preferConstValues: BooleanOption;
 };
 export declare abstract class TypeScriptFlowBaseTargetLanguage extends JavaScriptTargetLanguage {
     protected getOptions(): Option<any>[];

package/dist/language/TypeScriptFlow.js

@@ -15,7 +15,8 @@ exports.tsFlowOptions = Object.assign({}, JavaScript_1.javaScriptOptions, {
     nicePropertyNames: new RendererOptions_1.BooleanOption("nice-property-names", "Transform property names to be JavaScripty", false),
     declareUnions: new RendererOptions_1.BooleanOption("explicit-unions", "Explicitly name unions", false),
     preferUnions: new RendererOptions_1.BooleanOption("prefer-unions", "Use union type instead of enum", false),
-    preferTypes: new RendererOptions_1.BooleanOption("prefer-types", "Use types instead of interfaces", false)
+    preferTypes: new RendererOptions_1.BooleanOption("prefer-types", "Use types instead of interfaces", false),
+    preferConstValues: new RendererOptions_1.BooleanOption("prefer-const-values", "Use string instead of enum for string enums with single value", false)
 });
 const tsFlowTypeAnnotations = {
     any: ": any",
@@ -87,6 +88,10 @@ class TypeScriptFlowBaseRenderer extends JavaScript_1.JavaScriptRenderer {
         }
     }
     sourceFor(t) {
+        if (this._tsFlowOptions.preferConstValues && t.kind === "enum" && t instanceof Type_1.EnumType && t.cases.size === 1) {
+            const item = t.cases.values().next().value;
+            return (0, Source_1.singleWord)(`"${(0, Strings_1.utf16StringEscape)(item)}"`);
+        }
         if (["class", "object", "enum"].indexOf(t.kind) >= 0) {
             return (0, Source_1.singleWord)(this.nameForNamedType(t));
         }
@@ -216,6 +221,9 @@ class TypeScriptRenderer extends TypeScriptFlowBaseRenderer {
     }
     emitEnum(e, enumName) {
         this.emitDescription(this.descriptionForType(e));
+        // enums with only one value are emitted as constants
+        if (this._tsFlowOptions.preferConstValues && e.cases.size === 1)
+            return;
         if (this._tsFlowOptions.preferUnions) {
             let items = "";
             e.cases.forEach(item => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.0.51",
+    "version": "23.0.53",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",