quicktype-core 23.3.19 → 23.3.21

package/dist/input/io/NodeIO.d.ts

@@ -1,3 +1,3 @@
-import type { Readable } from "readable-stream";
+import { Readable } from "readable-stream";
 export declare function readableFromFileOrURL(fileOrURL: string, httpHeaders?: string[]): Promise<Readable>;
 export declare function readFromFileOrURL(fileOrURL: string, httpHeaders?: string[]): Promise<string>;

package/dist/input/io/NodeIO.js

@@ -41,6 +41,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -52,6 +65,7 @@ const path = __importStar(require("path"));
 const ts_necessities_1 = require("@glideapps/ts-necessities");
 const browser_or_node_1 = require("browser-or-node");
 const is_url_1 = __importDefault(require("is-url"));
+const readable_stream_1 = require("readable-stream");
 const Messages_1 = require("../../Messages");
 const Support_1 = require("../../support/Support");
 const get_stream_1 = require("./get-stream");
@@ -73,6 +87,35 @@ function parseHeaders(httpHeaders) {
         return result;
     }, {});
 }
+function webStreamChunks(stream) {
+    return __asyncGenerator(this, arguments, function* webStreamChunks_1() {
+        const reader = stream.getReader();
+        try {
+            for (;;) {
+                const { done, value } = yield __await(reader.read());
+                if (done)
+                    return yield __await(void 0);
+                yield yield __await((0, ts_necessities_1.defined)(value));
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    });
+}
+// readable-stream implements Readable.from (it can't do Readable.fromWeb),
+// but @types/readable-stream doesn't declare it, hence this cast.
+const ReadableWithFrom = readable_stream_1.Readable;
+function readableFromResponseBody(body) {
+    // Native fetch (Node >= 18, browsers) returns a WHATWG ReadableStream,
+    // which lacks the Node stream API that our consumers rely on, so we have
+    // to wrap it.  The cross-fetch fallback (node-fetch) already returns a
+    // Node stream, which we pass through unchanged.
+    if (typeof body.getReader === "function") {
+        return ReadableWithFrom.from(webStreamChunks(body), { objectMode: false });
+    }
+    return body;
+}
 function resolveSymbolicLink(filePath) {
     if (!fs.lstatSync(filePath).isSymbolicLink()) {
         return filePath;
@@ -90,7 +133,7 @@ function readableFromFileOrURL(fileOrURL, httpHeaders) {
                 const response = yield (0, _fetch_1.fetch)(fileOrURL, {
                     headers: parseHeaders(httpHeaders),
                 });
-                return (0, ts_necessities_1.defined)(response.body);
+                return readableFromResponseBody((0, ts_necessities_1.defined)(response.body));
             }
             if (browser_or_node_1.isNode) {
                 if (fileOrURL === "-") {

package/dist/language/Rust/constants.d.ts

@@ -1 +1 @@
-export declare const keywords: readonly ["Serialize", "Deserialize", "{{root}}", "$crate", "as", "async", "box", "break", "const", "continue", "crate", "else", "enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe", "use", "where", "while", "abstract", "alignof", "become", "do", "final", "macro", "offsetof", "override", "priv", "proc", "pure", "sizeof", "typeof", "unsized", "virtual", "yield", "catch", "default", "dyn", "'static", "union", "option"];
+export declare const keywords: readonly ["Serialize", "Deserialize", "{{root}}", "$crate", "as", "async", "box", "break", "const", "continue", "crate", "else", "enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe", "use", "where", "while", "abstract", "alignof", "become", "do", "final", "macro", "offsetof", "override", "priv", "proc", "pure", "sizeof", "typeof", "unsized", "virtual", "yield", "catch", "default", "dyn", "'static", "union", "option", "Option", "Some", "None", "Result", "Ok", "Err", "String", "Vec", "Box", "HashMap"];

package/dist/language/Rust/constants.js

@@ -71,4 +71,19 @@ exports.keywords = [
     "union",
     // Conflict between `std::Option` and potentially generated Option
     "option",
+    // Prelude and standard-library names that generated code refers to
+    // unqualified; a generated type with one of these names would shadow
+    // them and break compilation (e.g. a struct named `Option`).
+    "Option",
+    "Some",
+    "None",
+    "Result",
+    "Ok",
+    "Err",
+    "String",
+    "Vec",
+    "Box",
+    // Generated code contains `use std::collections::HashMap;`, which a
+    // type of the same name would conflict with.
+    "HashMap",
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.3.19",
+    "version": "23.3.21",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",
@@ -8,7 +8,7 @@
     "repository": "https://github.com/glideapps/quicktype",
     "scripts": {
         "clean": "rm -rf dist node_modules *~",
-        "build": "./env.sh && tsc"
+        "build": "tsc"
     },
     "dependencies": {
         "@glideapps/ts-necessities": "2.2.3",

package/dist/input/io/$fetch.ci.d.ts

@@ -1 +0,0 @@
-export declare const fetch: any;

package/dist/input/io/$fetch.ci.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = void 0;
-// No logging here: this module runs at import time, and anything written to
-// stdout corrupts redirected CLI output (issue #2874).
-exports.fetch = require("cross-fetch").default;