quicktype-core 23.1.2 → 23.1.4

package/dist/ConvenienceRenderer.js

@@ -18,8 +18,8 @@ const Strings_1 = require("./support/Strings");
 const Support_1 = require("./support/Support");
 const Transformers_1 = require("./Transformers");
 const Type_1 = require("./Type");
-const TypeGraph_1 = require("./TypeGraph");
-const TypeUtils_1 = require("./TypeUtils");
+const TypeGraph_1 = require("./Type/TypeGraph");
+const TypeUtils_1 = require("./Type/TypeUtils");
 const wordWrap = (0, wordwrap_1.default)(90);
 exports.topLevelNameOrder = 1;
 const givenNameOrder = 10;

package/dist/DeclarationIR.d.ts

@@ -1,5 +1,5 @@
-import { type Type } from "./Type";
-import { type TypeGraph } from "./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/GatherNames.d.ts

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

package/dist/GatherNames.js

@@ -29,8 +29,8 @@ const pluralize = __importStar(require("pluralize"));
 const TypeNames_1 = require("./attributes/TypeNames");
 const Support_1 = require("./support/Support");
 const Transformers_1 = require("./Transformers");
-const Type_1 = require("./Type");
-const TypeUtils_1 = require("./TypeUtils");
+const Type_1 = require("./Type/Type");
+const TypeUtils_1 = require("./Type/TypeUtils");
 class UniqueQueue {
     constructor() {
         this._present = new Set();

package/dist/GraphRewriting.d.ts

@@ -1,7 +1,9 @@
 import { type TypeAttributes } from "./attributes/TypeAttributes";
 import { type ClassProperty, type MaybeTypeIdentity, type PrimitiveTypeKind, type Type } from "./Type";
-import { type StringTypeMapping, TypeBuilder } from "./TypeBuilder";
-import { type TypeGraph, type TypeRef } from "./TypeGraph";
+import { TypeBuilder } from "./Type/TypeBuilder";
+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;
     reconstituteTypeRef: (typeRef: TypeRef, attributes?: TypeAttributes, forwardingRef?: TypeRef) => TypeRef;

package/dist/GraphRewriting.js

@@ -4,10 +4,9 @@ exports.GraphRewriteBuilder = exports.GraphRemapBuilder = exports.BaseGraphRewri
 const collection_utils_1 = require("collection-utils");
 const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
-// eslint-disable-next-line import/no-cycle
-const TypeBuilder_1 = require("./TypeBuilder");
-const TypeGraph_1 = require("./TypeGraph");
-const TypeUtils_1 = require("./TypeUtils");
+const TypeBuilder_1 = require("./Type/TypeBuilder");
+const TypeRef_1 = require("./Type/TypeRef");
+const TypeUtils_1 = require("./Type/TypeUtils");
 class TypeReconstituter {
     constructor(_typeBuilder, _makeClassUnique, _typeAttributes, _forwardingRef, _register) {
         this._typeBuilder = _typeBuilder;
@@ -45,7 +44,7 @@ class TypeReconstituter {
     }
     lookup(trefs) {
         (0, Support_1.assert)(!this._wasUsed, "Cannot lookup constituents after building type");
-        if ((0, TypeGraph_1.isTypeRef)(trefs)) {
+        if ((0, TypeRef_1.isTypeRef)(trefs)) {
             return this._typeBuilder.lookupTypeRefs([trefs], undefined, false);
         }
         else {
@@ -70,7 +69,7 @@ class TypeReconstituter {
     }
     reconstitute(trefs) {
         (0, Support_1.assert)(this._wasUsed, "Cannot reconstitute constituents before building type");
-        if ((0, TypeGraph_1.isTypeRef)(trefs)) {
+        if ((0, TypeRef_1.isTypeRef)(trefs)) {
             return this._typeBuilder.reconstituteTypeRef(trefs);
         }
         else {
@@ -142,7 +141,7 @@ class TypeReconstituter {
 exports.TypeReconstituter = TypeReconstituter;
 class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
     constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrint) {
-        super(originalGraph.serial + 1, stringTypeMapping, alphabetizeProperties, false, false, graphHasProvenanceAttributes);
+        super(stringTypeMapping, alphabetizeProperties, false, false, graphHasProvenanceAttributes);
         this.originalGraph = originalGraph;
         this.debugPrint = debugPrint;
         this.reconstitutedTypes = new Map();
@@ -177,10 +176,10 @@ class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
     assertTypeRefsToReconstitute(typeRefs, forwardingRef) {
         (0, Support_1.assert)(typeRefs.length > 0, "Must have at least one type to reconstitute");
         for (const originalRef of typeRefs) {
-            (0, TypeGraph_1.assertTypeRefGraph)(originalRef, this.originalGraph);
+            (0, TypeRef_1.assertTypeRefGraph)(originalRef, this.originalGraph);
         }
         if (forwardingRef !== undefined) {
-            (0, TypeGraph_1.assertTypeRefGraph)(forwardingRef, this.typeGraph);
+            (0, TypeRef_1.assertTypeRefGraph)(forwardingRef, this.typeGraph);
         }
     }
     changeDebugPrintIndent(delta) {
@@ -221,7 +220,7 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
         return undefined;
     }
     getMapTarget(tref) {
-        const maybeType = this._map.get((0, TypeGraph_1.derefTypeRef)(tref, this.originalGraph));
+        const maybeType = this._map.get((0, TypeRef_1.derefTypeRef)(tref, this.originalGraph));
         if (maybeType === undefined)
             return tref;
         (0, Support_1.assert)(this._map.get(maybeType) === undefined, "We have a type that's remapped to a remapped type");
@@ -233,11 +232,11 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
     lookupTypeRefs(typeRefs, forwardingRef) {
         (0, Support_1.assert)(forwardingRef === undefined, "We can't have a forwarding ref when we remap");
         this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
-        const first = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(this.getMapTarget(typeRefs[0])));
+        const first = this.reconstitutedTypes.get((0, TypeRef_1.typeRefIndex)(this.getMapTarget(typeRefs[0])));
         if (first === undefined)
             return undefined;
         for (let i = 1; i < typeRefs.length; i++) {
-            const other = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(this.getMapTarget(typeRefs[i])));
+            const other = this.reconstitutedTypes.get((0, TypeRef_1.typeRefIndex)(this.getMapTarget(typeRefs[i])));
             if (first !== other)
                 return undefined;
         }
@@ -245,16 +244,16 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
     }
     forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
         originalRef = this.getMapTarget(originalRef);
-        const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
+        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 => {
             this.reconstitutedTypes.set(index, forwardingRef);
             if (this.debugPrint) {
-                console.log(`${this.debugPrintIndentation}reconstituting ${index} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
+                console.log(`${this.debugPrintIndentation}reconstituting ${index} as ${(0, TypeRef_1.typeRefIndex)(forwardingRef)}`);
                 this.changeDebugPrintIndent(1);
             }
-            const [originalType, originalAttributes] = (0, TypeGraph_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
+            const [originalType, originalAttributes] = (0, TypeRef_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
             const attributeSources = this._attributeSources.get(originalType);
             if (attributes === undefined) {
                 attributes = TypeAttributes_1.emptyTypeAttributes;
@@ -270,7 +269,7 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
                 (0, Support_1.assert)(tref === forwardingRef, "Reconstituted type as a different ref");
                 if (this.debugPrint) {
                     this.changeDebugPrintIndent(-1);
-                    console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeGraph_1.typeRefIndex)(tref)}`);
+                    console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeRef_1.typeRefIndex)(tref)}`);
                 }
             });
             originalType.reconstitute(reconstituter, this.canonicalOrder);
@@ -304,12 +303,12 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             if (this.debugPrint) {
                 console.log(`${this.debugPrintIndentation}replacing set ${Array.from(typesToReplace)
                     .map(t => t.index.toString())
-                    .join(",")} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
+                    .join(",")} as ${(0, TypeRef_1.typeRefIndex)(forwardingRef)}`);
                 this.changeDebugPrintIndent(1);
             }
             for (const t of typesToReplace) {
                 const originalRef = t.typeRef;
-                const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
+                const index = (0, TypeRef_1.typeRefIndex)(originalRef);
                 this.reconstitutedTypes.set(index, forwardingRef);
                 this._setsToReplaceByMember.delete(index);
             }
@@ -319,14 +318,14 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
                 this.changeDebugPrintIndent(-1);
                 console.log(`${this.debugPrintIndentation}replaced set ${Array.from(typesToReplace)
                     .map(t => t.index.toString())
-                    .join(",")} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
+                    .join(",")} as ${(0, TypeRef_1.typeRefIndex)(forwardingRef)}`);
             }
             return result;
         });
     }
     forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
-        const [originalType, originalAttributes] = (0, TypeGraph_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
-        const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
+        const [originalType, originalAttributes] = (0, TypeRef_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
+        const index = (0, TypeRef_1.typeRefIndex)(originalRef);
         if (this.debugPrint) {
             console.log(`${this.debugPrintIndentation}reconstituting ${index}`);
             this.changeDebugPrintIndent(1);
@@ -340,7 +339,7 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         const reconstituter = new TypeReconstituter(this, this.canonicalOrder, attributes, maybeForwardingRef, tref => {
             if (this.debugPrint) {
                 this.changeDebugPrintIndent(-1);
-                console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeGraph_1.typeRefIndex)(tref)}`);
+                console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeRef_1.typeRefIndex)(tref)}`);
             }
             if (maybeForwardingRef !== undefined) {
                 (0, Support_1.assert)(tref === maybeForwardingRef, "We didn't pass the forwarding ref");
@@ -375,11 +374,11 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
         // Check whether we have already reconstituted them.  That means ensuring
         // that they all have the same target type.
-        let maybeRef = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(typeRefs[0]));
+        let maybeRef = this.reconstitutedTypes.get((0, TypeRef_1.typeRefIndex)(typeRefs[0]));
         if (maybeRef !== undefined && maybeRef !== forwardingRef) {
             let allEqual = true;
             for (let i = 1; i < typeRefs.length; i++) {
-                if (this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(typeRefs[i])) !== maybeRef) {
+                if (this.reconstitutedTypes.get((0, TypeRef_1.typeRefIndex)(typeRefs[i])) !== maybeRef) {
                     allEqual = false;
                     break;
                 }
@@ -394,12 +393,12 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             return this.forwardIfNecessary(forwardingRef, maybeRef);
         }
         // Is this set requested to be replaced?  If not, we're out of options.
-        const maybeSet = this._setsToReplaceByMember.get((0, TypeGraph_1.typeRefIndex)(typeRefs[0]));
+        const maybeSet = this._setsToReplaceByMember.get((0, TypeRef_1.typeRefIndex)(typeRefs[0]));
         if (maybeSet === undefined) {
             return undefined;
         }
         for (let i = 1; i < typeRefs.length; i++) {
-            if (this._setsToReplaceByMember.get((0, TypeGraph_1.typeRefIndex)(typeRefs[i])) !== maybeSet) {
+            if (this._setsToReplaceByMember.get((0, TypeRef_1.typeRefIndex)(typeRefs[i])) !== maybeSet) {
                 return undefined;
             }
         }

package/dist/MakeTransformations.d.ts

@@ -1,4 +1,4 @@
 import { type RunContext } from "./Run";
 import { type TargetLanguage } from "./TargetLanguage";
-import { type TypeGraph } from "./TypeGraph";
+import { type TypeGraph } from "./Type/TypeGraph";
 export declare function makeTransformations(ctx: RunContext, graph: TypeGraph, targetLanguage: TargetLanguage): TypeGraph;

package/dist/MakeTransformations.js

@@ -8,11 +8,11 @@ const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
 const Transformers_1 = require("./Transformers");
 const Type_1 = require("./Type");
-const TypeGraph_1 = require("./TypeGraph");
+const TypeRef_1 = require("./Type/TypeRef");
 function transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations) {
     const transformation = new Transformers_1.Transformation(graph, reconstitutedTargetType, transformer);
     if (debugPrintTransformations) {
-        console.log(`transformation for ${(0, TypeGraph_1.typeRefIndex)(reconstitutedTargetType)}:`);
+        console.log(`transformation for ${(0, TypeRef_1.typeRefIndex)(reconstitutedTargetType)}:`);
         transformation.debugPrint();
         console.log("reverse:");
         transformation.reverse.debugPrint();

package/dist/Renderer.d.ts

@@ -3,7 +3,7 @@ import { type Name, type Namespace } from "./Naming";
 import { type Source, type Sourcelike } from "./Source";
 import { type Comment } from "./support/Comments";
 import { type TargetLanguage } from "./TargetLanguage";
-import { type TypeGraph } from "./TypeGraph";
+import { type TypeGraph } from "./Type/TypeGraph";
 export interface RenderResult {
     names: ReadonlyMap<Name, string>;
     sources: ReadonlyMap<string, Source>;

package/dist/RendererOptions/types.d.ts

@@ -1,9 +1,10 @@
 import type { EnumOption, Option } from "./index";
 /**
  * Primary options show up in the web UI in the "Language" settings tab,
- * secondary options in "Other".
+ * Secondary options in "Other".
+ * CLI is only for cli
  */
-export type OptionKind = "primary" | "secondary";
+export type OptionKind = "primary" | "secondary" | "cli";
 export interface OptionDefinition<Name extends string = string, T = unknown> {
     alias?: string;
     defaultOption?: boolean;

package/dist/Run.d.ts

@@ -5,7 +5,7 @@ import { type SerializedRenderResult } from "./Source";
 import { type Comment } from "./support/Comments";
 import { type MultiFileRenderResult, type TargetLanguage } from "./TargetLanguage";
 import { type TransformedStringTypeKind } from "./Type";
-import { type StringTypeMapping } from "./TypeBuilder";
+import { type StringTypeMapping } from "./Type/TypeBuilderUtils";
 export declare function getTargetLanguage(nameOrInstance: LanguageName | TargetLanguage): TargetLanguage;
 export interface InferenceFlag {
     description: string;

package/dist/Run.js

@@ -48,8 +48,9 @@ const InferMaps_1 = require("./rewrites/InferMaps");
 const ReplaceObjectType_1 = require("./rewrites/ReplaceObjectType");
 const ResolveIntersections_1 = require("./rewrites/ResolveIntersections");
 const Support_1 = require("./support/Support");
-const TypeBuilder_1 = require("./TypeBuilder");
-const TypeGraph_1 = require("./TypeGraph");
+const TypeBuilder_1 = require("./Type/TypeBuilder");
+const TypeGraph_1 = require("./Type/TypeGraph");
+const TypeGraphUtils_1 = require("./Type/TypeGraphUtils");
 function getTargetLanguage(nameOrInstance) {
     if (typeof nameOrInstance === "object") {
         return nameOrInstance;
@@ -208,7 +209,8 @@ class Run {
         const targetLanguage = getTargetLanguage(this._options.lang);
         const stringTypeMapping = this.stringTypeMapping;
         const conflateNumbers = !targetLanguage.supportsUnionsWithBothNumberTypes;
-        const typeBuilder = new TypeBuilder_1.TypeBuilder(0, stringTypeMapping, this._options.alphabetizeProperties, this._options.allPropertiesOptional, this._options.checkProvenance, false);
+        const typeBuilder = new TypeBuilder_1.TypeBuilder(stringTypeMapping, this._options.alphabetizeProperties, this._options.allPropertiesOptional, this._options.checkProvenance, false);
+        typeBuilder.typeGraph = new TypeGraph_1.TypeGraph(typeBuilder, 0, this._options.checkProvenance);
         return { targetLanguage, stringTypeMapping, conflateNumbers, typeBuilder };
     }
     makeGraph(allInputs) {
@@ -234,7 +236,7 @@ class Run {
         }
         const debugPrintReconstitution = this.debugPrintReconstitution;
         if (typeBuilder.didAddForwardingIntersection || !this._options.ignoreJsonRefs) {
-            this.time("remove indirection intersections", () => (graph = (0, TypeGraph_1.removeIndirectionIntersections)(graph, stringTypeMapping, debugPrintReconstitution)));
+            this.time("remove indirection intersections", () => (graph = (0, TypeGraphUtils_1.removeIndirectionIntersections)(graph, stringTypeMapping, debugPrintReconstitution)));
         }
         let unionsDone = false;
         if (allInputs.needSchemaProcessing || !this._options.ignoreJsonRefs) {
@@ -281,9 +283,9 @@ class Run {
         if (allInputs.needSchemaProcessing) {
             this.time("flatten strings", () => (graph = (0, FlattenStrings_1.flattenStrings)(graph, stringTypeMapping, debugPrintReconstitution)));
         }
-        this.time("none to any", () => (graph = (0, TypeGraph_1.noneToAny)(graph, stringTypeMapping, debugPrintReconstitution)));
+        this.time("none to any", () => (graph = (0, TypeGraphUtils_1.noneToAny)(graph, stringTypeMapping, debugPrintReconstitution)));
         if (!targetLanguage.supportsOptionalClassProperties) {
-            this.time("optional to nullable", () => (graph = (0, TypeGraph_1.optionalToNullable)(graph, stringTypeMapping, debugPrintReconstitution)));
+            this.time("optional to nullable", () => (graph = (0, TypeGraphUtils_1.optionalToNullable)(graph, stringTypeMapping, debugPrintReconstitution)));
         }
         this.time("fixed point", () => (graph = graph.rewriteFixedPoint(false, debugPrintReconstitution)));
         this.time("make transformations", () => (graph = (0, MakeTransformations_1.makeTransformations)(this, graph, targetLanguage)));

package/dist/TargetLanguage.d.ts

@@ -3,9 +3,9 @@ import { type RenderContext, type Renderer } from "./Renderer";
 import { type Option, type OptionDefinition } from "./RendererOptions";
 import { type SerializedRenderResult } from "./Source";
 import { type Comment } from "./support/Comments";
-import { type Type } from "./Type";
-import { type StringTypeMapping } from "./TypeBuilder";
-import { type TypeGraph } from "./TypeGraph";
+import { type Type } from "./Type/Type";
+import { type StringTypeMapping } from "./Type/TypeBuilderUtils";
+import { type TypeGraph } from "./Type/TypeGraph";
 import { type FixMeOptionsType } from "./types";
 export type MultiFileRenderResult = ReadonlyMap<string, SerializedRenderResult>;
 export interface LanguageConfig {

package/dist/Transformers.d.ts

@@ -1,7 +1,8 @@
 import { TypeAttributeKind } from "./attributes/TypeAttributes";
 import { type BaseGraphRewriteBuilder } from "./GraphRewriting";
 import { EnumType, PrimitiveType, type Type, UnionType } from "./Type";
-import { type TypeGraph, type TypeRef } from "./TypeGraph";
+import { type TypeGraph } from "./Type/TypeGraph";
+import { type TypeRef } from "./Type/TypeRef";
 export declare abstract class Transformer {
     readonly kind: string;
     protected readonly graph: TypeGraph;

package/dist/Transformers.js

@@ -5,7 +5,7 @@ const collection_utils_1 = require("collection-utils");
 const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
 const Type_1 = require("./Type");
-const TypeGraph_1 = require("./TypeGraph");
+const TypeRef_1 = require("./Type/TypeRef");
 function debugStringForType(t) {
     const target = followTargetType(t);
     if (t === target) {
@@ -23,7 +23,7 @@ class Transformer {
         this.sourceTypeRef = sourceTypeRef;
     }
     get sourceType() {
-        return (0, TypeGraph_1.derefTypeRef)(this.sourceTypeRef, this.graph);
+        return (0, TypeRef_1.derefTypeRef)(this.sourceTypeRef, this.graph);
     }
     /** This must return a newly constructed set. */
     getChildren() {
@@ -177,7 +177,7 @@ class ArrayDecodingTransformer extends ProducerTransformer {
         return false;
     }
     get itemTargetType() {
-        return (0, TypeGraph_1.derefTypeRef)(this._itemTargetTypeRef, this.graph);
+        return (0, TypeRef_1.derefTypeRef)(this._itemTargetTypeRef, this.graph);
     }
     reverse(targetTypeRef, continuationTransformer) {
         if (continuationTransformer !== undefined) {
@@ -233,7 +233,7 @@ class ArrayEncodingTransformer extends Transformer {
         return false;
     }
     get itemTargetType() {
-        return (0, TypeGraph_1.derefTypeRef)(this._itemTargetTypeRef, this.graph);
+        return (0, TypeRef_1.derefTypeRef)(this._itemTargetTypeRef, this.graph);
     }
     reverse(_targetTypeRef, _continuationTransformer) {
         return (0, Support_1.panic)("Can't reverse array encoding transformer");
@@ -487,7 +487,7 @@ class UnionMemberMatchTransformer extends MatchTransformer {
         this.memberTypeRef = memberTypeRef;
     }
     get sourceType() {
-        const t = (0, TypeGraph_1.derefTypeRef)(this.sourceTypeRef, this.graph);
+        const t = (0, TypeRef_1.derefTypeRef)(this.sourceTypeRef, this.graph);
         if (!(t instanceof Type_1.UnionType)) {
             return (0, Support_1.panic)("The source of a union member match transformer must be a union type");
         }
@@ -497,7 +497,7 @@ class UnionMemberMatchTransformer extends MatchTransformer {
         return true;
     }
     get memberType() {
-        return (0, TypeGraph_1.derefTypeRef)(this.memberTypeRef, this.graph);
+        return (0, TypeRef_1.derefTypeRef)(this.memberTypeRef, this.graph);
     }
     getChildren() {
         return super.getChildren().add(this.memberType);
@@ -533,7 +533,7 @@ class StringMatchTransformer extends MatchTransformer {
         this.stringCase = stringCase;
     }
     get sourceType() {
-        const t = (0, TypeGraph_1.derefTypeRef)(this.sourceTypeRef, this.graph);
+        const t = (0, TypeRef_1.derefTypeRef)(this.sourceTypeRef, this.graph);
         if (!(t instanceof Type_1.EnumType) && !(t instanceof Type_1.PrimitiveType && t.kind === "string")) {
             return (0, Support_1.panic)("The source of a string match transformer must be an enum or string type");
         }
@@ -744,7 +744,7 @@ class Transformation {
         return this.transformer.sourceType;
     }
     get targetType() {
-        return (0, TypeGraph_1.derefTypeRef)(this._targetTypeRef, this._graph);
+        return (0, TypeRef_1.derefTypeRef)(this._targetTypeRef, this._graph);
     }
     get reverse() {
         return new Transformation(this._graph, this.transformer.sourceTypeRef, this.transformer.reverse(this._targetTypeRef, undefined));

package/dist/Type/ProvenanceTypeAttributeKind.d.ts

@@ -0,0 +1,2 @@
+import { TypeAttributeKind } from "../attributes/TypeAttributes";
+export declare const provenanceTypeAttributeKind: TypeAttributeKind<Set<number>>;

package/dist/Type/ProvenanceTypeAttributeKind.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provenanceTypeAttributeKind = void 0;
+const collection_utils_1 = require("collection-utils");
+const TypeAttributes_1 = require("../attributes/TypeAttributes");
+// FIXME: Don't infer provenance.  All original types should be present in
+// non-inferred form in the final graph.
+class ProvenanceTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
+    constructor() {
+        super("provenance");
+    }
+    appliesToTypeKind(_kind) {
+        return true;
+    }
+    combine(arr) {
+        return (0, collection_utils_1.setUnionManyInto)(new Set(), arr);
+    }
+    makeInferred(p) {
+        return p;
+    }
+    stringify(p) {
+        return Array.from(p)
+            .sort()
+            .map(i => i.toString())
+            .join(",");
+    }
+}
+exports.provenanceTypeAttributeKind = new ProvenanceTypeAttributeKind();

package/dist/Type/TransformedStringType.d.ts

@@ -0,0 +1,62 @@
+import { type TypeAttributes } from "../attributes/TypeAttributes";
+import { uriInferenceAttributesProducer } from "../attributes/URIAttributes";
+import { type Type } from "./Type";
+/**
+ * `jsonSchema` is the `format` to be used to represent this string type in
+ * JSON Schema.  It's ok to "invent" a new one if the JSON Schema standard doesn't
+ * have that particular type yet.
+ *
+ * For transformed type kinds that map to an existing primitive type, `primitive`
+ * must specify that type kind.
+ */
+export interface TransformedStringTypeTargets {
+    attributesProducer?: (s: string) => TypeAttributes;
+    jsonSchema: string;
+    primitive: PrimitiveNonStringTypeKind | undefined;
+}
+/**
+ * All the transformed string type kinds and the JSON Schema formats and
+ * primitive type kinds they map to.  Not all transformed string types map to
+ * primitive types.  Date-time types, for example, stand on their own, but
+ * stringified integers map to integers.
+ */
+declare const transformedStringTypeTargetTypeKinds: {
+    date: {
+        jsonSchema: string;
+        primitive: undefined;
+    };
+    time: {
+        jsonSchema: string;
+        primitive: undefined;
+    };
+    "date-time": {
+        jsonSchema: string;
+        primitive: undefined;
+    };
+    uuid: {
+        jsonSchema: string;
+        primitive: undefined;
+    };
+    uri: {
+        jsonSchema: string;
+        primitive: undefined;
+        attributesProducer: typeof uriInferenceAttributesProducer;
+    };
+    "integer-string": TransformedStringTypeTargets;
+    "bool-string": TransformedStringTypeTargets;
+};
+export declare const transformedStringTypeTargetTypeKindsMap: Map<string, TransformedStringTypeTargets>;
+export type TransformedStringTypeKind = keyof typeof transformedStringTypeTargetTypeKinds;
+export type PrimitiveStringTypeKind = "string" | TransformedStringTypeKind;
+export type PrimitiveNonStringTypeKind = "none" | "any" | "null" | "bool" | "integer" | "double";
+export type PrimitiveTypeKind = PrimitiveNonStringTypeKind | PrimitiveStringTypeKind;
+export type NamedTypeKind = "class" | "enum" | "union";
+export type TypeKind = PrimitiveTypeKind | NamedTypeKind | "array" | "object" | "map" | "intersection";
+export type ObjectTypeKind = "object" | "map" | "class";
+export declare const transformedStringTypeKinds: ReadonlySet<"date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string">;
+export declare function isPrimitiveStringTypeKind(kind: string): kind is PrimitiveStringTypeKind;
+export declare function targetTypeKindForTransformedStringTypeKind(kind: PrimitiveStringTypeKind): PrimitiveNonStringTypeKind | undefined;
+export declare function isNumberTypeKind(kind: TypeKind): kind is "integer" | "double";
+export declare function isPrimitiveTypeKind(kind: TypeKind): kind is PrimitiveTypeKind;
+export declare function triviallyStructurallyCompatible(x: Type, y: Type): boolean;
+export {};

package/dist/Type/TransformedStringType.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triviallyStructurallyCompatible = exports.isPrimitiveTypeKind = exports.isNumberTypeKind = exports.targetTypeKindForTransformedStringTypeKind = exports.isPrimitiveStringTypeKind = exports.transformedStringTypeKinds = exports.transformedStringTypeTargetTypeKindsMap = void 0;
+const collection_utils_1 = require("collection-utils");
+const URIAttributes_1 = require("../attributes/URIAttributes");
+/**
+ * All the transformed string type kinds and the JSON Schema formats and
+ * primitive type kinds they map to.  Not all transformed string types map to
+ * primitive types.  Date-time types, for example, stand on their own, but
+ * stringified integers map to integers.
+ */
+const transformedStringTypeTargetTypeKinds = {
+    "date": { jsonSchema: "date", primitive: undefined },
+    "time": { jsonSchema: "time", primitive: undefined },
+    "date-time": { jsonSchema: "date-time", primitive: undefined },
+    "uuid": { jsonSchema: "uuid", primitive: undefined },
+    "uri": { jsonSchema: "uri", primitive: undefined, attributesProducer: URIAttributes_1.uriInferenceAttributesProducer },
+    "integer-string": { jsonSchema: "integer", primitive: "integer" },
+    "bool-string": { jsonSchema: "boolean", primitive: "bool" }
+};
+exports.transformedStringTypeTargetTypeKindsMap = (0, collection_utils_1.mapFromObject)(transformedStringTypeTargetTypeKinds);
+exports.transformedStringTypeKinds = new Set(Object.getOwnPropertyNames(transformedStringTypeTargetTypeKinds));
+function isPrimitiveStringTypeKind(kind) {
+    return kind === "string" || (0, collection_utils_1.hasOwnProperty)(transformedStringTypeTargetTypeKinds, kind);
+}
+exports.isPrimitiveStringTypeKind = isPrimitiveStringTypeKind;
+function targetTypeKindForTransformedStringTypeKind(kind) {
+    const target = exports.transformedStringTypeTargetTypeKindsMap.get(kind);
+    if (target === undefined)
+        return undefined;
+    return target.primitive;
+}
+exports.targetTypeKindForTransformedStringTypeKind = targetTypeKindForTransformedStringTypeKind;
+function isNumberTypeKind(kind) {
+    return kind === "integer" || kind === "double";
+}
+exports.isNumberTypeKind = isNumberTypeKind;
+function isPrimitiveTypeKind(kind) {
+    if (isPrimitiveStringTypeKind(kind))
+        return true;
+    if (isNumberTypeKind(kind))
+        return true;
+    return kind === "none" || kind === "any" || kind === "null" || kind === "bool";
+}
+exports.isPrimitiveTypeKind = isPrimitiveTypeKind;
+function triviallyStructurallyCompatible(x, y) {
+    if (x.index === y.index)
+        return true;
+    if (x.kind === "none" || y.kind === "none")
+        return true;
+    return false;
+}
+exports.triviallyStructurallyCompatible = triviallyStructurallyCompatible;