hume 0.14.1 → 0.14.2-beta1

package/dist/core/schemas/utils/createIdentitySchemaCreator.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIdentitySchemaCreator = createIdentitySchemaCreator;
-const schema_utils_1 = require("../builders/schema-utils");
-const maybeSkipValidation_1 = require("./maybeSkipValidation");
+const index_js_1 = require("../builders/schema-utils/index.js");
+const maybeSkipValidation_js_1 = require("./maybeSkipValidation.js");
 function createIdentitySchemaCreator(schemaType, validate) {
     return () => {
         const baseSchema = {
@@ -10,6 +10,6 @@ function createIdentitySchemaCreator(schemaType, validate) {
             json: validate,
             getType: () => schemaType,
         };
-        return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+        return Object.assign(Object.assign({}, (0, maybeSkipValidation_js_1.maybeSkipValidation)(baseSchema)), (0, index_js_1.getSchemaUtils)(baseSchema));
     };
 }

package/dist/core/schemas/utils/maybeSkipValidation.d.ts

@@ -1,2 +1,2 @@
-import { BaseSchema } from "../Schema";
+import { BaseSchema } from "../Schema.js";
 export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/dist/core/schemas/utils/maybeSkipValidation.js

@@ -9,7 +9,7 @@ function transformAndMaybeSkipValidation(transform) {
         const transformed = transform(value, opts);
         const { skipValidation = false } = opts !== null && opts !== void 0 ? opts : {};
         if (!transformed.ok && skipValidation) {
-            // eslint-disable-next-line no-console
+            // biome-ignore lint/suspicious/noConsole: allow console
             console.warn([
                 "Failed to validate.",
                 ...transformed.errors.map((error) => "  - " +

package/dist/core/stream/Stream.d.ts

@@ -1,10 +1,9 @@
-import { Readable } from "stream";
 export declare namespace Stream {
     interface Args {
         /**
          * The HTTP response stream to read from.
          */
-        stream: Readable | ReadableStream;
+        stream: ReadableStream;
         /**
          * The event shape to use for parsing the stream data.
          */

package/dist/core/stream/Stream.js

@@ -31,7 +31,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stream = void 0;
 exports.readableStreamAsyncIterable = readableStreamAsyncIterable;
-const runtime_1 = require("../runtime");
+const index_js_1 = require("../runtime/index.js");
 const DATA_PREFIX = "data:";
 class Stream {
     constructor({ stream, parse, eventShape, signal }) {
@@ -122,7 +122,7 @@ class Stream {
             decoded += decoder.decode(chunk);
         }
         // Buffer is present in Node.js environment
-        else if (runtime_1.RUNTIME.type === "node" && typeof chunk !== "undefined") {
+        else if (index_js_1.RUNTIME.type === "node" && typeof chunk !== "undefined") {
             decoded += Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
         }
         return decoded;
@@ -132,7 +132,7 @@ exports.Stream = Stream;
 /**
  * Browser polyfill for ReadableStream
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// biome-ignore lint/suspicious/noExplicitAny: allow explicit any
 function readableStreamAsyncIterable(stream) {
     if (stream[Symbol.asyncIterator]) {
         return stream;

package/dist/core/stream/index.d.ts

@@ -1 +1 @@
-export { Stream } from "./Stream";
+export { Stream } from "./Stream.js";

package/dist/core/stream/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stream = void 0;
-var Stream_1 = require("./Stream");
-Object.defineProperty(exports, "Stream", { enumerable: true, get: function () { return Stream_1.Stream; } });
+var Stream_js_1 = require("./Stream.js");
+Object.defineProperty(exports, "Stream", { enumerable: true, get: function () { return Stream_js_1.Stream; } });

package/dist/core/url/index.d.ts

@@ -0,0 +1,2 @@
+export { join } from "./join.js";
+export { toQueryString } from "./qs.js";

package/dist/core/url/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toQueryString = exports.join = void 0;
+var join_js_1 = require("./join.js");
+Object.defineProperty(exports, "join", { enumerable: true, get: function () { return join_js_1.join; } });
+var qs_js_1 = require("./qs.js");
+Object.defineProperty(exports, "toQueryString", { enumerable: true, get: function () { return qs_js_1.toQueryString; } });

package/dist/core/url/join.d.ts

@@ -0,0 +1 @@
+export declare function join(base: string, ...segments: string[]): string;

package/dist/core/url/join.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = join;
+function join(base, ...segments) {
+    if (!base) {
+        return "";
+    }
+    if (segments.length === 0) {
+        return base;
+    }
+    if (base.includes("://")) {
+        let url;
+        try {
+            url = new URL(base);
+        }
+        catch (_a) {
+            // Fallback to path joining if URL is malformed
+            return joinPath(base, ...segments);
+        }
+        const lastSegment = segments[segments.length - 1];
+        const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/");
+        for (const segment of segments) {
+            const cleanSegment = trimSlashes(segment);
+            if (cleanSegment) {
+                url.pathname = joinPathSegments(url.pathname, cleanSegment);
+            }
+        }
+        if (shouldPreserveTrailingSlash && !url.pathname.endsWith("/")) {
+            url.pathname += "/";
+        }
+        return url.toString();
+    }
+    return joinPath(base, ...segments);
+}
+function joinPath(base, ...segments) {
+    if (segments.length === 0) {
+        return base;
+    }
+    let result = base;
+    const lastSegment = segments[segments.length - 1];
+    const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/");
+    for (const segment of segments) {
+        const cleanSegment = trimSlashes(segment);
+        if (cleanSegment) {
+            result = joinPathSegments(result, cleanSegment);
+        }
+    }
+    if (shouldPreserveTrailingSlash && !result.endsWith("/")) {
+        result += "/";
+    }
+    return result;
+}
+function joinPathSegments(left, right) {
+    if (left.endsWith("/")) {
+        return left + right;
+    }
+    return left + "/" + right;
+}
+function trimSlashes(str) {
+    if (!str)
+        return str;
+    let start = 0;
+    let end = str.length;
+    if (str.startsWith("/"))
+        start = 1;
+    if (str.endsWith("/"))
+        end = str.length - 1;
+    return start === 0 && end === str.length ? str : str.slice(start, end);
+}

package/dist/core/url/qs.d.ts

@@ -0,0 +1,6 @@
+interface QueryStringOptions {
+    arrayFormat?: "indices" | "repeat";
+    encode?: boolean;
+}
+export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;
+export {};

package/dist/core/url/qs.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toQueryString = toQueryString;
+const defaultQsOptions = {
+    arrayFormat: "indices",
+    encode: true,
+};
+function encodeValue(value, shouldEncode) {
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "";
+    }
+    const stringValue = String(value);
+    return shouldEncode ? encodeURIComponent(stringValue) : stringValue;
+}
+function stringifyObject(obj, prefix = "", options) {
+    const parts = [];
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}[${key}]` : key;
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                continue;
+            }
+            for (let i = 0; i < value.length; i++) {
+                const item = value[i];
+                if (item === undefined) {
+                    continue;
+                }
+                if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                    parts.push(...stringifyObject(item, arrayKey, options));
+                }
+                else {
+                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                    const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
+                    parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+                }
+            }
+        }
+        else if (typeof value === "object" && value !== null) {
+            if (Object.keys(value).length === 0) {
+                continue;
+            }
+            parts.push(...stringifyObject(value, fullKey, options));
+        }
+        else {
+            const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+            parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`);
+        }
+    }
+    return parts;
+}
+function toQueryString(obj, options) {
+    if (obj == null || typeof obj !== "object") {
+        return "";
+    }
+    const parts = stringifyObject(obj, "", Object.assign(Object.assign({}, defaultQsOptions), options));
+    return parts.join("&");
+}

package/dist/core/utils/index.d.ts

@@ -1 +1 @@
-export { setObjectProperty } from "./setObjectProperty";
+export { setObjectProperty } from "./setObjectProperty.js";

package/dist/core/utils/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setObjectProperty = void 0;
-var setObjectProperty_1 = require("./setObjectProperty");
-Object.defineProperty(exports, "setObjectProperty", { enumerable: true, get: function () { return setObjectProperty_1.setObjectProperty; } });
+var setObjectProperty_js_1 = require("./setObjectProperty.js");
+Object.defineProperty(exports, "setObjectProperty", { enumerable: true, get: function () { return setObjectProperty_js_1.setObjectProperty; } });

package/dist/core/websocket/events.d.ts

@@ -1,4 +1,3 @@
-/** THIS FILE IS MANUALLY MAINAINED: see .fernignore */
 export declare class Event {
     target: any;
     type: string;
@@ -13,7 +12,6 @@ export declare class CloseEvent extends Event {
     code: number;
     reason: string;
     wasClean: boolean;
-    willReconnect?: boolean;
     constructor(code: number | undefined, reason: string | undefined, target: any);
 }
 export interface WebSocketEventMap {

package/dist/core/websocket/events.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloseEvent = exports.ErrorEvent = exports.Event = void 0;
-/** THIS FILE IS MANUALLY MAINAINED: see .fernignore */
 class Event {
     constructor(type, target) {
         this.target = target;
@@ -21,7 +20,6 @@ class CloseEvent extends Event {
     constructor(code = 1000, reason = "", target) {
         super("close", target);
         this.wasClean = true;
-        this.willReconnect = false;
         this.code = code;
         this.reason = reason;
     }

package/dist/core/websocket/index.d.ts

@@ -1,2 +1 @@
-/** THIS FILE IS MANUALLY MAINAINED: see .fernignore */
-export * from "./ws";
+export * from "./ws.js";

package/dist/core/websocket/index.js

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/** THIS FILE IS MANUALLY MAINAINED: see .fernignore */
-__exportStar(require("./ws"), exports);
+__exportStar(require("./ws.js"), exports);

package/dist/core/websocket/ws.d.ts

@@ -1,27 +1,36 @@
-import * as Events from "./events";
+import * as Events from "./events.js";
 export type Event = Events.Event;
 export type ErrorEvent = Events.ErrorEvent;
 export type CloseEvent = Events.CloseEvent;
-export type Options = {
-    WebSocket?: any;
-    maxReconnectionDelay?: number;
-    minReconnectionDelay?: number;
-    reconnectionDelayGrowFactor?: number;
-    minUptime?: number;
-    connectionTimeout?: number;
-    maxRetries?: number;
-    maxEnqueuedMessages?: number;
-    startClosed?: boolean;
-    debug?: boolean;
-};
-export type UrlProvider = string | (() => string) | (() => Promise<string>);
-export type Message = string | ArrayBuffer | Blob | ArrayBufferView;
-export type ListenersMap = {
-    error: Array<Events.WebSocketEventListenerMap["error"]>;
-    message: Array<Events.WebSocketEventListenerMap["message"]>;
-    open: Array<Events.WebSocketEventListenerMap["open"]>;
-    close: Array<Events.WebSocketEventListenerMap["close"]>;
-};
+export declare namespace ReconnectingWebSocket {
+    interface Args {
+        url: string;
+        protocols?: string | string[];
+        options?: ReconnectingWebSocket.Options;
+        headers?: Record<string, unknown>;
+        queryParameters?: Record<string, string | string[] | object | object[] | null | undefined>;
+    }
+    type Options = {
+        WebSocket?: any;
+        maxReconnectionDelay?: number;
+        minReconnectionDelay?: number;
+        reconnectionDelayGrowFactor?: number;
+        minUptime?: number;
+        connectionTimeout?: number;
+        maxRetries?: number;
+        maxEnqueuedMessages?: number;
+        startClosed?: boolean;
+        debug?: boolean;
+    };
+    type UrlProvider = string | (() => string) | (() => Promise<string>);
+    type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+    type ListenersMap = {
+        error: Array<Events.WebSocketEventListenerMap["error"]>;
+        message: Array<Events.WebSocketEventListenerMap["message"]>;
+        open: Array<Events.WebSocketEventListenerMap["open"]>;
+        close: Array<Events.WebSocketEventListenerMap["close"]>;
+    };
+}
 export declare class ReconnectingWebSocket {
     private _ws?;
     private _listeners;
@@ -36,8 +45,9 @@ export declare class ReconnectingWebSocket {
     private readonly _url;
     private readonly _protocols?;
     private readonly _options;
-    private readonly _WebSocket;
-    constructor(url: UrlProvider, protocols?: string | string[], options?: Options);
+    private readonly _headers?;
+    private readonly _queryParameters?;
+    constructor({ url, protocols, options, headers, queryParameters }: ReconnectingWebSocket.Args);
     static get CONNECTING(): number;
     static get OPEN(): number;
     static get CLOSING(): number;
@@ -108,7 +118,7 @@ export declare class ReconnectingWebSocket {
     /**
      * Enqueue specified data to be transmitted to the server over the WebSocket connection
      */
-    send(data: Message): void;
+    send(data: ReconnectingWebSocket.Message): void;
     /**
      * Register an event handler of a specific event type
      */
@@ -122,15 +132,6 @@ export declare class ReconnectingWebSocket {
     private _getNextDelay;
     private _wait;
     private _getNextUrl;
-    /**
-     * Handles the final "tear down" process when connection attempts must permanently stop
-     * (e.g., max retries reached, fatal configuration error).
-     * Releases locks, disables reconnection, dispatches final error and close events.
-     *
-     * @param error - The specific Error instance indicating the reason for termination.
-     * @param closeReason - The reason string to use for the final CloseEvent.
-     */
-    private _shutdown;
     private _connect;
     private _handleTimeout;
     private _disconnect;
@@ -138,28 +139,7 @@ export declare class ReconnectingWebSocket {
     private _callEventListener;
     private _handleOpen;
     private _handleMessage;
-    /**
-     * Adapts a raw error or event input into a standardized `Events.ErrorEvent`.
-     * This utility is called by `_handleError` to ensure it operates on a
-     * consistent error structure.
-     * @param rawErrorOrEventInput - The raw error data (e.g., Error instance, DOM Event, Events.ErrorEvent).
-     * @returns A standardized `Events.ErrorEvent` containing an underlying `Error` instance.
-     */
-    private _adaptError;
-    /**
-     * Core handler for all errors. It first standardizes the error input using `_adaptError`,
-     * then manages disconnection, dispatches the standardized error event, and initiates reconnection.
-     * @param rawErrorOrEventInput - The error data from any internal source.
-     */
     private _handleError;
-    /**
-     * Handles WebSocket close events, either native or synthesized internally.
-     *
-     * Adapts the event if necessary, manages state, dispatches standardized close events,
-     * and initiates reconnection if appropriate.
-     *
-     * @param eventInfo - Either an internal Events.CloseEvent or a native DOM CloseEvent.
-     */
     private _handleClose;
     private _removeListeners;
     private _addListeners;