quicktype-core 23.3.20 → 23.3.22

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/TypeScriptZod/TypeScriptZodRenderer.d.ts

@@ -8,6 +8,10 @@ import { type ClassProperty, type EnumType, ObjectType, type Type } from "../../
 import type { typeScriptZodOptions } from "./language";
 export declare class TypeScriptZodRenderer extends ConvenienceRenderer {
     protected readonly _options: OptionValues<typeof typeScriptZodOptions>;
+    /** TypeRefs of object types that participate in a reference cycle.
+     * These must be emitted as z.lazy() schemas with an explicit type
+     * annotation, since zod cannot infer recursive types. */
+    private _recursiveTypeRefs;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof typeScriptZodOptions>);
     protected forbiddenNamesForGlobalNamespace(): string[];
     protected nameStyle(original: string, upper: boolean): string;
@@ -19,7 +23,23 @@ export declare class TypeScriptZodRenderer extends ConvenienceRenderer {
     protected emitImports(): void;
     protected typeMapTypeForProperty(p: ClassProperty): Sourcelike;
     protected typeMapTypeFor(t: Type, required?: boolean): Sourcelike;
+    /** TypeScript type for `t`, used to annotate recursive schemas for
+     * which zod cannot infer the type.
+     *
+     * This intentionally duplicates neither `typeMapTypeFor` above nor
+     * `sourceFor` in the plain TypeScript renderer
+     * (`TypeScriptFlowBaseRenderer`): it must mirror exactly what
+     * `z.infer` would derive from the schemas emitted by
+     * `typeMapTypeFor` (e.g. `z.coerce.date()` implies `Date`), while
+     * `sourceFor` is shaped by ts/flow-specific options like
+     * `preferConstValues` and `declareUnions` that don't exist here. */
+    protected underlyingTypeFor(t: Type): Sourcelike;
+    protected isRecursive(t: ObjectType): boolean;
     protected emitObject(name: Name, t: ObjectType): void;
+    /** Emit a recursive object type. zod cannot infer recursive types, so
+     * the type is declared explicitly and the schema is wrapped in
+     * z.lazy() with a z.ZodType annotation. */
+    protected emitLazyObject(name: Name, t: ObjectType): void;
     protected emitEnum(e: EnumType, enumName: Name): void;
     /** Static function that extracts underlying type refs for types that form part of the
      * definition of the passed type - used to ensure that these appear in generated source

package/dist/language/TypeScriptZod/TypeScriptZodRenderer.js

@@ -14,6 +14,10 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     constructor(targetLanguage, renderContext, _options) {
         super(targetLanguage, renderContext);
         this._options = _options;
+        /** TypeRefs of object types that participate in a reference cycle.
+         * These must be emitted as z.lazy() schemas with an explicit type
+         * annotation, since zod cannot infer recursive types. */
+        this._recursiveTypeRefs = new Set();
     }
     forbiddenNamesForGlobalNamespace() {
         return ["Class", "Date", "Object", "String", "Array", "JSON", "Error"];
@@ -72,7 +76,46 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         return match;
     }
+    /** TypeScript type for `t`, used to annotate recursive schemas for
+     * which zod cannot infer the type.
+     *
+     * This intentionally duplicates neither `typeMapTypeFor` above nor
+     * `sourceFor` in the plain TypeScript renderer
+     * (`TypeScriptFlowBaseRenderer`): it must mirror exactly what
+     * `z.infer` would derive from the schemas emitted by
+     * `typeMapTypeFor` (e.g. `z.coerce.date()` implies `Date`), while
+     * `sourceFor` is shaped by ts/flow-specific options like
+     * `preferConstValues` and `declareUnions` that don't exist here. */
+    underlyingTypeFor(t) {
+        if (["class", "object", "enum"].includes(t.kind)) {
+            return this.nameForNamedType(t);
+        }
+        return (0, TypeUtils_1.matchType)(t, (_anyType) => "any", (_nullType) => "null", (_boolType) => "boolean", (_integerType) => "number", (_doubleType) => "number", (_stringType) => "string", (arrayType) => [
+            "Array<",
+            this.underlyingTypeFor(arrayType.items),
+            ">",
+        ], (_classType) => (0, Support_1.panic)("Should already be handled."), (mapType) => [
+            "Record<string, ",
+            this.underlyingTypeFor(mapType.values),
+            ">",
+        ], (_enumType) => (0, Support_1.panic)("Should already be handled."), (unionType) => {
+            const children = Array.from(unionType.getChildren()).map((type) => this.underlyingTypeFor(type));
+            return (0, collection_utils_1.arrayIntercalate)(" | ", children);
+        }, (_transformedStringType) => {
+            if (_transformedStringType.kind === "date-time") {
+                return "Date";
+            }
+            return "string";
+        });
+    }
+    isRecursive(t) {
+        return this._recursiveTypeRefs.has(t.typeRef);
+    }
     emitObject(name, t) {
+        if (this.isRecursive(t)) {
+            this.emitLazyObject(name, t);
+            return;
+        }
         this.ensureBlankLine();
         this.emitLine("\nexport const ", name, "Schema = ", "z.object({");
         this.indent(() => {
@@ -85,6 +128,35 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("export type ", name, " = z.infer<typeof ", name, "Schema>;");
         }
     }
+    /** Emit a recursive object type. zod cannot infer recursive types, so
+     * the type is declared explicitly and the schema is wrapped in
+     * z.lazy() with a z.ZodType annotation. */
+    emitLazyObject(name, t) {
+        this.ensureBlankLine();
+        if (this._options.justSchema) {
+            this.emitLine("\nexport const ", name, "Schema: z.ZodType<any> = z.lazy(() =>");
+        }
+        else {
+            this.emitLine("\nexport type ", name, " = {");
+            this.indent(() => {
+                this.forEachClassProperty(t, "none", (_, jsonName, property) => {
+                    this.emitLine(`"${(0, Strings_1.utf16StringEscape)(jsonName)}"`, property.isOptional ? "?" : "", ": ", this.underlyingTypeFor(property.type), ";");
+                });
+            });
+            this.emitLine("};");
+            this.emitLine("export const ", name, "Schema: z.ZodType<", name, "> = z.lazy(() =>");
+        }
+        this.indent(() => {
+            this.emitLine("z.object({");
+            this.indent(() => {
+                this.forEachClassProperty(t, "none", (_, jsonName, property) => {
+                    this.emitLine(`"${(0, Strings_1.utf16StringEscape)(jsonName)}"`, ": ", this.typeMapTypeForProperty(property), ",");
+                });
+            });
+            this.emitLine("})");
+        });
+        this.emitLine(");");
+    }
     emitEnum(e, enumName) {
         this.ensureBlankLine();
         this.emitDescription(this.descriptionForType(e));
@@ -164,10 +236,44 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             });
             mapChildTypeRefs.push(childTypeRefs);
         });
+        // Find types that participate in a reference cycle: types from
+        // which we can get back to the same type by following child type
+        // references. Those can never be topologically ordered.
+        const indexForTypeRef = new Map();
+        mapTypeRef.forEach((typeRef, index) => indexForTypeRef.set(typeRef, index));
+        this._recursiveTypeRefs = new Set();
+        mapType.forEach((_, startIndex) => {
+            const visited = new Set();
+            const stack = [...mapChildTypeRefs[startIndex]];
+            while (stack.length > 0) {
+                const childRef = stack.pop();
+                const childIndex = indexForTypeRef.get(childRef);
+                if (childIndex === undefined)
+                    continue;
+                if (childIndex === startIndex) {
+                    this._recursiveTypeRefs.add(mapTypeRef[startIndex]);
+                    break;
+                }
+                if (visited.has(childIndex))
+                    continue;
+                visited.add(childIndex);
+                stack.push(...mapChildTypeRefs[childIndex]);
+            }
+        });
         // Items to process on this pass
         let indices = [];
         mapType.forEach((_, index) => {
-            indices.push(index);
+            if (this._recursiveTypeRefs.has(mapTypeRef[index])) {
+                // Recursive types are emitted first: they are wrapped in
+                // z.lazy(), so all their references to other schemas are
+                // deferred until parse time and don't constrain the
+                // output order, while other schemas can reference them
+                // directly.
+                order.push(index);
+            }
+            else {
+                indices.push(index);
+            }
         });
         // items to process on the next pass
         let deferredIndices = [];
@@ -214,8 +320,9 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             deferredIndices = [];
             passNum++;
             if (passNum > MAX_PASSES) {
-                // giving up
-                order.push(...deferredIndices);
+                // giving up: emit the stuck items anyway rather than
+                // silently dropping them
+                order.push(...indices);
                 console.warn("Exceeded maximum number of passes when determining output order, output may contain forward references");
             }
         } while (indices.length > 0 && passNum <= MAX_PASSES);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.3.20",
+    "version": "23.3.22",
     "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;