quicktype-core 23.0.108 → 23.0.110

package/dist/language/TypeScriptEffectSchema.d.ts

@@ -1,5 +1,5 @@
-import { ClassProperty, Type } from "../Type";
-import { Namer } from "../Naming";
+import { ClassProperty, ObjectType, Type } from "../Type";
+import { Name, Namer } from "../Naming";
 import { RenderContext } from "../Renderer";
 import { BooleanOption, Option, OptionValues } from "../RendererOptions";
 import { TargetLanguage } from "../TargetLanguage";
@@ -27,9 +27,11 @@ export declare class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer
     private importStatement;
     protected emitImports(): void;
     typeMapTypeForProperty(p: ClassProperty): Sourcelike;
+    emittedObjects: Set<Name>;
     typeMapTypeFor(t: Type, required?: boolean): Sourcelike;
     private emitObject;
     private emitEnum;
+    protected walkObjectNames(type: ObjectType): Name[];
     protected emitSchemas(): void;
     protected emitSourceStructure(): void;
 }

package/dist/language/TypeScriptEffectSchema.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptEffectSchemaRenderer = exports.TypeScriptEffectSchemaTargetLanguage = exports.typeScriptEffectSchemaOptions = void 0;
 const collection_utils_1 = require("collection-utils");
+const Type_1 = require("../Type");
 const TypeUtils_1 = require("../TypeUtils");
 const Naming_1 = require("../Naming");
 const RendererOptions_1 = require("../RendererOptions");
@@ -30,6 +31,7 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
     constructor(targetLanguage, renderContext, _options) {
         super(targetLanguage, renderContext);
         this._options = _options;
+        this.emittedObjects = new Set();
     }
     forbiddenNamesForGlobalNamespace() {
         return ["Class", "Date", "Object", "String", "Array", "JSON", "Error"];
@@ -63,8 +65,12 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
         return p.isOptional ? ["S.optional(", typeMap, ")"] : typeMap;
     }
     typeMapTypeFor(t, required = true) {
-        if (["class", "object", "enum"].indexOf(t.kind) >= 0) {
-            return ["S.lazy(() => ", this.nameForNamedType(t), ")"];
+        if (t.kind === "class" || t.kind === "object" || t.kind === "enum") {
+            const name = this.nameForNamedType(t);
+            if (this.emittedObjects.has(name)) {
+                return [name];
+            }
+            return ["S.suspend(() => ", name, ")"];
         }
         const match = (0, TypeUtils_1.matchType)(t, _anyType => "S.any", _nullType => "S.null", _boolType => "S.boolean", _integerType => "S.number", _doubleType => "S.number", _stringType => "S.string", arrayType => ["S.array(", this.typeMapTypeFor(arrayType.items, false), ")"], _classType => (0, Support_1.panic)("Should already be handled."), _mapType => ["S.record(S.string, ", this.typeMapTypeFor(_mapType.values, false), ")"], _enumType => (0, Support_1.panic)("Should already be handled."), unionType => {
             const children = Array.from(unionType.getChildren()).map((type) => this.typeMapTypeFor(type, false));
@@ -78,37 +84,55 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
         return match;
     }
     emitObject(name, t) {
+        this.emittedObjects.add(name);
         this.ensureBlankLine();
-        if (this._options.justSchema) {
-            this.emitLine("\nexport const ", name, " = S.struct({");
-        }
-        else {
-            this.emitLine("\nconst ", name, "_ = S.struct({");
-        }
+        this.emitLine("\nexport class ", name, " extends S.Class<", name, '>("', name, '")({');
         this.indent(() => {
             this.forEachClassProperty(t, "none", (_, jsonName, property) => {
                 this.emitLine(`"${(0, Strings_1.utf16StringEscape)(jsonName)}"`, ": ", this.typeMapTypeForProperty(property), ",");
             });
         });
-        this.emitLine("});");
-        if (!this._options.justSchema) {
-            this.emitLine("export interface ", name, " extends S.Schema.To<typeof ", name, "_> {}");
-            this.emitLine("export const ", name, ": S.Schema<S.Schema.From<typeof ", name, "_>, ", name, "> = ", name, "_;");
-        }
+        this.emitLine("}) {}");
     }
     emitEnum(e, enumName) {
+        this.emittedObjects.add(enumName);
         this.ensureBlankLine();
         this.emitDescription(this.descriptionForType(e));
-        this.emitLine("\nexport const ", enumName, " = ", "S.enums({");
+        this.emitLine("\nexport const ", enumName, " = ", "S.literal(");
         this.indent(() => this.forEachEnumCase(e, "none", (_, jsonName) => {
-            const name = (0, Strings_1.stringEscape)(jsonName);
-            this.emitLine('"', name, '": "', name, '",');
+            this.emitLine('"', (0, Strings_1.stringEscape)(jsonName), '",');
         }));
-        this.emitLine("});");
+        this.emitLine(");");
         if (!this._options.justSchema) {
-            this.emitLine("export type ", enumName, " = S.Schema.To<typeof ", enumName, ">;");
+            this.emitLine("export type ", enumName, " = S.Schema.Type<typeof ", enumName, ">;");
         }
     }
+    walkObjectNames(type) {
+        const names = [];
+        const recurse = (type) => {
+            if (type.kind === "object" || type.kind === "class") {
+                names.push(this.nameForNamedType(type));
+                this.forEachClassProperty(type, "none", (_, __, prop) => {
+                    recurse(prop.type);
+                });
+            }
+            else if (type instanceof Type_1.ArrayType) {
+                recurse(type.items);
+            }
+            else if (type instanceof Type_1.MapType) {
+                recurse(type.values);
+            }
+            else if (type instanceof Type_1.EnumType) {
+                for (const t of type.getChildren()) {
+                    recurse(t);
+                }
+            }
+        };
+        this.forEachClassProperty(type, "none", (_, __, prop) => {
+            recurse(prop.type);
+        });
+        return names;
+    }
     emitSchemas() {
         this.ensureBlankLine();
         this.forEachEnum("leading-and-interposing", (u, enumName) => {
@@ -119,14 +143,14 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
         const mapValue = [];
         this.forEachObject("none", (type, name) => {
             mapKey.push(name);
-            mapValue.push(this.gatherSource(() => this.emitObject(name, type)));
+            mapValue.push(type);
         });
         mapKey.forEach((_, index) => {
             // assume first
             let ordinal = 0;
             // pull out all names
             const source = mapValue[index];
-            const names = source.filter(value => value);
+            const names = this.walkObjectNames(source);
             // must be behind all these names
             for (let i = 0; i < names.length; i++) {
                 const depName = names[i];
@@ -143,7 +167,7 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
             order.splice(ordinal, 0, index);
         });
         // now emit ordered source
-        order.forEach(i => this.emitGatheredSource(mapValue[i]));
+        order.forEach(i => this.emitGatheredSource(this.gatherSource(() => this.emitObject(mapKey[i], mapValue[i]))));
     }
     emitSourceStructure() {
         if (this.leadingComments !== undefined) {

package/package.json

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