quicktype-core 6.0.65 → 6.0.69

package/dist/language/CPlusPlus.d.ts

@@ -174,6 +174,7 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     protected emitUnionHeaders(u: UnionType): void;
     protected emitUnionFunctions(u: UnionType): void;
     protected emitEnumHeaders(enumName: Name): void;
+    private isLargeEnum;
     protected emitEnumFunctions(e: EnumType, enumName: Name): void;
     protected emitTopLevelTypedef(t: Type, name: Name): void;
     protected emitAllUnionFunctions(): void;

package/dist/language/CPlusPlus.js

@@ -1103,16 +1103,34 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("void from_json(", this.withConst("json"), " & j, ", ourQualifier, enumName, " & x);");
         this.emitLine("void to_json(json & j, ", this.withConst([ourQualifier, enumName]), " & x);");
     }
+    isLargeEnum(e) {
+        // This is just an estimation. Someone might want to do some
+        // benchmarks to find the optimum value here
+        return e.cases.size > 15;
+    }
     emitEnumFunctions(e, enumName) {
         const ourQualifier = this.ourQualifier(true);
         this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, enumName, " & x)"], false, () => {
-            let onFirst = true;
-            this.forEachEnumCase(e, "none", (name, jsonName) => {
-                const maybeElse = onFirst ? "" : "else ";
-                this.emitLine(maybeElse, "if (j == ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
-                onFirst = false;
-            });
-            this.emitLine('else throw "Input JSON does not conform to schema";');
+            if (this.isLargeEnum(e)) {
+                this.emitBlock(["static std::unordered_map<", this._stringType.getType(), ", ", ourQualifier, enumName, "> enumValues"], true, () => {
+                    this.forEachEnumCase(e, "none", (name, jsonName) => {
+                        this.emitLine("{", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
+                    });
+                });
+                this.emitLine(`auto iter = enumValues.find(j.get<${this._stringType.getType()}>());`);
+                this.emitBlock("if (iter != enumValues.end())", false, () => {
+                    this.emitLine("x = iter->second;");
+                });
+            }
+            else {
+                let onFirst = true;
+                this.forEachEnumCase(e, "none", (name, jsonName) => {
+                    const maybeElse = onFirst ? "" : "else ";
+                    this.emitLine(maybeElse, "if (j == ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
+                    onFirst = false;
+                });
+                this.emitLine('else throw "Input JSON does not conform to schema";');
+            }
         });
         this.ensureBlankLine();
         this.emitBlock(["inline void to_json(json & j, ", this.withConst([ourQualifier, enumName]), " & x)"], false, () => {
@@ -1325,6 +1343,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitInclude(true, `codecvt`);
             this.emitInclude(true, `locale`);
         }
+        // Include unordered_map if contains large enums
+        if (Array.from(this.enums).some(enumType => this.isLargeEnum(enumType))) {
+            this.emitInclude(true, `unordered_map`);
+        }
         this.ensureBlankLine();
     }
     emitHelper() {

package/dist/language/Golang.js

@@ -58,7 +58,7 @@ function canOmitEmpty(cp) {
     if (!cp.isOptional)
         return false;
     const t = cp.type;
-    return ["union", "null", "any", "array"].indexOf(t.kind) < 0;
+    return ["union", "null", "any"].indexOf(t.kind) < 0;
 }
 class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     constructor(targetLanguage, renderContext, _options) {

package/dist/language/JavaScript.d.ts

@@ -6,13 +6,14 @@ import { Namer, Name } from "../Naming";
 import { ConvenienceRenderer } from "../ConvenienceRenderer";
 import { TargetLanguage } from "../TargetLanguage";
 import { StringTypeMapping } from "../TypeBuilder";
-import { BooleanOption, Option, OptionValues } from "../RendererOptions";
+import { BooleanOption, Option, OptionValues, EnumOption } from "../RendererOptions";
 import { RenderContext } from "../Renderer";
 export declare const javaScriptOptions: {
-    acronymStyle: import("../RendererOptions").EnumOption<AcronymStyleOptions>;
+    acronymStyle: EnumOption<AcronymStyleOptions>;
     runtimeTypecheck: BooleanOption;
     runtimeTypecheckIgnoreUnknownProperties: BooleanOption;
-    converters: import("../RendererOptions").EnumOption<ConvertersOptions>;
+    converters: EnumOption<ConvertersOptions>;
+    rawType: EnumOption<"any" | "json">;
 };
 export declare type JavaScriptTypeAnnotations = {
     any: string;

package/dist/language/JavaScript.js

@@ -17,6 +17,10 @@ exports.javaScriptOptions = {
     runtimeTypecheck: new RendererOptions_1.BooleanOption("runtime-typecheck", "Verify JSON.parse results at runtime", true),
     runtimeTypecheckIgnoreUnknownProperties: new RendererOptions_1.BooleanOption("runtime-typecheck-ignore-unknown-properties", "Ignore unknown properties when verifying at runtime", false, "secondary"),
     converters: Converters_1.convertersOption(),
+    rawType: new RendererOptions_1.EnumOption("raw-type", "Type to raw input (json by default)", [
+        ["json", "json"],
+        ["any", "any"]
+    ], "json", "secondary")
 };
 class JavaScriptTargetLanguage extends TargetLanguage_1.TargetLanguage {
     constructor(displayName = "JavaScript", names = ["javascript", "js", "jsx"], extension = "js") {
@@ -28,6 +32,7 @@ class JavaScriptTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.javaScriptOptions.runtimeTypecheckIgnoreUnknownProperties,
             exports.javaScriptOptions.acronymStyle,
             exports.javaScriptOptions.converters,
+            exports.javaScriptOptions.rawType
         ];
     }
     get stringTypeMapping() {
@@ -153,26 +158,45 @@ class JavaScriptRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return ["function cast(val, typ)", "function uncast(val, typ)"];
     }
     get typeAnnotations() {
-        return { any: "", anyArray: "", anyMap: "", string: "", stringArray: "", boolean: "", never: "" };
+        return {
+            any: "",
+            anyArray: "",
+            anyMap: "",
+            string: "",
+            stringArray: "",
+            boolean: "",
+            never: ""
+        };
     }
     emitConvertModuleBody() {
         const converter = (t, name) => {
             const typeMap = this.typeMapTypeFor(t);
             this.emitBlock([this.deserializerFunctionLine(t, name), " "], "", () => {
+                const parsedJson = this._jsOptions.rawType === "json" ? "JSON.parse(json)" : "json";
                 if (!this._jsOptions.runtimeTypecheck) {
-                    this.emitLine("return JSON.parse(json);");
+                    this.emitLine("return ", parsedJson, ";");
                 }
                 else {
-                    this.emitLine("return cast(JSON.parse(json), ", typeMap, ");");
+                    this.emitLine("return cast(", parsedJson, ", ", typeMap, ");");
                 }
             });
             this.ensureBlankLine();
             this.emitBlock([this.serializerFunctionLine(t, name), " "], "", () => {
-                if (!this._jsOptions.runtimeTypecheck) {
-                    this.emitLine("return JSON.stringify(value);");
+                if (this._jsOptions.rawType === "json") {
+                    if (!this._jsOptions.runtimeTypecheck) {
+                        this.emitLine("return JSON.stringify(value);");
+                    }
+                    else {
+                        this.emitLine("return JSON.stringify(uncast(value, ", typeMap, "), null, 2);");
+                    }
                 }
                 else {
-                    this.emitLine("return JSON.stringify(uncast(value, ", typeMap, "), null, 2);");
+                    if (!this._jsOptions.runtimeTypecheck) {
+                        this.emitLine("return value;");
+                    }
+                    else {
+                        this.emitLine("return uncast(value, ", typeMap, ");");
+                    }
                 }
             });
         };
@@ -189,8 +213,12 @@ class JavaScriptRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         if (this._jsOptions.runtimeTypecheck) {
             const { any: anyAnnotation, anyArray: anyArrayAnnotation, anyMap: anyMapAnnotation, string: stringAnnotation, stringArray: stringArrayAnnotation, never: neverAnnotation } = this.typeAnnotations;
             this.ensureBlankLine();
-            this.emitMultiline(`function invalidValue(typ${anyAnnotation}, val${anyAnnotation})${neverAnnotation} {
-    throw Error(\`Invalid value \${JSON.stringify(val)} for type \${JSON.stringify(typ)}\`);
+            this
+                .emitMultiline(`function invalidValue(typ${anyAnnotation}, val${anyAnnotation}, key${anyAnnotation} = '')${neverAnnotation} {
+    if (key) {
+        throw Error(\`Invalid value for key \"\${key}\". Expected type \${JSON.stringify(typ)} but got \${JSON.stringify(val)}\`);
+    }
+    throw Error(\`Invalid value \${JSON.stringify(val)} for type \${JSON.stringify(typ)}\`, );
 }
 
 function jsonToJSProps(typ${anyAnnotation})${anyAnnotation} {
@@ -211,10 +239,10 @@ function jsToJSONProps(typ${anyAnnotation})${anyAnnotation} {
     return typ.jsToJSON;
 }
 
-function transform(val${anyAnnotation}, typ${anyAnnotation}, getProps${anyAnnotation})${anyAnnotation} {
+function transform(val${anyAnnotation}, typ${anyAnnotation}, getProps${anyAnnotation}, key${anyAnnotation} = '')${anyAnnotation} {
     function transformPrimitive(typ${stringAnnotation}, val${anyAnnotation})${anyAnnotation} {
         if (typeof typ === typeof val) return val;
-        return invalidValue(typ, val);
+        return invalidValue(typ, val, key);
     }
 
     function transformUnion(typs${anyArrayAnnotation}, val${anyAnnotation})${anyAnnotation} {
@@ -259,13 +287,13 @@ function transform(val${anyAnnotation}, typ${anyAnnotation}, getProps${anyAnnota
         Object.getOwnPropertyNames(props).forEach(key => {
             const prop = props[key];
             const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
-            result[prop.key] = transform(v, prop.typ, getProps);
+            result[prop.key] = transform(v, prop.typ, getProps, prop.key);
         });
         Object.getOwnPropertyNames(val).forEach(key => {
             if (!Object.prototype.hasOwnProperty.call(props, key)) {
                 result[key] = ${this._jsOptions.runtimeTypecheckIgnoreUnknownProperties
                 ? `val[key]`
-                : `transform(val[key], additional, getProps)`};
+                : `transform(val[key], additional, getProps, key)`};
             }
         });
         return result;
@@ -325,9 +353,9 @@ function r(name${stringAnnotation}) {
     }
     emitConvertModule() {
         this.ensureBlankLine();
-        this.emitMultiline(`// Converts JSON strings to/from your types`);
+        this.emitMultiline(`// Converts JSON ${this._jsOptions.rawType === "json" ? "strings" : "types"} to/from your types`);
         if (this._jsOptions.runtimeTypecheck) {
-            this.emitMultiline(`// and asserts the results of JSON.parse at runtime`);
+            this.emitMultiline(`// and asserts the results${this._jsOptions.rawType === "json" ? " of JSON.parse" : ""} at runtime`);
         }
         const moduleLine = this.moduleLine;
         if (moduleLine === undefined) {

package/dist/language/Objective-C.js

@@ -540,6 +540,14 @@ class ObjectiveCRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitLine("id resolved = ", className, ".properties[key];");
                 this.emitLine("if (resolved) [super setValue:value forKey:resolved];");
             });
+            // setNilValueForKey: is automatically invoked by the NSObject setValue:forKey: when it is passed nil for a scalar (a.k.a. non-nullable) object
+            // The approach below sets the scalar to 0 in this case, and therefore assumes an initializer with incomplete data shouldn't be grounds for raising an exception.
+            // Put another way, if the initializer didn't have a key at all, there wouldn't be an exception raised, so sending nil for something probably shouldn't cause one.
+            this.ensureBlankLine();
+            this.emitMethod("- (void)setNilValueForKey:(NSString *)key", () => {
+                this.emitLine("id resolved = ", className, ".properties[key];");
+                this.emitLine("if (resolved) [super setValue:@(0) forKey:resolved];");
+            });
             this.ensureBlankLine();
             this.emitMethod("- (NSDictionary *)JSONDictionary", () => {
                 if (!hasIrregularProperties && !hasUnsafeProperties) {

package/dist/language/Rust.d.ts

@@ -18,6 +18,8 @@ export declare const rustOptions: {
     density: EnumOption<Density>;
     visibility: EnumOption<Visibility>;
     deriveDebug: BooleanOption;
+    edition2018: BooleanOption;
+    leadingComments: BooleanOption;
 };
 export declare class RustTargetLanguage extends TargetLanguage {
     protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {

package/dist/language/Rust.js

@@ -22,13 +22,18 @@ var Visibility;
     Visibility[Visibility["Public"] = 2] = "Public";
 })(Visibility = exports.Visibility || (exports.Visibility = {}));
 exports.rustOptions = {
-    density: new RendererOptions_1.EnumOption("density", "Density", [["normal", Density.Normal], ["dense", Density.Dense]]),
+    density: new RendererOptions_1.EnumOption("density", "Density", [
+        ["normal", Density.Normal],
+        ["dense", Density.Dense]
+    ]),
     visibility: new RendererOptions_1.EnumOption("visibility", "Field visibility", [
         ["private", Visibility.Private],
         ["crate", Visibility.Crate],
         ["public", Visibility.Public]
     ]),
-    deriveDebug: new RendererOptions_1.BooleanOption("derive-debug", "Derive Debug impl", false)
+    deriveDebug: new RendererOptions_1.BooleanOption("derive-debug", "Derive Debug impl", false),
+    edition2018: new RendererOptions_1.BooleanOption("edition-2018", "Edition 2018", false),
+    leadingComments: new RendererOptions_1.BooleanOption("leading-comments", "Leading Comments", true)
 };
 class RustTargetLanguage extends TargetLanguage_1.TargetLanguage {
     makeRenderer(renderContext, untypedOptionValues) {
@@ -274,9 +279,16 @@ class RustRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
 // }`);
     }
     emitSourceStructure() {
-        this.emitLeadingComments();
+        if (this._options.leadingComments) {
+            this.emitLeadingComments();
+        }
         this.ensureBlankLine();
-        this.emitLine("extern crate serde_json;");
+        if (this._options.edition2018) {
+            this.emitLine("use serde::{Serialize, Deserialize};");
+        }
+        else {
+            this.emitLine("extern crate serde_derive;");
+        }
         if (this.haveMaps) {
             this.emitLine("use std::collections::HashMap;");
         }

package/dist/language/TypeScriptFlow.d.ts

@@ -10,6 +10,7 @@ export declare const tsFlowOptions: {
     runtimeTypecheck: BooleanOption;
     runtimeTypecheckIgnoreUnknownProperties: BooleanOption;
     converters: import("../RendererOptions").EnumOption<import("../support/Converters").ConvertersOptions>;
+    rawType: import("../RendererOptions").EnumOption<"any" | "json">;
 } & {
     justTypes: BooleanOption;
     nicePropertyNames: BooleanOption;
@@ -29,7 +30,7 @@ export declare class TypeScriptTargetLanguage extends TypeScriptFlowBaseTargetLa
     }): TypeScriptRenderer;
 }
 export declare abstract class TypeScriptFlowBaseRenderer extends JavaScriptRenderer {
-    private readonly _tsFlowOptions;
+    protected readonly _tsFlowOptions: OptionValues<typeof tsFlowOptions>;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _tsFlowOptions: OptionValues<typeof tsFlowOptions>);
     protected namerForObjectProperty(): Namer;
     protected sourceFor(t: Type): MultiWord;

package/dist/language/TypeScriptFlow.js

@@ -31,7 +31,8 @@ class TypeScriptFlowBaseTargetLanguage extends JavaScript_1.JavaScriptTargetLang
             exports.tsFlowOptions.runtimeTypecheck,
             exports.tsFlowOptions.runtimeTypecheckIgnoreUnknownProperties,
             exports.tsFlowOptions.acronymStyle,
-            exports.tsFlowOptions.converters
+            exports.tsFlowOptions.converters,
+            exports.tsFlowOptions.rawType
         ];
     }
     get supportsOptionalClassProperties() {
@@ -138,11 +139,13 @@ class TypeScriptFlowBaseRenderer extends JavaScript_1.JavaScriptRenderer {
         super.emitUsageComments();
     }
     deserializerFunctionLine(t, name) {
-        return ["function to", name, "(json: string): ", this.sourceFor(t).source];
+        const jsonType = this._tsFlowOptions.rawType === "json" ? "string" : "any";
+        return ["function to", name, "(json: ", jsonType, "): ", this.sourceFor(t).source];
     }
     serializerFunctionLine(t, name) {
         const camelCaseName = Source_1.modifySource(Strings_1.camelCase, name);
-        return ["function ", camelCaseName, "ToJson(value: ", this.sourceFor(t).source, "): string"];
+        const returnType = this._tsFlowOptions.rawType === "json" ? "string" : "any";
+        return ["function ", camelCaseName, "ToJson(value: ", this.sourceFor(t).source, "): ", returnType];
     }
     get moduleLine() {
         return undefined;
@@ -178,11 +181,13 @@ class TypeScriptRenderer extends TypeScriptFlowBaseRenderer {
         return ["Array", "Date"];
     }
     deserializerFunctionLine(t, name) {
-        return ["public static to", name, "(json: string): ", this.sourceFor(t).source];
+        const jsonType = this._tsFlowOptions.rawType === "json" ? "string" : "any";
+        return ["public static to", name, "(json: ", jsonType, "): ", this.sourceFor(t).source];
     }
     serializerFunctionLine(t, name) {
         const camelCaseName = Source_1.modifySource(Strings_1.camelCase, name);
-        return ["public static ", camelCaseName, "ToJson(value: ", this.sourceFor(t).source, "): string"];
+        const returnType = this._tsFlowOptions.rawType === "json" ? "string" : "any";
+        return ["public static ", camelCaseName, "ToJson(value: ", this.sourceFor(t).source, "): ", returnType];
     }
     get moduleLine() {
         return "export class Convert";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "6.0.65",
+    "version": "6.0.69",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",
@@ -14,6 +14,7 @@
     },
     "dependencies": {
         "collection-utils": "^1.0.1",
+        "is-url": "^1.2.4",
         "js-base64": "^2.4.3",
         "pako": "^1.0.6",
         "pluralize": "^7.0.0",
@@ -28,13 +29,13 @@
     "devDependencies": {
         "@types/urijs": "^1.19.8",
         "@types/js-base64": "^2.3.1",
-        "@types/node": "^8.10.10",
+        "@types/node": "8.10.10",
         "@types/pako": "^1.0.0",
         "@types/pluralize": "0.0.28",
         "@types/yaml": "^1.0.2",
         "typescript": "~3.2.1",
         "tslint": "^5.11.0",
-        "@types/readable-stream": "2.3.0",
+        "@types/readable-stream": "2.3.9",
         "@types/browser-or-node": "^1.2.0"
     },
     "files": [
@@ -44,6 +45,6 @@
         "fs": false
     },
     "config": {
-        "commit": "7a6a0fbdaa817ac36d0acf8701fe92e36ae261d6"
+        "commit": "e6cc44fdfcb75c3f3ed3e12f69f15a0c863a1a05"
     }
 }