quicktype 17.0.4 → 17.0.5

package/dist/quicktype-core/TypeUtils.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchCompoundType = exports.matchType = exports.matchTypeExhaustive = exports.stringTypesForType = exports.directlyReachableSingleNamedType = exports.directlyReachableTypes = exports.separateNamedTypes = exports.isNamedType = exports.getNullAsOptional = exports.nonNullTypeCases = exports.nullableFromUnion = exports.removeNullFromType = exports.removeNullFromUnion = exports.isAnyOrNull = exports.combineTypeAttributesOfTypes = exports.makeGroupsToFlatten = exports.setOperationMembersRecursively = exports.assertIsClass = exports.assertIsObject = void 0;
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("./support/Support");
 const TypeAttributes_1 = require("./attributes/TypeAttributes");
@@ -10,12 +9,12 @@ function assertIsObject(t) {
     if (t instanceof Type_1.ObjectType) {
         return t;
     }
-    return (0, Support_1.panic)("Supposed object type is not an object type");
+    return Support_1.panic("Supposed object type is not an object type");
 }
 exports.assertIsObject = assertIsObject;
 function assertIsClass(t) {
     if (!(t instanceof Type_1.ClassType)) {
-        return (0, Support_1.panic)("Supposed class type is not a class type");
+        return Support_1.panic("Supposed class type is not a class type");
     }
     return t;
 }
@@ -34,7 +33,7 @@ function setOperationMembersRecursively(oneOrMany, combinationKind) {
                 return;
             processedSetOperations.add(so);
             if (combinationKind !== undefined) {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)(combinationKind, attributes, t.getAttributes());
+                attributes = TypeAttributes_1.combineTypeAttributes(combinationKind, attributes, t.getAttributes());
             }
             for (const m of so.members) {
                 process(m);
@@ -45,7 +44,7 @@ function setOperationMembersRecursively(oneOrMany, combinationKind) {
         }
         else {
             if (combinationKind !== undefined) {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)(combinationKind, attributes, t.getAttributes());
+                attributes = TypeAttributes_1.combineTypeAttributes(combinationKind, attributes, t.getAttributes());
             }
         }
     }
@@ -69,7 +68,7 @@ function makeGroupsToFlatten(setOperations, include) {
         if (maybeSet === undefined) {
             maybeSet = new Set();
             if (members.size === 1) {
-                maybeSet.add((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(members)));
+                maybeSet.add(Support_1.defined(collection_utils_1.iterableFirst(members)));
             }
         }
         maybeSet.add(u);
@@ -79,7 +78,7 @@ function makeGroupsToFlatten(setOperations, include) {
 }
 exports.makeGroupsToFlatten = makeGroupsToFlatten;
 function combineTypeAttributesOfTypes(combinationKind, types) {
-    return (0, TypeAttributes_1.combineTypeAttributes)(combinationKind, Array.from(types).map(t => t.getAttributes()));
+    return TypeAttributes_1.combineTypeAttributes(combinationKind, Array.from(types).map(t => t.getAttributes()));
 }
 exports.combineTypeAttributesOfTypes = combineTypeAttributesOfTypes;
 function isAnyOrNull(t) {
@@ -94,14 +93,14 @@ function removeNullFromUnion(t, sortBy = false) {
         if (sortBy === false)
             return s;
         if (sortBy === true)
-            return (0, collection_utils_1.setSortBy)(s, m => m.kind);
-        return (0, collection_utils_1.setSortBy)(s, sortBy);
+            return collection_utils_1.setSortBy(s, m => m.kind);
+        return collection_utils_1.setSortBy(s, sortBy);
     }
     const nullType = t.findMember("null");
     if (nullType === undefined) {
         return [null, sort(t.members)];
     }
-    return [nullType, sort((0, collection_utils_1.setFilter)(t.members, m => m.kind !== "null"))];
+    return [nullType, sort(collection_utils_1.setFilter(t.members, m => m.kind !== "null"))];
 }
 exports.removeNullFromUnion = removeNullFromUnion;
 function removeNullFromType(t) {
@@ -120,7 +119,7 @@ function nullableFromUnion(t) {
         return null;
     if (nonNulls.size !== 1)
         return null;
-    return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls));
+    return Support_1.defined(collection_utils_1.iterableFirst(nonNulls));
 }
 exports.nullableFromUnion = nullableFromUnion;
 function nonNullTypeCases(t) {
@@ -142,9 +141,9 @@ function isNamedType(t) {
 }
 exports.isNamedType = isNamedType;
 function separateNamedTypes(types) {
-    const objects = (0, collection_utils_1.setFilter)(types, t => t.kind === "object" || t.kind === "class");
-    const enums = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.EnumType);
-    const unions = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.UnionType);
+    const objects = collection_utils_1.setFilter(types, t => t.kind === "object" || t.kind === "class");
+    const enums = collection_utils_1.setFilter(types, t => t instanceof Type_1.EnumType);
+    const unions = collection_utils_1.setFilter(types, t => t instanceof Type_1.UnionType);
     return { objects, enums, unions };
 }
 exports.separateNamedTypes = separateNamedTypes;
@@ -152,7 +151,7 @@ function directlyReachableTypes(t, setForType) {
     const set = setForType(t);
     if (set !== null)
         return set;
-    return (0, collection_utils_1.setUnion)(...Array.from(t.getNonAttributeChildren()).map(c => directlyReachableTypes(c, setForType)));
+    return collection_utils_1.setUnion(...Array.from(t.getNonAttributeChildren()).map(c => directlyReachableTypes(c, setForType)));
 }
 exports.directlyReachableTypes = directlyReachableTypes;
 function directlyReachableSingleNamedType(type) {
@@ -163,22 +162,22 @@ function directlyReachableSingleNamedType(type) {
         }
         return null;
     });
-    (0, Support_1.assert)(definedTypes.size <= 1, "Cannot have more than one defined type per top-level");
-    return (0, collection_utils_1.iterableFirst)(definedTypes);
+    Support_1.assert(definedTypes.size <= 1, "Cannot have more than one defined type per top-level");
+    return collection_utils_1.iterableFirst(definedTypes);
 }
 exports.directlyReachableSingleNamedType = directlyReachableSingleNamedType;
 function stringTypesForType(t) {
-    (0, Support_1.assert)(t.kind === "string", "Only strings can have string types");
+    Support_1.assert(t.kind === "string", "Only strings can have string types");
     const stringTypes = StringTypes_1.stringTypesTypeAttributeKind.tryGetInAttributes(t.getAttributes());
     if (stringTypes === undefined) {
-        return (0, Support_1.panic)("All strings must have a string type attribute");
+        return Support_1.panic("All strings must have a string type attribute");
     }
     return stringTypes;
 }
 exports.stringTypesForType = stringTypesForType;
 function matchTypeExhaustive(t, noneType, anyType, nullType, boolType, integerType, doubleType, stringType, arrayType, classType, mapType, objectType, enumType, unionType, transformedStringType) {
     if (t.isPrimitive()) {
-        if ((0, Type_1.isPrimitiveStringTypeKind)(t.kind)) {
+        if (Type_1.isPrimitiveStringTypeKind(t.kind)) {
             if (t.kind === "string") {
                 return stringType(t);
             }
@@ -195,7 +194,7 @@ function matchTypeExhaustive(t, noneType, anyType, nullType, boolType, integerTy
         }[kind];
         if (f !== undefined)
             return f(t);
-        return (0, Support_1.assertNever)(f);
+        return Support_1.assertNever(f);
     }
     else if (t instanceof Type_1.ArrayType)
         return arrayType(t);
@@ -209,12 +208,12 @@ function matchTypeExhaustive(t, noneType, anyType, nullType, boolType, integerTy
         return enumType(t);
     else if (t instanceof Type_1.UnionType)
         return unionType(t);
-    return (0, Support_1.panic)(`Unknown type ${t.kind}`);
+    return Support_1.panic(`Unknown type ${t.kind}`);
 }
 exports.matchTypeExhaustive = matchTypeExhaustive;
 function matchType(type, anyType, nullType, boolType, integerType, doubleType, stringType, arrayType, classType, mapType, enumType, unionType, transformedStringType) {
     function typeNotSupported(t) {
-        return (0, Support_1.panic)(`Unsupported type ${t.kind} in non-exhaustive match`);
+        return Support_1.panic(`Unsupported type ${t.kind} in non-exhaustive match`);
     }
     /* tslint:disable:strict-boolean-expressions */
     return matchTypeExhaustive(type, typeNotSupported, anyType, nullType, boolType, integerType, doubleType, stringType, arrayType, classType, mapType, typeNotSupported, enumType, unionType, transformedStringType || typeNotSupported);

package/dist/quicktype-core/UnifyClasses.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unifyTypes = exports.unionBuilderForUnification = exports.UnifyUnionBuilder = void 0;
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("./Type");
 const TypeUtils_1 = require("./TypeUtils");
@@ -12,7 +11,7 @@ function getCliqueProperties(clique, builder, makePropertyType) {
     let lostTypeAttributes = false;
     let propertyNames = new Set();
     for (const o of clique) {
-        (0, collection_utils_1.setUnionInto)(propertyNames, o.getProperties().keys());
+        collection_utils_1.setUnionInto(propertyNames, o.getProperties().keys());
     }
     let properties = Array.from(propertyNames).map(name => [name, new Set(), false]);
     let additionalProperties = undefined;
@@ -70,9 +69,6 @@ function countProperties(clique) {
     return { hasProperties, hasAdditionalProperties, hasNonAnyAdditionalProperties };
 }
 class UnifyUnionBuilder extends UnionBuilder_1.UnionBuilder {
-    _makeObjectTypes;
-    _makeClassesFixed;
-    _unifyTypes;
     constructor(typeBuilder, _makeObjectTypes, _makeClassesFixed, _unifyTypes) {
         super(typeBuilder);
         this._makeObjectTypes = _makeObjectTypes;
@@ -82,29 +78,29 @@ class UnifyUnionBuilder extends UnionBuilder_1.UnionBuilder {
     makeObject(objectRefs, typeAttributes, forwardingRef) {
         const maybeTypeRef = this.typeBuilder.lookupTypeRefs(objectRefs, forwardingRef);
         if (maybeTypeRef !== undefined) {
-            (0, Support_1.assert)(forwardingRef === undefined || maybeTypeRef === forwardingRef, "The forwarding ref must be consumed");
+            Support_1.assert(forwardingRef === undefined || maybeTypeRef === forwardingRef, "The forwarding ref must be consumed");
             this.typeBuilder.addAttributes(maybeTypeRef, typeAttributes);
             return maybeTypeRef;
         }
         if (objectRefs.length === 1) {
             return this.typeBuilder.reconstituteTypeRef(objectRefs[0], typeAttributes, forwardingRef);
         }
-        const objectTypes = objectRefs.map(r => (0, TypeUtils_1.assertIsObject)((0, TypeGraph_1.derefTypeRef)(r, this.typeBuilder)));
+        const objectTypes = objectRefs.map(r => TypeUtils_1.assertIsObject(TypeGraph_1.derefTypeRef(r, this.typeBuilder)));
         const { hasProperties, hasAdditionalProperties, hasNonAnyAdditionalProperties } = countProperties(objectTypes);
         if (!this._makeObjectTypes && (hasNonAnyAdditionalProperties || (!hasProperties && hasAdditionalProperties))) {
             const propertyTypes = new Set();
             for (const o of objectTypes) {
-                (0, collection_utils_1.setUnionInto)(propertyTypes, Array.from(o.getProperties().values()).map(cp => cp.typeRef));
+                collection_utils_1.setUnionInto(propertyTypes, Array.from(o.getProperties().values()).map(cp => cp.typeRef));
             }
             const additionalPropertyTypes = new Set(objectTypes
                 .filter(o => o.getAdditionalProperties() !== undefined)
-                .map(o => (0, Support_1.defined)(o.getAdditionalProperties()).typeRef));
-            (0, collection_utils_1.setUnionInto)(propertyTypes, additionalPropertyTypes);
+                .map(o => Support_1.defined(o.getAdditionalProperties()).typeRef));
+            collection_utils_1.setUnionInto(propertyTypes, additionalPropertyTypes);
             return this.typeBuilder.getMapType(typeAttributes, this._unifyTypes(Array.from(propertyTypes)));
         }
         else {
             const [properties, additionalProperties, lostTypeAttributes] = getCliqueProperties(objectTypes, this.typeBuilder, types => {
-                (0, Support_1.assert)(types.size > 0, "Property has no type");
+                Support_1.assert(types.size > 0, "Property has no type");
                 return this._unifyTypes(Array.from(types).map(t => t.typeRef));
             });
             if (lostTypeAttributes) {
@@ -114,7 +110,7 @@ class UnifyUnionBuilder extends UnionBuilder_1.UnionBuilder {
                 return this.typeBuilder.getUniqueObjectType(typeAttributes, properties, additionalProperties, forwardingRef);
             }
             else {
-                (0, Support_1.assert)(additionalProperties === undefined, "We have additional properties but want to make a class");
+                Support_1.assert(additionalProperties === undefined, "We have additional properties but want to make a class");
                 return this.typeBuilder.getUniqueClassType(typeAttributes, this._makeClassesFixed, properties, forwardingRef);
             }
         }
@@ -126,7 +122,7 @@ class UnifyUnionBuilder extends UnionBuilder_1.UnionBuilder {
 }
 exports.UnifyUnionBuilder = UnifyUnionBuilder;
 function unionBuilderForUnification(typeBuilder, makeObjectTypes, makeClassesFixed, conflateNumbers) {
-    return new UnifyUnionBuilder(typeBuilder, makeObjectTypes, makeClassesFixed, trefs => unifyTypes(new Set(trefs.map(tref => (0, TypeGraph_1.derefTypeRef)(tref, typeBuilder))), TypeAttributes_1.emptyTypeAttributes, typeBuilder, unionBuilderForUnification(typeBuilder, makeObjectTypes, makeClassesFixed, conflateNumbers), conflateNumbers));
+    return new UnifyUnionBuilder(typeBuilder, makeObjectTypes, makeClassesFixed, trefs => unifyTypes(new Set(trefs.map(tref => TypeGraph_1.derefTypeRef(tref, typeBuilder))), TypeAttributes_1.emptyTypeAttributes, typeBuilder, unionBuilderForUnification(typeBuilder, makeObjectTypes, makeClassesFixed, conflateNumbers), conflateNumbers));
 }
 exports.unionBuilderForUnification = unionBuilderForUnification;
 // typeAttributes must not be reconstituted yet.
@@ -134,10 +130,10 @@ exports.unionBuilderForUnification = unionBuilderForUnification;
 function unifyTypes(types, typeAttributes, typeBuilder, unionBuilder, conflateNumbers, maybeForwardingRef) {
     typeAttributes = typeBuilder.reconstituteTypeAttributes(typeAttributes);
     if (types.size === 0) {
-        return (0, Support_1.panic)("Cannot unify empty set of types");
+        return Support_1.panic("Cannot unify empty set of types");
     }
     else if (types.size === 1) {
-        const first = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(types));
+        const first = Support_1.defined(collection_utils_1.iterableFirst(types));
         if (!(first instanceof Type_1.UnionType)) {
             return typeBuilder.reconstituteTypeRef(first.typeRef, typeAttributes, maybeForwardingRef);
         }
@@ -150,7 +146,7 @@ function unifyTypes(types, typeAttributes, typeBuilder, unionBuilder, conflateNu
     }
     const accumulator = new UnionBuilder_1.TypeRefUnionAccumulator(conflateNumbers);
     const nestedAttributes = typeBuilder.reconstituteTypeAttributes(accumulator.addTypes(types));
-    typeAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", typeAttributes, nestedAttributes);
+    typeAttributes = TypeAttributes_1.combineTypeAttributes("union", typeAttributes, nestedAttributes);
     return typeBuilder.withForwardingRef(maybeForwardingRef, forwardingRef => {
         typeBuilder.registerUnion(typeRefs, forwardingRef);
         return unionBuilder.buildUnion(accumulator, false, typeAttributes, forwardingRef);

package/dist/quicktype-core/UnionBuilder.d.ts

@@ -10,7 +10,7 @@ export interface UnionTypeProvider<TArrayData, TObjectData> {
     getMemberKinds(): TypeAttributeMap<TypeKind>;
     readonly lostTypeAttributes: boolean;
 }
-export type TypeAttributeMap<T extends TypeKind> = Map<T, TypeAttributes>;
+export declare type TypeAttributeMap<T extends TypeKind> = Map<T, TypeAttributes>;
 export declare class UnionAccumulator<TArray, TObject> implements UnionTypeProvider<TArray[], TObject[]> {
     private readonly _conflateNumbers;
     private readonly _nonStringTypeAttributes;
@@ -31,9 +31,9 @@ export declare class UnionAccumulator<TArray, TObject> implements UnionTypeProvi
     addEnum(cases: ReadonlySet<string>, attributes: TypeAttributes): void;
     addStringCases(cases: string[], attributes: TypeAttributes): void;
     addStringCase(s: string, count: number, attributes: TypeAttributes): void;
-    get enumCases(): ReadonlySet<string>;
+    readonly enumCases: ReadonlySet<string>;
     getMemberKinds(): TypeAttributeMap<TypeKind>;
-    get lostTypeAttributes(): boolean;
+    readonly lostTypeAttributes: boolean;
 }
 export declare class TypeRefUnionAccumulator extends UnionAccumulator<TypeRef, TypeRef> {
     private addType;

package/dist/quicktype-core/UnionBuilder.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionBuilder = exports.TypeRefUnionAccumulator = exports.UnionAccumulator = void 0;
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("./Type");
 const TypeUtils_1 = require("./TypeUtils");
@@ -10,7 +9,7 @@ const StringTypes_1 = require("./attributes/StringTypes");
 function addAttributes(accumulatorAttributes, newAttributes) {
     if (accumulatorAttributes === undefined)
         return newAttributes;
-    return (0, TypeAttributes_1.combineTypeAttributes)("union", accumulatorAttributes, newAttributes);
+    return TypeAttributes_1.combineTypeAttributes("union", accumulatorAttributes, newAttributes);
 }
 function setAttributes(attributeMap, kind, newAttributes) {
     attributeMap.set(kind, addAttributes(attributeMap.get(kind), newAttributes));
@@ -24,23 +23,22 @@ function addAttributesToBuilder(builder, kind, newAttributes) {
     arr.push(newAttributes);
 }
 function buildTypeAttributeMap(builder) {
-    return (0, collection_utils_1.mapMap)(builder, arr => (0, TypeAttributes_1.combineTypeAttributes)("union", arr));
+    return collection_utils_1.mapMap(builder, arr => TypeAttributes_1.combineTypeAttributes("union", arr));
 }
 function moveAttributes(map, fromKind, toKind) {
-    const fromAttributes = (0, Support_1.defined)(map.get(fromKind));
+    const fromAttributes = Support_1.defined(map.get(fromKind));
     map.delete(fromKind);
     setAttributes(map, toKind, fromAttributes);
 }
 class UnionAccumulator {
-    _conflateNumbers;
-    _nonStringTypeAttributes = new Map();
-    _stringTypeAttributes = new Map();
-    arrayData = [];
-    objectData = [];
-    _enumCases = new Set();
-    _lostTypeAttributes = false;
     constructor(_conflateNumbers) {
         this._conflateNumbers = _conflateNumbers;
+        this._nonStringTypeAttributes = new Map();
+        this._stringTypeAttributes = new Map();
+        this.arrayData = [];
+        this.objectData = [];
+        this._enumCases = new Set();
+        this._lostTypeAttributes = false;
     }
     have(kind) {
         return (this._nonStringTypeAttributes.has(kind) || this._stringTypeAttributes.has(kind));
@@ -56,7 +54,7 @@ class UnionAccumulator {
         this._lostTypeAttributes = true;
     }
     addPrimitive(kind, attributes) {
-        (0, Support_1.assert)(kind !== "any", "any must be added with addAny");
+        Support_1.assert(kind !== "any", "any must be added with addAny");
         addAttributesToBuilder(this._nonStringTypeAttributes, kind, attributes);
     }
     addFullStringType(attributes, stringTypes) {
@@ -73,7 +71,7 @@ class UnionAccumulator {
         }
         const maybeEnumAttributes = this._nonStringTypeAttributes.get("enum");
         if (stringTypes.isRestricted) {
-            (0, Support_1.assert)(maybeEnumAttributes === undefined, "We can't add both an enum as well as a restricted string type to a union builder");
+            Support_1.assert(maybeEnumAttributes === undefined, "We can't add both an enum as well as a restricted string type to a union builder");
         }
         addAttributesToBuilder(this._stringTypeAttributes, "string", attributes);
         if (stringTypesAttributes !== undefined) {
@@ -105,7 +103,7 @@ class UnionAccumulator {
             return;
         }
         addAttributesToBuilder(this._nonStringTypeAttributes, "enum", attributes);
-        (0, collection_utils_1.setUnionInto)(this._enumCases, cases);
+        collection_utils_1.setUnionInto(this._enumCases, cases);
     }
     addStringCases(cases, attributes) {
         this.addFullStringType(attributes, StringTypes_1.StringTypes.fromCases(cases));
@@ -117,14 +115,14 @@ class UnionAccumulator {
         return this._enumCases;
     }
     getMemberKinds() {
-        (0, Support_1.assert)(!(this.have("enum") && this.have("string")), "We can't have both strings and enums in the same union");
-        let merged = (0, collection_utils_1.mapMerge)(buildTypeAttributeMap(this._nonStringTypeAttributes), buildTypeAttributeMap(this._stringTypeAttributes));
+        Support_1.assert(!(this.have("enum") && this.have("string")), "We can't have both strings and enums in the same union");
+        let merged = collection_utils_1.mapMerge(buildTypeAttributeMap(this._nonStringTypeAttributes), buildTypeAttributeMap(this._stringTypeAttributes));
         if (merged.size === 0) {
             return new Map([["none", TypeAttributes_1.emptyTypeAttributes]]);
         }
         if (this._nonStringTypeAttributes.has("any")) {
-            (0, Support_1.assert)(this._lostTypeAttributes, "This had to be set when we added 'any'");
-            const allAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", Array.from(merged.values()));
+            Support_1.assert(this._lostTypeAttributes, "This had to be set when we added 'any'");
+            const allAttributes = TypeAttributes_1.combineTypeAttributes("union", Array.from(merged.values()));
             return new Map([["any", allAttributes]]);
         }
         if (this._conflateNumbers && this.have("integer") && this.have("double")) {
@@ -170,9 +168,9 @@ function attributesForTypes(types) {
             path.pop();
         }
         else {
-            (0, collection_utils_1.mapUpdateInto)(unionsForType, t, s => (s === undefined ? new Set(path) : (0, collection_utils_1.setUnionInto)(s, path)));
+            collection_utils_1.mapUpdateInto(unionsForType, t, s => (s === undefined ? new Set(path) : collection_utils_1.setUnionInto(s, path)));
             for (const u of path) {
-                (0, collection_utils_1.mapUpdateInto)(typesForUnion, u, s => (s === undefined ? new Set([t]) : s.add(t)));
+                collection_utils_1.mapUpdateInto(typesForUnion, u, s => (s === undefined ? new Set([t]) : s.add(t)));
             }
         }
     }
@@ -181,11 +179,11 @@ function attributesForTypes(types) {
     for (const t of typesArray) {
         traverse(t, rootPath, typesArray.length === 1);
     }
-    const resultAttributes = (0, collection_utils_1.mapMap)(unionsForType, (unionForType, t) => {
-        const singleAncestors = Array.from(unionForType).filter(u => (0, Support_1.defined)(typesForUnion.get(u)).size === 1);
-        (0, Support_1.assert)(singleAncestors.every(u => (0, Support_1.defined)(typesForUnion.get(u)).has(t)), "We messed up bookkeeping");
+    const resultAttributes = collection_utils_1.mapMap(unionsForType, (unionForType, t) => {
+        const singleAncestors = Array.from(unionForType).filter(u => Support_1.defined(typesForUnion.get(u)).size === 1);
+        Support_1.assert(singleAncestors.every(u => Support_1.defined(typesForUnion.get(u)).has(t)), "We messed up bookkeeping");
         const inheritedAttributes = singleAncestors.map(u => u.getAttributes());
-        return (0, TypeAttributes_1.combineTypeAttributes)("union", [t.getAttributes()].concat(inheritedAttributes));
+        return TypeAttributes_1.combineTypeAttributes("union", [t.getAttributes()].concat(inheritedAttributes));
     });
     const unionAttributes = Array.from(unions).map(u => {
         const t = typesForUnion.get(u);
@@ -196,21 +194,21 @@ function attributesForTypes(types) {
         if (unionsEquivalentToRoot.has(u)) {
             return attributes;
         }
-        return (0, TypeAttributes_1.makeTypeAttributesInferred)(attributes);
+        return TypeAttributes_1.makeTypeAttributesInferred(attributes);
     });
-    return [resultAttributes, (0, TypeAttributes_1.combineTypeAttributes)("union", unionAttributes)];
+    return [resultAttributes, TypeAttributes_1.combineTypeAttributes("union", unionAttributes)];
 }
 // FIXME: Move this to UnifyClasses.ts?
 class TypeRefUnionAccumulator extends UnionAccumulator {
     // There is a method analogous to this in the IntersectionAccumulator.  It might
     // make sense to find a common interface.
     addType(t, attributes) {
-        (0, TypeUtils_1.matchTypeExhaustive)(t, _noneType => this.addNone(attributes), _anyType => this.addAny(attributes), _nullType => this.addPrimitive("null", attributes), _boolType => this.addPrimitive("bool", attributes), _integerType => this.addPrimitive("integer", attributes), _doubleType => this.addPrimitive("double", attributes), _stringType => this.addStringType("string", attributes), arrayType => this.addArray(arrayType.items.typeRef, attributes), classType => this.addObject(classType.typeRef, attributes), mapType => this.addObject(mapType.typeRef, attributes), objectType => this.addObject(objectType.typeRef, attributes), 
+        TypeUtils_1.matchTypeExhaustive(t, _noneType => this.addNone(attributes), _anyType => this.addAny(attributes), _nullType => this.addPrimitive("null", attributes), _boolType => this.addPrimitive("bool", attributes), _integerType => this.addPrimitive("integer", attributes), _doubleType => this.addPrimitive("double", attributes), _stringType => this.addStringType("string", attributes), arrayType => this.addArray(arrayType.items.typeRef, attributes), classType => this.addObject(classType.typeRef, attributes), mapType => this.addObject(mapType.typeRef, attributes), objectType => this.addObject(objectType.typeRef, attributes), 
         // FIXME: We're not carrying counts, so this is not correct if we do enum
         // inference.  JSON Schema input uses this case, however, without enum
         // inference, which is fine, but still a bit ugly.
         enumType => this.addEnum(enumType.cases, attributes), _unionType => {
-            return (0, Support_1.panic)("The unions should have been eliminated in attributesForTypesInUnion");
+            return Support_1.panic("The unions should have been eliminated in attributesForTypesInUnion");
         }, transformedStringType => this.addStringType(transformedStringType.kind, attributes));
     }
     addTypes(types) {
@@ -223,7 +221,6 @@ class TypeRefUnionAccumulator extends UnionAccumulator {
 }
 exports.TypeRefUnionAccumulator = TypeRefUnionAccumulator;
 class UnionBuilder {
-    typeBuilder;
     constructor(typeBuilder) {
         this.typeBuilder = typeBuilder;
     }
@@ -238,13 +235,13 @@ class UnionBuilder {
             case "array":
                 return this.makeArray(typeProvider.arrayData, typeAttributes, forwardingRef);
             default:
-                if ((0, Type_1.isPrimitiveTypeKind)(kind)) {
+                if (Type_1.isPrimitiveTypeKind(kind)) {
                     return this.typeBuilder.getPrimitiveType(kind, typeAttributes, forwardingRef);
                 }
                 if (kind === "union" || kind === "class" || kind === "map" || kind === "intersection") {
-                    return (0, Support_1.panic)(`getMemberKinds() shouldn't return ${kind}`);
+                    return Support_1.panic(`getMemberKinds() shouldn't return ${kind}`);
                 }
-                return (0, Support_1.assertNever)(kind);
+                return Support_1.assertNever(kind);
         }
     }
     buildUnion(typeProvider, unique, typeAttributes, forwardingRef) {
@@ -258,7 +255,7 @@ class UnionBuilder {
         // right now, it's just a very bad way of surfacing that error.
         if (kinds.size === 1) {
             const [[kind, memberAttributes]] = Array.from(kinds);
-            const allAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", typeAttributes, (0, TypeAttributes_1.increaseTypeAttributesDistance)(memberAttributes));
+            const allAttributes = TypeAttributes_1.combineTypeAttributes("union", typeAttributes, TypeAttributes_1.increaseTypeAttributesDistance(memberAttributes));
             const t = this.makeTypeOfKind(typeProvider, kind, allAttributes, forwardingRef);
             return t;
         }

package/dist/quicktype-core/attributes/AccessorNames.d.ts

@@ -2,8 +2,8 @@ import { TypeAttributeKind, TypeAttributes } from "./TypeAttributes";
 import { EnumType, UnionType, Type, ObjectType } from "../Type";
 import { JSONSchema } from "../input/JSONSchemaStore";
 import { Ref, JSONSchemaType, JSONSchemaAttributes } from "../input/JSONSchemaInput";
-export type AccessorEntry = string | Map<string, string>;
-export type AccessorNames = Map<string, AccessorEntry>;
+export declare type AccessorEntry = string | Map<string, string>;
+export declare type AccessorNames = Map<string, AccessorEntry>;
 export declare const accessorNamesTypeAttributeKind: TypeAttributeKind<AccessorNames>;
 export declare function lookupKey(accessors: AccessorNames, key: string, language: string): [string, boolean] | undefined;
 export declare function objectPropertyNames(o: ObjectType, language: string): Map<string, [string, boolean] | undefined>;

package/dist/quicktype-core/attributes/AccessorNames.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.accessorNamesAttributeProducer = exports.makeAccessorNames = exports.unionMemberName = exports.makeUnionMemberNamesAttribute = exports.unionMemberNamesTypeAttributeKind = exports.makeUnionIdentifierAttribute = exports.unionIdentifierTypeAttributeKind = exports.getAccessorName = exports.enumCaseNames = exports.objectPropertyNames = exports.lookupKey = exports.accessorNamesTypeAttributeKind = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeAttributes_1 = require("./TypeAttributes");
 const Support_1 = require("../support/Support");
@@ -37,15 +36,15 @@ function objectPropertyNames(o, language) {
     const accessors = exports.accessorNamesTypeAttributeKind.tryGetInAttributes(o.getAttributes());
     const map = o.getProperties();
     if (accessors === undefined)
-        return (0, collection_utils_1.mapMap)(map, _ => undefined);
-    return (0, collection_utils_1.mapMap)(map, (_cp, n) => lookupKey(accessors, n, language));
+        return collection_utils_1.mapMap(map, _ => undefined);
+    return collection_utils_1.mapMap(map, (_cp, n) => lookupKey(accessors, n, language));
 }
 exports.objectPropertyNames = objectPropertyNames;
 function enumCaseNames(e, language) {
     const accessors = exports.accessorNamesTypeAttributeKind.tryGetInAttributes(e.getAttributes());
     if (accessors === undefined)
-        return (0, collection_utils_1.mapMap)(e.cases.entries(), _ => undefined);
-    return (0, collection_utils_1.mapMap)(e.cases.entries(), c => lookupKey(accessors, c, language));
+        return collection_utils_1.mapMap(e.cases.entries(), _ => undefined);
+    return collection_utils_1.mapMap(e.cases.entries(), c => lookupKey(accessors, c, language));
 }
 exports.enumCaseNames = enumCaseNames;
 function getAccessorName(names, original) {
@@ -67,7 +66,7 @@ class UnionIdentifierTypeAttributeKind extends TypeAttributes_1.TypeAttributeKin
         super("unionIdentifier");
     }
     combine(arr) {
-        return (0, collection_utils_1.setUnionManyInto)(new Set(), arr);
+        return collection_utils_1.setUnionManyInto(new Set(), arr);
     }
     makeInferred(_) {
         return new Set();
@@ -88,15 +87,15 @@ class UnionMemberNamesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKi
     combine(arr) {
         const result = new Map();
         for (const m of arr) {
-            (0, collection_utils_1.mapMergeInto)(result, m);
+            collection_utils_1.mapMergeInto(result, m);
         }
         return result;
     }
 }
 exports.unionMemberNamesTypeAttributeKind = new UnionMemberNamesTypeAttributeKind();
 function makeUnionMemberNamesAttribute(unionAttributes, entry) {
-    const identifiers = (0, Support_1.defined)(exports.unionIdentifierTypeAttributeKind.tryGetInAttributes(unionAttributes));
-    const map = (0, collection_utils_1.mapFromIterable)(identifiers, _ => entry);
+    const identifiers = Support_1.defined(exports.unionIdentifierTypeAttributeKind.tryGetInAttributes(unionAttributes));
+    const map = collection_utils_1.mapFromIterable(identifiers, _ => entry);
     return exports.unionMemberNamesTypeAttributeKind.makeAttributes(map);
 }
 exports.makeUnionMemberNamesAttribute = makeUnionMemberNamesAttribute;
@@ -126,19 +125,19 @@ function unionMemberName(u, member, language) {
     }
     let size;
     let isFixed;
-    let first = (0, collection_utils_1.iterableFirst)(fixedNames);
+    let first = collection_utils_1.iterableFirst(fixedNames);
     if (first !== undefined) {
         size = fixedNames.size;
         isFixed = true;
     }
     else {
-        first = (0, collection_utils_1.iterableFirst)(names);
+        first = collection_utils_1.iterableFirst(names);
         if (first === undefined)
             return [undefined, false];
         size = names.size;
         isFixed = false;
     }
-    (0, Messages_1.messageAssert)(size === 1, "SchemaMoreThanOneUnionMemberName", { names: Array.from(names) });
+    Messages_1.messageAssert(size === 1, "SchemaMoreThanOneUnionMemberName", { names: Array.from(names) });
     return [first, isFixed];
 }
 exports.unionMemberName = unionMemberName;
@@ -146,17 +145,17 @@ function isAccessorEntry(x) {
     if (typeof x === "string") {
         return true;
     }
-    return (0, Support_1.isStringMap)(x, (v) => typeof v === "string");
+    return Support_1.isStringMap(x, (v) => typeof v === "string");
 }
 function makeAccessorEntry(ae) {
     if (typeof ae === "string")
         return ae;
-    return (0, collection_utils_1.mapFromObject)(ae);
+    return collection_utils_1.mapFromObject(ae);
 }
 function makeAccessorNames(x) {
     // FIXME: Do proper error reporting
-    const stringMap = (0, Support_1.checkStringMap)(x, isAccessorEntry);
-    return (0, collection_utils_1.mapMap)((0, collection_utils_1.mapFromObject)(stringMap), makeAccessorEntry);
+    const stringMap = Support_1.checkStringMap(x, isAccessorEntry);
+    return collection_utils_1.mapMap(collection_utils_1.mapFromObject(stringMap), makeAccessorEntry);
 }
 exports.makeAccessorNames = makeAccessorNames;
 function accessorNamesAttributeProducer(schema, canonicalRef, _types, cases) {
@@ -170,8 +169,8 @@ function accessorNamesAttributeProducer(schema, canonicalRef, _types, cases) {
     }
     else {
         const identifierAttribute = makeUnionIdentifierAttribute();
-        const accessors = (0, Support_1.checkArray)(maybeAccessors, isAccessorEntry);
-        (0, Messages_1.messageAssert)(cases.length === accessors.length, "SchemaWrongAccessorEntryArrayLength", {
+        const accessors = Support_1.checkArray(maybeAccessors, isAccessorEntry);
+        Messages_1.messageAssert(cases.length === accessors.length, "SchemaWrongAccessorEntryArrayLength", {
             operation: "oneOf",
             ref: canonicalRef.push("oneOf")
         });

package/dist/quicktype-core/attributes/Constraints.d.ts

@@ -2,13 +2,13 @@ import { Type, TypeKind } from "../Type";
 import { TypeAttributeKind } from "./TypeAttributes";
 import { JSONSchemaType, JSONSchemaAttributes, Ref } from "../input/JSONSchemaInput";
 import { JSONSchema } from "../input/JSONSchemaStore";
-export type MinMaxConstraint = [number | undefined, number | undefined];
+export declare type MinMaxConstraint = [number | undefined, number | undefined];
 export declare class MinMaxConstraintTypeAttributeKind extends TypeAttributeKind<MinMaxConstraint> {
     private _typeKinds;
     private _minSchemaProperty;
     private _maxSchemaProperty;
     constructor(name: string, _typeKinds: Set<TypeKind>, _minSchemaProperty: string, _maxSchemaProperty: string);
-    get inIdentity(): boolean;
+    readonly inIdentity: boolean;
     combine(arr: MinMaxConstraint[]): MinMaxConstraint | undefined;
     intersect(arr: MinMaxConstraint[]): MinMaxConstraint | undefined;
     makeInferred(_: MinMaxConstraint): undefined;
@@ -25,7 +25,7 @@ export declare function minMaxValueForType(t: Type): MinMaxConstraint | undefine
 export declare function minMaxLengthForType(t: Type): MinMaxConstraint | undefined;
 export declare class PatternTypeAttributeKind extends TypeAttributeKind<string> {
     constructor();
-    get inIdentity(): boolean;
+    readonly inIdentity: boolean;
     combine(arr: string[]): string;
     intersect(_arr: string[]): string | undefined;
     makeInferred(_: string): undefined;