quicktype 17.0.0 → 17.0.1

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

@@ -1,5 +1,5 @@
 import { StringMap } from "../support/Support";
-export type JSONSchema = StringMap | boolean;
+export declare type JSONSchema = StringMap | boolean;
 export declare abstract class JSONSchemaStore {
     private readonly _schemas;
     private add;

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

@@ -1,36 +1,47 @@
 "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.JSONSchemaStore = void 0;
 const Support_1 = require("../support/Support");
 class JSONSchemaStore {
-    _schemas = new Map();
+    constructor() {
+        this._schemas = new Map();
+    }
     add(address, schema) {
-        (0, Support_1.assert)(!this._schemas.has(address), "Cannot set a schema for an address twice");
+        Support_1.assert(!this._schemas.has(address), "Cannot set a schema for an address twice");
         this._schemas.set(address, schema);
     }
-    async get(address, debugPrint) {
-        let schema = this._schemas.get(address);
-        if (schema !== undefined) {
-            return schema;
-        }
-        if (debugPrint) {
-            console.log(`trying to fetch ${address}`);
-        }
-        try {
-            schema = await this.fetch(address);
-        }
-        catch { }
-        if (schema === undefined) {
+    get(address, debugPrint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let schema = this._schemas.get(address);
+            if (schema !== undefined) {
+                return schema;
+            }
+            if (debugPrint) {
+                console.log(`trying to fetch ${address}`);
+            }
+            try {
+                schema = yield this.fetch(address);
+            }
+            catch (_a) { }
+            if (schema === undefined) {
+                if (debugPrint) {
+                    console.log(`couldn't fetch ${address}`);
+                }
+                return undefined;
+            }
             if (debugPrint) {
-                console.log(`couldn't fetch ${address}`);
+                console.log(`successully fetched ${address}`);
             }
-            return undefined;
-        }
-        if (debugPrint) {
-            console.log(`successully fetched ${address}`);
-        }
-        this.add(address, schema);
-        return schema;
+            this.add(address, schema);
+            return schema;
+        });
     }
 }
 exports.JSONSchemaStore = JSONSchemaStore;

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourcesFromPostmanCollection = void 0;
 const Support_1 = require("../support/Support");
 function isValidJSON(s) {
     try {
@@ -49,7 +48,7 @@ function sourcesFromPostmanCollection(collectionJSON, collectionJSONAddress) {
             }
         }
     }
-    processCollection((0, Support_1.parseJSON)(collectionJSON, "Postman collection", collectionJSONAddress));
+    processCollection(Support_1.parseJSON(collectionJSON, "Postman collection", collectionJSONAddress));
     const joinedDescription = descriptions.join("\n\n").trim();
     let description = undefined;
     if (joinedDescription !== "") {

package/dist/quicktype-core/input/io/NodeIO.js

@@ -1,33 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : 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 __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.readFromFileOrURL = exports.readableFromFileOrURL = void 0;
-const fs = __importStar(require("fs"));
+const fs = require("fs");
 const browser_or_node_1 = require("browser-or-node");
 const get_stream_1 = require("./get-stream");
-const ts_necessities_1 = require("@glideapps/ts-necessities");
 const index_1 = require("../../index");
 // The typings for this module are screwy
 const isURL = require("is-url");
@@ -40,7 +23,7 @@ function parseHeaders(httpHeaders) {
         if (httpHeader !== undefined && httpHeader.length > 0) {
             const split = httpHeader.indexOf(":");
             if (split < 0) {
-                return (0, index_1.panic)(`Could not parse HTTP header "${httpHeader}".`);
+                return index_1.panic(`Could not parse HTTP header "${httpHeader}".`);
             }
             const key = httpHeader.slice(0, split).trim();
             const value = httpHeader.slice(split + 1).trim();
@@ -49,39 +32,45 @@ function parseHeaders(httpHeaders) {
         return result;
     }, {});
 }
-async function readableFromFileOrURL(fileOrURL, httpHeaders) {
-    try {
-        if (isURL(fileOrURL)) {
-            const response = await fetch(fileOrURL, {
-                headers: parseHeaders(httpHeaders)
-            });
-            return response.body;
-        }
-        else if (browser_or_node_1.isNode) {
-            if (fileOrURL === "-") {
-                // Cast node readable to isomorphic readable from readable-stream
-                return process.stdin;
+function readableFromFileOrURL(fileOrURL, httpHeaders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (isURL(fileOrURL)) {
+                const response = yield fetch(fileOrURL, {
+                    headers: parseHeaders(httpHeaders)
+                });
+                return response.body;
             }
-            const filePath = fs.lstatSync(fileOrURL).isSymbolicLink() ? fs.readlinkSync(fileOrURL) : fileOrURL;
-            if (fs.existsSync(filePath)) {
-                // Cast node readable to isomorphic readable from readable-stream
-                return fs.createReadStream(filePath, "utf8");
+            else if (browser_or_node_1.isNode) {
+                if (fileOrURL === "-") {
+                    // Cast node readable to isomorphic readable from readable-stream
+                    return process.stdin;
+                }
+                const filePath = fs.lstatSync(fileOrURL).isSymbolicLink() ? fs.readlinkSync(fileOrURL) : fileOrURL;
+                if (fs.existsSync(filePath)) {
+                    // Cast node readable to isomorphic readable from readable-stream
+                    return fs.createReadStream(filePath, "utf8");
+                }
             }
         }
-    }
-    catch (e) {
-        return (0, index_1.messageError)("MiscReadError", { fileOrURL, message: (0, ts_necessities_1.exceptionToString)(e) });
-    }
-    return (0, index_1.messageError)("DriverInputFileDoesNotExist", { filename: fileOrURL });
+        catch (e) {
+            const message = typeof e.message === "string" ? e.message : "Unknown error";
+            return index_1.messageError("MiscReadError", { fileOrURL, message });
+        }
+        return index_1.messageError("DriverInputFileDoesNotExist", { filename: fileOrURL });
+    });
 }
 exports.readableFromFileOrURL = readableFromFileOrURL;
-async function readFromFileOrURL(fileOrURL, httpHeaders) {
-    const readable = await readableFromFileOrURL(fileOrURL, httpHeaders);
-    try {
-        return await (0, get_stream_1.getStream)(readable);
-    }
-    catch (e) {
-        return (0, index_1.messageError)("MiscReadError", { fileOrURL, message: (0, ts_necessities_1.exceptionToString)(e) });
-    }
+function readFromFileOrURL(fileOrURL, httpHeaders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const readable = yield readableFromFileOrURL(fileOrURL, httpHeaders);
+        try {
+            return yield get_stream_1.getStream(readable);
+        }
+        catch (e) {
+            const message = typeof e.message === "string" ? e.message : "Unknown error";
+            return index_1.messageError("MiscReadError", { fileOrURL, message });
+        }
+    });
 }
 exports.readFromFileOrURL = readFromFileOrURL;

package/dist/quicktype-core/input/io/get-stream/index.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.array = exports.buffer = exports.getStream = void 0;
-const buffer_stream_1 = __importDefault(require("./buffer-stream"));
+const buffer_stream_1 = require("./buffer-stream");
 function getStream(inputStream, opts = {}) {
     if (!inputStream) {
         return Promise.reject(new Error("Expected a stream"));
@@ -21,7 +17,7 @@ function getStream(inputStream, opts = {}) {
             }
             reject(err);
         };
-        stream = (0, buffer_stream_1.default)(opts);
+        stream = buffer_stream_1.default(opts);
         inputStream.once("error", error);
         inputStream.pipe(stream);
         stream.on("data", () => {

package/dist/quicktype-core/language/All.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.languageNamed = exports.all = void 0;
 const collection_utils_1 = require("collection-utils");
 const CSharp_1 = require("./CSharp");
 const Golang_1 = require("./Golang");
@@ -49,9 +48,9 @@ function languageNamed(name, targetLanguages) {
     if (targetLanguages === undefined) {
         targetLanguages = exports.all;
     }
-    const maybeTargetLanguage = (0, collection_utils_1.iterableFind)(targetLanguages, l => l.names.indexOf(name) >= 0 || l.displayName === name);
+    const maybeTargetLanguage = collection_utils_1.iterableFind(targetLanguages, l => l.names.indexOf(name) >= 0 || l.displayName === name);
     if (maybeTargetLanguage !== undefined)
         return maybeTargetLanguage;
-    return (0, collection_utils_1.iterableFind)(targetLanguages, l => l.extension === name);
+    return collection_utils_1.iterableFind(targetLanguages, l => l.extension === name);
 }
 exports.languageNamed = languageNamed;

package/dist/quicktype-core/language/CPlusPlus.d.ts

@@ -26,8 +26,8 @@ export declare const cPlusPlusOptions: {
 export declare class CPlusPlusTargetLanguage extends TargetLanguage {
     constructor(displayName?: string, names?: string[], extension?: string);
     protected getOptions(): Option<any>[];
-    get supportsUnionsWithBothNumberTypes(): boolean;
-    get supportsOptionalClassProperties(): boolean;
+    readonly supportsUnionsWithBothNumberTypes: boolean;
+    readonly supportsOptionalClassProperties: boolean;
     protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
         [name: string]: any;
     }): CPlusPlusRenderer;
@@ -68,18 +68,18 @@ export declare enum MemberNames {
     GetPattern = 13,
     SetPattern = 14
 }
-type ConstraintMember = {
+declare type ConstraintMember = {
     name: MemberNames;
     getter: MemberNames;
     setter: MemberNames;
     cppType: string;
     cppConstType?: string;
 };
-export type IncludeRecord = {
+export declare type IncludeRecord = {
     kind: IncludeKind | undefined /** How to include that */;
     typeKind: TypeKind | undefined /** What exactly to include */;
 };
-export type TypeRecord = {
+export declare type TypeRecord = {
     name: Name;
     type: Type;
     level: number;
@@ -90,8 +90,8 @@ export type TypeRecord = {
  * We map each and every unique type to a include kind, e.g. how
  * to include the given type
  */
-export type IncludeMap = Map<string, IncludeRecord>;
-export type TypeContext = {
+export declare type IncludeMap = Map<string, IncludeRecord>;
+export declare type TypeContext = {
     needsForwardIndirection: boolean;
     needsOptionalIndirection: boolean;
     inJsonNamespace: boolean;
@@ -146,7 +146,7 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     protected emitInclude(global: boolean, name: Sourcelike): void;
     protected startFile(basename: Sourcelike, includeHelper?: boolean): void;
     protected finishFile(): void;
-    protected get needsTypeDeclarationBeforeUse(): boolean;
+    protected readonly needsTypeDeclarationBeforeUse: boolean;
     protected canBeForwardDeclared(t: Type): boolean;
     protected emitDescriptionBlock(lines: Sourcelike[]): void;
     protected emitBlock(line: Sourcelike, withSemicolon: boolean, f: () => void, withIndent?: boolean): void;