@kikiutils/shared 18.2.0 → 19.0.0

package/src/logger/node/index.ts

@@ -0,0 +1,175 @@
+import { writeSync } from 'node:fs';
+import { stripVTControlCharacters } from 'node:util';
+
+import { supportsLoggerColor } from '../_internals/formatter';
+import { getLoggerStreamName } from '../_internals/levels';
+import {
+    createDiagnosticReporter,
+    createLoggerCore,
+} from '../_internals/logger';
+import type { LoggerDiagnostic } from '../types';
+
+import { createFileWriter } from './_internals/file-writer';
+import { formatNodeLoggerRecord } from './_internals/formatter';
+import type {
+    NodeLogger,
+    NodeLoggerOptions,
+} from './types';
+
+interface ConsoleStreamState {
+    onClose: () => void;
+    onError: (error: Error) => void;
+    owners: Set<object>;
+    pending: Set<(error?: Error | null) => void>;
+}
+
+// Constants/Variables
+const consoleStreams = new WeakMap<NodeJS.WriteStream, ConsoleStreamState>();
+
+// Functions
+
+/**
+ * Creates a Node.js/Bun logger with optional bounded, append-only file output and rotation.
+ *
+ * Log calls never throw or reject. Awaiting them waits for processing, not proof of successful
+ * persistence: overload drops the newest file record and failures are reported safely. Factory
+ * validation/open failures reject. Call close explicitly; no process signal handlers are installed.
+ */
+export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise<NodeLogger> {
+    const report = createDiagnosticReporter(options.onError, (message) => writeSync(2, message));
+    let writer: Awaited<ReturnType<typeof createFileWriter>> | undefined;
+    let closed = false;
+    let closePromise: Promise<void> | undefined;
+    const consoleOwner = {};
+    const consoleTargets = new Set<NodeJS.WriteStream>();
+    const consoleWrites = new Set<Promise<void>>();
+    const logger = createLoggerCore(
+        options,
+        {
+            report,
+            write(record) {
+                if (closed) {
+                    report({
+                        message: 'Logger is closed.',
+                        type: 'closed',
+                    });
+
+                    return;
+                }
+
+                if (!record.console && !writer) return;
+                const target = process[getLoggerStreamName(record.type)];
+
+                const text = formatNodeLoggerRecord(record, record.console && supportsLoggerColor(target));
+                if (record.console) {
+                    const line = `${text}\n`;
+                    consoleTargets.add(target);
+                    const completion = writeConsole(target, line, report, consoleOwner);
+                    consoleWrites.add(completion);
+                    void completion.then(() => consoleWrites.delete(completion));
+                    const fileCompletion = writer?.write(`${stripVTControlCharacters(text)}\n`);
+                    return fileCompletion
+                        ? Promise.all([
+                            completion,
+                            fileCompletion,
+                        ]).then(() => {})
+                        : completion;
+                }
+
+                return writer?.write(`${stripVTControlCharacters(text)}\n`);
+            },
+        },
+    );
+
+    if (options.file !== undefined && options.file !== false) writer = await createFileWriter(options.file, report);
+
+    return Object.assign(
+        logger,
+        {
+            close() {
+                if (closePromise) return closePromise;
+                closed = true;
+                closePromise = (async () => {
+                    await Promise.all([
+                        writer?.close(),
+                        ...consoleWrites,
+                    ]);
+
+                    for (const target of consoleTargets) {
+                        const state = consoleStreams.get(target);
+                        if (!state) continue;
+                        state.owners.delete(consoleOwner);
+                        if (!state.owners.size) {
+                            target.off('error', state.onError);
+                            target.off('close', state.onClose);
+                            consoleStreams.delete(target);
+                        }
+                    }
+
+                    consoleTargets.clear();
+                })();
+                return closePromise;
+            },
+            getStats: () => writer?.getStats() ?? {
+                droppedCount: 0,
+                pendingBytes: 0,
+                writeErrorCount: 0,
+            },
+        },
+    );
+}
+
+/** One error listener per shared output stream; retained until its last owning logger calls close(). */
+function writeConsole(
+    target: NodeJS.WriteStream,
+    text: string,
+    report: (event: LoggerDiagnostic) => void,
+    owner: object,
+) {
+    let state = consoleStreams.get(target);
+    if (!state) {
+        const pending = new Set<(error?: Error | null) => void>();
+        const onError = (error: Error) => {
+            for (const settle of pending) settle(error);
+        };
+
+        const onClose = () => onError(new Error('Console stream closed.'));
+        state = {
+            onClose,
+            onError,
+            owners: new Set(),
+            pending,
+        };
+
+        consoleStreams.set(target, state);
+        target.on('error', onError);
+        target.on('close', onClose);
+    }
+
+    state.owners.add(owner);
+    const current = state;
+    return new Promise<void>((resolveWritten) => {
+        let settled = false;
+        const settle = (error?: Error | null) => {
+            if (settled) return;
+            settled = true;
+            current.pending.delete(settle);
+            if (error) {
+                report({
+                    error,
+                    message: 'Console output failed.',
+                    type: 'console',
+                });
+            }
+
+            resolveWritten();
+        };
+
+        current.pending.add(settle);
+        try {
+            target.write(text, settle);
+        } catch (error) {
+            settle(error instanceof Error ? error : new Error('Console output failed.'));
+        }
+    });
+}

package/src/logger/node/types.ts

@@ -0,0 +1,58 @@
+import type { PathLike } from '../../classes/path';
+import type {
+    Logger,
+    LoggerOptions,
+} from '../types';
+
+/** Specify interval and/or maxSize. Size limits use positive integers with B, K, M, or G (binary units). */
+export type LoggerRotationOptions = {
+    /** Gzip historical files. Defaults to true. */
+    compress?: boolean;
+
+    /** Number of historical files, excluding the active file. Defaults to 30. */
+    keepFiles?: number;
+
+    /** Maximum combined size of historical files. */
+    maxTotalSize?: string;
+} & (
+  | {
+      /** Opt-in time rotation aligned to the system's local calendar boundary. */
+      interval: 'daily' | 'hourly';
+      maxSize?: string;
+  }
+  | {
+      /** Opt-in time rotation aligned to the system's local calendar boundary. */
+      interval?: 'daily' | 'hourly';
+      maxSize: string;
+  }
+);
+
+export interface LoggerFileOptions {
+    /** Maximum unfinished payload bytes, including data already submitted to the stream. */
+    maxPendingBytes?: number;
+
+    /** Resolved once at creation. The file is opened in append mode. */
+    path: PathLike;
+
+    /** Omitted or false disables rotation. An object must specify interval or maxSize. */
+    rotate?: false | LoggerRotationOptions;
+}
+
+export interface NodeLogger extends Logger {
+    /** Stop accepting records, finish accepted file writes, then release the stream. Not fsync. */
+    close: () => Promise<void>;
+
+    /** A fresh snapshot. Dropped/failed records still resolve their logging promises. */
+    getStats: () => NodeLoggerStats;
+}
+
+export interface NodeLoggerOptions extends LoggerOptions {
+    /** Disabled by default. Each logger owns at most one fixed file destination. */
+    file?: false | LoggerFileOptions;
+}
+
+export interface NodeLoggerStats {
+    droppedCount: number;
+    pendingBytes: number;
+    writeErrorCount: number;
+}

package/src/logger/types.ts

@@ -0,0 +1,59 @@
+/** Minimum severity to emit; `success` uses the same threshold as `info`. */
+export type LoggerLevel = 'debug' | 'error' | 'fatal' | 'info' | 'silent' | 'trace' | 'warn';
+
+/** A logging method, including the informational success presentation. */
+export type LoggerMethod = 'success' | Exclude<LoggerLevel, 'silent'>;
+
+/**
+ * A logger whose logging methods never throw or reject for recoverable failures.
+ *
+ * Awaiting a method waits for processing, not guaranteed successful delivery or fsync.
+ * Configuration errors may throw from the factory, configure(), or setLevel().
+ */
+export interface Logger {
+    configure: (options: Pick<LoggerOptions, 'console' | 'icons' | 'prefix' | 'suffix' | 'timestamp'>) => void;
+    debug: (...args: unknown[]) => Promise<void>;
+    error: (...args: unknown[]) => Promise<void>;
+    fatal: (...args: unknown[]) => Promise<void>;
+    info: (...args: unknown[]) => Promise<void>;
+
+    /** Accepts success as an informational method; it is not a configurable threshold. */
+    isLevelEnabled: (level: LoggerLevel | LoggerMethod) => boolean;
+
+    /** Sets a severity threshold (not success); env restores environment-driven filtering. */
+    setLevel: (level: 'env' | LoggerLevel) => void;
+    success: (...args: unknown[]) => Promise<void>;
+    trace: (...args: unknown[]) => Promise<void>;
+    warn: (...args: unknown[]) => Promise<void>;
+}
+
+/** A recoverable logging failure, reported without throwing from log methods. */
+export interface LoggerDiagnostic {
+    droppedCount?: number;
+    error?: unknown;
+    message: string;
+
+    /** Same-type notifications suppressed since the previous emitted diagnostic. */
+    suppressedCount?: number;
+    type: 'closed' | 'console' | 'file' | 'format' | 'invalid-level' | 'overflow';
+}
+
+/** Configuration shared by browser and server loggers. */
+export interface LoggerOptions {
+    /** Enables console output. Defaults to `true`. */
+    console?: boolean;
+
+    /** Enables Unicode level icons. Defaults to `true`. */
+    icons?: boolean;
+
+    /** Overrides LOG_LEVEL; `env` restores the environment-driven threshold. */
+    level?: 'env' | LoggerLevel;
+
+    /** Best-effort, rate-limited notification; failures in this callback are contained. */
+    onError?: (event: LoggerDiagnostic) => void;
+    prefix?: string;
+    suffix?: string;
+
+    /** Enables the fixed local-time millisecond prefix. Defaults to `true`. */
+    timestamp?: boolean;
+}

package/src/storages/lru/keyed-store.ts

@@ -7,6 +7,7 @@ import type { LRUCache } from 'lru-cache';
  * The key resolver is called synchronously once per operation, and its exceptions propagate.
  * Reads return the cached value without copying it, or `null` for missing or nullish values.
  * `getItemTtl` exposes the underlying remaining TTL in milliseconds; `setItem` returns the underlying cache.
+ * `setItemWithTtl` accepts its TTL in milliseconds before the value and key arguments and returns the cache.
  * The facade does not dispose the supplied cache, and LRU defaults remain those of the supplied instance.
  *
  * @typeParam D - The stored value type used by reads and writes.
@@ -46,5 +47,8 @@ export function createLruKeyedStore<D = unknown>(lruInstance: LRUCache<any, any,
          */
         resolveKey: (...args: P) => keyFn(...args),
         setItem: (value: D, ...args: P) => lruInstance.set(keyFn(...args), value),
+        setItemWithTtl(ttlMilliseconds: number, value: D, ...args: P) {
+            return lruInstance.set(keyFn(...args), value, { ttl: ttlMilliseconds });
+        },
     });
 }

package/src/types/index.ts

@@ -6,11 +6,6 @@ import type {
 
 export type { FilteredKeyPath } from './filtered-key-path';
 
-/**
- * A generic string-keyed object for utility APIs that intentionally accept any value shape.
- */
-export type AnyRecord = Record<string, any>;
-
 /**
  * Binary-like inputs accepted by `toBuffer` across browser and Node.js runtimes.
  */
@@ -31,11 +26,6 @@ export type MaybePartial<T> = Partial<T> | T;
  */
 export type MaybeReadonly<T> = Readonly<T> | T;
 
-/**
- * Number-like value represented as a number or a numeric string.
- */
-export type Numberish = number | string;
-
 /**
  * A `Record` where every key is optional.
  */

package/dist/classes/ssh-client.d.ts

@@ -1,39 +0,0 @@
-import { PathLike } from "./path.js";
-import { Config, NodeSSH, SSHExecCommandOptions, SSHGetPutDirectoryOptions, SSHPutFilesOptions } from "node-ssh";
-import { SFTPWrapper, TransferOptions } from "ssh2";
-//#region src/classes/ssh-client.d.ts
-declare const loggerLevelStringToConsolaLogLevelMap: {
-  readonly debug: 4;
-  readonly error: 0;
-  readonly fatal: 0;
-  readonly info: 3;
-  readonly normal: 2;
-  readonly silent: -999;
-  readonly trace: 5;
-  readonly verbose: 999;
-  readonly warn: 1;
-};
-export declare class SshClient {
-  #private;
-  getDir: (localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) => Promise<boolean>;
-  putDir: (localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) => Promise<boolean>;
-  constructor(host: string, username: string, password: string, port?: number, connectConfig?: Config);
-  get nodeSsh(): NodeSSH;
-  connect(): Promise<boolean>;
-  disconnect(): boolean;
-  execCommand(command: string, options?: SSHExecCommandOptions): Promise<void | import("node-ssh").SSHExecCommandResponse>;
-  execCommandWithIo(command: string, options?: SSHExecCommandOptions): Promise<void | import("node-ssh").SSHExecCommandResponse>;
-  getDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions): Promise<boolean>;
-  getFile(localFile: PathLike, remoteFile: PathLike, givenSftp?: null | SFTPWrapper, transferOptions?: null | TransferOptions): Promise<boolean>;
-  isConnected(): boolean;
-  mkdir(path: PathLike): Promise<boolean>;
-  putDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions): Promise<boolean>;
-  putFile(localFile: PathLike, remoteFile: PathLike, givenSftp?: null | SFTPWrapper, transferOptions?: null | TransferOptions): Promise<boolean>;
-  putFiles(files: {
-    local: PathLike;
-    remote: PathLike;
-  }[], options?: SSHPutFilesOptions): Promise<boolean>;
-  setLoggerLevel(level: keyof typeof loggerLevelStringToConsolaLogLevelMap): void;
-}
-//#endregion
-//# sourceMappingURL=ssh-client.d.ts.map

package/dist/classes/ssh-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssh-client.d.ts","names":[],"sources":["../../src/classes/ssh-client.ts"],"mappings":";;;;cAgBM;;;;;;;;;;;qBAYO;;EAOT,SAAM,gBA2D6B,UAAQ,iBAAmB,UAAQ,UAAY,8BAAyB;EA1D3G,SAAM,gBAgG6B,UAAQ,iBAAmB,UAAQ,UAAY,8BAAyB;EA7F/F,YAAA,cAAc,kBAAkB,kBAAkB,eAAmB,gBAAgB;MAe7F,WAAO;EAKL,WAAO;EAUb;EAUA,YAAY,iBAAiB,UAAU,wBAAqB,kCAAA;EAI5D,kBAAkB,iBAAiB,UAAU,wBAAqB,kCAAA;EAW5D,aAAa,gBAAgB,UAAU,iBAAiB,UAAU,UAAU,4BAAyB;EASrG,QACF,WAAW,UACX,YAAY,UACZ,mBAAmB,aACnB,yBAAyB,kBAAe;EAW5C;EAIM,MAAM,MAAM,WAAQ;EAUpB,aAAa,gBAAgB,UAAU,iBAAiB,UAAU,UAAU,4BAAyB;EASrG,QACF,WAAW,UACX,YAAY,UACZ,mBAAmB,aACnB,yBAAyB,kBAAe;EAWtC,SAAS;IAAS,OAAO;IAAU,QAAQ;OAAc,UAAU,qBAAkB;EAe3F,eAAe,oBAAoB"}

package/dist/classes/ssh-client.js

@@ -1,130 +0,0 @@
-import { createConsola } from "consola";
-import { NodeSSH } from "node-ssh";
-//#region src/classes/ssh-client.ts
-const loggerLevelStringToConsolaLogLevelMap = {
-	debug: 4,
-	error: 0,
-	fatal: 0,
-	info: 3,
-	normal: 2,
-	silent: -999,
-	trace: 5,
-	verbose: 999,
-	warn: 1
-};
-var SshClient = class {
-	#connectConfig;
-	#logger;
-	#nodeSsh;
-	getDir = this.getDirectory;
-	putDir = this.putDirectory;
-	constructor(host, username, password, port = 22, connectConfig) {
-		this.#connectConfig = {
-			...connectConfig,
-			host,
-			password,
-			port,
-			username
-		};
-		this.#logger = createConsola();
-		this.#nodeSsh = new NodeSSH();
-		if (process.env.NODE_ENV === "production") this.setLoggerLevel("error");
-	}
-	get nodeSsh() {
-		return this.#nodeSsh;
-	}
-	async connect() {
-		try {
-			this.#nodeSsh = await this.#nodeSsh.connect(this.#connectConfig);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	disconnect() {
-		try {
-			this.#nodeSsh.dispose();
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	execCommand(command, options) {
-		return this.#nodeSsh.execCommand(command, options).catch(() => {});
-	}
-	execCommandWithIo(command, options) {
-		return this.execCommand(command, {
-			...options,
-			onStderr: (data) => process.stderr.write(data.toString()),
-			onStdout: (data) => process.stdout.write(data.toString())
-		});
-	}
-	async getDirectory(localDirectory, remoteDirectory, options) {
-		try {
-			return await this.#nodeSsh.getDirectory(localDirectory.toString(), remoteDirectory.toString(), options);
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async getFile(localFile, remoteFile, givenSftp, transferOptions) {
-		try {
-			await this.#nodeSsh.getFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	isConnected() {
-		return this.#nodeSsh.isConnected();
-	}
-	async mkdir(path) {
-		try {
-			await this.#nodeSsh.mkdir(path.toString());
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async putDirectory(localDirectory, remoteDirectory, options) {
-		try {
-			return await this.#nodeSsh.putDirectory(localDirectory.toString(), remoteDirectory.toString(), options);
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async putFile(localFile, remoteFile, givenSftp, transferOptions) {
-		try {
-			await this.#nodeSsh.putFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async putFiles(files, options) {
-		try {
-			const convertedFiles = files.map(({ local, remote }) => ({
-				local: local.toString(),
-				remote: remote.toString()
-			}));
-			await this.#nodeSsh.putFiles(convertedFiles, options);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	setLoggerLevel(level) {
-		this.#logger.level = loggerLevelStringToConsolaLogLevelMap[level];
-	}
-};
-//#endregion
-export { SshClient };
-
-//# sourceMappingURL=ssh-client.js.map

package/dist/classes/ssh-client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssh-client.js","names":[],"sources":["../../src/classes/ssh-client.ts"],"sourcesContent":["import { createConsola } from 'consola';\nimport type { ConsolaInstance } from 'consola';\nimport { NodeSSH } from 'node-ssh';\nimport type {\n    Config,\n    SSHExecCommandOptions,\n    SSHGetPutDirectoryOptions,\n    SSHPutFilesOptions,\n} from 'node-ssh';\nimport type {\n    SFTPWrapper,\n    TransferOptions,\n} from 'ssh2';\n\nimport type { PathLike } from './path';\n\nconst loggerLevelStringToConsolaLogLevelMap = {\n    debug: 4,\n    error: 0,\n    fatal: 0,\n    info: 3,\n    normal: 2,\n    silent: -999,\n    trace: 5,\n    verbose: 999,\n    warn: 1,\n} as const;\n\nexport class SshClient {\n    // Private instance properties\n    readonly #connectConfig: Config;\n    readonly #logger: ConsolaInstance;\n    #nodeSsh: NodeSSH;\n\n    // Public instance properties\n    getDir = this.getDirectory;\n    putDir = this.putDirectory;\n\n    // Constructor\n    constructor(host: string, username: string, password: string, port: number = 22, connectConfig?: Config) {\n        this.#connectConfig = {\n            ...connectConfig,\n            host,\n            password,\n            port,\n            username,\n        };\n\n        this.#logger = createConsola();\n        this.#nodeSsh = new NodeSSH();\n        if (process.env.NODE_ENV === 'production') this.setLoggerLevel('error');\n    }\n\n    // Public instance accessors\n    get nodeSsh() {\n        return this.#nodeSsh;\n    }\n\n    // Public instance methods\n    async connect() {\n        try {\n            this.#nodeSsh = await this.#nodeSsh.connect(this.#connectConfig);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    disconnect() {\n        try {\n            this.#nodeSsh.dispose();\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    execCommand(command: string, options?: SSHExecCommandOptions) {\n        return this.#nodeSsh.execCommand(command, options).catch(() => {});\n    }\n\n    execCommandWithIo(command: string, options?: SSHExecCommandOptions) {\n        return this.execCommand(\n            command,\n            {\n                ...options,\n                onStderr: (data) => process.stderr.write(data.toString()),\n                onStdout: (data) => process.stdout.write(data.toString()),\n            },\n        );\n    }\n\n    async getDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) {\n        try {\n            return await this.#nodeSsh.getDirectory(localDirectory.toString(), remoteDirectory.toString(), options);\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async getFile(\n        localFile: PathLike,\n        remoteFile: PathLike,\n        givenSftp?: null | SFTPWrapper,\n        transferOptions?: null | TransferOptions,\n    ) {\n        try {\n            await this.#nodeSsh.getFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    isConnected() {\n        return this.#nodeSsh.isConnected();\n    }\n\n    async mkdir(path: PathLike) {\n        try {\n            await this.#nodeSsh.mkdir(path.toString());\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async putDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) {\n        try {\n            return await this.#nodeSsh.putDirectory(localDirectory.toString(), remoteDirectory.toString(), options);\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async putFile(\n        localFile: PathLike,\n        remoteFile: PathLike,\n        givenSftp?: null | SFTPWrapper,\n        transferOptions?: null | TransferOptions,\n    ) {\n        try {\n            await this.#nodeSsh.putFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async putFiles(files: { local: PathLike; remote: PathLike }[], options?: SSHPutFilesOptions) {\n        try {\n            const convertedFiles = files.map(({ local, remote }) => ({\n                local: local.toString(),\n                remote: remote.toString(),\n            }));\n\n            await this.#nodeSsh.putFiles(convertedFiles, options);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    setLoggerLevel(level: keyof typeof loggerLevelStringToConsolaLogLevelMap) {\n        this.#logger.level = loggerLevelStringToConsolaLogLevelMap[level];\n    }\n}\n"],"mappings":"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"}

package/dist/consola.d.ts

@@ -1,24 +0,0 @@
-//#region src/consola.d.ts
-/**
- * A consola logger with environment-controlled verbosity.
- *
- * @remarks
- * `CONSOLA_LOGGER_LEVEL` sets the log level when defined at module initialization;
- * otherwise, `NODE_ENV=production` selects `0`, and other environments retain the logger's default level.
- * Assign `logger.level` to change verbosity after initialization.
- *
- * @example
- *
- * ```ts
- * import { logger } from '@kikiutils/shared/consola';
- *
- * logger.level = 3;
- * logger.info('Application started');
- * ```
- *
- * @see {@link https://github.com/unjs/consola#log-level | Consola log levels}
- */
-export declare const consolaLogger: import("consola").ConsolaInstance;
-export declare const logger: import("consola").ConsolaInstance;
-//#endregion
-//# sourceMappingURL=consola.d.ts.map

package/dist/consola.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consola.d.ts","names":[],"sources":["../src/consola.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAqBa,iCAAa;qBACb,0BAAM"}

package/dist/consola.js

@@ -1,29 +0,0 @@
-import { createConsola } from "consola";
-//#region src/consola.ts
-/**
-* A consola logger with environment-controlled verbosity.
-*
-* @remarks
-* `CONSOLA_LOGGER_LEVEL` sets the log level when defined at module initialization;
-* otherwise, `NODE_ENV=production` selects `0`, and other environments retain the logger's default level.
-* Assign `logger.level` to change verbosity after initialization.
-*
-* @example
-*
-* ```ts
-* import { logger } from '@kikiutils/shared/consola';
-*
-* logger.level = 3;
-* logger.info('Application started');
-* ```
-*
-* @see {@link https://github.com/unjs/consola#log-level | Consola log levels}
-*/
-const consolaLogger = createConsola();
-const logger = consolaLogger;
-if (process.env.CONSOLA_LOGGER_LEVEL !== void 0) consolaLogger.level = +process.env.CONSOLA_LOGGER_LEVEL;
-else consolaLogger.level = process.env.NODE_ENV === "production" ? 0 : consolaLogger.level;
-//#endregion
-export { consolaLogger, logger };
-
-//# sourceMappingURL=consola.js.map

package/dist/consola.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"consola.js","names":[],"sources":["../src/consola.ts"],"sourcesContent":["import { createConsola } from 'consola';\n\n/**\n * A consola logger with environment-controlled verbosity.\n *\n * @remarks\n * `CONSOLA_LOGGER_LEVEL` sets the log level when defined at module initialization;\n * otherwise, `NODE_ENV=production` selects `0`, and other environments retain the logger's default level.\n * Assign `logger.level` to change verbosity after initialization.\n *\n * @example\n *\n * ```ts\n * import { logger } from '@kikiutils/shared/consola';\n *\n * logger.level = 3;\n * logger.info('Application started');\n * ```\n *\n * @see {@link https://github.com/unjs/consola#log-level | Consola log levels}\n */\nexport const consolaLogger = createConsola();\nexport const logger = consolaLogger;\nif (process.env.CONSOLA_LOGGER_LEVEL !== undefined) consolaLogger.level = +process.env.CONSOLA_LOGGER_LEVEL;\nelse consolaLogger.level = process.env.NODE_ENV === 'production' ? 0 : consolaLogger.level;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,gBAAgB,cAAc;AAC3C,MAAa,SAAS;AACtB,IAAI,QAAQ,IAAI,yBAAyB,KAAA,GAAW,cAAc,QAAQ,CAAC,QAAQ,IAAI;KAClF,cAAc,QAAQ,QAAQ,IAAI,aAAa,eAAe,IAAI,cAAc"}

package/dist/object.d.ts

@@ -1,44 +0,0 @@
-//#region src/object.d.ts
-/**
- * Serializes a nested object into a deterministic, flat string format.
- *
- * @remarks
- * This function recursively traverses the input object (including nested objects and arrays),
- * flattens it into key paths using dot notation (e.g. "a.b.0.c"), sorts all keys,
- * and joins each key-value pair into a string with customizable separators.
- *
- * It is designed for use cases such as signature generation, cache key construction,
- * or any context requiring consistent and predictable object serialization.
- *
- * Note: Empty objects and arrays produce an empty string, which is useful for
- * generating deterministic signature payloads.
- *
- * @param input - The object to serialize. Can contain nested objects and arrays.
- * @param kvSeparator - The string used to separate each key from its value (default: '=').
- * @param pairSeparator - The string used to separate each key-value pair (default: '&').
- *
- * @returns A deterministic string representation of the input object.
- *
- * @example
- *
- * ```ts
- * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';
- *
- * console.log(stringifyObjectDeterministically({
- *     b: 2,
- *     a: {
- *         x: 1,
- *         y: [
- *             3,
- *             4,
- *         ],
- *     },
- * })); // => a.x=1&a.y.0=3&a.y.1=4&b=2
- *
- * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // => foo:bar
- * console.log(stringifyObjectDeterministically({})); // => ''
- * ```
- */
-export declare function stringifyObjectDeterministically(input: Record<string, any>, kvSeparator?: string, pairSeparator?: string): string;
-//#endregion
-//# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.d.ts","names":[],"sources":["../src/object.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwCgB,iCACZ,OAAO,qBACP,sBACA"}