quicktype 17.0.6 → 18.0.0

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

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

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

@@ -1,47 +1,36 @@
 "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 {
-    constructor() {
-        this._schemas = new Map();
-    }
+    _schemas = new Map();
     add(address, schema) {
-        Support_1.assert(!this._schemas.has(address), "Cannot set a schema for an address twice");
+        (0, Support_1.assert)(!this._schemas.has(address), "Cannot set a schema for an address twice");
         this._schemas.set(address, schema);
     }
-    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;
-            }
+    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) {
             if (debugPrint) {
-                console.log(`successully fetched ${address}`);
+                console.log(`couldn't fetch ${address}`);
             }
-            this.add(address, schema);
-            return schema;
-        });
+            return undefined;
+        }
+        if (debugPrint) {
+            console.log(`successully fetched ${address}`);
+        }
+        this.add(address, schema);
+        return schema;
     }
 }
 exports.JSONSchemaStore = JSONSchemaStore;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourcesFromPostmanCollection = void 0;
 const Support_1 = require("../support/Support");
 function isValidJSON(s) {
     try {
@@ -48,7 +49,7 @@ function sourcesFromPostmanCollection(collectionJSON, collectionJSONAddress) {
             }
         }
     }
-    processCollection(Support_1.parseJSON(collectionJSON, "Postman collection", collectionJSONAddress));
+    processCollection((0, 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,16 +1,33 @@
 "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());
-    });
+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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("fs");
+exports.readFromFileOrURL = exports.readableFromFileOrURL = void 0;
+const fs = __importStar(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");
@@ -23,7 +40,7 @@ function parseHeaders(httpHeaders) {
         if (httpHeader !== undefined && httpHeader.length > 0) {
             const split = httpHeader.indexOf(":");
             if (split < 0) {
-                return index_1.panic(`Could not parse HTTP header "${httpHeader}".`);
+                return (0, index_1.panic)(`Could not parse HTTP header "${httpHeader}".`);
             }
             const key = httpHeader.slice(0, split).trim();
             const value = httpHeader.slice(split + 1).trim();
@@ -32,45 +49,39 @@ function parseHeaders(httpHeaders) {
         return result;
     }, {});
 }
-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;
+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;
             }
-            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");
-                }
+            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) {
-            const message = typeof e.message === "string" ? e.message : "Unknown error";
-            return index_1.messageError("MiscReadError", { fileOrURL, message });
-        }
-        return index_1.messageError("DriverInputFileDoesNotExist", { filename: fileOrURL });
-    });
+    }
+    catch (e) {
+        return (0, index_1.messageError)("MiscReadError", { fileOrURL, message: (0, ts_necessities_1.exceptionToString)(e) });
+    }
+    return (0, index_1.messageError)("DriverInputFileDoesNotExist", { filename: fileOrURL });
 }
 exports.readableFromFileOrURL = readableFromFileOrURL;
-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 });
-        }
-    });
+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) });
+    }
 }
 exports.readFromFileOrURL = readFromFileOrURL;

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

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

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

@@ -1,5 +1,6 @@
 "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");
@@ -48,9 +49,9 @@ function languageNamed(name, targetLanguages) {
     if (targetLanguages === undefined) {
         targetLanguages = exports.all;
     }
-    const maybeTargetLanguage = collection_utils_1.iterableFind(targetLanguages, l => l.names.indexOf(name) >= 0 || l.displayName === name);
+    const maybeTargetLanguage = (0, collection_utils_1.iterableFind)(targetLanguages, l => l.names.indexOf(name) >= 0 || l.displayName === name);
     if (maybeTargetLanguage !== undefined)
         return maybeTargetLanguage;
-    return collection_utils_1.iterableFind(targetLanguages, l => l.extension === name);
+    return (0, collection_utils_1.iterableFind)(targetLanguages, l => l.extension === name);
 }
 exports.languageNamed = languageNamed;

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

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