quicktype-core 23.1.4 → 23.2.0

package/dist/ConvenienceRenderer.d.ts

@@ -3,7 +3,7 @@ import { DependencyName, type Name, type Namer, Namespace } from "./Naming";
 import { type BlankLineConfig, type ForEachPosition, type RenderContext, Renderer } from "./Renderer";
 import { type Sourcelike } from "./Source";
 import { type Comment, type CommentOptions } from "./support/Comments";
-import { type TargetLanguage } from "./TargetLanguage";
+import type { TargetLanguage } from "./TargetLanguage";
 import { type Transformation } from "./Transformers";
 import { type ClassProperty, ClassType, EnumType, ObjectType, type Type, type TypeKind, UnionType } from "./Type";
 export declare const topLevelNameOrder = 1;
@@ -130,7 +130,7 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     protected sourcelikeToString(src: Sourcelike): string;
     protected get commentLineStart(): string;
     protected emitComments(comments: Comment[]): void;
-    protected emitCommentLines(lines: Sourcelike[], { lineStart, firstLineStart, lineEnd, beforeComment, afterComment }?: CommentOptions): void;
+    protected emitCommentLines(lines: Sourcelike[], { lineStart, firstLineStart, lineEnd, beforeComment, afterComment, }?: CommentOptions): void;
     protected emitDescription(description: Sourcelike[] | undefined): void;
     protected emitDescriptionBlock(lines: Sourcelike[]): void;
     protected emitPropertyTable(c: ClassType, makePropertyRow: (name: Name, jsonName: string, p: ClassProperty) => Sourcelike[]): void;

package/dist/ConvenienceRenderer.js

@@ -37,7 +37,7 @@ function splitDescription(descriptions) {
         return undefined;
     return wordWrap(description)
         .split("\n")
-        .map(l => l.trim());
+        .map((l) => l.trim());
 }
 const assignedNameAttributeKind = new TypeAttributes_1.TypeAttributeKind("assignedName");
 const assignedPropertyNamesAttributeKind = new TypeAttributes_1.TypeAttributeKind("assignedPropertyNames");
@@ -117,7 +117,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return (0, Support_1.defined)(this._nameStoreView);
     }
     descriptionForType(t) {
-        let description = this.typeGraph.attributeStore.tryGet(Description_1.descriptionTypeAttributeKind, t);
+        const description = this.typeGraph.attributeStore.tryGet(Description_1.descriptionTypeAttributeKind, t);
         return splitDescription(description);
     }
     descriptionForClassProperty(o, name) {
@@ -139,7 +139,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         this._otherForbiddenNamespaces = new Map();
         this._globalNamespace = new Naming_1.Namespace("global", undefined, [this._globalForbiddenNamespace], []);
         const { objects, enums, unions } = this.typeGraph.allNamedTypesSeparated();
-        const namedUnions = (0, collection_utils_1.setFilter)(unions, u => this.unionNeedsName(u));
+        const namedUnions = (0, collection_utils_1.setFilter)(unions, (u) => this.unionNeedsName(u));
         for (const [name, t] of this.topLevels) {
             this.nameStoreView.setForTopLevel(name, this.addNameForTopLevel(t, name));
         }
@@ -263,8 +263,12 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         // maybe we'll need global properties for some weird language at
         // some point.
         const alternative = `${o.getCombinedName()}_${jsonName}`;
-        const order = assignedName === undefined ? classPropertyNameOrder : assignedClassPropertyNameOrder;
-        const names = assignedName === undefined ? [jsonName, alternative] : [assignedName];
+        const order = assignedName === undefined
+            ? classPropertyNameOrder
+            : assignedClassPropertyNameOrder;
+        const names = assignedName === undefined
+            ? [jsonName, alternative]
+            : [assignedName];
         return new Naming_1.SimpleName(names, namer, order);
     }
     makePropertyDependencyNames(_o, _className, _p, _jsonName, _name) {
@@ -301,7 +305,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         if (isFixed) {
             return new Naming_1.FixedName((0, Support_1.defined)(assignedName));
         }
-        return new Naming_1.DependencyName((0, Support_1.nonNull)(this._unionMemberNamer), unionMemberNameOrder, lookup => {
+        return new Naming_1.DependencyName((0, Support_1.nonNull)(this._unionMemberNamer), unionMemberNameOrder, (lookup) => {
             if (assignedName !== undefined)
                 return assignedName;
             return this.proposeUnionMemberName(u, unionName, t, lookup);
@@ -319,7 +323,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         else {
             ns = new Naming_1.Namespace(u.getCombinedName(), this.globalNamespace, forbiddenNamespaces, forbiddenNames);
         }
-        let names = new Map();
+        const names = new Map();
         for (const t of u.members) {
             const name = this.makeNameForUnionMember(u, unionName, (0, Transformers_1.followTargetType)(t));
             names.set(t, ns.add(name));
@@ -330,8 +334,12 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         // FIXME: See the FIXME in `makeNameForProperty`.  We do have global
         // enum cases, though (in Go), so this is actually useful already.
         const alternative = `${e.getCombinedName()}_${caseName}`;
-        const order = assignedName === undefined ? enumCaseNameOrder : assignedEnumCaseNameOrder;
-        const names = assignedName === undefined ? [caseName, alternative] : [assignedName];
+        const order = assignedName === undefined
+            ? enumCaseNameOrder
+            : assignedEnumCaseNameOrder;
+        const names = assignedName === undefined
+            ? [caseName, alternative]
+            : [assignedName];
         return new Naming_1.SimpleName(names, (0, Support_1.nonNull)(this._enumCaseNamer), order);
     }
     // FIXME: this is very similar to addPropertyNameds and addUnionMemberNames
@@ -346,7 +354,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         else {
             ns = new Naming_1.Namespace(e.getCombinedName(), this.globalNamespace, forbiddenNamespaces, forbiddenNames);
         }
-        let names = new Map();
+        const names = new Map();
         const accessorNames = (0, AccessorNames_1.enumCaseNames)(e, this.targetLanguage.name);
         for (const caseName of e.cases) {
             const [assignedName, isFixed] = (0, AccessorNames_1.getAccessorName)(accessorNames, caseName);
@@ -409,12 +417,12 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         if (simpleName !== null) {
             return simpleName;
         }
-        const typeNameForUnionMember = (t) => (0, TypeUtils_1.matchTypeExhaustive)(t, _noneType => {
+        const typeNameForUnionMember = (t) => (0, TypeUtils_1.matchTypeExhaustive)(t, (_noneType) => {
             return (0, Support_1.panic)("none type should have been replaced");
-        }, _anyType => "anything", _nullType => "null", _boolType => "bool", _integerType => "integer", _doubleType => "double", _stringType => "string", arrayType => typeNameForUnionMember(arrayType.items) + "_array", classType => lookup(this.nameForNamedType(classType)), mapType => typeNameForUnionMember(mapType.values) + "_map", objectType => {
+        }, (_anyType) => "anything", (_nullType) => "null", (_boolType) => "bool", (_integerType) => "integer", (_doubleType) => "double", (_stringType) => "string", (arrayType) => typeNameForUnionMember(arrayType.items) + "_array", (classType) => lookup(this.nameForNamedType(classType)), (mapType) => typeNameForUnionMember(mapType.values) + "_map", (objectType) => {
             (0, Support_1.assert)(this.targetLanguage.supportsFullObjectType, "Object type should have been replaced in `replaceObjectType`");
             return lookup(this.nameForNamedType(objectType));
-        }, _enumType => "enum", _unionType => "union", transformedType => transformedType.kind.replace("-", "_"));
+        }, (_enumType) => "enum", (_unionType) => "union", (transformedType) => transformedType.kind.replace("-", "_"));
         return typeNameForUnionMember(fieldType);
     }
     nameForNamedType(t) {
@@ -431,7 +439,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
     }
     isCycleBreakerType(t) {
         if (this._cycleBreakerTypes === undefined) {
-            this._cycleBreakerTypes = (0, DeclarationIR_1.cycleBreakerTypesForGraph)(this.typeGraph, s => this.isImplicitCycleBreaker(s), s => this.canBreakCycles(s));
+            this._cycleBreakerTypes = (0, DeclarationIR_1.cycleBreakerTypesForGraph)(this.typeGraph, (s) => this.isImplicitCycleBreaker(s), (s) => this.canBreakCycles(s));
         }
         return this._cycleBreakerTypes.has(t);
     }
@@ -466,9 +474,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
                 return (0, Support_1.defined)(this.names.get(name));
             });
         }
-        else {
-            return properties;
-        }
+        return properties;
     }
     forEachClassProperty(o, blankLocations, f) {
         const propertyNames = (0, Support_1.defined)(this._propertyNamesStoreView).get(o);
@@ -496,7 +502,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
     }
     forEachEnumCase(e, blankLocations, f) {
         const caseNames = (0, Support_1.defined)(this._caseNamesStoreView).get(e);
-        const sortedCaseNames = (0, collection_utils_1.mapSortBy)(caseNames, n => (0, Support_1.defined)(this.names.get(n)));
+        const sortedCaseNames = (0, collection_utils_1.mapSortBy)(caseNames, (n) => (0, Support_1.defined)(this.names.get(n)));
         this.forEachWithBlankLines(sortedCaseNames, blankLocations, f);
     }
     forEachTransformation(blankLocations, f) {
@@ -554,7 +560,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return "// ";
     }
     emitComments(comments) {
-        comments.forEach(comment => {
+        comments.forEach((comment) => {
             if ((0, Comments_1.isStringComment)(comment)) {
                 this.emitCommentLines([comment]);
             }
@@ -570,7 +576,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
             this.ensureBlankLine();
         });
     }
-    emitCommentLines(lines, { lineStart = this.commentLineStart, firstLineStart = lineStart, lineEnd, beforeComment, afterComment } = {}) {
+    emitCommentLines(lines, { lineStart = this.commentLineStart, firstLineStart = lineStart, lineEnd, beforeComment, afterComment, } = {}) {
         if (beforeComment !== undefined) {
             this.emitLine(beforeComment);
         }
@@ -620,18 +626,22 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         emitTable();
     }
     processGraph() {
-        this._declarationIR = (0, DeclarationIR_1.declarationsForGraph)(this.typeGraph, this.needsTypeDeclarationBeforeUse ? (t) => this.canBeForwardDeclared(t) : undefined, t => this.childrenOfType(t), t => {
+        this._declarationIR = (0, DeclarationIR_1.declarationsForGraph)(this.typeGraph, this.needsTypeDeclarationBeforeUse
+            ? (t) => this.canBeForwardDeclared(t)
+            : undefined, (t) => this.childrenOfType(t), (t) => {
             if (t instanceof Type_1.UnionType) {
                 return this.unionNeedsName(t);
             }
             return (0, TypeUtils_1.isNamedType)(t);
         });
         const types = this.typeGraph.allTypesUnordered();
-        this._haveUnions = (0, collection_utils_1.iterableSome)(types, t => t instanceof Type_1.UnionType);
-        this._haveMaps = (0, collection_utils_1.iterableSome)(types, t => t instanceof Type_1.MapType);
-        const classTypes = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.ClassType);
-        this._haveOptionalProperties = (0, collection_utils_1.iterableSome)(classTypes, c => (0, collection_utils_1.mapSome)(c.getProperties(), p => p.isOptional));
-        this._namedTypes = this._declarationIR.declarations.filter(d => d.kind === "define").map(d => d.type);
+        this._haveUnions = (0, collection_utils_1.iterableSome)(types, (t) => t instanceof Type_1.UnionType);
+        this._haveMaps = (0, collection_utils_1.iterableSome)(types, (t) => t instanceof Type_1.MapType);
+        const classTypes = (0, collection_utils_1.setFilter)(types, (t) => t instanceof Type_1.ClassType);
+        this._haveOptionalProperties = (0, collection_utils_1.iterableSome)(classTypes, (c) => (0, collection_utils_1.mapSome)(c.getProperties(), (p) => p.isOptional));
+        this._namedTypes = this._declarationIR.declarations
+            .filter((d) => d.kind === "define")
+            .map((d) => d.type);
         const { objects, enums, unions } = (0, TypeUtils_1.separateNamedTypes)(this._namedTypes);
         this._namedObjects = new Set(objects);
         this._namedEnums = new Set(enums);

package/dist/CycleBreaker.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.breakCycles = void 0;
+exports.breakCycles = breakCycles;
 const Support_1 = require("./support/Support");
 function breakCycles(outEdges, chooseBreaker) {
     const numNodes = outEdges.length;
@@ -72,7 +72,7 @@ function breakCycles(outEdges, chooseBreaker) {
             // We could count the number of reachable nodes for all nodes in the graph,
             // and then pick one of the nodes with the lowest number, which would pick
             // the dependee cycle.
-            const maybeEdge = outEdges[n].find(x => !done[x]);
+            const maybeEdge = outEdges[n].find((x) => !done[x]);
             if (maybeEdge === undefined) {
                 return (0, Support_1.panic)("Presumed cycle is not a cycle");
             }
@@ -95,4 +95,3 @@ function breakCycles(outEdges, chooseBreaker) {
     }
     return results;
 }
-exports.breakCycles = breakCycles;

package/dist/DateTime.js

@@ -52,7 +52,9 @@ class DefaultDateTimeRecognizer {
     isDateTime(str) {
         // http://tools.ietf.org/html/rfc3339#section-5.6
         const dateTime = str.split(DATE_TIME_SEPARATOR);
-        return dateTime.length === 2 && this.isDate(dateTime[0]) && this.isTime(dateTime[1]);
+        return (dateTime.length === 2 &&
+            this.isDate(dateTime[0]) &&
+            this.isTime(dateTime[1]));
     }
 }
 exports.DefaultDateTimeRecognizer = DefaultDateTimeRecognizer;

package/dist/DeclarationIR.d.ts

@@ -1,5 +1,5 @@
-import { type Type } from "./Type/Type";
-import { type TypeGraph } from "./Type/TypeGraph";
+import type { Type } from "./Type/Type";
+import type { TypeGraph } from "./Type/TypeGraph";
 export type DeclarationKind = "forward" | "define";
 export interface Declaration {
     readonly kind: DeclarationKind;

package/dist/DeclarationIR.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.declarationsForGraph = exports.cycleBreakerTypesForGraph = exports.DeclarationIR = void 0;
+exports.DeclarationIR = void 0;
+exports.cycleBreakerTypesForGraph = cycleBreakerTypesForGraph;
+exports.declarationsForGraph = declarationsForGraph;
 const collection_utils_1 = require("collection-utils");
 const Graph_1 = require("./Graph");
 const Messages_1 = require("./Messages");
@@ -62,7 +64,6 @@ function cycleBreakerTypesForGraph(graph, isImplicitCycleBreaker, canBreakCycles
     }
     return cycleBreakerTypes;
 }
-exports.cycleBreakerTypesForGraph = cycleBreakerTypesForGraph;
 function declarationsForGraph(typeGraph, canBeForwardDeclared, childrenOfType, needsDeclaration) {
     /*
     function nodeTitle(t: Type): string {
@@ -92,7 +93,10 @@ function declarationsForGraph(typeGraph, canBeForwardDeclared, childrenOfType, n
             // 1. Only one node in the cycle needs a declaration, in which
             // case it's the breaker, and no forward declaration is necessary.
             if (declarationNeeded.size === 1) {
-                declarations.push({ kind: "define", type: (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(declarationNeeded)) });
+                declarations.push({
+                    kind: "define",
+                    type: (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(declarationNeeded)),
+                });
                 return;
             }
             // 2. No node in the cycle needs a declaration, but it's also
@@ -105,7 +109,10 @@ function declarationsForGraph(typeGraph, canBeForwardDeclared, childrenOfType, n
             // declaration, so we can pick any one. This is not a forward
             // declaration, either.
             if (declarationNeeded.size === 0) {
-                declarations.push({ kind: "define", type: (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(component)) });
+                declarations.push({
+                    kind: "define",
+                    type: (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(component)),
+                });
                 return;
             }
             // 4. More than one node needs a declaration, and we don't need
@@ -125,14 +132,14 @@ function declarationsForGraph(typeGraph, canBeForwardDeclared, childrenOfType, n
             // we declare the types we previously forward-declared.
             const forwardDeclarable = (0, collection_utils_1.setFilter)(component, canBeForwardDeclared);
             if (forwardDeclarable.size === 0) {
-                return (0, Messages_1.messageError)("IRNoForwardDeclarableTypeInCycle", {});
+                (0, Messages_1.messageError)("IRNoForwardDeclarableTypeInCycle", {});
             }
             for (const t of forwardDeclarable) {
                 declarations.push({ kind: "forward", type: t });
             }
             (0, collection_utils_1.setUnionInto)(forwardedTypes, forwardDeclarable);
             const rest = (0, collection_utils_1.setSubtract)(component, forwardDeclarable);
-            const restGraph = new Graph_1.Graph(rest, true, t => (0, collection_utils_1.setIntersect)(childrenOfType(t), rest));
+            const restGraph = new Graph_1.Graph(rest, true, (t) => (0, collection_utils_1.setIntersect)(childrenOfType(t), rest));
             processGraph(restGraph, false);
             for (const t of forwardDeclarable) {
                 declarations.push({ kind: "define", type: t });
@@ -162,4 +169,3 @@ function declarationsForGraph(typeGraph, canBeForwardDeclared, childrenOfType, n
     processGraph(fullGraph, true);
     return new DeclarationIR(declarations, forwardedTypes);
 }
-exports.declarationsForGraph = declarationsForGraph;

package/dist/GatherNames.d.ts

@@ -1,2 +1,2 @@
-import { type TypeGraph } from "./Type/TypeGraph";
+import type { TypeGraph } from "./Type/TypeGraph";
 export declare function gatherNames(graph: TypeGraph, destructive: boolean, debugPrint: boolean): void;

package/dist/GatherNames.js

@@ -15,15 +15,25 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gatherNames = void 0;
+exports.gatherNames = gatherNames;
 const collection_utils_1 = require("collection-utils");
 const pluralize = __importStar(require("pluralize"));
 const TypeNames_1 = require("./attributes/TypeNames");
@@ -170,10 +180,12 @@ function gatherNames(graph, destructive, debugPrint) {
             }
         }
         else {
-            (0, TypeUtils_1.matchCompoundType)(t, arrayType => {
-                addNames(arrayType.items, names === null ? null : (0, collection_utils_1.setMap)(names, pluralize.singular));
-            }, _classType => (0, Support_1.panic)("We handled this above"), _mapType => (0, Support_1.panic)("We handled this above"), _objectType => (0, Support_1.panic)("We handled this above"), unionType => {
-                const members = (0, collection_utils_1.setSortBy)(unionType.members, member => member.kind);
+            (0, TypeUtils_1.matchCompoundType)(t, (arrayType) => {
+                addNames(arrayType.items, names === null
+                    ? null
+                    : (0, collection_utils_1.setMap)(names, pluralize.singular));
+            }, (_classType) => (0, Support_1.panic)("We handled this above"), (_mapType) => (0, Support_1.panic)("We handled this above"), (_objectType) => (0, Support_1.panic)("We handled this above"), (unionType) => {
+                const members = (0, collection_utils_1.setSortBy)(unionType.members, (member) => member.kind);
                 for (const memberType of members) {
                     addNames(memberType, names);
                 }
@@ -234,15 +246,16 @@ function gatherNames(graph, destructive, debugPrint) {
                 else if (ancestorNames !== undefined) {
                     const alternatives = [];
                     for (const name of names) {
-                        alternatives.push(...Array.from(ancestorNames).map(an => `${an}_${name}`));
+                        alternatives.push(...Array.from(ancestorNames).map((an) => `${an}_${name}`));
                         // FIXME: add alternatives with the suffix here, too?
-                        alternatives.push(...Array.from(ancestorNames).map(an => `${an}_${name}_${t.kind}`));
+                        alternatives.push(...Array.from(ancestorNames).map((an) => `${an}_${name}_${t.kind}`));
                         // FIXME: add alternatives with the suffix here, too?
                     }
                     ancestorAlternatives = addAlternatives(ancestorAlternatives, alternatives);
                 }
             }
-            if (alternativeSuffix !== undefined && directAlternatives !== null) {
+            if (alternativeSuffix !== undefined &&
+                directAlternatives !== null) {
                 const alternatives = [];
                 for (const name of names) {
                     // FIXME: we should only add these for names we couldn't singularize
@@ -268,13 +281,16 @@ function gatherNames(graph, destructive, debugPrint) {
             }
         }
         else {
-            (0, TypeUtils_1.matchCompoundType)(t, arrayType => {
+            (0, TypeUtils_1.matchCompoundType)(t, (arrayType) => {
                 processType(ancestor, arrayType.items, "element");
-            }, _classType => (0, Support_1.panic)("We handled this above"), _mapType => (0, Support_1.panic)("We handled this above"), _objectType => (0, Support_1.panic)("We handled this above"), unionType => {
-                const members = (0, collection_utils_1.setSortBy)(unionType.members, member => member.kind);
+            }, (_classType) => (0, Support_1.panic)("We handled this above"), (_mapType) => (0, Support_1.panic)("We handled this above"), (_objectType) => (0, Support_1.panic)("We handled this above"), (unionType) => {
+                const members = (0, collection_utils_1.setSortBy)(unionType.members, (member) => member.kind);
                 const unionHasGivenName = unionType.hasNames && !unionType.getNames().areInferred;
-                const unionIsAncestor = unionHasGivenName || (0, TypeUtils_1.nullableFromUnion)(unionType) === null;
-                const ancestorForMembers = unionIsAncestor ? unionType : ancestor;
+                const unionIsAncestor = unionHasGivenName ||
+                    (0, TypeUtils_1.nullableFromUnion)(unionType) === null;
+                const ancestorForMembers = unionIsAncestor
+                    ? unionType
+                    : ancestor;
                 for (const memberType of members) {
                     processType(ancestorForMembers, memberType, undefined);
                 }
@@ -298,7 +314,7 @@ function gatherNames(graph, destructive, debugPrint) {
         if (alternatives === undefined) {
             alternatives = new Set();
         }
-        alternatives = (0, collection_utils_1.setUnion)(alternatives, (0, collection_utils_1.setMap)(names, name => `${name}_${t.kind}`));
+        alternatives = (0, collection_utils_1.setUnion)(alternatives, (0, collection_utils_1.setMap)(names, (name) => `${name}_${t.kind}`));
         directAlternativesForType.set(t, alternatives);
     }
     for (const t of graph.allTypesUnordered()) {
@@ -317,13 +333,15 @@ function gatherNames(graph, destructive, debugPrint) {
                 alternatives = undefined;
             }
             else {
-                if (directAlternatives !== null && directAlternatives !== undefined) {
+                if (directAlternatives !== null &&
+                    directAlternatives !== undefined) {
                     alternatives = directAlternatives;
                 }
                 else {
                     alternatives = new Set();
                 }
-                if (ancestorAlternatives !== null && ancestorAlternatives !== undefined) {
+                if (ancestorAlternatives !== null &&
+                    ancestorAlternatives !== undefined) {
                     alternatives = (0, collection_utils_1.setUnion)(alternatives, ancestorAlternatives);
                 }
             }
@@ -332,4 +350,3 @@ function gatherNames(graph, destructive, debugPrint) {
         setNames(t, t.hasNames ? t.getNames().add([typeNames]) : typeNames);
     }
 }
-exports.gatherNames = gatherNames;

package/dist/Graph.js

@@ -148,7 +148,7 @@ class Graph {
             edgesArray = edges;
         }
         else {
-            edgesArray = this._nodes.map(n => Array.from(edges(n)).map(s => (0, Support_1.defined)(this._indexByNode.get(s))));
+            edgesArray = this._nodes.map((n) => Array.from(edges(n)).map((s) => (0, Support_1.defined)(this._indexByNode.get(s))));
         }
         if (invertDirection) {
             edgesArray = invertEdges(edgesArray);
@@ -163,7 +163,7 @@ class Graph {
     }
     findRoots() {
         const roots = findRoots(this._successors);
-        return new Set(roots.map(n => this._nodes[n]));
+        return new Set(roots.map((n) => this._nodes[n]));
     }
     // The subgraph starting at `root` must be acyclic.
     dfsTraversal(root, preOrder, process) {
@@ -187,7 +187,7 @@ class Graph {
     stronglyConnectedComponents() {
         const components = stronglyConnectedComponents(this._successors);
         const componentSuccessors = buildMetaSuccessors(this._successors, components);
-        return new Graph(components.map(ns => (0, collection_utils_1.setMap)(ns, n => this._nodes[n])), false, componentSuccessors);
+        return new Graph(components.map((ns) => (0, collection_utils_1.setMap)(ns, (n) => this._nodes[n])), false, componentSuccessors);
     }
     makeDot(includeNode, nodeLabel) {
         const lines = [];

package/dist/GraphRewriting.d.ts

@@ -1,8 +1,8 @@
 import { type TypeAttributes } from "./attributes/TypeAttributes";
-import { type ClassProperty, type MaybeTypeIdentity, type PrimitiveTypeKind, type Type } from "./Type";
+import type { ClassProperty, MaybeTypeIdentity, PrimitiveTypeKind, Type } from "./Type";
 import { TypeBuilder } from "./Type/TypeBuilder";
-import { type StringTypeMapping } from "./Type/TypeBuilderUtils";
-import { type TypeGraph } from "./Type/TypeGraph";
+import type { StringTypeMapping } from "./Type/TypeBuilderUtils";
+import type { TypeGraph } from "./Type/TypeGraph";
 import { type TypeRef } from "./Type/TypeRef";
 export interface TypeLookerUp {
     lookupTypeRefs: (typeRefs: TypeRef[], forwardingRef?: TypeRef) => TypeRef | undefined;

package/dist/GraphRewriting.js

@@ -47,12 +47,11 @@ class TypeReconstituter {
         if ((0, TypeRef_1.isTypeRef)(trefs)) {
             return this._typeBuilder.lookupTypeRefs([trefs], undefined, false);
         }
-        else {
-            const maybeRefs = Array.from(trefs).map(tref => this._typeBuilder.lookupTypeRefs([tref], undefined, false));
-            if (maybeRefs.some(tref => tref === undefined))
-                return undefined;
-            return maybeRefs;
+        const maybeRefs = Array.from(trefs).map((tref) => this._typeBuilder.lookupTypeRefs([tref], undefined, false));
+        if (maybeRefs.some((tref) => tref === undefined)) {
+            return undefined;
         }
+        return maybeRefs;
     }
     lookupMap(trefs) {
         const resultValues = this.lookup(trefs.values());
@@ -72,12 +71,10 @@ class TypeReconstituter {
         if ((0, TypeRef_1.isTypeRef)(trefs)) {
             return this._typeBuilder.reconstituteTypeRef(trefs);
         }
-        else {
-            return Array.from(trefs).map(tref => this._typeBuilder.reconstituteTypeRef(tref));
-        }
+        return Array.from(trefs).map((tref) => this._typeBuilder.reconstituteTypeRef(tref));
     }
     reconstituteMap(trefs) {
-        return (0, collection_utils_1.mapMap)(trefs, tref => this._typeBuilder.reconstituteTypeRef(tref));
+        return (0, collection_utils_1.mapMap)(trefs, (tref) => this._typeBuilder.reconstituteTypeRef(tref));
     }
     getPrimitiveType(kind) {
         this.register(this.builderForNewType().getPrimitiveType(kind, this._typeAttributes, this._forwardingRef));
@@ -247,7 +244,7 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
         const index = (0, TypeRef_1.typeRefIndex)(originalRef);
         (0, Support_1.assert)(this.reconstitutedTypes.get(index) === undefined, "Type has already been reconstituted");
         (0, Support_1.assert)(maybeForwardingRef === undefined, "We can't have a forwarding ref when we remap");
-        return this.withForwardingRef(undefined, forwardingRef => {
+        return this.withForwardingRef(undefined, (forwardingRef) => {
             this.reconstitutedTypes.set(index, forwardingRef);
             if (this.debugPrint) {
                 console.log(`${this.debugPrintIndentation}reconstituting ${index} as ${(0, TypeRef_1.typeRefIndex)(forwardingRef)}`);
@@ -265,7 +262,7 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
                 attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes((0, TypeUtils_1.combineTypeAttributesOfTypes)("union", attributeSources)));
             }
             const newAttributes = attributes;
-            const reconstituter = new TypeReconstituter(this, this.canonicalOrder, newAttributes, forwardingRef, tref => {
+            const reconstituter = new TypeReconstituter(this, this.canonicalOrder, newAttributes, forwardingRef, (tref) => {
                 (0, Support_1.assert)(tref === forwardingRef, "Reconstituted type as a different ref");
                 if (this.debugPrint) {
                     this.changeDebugPrintIndent(-1);
@@ -299,10 +296,10 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         this._reconstitutedUnions.set(set, reconstituted);
     }
     replaceSet(typesToReplace, maybeForwardingRef) {
-        return this.withForwardingRef(maybeForwardingRef, forwardingRef => {
+        return this.withForwardingRef(maybeForwardingRef, (forwardingRef) => {
             if (this.debugPrint) {
                 console.log(`${this.debugPrintIndentation}replacing set ${Array.from(typesToReplace)
-                    .map(t => t.index.toString())
+                    .map((t) => t.index.toString())
                     .join(",")} as ${(0, TypeRef_1.typeRefIndex)(forwardingRef)}`);
                 this.changeDebugPrintIndent(1);
             }
@@ -317,7 +314,7 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             if (this.debugPrint) {
                 this.changeDebugPrintIndent(-1);
                 console.log(`${this.debugPrintIndentation}replaced set ${Array.from(typesToReplace)
-                    .map(t => t.index.toString())
+                    .map((t) => t.index.toString())
                     .join(",")} as ${(0, TypeRef_1.typeRefIndex)(forwardingRef)}`);
             }
             return result;
@@ -336,7 +333,7 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         else {
             attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
         }
-        const reconstituter = new TypeReconstituter(this, this.canonicalOrder, attributes, maybeForwardingRef, tref => {
+        const reconstituter = new TypeReconstituter(this, this.canonicalOrder, attributes, maybeForwardingRef, (tref) => {
             if (this.debugPrint) {
                 this.changeDebugPrintIndent(-1);
                 console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeRef_1.typeRefIndex)(tref)}`);
@@ -378,7 +375,8 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         if (maybeRef !== undefined && maybeRef !== forwardingRef) {
             let allEqual = true;
             for (let i = 1; i < typeRefs.length; i++) {
-                if (this.reconstitutedTypes.get((0, TypeRef_1.typeRefIndex)(typeRefs[i])) !== maybeRef) {
+                if (this.reconstitutedTypes.get((0, TypeRef_1.typeRefIndex)(typeRefs[i])) !==
+                    maybeRef) {
                     allEqual = false;
                     break;
                 }
@@ -398,7 +396,8 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             return undefined;
         }
         for (let i = 1; i < typeRefs.length; i++) {
-            if (this._setsToReplaceByMember.get((0, TypeRef_1.typeRefIndex)(typeRefs[i])) !== maybeSet) {
+            if (this._setsToReplaceByMember.get((0, TypeRef_1.typeRefIndex)(typeRefs[i])) !==
+                maybeSet) {
                 return undefined;
             }
         }

package/dist/Inference.d.ts

@@ -0,0 +1,79 @@
+import type { TransformedStringTypeKind } from "./Type";
+export interface InferenceFlag {
+    description: string;
+    explanation: string;
+    negationDescription: string;
+    order: number;
+    stringType?: TransformedStringTypeKind;
+}
+export declare const inferenceFlagsObject: {
+    /** Whether to infer map types from JSON data */
+    inferMaps: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        order: number;
+    };
+    /** Whether to infer enum types from JSON data */
+    inferEnums: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        order: number;
+    };
+    /** Whether to convert UUID strings to UUID objects */
+    inferUuids: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        stringType: TransformedStringTypeKind;
+        order: number;
+    };
+    /** Whether to assume that JSON strings that look like dates are dates */
+    inferDateTimes: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        stringType: TransformedStringTypeKind;
+        order: number;
+    };
+    /** Whether to convert stringified integers to integers */
+    inferIntegerStrings: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        stringType: TransformedStringTypeKind;
+        order: number;
+    };
+    /** Whether to convert stringified booleans to boolean values */
+    inferBooleanStrings: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        stringType: TransformedStringTypeKind;
+        order: number;
+    };
+    /** Combine similar classes.  This doesn't apply to classes from a schema, only from inference. */
+    combineClasses: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        order: number;
+    };
+    /** Whether to treat $ref as references within JSON */
+    ignoreJsonRefs: {
+        description: string;
+        negationDescription: string;
+        explanation: string;
+        order: number;
+    };
+};
+export type InferenceFlagName = keyof typeof inferenceFlagsObject;
+export declare const inferenceFlagNames: InferenceFlagName[];
+export declare const inferenceFlags: {
+    [F in InferenceFlagName]: InferenceFlag;
+};
+export type InferenceFlags = {
+    [F in InferenceFlagName]: boolean;
+};
+export declare const defaultInferenceFlags: InferenceFlags;