@kikiutils/shared 18.3.0 → 20.0.0

package/dist/logger/node/_internals/formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/logger/node/_internals/formatter.ts"],"sourcesContent":["import { inspect } from 'node:util';\n\nimport { formatLoggerParts } from '../../_internals/formatter';\nimport type { LoggerRecord } from '../../_internals/types';\n\n// Functions\n\n/** Preserve user ANSI for console output without invoking custom inspect callbacks/getters. */\nexport function formatNodeLoggerRecord(record: LoggerRecord, colors = false) {\n    const message = record.args.map(\n        (arg) => typeof arg === 'string'\n            ? arg\n            : inspect(\n                arg,\n                {\n                    colors: false,\n                    customInspect: false,\n                    depth: 6,\n                    getters: false,\n                    maxArrayLength: 100,\n                    maxStringLength: 10_000,\n                },\n            ),\n    ).join(' ');\n\n    return formatLoggerParts(\n        {\n            ...record,\n            args: record.args.length ? [message] : [],\n        },\n        colors,\n    ).join(' ');\n}\n"],"mappings":";;;;AAQA,SAAgB,uBAAuB,QAAsB,SAAS,OAAO;CACzE,MAAM,UAAU,OAAO,KAAK,KACvB,QAAQ,OAAO,QAAQ,WAClB,MACA,QACE,KACA;EACI,QAAQ;EACR,eAAe;EACf,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,iBAAiB;CACrB,CACJ,CACR,CAAC,CAAC,KAAK,GAAG;CAEV,OAAO,kBACH;EACI,GAAG;EACH,MAAM,OAAO,KAAK,SAAS,CAAC,OAAO,IAAI,CAAC;CAC5C,GACA,MACJ,CAAC,CAAC,KAAK,GAAG;AACd"}

package/dist/logger/node/index.d.ts

@@ -0,0 +1,10 @@
+import { NodeLogger, NodeLoggerOptions } from "./types.js";
+/**
+ * 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 declare function createNodeLogger(options?: NodeLoggerOptions): Promise<Readonly<NodeLogger>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/logger/node/index.ts"],"mappings":";;;;;;;;wBAqCsB,iBAAiB,UAAS,oBAAyB,QAAQ,SAAS"}

package/dist/logger/node/index.js

@@ -0,0 +1,123 @@
+import { getLoggerStreamName } from "../_internals/levels.js";
+import { supportsLoggerColor } from "../_internals/formatter.js";
+import { createDiagnosticReporter, createLoggerCore } from "../_internals/logger.js";
+import { createFileWriter } from "./_internals/file-writer.js";
+import { formatNodeLoggerRecord } from "./_internals/formatter.js";
+import { writeSync } from "node:fs";
+import { stripVTControlCharacters } from "node:util";
+// src/logger/node/index.ts
+const consoleStreams = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
+async function createNodeLogger(options = {}) {
+	const report = createDiagnosticReporter(options.onError, (message) => writeSync(2, message));
+	let writer;
+	let closed = false;
+	let closePromise;
+	const consoleOwner = {};
+	const consoleTargets = /* @__PURE__ */ new Set();
+	const consoleWrites = /* @__PURE__ */ new Set();
+	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);
+				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 !== void 0 && options.file !== false) writer = await createFileWriter(options.file, report);
+	return Object.freeze({
+		...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() ?? Object.freeze({
+			droppedCount: 0,
+			pendingBytes: 0,
+			writeErrorCount: 0
+		})
+	});
+}
+/** One error listener per shared output stream; retained until its last owning logger calls close(). */
+function writeConsole(target, text, report, owner) {
+	let state = consoleStreams.get(target);
+	if (!state) {
+		const pending = /* @__PURE__ */ new Set();
+		const onError = (error) => {
+			for (const settle of pending) settle(error);
+		};
+		const onClose = () => onError(/* @__PURE__ */ new Error("Console stream closed."));
+		state = {
+			onClose,
+			onError,
+			owners: /* @__PURE__ */ 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((resolveWritten) => {
+		let settled = false;
+		const settle = (error) => {
+			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 : /* @__PURE__ */ new Error("Console output failed."));
+		}
+	});
+}
+export { createNodeLogger };
+
+//# sourceMappingURL=index.js.map

package/dist/logger/node/index.js.map

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

package/dist/logger/node/types.d.ts

@@ -0,0 +1,43 @@
+import { PathLike } from "../../classes/path.js";
+import { Logger, LoggerOptions } from "../types.js";
+/** 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, frozen file-output snapshot. Dropped/failed records still resolve their logging promises. */
+  getStats: () => Readonly<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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/logger/node/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/logger/node/types.ts"],"mappings":";;;YAOY;;EAER;;EAGA;;EAGA;;;EAIE;EACA;;;EAIA;EACA;;iBAIW;;EAEb;;EAGA,MAAM;;EAGN,iBAAiB;;iBAGJ,mBAAmB;;EAEhC,aAAa;;EAGb,gBAAgB,SAAS;;iBAGZ,0BAA0B;;EAEvC,eAAe;;iBAGF;EACb;EACA;EACA"}

package/dist/logger/node/types.js

@@ -0,0 +1 @@
+export {};

package/dist/logger/types.d.ts

@@ -0,0 +1,50 @@
+/** 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().
+ * Factories freeze the API object; settings remain adjustable through its methods.
+ */
+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 shallow-frozen failure notification; nested error values retain their original ownership. */
+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: Readonly<LoggerDiagnostic>) => void;
+  prefix?: string;
+  suffix?: string;
+  /** Enables the fixed local-time millisecond prefix. Defaults to `true`. */
+  timestamp?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/logger/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/logger/types.ts"],"mappings":";YACY;;YAGA,2BAA2B,QAAQ;;;;;;;;iBAS9B;EACb,YAAY,SAAS,KAAK;EAC1B,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,UAAU,oBAAoB;;EAG9B,iBAAiB,OAAO,cAAc;;EAGtC,WAAW,eAAe;EAC1B,aAAa,oBAAoB;EACjC,WAAW,oBAAoB;EAC/B,UAAU,oBAAoB;;;iBAIjB;EACb;EACA;EACA;;EAGA;EACA;;;iBAIa;;EAEb;;EAGA;;EAGA,gBAAgB;;EAGhB,WAAW,OAAO,SAAS;EAC3B;EACA;;EAGA"}

package/dist/logger/types.js

@@ -0,0 +1 @@
+export {};

package/dist/math.d.ts

@@ -1,5 +1,4 @@
 import { Decimal } from "decimal.js";
-//#region src/math.d.ts
 type CalculableValue = Decimal.Value | {
   toString: () => string;
 };
@@ -45,6 +44,5 @@ export interface ToPercentageStringOptions {
  * ```
  */
 export declare function toPercentageString(molecular: CalculableValue, denominator: CalculableValue, options?: ToPercentageStringOptions): string;
-//#endregion
 export {};
 //# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"mappings":";;KAEK,kBAAkB,QAAQ;EAAU;;;;;iBAKxB;;;;;;EAMb;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BY,mBACZ,WAAW,iBACX,aAAa,iBACb,UAAU"}
+{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"mappings":";KAEK,kBAAkB,QAAQ;EAAU;;;;;iBAKxB;;;;;;EAMb;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BY,mBACZ,WAAW,iBACX,aAAa,iBACb,UAAU"}

package/dist/math.js

@@ -1,5 +1,5 @@
 import { Decimal } from "decimal.js";
-//#region src/math.ts
+// src/math.ts
 /**
 * Converts a numerator and denominator into a formatted percentage.
 *
@@ -31,7 +31,6 @@ function toPercentageString(molecular, denominator, options) {
 	const result = calculationResult.isNaN() || !calculationResult.isFinite() ? "0.00" : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);
 	return options?.withSymbol ?? true ? `${result}%` : result;
 }
-//#endregion
 export { toPercentageString };
 
 //# sourceMappingURL=math.js.map

package/dist/number.d.ts

@@ -1,5 +1,4 @@
 import { millify } from "millify";
-//#region src/number.d.ts
 /**
  * Converts a large number into a compact, human-readable string using `millify`.
  *
@@ -21,5 +20,4 @@ import { millify } from "millify";
  * ```
  */
 export declare function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]): string;
-//#endregion
 //# sourceMappingURL=number.d.ts.map

package/dist/number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","names":[],"sources":["../src/number.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;wBAsBgB,sBAAsB,eAAe,UAAU,kBAAkB"}
+{"version":3,"file":"number.d.ts","names":[],"sources":["../src/number.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBAsBgB,sBAAsB,eAAe,UAAU,kBAAkB"}

package/dist/number.js

@@ -1,5 +1,5 @@
 import { millify } from "millify";
-//#region src/number.ts
+// src/number.ts
 /**
 * Converts a large number into a compact, human-readable string using `millify`.
 *
@@ -27,7 +27,6 @@ function toCompactNumberString(value, options) {
 		...options
 	});
 }
-//#endregion
 export { toCompactNumberString };
 
 //# sourceMappingURL=number.js.map

package/dist/random.d.ts

@@ -1,4 +1,3 @@
-//#region src/random.d.ts
 /**
  * Calls a generator once with a length sampled from two nested random ranges.
  *
@@ -23,5 +22,4 @@
  * @throws Error if `minMin` exceeds `minMax` or `maxMin` exceeds `maxMax`.
  */
 export declare function generateWithNestedRandomLength<T = string>(generator: (length: number) => T, minMin: number, minMax: number, maxMin: number, maxMax: number): T;
-//#endregion
 //# sourceMappingURL=random.d.ts.map

package/dist/random.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random.d.ts","names":[],"sources":["../src/random.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBAuBgB,+BAA+B,YAC3C,YAAY,mBAAmB,GAC/B,gBACA,gBACA,gBACA,iBAAc"}
+{"version":3,"file":"random.d.ts","names":[],"sources":["../src/random.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBAuBgB,+BAA+B,YAC3C,YAAY,mBAAmB,GAC/B,gBACA,gBACA,gBACA,iBAAc"}

package/dist/random.js

@@ -1,4 +1,4 @@
-//#region src/random.ts
+// src/random.ts
 /**
 * Calls a generator once with a length sampled from two nested random ranges.
 *
@@ -29,7 +29,6 @@ function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMa
 	const innerMin = random(minMin, minMax);
 	return generator(random(Math.max(innerMin, maxMin), maxMax));
 }
-//#endregion
 export { generateWithNestedRandomLength };
 
 //# sourceMappingURL=random.js.map

package/dist/redis/script-runner.d.ts

@@ -1,4 +1,3 @@
-//#region src/redis/script-runner.d.ts
 /**
  * An asynchronous Lua script runner with caller-declared results.
  *
@@ -53,5 +52,4 @@ export interface RedisLikeScriptClient {
  * @throws RangeError if `maxAttempts` is not a positive safe integer.
  */
 export declare function createRedisScriptRunner<T = unknown>(client: RedisLikeScriptClient, source: string, maxAttempts?: number): RedisScriptRunner<T>;
-//#endregion
 //# sourceMappingURL=script-runner.d.ts.map

package/dist/redis/script-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script-runner.d.ts","names":[],"sources":["../../src/redis/script-runner.ts"],"mappings":";;;;;;;;;;;;;;;YAgBY,kBAAkB,gBAAgB,yBAAyB,uCAAuC,QAC1G;;;;;;;;;iBAWa;;;;;;;EAOb,OAAO,iBAAiB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;wBAwB/B,wBAAwB,aACpC,QAAQ,uBACR,gBACA,uBACD,kBAAkB"}
+{"version":3,"file":"script-runner.d.ts","names":[],"sources":["../../src/redis/script-runner.ts"],"mappings":";;;;;;;;;;;;;;YAgBY,kBAAkB,gBAAgB,yBAAyB,uCAAuC,QAC1G;;;;;;;;;iBAWa;;;;;;;EAOb,OAAO,iBAAiB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;wBAwB/B,wBAAwB,aACpC,QAAQ,uBACR,gBACA,uBACD,kBAAkB"}

package/dist/redis/script-runner.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-//#region src/redis/script-runner.ts
+// src/redis/script-runner.ts
 /**
 * Creates a Lua script runner that reloads missing cached scripts before retrying execution.
 *
@@ -40,7 +40,6 @@ function createRedisScriptRunner(client, source, maxAttempts = 3) {
 		}
 	};
 }
-//#endregion
 export { createRedisScriptRunner };
 
 //# sourceMappingURL=script-runner.js.map

package/dist/storages/lru/keyed-store.d.ts

@@ -1,5 +1,4 @@
 import { LRUCache } from "lru-cache";
-//#region src/storages/lru/keyed-store.d.ts
 /**
  * Creates a keyed cache factory sharing a caller-owned LRU cache.
  *
@@ -45,5 +44,4 @@ export declare function createLruKeyedStore<D = unknown>(lruInstance: LRUCache<a
   setItem: (value: D, ...args: P) => LRUCache<any, any, any>;
   setItemWithTtl(ttlMilliseconds: number, value: D, ...args: P): LRUCache<any, any, any>;
 }>;
-//#endregion
 //# sourceMappingURL=keyed-store.d.ts.map

package/dist/storages/lru/keyed-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/lru/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BgB,oBAAoB,aAAa,aAAa,2BAClD,iBAAiB,WAAW,MAAM,iBAAY;;;;;;EAMjC,WAAA,MAAA,IAAC,YAAA;EAII,gBAAA,MAAA;EACH,aAAA,MAAA;EACG,gBAAA,MAAA;;;;EAIA,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACE,eAAA,yBAAM,OAAS,MAAC,MAAW,IAAC"}
+{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/lru/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BgB,oBAAoB,aAAa,aAAa,2BAClD,iBAAiB,WAAW,MAAM,iBAAY;;;;;;EAMjC,WAAA,MAAA,IAAC,YAAA;EAII,gBAAA,MAAA;EACH,aAAA,MAAA;EACG,gBAAA,MAAA;;;;EAIA,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACE,eAAA,yBAAM,OAAS,MAAC,MAAW,IAAC"}

package/dist/storages/lru/keyed-store.js

@@ -1,4 +1,4 @@
-//#region src/storages/lru/keyed-store.ts
+// src/storages/lru/keyed-store.ts
 /**
 * Creates a keyed cache factory sharing a caller-owned LRU cache.
 *
@@ -50,7 +50,6 @@ function createLruKeyedStore(lruInstance) {
 		}
 	});
 }
-//#endregion
 export { createLruKeyedStore };
 
 //# sourceMappingURL=keyed-store.js.map

package/dist/storages/redis/keyed-store.d.ts

@@ -1,13 +1,12 @@
 import { MaybeReadonly } from "../../types/index.js";
 import { RedisLikeStorage } from "./types.js";
-//#region src/storages/redis/keyed-store.d.ts
 /**
  * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.
  *
  * @remarks
  * The key resolver is called synchronously once per operation with the operation's key arguments.
  * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.
- * `setItemWithTtl` accepts its TTL in seconds before the value and key arguments.
+ * `setItemWithTtl` and `setItemWithTtlIfAbsent` accept their TTL in seconds before the value and key arguments.
  * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.
  *
  * @typeParam D - The stored value type used by reads and writes.
@@ -15,9 +14,10 @@ import { RedisLikeStorage } from "./types.js";
  * @param storage - The shared Redis-like storage instance.
  *
  * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.
- * Reads, writes, removals, and TTL results retain the underlying storage contract.
+ * Reads, atomic read-and-removals, writes, removals, and TTL results retain the underlying storage contract.
  */
 export declare function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>): <P extends any[]>(keyFn: (...args: P) => string) => Readonly<{
+  getAndRemoveItem: (...args: P) => Promise<D | null>;
   getItem: (...args: P) => Promise<D | null>;
   getItemTtl: (...args: P) => Promise<number>;
   hasItem: (...args: P) => Promise<boolean>;
@@ -25,6 +25,6 @@ export declare function createRedisKeyedStore<D = unknown>(storage: MaybeReadonl
   resolveKey: (...args: P) => string;
   setItem: (value: D, ...args: P) => Promise<boolean>;
   setItemWithTtl(ttlSeconds: number, value: D, ...args: P): Promise<boolean>;
+  setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P): Promise<boolean>;
 }>;
-//#endregion
 //# sourceMappingURL=keyed-store.d.ts.map

package/dist/storages/redis/keyed-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBAoBgB,sBAAsB,aAAa,SAAS,cAAc,qBAC9D,iBAAiB,WAAW,MAAM,iBAAY;EAC/B,aAAA,MAAA,MAAC,QAAA;EACE,gBAAA,MAAA,MAAC;EACJ,aAAA,MAAA,MAAC;EACE,gBAAA,MAAA,MAAC;EACD,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACH,eAAA,oBAAM,OAAS,MAAC,MAAW,IAAC"}
+{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;wBAoBgB,sBAAsB,aAAa,SAAS,cAAc,qBAC9D,iBAAiB,WAAW,MAAM,iBAAY;EACtB,sBAAA,MAAA,MAAC,QAAA;EACV,aAAA,MAAA,MAAC,QAAA;EACE,gBAAA,MAAA,MAAC;EACJ,aAAA,MAAA,MAAC;EACE,gBAAA,MAAA,MAAC;EACD,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACH,eAAA,oBAAM,OAAS,MAAC,MAAW,IAAC;EAGpB,uBAAA,oBAAM,OAAS,MAAC,MAAW,IAAC"}

package/dist/storages/redis/keyed-store.js

@@ -1,11 +1,11 @@
-//#region src/storages/redis/keyed-store.ts
+// src/storages/redis/keyed-store.ts
 /**
 * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.
 *
 * @remarks
 * The key resolver is called synchronously once per operation with the operation's key arguments.
 * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.
-* `setItemWithTtl` accepts its TTL in seconds before the value and key arguments.
+* `setItemWithTtl` and `setItemWithTtlIfAbsent` accept their TTL in seconds before the value and key arguments.
 * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.
 *
 * @typeParam D - The stored value type used by reads and writes.
@@ -13,10 +13,11 @@
 * @param storage - The shared Redis-like storage instance.
 *
 * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.
-* Reads, writes, removals, and TTL results retain the underlying storage contract.
+* Reads, atomic read-and-removals, writes, removals, and TTL results retain the underlying storage contract.
 */
 function createRedisKeyedStore(storage) {
 	return (keyFn) => Object.freeze({
+		getAndRemoveItem: (...args) => storage.getAndRemoveItem(keyFn(...args)),
 		getItem: (...args) => storage.getItem(keyFn(...args)),
 		getItemTtl: (...args) => storage.getItemTtl(keyFn(...args)),
 		hasItem: (...args) => storage.hasItem(keyFn(...args)),
@@ -25,10 +26,12 @@ function createRedisKeyedStore(storage) {
 		setItem: (value, ...args) => storage.setItem(keyFn(...args), value),
 		setItemWithTtl(ttlSeconds, value, ...args) {
 			return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);
+		},
+		setItemWithTtlIfAbsent(ttlSeconds, value, ...args) {
+			return storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);
 		}
 	});
 }
-//#endregion
 export { createRedisKeyedStore };
 
 //# sourceMappingURL=keyed-store.js.map

package/dist/storages/redis/keyed-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"sourcesContent":["import type { MaybeReadonly } from '../../types';\n\nimport type { RedisLikeStorage } from './types';\n\n/**\n * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.\n *\n * @remarks\n * The key resolver is called synchronously once per operation with the operation's key arguments.\n * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.\n * `setItemWithTtl` accepts its TTL in seconds before the value and key arguments.\n * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.\n *\n * @typeParam D - The stored value type used by reads and writes.\n *\n * @param storage - The shared Redis-like storage instance.\n *\n * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.\n * Reads, writes, removals, and TTL results retain the underlying storage contract.\n */\nexport function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {\n    return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),\n        hasItem: (...args: P) => storage.hasItem(keyFn(...args)),\n        removeItem: (...args: P) => storage.removeItem(keyFn(...args)),\n        resolveKey: (...args: P) => keyFn(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(keyFn(...args), value),\n        setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,sBAAmC,SAA0C;CACzF,QAAyB,UAAkC,OAAO,OAAO;EACrE,UAAU,GAAG,SAAY,QAAQ,QAAW,MAAM,GAAG,IAAI,CAAC;EAC1D,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,UAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC;EACvD,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,aAAa,GAAG,SAAY,MAAM,GAAG,IAAI;EACzC,UAAU,OAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,GAAG,KAAK;EACxE,eAAe,YAAoB,OAAU,GAAG,MAAS;GACrD,OAAO,QAAQ,eAAe,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACnE;CACJ,CAAC;AACL"}
+{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"sourcesContent":["import type { MaybeReadonly } from '../../types';\n\nimport type { RedisLikeStorage } from './types';\n\n/**\n * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.\n *\n * @remarks\n * The key resolver is called synchronously once per operation with the operation's key arguments.\n * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.\n * `setItemWithTtl` and `setItemWithTtlIfAbsent` accept their TTL in seconds before the value and key arguments.\n * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.\n *\n * @typeParam D - The stored value type used by reads and writes.\n *\n * @param storage - The shared Redis-like storage instance.\n *\n * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.\n * Reads, atomic read-and-removals, writes, removals, and TTL results retain the underlying storage contract.\n */\nexport function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {\n    return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({\n        getAndRemoveItem: (...args: P) => storage.getAndRemoveItem<D>(keyFn(...args)),\n        getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),\n        hasItem: (...args: P) => storage.hasItem(keyFn(...args)),\n        removeItem: (...args: P) => storage.removeItem(keyFn(...args)),\n        resolveKey: (...args: P) => keyFn(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(keyFn(...args), value),\n        setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);\n        },\n        setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,sBAAmC,SAA0C;CACzF,QAAyB,UAAkC,OAAO,OAAO;EACrE,mBAAmB,GAAG,SAAY,QAAQ,iBAAoB,MAAM,GAAG,IAAI,CAAC;EAC5E,UAAU,GAAG,SAAY,QAAQ,QAAW,MAAM,GAAG,IAAI,CAAC;EAC1D,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,UAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC;EACvD,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,aAAa,GAAG,SAAY,MAAM,GAAG,IAAI;EACzC,UAAU,OAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,GAAG,KAAK;EACxE,eAAe,YAAoB,OAAU,GAAG,MAAS;GACrD,OAAO,QAAQ,eAAe,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACnE;EACA,uBAAuB,YAAoB,OAAU,GAAG,MAAS;GAC7D,OAAO,QAAQ,uBAAuB,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EAC3E;CACJ,CAAC;AACL"}

package/dist/storages/redis/msgpack.d.ts

@@ -1,11 +1,11 @@
 import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
-//#region src/storages/redis/msgpack.d.ts
 /**
  * Creates a frozen Redis-like storage facade using MessagePack serialization.
  *
  * @remarks
  * Adapter rejections and MessagePack serialization errors propagate to the caller.
- * Reads resolve to `null` when no raw value exists. Writes resolve to `true` only when the adapter returns `OK`;
+ * Reads resolve to `null` when no raw value exists; `getAndRemoveItem` reads and deletes in one atomic adapter call.
+ * Writes resolve to `true` only when the adapter returns `OK`;
  * removal resolves to `true` only when exactly one key is deleted.
  * The adapter remains caller-owned; creating the facade does not open or close a connection.
  *
@@ -24,6 +24,11 @@ import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
  * const adapter: RedisLikeAdapter = {
  *     delete: async (key) => values.delete(key) ? 1 : 0,
  *     getBuffer: async (key) => values.get(key) ?? null,
+ *     getBufferAndDelete: async (key) => {
+ *         const value = values.get(key) ?? null;
+ *         values.delete(key);
+ *         return value;
+ *     },
  *     has: async (key) => values.has(key),
  *     setBuffer: async (key, value) => {
  *         values.set(key, value);
@@ -32,6 +37,9 @@ import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
  *     setBufferEx: async () => {
  *         throw new Error('TTL writes are not supported by this example adapter');
  *     },
+ *     setBufferExNx: async () => {
+ *         throw new Error('TTL writes are not supported by this example adapter');
+ *     },
  *     ttl: async (key) => values.has(key) ? -1 : -2,
  * };
  *
@@ -42,5 +50,4 @@ import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
  * ```
  */
 export declare function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage>;
-//#endregion
 //# sourceMappingURL=msgpack.d.ts.map

package/dist/storages/redis/msgpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"msgpack.d.ts","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDgB,0BAA0B,SAAS,mBAAmB,SAAS"}
+{"version":3,"file":"msgpack.d.ts","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiEgB,0BAA0B,SAAS,mBAAmB,SAAS"}