quicktype 18.0.5 → 19.0.4

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

@@ -1,16 +0,0 @@
-import { Type } from "./Type";
-import { TypeBuilder } from "./TypeBuilder";
-import { TypeLookerUp, GraphRewriteBuilder, BaseGraphRewriteBuilder } from "./GraphRewriting";
-import { UnionBuilder } from "./UnionBuilder";
-import { TypeAttributes } from "./attributes/TypeAttributes";
-import { TypeRef } from "./TypeGraph";
-export declare class UnifyUnionBuilder extends UnionBuilder<BaseGraphRewriteBuilder, TypeRef[], TypeRef[]> {
-    private readonly _makeObjectTypes;
-    private readonly _makeClassesFixed;
-    private readonly _unifyTypes;
-    constructor(typeBuilder: BaseGraphRewriteBuilder, _makeObjectTypes: boolean, _makeClassesFixed: boolean, _unifyTypes: (typesToUnify: TypeRef[]) => TypeRef);
-    protected makeObject(objectRefs: TypeRef[], typeAttributes: TypeAttributes, forwardingRef: TypeRef | undefined): TypeRef;
-    protected makeArray(arrays: TypeRef[], typeAttributes: TypeAttributes, forwardingRef: TypeRef | undefined): TypeRef;
-}
-export declare function unionBuilderForUnification<T extends Type>(typeBuilder: GraphRewriteBuilder<T>, makeObjectTypes: boolean, makeClassesFixed: boolean, conflateNumbers: boolean): UnionBuilder<TypeBuilder & TypeLookerUp, TypeRef[], TypeRef[]>;
-export declare function unifyTypes<T extends Type>(types: ReadonlySet<Type>, typeAttributes: TypeAttributes, typeBuilder: GraphRewriteBuilder<T>, unionBuilder: UnionBuilder<TypeBuilder & TypeLookerUp, TypeRef[], TypeRef[]>, conflateNumbers: boolean, maybeForwardingRef?: TypeRef): TypeRef;

package/dist/quicktype-core/UnifyClasses.js

@@ -1,159 +0,0 @@
-"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");
-const UnionBuilder_1 = require("./UnionBuilder");
-const Support_1 = require("./support/Support");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const TypeGraph_1 = require("./TypeGraph");
-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());
-    }
-    let properties = Array.from(propertyNames).map(name => [name, new Set(), false]);
-    let additionalProperties = undefined;
-    for (const o of clique) {
-        let additional = o.getAdditionalProperties();
-        if (additional !== undefined) {
-            if (additionalProperties === undefined) {
-                additionalProperties = new Set();
-            }
-            if (additional !== undefined) {
-                additionalProperties.add(additional);
-            }
-        }
-        for (let i = 0; i < properties.length; i++) {
-            let [name, types, isOptional] = properties[i];
-            const maybeProperty = o.getProperties().get(name);
-            if (maybeProperty === undefined) {
-                isOptional = true;
-                if (additional !== undefined && additional.kind !== "any") {
-                    types.add(additional);
-                }
-            }
-            else {
-                if (maybeProperty.isOptional) {
-                    isOptional = true;
-                }
-                types.add(maybeProperty.type);
-            }
-            properties[i][2] = isOptional;
-        }
-    }
-    const unifiedAdditionalProperties = additionalProperties === undefined ? undefined : makePropertyType(additionalProperties);
-    const unifiedPropertiesArray = properties.map(([name, types, isOptional]) => {
-        return [name, builder.makeClassProperty(makePropertyType(types), isOptional)];
-    });
-    const unifiedProperties = new Map(unifiedPropertiesArray);
-    return [unifiedProperties, unifiedAdditionalProperties, lostTypeAttributes];
-}
-function countProperties(clique) {
-    let hasProperties = false;
-    let hasAdditionalProperties = false;
-    let hasNonAnyAdditionalProperties = false;
-    for (const o of clique) {
-        if (o.getProperties().size > 0) {
-            hasProperties = true;
-        }
-        const additional = o.getAdditionalProperties();
-        if (additional !== undefined) {
-            hasAdditionalProperties = true;
-            if (additional.kind !== "any") {
-                hasNonAnyAdditionalProperties = true;
-            }
-        }
-    }
-    return { hasProperties, hasAdditionalProperties, hasNonAnyAdditionalProperties };
-}
-class UnifyUnionBuilder extends UnionBuilder_1.UnionBuilder {
-    _makeObjectTypes;
-    _makeClassesFixed;
-    _unifyTypes;
-    constructor(typeBuilder, _makeObjectTypes, _makeClassesFixed, _unifyTypes) {
-        super(typeBuilder);
-        this._makeObjectTypes = _makeObjectTypes;
-        this._makeClassesFixed = _makeClassesFixed;
-        this._unifyTypes = _unifyTypes;
-    }
-    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");
-            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 { 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));
-            }
-            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);
-            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");
-                return this._unifyTypes(Array.from(types).map(t => t.typeRef));
-            });
-            if (lostTypeAttributes) {
-                this.typeBuilder.setLostTypeAttributes();
-            }
-            if (this._makeObjectTypes) {
-                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");
-                return this.typeBuilder.getUniqueClassType(typeAttributes, this._makeClassesFixed, properties, forwardingRef);
-            }
-        }
-    }
-    makeArray(arrays, typeAttributes, forwardingRef) {
-        const ref = this.typeBuilder.getArrayType(typeAttributes, this._unifyTypes(arrays), forwardingRef);
-        return ref;
-    }
-}
-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));
-}
-exports.unionBuilderForUnification = unionBuilderForUnification;
-// typeAttributes must not be reconstituted yet.
-// FIXME: The UnionBuilder might end up not being used.
-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");
-    }
-    else if (types.size === 1) {
-        const first = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(types));
-        if (!(first instanceof Type_1.UnionType)) {
-            return typeBuilder.reconstituteTypeRef(first.typeRef, typeAttributes, maybeForwardingRef);
-        }
-    }
-    const typeRefs = Array.from(types).map(t => t.typeRef);
-    const maybeTypeRef = typeBuilder.lookupTypeRefs(typeRefs, maybeForwardingRef);
-    if (maybeTypeRef !== undefined) {
-        typeBuilder.addAttributes(maybeTypeRef, typeAttributes);
-        return maybeTypeRef;
-    }
-    const accumulator = new UnionBuilder_1.TypeRefUnionAccumulator(conflateNumbers);
-    const nestedAttributes = typeBuilder.reconstituteTypeAttributes(accumulator.addTypes(types));
-    typeAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", typeAttributes, nestedAttributes);
-    return typeBuilder.withForwardingRef(maybeForwardingRef, forwardingRef => {
-        typeBuilder.registerUnion(typeRefs, forwardingRef);
-        return unionBuilder.buildUnion(accumulator, false, typeAttributes, forwardingRef);
-    });
-}
-exports.unifyTypes = unifyTypes;

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

@@ -1,49 +0,0 @@
-import { TypeKind, PrimitiveStringTypeKind, Type, PrimitiveTypeKind } from "./Type";
-import { TypeAttributes } from "./attributes/TypeAttributes";
-import { TypeBuilder } from "./TypeBuilder";
-import { StringTypes } from "./attributes/StringTypes";
-import { TypeRef } from "./TypeGraph";
-export interface UnionTypeProvider<TArrayData, TObjectData> {
-    readonly arrayData: TArrayData;
-    readonly objectData: TObjectData;
-    readonly enumCases: ReadonlySet<string>;
-    getMemberKinds(): TypeAttributeMap<TypeKind>;
-    readonly lostTypeAttributes: boolean;
-}
-export type TypeAttributeMap<T extends TypeKind> = Map<T, TypeAttributes>;
-export declare class UnionAccumulator<TArray, TObject> implements UnionTypeProvider<TArray[], TObject[]> {
-    private readonly _conflateNumbers;
-    private readonly _nonStringTypeAttributes;
-    private readonly _stringTypeAttributes;
-    readonly arrayData: TArray[];
-    readonly objectData: TObject[];
-    private readonly _enumCases;
-    private _lostTypeAttributes;
-    constructor(_conflateNumbers: boolean);
-    private have;
-    addNone(_attributes: TypeAttributes): void;
-    addAny(attributes: TypeAttributes): void;
-    addPrimitive(kind: PrimitiveTypeKind, attributes: TypeAttributes): void;
-    protected addFullStringType(attributes: TypeAttributes, stringTypes: StringTypes | undefined): void;
-    addStringType(kind: PrimitiveStringTypeKind, attributes: TypeAttributes, stringTypes?: StringTypes): void;
-    addArray(t: TArray, attributes: TypeAttributes): void;
-    addObject(t: TObject, attributes: TypeAttributes): void;
-    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>;
-    getMemberKinds(): TypeAttributeMap<TypeKind>;
-    get lostTypeAttributes(): boolean;
-}
-export declare class TypeRefUnionAccumulator extends UnionAccumulator<TypeRef, TypeRef> {
-    private addType;
-    addTypes(types: Iterable<Type>): TypeAttributes;
-}
-export declare abstract class UnionBuilder<TBuilder extends TypeBuilder, TArrayData, TObjectData> {
-    protected readonly typeBuilder: TBuilder;
-    constructor(typeBuilder: TBuilder);
-    protected abstract makeObject(objects: TObjectData, typeAttributes: TypeAttributes, forwardingRef: TypeRef | undefined): TypeRef;
-    protected abstract makeArray(arrays: TArrayData, typeAttributes: TypeAttributes, forwardingRef: TypeRef | undefined): TypeRef;
-    private makeTypeOfKind;
-    buildUnion(typeProvider: UnionTypeProvider<TArrayData, TObjectData>, unique: boolean, typeAttributes: TypeAttributes, forwardingRef?: TypeRef): TypeRef;
-}

package/dist/quicktype-core/UnionBuilder.js

@@ -1,282 +0,0 @@
-"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");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const Support_1 = require("./support/Support");
-const StringTypes_1 = require("./attributes/StringTypes");
-function addAttributes(accumulatorAttributes, newAttributes) {
-    if (accumulatorAttributes === undefined)
-        return newAttributes;
-    return (0, TypeAttributes_1.combineTypeAttributes)("union", accumulatorAttributes, newAttributes);
-}
-function setAttributes(attributeMap, kind, newAttributes) {
-    attributeMap.set(kind, addAttributes(attributeMap.get(kind), newAttributes));
-}
-function addAttributesToBuilder(builder, kind, newAttributes) {
-    let arr = builder.get(kind);
-    if (arr === undefined) {
-        arr = [];
-        builder.set(kind, arr);
-    }
-    arr.push(newAttributes);
-}
-function buildTypeAttributeMap(builder) {
-    return (0, collection_utils_1.mapMap)(builder, arr => (0, TypeAttributes_1.combineTypeAttributes)("union", arr));
-}
-function moveAttributes(map, fromKind, toKind) {
-    const fromAttributes = (0, 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;
-    }
-    have(kind) {
-        return (this._nonStringTypeAttributes.has(kind) || this._stringTypeAttributes.has(kind));
-    }
-    addNone(_attributes) {
-        // FIXME: Add them to all members?  Or add them to the union, which means we'd have
-        // to change getMemberKinds() to also return the attributes for the union itself,
-        // or add a new method that does that.
-        this._lostTypeAttributes = true;
-    }
-    addAny(attributes) {
-        addAttributesToBuilder(this._nonStringTypeAttributes, "any", attributes);
-        this._lostTypeAttributes = true;
-    }
-    addPrimitive(kind, attributes) {
-        (0, Support_1.assert)(kind !== "any", "any must be added with addAny");
-        addAttributesToBuilder(this._nonStringTypeAttributes, kind, attributes);
-    }
-    addFullStringType(attributes, stringTypes) {
-        let stringTypesAttributes = undefined;
-        if (stringTypes === undefined) {
-            stringTypes = StringTypes_1.stringTypesTypeAttributeKind.tryGetInAttributes(attributes);
-        }
-        else {
-            stringTypesAttributes = StringTypes_1.stringTypesTypeAttributeKind.makeAttributes(stringTypes);
-        }
-        if (stringTypes === undefined) {
-            stringTypes = StringTypes_1.StringTypes.unrestricted;
-            stringTypesAttributes = StringTypes_1.stringTypesTypeAttributeKind.makeAttributes(stringTypes);
-        }
-        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");
-        }
-        addAttributesToBuilder(this._stringTypeAttributes, "string", attributes);
-        if (stringTypesAttributes !== undefined) {
-            addAttributesToBuilder(this._stringTypeAttributes, "string", stringTypesAttributes);
-        }
-    }
-    addStringType(kind, attributes, stringTypes) {
-        if (kind === "string") {
-            this.addFullStringType(attributes, stringTypes);
-            return;
-        }
-        addAttributesToBuilder(this._stringTypeAttributes, kind, attributes);
-        if (stringTypes !== undefined) {
-            addAttributesToBuilder(this._stringTypeAttributes, kind, StringTypes_1.stringTypesTypeAttributeKind.makeAttributes(stringTypes));
-        }
-    }
-    addArray(t, attributes) {
-        this.arrayData.push(t);
-        addAttributesToBuilder(this._nonStringTypeAttributes, "array", attributes);
-    }
-    addObject(t, attributes) {
-        this.objectData.push(t);
-        addAttributesToBuilder(this._nonStringTypeAttributes, "object", attributes);
-    }
-    addEnum(cases, attributes) {
-        const maybeStringAttributes = this._stringTypeAttributes.get("string");
-        if (maybeStringAttributes !== undefined) {
-            addAttributesToBuilder(this._stringTypeAttributes, "string", attributes);
-            return;
-        }
-        addAttributesToBuilder(this._nonStringTypeAttributes, "enum", attributes);
-        (0, collection_utils_1.setUnionInto)(this._enumCases, cases);
-    }
-    addStringCases(cases, attributes) {
-        this.addFullStringType(attributes, StringTypes_1.StringTypes.fromCases(cases));
-    }
-    addStringCase(s, count, attributes) {
-        this.addFullStringType(attributes, StringTypes_1.StringTypes.fromCase(s, count));
-    }
-    get enumCases() {
-        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));
-        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()));
-            return new Map([["any", allAttributes]]);
-        }
-        if (this._conflateNumbers && this.have("integer") && this.have("double")) {
-            moveAttributes(merged, "integer", "double");
-        }
-        if (this.have("map")) {
-            moveAttributes(merged, "map", "class");
-        }
-        return merged;
-    }
-    get lostTypeAttributes() {
-        return this._lostTypeAttributes;
-    }
-}
-exports.UnionAccumulator = UnionAccumulator;
-class FauxUnion {
-    getAttributes() {
-        return TypeAttributes_1.emptyTypeAttributes;
-    }
-}
-function attributesForTypes(types) {
-    // These two maps are the reverse of each other.  unionsForType is all the unions
-    // that are ancestors of that type, when going from one of the given types, only
-    // following unions.
-    const unionsForType = new Map();
-    const typesForUnion = new Map();
-    // All the unions we've seen, starting from types, stopping when we hit non-unions.
-    const unions = new Set();
-    // All the unions that are equivalent to the single root type.  If more than one type
-    // is given, this will be empty.
-    let unionsEquivalentToRoot = new Set();
-    function traverse(t, path, isEquivalentToRoot) {
-        if (t instanceof Type_1.UnionType) {
-            unions.add(t);
-            if (isEquivalentToRoot) {
-                unionsEquivalentToRoot = unionsEquivalentToRoot.add(t);
-            }
-            isEquivalentToRoot = isEquivalentToRoot && t.members.size === 1;
-            path.push(t);
-            for (const m of t.members) {
-                traverse(m, path, isEquivalentToRoot);
-            }
-            path.pop();
-        }
-        else {
-            (0, collection_utils_1.mapUpdateInto)(unionsForType, t, s => (s === undefined ? new Set(path) : (0, 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)));
-            }
-        }
-    }
-    const rootPath = [new FauxUnion()];
-    const typesArray = Array.from(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 inheritedAttributes = singleAncestors.map(u => u.getAttributes());
-        return (0, TypeAttributes_1.combineTypeAttributes)("union", [t.getAttributes()].concat(inheritedAttributes));
-    });
-    const unionAttributes = Array.from(unions).map(u => {
-        const t = typesForUnion.get(u);
-        if (t !== undefined && t.size === 1) {
-            return TypeAttributes_1.emptyTypeAttributes;
-        }
-        const attributes = u.getAttributes();
-        if (unionsEquivalentToRoot.has(u)) {
-            return attributes;
-        }
-        return (0, TypeAttributes_1.makeTypeAttributesInferred)(attributes);
-    });
-    return [resultAttributes, (0, 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), 
-        // 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");
-        }, transformedStringType => this.addStringType(transformedStringType.kind, attributes));
-    }
-    addTypes(types) {
-        const [attributesMap, unionAttributes] = attributesForTypes(types);
-        for (const [t, attributes] of attributesMap) {
-            this.addType(t, attributes);
-        }
-        return unionAttributes;
-    }
-}
-exports.TypeRefUnionAccumulator = TypeRefUnionAccumulator;
-class UnionBuilder {
-    typeBuilder;
-    constructor(typeBuilder) {
-        this.typeBuilder = typeBuilder;
-    }
-    makeTypeOfKind(typeProvider, kind, typeAttributes, forwardingRef) {
-        switch (kind) {
-            case "string":
-                return this.typeBuilder.getStringType(typeAttributes, undefined, forwardingRef);
-            case "enum":
-                return this.typeBuilder.getEnumType(typeAttributes, typeProvider.enumCases, forwardingRef);
-            case "object":
-                return this.makeObject(typeProvider.objectData, typeAttributes, forwardingRef);
-            case "array":
-                return this.makeArray(typeProvider.arrayData, typeAttributes, forwardingRef);
-            default:
-                if ((0, 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 (0, Support_1.assertNever)(kind);
-        }
-    }
-    buildUnion(typeProvider, unique, typeAttributes, forwardingRef) {
-        const kinds = typeProvider.getMemberKinds();
-        if (typeProvider.lostTypeAttributes) {
-            this.typeBuilder.setLostTypeAttributes();
-        }
-        // FIXME: We don't reconstitute type attributes here, so it's possible that
-        // we get type refs for the wrong graphs if the transformation making rewrite
-        // makes unions that have to be unified here.  That's a bug anyway, at least
-        // 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 t = this.makeTypeOfKind(typeProvider, kind, allAttributes, forwardingRef);
-            return t;
-        }
-        const union = unique
-            ? this.typeBuilder.getUniqueUnionType(typeAttributes, undefined, forwardingRef)
-            : undefined;
-        const types = [];
-        for (const [kind, memberAttributes] of kinds) {
-            types.push(this.makeTypeOfKind(typeProvider, kind, memberAttributes, undefined));
-        }
-        const typesSet = new Set(types);
-        if (union !== undefined) {
-            this.typeBuilder.setSetOperationMembers(union, typesSet);
-            return union;
-        }
-        else {
-            return this.typeBuilder.getUnionType(typeAttributes, typesSet, forwardingRef);
-        }
-    }
-}
-exports.UnionBuilder = UnionBuilder;

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

@@ -1,18 +0,0 @@
-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 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>;
-export declare function enumCaseNames(e: EnumType, language: string): Map<string, [string, boolean] | undefined>;
-export declare function getAccessorName(names: Map<string, [string, boolean] | undefined>, original: string): [string | undefined, boolean];
-export declare const unionIdentifierTypeAttributeKind: TypeAttributeKind<ReadonlySet<number>>;
-export declare function makeUnionIdentifierAttribute(): TypeAttributes;
-export declare const unionMemberNamesTypeAttributeKind: TypeAttributeKind<Map<number, AccessorEntry>>;
-export declare function makeUnionMemberNamesAttribute(unionAttributes: TypeAttributes, entry: AccessorEntry): TypeAttributes;
-export declare function unionMemberName(u: UnionType, member: Type, language: string): [string | undefined, boolean];
-export declare function makeAccessorNames(x: any): AccessorNames;
-export declare function accessorNamesAttributeProducer(schema: JSONSchema, canonicalRef: Ref, _types: Set<JSONSchemaType>, cases: JSONSchema[] | undefined): JSONSchemaAttributes | undefined;