quicktype 17.0.6 → 18.0.1

package/dist/quicktype-core/TypeBuilder.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeBuilder = exports.getNoStringTypeMapping = exports.stringTypeMappingGet = exports.provenanceTypeAttributeKind = void 0;
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("./Type");
 const TypeGraph_1 = require("./TypeGraph");
@@ -16,7 +17,7 @@ class ProvenanceTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         return true;
     }
     combine(arr) {
-        return collection_utils_1.setUnionManyInto(new Set(), arr);
+        return (0, collection_utils_1.setUnionManyInto)(new Set(), arr);
     }
     makeInferred(p) {
         return p;
@@ -45,30 +46,34 @@ function getNoStringTypeMapping() {
 }
 exports.getNoStringTypeMapping = getNoStringTypeMapping;
 class TypeBuilder {
+    _stringTypeMapping;
+    canonicalOrder;
+    _allPropertiesOptional;
+    _addProvenanceAttributes;
+    typeGraph;
+    topLevels = new Map();
+    types = [];
+    typeAttributes = [];
+    _addedForwardingIntersection = false;
     constructor(typeGraphSerial, _stringTypeMapping, canonicalOrder, _allPropertiesOptional, _addProvenanceAttributes, inheritsProvenanceAttributes) {
         this._stringTypeMapping = _stringTypeMapping;
         this.canonicalOrder = canonicalOrder;
         this._allPropertiesOptional = _allPropertiesOptional;
         this._addProvenanceAttributes = _addProvenanceAttributes;
-        this.topLevels = new Map();
-        this.types = [];
-        this.typeAttributes = [];
-        this._addedForwardingIntersection = false;
-        this._typeForIdentity = new collection_utils_1.EqualityMap();
-        Support_1.assert(!_addProvenanceAttributes || !inheritsProvenanceAttributes, "We can't both inherit as well as add provenance");
+        (0, Support_1.assert)(!_addProvenanceAttributes || !inheritsProvenanceAttributes, "We can't both inherit as well as add provenance");
         this.typeGraph = new TypeGraph_1.TypeGraph(this, typeGraphSerial, _addProvenanceAttributes || inheritsProvenanceAttributes);
     }
     addTopLevel(name, tref) {
         // assert(t.typeGraph === this.typeGraph, "Adding top-level to wrong type graph");
-        Support_1.assert(!this.topLevels.has(name), "Trying to add top-level with existing name");
-        Support_1.assert(this.types[TypeGraph_1.typeRefIndex(tref)] !== undefined, "Trying to add a top-level type that doesn't exist (yet?)");
+        (0, Support_1.assert)(!this.topLevels.has(name), "Trying to add top-level with existing name");
+        (0, Support_1.assert)(this.types[(0, TypeGraph_1.typeRefIndex)(tref)] !== undefined, "Trying to add a top-level type that doesn't exist (yet?)");
         this.topLevels.set(name, tref);
     }
     reserveTypeRef() {
         const index = this.types.length;
         // console.log(`reserving ${index}`);
         this.types.push(undefined);
-        const tref = TypeGraph_1.makeTypeRef(this.typeGraph, index);
+        const tref = (0, TypeGraph_1.makeTypeRef)(this.typeGraph, index);
         const attributes = this._addProvenanceAttributes
             ? exports.provenanceTypeAttributeKind.makeAttributes(new Set([index]))
             : TypeAttributes_1.emptyTypeAttributes;
@@ -78,7 +83,7 @@ class TypeBuilder {
     assertTypeRefGraph(tref) {
         if (tref === undefined)
             return;
-        TypeGraph_1.assertTypeRefGraph(tref, this.typeGraph);
+        (0, TypeGraph_1.assertTypeRefGraph)(tref, this.typeGraph);
     }
     assertTypeRefSetGraph(trefs) {
         if (trefs === undefined)
@@ -86,7 +91,7 @@ class TypeBuilder {
         trefs.forEach(tref => this.assertTypeRefGraph(tref));
     }
     filterTypeAttributes(t, attributes) {
-        const filtered = collection_utils_1.mapFilter(attributes, (_, k) => k.appliesToTypeKind(t.kind));
+        const filtered = (0, collection_utils_1.mapFilter)(attributes, (_, k) => k.appliesToTypeKind(t.kind));
         if (attributes.size !== filtered.size) {
             this.setLostTypeAttributes();
         }
@@ -94,22 +99,22 @@ class TypeBuilder {
     }
     commitType(tref, t) {
         this.assertTypeRefGraph(tref);
-        const index = TypeGraph_1.typeRefIndex(tref);
+        const index = (0, TypeGraph_1.typeRefIndex)(tref);
         // const name = names !== undefined ? ` ${names.combinedName}` : "";
         // console.log(`committing ${t.kind}${name} to ${index}`);
-        Support_1.assert(this.types[index] === undefined, "A type index was committed twice");
+        (0, Support_1.assert)(this.types[index] === undefined, "A type index was committed twice");
         this.types[index] = t;
         this.typeAttributes[index] = this.filterTypeAttributes(t, this.typeAttributes[index]);
     }
     addType(forwardingRef, creator, attributes) {
         if (forwardingRef !== undefined) {
             this.assertTypeRefGraph(forwardingRef);
-            Support_1.assert(this.types[TypeGraph_1.typeRefIndex(forwardingRef)] === undefined);
+            (0, Support_1.assert)(this.types[(0, TypeGraph_1.typeRefIndex)(forwardingRef)] === undefined);
         }
         const tref = forwardingRef !== undefined ? forwardingRef : this.reserveTypeRef();
         if (attributes !== undefined) {
-            const index = TypeGraph_1.typeRefIndex(tref);
-            this.typeAttributes[index] = TypeAttributes_1.combineTypeAttributes("union", this.typeAttributes[index], attributes);
+            const index = (0, TypeGraph_1.typeRefIndex)(tref);
+            this.typeAttributes[index] = (0, TypeAttributes_1.combineTypeAttributes)("union", this.typeAttributes[index], attributes);
         }
         const t = creator(tref);
         this.commitType(tref, t);
@@ -118,7 +123,7 @@ class TypeBuilder {
     typeAtIndex(index) {
         const maybeType = this.types[index];
         if (maybeType === undefined) {
-            return Support_1.panic("Trying to deref an undefined type in a type builder");
+            return (0, Support_1.panic)("Trying to deref an undefined type in a type builder");
         }
         return maybeType;
     }
@@ -129,22 +134,22 @@ class TypeBuilder {
     }
     addAttributes(tref, attributes) {
         this.assertTypeRefGraph(tref);
-        const index = TypeGraph_1.typeRefIndex(tref);
+        const index = (0, TypeGraph_1.typeRefIndex)(tref);
         const existingAttributes = this.typeAttributes[index];
-        Support_1.assert(collection_utils_1.iterableEvery(attributes, ([k, v]) => {
+        (0, Support_1.assert)((0, collection_utils_1.iterableEvery)(attributes, ([k, v]) => {
             if (!k.inIdentity)
                 return true;
             const existing = existingAttributes.get(k);
             if (existing === undefined)
                 return false;
-            return collection_utils_1.areEqual(existing, v);
+            return (0, collection_utils_1.areEqual)(existing, v);
         }), "Can't add different identity type attributes to an existing type");
         const maybeType = this.types[index];
         if (maybeType !== undefined) {
             attributes = this.filterTypeAttributes(maybeType, attributes);
         }
-        const nonIdentityAttributes = collection_utils_1.mapFilter(attributes, (_, k) => !k.inIdentity);
-        this.typeAttributes[index] = TypeAttributes_1.combineTypeAttributes("union", existingAttributes, nonIdentityAttributes);
+        const nonIdentityAttributes = (0, collection_utils_1.mapFilter)(attributes, (_, k) => !k.inIdentity);
+        this.typeAttributes[index] = (0, TypeAttributes_1.combineTypeAttributes)("union", existingAttributes, nonIdentityAttributes);
     }
     finish() {
         this.typeGraph.freeze(this.topLevels, this.types.map(Support_1.defined), this.typeAttributes);
@@ -165,6 +170,7 @@ class TypeBuilder {
     get didAddForwardingIntersection() {
         return this._addedForwardingIntersection;
     }
+    _typeForIdentity = new collection_utils_1.EqualityMap();
     registerTypeForIdentity(identity, tref) {
         if (identity === undefined)
             return;
@@ -189,7 +195,7 @@ class TypeBuilder {
                 // we found the type based on its identity, i.e. all the identity
                 // attributes must be in there already, and we have a check that
                 // asserts that no identity attributes are added later.
-                this.addAttributes(result, collection_utils_1.mapFilter(attributes, (_, k) => !k.inIdentity));
+                this.addAttributes(result, (0, collection_utils_1.mapFilter)(attributes, (_, k) => !k.inIdentity));
             }
             return result;
         }
@@ -201,35 +207,35 @@ class TypeBuilder {
         this.registerTypeForIdentity(t.identity, t.typeRef);
     }
     getPrimitiveType(kind, maybeAttributes, forwardingRef) {
-        const attributes = collection_utils_1.withDefault(maybeAttributes, TypeAttributes_1.emptyTypeAttributes);
+        const attributes = (0, collection_utils_1.withDefault)(maybeAttributes, TypeAttributes_1.emptyTypeAttributes);
         // FIXME: Why do date/time types need a StringTypes attribute?
         // FIXME: Remove this from here and put it into flattenStrings
         let stringTypes = kind === "string" ? undefined : StringTypes_1.StringTypes.unrestricted;
-        if (Type_1.isPrimitiveStringTypeKind(kind) && kind !== "string") {
+        if ((0, Type_1.isPrimitiveStringTypeKind)(kind) && kind !== "string") {
             kind = stringTypeMappingGet(this._stringTypeMapping, kind);
         }
         if (kind === "string") {
             return this.getStringType(attributes, stringTypes, forwardingRef);
         }
-        return this.getOrAddType(() => Type_1.primitiveTypeIdentity(kind, attributes), tr => new Type_1.PrimitiveType(tr, this.typeGraph, kind), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.primitiveTypeIdentity)(kind, attributes), tr => new Type_1.PrimitiveType(tr, this.typeGraph, kind), attributes, forwardingRef);
     }
     getStringType(attributes, stringTypes, forwardingRef) {
-        const existingStringTypes = collection_utils_1.mapFind(attributes, (_, k) => k === StringTypes_1.stringTypesTypeAttributeKind);
-        Support_1.assert((stringTypes === undefined) !== (existingStringTypes === undefined), "Must instantiate string type with one enum case attribute");
+        const existingStringTypes = (0, collection_utils_1.mapFind)(attributes, (_, k) => k === StringTypes_1.stringTypesTypeAttributeKind);
+        (0, Support_1.assert)((stringTypes === undefined) !== (existingStringTypes === undefined), "Must instantiate string type with one enum case attribute");
         if (existingStringTypes === undefined) {
-            attributes = TypeAttributes_1.combineTypeAttributes("union", attributes, StringTypes_1.stringTypesTypeAttributeKind.makeAttributes(Support_1.defined(stringTypes)));
+            attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, StringTypes_1.stringTypesTypeAttributeKind.makeAttributes((0, Support_1.defined)(stringTypes)));
         }
-        return this.getOrAddType(() => Type_1.primitiveTypeIdentity("string", attributes), tr => new Type_1.PrimitiveType(tr, this.typeGraph, "string"), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.primitiveTypeIdentity)("string", attributes), tr => new Type_1.PrimitiveType(tr, this.typeGraph, "string"), attributes, forwardingRef);
     }
     getEnumType(attributes, cases, forwardingRef) {
-        return this.getOrAddType(() => Type_1.enumTypeIdentity(attributes, cases), tr => new Type_1.EnumType(tr, this.typeGraph, cases), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.enumTypeIdentity)(attributes, cases), tr => new Type_1.EnumType(tr, this.typeGraph, cases), attributes, forwardingRef);
     }
     makeClassProperty(tref, isOptional) {
         return new Type_1.ClassProperty(tref, this.typeGraph, isOptional);
     }
     getUniqueObjectType(attributes, properties, additionalProperties, forwardingRef) {
         this.assertTypeRefGraph(additionalProperties);
-        properties = collection_utils_1.definedMap(properties, p => this.modifyPropertiesIfNecessary(p));
+        properties = (0, collection_utils_1.definedMap)(properties, p => this.modifyPropertiesIfNecessary(p));
         return this.addType(forwardingRef, tref => new Type_1.ObjectType(tref, this.typeGraph, "object", true, properties, additionalProperties), attributes);
     }
     getUniqueMapType(forwardingRef) {
@@ -237,13 +243,13 @@ class TypeBuilder {
     }
     getMapType(attributes, values, forwardingRef) {
         this.assertTypeRefGraph(values);
-        return this.getOrAddType(() => Type_1.mapTypeIdentify(attributes, values), tr => new Type_1.MapType(tr, this.typeGraph, values), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.mapTypeIdentify)(attributes, values), tr => new Type_1.MapType(tr, this.typeGraph, values), attributes, forwardingRef);
     }
     setObjectProperties(ref, properties, additionalProperties) {
         this.assertTypeRefGraph(additionalProperties);
-        const type = TypeGraph_1.derefTypeRef(ref, this.typeGraph);
+        const type = (0, TypeGraph_1.derefTypeRef)(ref, this.typeGraph);
         if (!(type instanceof Type_1.ObjectType)) {
-            return Support_1.panic("Tried to set properties of non-object type");
+            return (0, Support_1.panic)("Tried to set properties of non-object type");
         }
         type.setProperties(this.modifyPropertiesIfNecessary(properties), additionalProperties);
         this.registerType(type);
@@ -253,13 +259,13 @@ class TypeBuilder {
     }
     getArrayType(attributes, items, forwardingRef) {
         this.assertTypeRefGraph(items);
-        return this.getOrAddType(() => Type_1.arrayTypeIdentity(attributes, items), tr => new Type_1.ArrayType(tr, this.typeGraph, items), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.arrayTypeIdentity)(attributes, items), tr => new Type_1.ArrayType(tr, this.typeGraph, items), attributes, forwardingRef);
     }
     setArrayItems(ref, items) {
         this.assertTypeRefGraph(items);
-        const type = TypeGraph_1.derefTypeRef(ref, this.typeGraph);
+        const type = (0, TypeGraph_1.derefTypeRef)(ref, this.typeGraph);
         if (!(type instanceof Type_1.ArrayType)) {
-            return Support_1.panic("Tried to set items of non-array type");
+            return (0, Support_1.panic)("Tried to set items of non-array type");
         }
         type.setItems(items);
         this.registerType(type);
@@ -267,26 +273,26 @@ class TypeBuilder {
     modifyPropertiesIfNecessary(properties) {
         properties.forEach(p => this.assertTypeRefGraph(p.typeRef));
         if (this.canonicalOrder) {
-            properties = collection_utils_1.mapSortByKey(properties);
+            properties = (0, collection_utils_1.mapSortByKey)(properties);
         }
         if (this._allPropertiesOptional) {
-            properties = collection_utils_1.mapMap(properties, cp => this.makeClassProperty(cp.typeRef, true));
+            properties = (0, collection_utils_1.mapMap)(properties, cp => this.makeClassProperty(cp.typeRef, true));
         }
         return properties;
     }
     getClassType(attributes, properties, forwardingRef) {
         properties = this.modifyPropertiesIfNecessary(properties);
-        return this.getOrAddType(() => Type_1.classTypeIdentity(attributes, properties), tr => new Type_1.ClassType(tr, this.typeGraph, false, properties), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.classTypeIdentity)(attributes, properties), tr => new Type_1.ClassType(tr, this.typeGraph, false, properties), attributes, forwardingRef);
     }
     // FIXME: Maybe just distinguish between this and `getClassType`
     // via a flag?  That would make `ClassType.map` simpler.
     getUniqueClassType(attributes, isFixed, properties, forwardingRef) {
-        properties = collection_utils_1.definedMap(properties, p => this.modifyPropertiesIfNecessary(p));
+        properties = (0, collection_utils_1.definedMap)(properties, p => this.modifyPropertiesIfNecessary(p));
         return this.addType(forwardingRef, tref => new Type_1.ClassType(tref, this.typeGraph, isFixed, properties), attributes);
     }
     getUnionType(attributes, members, forwardingRef) {
         this.assertTypeRefSetGraph(members);
-        return this.getOrAddType(() => Type_1.unionTypeIdentity(attributes, members), tr => new Type_1.UnionType(tr, this.typeGraph, members), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.unionTypeIdentity)(attributes, members), tr => new Type_1.UnionType(tr, this.typeGraph, members), attributes, forwardingRef);
     }
     // FIXME: why do we sometimes call this with defined members???
     getUniqueUnionType(attributes, members, forwardingRef) {
@@ -295,7 +301,7 @@ class TypeBuilder {
     }
     getIntersectionType(attributes, members, forwardingRef) {
         this.assertTypeRefSetGraph(members);
-        return this.getOrAddType(() => Type_1.intersectionTypeIdentity(attributes, members), tr => new Type_1.IntersectionType(tr, this.typeGraph, members), attributes, forwardingRef);
+        return this.getOrAddType(() => (0, Type_1.intersectionTypeIdentity)(attributes, members), tr => new Type_1.IntersectionType(tr, this.typeGraph, members), attributes, forwardingRef);
     }
     // FIXME: why do we sometimes call this with defined members???
     getUniqueIntersectionType(attributes, members, forwardingRef) {
@@ -304,9 +310,9 @@ class TypeBuilder {
     }
     setSetOperationMembers(ref, members) {
         this.assertTypeRefSetGraph(members);
-        const type = TypeGraph_1.derefTypeRef(ref, this.typeGraph);
+        const type = (0, TypeGraph_1.derefTypeRef)(ref, this.typeGraph);
         if (!(type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType)) {
-            return Support_1.panic("Tried to set members of non-set-operation type");
+            return (0, Support_1.panic)("Tried to set members of non-set-operation type");
         }
         type.setMembers(members);
         this.registerType(type);

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

@@ -4,7 +4,7 @@ import { TypeBuilder, StringTypeMapping } from "./TypeBuilder";
 import { GraphRewriteBuilder, BaseGraphRewriteBuilder } from "./GraphRewriting";
 import { Graph } from "./Graph";
 import { TypeAttributeKind, TypeAttributes } from "./attributes/TypeAttributes";
-export declare type TypeRef = number;
+export type TypeRef = number;
 export declare function isTypeRef(x: any): x is TypeRef;
 export declare function makeTypeRef(graph: TypeGraph, index: number): TypeRef;
 export declare function typeRefIndex(tref: TypeRef): number;
@@ -48,10 +48,10 @@ export declare class TypeGraph {
     private _parents;
     private _printOnRewrite;
     constructor(typeBuilder: TypeBuilder, serial: number, _haveProvenanceAttributes: boolean);
-    private readonly isFrozen;
-    readonly attributeStore: TypeAttributeStore;
+    private get isFrozen();
+    get attributeStore(): TypeAttributeStore;
     freeze(topLevels: ReadonlyMap<string, TypeRef>, types: Type[], typeAttributes: (TypeAttributes | undefined)[]): void;
-    readonly topLevels: ReadonlyMap<string, Type>;
+    get topLevels(): ReadonlyMap<string, Type>;
     typeAtIndex(index: number): Type;
     atIndex(index: number): [Type, TypeAttributes];
     private filterTypes;

package/dist/quicktype-core/TypeGraph.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeIndirectionIntersections = exports.optionalToNullable = exports.noneToAny = exports.TypeGraph = exports.TypeAttributeStoreView = exports.TypeAttributeStore = exports.typeAndAttributesForTypeRef = exports.attributesForTypeRef = exports.derefTypeRef = exports.assertTypeRefGraph = exports.typeRefIndex = exports.makeTypeRef = exports.isTypeRef = void 0;
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("./Type");
 const TypeUtils_1 = require("./TypeUtils");
@@ -19,7 +20,7 @@ function isTypeRef(x) {
 }
 exports.isTypeRef = isTypeRef;
 function makeTypeRef(graph, index) {
-    Support_1.assert(index <= indexMask, "Too many types in graph");
+    (0, Support_1.assert)(index <= indexMask, "Too many types in graph");
     return ((graph.serial & serialMask) << indexBits) | index;
 }
 exports.makeTypeRef = makeTypeRef;
@@ -28,7 +29,7 @@ function typeRefIndex(tref) {
 }
 exports.typeRefIndex = typeRefIndex;
 function assertTypeRefGraph(tref, graph) {
-    Support_1.assert(((tref >> indexBits) & serialMask) === (graph.serial & serialMask), "Mixing the wrong type reference and graph");
+    (0, Support_1.assert)(((tref >> indexBits) & serialMask) === (graph.serial & serialMask), "Mixing the wrong type reference and graph");
 }
 exports.assertTypeRefGraph = assertTypeRefGraph;
 function getGraph(graphOrBuilder) {
@@ -55,10 +56,12 @@ function typeAndAttributesForTypeRef(tref, graphOrBuilder) {
 }
 exports.typeAndAttributesForTypeRef = typeAndAttributesForTypeRef;
 class TypeAttributeStore {
+    _typeGraph;
+    _values;
+    _topLevelValues = new Map();
     constructor(_typeGraph, _values) {
         this._typeGraph = _typeGraph;
         this._values = _values;
-        this._topLevelValues = new Map();
     }
     getTypeIndex(t) {
         const tref = t.typeRef;
@@ -106,6 +109,8 @@ class TypeAttributeStore {
 }
 exports.TypeAttributeStore = TypeAttributeStore;
 class TypeAttributeStoreView {
+    _attributeStore;
+    _definition;
     constructor(_attributeStore, _definition) {
         this._attributeStore = _attributeStore;
         this._definition = _definition;
@@ -120,36 +125,40 @@ class TypeAttributeStoreView {
         return this._attributeStore.tryGet(this._definition, t);
     }
     get(t) {
-        return Support_1.defined(this.tryGet(t));
+        return (0, Support_1.defined)(this.tryGet(t));
     }
     tryGetForTopLevel(name) {
         return this._attributeStore.tryGetForTopLevel(this._definition, name);
     }
     getForTopLevel(name) {
-        return Support_1.defined(this.tryGetForTopLevel(name));
+        return (0, Support_1.defined)(this.tryGetForTopLevel(name));
     }
 }
 exports.TypeAttributeStoreView = TypeAttributeStoreView;
 class TypeGraph {
+    serial;
+    _haveProvenanceAttributes;
+    _typeBuilder;
+    _attributeStore = undefined;
+    // FIXME: OrderedMap?  We lose the order in PureScript right now, though,
+    // and maybe even earlier in the TypeScript driver.
+    _topLevels = new Map();
+    _types;
+    _parents = undefined;
+    _printOnRewrite = false;
     constructor(typeBuilder, serial, _haveProvenanceAttributes) {
         this.serial = serial;
         this._haveProvenanceAttributes = _haveProvenanceAttributes;
-        this._attributeStore = undefined;
-        // FIXME: OrderedMap?  We lose the order in PureScript right now, though,
-        // and maybe even earlier in the TypeScript driver.
-        this._topLevels = new Map();
-        this._parents = undefined;
-        this._printOnRewrite = false;
         this._typeBuilder = typeBuilder;
     }
     get isFrozen() {
         return this._typeBuilder === undefined;
     }
     get attributeStore() {
-        return Support_1.defined(this._attributeStore);
+        return (0, Support_1.defined)(this._attributeStore);
     }
     freeze(topLevels, types, typeAttributes) {
-        Support_1.assert(!this.isFrozen, "Tried to freeze TypeGraph a second time");
+        (0, Support_1.assert)(!this.isFrozen, "Tried to freeze TypeGraph a second time");
         for (const t of types) {
             assertTypeRefGraph(t.typeRef, this);
         }
@@ -160,24 +169,24 @@ class TypeGraph {
         // either a _typeBuilder or a _types.
         this._types = types;
         this._typeBuilder = undefined;
-        this._topLevels = collection_utils_1.mapMap(topLevels, tref => derefTypeRef(tref, this));
+        this._topLevels = (0, collection_utils_1.mapMap)(topLevels, tref => derefTypeRef(tref, this));
     }
     get topLevels() {
-        Support_1.assert(this.isFrozen, "Cannot get top-levels from a non-frozen graph");
+        (0, Support_1.assert)(this.isFrozen, "Cannot get top-levels from a non-frozen graph");
         return this._topLevels;
     }
     typeAtIndex(index) {
         if (this._typeBuilder !== undefined) {
             return this._typeBuilder.typeAtIndex(index);
         }
-        return Support_1.defined(this._types)[index];
+        return (0, Support_1.defined)(this._types)[index];
     }
     atIndex(index) {
         if (this._typeBuilder !== undefined) {
             return this._typeBuilder.atIndex(index);
         }
         const t = this.typeAtIndex(index);
-        return [t, Support_1.defined(this._attributeStore).attributesForType(t)];
+        return [t, (0, Support_1.defined)(this._attributeStore).attributesForType(t)];
     }
     filterTypes(predicate) {
         const seen = new Set();
@@ -204,10 +213,10 @@ class TypeGraph {
     }
     allNamedTypesSeparated() {
         const types = this.allNamedTypes();
-        return TypeUtils_1.separateNamedTypes(types);
+        return (0, TypeUtils_1.separateNamedTypes)(types);
     }
     allProvenance() {
-        Support_1.assert(this._haveProvenanceAttributes);
+        (0, Support_1.assert)(this._haveProvenanceAttributes);
         const view = new TypeAttributeStoreView(this.attributeStore, TypeBuilder_1.provenanceTypeAttributeKind);
         const sets = Array.from(this.allTypesUnordered()).map(t => {
             const maybeSet = view.tryGet(t);
@@ -216,7 +225,7 @@ class TypeGraph {
             return new Set();
         });
         const result = new Set();
-        collection_utils_1.setUnionManyInto(result, sets);
+        (0, collection_utils_1.setUnionManyInto)(result, sets);
         return result;
     }
     setPrintOnRewrite() {
@@ -228,9 +237,9 @@ class TypeGraph {
         const oldProvenance = this.allProvenance();
         const newProvenance = newGraph.allProvenance();
         if (oldProvenance.size !== newProvenance.size) {
-            const difference = collection_utils_1.setSubtract(oldProvenance, newProvenance);
+            const difference = (0, collection_utils_1.setSubtract)(oldProvenance, newProvenance);
             const indexes = Array.from(difference);
-            return Messages_1.messageError("IRTypeAttributesNotPropagated", { count: difference.size, indexes });
+            return (0, Messages_1.messageError)("IRTypeAttributesNotPropagated", { count: difference.size, indexes });
         }
     }
     printRewrite(title) {
@@ -270,17 +279,17 @@ class TypeGraph {
             newGraph.setPrintOnRewrite();
             newGraph.printGraph();
         }
-        Support_1.assert(!builder.didAddForwardingIntersection);
+        (0, Support_1.assert)(!builder.didAddForwardingIntersection);
         return newGraph;
     }
     garbageCollect(alphabetizeProperties, debugPrintReconstitution) {
-        const newGraph = this.remap("GC", TypeBuilder_1.getNoStringTypeMapping(), alphabetizeProperties, new Map(), debugPrintReconstitution, true);
+        const newGraph = this.remap("GC", (0, TypeBuilder_1.getNoStringTypeMapping)(), alphabetizeProperties, new Map(), debugPrintReconstitution, true);
         return newGraph;
     }
     rewriteFixedPoint(alphabetizeProperties, debugPrintReconstitution) {
         let graph = this;
         for (;;) {
-            const newGraph = this.rewrite("fixed-point", TypeBuilder_1.getNoStringTypeMapping(), alphabetizeProperties, [], debugPrintReconstitution, Support_1.mustNotHappen, true);
+            const newGraph = this.rewrite("fixed-point", (0, TypeBuilder_1.getNoStringTypeMapping)(), alphabetizeProperties, [], debugPrintReconstitution, Support_1.mustNotHappen, true);
             if (graph.allTypesUnordered().size === newGraph.allTypesUnordered().size) {
                 return graph;
             }
@@ -288,16 +297,16 @@ class TypeGraph {
         }
     }
     allTypesUnordered() {
-        Support_1.assert(this.isFrozen, "Tried to get all graph types before it was frozen");
-        return new Set(Support_1.defined(this._types));
+        (0, Support_1.assert)(this.isFrozen, "Tried to get all graph types before it was frozen");
+        return new Set((0, Support_1.defined)(this._types));
     }
     makeGraph(invertDirection, childrenOfType) {
-        return new Graph_1.Graph(Support_1.defined(this._types), invertDirection, childrenOfType);
+        return new Graph_1.Graph((0, Support_1.defined)(this._types), invertDirection, childrenOfType);
     }
     getParentsOfType(t) {
         assertTypeRefGraph(t.typeRef, this);
         if (this._parents === undefined) {
-            const parents = Support_1.defined(this._types).map(_ => new Set());
+            const parents = (0, Support_1.defined)(this._types).map(_ => new Set());
             for (const p of this.allTypesUnordered()) {
                 for (const c of p.getChildren()) {
                     const index = c.index;
@@ -309,7 +318,7 @@ class TypeGraph {
         return this._parents[t.index];
     }
     printGraph() {
-        const types = Support_1.defined(this._types);
+        const types = (0, Support_1.defined)(this._types);
         for (let i = 0; i < types.length; i++) {
             const t = types[i];
             const parts = [];
@@ -332,13 +341,13 @@ class TypeGraph {
 }
 exports.TypeGraph = TypeGraph;
 function noneToAny(graph, stringTypeMapping, debugPrintReconstitution) {
-    const noneTypes = collection_utils_1.setFilter(graph.allTypesUnordered(), t => t.kind === "none");
+    const noneTypes = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t.kind === "none");
     if (noneTypes.size === 0) {
         return graph;
     }
-    Support_1.assert(noneTypes.size === 1, "Cannot have more than one none type");
+    (0, Support_1.assert)(noneTypes.size === 1, "Cannot have more than one none type");
     return graph.rewrite("none to any", stringTypeMapping, false, [Array.from(noneTypes)], debugPrintReconstitution, (types, builder, forwardingRef) => {
-        const attributes = TypeUtils_1.combineTypeAttributesOfTypes("union", types);
+        const attributes = (0, TypeUtils_1.combineTypeAttributesOfTypes)("union", types);
         const tref = builder.getPrimitiveType("any", attributes, forwardingRef);
         return tref;
     });
@@ -346,7 +355,7 @@ function noneToAny(graph, stringTypeMapping, debugPrintReconstitution) {
 exports.noneToAny = noneToAny;
 function optionalToNullable(graph, stringTypeMapping, debugPrintReconstitution) {
     function rewriteClass(c, builder, forwardingRef) {
-        const properties = collection_utils_1.mapMap(c.getProperties(), (p, name) => {
+        const properties = (0, collection_utils_1.mapMap)(c.getProperties(), (p, name) => {
             const t = p.type;
             let ref;
             if (!p.isOptional || t.isNullable) {
@@ -356,7 +365,7 @@ function optionalToNullable(graph, stringTypeMapping, debugPrintReconstitution)
                 const nullType = builder.getPrimitiveType("null");
                 let members;
                 if (t instanceof Type_1.UnionType) {
-                    members = collection_utils_1.setMap(t.members, m => builder.reconstituteType(m)).add(nullType);
+                    members = (0, collection_utils_1.setMap)(t.members, m => builder.reconstituteType(m)).add(nullType);
                 }
                 else {
                     members = new Set([builder.reconstituteType(t), nullType]);
@@ -373,14 +382,14 @@ function optionalToNullable(graph, stringTypeMapping, debugPrintReconstitution)
             return builder.getClassType(c.getAttributes(), properties, forwardingRef);
         }
     }
-    const classesWithOptional = collection_utils_1.setFilter(graph.allTypesUnordered(), t => t instanceof Type_1.ClassType && collection_utils_1.mapSome(t.getProperties(), p => p.isOptional));
+    const classesWithOptional = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t instanceof Type_1.ClassType && (0, collection_utils_1.mapSome)(t.getProperties(), p => p.isOptional));
     const replacementGroups = Array.from(classesWithOptional).map(c => [c]);
     if (classesWithOptional.size === 0) {
         return graph;
     }
     return graph.rewrite("optional to nullable", stringTypeMapping, false, replacementGroups, debugPrintReconstitution, (setOfClass, builder, forwardingRef) => {
-        Support_1.assert(setOfClass.size === 1);
-        const c = Support_1.defined(collection_utils_1.iterableFirst(setOfClass));
+        (0, Support_1.assert)(setOfClass.size === 1);
+        const c = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfClass));
         return rewriteClass(c, builder, forwardingRef);
     });
 }
@@ -393,14 +402,14 @@ function removeIndirectionIntersections(graph, stringTypeMapping, debugPrintRema
         const seen = new Set([t]);
         let current = t;
         while (current.members.size === 1) {
-            const member = Support_1.defined(collection_utils_1.iterableFirst(current.members));
+            const member = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(current.members));
             if (!(member instanceof Type_1.IntersectionType)) {
                 map.push([t, member]);
                 break;
             }
             if (seen.has(member)) {
                 // FIXME: Technically, this is an any type.
-                return Support_1.panic("There's a cycle of intersection types");
+                return (0, Support_1.panic)("There's a cycle of intersection types");
             }
             seen.add(member);
             current = member;

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

@@ -14,7 +14,7 @@ export declare function nullableFromUnion(t: UnionType): Type | null;
 export declare function nonNullTypeCases(t: Type): ReadonlySet<Type>;
 export declare function getNullAsOptional(cp: ClassProperty): [boolean, ReadonlySet<Type>];
 export declare function isNamedType(t: Type): boolean;
-export declare type SeparatedNamedTypes = {
+export type SeparatedNamedTypes = {
     objects: ReadonlySet<ObjectType>;
     enums: ReadonlySet<EnumType>;
     unions: ReadonlySet<UnionType>;
@@ -23,7 +23,7 @@ export declare function separateNamedTypes(types: Iterable<Type>): SeparatedName
 export declare function directlyReachableTypes<T>(t: Type, setForType: (t: Type) => ReadonlySet<T> | null): ReadonlySet<T>;
 export declare function directlyReachableSingleNamedType(type: Type): Type | undefined;
 export declare function stringTypesForType(t: PrimitiveType): StringTypes;
-export declare type StringTypeMatchers<U> = {
+export type StringTypeMatchers<U> = {
     dateType?: (dateType: PrimitiveType) => U;
     timeType?: (timeType: PrimitiveType) => U;
     dateTimeType?: (dateTimeType: PrimitiveType) => U;