quicktype 17.0.4 → 17.0.5

package/dist/quicktype-core/input/FetchingJSONSchemaStore.js

@@ -1,18 +1,26 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FetchingJSONSchemaStore = void 0;
 const JSONSchemaStore_1 = require("./JSONSchemaStore");
 const __1 = require("..");
 const NodeIO_1 = require("./io/NodeIO");
 class FetchingJSONSchemaStore extends JSONSchemaStore_1.JSONSchemaStore {
-    _httpHeaders;
     constructor(_httpHeaders) {
         super();
         this._httpHeaders = _httpHeaders;
     }
-    async fetch(address) {
-        // console.log(`Fetching ${address}`);
-        return (0, __1.parseJSON)(await (0, NodeIO_1.readFromFileOrURL)(address, this._httpHeaders), "JSON Schema", address);
+    fetch(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log(`Fetching ${address}`);
+            return __1.parseJSON(yield NodeIO_1.readFromFileOrURL(address, this._httpHeaders), "JSON Schema", address);
+        });
     }
 }
 exports.FetchingJSONSchemaStore = FetchingJSONSchemaStore;

package/dist/quicktype-core/input/Inference.d.ts

@@ -3,8 +3,8 @@ import { TypeBuilder } from "../TypeBuilder";
 import { UnionAccumulator } from "../UnionBuilder";
 import { TypeAttributes } from "../attributes/TypeAttributes";
 import { TypeRef } from "../TypeGraph";
-export type NestedValueArray = any;
-export type Accumulator = UnionAccumulator<NestedValueArray, NestedValueArray>;
+export declare type NestedValueArray = any;
+export declare type Accumulator = UnionAccumulator<NestedValueArray, NestedValueArray>;
 export declare class TypeInference {
     private readonly _cjson;
     private readonly _typeBuilder;

package/dist/quicktype-core/input/Inference.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeInference = void 0;
 const CompressedJSON_1 = require("./CompressedJSON");
 const Support_1 = require("../support/Support");
 const UnionBuilder_1 = require("../UnionBuilder");
@@ -31,8 +30,6 @@ function forEachValueInNestedValueArray(va, f) {
     });
 }
 class InferenceUnionBuilder extends UnionBuilder_1.UnionBuilder {
-    _typeInference;
-    _fixed;
     constructor(typeBuilder, _typeInference, _fixed) {
         super(typeBuilder);
         this._typeInference = _typeInference;
@@ -49,11 +46,6 @@ function canBeEnumCase(_s) {
     return true;
 }
 class TypeInference {
-    _cjson;
-    _typeBuilder;
-    _inferMaps;
-    _inferEnums;
-    _refIntersections;
     constructor(_cjson, _typeBuilder, _inferMaps, _inferEnums) {
         this._cjson = _cjson;
         this._typeBuilder = _typeBuilder;
@@ -62,7 +54,7 @@ class TypeInference {
     }
     addValuesToAccumulator(valueArray, accumulator) {
         forEachValueInNestedValueArray(valueArray, value => {
-            const t = (0, CompressedJSON_1.valueTag)(value);
+            const t = CompressedJSON_1.valueTag(value);
             switch (t) {
                 case CompressedJSON_1.Tag.Null:
                     accumulator.addPrimitive("null", TypeAttributes_1.emptyTypeAttributes);
@@ -107,19 +99,19 @@ class TypeInference {
                 }
                 case CompressedJSON_1.Tag.TransformedString: {
                     const s = this._cjson.getStringForValue(value);
-                    const kind = (0, StringTypes_1.inferTransformedStringTypeKindForString)(s, this._cjson.dateTimeRecognizer);
+                    const kind = StringTypes_1.inferTransformedStringTypeKindForString(s, this._cjson.dateTimeRecognizer);
                     if (kind === undefined) {
-                        return (0, Support_1.panic)("TransformedString does not have a kind");
+                        return Support_1.panic("TransformedString does not have a kind");
                     }
-                    const producer = (0, Support_1.defined)(Type_1.transformedStringTypeTargetTypeKindsMap.get(kind)).attributesProducer;
+                    const producer = Support_1.defined(Type_1.transformedStringTypeTargetTypeKindsMap.get(kind)).attributesProducer;
                     if (producer === undefined) {
-                        return (0, Support_1.panic)("TransformedString does not have attribute producer");
+                        return Support_1.panic("TransformedString does not have attribute producer");
                     }
                     accumulator.addStringType("string", producer(s), new StringTypes_1.StringTypes(new Map(), new Set([kind])));
                     break;
                 }
                 default:
-                    return (0, Support_1.assertNever)(t);
+                    return Support_1.assertNever(t);
             }
         });
     }
@@ -129,25 +121,25 @@ class TypeInference {
     }
     resolveRef(ref, topLevel) {
         if (!ref.startsWith("#/")) {
-            return (0, Messages_1.messageError)("InferenceJSONReferenceNotRooted", { reference: ref });
+            return Messages_1.messageError("InferenceJSONReferenceNotRooted", { reference: ref });
         }
         const parts = ref.split("/").slice(1);
         const graph = this._typeBuilder.typeGraph;
         let tref = topLevel;
         for (const part of parts) {
-            let t = (0, TypeGraph_1.derefTypeRef)(tref, graph);
+            let t = TypeGraph_1.derefTypeRef(tref, graph);
             if (t instanceof Type_1.UnionType) {
-                const nullable = (0, TypeUtils_1.nullableFromUnion)(t);
+                const nullable = TypeUtils_1.nullableFromUnion(t);
                 if (nullable === null) {
                     // FIXME: handle unions
-                    return (0, Messages_1.messageError)("InferenceJSONReferenceToUnion", { reference: ref });
+                    return Messages_1.messageError("InferenceJSONReferenceToUnion", { reference: ref });
                 }
                 t = nullable;
             }
             if (t instanceof Type_1.ClassType) {
                 const cp = t.getProperties().get(part);
                 if (cp === undefined) {
-                    return (0, Messages_1.messageError)("InferenceJSONReferenceWrongProperty", { reference: ref });
+                    return Messages_1.messageError("InferenceJSONReferenceWrongProperty", { reference: ref });
                 }
                 tref = cp.typeRef;
             }
@@ -156,24 +148,24 @@ class TypeInference {
             }
             else if (t instanceof Type_1.ArrayType) {
                 if (part.match("^[0-9]+$") === null) {
-                    return (0, Messages_1.messageError)("InferenceJSONReferenceInvalidArrayIndex", { reference: ref });
+                    return Messages_1.messageError("InferenceJSONReferenceInvalidArrayIndex", { reference: ref });
                 }
                 tref = t.items.typeRef;
             }
             else {
-                return (0, Messages_1.messageError)("InferenceJSONReferenceWrongProperty", { reference: ref });
+                return Messages_1.messageError("InferenceJSONReferenceWrongProperty", { reference: ref });
             }
         }
         return tref;
     }
     inferTopLevelType(typeAttributes, valueArray, fixed) {
-        (0, Support_1.assert)(this._refIntersections === undefined, "Didn't reset ref intersections - nested invocations?");
+        Support_1.assert(this._refIntersections === undefined, "Didn't reset ref intersections - nested invocations?");
         if (this._cjson.handleRefs) {
             this._refIntersections = [];
         }
         const topLevel = this.inferType(typeAttributes, valueArray, fixed);
         if (this._cjson.handleRefs) {
-            for (const [tref, refs] of (0, Support_1.defined)(this._refIntersections)) {
+            for (const [tref, refs] of Support_1.defined(this._refIntersections)) {
                 const resolved = refs.map(r => this.resolveRef(r, topLevel));
                 this._typeBuilder.setSetOperationMembers(tref, new Set(resolved));
             }
@@ -206,11 +198,11 @@ class TypeInference {
         });
         if (this._cjson.handleRefs && propertyNames.length === 1 && propertyNames[0] === "$ref") {
             const values = propertyValues["$ref"];
-            if (values.every(v => (0, CompressedJSON_1.valueTag)(v) === CompressedJSON_1.Tag.InternedString)) {
+            if (values.every(v => CompressedJSON_1.valueTag(v) === CompressedJSON_1.Tag.InternedString)) {
                 const allRefs = values.map(v => this._cjson.getStringForValue(v));
                 // FIXME: Add is-ref attribute
                 const tref = this._typeBuilder.getUniqueIntersectionType(typeAttributes, undefined);
-                (0, Support_1.defined)(this._refIntersections).push([tref, allRefs]);
+                Support_1.defined(this._refIntersections).push([tref, allRefs]);
                 return tref;
             }
         }

package/dist/quicktype-core/input/Inputs.d.ts

@@ -42,7 +42,7 @@ export declare class InputData {
     addSourceSync<T>(kind: string, source: T, makeInput: () => Input<T>): void;
     addTypes(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): Promise<void>;
     addTypesSync(ctx: RunContext, typeBuilder: TypeBuilder, inferMaps: boolean, inferEnums: boolean, fixedTopLevels: boolean): void;
-    get needIR(): boolean;
-    get needSchemaProcessing(): boolean;
+    readonly needIR: boolean;
+    readonly needSchemaProcessing: boolean;
     singleStringSchemaSource(): string | undefined;
 }

package/dist/quicktype-core/input/Inputs.js

@@ -1,6 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputData = exports.jsonInputForTargetLanguage = exports.JSONInput = void 0;
 const collection_utils_1 = require("collection-utils");
 const CompressedJSON_1 = require("./CompressedJSON");
 const Support_1 = require("../support/Support");
@@ -10,21 +17,20 @@ const Description_1 = require("../attributes/Description");
 const Inference_1 = require("./Inference");
 const All_1 = require("../language/All");
 function messageParseError(name, description, e) {
-    return (0, Messages_1.messageError)("MiscJSONParseError", {
-        description: (0, collection_utils_1.withDefault)(description, "input"),
+    return Messages_1.messageError("MiscJSONParseError", {
+        description: collection_utils_1.withDefault(description, "input"),
         address: name,
-        message: (0, Support_1.errorMessage)(e)
+        message: Support_1.errorMessage(e)
     });
 }
 class JSONInput {
-    _compressedJSON;
-    kind = "json";
-    needIR = true;
-    needSchemaProcessing = false;
-    _topLevels = new Map();
     /* tslint:disable:no-unused-variable */
     constructor(_compressedJSON) {
         this._compressedJSON = _compressedJSON;
+        this.kind = "json";
+        this.needIR = true;
+        this.needSchemaProcessing = false;
+        this._topLevels = new Map();
     }
     addSample(topLevelName, sample) {
         let topLevel = this._topLevels.get(topLevelName);
@@ -37,7 +43,7 @@ class JSONInput {
     setDescription(topLevelName, description) {
         let topLevel = this._topLevels.get(topLevelName);
         if (topLevel === undefined) {
-            return (0, Support_1.panic)("Trying to set description for a top-level that doesn't exist");
+            return Support_1.panic("Trying to set description for a top-level that doesn't exist");
         }
         topLevel.description = description;
     }
@@ -49,15 +55,17 @@ class JSONInput {
             }
         }
     }
-    async addSource(source) {
-        const { name, samples, description } = source;
-        try {
-            const values = await (0, collection_utils_1.arrayMapSync)(samples, async (s) => await this._compressedJSON.parse(s));
-            this.addSamples(name, values, description);
-        }
-        catch (e) {
-            return messageParseError(name, description, e);
-        }
+    addSource(source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name, samples, description } = source;
+            try {
+                const values = yield collection_utils_1.arrayMapSync(samples, (s) => __awaiter(this, void 0, void 0, function* () { return yield this._compressedJSON.parse(s); }));
+                this.addSamples(name, values, description);
+            }
+            catch (e) {
+                return messageParseError(name, description, e);
+            }
+        });
     }
     addSourceSync(source) {
         const { name, samples, description } = source;
@@ -72,13 +80,15 @@ class JSONInput {
     singleStringSchemaSource() {
         return undefined;
     }
-    async addTypes(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels) {
-        return this.addTypesSync(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels);
+    addTypes(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.addTypesSync(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels);
+        });
     }
     addTypesSync(_ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels) {
         const inference = new Inference_1.TypeInference(this._compressedJSON, typeBuilder, inferMaps, inferEnums);
         for (const [name, { samples, description }] of this._topLevels) {
-            const tref = inference.inferTopLevelType((0, TypeNames_1.makeNamesTypeAttributes)(name, false), samples, fixedTopLevels);
+            const tref = inference.inferTopLevelType(TypeNames_1.makeNamesTypeAttributes(name, false), samples, fixedTopLevels);
             typeBuilder.addTopLevel(name, tref);
             if (description !== undefined) {
                 const attributes = Description_1.descriptionTypeAttributeKind.makeAttributes(new Set([description]));
@@ -90,38 +100,44 @@ class JSONInput {
 exports.JSONInput = JSONInput;
 function jsonInputForTargetLanguage(targetLanguage, languages, handleJSONRefs = false) {
     if (typeof targetLanguage === "string") {
-        targetLanguage = (0, Support_1.defined)((0, All_1.languageNamed)(targetLanguage, languages));
+        targetLanguage = Support_1.defined(All_1.languageNamed(targetLanguage, languages));
     }
     const compressedJSON = new CompressedJSON_1.CompressedJSONFromString(targetLanguage.dateTimeRecognizer, handleJSONRefs);
     return new JSONInput(compressedJSON);
 }
 exports.jsonInputForTargetLanguage = jsonInputForTargetLanguage;
 class InputData {
-    // FIXME: Make into a Map, indexed by kind.
-    _inputs = new Set();
+    constructor() {
+        // FIXME: Make into a Map, indexed by kind.
+        this._inputs = new Set();
+    }
     addInput(input) {
         this._inputs = this._inputs.add(input);
     }
     getOrAddInput(kind, makeInput) {
-        let input = (0, collection_utils_1.iterableFind)(this._inputs, i => i.kind === kind);
+        let input = collection_utils_1.iterableFind(this._inputs, i => i.kind === kind);
         if (input === undefined) {
             input = makeInput();
             this.addInput(input);
         }
         return input;
     }
-    async addSource(kind, source, makeInput) {
-        const input = this.getOrAddInput(kind, makeInput);
-        await input.addSource(source);
+    addSource(kind, source, makeInput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const input = this.getOrAddInput(kind, makeInput);
+            yield input.addSource(source);
+        });
     }
     addSourceSync(kind, source, makeInput) {
         const input = this.getOrAddInput(kind, makeInput);
         input.addSourceSync(source);
     }
-    async addTypes(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels) {
-        for (const input of this._inputs) {
-            await input.addTypes(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels);
-        }
+    addTypes(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const input of this._inputs) {
+                yield input.addTypes(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels);
+            }
+        });
     }
     addTypesSync(ctx, typeBuilder, inferMaps, inferEnums, fixedTopLevels) {
         for (const input of this._inputs) {
@@ -129,17 +145,17 @@ class InputData {
         }
     }
     get needIR() {
-        return (0, collection_utils_1.iterableSome)(this._inputs, i => i.needIR);
+        return collection_utils_1.iterableSome(this._inputs, i => i.needIR);
     }
     get needSchemaProcessing() {
-        return (0, collection_utils_1.iterableSome)(this._inputs, i => i.needSchemaProcessing);
+        return collection_utils_1.iterableSome(this._inputs, i => i.needSchemaProcessing);
     }
     singleStringSchemaSource() {
-        const schemaStrings = (0, collection_utils_1.setFilterMap)(this._inputs, i => i.singleStringSchemaSource());
+        const schemaStrings = collection_utils_1.setFilterMap(this._inputs, i => i.singleStringSchemaSource());
         if (schemaStrings.size > 1) {
-            return (0, Support_1.panic)("We have more than one input with a string schema source");
+            return Support_1.panic("We have more than one input with a string schema source");
         }
-        return (0, collection_utils_1.iterableFirst)(schemaStrings);
+        return collection_utils_1.iterableFirst(schemaStrings);
     }
 }
 exports.InputData = InputData;

package/dist/quicktype-core/input/JSONSchemaInput.d.ts

@@ -1,4 +1,4 @@
-import URI from "urijs";
+import * as URI from "urijs";
 import { TypeBuilder } from "../TypeBuilder";
 import { TypeAttributes } from "../attributes/TypeAttributes";
 import { JSONSchema, JSONSchemaStore } from "./JSONSchemaStore";
@@ -10,7 +10,7 @@ export declare enum PathElementKind {
     Type = 2,
     Object = 3
 }
-export type PathElement = {
+export declare type PathElement = {
     kind: PathElementKind.Root;
 } | {
     kind: PathElementKind.KeyOrIndex;
@@ -29,16 +29,16 @@ export declare class Ref {
     static parse(ref: string): Ref;
     addressURI: URI | undefined;
     constructor(addressURI: URI | undefined, path: ReadonlyArray<PathElement>);
-    get hasAddress(): boolean;
-    get address(): string;
-    get isRoot(): boolean;
+    readonly hasAddress: boolean;
+    readonly address: string;
+    readonly isRoot: boolean;
     private pushElement;
     push(...keys: string[]): Ref;
     pushObject(): Ref;
     pushType(index: number): Ref;
     resolveAgainst(base: Ref | undefined): Ref;
-    get name(): string;
-    get definitionName(): string | undefined;
+    readonly name: string;
+    readonly definitionName: string | undefined;
     toString(): string;
     private lookup;
     lookupRef(root: JSONSchema): JSONSchema;
@@ -54,8 +54,8 @@ export declare const schemaTypeDict: {
     array: boolean;
     object: boolean;
 };
-export type JSONSchemaType = keyof typeof schemaTypeDict;
-export type JSONSchemaAttributes = {
+export declare type JSONSchemaType = keyof typeof schemaTypeDict;
+export declare type JSONSchemaAttributes = {
     forType?: TypeAttributes;
     forUnion?: TypeAttributes;
     forObject?: TypeAttributes;
@@ -63,7 +63,7 @@ export type JSONSchemaAttributes = {
     forString?: TypeAttributes;
     forCases?: TypeAttributes[];
 };
-export type JSONSchemaAttributeProducer = (schema: JSONSchema, canonicalRef: Ref, types: Set<JSONSchemaType>, unionCases: JSONSchema[] | undefined) => JSONSchemaAttributes | undefined;
+export declare type JSONSchemaAttributeProducer = (schema: JSONSchema, canonicalRef: Ref, types: Set<JSONSchemaType>, unionCases: JSONSchema[] | undefined) => JSONSchemaAttributes | undefined;
 export interface JSONSchemaSourceData {
     name: string;
     uris?: string[];
@@ -81,7 +81,7 @@ export declare class JSONSchemaInput implements Input<JSONSchemaSourceData> {
     private readonly _topLevels;
     private _needIR;
     constructor(_schemaStore: JSONSchemaStore | undefined, additionalAttributeProducers?: JSONSchemaAttributeProducer[], _additionalSchemaAddresses?: ReadonlyArray<string>);
-    get needIR(): boolean;
+    readonly needIR: boolean;
     addTopLevel(name: string, ref: Ref): void;
     addTypes(ctx: RunContext, typeBuilder: TypeBuilder): Promise<void>;
     addTypesSync(): void;