quicktype-core 23.0.98 → 23.0.100

package/dist/input/JSONSchemaInput.js

@@ -670,7 +670,7 @@ function addTypesInSchema(resolver, typeBuilder, references, attributeProducers)
                             const itemsLoc = loc.push("items");
                             itemType = yield toType(checkJSONSchema(items, itemsLoc.canonicalRef), itemsLoc, singularAttributes);
                         }
-                        else if (items !== undefined) {
+                        else if (items !== undefined && items !== true) {
                             return (0, Messages_1.messageError)("SchemaArrayItemsMustBeStringOrArray", withRef(loc, { actual: items }));
                         }
                         else {

package/dist/language/Golang.d.ts

@@ -5,6 +5,7 @@ import { Sourcelike } from "../Source";
 import { TargetLanguage } from "../TargetLanguage";
 import { ConvenienceRenderer } from "../ConvenienceRenderer";
 import { RenderContext } from "../Renderer";
+import { StringTypeMapping } from "..";
 export declare const goOptions: {
     justTypes: BooleanOption;
     justTypesAndPackage: BooleanOption;
@@ -17,6 +18,7 @@ export declare class GoTargetLanguage extends TargetLanguage {
     constructor();
     protected getOptions(): Option<any>[];
     get supportsUnionsWithBothNumberTypes(): boolean;
+    get stringTypeMapping(): StringTypeMapping;
     get supportsOptionalClassProperties(): boolean;
     protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
         [name: string]: any;
@@ -48,6 +50,10 @@ export declare class GoRenderer extends ConvenienceRenderer {
     private emitUnion;
     private emitSingleFileHeaderComments;
     private emitPackageDefinitons;
+    private emitImports;
     private emitHelperFunctions;
     protected emitSourceStructure(): void;
+    private collectAllImports;
+    private collectClassImports;
+    private collectUnionImports;
 }

package/dist/language/Golang.js

@@ -36,6 +36,11 @@ class GoTargetLanguage extends TargetLanguage_1.TargetLanguage {
     get supportsUnionsWithBothNumberTypes() {
         return true;
     }
+    get stringTypeMapping() {
+        const mapping = new Map();
+        mapping.set("date-time", "date-time");
+        return mapping;
+    }
     get supportsOptionalClassProperties() {
         return true;
     }
@@ -57,7 +62,7 @@ const primitiveValueTypeKinds = ["integer", "double", "bool", "string"];
 const compoundTypeKinds = ["array", "class", "map", "enum"];
 function isValueType(t) {
     const kind = t.kind;
-    return primitiveValueTypeKinds.indexOf(kind) >= 0 || kind === "class" || kind === "enum";
+    return primitiveValueTypeKinds.indexOf(kind) >= 0 || kind === "class" || kind === "enum" || kind === "date-time";
 }
 function canOmitEmpty(cp) {
     if (!cp.isOptional)
@@ -154,6 +159,11 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             if (nullable !== null)
                 return this.nullableGoType(nullable, withIssues);
             return this.nameForNamedType(unionType);
+        }, transformedStringType => {
+            if (transformedStringType.kind === "date-time") {
+                return "time.Time";
+            }
+            return "string";
         });
     }
     emitTopLevel(t, name) {
@@ -190,8 +200,8 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitClass(c, className) {
         this.startFile(className);
-        this.emitPackageDefinitons(false);
         let columns = [];
+        const usedTypes = new Set();
         this.forEachClassProperty(c, "none", (name, jsonName, p) => {
             const description = this.descriptionForClassProperty(c, jsonName);
             const docStrings = description !== undefined && description.length > 0 ? description.map(d => "// " + d) : [];
@@ -207,7 +217,9 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 [goType, " "],
                 ["`", tags, "`"]
             ]);
+            usedTypes.add(goType.toString());
         });
+        this.emitPackageDefinitons(false, usedTypes.has("time.Time") || usedTypes.has("*,time.Time") ? new Set(["time"]) : undefined);
         this.emitDescription(this.descriptionForType(c));
         this.emitStruct(className, columns);
         this.endFile();
@@ -310,7 +322,7 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("//    bytes, err = ", ref, ".Marshal()");
         });
     }
-    emitPackageDefinitons(includeJSONEncodingImport) {
+    emitPackageDefinitons(includeJSONEncodingImport, imports = new Set()) {
         if (!this._options.justTypes || this._options.justTypesAndPackage) {
             this.ensureBlankLine();
             const packageDeclaration = "package " + this._options.packageName;
@@ -318,25 +330,35 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         }
         if (!this._options.justTypes && !this._options.justTypesAndPackage) {
-            this.ensureBlankLine();
             if (this.haveNamedUnions && this._options.multiFileOutput === false) {
-                this.emitLineOnce('import "bytes"');
-                this.emitLineOnce('import "errors"');
+                imports.add("bytes");
+                imports.add("errors");
             }
             if (includeJSONEncodingImport) {
-                this.emitLineOnce('import "encoding/json"');
+                imports.add("encoding/json");
             }
-            this.ensureBlankLine();
         }
+        this.emitImports(imports);
+    }
+    emitImports(imports) {
+        const sortedImports = Array.from(imports).sort((a, b) => a.localeCompare(b));
+        if (sortedImports.length === 0) {
+            return;
+        }
+        sortedImports.forEach(packageName => {
+            this.emitLineOnce(`import "${packageName}"`);
+        });
+        this.ensureBlankLine();
     }
     emitHelperFunctions() {
         if (this.haveNamedUnions) {
             this.startFile("JSONSchemaSupport");
-            this.emitPackageDefinitons(true);
+            const imports = new Set();
             if (this._options.multiFileOutput) {
-                this.emitLineOnce('import "bytes"');
-                this.emitLineOnce('import "errors"');
+                imports.add("bytes");
+                imports.add("errors");
             }
+            this.emitPackageDefinitons(true, imports);
             this.ensureBlankLine();
             this
                 .emitMultiline(`func unmarshalUnion(data []byte, pi **int64, pf **float64, pb **bool, ps **string, haveArray bool, pa interface{}, haveObject bool, pc interface{}, haveMap bool, pm interface{}, haveEnum bool, pe interface{}, nullable bool) (bool, error) {
@@ -461,6 +483,7 @@ func marshalUnion(pi *int64, pf *float64, pb *bool, ps *string, haveArray bool,
             this._options.justTypesAndPackage === false &&
             this.leadingComments === undefined) {
             this.emitSingleFileHeaderComments();
+            this.emitPackageDefinitons(false, this.collectAllImports());
         }
         this.forEachTopLevel("leading-and-interposing", (t, name) => this.emitTopLevel(t, name), t => !(this._options.justTypes || this._options.justTypesAndPackage) ||
             this.namedTypeToNameForTopLevel(t) === undefined);
@@ -472,5 +495,54 @@ func marshalUnion(pi *int64, pf *float64, pb *bool, ps *string, haveArray bool,
         }
         this.emitHelperFunctions();
     }
+    collectAllImports() {
+        let imports = new Set();
+        this.forEachObject("leading-and-interposing", (c, _className) => {
+            const classImports = this.collectClassImports(c);
+            imports = new Set([...imports, ...classImports]);
+        });
+        this.forEachUnion("leading-and-interposing", (u, _unionName) => {
+            const unionImports = this.collectUnionImports(u);
+            imports = new Set([...imports, ...unionImports]);
+        });
+        return imports;
+    }
+    collectClassImports(c) {
+        const usedTypes = new Set();
+        const mapping = new Map();
+        mapping.set("time.Time", "time");
+        mapping.set("*,time.Time", "time");
+        this.forEachClassProperty(c, "none", (_name, _jsonName, p) => {
+            const goType = this.propertyGoType(p);
+            usedTypes.add(goType.toString());
+        });
+        const imports = new Set();
+        usedTypes.forEach(k => {
+            const typeImport = mapping.get(k);
+            if (typeImport) {
+                imports.add(typeImport);
+            }
+        });
+        return imports;
+    }
+    collectUnionImports(u) {
+        const usedTypes = new Set();
+        const mapping = new Map();
+        mapping.set("time.Time", "time");
+        mapping.set("*,time.Time", "time");
+        this.forEachUnionMember(u, null, "none", null, (_fieldName, t) => {
+            const goType = this.nullableGoType(t, true);
+            usedTypes.add(goType.toString());
+        });
+        const imports = new Set();
+        usedTypes.forEach(k => {
+            const typeImport = mapping.get(k);
+            if (!typeImport) {
+                return;
+            }
+            imports.add(typeImport);
+        });
+        return imports;
+    }
 }
 exports.GoRenderer = GoRenderer;

package/package.json

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