hume 0.15.3-beta.2 → 0.15.3

package/dist/cjs/core/form-data-utils/FormDataWrapper.js

@@ -51,14 +51,47 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormDataWrapper = void 0;
 exports.newFormData = newFormData;
+const index_js_1 = require("../../core/file/index.js");
 const json_js_1 = require("../../core/json.js");
-const index_js_1 = require("../runtime/index.js");
-function isNamedValue(value) {
-    return typeof value === "object" && value != null && "name" in value;
+const index_js_2 = require("../runtime/index.js");
+function newFormData() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new FormDataWrapper();
+    });
 }
-function isPathedValue(value) {
-    return typeof value === "object" && value != null && "path" in value;
+class FormDataWrapper {
+    constructor() {
+        this.fd = new FormData();
+    }
+    setup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // noop
+        });
+    }
+    append(key, value) {
+        this.fd.append(key, String(value));
+    }
+    appendFile(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, filename, contentType } = yield (0, index_js_1.toMultipartDataPart)(value);
+            const blob = yield convertToBlob(data, contentType);
+            if (filename) {
+                this.fd.append(key, blob, filename);
+            }
+            else {
+                this.fd.append(key, blob);
+            }
+        });
+    }
+    getRequest() {
+        return {
+            body: this.fd,
+            headers: {},
+            duplex: "half",
+        };
+    }
 }
+exports.FormDataWrapper = FormDataWrapper;
 function isStreamLike(value) {
     return typeof value === "object" && value != null && ("read" in value || "pipe" in value);
 }
@@ -71,17 +104,11 @@ function isBuffer(value) {
 function isArrayBufferView(value) {
     return ArrayBuffer.isView(value);
 }
-function getLastPathSegment(pathStr) {
-    const lastForwardSlash = pathStr.lastIndexOf("/");
-    const lastBackSlash = pathStr.lastIndexOf("\\");
-    const lastSlashIndex = Math.max(lastForwardSlash, lastBackSlash);
-    return lastSlashIndex >= 0 ? pathStr.substring(lastSlashIndex + 1) : pathStr;
-}
 function streamToBuffer(stream) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, stream_1, stream_1_1;
         var _b, e_1, _c, _d;
-        if (index_js_1.RUNTIME.type === "node") {
+        if (index_js_2.RUNTIME.type === "node") {
             const { Readable } = yield Promise.resolve().then(() => __importStar(require("stream")));
             if (stream instanceof Readable) {
                 const chunks = [];
@@ -126,83 +153,33 @@ function streamToBuffer(stream) {
             }
             return Buffer.from(result);
         }
-        throw new Error("Unsupported stream type: " + typeof stream + ". Expected Node.js Readable stream or Web ReadableStream.");
+        throw new Error(`Unsupported stream type: ${typeof stream}. Expected Node.js Readable stream or Web ReadableStream.`);
     });
 }
-function newFormData() {
+function convertToBlob(value, contentType) {
     return __awaiter(this, void 0, void 0, function* () {
-        return new FormDataWrapper();
-    });
-}
-class FormDataWrapper {
-    constructor() {
-        this.fd = new FormData();
-    }
-    setup() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // noop
-        });
-    }
-    append(key, value) {
-        this.fd.append(key, String(value));
-    }
-    getFileName(value, filename) {
-        if (filename != null) {
-            return filename;
+        if (isStreamLike(value) || isReadableStream(value)) {
+            const buffer = yield streamToBuffer(value);
+            return new Blob([buffer], { type: contentType });
         }
-        if (isNamedValue(value)) {
-            return value.name;
+        if (value instanceof Blob) {
+            return value;
         }
-        if (isPathedValue(value) && value.path) {
-            return getLastPathSegment(value.path.toString());
+        if (isBuffer(value)) {
+            return new Blob([value], { type: contentType });
         }
-        return undefined;
-    }
-    convertToBlob(value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isStreamLike(value) || isReadableStream(value)) {
-                const buffer = yield streamToBuffer(value);
-                return new Blob([buffer]);
-            }
-            if (value instanceof Blob) {
-                return value;
-            }
-            if (isBuffer(value)) {
-                return new Blob([value]);
-            }
-            if (value instanceof ArrayBuffer) {
-                return new Blob([value]);
-            }
-            if (isArrayBufferView(value)) {
-                return new Blob([value]);
-            }
-            if (typeof value === "string") {
-                return new Blob([value]);
-            }
-            if (typeof value === "object" && value !== null) {
-                return new Blob([(0, json_js_1.toJson)(value)], { type: "application/json" });
-            }
-            return new Blob([String(value)]);
-        });
-    }
-    appendFile(key, value, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            fileName = this.getFileName(value, fileName);
-            const blob = yield this.convertToBlob(value);
-            if (fileName) {
-                this.fd.append(key, blob, fileName);
-            }
-            else {
-                this.fd.append(key, blob);
-            }
-        });
-    }
-    getRequest() {
-        return {
-            body: this.fd,
-            headers: {},
-            duplex: "half",
-        };
-    }
+        if (value instanceof ArrayBuffer) {
+            return new Blob([value], { type: contentType });
+        }
+        if (isArrayBufferView(value)) {
+            return new Blob([value], { type: contentType });
+        }
+        if (typeof value === "string") {
+            return new Blob([value], { type: contentType });
+        }
+        if (typeof value === "object" && value !== null) {
+            return new Blob([(0, json_js_1.toJson)(value)], { type: contentType !== null && contentType !== void 0 ? contentType : "application/json" });
+        }
+        return new Blob([String(value)], { type: contentType });
+    });
 }
-exports.FormDataWrapper = FormDataWrapper;

package/dist/cjs/core/headers.d.ts

@@ -1,3 +1,2 @@
-import * as core from "./index.js";
-export declare function mergeHeaders(...headersArray: (Record<string, string | core.Supplier<string | null | undefined> | null | undefined> | null | undefined)[]): Record<string, string | core.Supplier<string | null | undefined>>;
-export declare function mergeOnlyDefinedHeaders(...headersArray: (Record<string, string | core.Supplier<string | null | undefined> | null | undefined> | null | undefined)[]): Record<string, string | core.Supplier<string | null | undefined>>;
+export declare function mergeHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, string | THeaderValue>;
+export declare function mergeOnlyDefinedHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, THeaderValue>;

package/dist/cjs/core/headers.js

@@ -7,11 +7,12 @@ function mergeHeaders(...headersArray) {
     for (const [key, value] of headersArray
         .filter((headers) => headers != null)
         .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
         if (value != null) {
-            result[key] = value;
+            result[insensitiveKey] = value;
         }
-        else if (key in result) {
-            delete result[key];
+        else if (insensitiveKey in result) {
+            delete result[insensitiveKey];
         }
     }
     return result;
@@ -21,8 +22,9 @@ function mergeOnlyDefinedHeaders(...headersArray) {
     for (const [key, value] of headersArray
         .filter((headers) => headers != null)
         .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
         if (value != null) {
-            result[key] = value;
+            result[insensitiveKey] = value;
         }
     }
     return result;

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

@@ -1,10 +1,11 @@
 export * from "./fetcher/index.js";
+export * as file from "./file/index.js";
+export * from "./form-data-utils/index.js";
+export * as logging from "./logging/index.js";
+export * from "./pagination/index.js";
 export * from "./runtime/index.js";
-export * as url from "./url/index.js";
 export * as serialization from "./schemas/index.js";
-export * from "./websocket/index.js";
 export * from "./stream/index.js";
+export * as url from "./url/index.js";
 export * from "./utils/index.js";
-export * from "./pagination/index.js";
-export * from "./form-data-utils/index.js";
-export * as file from "./file/index.js";
+export * from "./websocket/index.js";

package/dist/cjs/core/index.js

@@ -36,14 +36,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.file = exports.serialization = exports.url = void 0;
+exports.url = exports.serialization = exports.logging = exports.file = void 0;
 __exportStar(require("./fetcher/index.js"), exports);
+exports.file = __importStar(require("./file/index.js"));
+__exportStar(require("./form-data-utils/index.js"), exports);
+exports.logging = __importStar(require("./logging/index.js"));
+__exportStar(require("./pagination/index.js"), exports);
 __exportStar(require("./runtime/index.js"), exports);
-exports.url = __importStar(require("./url/index.js"));
 exports.serialization = __importStar(require("./schemas/index.js"));
-__exportStar(require("./websocket/index.js"), exports);
 __exportStar(require("./stream/index.js"), exports);
+exports.url = __importStar(require("./url/index.js"));
 __exportStar(require("./utils/index.js"), exports);
-__exportStar(require("./pagination/index.js"), exports);
-__exportStar(require("./form-data-utils/index.js"), exports);
-exports.file = __importStar(require("./file/index.js"));
+__exportStar(require("./websocket/index.js"), exports);

package/dist/cjs/core/logging/exports.d.ts

@@ -0,0 +1,18 @@
+import * as logger from "./logger.js";
+export declare namespace logging {
+    /**
+     * Configuration for logger instances.
+     */
+    type LogConfig = logger.LogConfig;
+    type LogLevel = logger.LogLevel;
+    const LogLevel: typeof logger.LogLevel;
+    type ILogger = logger.ILogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    type ConsoleLogger = logger.ConsoleLogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    const ConsoleLogger: typeof logger.ConsoleLogger;
+}

package/dist/{serialization/resources/empathicVoice/resources/configs/client/requests/PostedConfigName.js → cjs/core/logging/exports.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);
@@ -36,8 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostedConfigName = void 0;
-const core = __importStar(require("../../../../../../../core/index.js"));
-exports.PostedConfigName = core.serialization.object({
-    name: core.serialization.string(),
-});
+exports.logging = void 0;
+const logger = __importStar(require("./logger.js"));
+var logging;
+(function (logging) {
+    logging.LogLevel = logger.LogLevel;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    logging.ConsoleLogger = logger.ConsoleLogger;
+})(logging || (exports.logging = logging = {}));

package/dist/cjs/core/logging/index.d.ts

@@ -0,0 +1 @@
+export * from "./logger.js";

package/dist/{core/websocket → cjs/core/logging}/index.js

@@ -14,4 +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 });
-__exportStar(require("./ws.js"), exports);
+__exportStar(require("./logger.js"), exports);

package/dist/cjs/core/logging/logger.d.ts

@@ -0,0 +1,126 @@
+export declare const LogLevel: {
+    readonly Debug: "debug";
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export interface ILogger {
+    /**
+     * Logs a debug message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an info message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an error message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for logger initialization.
+ */
+export interface LogConfig {
+    /**
+     * Minimum log level to output.
+     * @default LogLevel.Info
+     */
+    level?: LogLevel;
+    /**
+     * Logger implementation to use.
+     * @default new ConsoleLogger()
+     */
+    logger?: ILogger;
+    /**
+     * Whether logging should be silenced.
+     * @default true
+     */
+    silent?: boolean;
+}
+/**
+ * Default console-based logger implementation.
+ */
+export declare class ConsoleLogger implements ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export declare class Logger {
+    private readonly level;
+    private readonly logger;
+    private readonly silent;
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config: Required<LogConfig>);
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level: LogLevel): boolean;
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug(): boolean;
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo(): boolean;
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn(): boolean;
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError(): boolean;
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+export declare function createLogger(config?: LogConfig | Logger): Logger;

package/dist/cjs/core/logging/logger.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.ConsoleLogger = exports.LogLevel = void 0;
+exports.createLogger = createLogger;
+exports.LogLevel = {
+    Debug: "debug",
+    Info: "info",
+    Warn: "warn",
+    Error: "error",
+};
+const logLevelMap = {
+    [exports.LogLevel.Debug]: 1,
+    [exports.LogLevel.Info]: 2,
+    [exports.LogLevel.Warn]: 3,
+    [exports.LogLevel.Error]: 4,
+};
+/**
+ * Default console-based logger implementation.
+ */
+class ConsoleLogger {
+    debug(message, ...args) {
+        console.debug(message, ...args);
+    }
+    info(message, ...args) {
+        console.info(message, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(message, ...args);
+    }
+    error(message, ...args) {
+        console.error(message, ...args);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+class Logger {
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config) {
+        this.level = logLevelMap[config.level];
+        this.logger = config.logger;
+        this.silent = config.silent;
+    }
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level) {
+        return !this.silent && this.level >= logLevelMap[level];
+    }
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug() {
+        return this.shouldLog(exports.LogLevel.Debug);
+    }
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message, ...args) {
+        if (this.isDebug()) {
+            this.logger.debug(message, ...args);
+        }
+    }
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo() {
+        return this.shouldLog(exports.LogLevel.Info);
+    }
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message, ...args) {
+        if (this.isInfo()) {
+            this.logger.info(message, ...args);
+        }
+    }
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn() {
+        return this.shouldLog(exports.LogLevel.Warn);
+    }
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.isWarn()) {
+            this.logger.warn(message, ...args);
+        }
+    }
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError() {
+        return this.shouldLog(exports.LogLevel.Error);
+    }
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message, ...args) {
+        if (this.isError()) {
+            this.logger.error(message, ...args);
+        }
+    }
+}
+exports.Logger = Logger;
+function createLogger(config) {
+    var _a, _b, _c;
+    if (config == null) {
+        return defaultLogger;
+    }
+    if (config instanceof Logger) {
+        return config;
+    }
+    config = config !== null && config !== void 0 ? config : {};
+    (_a = config.level) !== null && _a !== void 0 ? _a : (config.level = exports.LogLevel.Info);
+    (_b = config.logger) !== null && _b !== void 0 ? _b : (config.logger = new ConsoleLogger());
+    (_c = config.silent) !== null && _c !== void 0 ? _c : (config.silent = true);
+    return new Logger(config);
+}
+const defaultLogger = new Logger({
+    level: exports.LogLevel.Info,
+    logger: new ConsoleLogger(),
+    silent: true,
+});

package/dist/cjs/core/pagination/Page.d.ts

@@ -1,22 +1,23 @@
-import { HttpResponsePromise, RawResponse } from "../fetcher/index.js";
+import type { HttpResponsePromise, RawResponse } from "../fetcher/index.js";
 /**
  * A page of results from a paginated API.
  *
  * @template T The type of the items in the page.
+ * @template R The type of the API response.
  */
-export declare class Page<T> implements AsyncIterable<T> {
+export declare class Page<T, R = unknown> implements AsyncIterable<T> {
     data: T[];
     rawResponse: RawResponse;
-    private response;
+    response: R;
     private _hasNextPage;
     private getItems;
     private loadNextPage;
     constructor({ response, rawResponse, hasNextPage, getItems, loadPage, }: {
-        response: unknown;
+        response: R;
         rawResponse: RawResponse;
-        hasNextPage: (response: unknown) => boolean;
-        getItems: (response: unknown) => T[];
-        loadPage: (response: unknown) => HttpResponsePromise<any>;
+        hasNextPage: (response: R) => boolean;
+        getItems: (response: R) => T[];
+        loadPage: (response: R) => HttpResponsePromise<R>;
     });
     /**
      * Retrieves the next page

package/dist/cjs/core/pagination/Page.js

@@ -34,6 +34,7 @@ exports.Page = void 0;
  * A page of results from a paginated API.
  *
  * @template T The type of the items in the page.
+ * @template R The type of the API response.
  */
 class Page {
     constructor({ response, rawResponse, hasNextPage, getItems, loadPage, }) {

package/dist/cjs/core/pagination/exports.d.ts

@@ -0,0 +1 @@
+export type { Page } from "./Page.js";

package/dist/cjs/core/pagination/index.d.ts

@@ -1,2 +1 @@
 export { Page } from "./Page.js";
-export { Pageable } from "./Pageable.js";

package/dist/cjs/core/pagination/index.js

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

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

@@ -1,4 +1,4 @@
-import { SchemaUtils } from "./builders/index.js";
+import type { SchemaUtils } from "./builders/index.js";
 export type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;

package/dist/cjs/core/schemas/builders/bigint/bigint.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema.js";
+import { type Schema } from "../../Schema.js";
 export declare function bigint(): Schema<bigint | number, bigint>;

package/dist/cjs/core/schemas/builders/date/date.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema.js";
+import { type Schema } from "../../Schema.js";
 export declare function date(): Schema<string, Date>;

package/dist/cjs/core/schemas/builders/enum/enum.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema.js";
+import { type Schema } from "../../Schema.js";
 export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;

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

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema.js";
+import type { BaseSchema, Schema } from "../../Schema.js";
 export 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>;