scorecard-ai 0.5.3 → 0.6.0

package/dist/core/fetcher/stream-wrappers/UndiciStreamWrapper.js

@@ -0,0 +1,227 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndiciStreamWrapper = void 0;
+class UndiciStreamWrapper {
+    constructor(readableStream) {
+        this.readableStream = readableStream;
+        this.reader = this.readableStream.getReader();
+        this.events = {
+            data: [],
+            end: [],
+            error: [],
+            readable: [],
+            close: [],
+            pause: [],
+            resume: [],
+        };
+        this.paused = false;
+        this.resumeCallback = null;
+        this.encoding = null;
+    }
+    on(event, callback) {
+        var _a;
+        (_a = this.events[event]) === null || _a === void 0 ? void 0 : _a.push(callback);
+    }
+    off(event, callback) {
+        var _a;
+        this.events[event] = (_a = this.events[event]) === null || _a === void 0 ? void 0 : _a.filter((cb) => cb !== callback);
+    }
+    pipe(dest) {
+        this.on("data", (chunk) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._write(chunk);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.write(chunk).then(() => writer.releaseLock());
+            }
+        });
+        this.on("end", () => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._end();
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.close();
+            }
+        });
+        this.on("error", (error) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._error(error);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.abort(error);
+            }
+        });
+        this._startReading();
+        return dest;
+    }
+    pipeTo(dest) {
+        return this.pipe(dest);
+    }
+    unpipe(dest) {
+        this.off("data", (chunk) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._write(chunk);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.write(chunk).then(() => writer.releaseLock());
+            }
+        });
+        this.off("end", () => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._end();
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.close();
+            }
+        });
+        this.off("error", (error) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._error(error);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.abort(error);
+            }
+        });
+    }
+    destroy(error) {
+        this.reader
+            .cancel(error)
+            .then(() => {
+            this._emit("close");
+        })
+            .catch((err) => {
+            this._emit("error", err);
+        });
+    }
+    pause() {
+        this.paused = true;
+        this._emit("pause");
+    }
+    resume() {
+        if (this.paused) {
+            this.paused = false;
+            this._emit("resume");
+            if (this.resumeCallback) {
+                this.resumeCallback();
+                this.resumeCallback = null;
+            }
+        }
+    }
+    get isPaused() {
+        return this.paused;
+    }
+    read() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.paused) {
+                yield new Promise((resolve) => {
+                    this.resumeCallback = resolve;
+                });
+            }
+            const { done, value } = yield this.reader.read();
+            if (done) {
+                return undefined;
+            }
+            return value;
+        });
+    }
+    setEncoding(encoding) {
+        this.encoding = encoding;
+    }
+    text() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunks = [];
+            while (true) {
+                const { done, value } = yield this.reader.read();
+                if (done)
+                    break;
+                if (value)
+                    chunks.push(value);
+            }
+            const decoder = new TextDecoder(this.encoding || "utf-8");
+            return decoder.decode(yield new Blob(chunks).arrayBuffer());
+        });
+    }
+    json() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const text = yield this.text();
+            return JSON.parse(text);
+        });
+    }
+    _write(chunk) {
+        this._emit("data", chunk);
+    }
+    _end() {
+        this._emit("end");
+    }
+    _error(error) {
+        this._emit("error", error);
+    }
+    _emit(event, data) {
+        if (this.events[event]) {
+            for (const callback of this.events[event] || []) {
+                callback(data);
+            }
+        }
+    }
+    _startReading() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this._emit("readable");
+                while (true) {
+                    if (this.paused) {
+                        yield new Promise((resolve) => {
+                            this.resumeCallback = resolve;
+                        });
+                    }
+                    const { done, value } = yield this.reader.read();
+                    if (done) {
+                        this._emit("end");
+                        this._emit("close");
+                        break;
+                    }
+                    if (value) {
+                        this._emit("data", value);
+                    }
+                }
+            }
+            catch (error) {
+                this._emit("error", error);
+            }
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => __awaiter(this, void 0, void 0, function* () {
+                if (this.paused) {
+                    yield new Promise((resolve) => {
+                        this.resumeCallback = resolve;
+                    });
+                }
+                const { done, value } = yield this.reader.read();
+                if (done) {
+                    return { done: true, value: undefined };
+                }
+                return { done: false, value };
+            }),
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
+}
+exports.UndiciStreamWrapper = UndiciStreamWrapper;

package/dist/core/fetcher/stream-wrappers/chooseStreamWrapper.d.ts

@@ -0,0 +1,18 @@
+export declare type EventCallback = (data?: any) => void;
+export interface StreamWrapper<WritableStream, ReadFormat> {
+    setEncoding(encoding?: string): void;
+    on(event: string, callback: EventCallback): void;
+    off(event: string, callback: EventCallback): void;
+    pipe(dest: WritableStream): WritableStream;
+    pipeTo(dest: WritableStream): WritableStream;
+    unpipe(dest?: WritableStream): void;
+    destroy(error?: Error): void;
+    pause(): void;
+    resume(): void;
+    get isPaused(): boolean;
+    read(): Promise<ReadFormat | undefined>;
+    text(): Promise<string>;
+    json<T>(): Promise<T>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<ReadFormat>;
+}
+export declare function chooseStreamWrapper(responseBody: any): Promise<Promise<StreamWrapper<any, any>>>;

package/dist/{serialization/resources/traces/client/get.js → core/fetcher/stream-wrappers/chooseStreamWrapper.js}

@@ -1,7 +1,4 @@
 "use strict";
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -35,6 +32,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Response = void 0;
-const core = __importStar(require("../../../../core"));
-exports.Response = core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("../../..")))).Span; })));
+exports.chooseStreamWrapper = void 0;
+const runtime_1 = require("../../runtime");
+function chooseStreamWrapper(responseBody) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (runtime_1.RUNTIME.type === "node" && runtime_1.RUNTIME.parsedVersion != null && runtime_1.RUNTIME.parsedVersion >= 18) {
+            return new (yield Promise.resolve().then(() => __importStar(require("./Node18UniversalStreamWrapper")))).Node18UniversalStreamWrapper(responseBody);
+        }
+        else if (runtime_1.RUNTIME.type !== "node" && typeof fetch == "function") {
+            return new (yield Promise.resolve().then(() => __importStar(require("./UndiciStreamWrapper")))).UndiciStreamWrapper(responseBody);
+        }
+        else {
+            return new (yield Promise.resolve().then(() => __importStar(require("./NodePre18StreamWrapper")))).NodePre18StreamWrapper(responseBody);
+        }
+    });
+}
+exports.chooseStreamWrapper = chooseStreamWrapper;

package/dist/core/runtime/runtime.d.ts

@@ -3,6 +3,7 @@
  */
 export declare const RUNTIME: Runtime;
 export interface Runtime {
-    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown";
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd";
     version?: string;
+    parsedVersion?: number;
 }

package/dist/core/runtime/runtime.js

@@ -1,5 +1,5 @@
 "use strict";
-var _a, _b, _c, _d;
+var _a, _b, _c, _d, _e;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RUNTIME = void 0;
 /**
@@ -37,6 +37,11 @@ const isNode = typeof process !== "undefined" &&
  * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
  */
 const isReactNative = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === "ReactNative";
+/**
+ * A constant that indicates whether the environment the code is running is Cloudflare.
+ * https://developers.cloudflare.com/workers/runtime-apis/web-standards/#navigatoruseragent
+ */
+const isCloudflare = typeof globalThis !== "undefined" && ((_e = globalThis === null || globalThis === void 0 ? void 0 : globalThis.navigator) === null || _e === void 0 ? void 0 : _e.userAgent) === "Cloudflare-Workers";
 /**
  * A constant that indicates which environment and version the SDK is running in.
  */
@@ -48,6 +53,11 @@ function evaluateRuntime() {
             version: window.navigator.userAgent,
         };
     }
+    if (isCloudflare) {
+        return {
+            type: "workerd",
+        };
+    }
     if (isWebWorker) {
         return {
             type: "web-worker",
@@ -69,6 +79,7 @@ function evaluateRuntime() {
         return {
             type: "node",
             version: process.versions.node,
+            parsedVersion: Number(process.versions.node.split(".")[0]),
         };
     }
     if (isReactNative) {

package/dist/core/schemas/Schema.d.ts

@@ -1,12 +1,11 @@
 import { SchemaUtils } from "./builders";
-import { MaybePromise } from "./utils/MaybePromise";
 export declare type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export declare type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export declare type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
 export interface BaseSchema<Raw, Parsed> {
-    parse: (raw: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Parsed>>;
-    json: (parsed: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Raw>>;
-    getType: () => SchemaType | Promise<SchemaType>;
+    parse: (raw: unknown, opts?: SchemaOptions) => MaybeValid<Parsed>;
+    json: (parsed: unknown, opts?: SchemaOptions) => MaybeValid<Raw>;
+    getType: () => SchemaType | SchemaType;
 }
 export declare const SchemaType: {
     readonly DATE: "date";
@@ -78,4 +77,8 @@ export interface SchemaOptions {
      * helpful for zurg's internal debug logging.
      */
     breadcrumbsPrefix?: string[];
+    /**
+     * whether to send 'null' for optional properties explicitly set to 'undefined'.
+     */
+    omitUndefined?: boolean;
 }

package/dist/core/schemas/builders/lazy/lazy.d.ts

@@ -1,5 +1,5 @@
 import { BaseSchema, Schema } from "../../Schema";
-export declare type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType | Promise<SchemaType>;
+export declare type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
 export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
 export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;
-export declare function getMemoizedSchema<SchemaType extends Schema<any, any>>(getter: SchemaGetter<SchemaType>): Promise<SchemaType>;
+export declare function getMemoizedSchema<SchemaType extends Schema<any, any>>(getter: SchemaGetter<SchemaType>): SchemaType;

package/dist/core/schemas/builders/lazy/lazy.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMemoizedSchema = exports.constructLazyBaseSchema = exports.lazy = void 0;
 const schema_utils_1 = require("../schema-utils");
@@ -18,19 +9,17 @@ function lazy(getter) {
 exports.lazy = lazy;
 function constructLazyBaseSchema(getter) {
     return {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).parse(raw, opts); }),
-        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).json(parsed, opts); }),
-        getType: () => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).getType(); }),
+        parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
+        json: (parsed, opts) => getMemoizedSchema(getter).json(parsed, opts),
+        getType: () => getMemoizedSchema(getter).getType(),
     };
 }
 exports.constructLazyBaseSchema = constructLazyBaseSchema;
 function getMemoizedSchema(getter) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const castedGetter = getter;
-        if (castedGetter.__zurg_memoized == null) {
-            castedGetter.__zurg_memoized = yield getter();
-        }
-        return castedGetter.__zurg_memoized;
-    });
+    const castedGetter = getter;
+    if (castedGetter.__zurg_memoized == null) {
+        castedGetter.__zurg_memoized = getter();
+    }
+    return castedGetter.__zurg_memoized;
 }
 exports.getMemoizedSchema = getMemoizedSchema;

package/dist/core/schemas/builders/lazy/lazyObject.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyObject = void 0;
 const object_1 = require("../object");
@@ -15,7 +6,7 @@ const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
 const lazy_1 = require("./lazy");
 function lazyObject(getter) {
-    const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getRawProperties(); }), _getParsedProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getParsedProperties(); }) });
+    const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getRawProperties(), _getParsedProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getParsedProperties() });
     return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), (0, object_1.getObjectUtils)(baseSchema));
 }
 exports.lazyObject = lazyObject;

package/dist/core/schemas/builders/list/list.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.list = void 0;
 const Schema_1 = require("../../Schema");
@@ -16,11 +7,9 @@ const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function list(schema) {
     const baseSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
-            return validateAndTransformArray(raw, (item, index) => {
-                var _a;
-                return schema.parse(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
-            });
+        parse: (raw, opts) => validateAndTransformArray(raw, (item, index) => {
+            var _a;
+            return schema.parse(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
         }),
         json: (parsed, opts) => validateAndTransformArray(parsed, (item, index) => {
             var _a;
@@ -32,37 +21,35 @@ function list(schema) {
 }
 exports.list = list;
 function validateAndTransformArray(value, transformItem) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!Array.isArray(value)) {
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
+                    path: [],
+                },
+            ],
+        };
+    }
+    const maybeValidItems = value.map((item, index) => transformItem(item, index));
+    return maybeValidItems.reduce((acc, item) => {
+        if (acc.ok && item.ok) {
             return {
-                ok: false,
-                errors: [
-                    {
-                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
-                        path: [],
-                    },
-                ],
+                ok: true,
+                value: [...acc.value, item.value],
             };
         }
-        const maybeValidItems = yield Promise.all(value.map((item, index) => transformItem(item, index)));
-        return maybeValidItems.reduce((acc, item) => {
-            if (acc.ok && item.ok) {
-                return {
-                    ok: true,
-                    value: [...acc.value, item.value],
-                };
-            }
-            const errors = [];
-            if (!acc.ok) {
-                errors.push(...acc.errors);
-            }
-            if (!item.ok) {
-                errors.push(...item.errors);
-            }
-            return {
-                ok: false,
-                errors,
-            };
-        }, { ok: true, value: [] });
-    });
+        const errors = [];
+        if (!acc.ok) {
+            errors.push(...acc.errors);
+        }
+        if (!item.ok) {
+            errors.push(...item.errors);
+        }
+        return {
+            ok: false,
+            errors,
+        };
+    }, { ok: true, value: [] });
 }