quicktype-core 23.1.0 → 23.1.2

package/dist/language/CPlusPlus/CPlusPlusRenderer.js

@@ -204,7 +204,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             //     };
             //
             // checking to see if the collapse of the variant has
-            // occured and then doing the isCycleBreakerType check
+            // occurred and then doing the isCycleBreakerType check
             // on the single type the variant would contain seems
             // to solve the problem. But does this point to a problem
             // with the core library or with the CPlusPlus package
@@ -733,7 +733,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             if (constraints === undefined)
                 return;
             const { minMax, minMaxLength, pattern } = constraints;
-            // TODO is there a better way to check if property.type is an interger or a number?
+            // TODO is there a better way to check if property.type is an integer or a number?
             const cppType = this.cppType(property.type, {
                 needsForwardIndirection: true,
                 needsOptionalIndirection: true,
@@ -1171,7 +1171,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.forEachEnumCase(e, "none", (name, jsonName) => {
                     this.emitLine("case ", ourQualifier, enumName, "::", name, ": j = ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), "; break;");
                 });
-                this.emitLine(`default: throw std::runtime_error("Unexpected value in enumeration \\"${enumName}\\": " + std::to_string(static_cast<int>(x)));`);
+                this.emitLine(`default: throw std::runtime_error("Unexpected value in enumeration \\"`, enumName, `\\": " + std::to_string(static_cast<int>(x)));`);
             });
         });
     }

package/dist/language/TypeScriptEffectSchema/TypeScriptEffectSchemaRenderer.js

@@ -41,11 +41,13 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
     }
     emitImports() {
         this.ensureBlankLine();
-        this.emitLine(this.importStatement("* as S", '"@effect/schema/Schema"'));
+        this.emitLine(this.importStatement("* as S", '"effect/Schema"'));
     }
     typeMapTypeForProperty(p) {
-        const typeMap = this.typeMapTypeFor(p.type);
-        return p.isOptional ? ["S.optional(", typeMap, ")"] : typeMap;
+        if (!p.isOptional) {
+            return this.typeMapTypeFor(p.type);
+        }
+        return ["S.optional(", this.typeMapTypeFor(p.type), ")"];
     }
     typeMapTypeFor(t, required = true) {
         if (t.kind === "class" || t.kind === "object" || t.kind === "enum") {
@@ -55,9 +57,22 @@ class TypeScriptEffectSchemaRenderer extends ConvenienceRenderer_1.ConvenienceRe
             }
             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));
-            return ["S.Union(", ...(0, collection_utils_1.arrayIntercalate)(", ", children), ")"];
+        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({ key: S.String, value: ", this.typeMapTypeFor(_mapType.values, false), "})"], _enumType => (0, Support_1.panic)("Should already be handled."), unionType => {
+            const types = Array.from(unionType.getChildren());
+            let children = [];
+            let nullable = false;
+            for (const type of types) {
+                if (type.kind === "null") {
+                    nullable = true;
+                }
+                else {
+                    children.push(this.typeMapTypeFor(type, false));
+                }
+            }
+            if (nullable && children.length === 1) {
+                return ["S.NullOr(", children[0], ")"];
+            }
+            return ["S.Union(", ...(0, collection_utils_1.arrayIntercalate)(", ", children), nullable ? ", S.Null)" : ")"];
         }, _transformedStringType => {
             return "S.String";
         });

package/dist/rewrites/ExpandStrings.js

@@ -128,7 +128,7 @@ function expandStrings(ctx, graph, inference) {
         const transformations = mappedStringTypes.transformations;
         // FIXME: This is probably wrong, or at least overly conservative.  This is for the case
         // where some attributes are identity ones, i.e. where we can't merge the primitive types,
-        // like it happens in the line after the `if`.  The case where this occured was with URI
+        // like it happens in the line after the `if`.  The case where this occurred was with URI
         // attributes: we had two separate string types with different URI attributes, but because
         // both are rewritten via `getPrimitiveType` below without any attributes, they end up
         // being the same string type.

package/package.json

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