@kikiutils/shared 12.0.0 → 13.0.1

package/dist/pino.d.ts

@@ -1,3 +1,7 @@
+import * as pino0 from "pino";
+
+//#region src/pino.d.ts
+
 /**
  * A pino logger instance with the configured stream.
  *
@@ -19,6 +23,8 @@
  * logger.level = 'info';
  * ```
  */
-export declare const pinoLogger: import("pino").Logger<never, boolean>;
-export declare const logger: import("pino").Logger<never, boolean>;
+declare const pinoLogger: pino0.Logger<never, boolean>;
+declare const logger: pino0.Logger<never, boolean>;
+//#endregion
+export { logger, pinoLogger };
 //# sourceMappingURL=pino.d.ts.map

package/dist/pino.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pino.d.ts","sourceRoot":"","sources":["../src/pino.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,UAAU,uCAAmB,CAAC;AAC3C,eAAO,MAAM,MAAM,uCAAa,CAAC"}
+{"version":3,"file":"pino.d.ts","names":[],"sources":["../src/pino.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiCA;AACA;;;;;;;;;;;;;;;;;cADa,YAA6B,KAAA,CAAnB;cACV,QAAmB,KAAA,CAAb"}

package/dist/pino.js

@@ -0,0 +1,40 @@
+import { pino } from "pino";
+import { PinoPretty } from "pino-pretty";
+
+//#region src/pino.ts
+/**
+* Configure pinoPretty to enhance the log output.
+*/
+const stream = PinoPretty({
+	colorize: true,
+	ignore: "hostname,pid",
+	translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l"
+});
+/**
+* A pino logger instance with the configured stream.
+*
+* The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.
+* If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,
+* the level will be set to `error`.
+*
+* To manually change the level, assign the desired level to `logger.level`.
+*
+* See available levels [here](https://getpino.io/#/docs/api?id=level-string).
+*
+* @example
+* ```typescript
+* import { logger } from '@kikiutils/shared/pino';
+*
+* logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test
+*
+* // Manually change the level
+* logger.level = 'info';
+* ```
+*/
+const pinoLogger = pino({}, stream);
+const logger = pinoLogger;
+pinoLogger.level = process.env.PINO_LOGGER_LEVEL || (process.env.NODE_ENV === "production" ? "error" : pinoLogger.level);
+
+//#endregion
+export { logger, pinoLogger };
+//# sourceMappingURL=pino.js.map

package/dist/pino.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.js","names":[],"sources":["../src/pino.ts"],"sourcesContent":["import { pino } from 'pino';\nimport { PinoPretty } from 'pino-pretty';\n\n/**\n * Configure pinoPretty to enhance the log output.\n */\nconst stream = PinoPretty({\n    colorize: true, // Enable colored output for better readability\n    ignore: 'hostname,pid', // Exclude 'hostname' and 'pid' fields from the logs\n    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l', // Format the timestamp in 'yyyy-mm-dd HH:MM:ss.l' format\n});\n\n/**\n * A pino logger instance with the configured stream.\n *\n * The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.\n * If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,\n * the level will be set to `error`.\n *\n * To manually change the level, assign the desired level to `logger.level`.\n *\n * See available levels [here](https://getpino.io/#/docs/api?id=level-string).\n *\n * @example\n * ```typescript\n * import { logger } from '@kikiutils/shared/pino';\n *\n * logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test\n *\n * // Manually change the level\n * logger.level = 'info';\n * ```\n */\nexport const pinoLogger = pino({}, stream);\nexport const logger = pinoLogger;\n// eslint-disable-next-line style/max-len\npinoLogger.level = process.env.PINO_LOGGER_LEVEL || (process.env.NODE_ENV === 'production' ? 'error' : pinoLogger.level);\n"],"mappings":";;;;;;;AAMA,MAAM,SAAS,WAAW;CACtB,UAAU;CACV,QAAQ;CACR,eAAe;CAClB,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuBF,MAAa,aAAa,KAAK,EAAE,EAAE,OAAO;AAC1C,MAAa,SAAS;AAEtB,WAAW,QAAQ,QAAQ,IAAI,sBAAsB,QAAQ,IAAI,aAAa,eAAe,UAAU,WAAW"}

package/dist/random.d.ts

@@ -1,3 +1,4 @@
+//#region src/random.d.ts
 /**
  * Generates a value using a provided generator function, where the input length
  * is determined by two levels of nested random ranges:
@@ -18,5 +19,7 @@
  *
  * @returns {T} The result of the generator function using the computed final length
  */
-export declare function generateWithNestedRandomLength<T = string>(generator: (length: number) => T, minMin: number, minMax: number, maxMin: number, maxMax: number): T;
+declare function generateWithNestedRandomLength<T = string>(generator: (length: number) => T, minMin: number, minMax: number, maxMin: number, maxMax: number): T;
+//#endregion
+export { generateWithNestedRandomLength };
 //# sourceMappingURL=random.d.ts.map

package/dist/random.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../src/random.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,GAAG,MAAM,EACrD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,CAAC,EAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,KAMjB"}
+{"version":3,"file":"random.d.ts","names":[],"sources":["../src/random.ts"],"sourcesContent":[],"mappings":";;AAoBA;;;;;;;;;;;;;;;;;;;iBAAgB,0EACmB,oEAIjB"}

package/dist/random.js

@@ -0,0 +1,31 @@
+//#region src/random.ts
+/**
+* Generates a value using a provided generator function, where the input length
+* is determined by two levels of nested random ranges:
+*
+* 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.
+* 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.
+* 3. The generator is called with the final length and its result is returned.
+*
+* This function supports any return type by using a generic type parameter.
+*
+* @template T - The return type of the generator function
+*
+* @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T
+* @param {number} minMin - Lower bound of the first random range
+* @param {number} minMax - Upper bound of the first random range
+* @param {number} maxMin - Lower bound of the second random range
+* @param {number} maxMax - Upper bound of the second random range
+*
+* @returns {T} The result of the generator function using the computed final length
+*/
+function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMax) {
+	const random = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+	const innerMin = random(minMin, minMax);
+	const finalLength = random(Math.max(innerMin, maxMin), maxMax);
+	return generator(finalLength);
+}
+
+//#endregion
+export { generateWithNestedRandomLength };
+//# sourceMappingURL=random.js.map

package/dist/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","names":[],"sources":["../src/random.ts"],"sourcesContent":["/**\n * Generates a value using a provided generator function, where the input length\n * is determined by two levels of nested random ranges:\n *\n * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.\n * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.\n * 3. The generator is called with the final length and its result is returned.\n *\n * This function supports any return type by using a generic type parameter.\n *\n * @template T - The return type of the generator function\n *\n * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T\n * @param {number} minMin - Lower bound of the first random range\n * @param {number} minMax - Upper bound of the first random range\n * @param {number} maxMin - Lower bound of the second random range\n * @param {number} maxMax - Upper bound of the second random range\n *\n * @returns {T} The result of the generator function using the computed final length\n */\nexport function generateWithNestedRandomLength<T = string>(\n    generator: (length: number) => T,\n    minMin: number,\n    minMax: number,\n    maxMin: number,\n    maxMax: number,\n) {\n    const random = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1)) + min;\n    const innerMin = random(minMin, minMax);\n    const finalLength = random(Math.max(innerMin, maxMin), maxMax);\n    return generator(finalLength);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,+BACZ,WACA,QACA,QACA,QACA,QACF;CACE,MAAM,UAAU,KAAa,QAAgB,KAAK,MAAM,KAAK,QAAQ,IAAI,MAAM,MAAM,GAAG,GAAG;CAC3F,MAAM,WAAW,OAAO,QAAQ,OAAO;CACvC,MAAM,cAAc,OAAO,KAAK,IAAI,UAAU,OAAO,EAAE,OAAO;AAC9D,QAAO,UAAU,YAAY"}

package/dist/storage/enhanced/local/core.d.ts

@@ -1,3 +1,4 @@
+//#region src/storage/enhanced/local/core.d.ts
 /**
  * An enhanced localStorage wrapper that supports storing
  * complex data types (e.g. Dates, Maps, Sets) using SuperJSON encoding.
@@ -12,47 +13,49 @@
  * const user = enhancedLocalStorage.getItem<{ name: string, createdAt: Date }>('user');
  * ```
  */
-export declare const enhancedLocalStorage: Readonly<{
-    /**
-     * Removes all items from localStorage.
-     */
-    clear: () => void;
-    /**
-     * Retrieves a value by key and decodes it using SuperJSON or raw string.
-     *
-     * @template T - The expected type of the value
-     *
-     * @param {string} key - The key of the value to retrieve
-     *
-     * @returns {null | T} The decoded value or null if not found
-     */
-    getItem<T = unknown>(key: string): T | null;
-    /**
-     * Checks whether a key exists in localStorage.
-     *
-     * @param {string} key - The key to check
-     *
-     * @returns {boolean} True if the key exists, false otherwise
-     */
-    hasItem: (key: string) => boolean;
-    /**
-     * Returns the number of items stored in localStorage.
-     *
-     * @returns {number} The number of items stored in localStorage
-     */
-    readonly length: number;
-    /**
-     * Removes a specific key from localStorage.
-     *
-     * @param {string} key - The key to remove
-     */
-    removeItem: (key: string) => void;
-    /**
-     * Stores a value in localStorage with automatic serialization.
-     *
-     * @param {string} key - The key to store the value under
-     * @param {any} value - The value to store
-     */
-    setItem: (key: string, value: any) => void;
+declare const enhancedLocalStorage: Readonly<{
+  /**
+   * Removes all items from localStorage.
+   */
+  clear: () => void;
+  /**
+   * Retrieves a value by key and decodes it using SuperJSON or raw string.
+   *
+   * @template T - The expected type of the value
+   *
+   * @param {string} key - The key of the value to retrieve
+   *
+   * @returns {null | T} The decoded value or null if not found
+   */
+  getItem<T = unknown>(key: string): T | null;
+  /**
+   * Checks whether a key exists in localStorage.
+   *
+   * @param {string} key - The key to check
+   *
+   * @returns {boolean} True if the key exists, false otherwise
+   */
+  hasItem: (key: string) => boolean;
+  /**
+   * Returns the number of items stored in localStorage.
+   *
+   * @returns {number} The number of items stored in localStorage
+   */
+  readonly length: number;
+  /**
+   * Removes a specific key from localStorage.
+   *
+   * @param {string} key - The key to remove
+   */
+  removeItem: (key: string) => void;
+  /**
+   * Stores a value in localStorage with automatic serialization.
+   *
+   * @param {string} key - The key to store the value under
+   * @param {any} value - The value to store
+   */
+  setItem: (key: string, value: any) => void;
 }>;
+//#endregion
+export { enhancedLocalStorage };
 //# sourceMappingURL=core.d.ts.map

package/dist/storage/enhanced/local/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/local/core.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB;IAC7B;;OAEG;;IAEH;;;;;;;;OAQG;YACK,CAAC,iBAAiB,MAAM;IAIhC;;;;;;OAMG;mBACY,MAAM;IACrB;;;;OAIG;;IAIH;;;;OAIG;sBACe,MAAM;IACxB;;;;;OAKG;mBACY,MAAM,SAAS,GAAG;EACnC,CAAC"}
+{"version":3,"file":"core.d.ts","names":[],"sources":["../../../../src/storage/enhanced/local/core.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;;;;;;;;cAAa,sBAAoB;;;;;;;;;;;;;;qCAcG"}

package/dist/storage/enhanced/local/core.js

@@ -0,0 +1,63 @@
+import { deserialize, serialize } from "superjson";
+
+//#region src/storage/enhanced/local/core.ts
+var StorageValueEncodingType = /* @__PURE__ */ function(StorageValueEncodingType$1) {
+	StorageValueEncodingType$1["Json"] = "0";
+	StorageValueEncodingType$1["String"] = "1";
+	return StorageValueEncodingType$1;
+}(StorageValueEncodingType || {});
+const customValueHeader = "​⁠";
+const customValueHeaderLength = 3;
+const toCustomValue = (type, payload) => `${customValueHeader}${type}${payload}`;
+/**
+* An enhanced localStorage wrapper that supports storing
+* complex data types (e.g. Dates, Maps, Sets) using SuperJSON encoding.
+*
+* This utility preserves type structure when saving and retrieving values.
+*
+* @example
+* ```typescript
+* import { enhancedLocalStorage } from '@kikiutils/shared/storage/enhanced/local';
+*
+* enhancedLocalStorage.setItem('user', { name: 'user', createdAt: new Date() });
+* const user = enhancedLocalStorage.getItem<{ name: string, createdAt: Date }>('user');
+* ```
+*/
+const enhancedLocalStorage = Object.freeze({
+	clear: () => window.localStorage.clear(),
+	getItem(key) {
+		const rawValue = window.localStorage.getItem(key);
+		return rawValue ? decodeStorageValue(rawValue) : null;
+	},
+	hasItem: (key) => window.localStorage.getItem(key) !== null,
+	get length() {
+		return window.localStorage.length;
+	},
+	removeItem: (key) => window.localStorage.removeItem(key),
+	setItem: (key, value) => window.localStorage.setItem(key, encodeToStorageValue(value))
+});
+function decodeStorageValue(data) {
+	if (!isCustomFormat(data)) return data;
+	const payload = data.substring(customValueHeaderLength);
+	const type = data.charAt(2);
+	switch (type) {
+		case StorageValueEncodingType.Json: try {
+			return deserialize(JSON.parse(payload));
+		} catch {
+			throw new Error("[EnhancedLocalStorage] Failed to parse JSON payload");
+		}
+		case StorageValueEncodingType.String: return payload;
+		default: throw new Error(`[EnhancedLocalStorage] Unknown encoding type: ${type}`);
+	}
+}
+function encodeToStorageValue(value) {
+	if (typeof value === "string") return toCustomValue(StorageValueEncodingType.String, value);
+	return toCustomValue(StorageValueEncodingType.Json, JSON.stringify(serialize(value)));
+}
+function isCustomFormat(data) {
+	return data.length >= customValueHeaderLength && data[0] === customValueHeader[0] && data[1] === customValueHeader[1];
+}
+
+//#endregion
+export { enhancedLocalStorage };
+//# sourceMappingURL=core.js.map

package/dist/storage/enhanced/local/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","names":[],"sources":["../../../../src/storage/enhanced/local/core.ts"],"sourcesContent":["import {\n    deserialize,\n    serialize,\n} from 'superjson';\n\nenum StorageValueEncodingType {\n    Json = '0',\n    String = '1',\n}\n\nconst customValueHeader = '​⁠';\nconst customValueHeaderLength = customValueHeader.length + 1;\nconst toCustomValue = (type: StorageValueEncodingType, payload: string) => `${customValueHeader}${type}${payload}`;\n\n/**\n * An enhanced localStorage wrapper that supports storing\n * complex data types (e.g. Dates, Maps, Sets) using SuperJSON encoding.\n *\n * This utility preserves type structure when saving and retrieving values.\n *\n * @example\n * ```typescript\n * import { enhancedLocalStorage } from '@kikiutils/shared/storage/enhanced/local';\n *\n * enhancedLocalStorage.setItem('user', { name: 'user', createdAt: new Date() });\n * const user = enhancedLocalStorage.getItem<{ name: string, createdAt: Date }>('user');\n * ```\n */\nexport const enhancedLocalStorage = Object.freeze({\n    /**\n     * Removes all items from localStorage.\n     */\n    clear: () => window.localStorage.clear(),\n    /**\n     * Retrieves a value by key and decodes it using SuperJSON or raw string.\n     *\n     * @template T - The expected type of the value\n     *\n     * @param {string} key - The key of the value to retrieve\n     *\n     * @returns {null | T} The decoded value or null if not found\n     */\n    getItem<T = unknown>(key: string) {\n        const rawValue = window.localStorage.getItem(key);\n        return rawValue ? decodeStorageValue(rawValue) as T : null;\n    },\n    /**\n     * Checks whether a key exists in localStorage.\n     *\n     * @param {string} key - The key to check\n     *\n     * @returns {boolean} True if the key exists, false otherwise\n     */\n    hasItem: (key: string) => window.localStorage.getItem(key) !== null,\n    /**\n     * Returns the number of items stored in localStorage.\n     *\n     * @returns {number} The number of items stored in localStorage\n     */\n    get length() {\n        return window.localStorage.length;\n    },\n    /**\n     * Removes a specific key from localStorage.\n     *\n     * @param {string} key - The key to remove\n     */\n    removeItem: (key: string) => window.localStorage.removeItem(key),\n    /**\n     * Stores a value in localStorage with automatic serialization.\n     *\n     * @param {string} key - The key to store the value under\n     * @param {any} value - The value to store\n     */\n    setItem: (key: string, value: any) => window.localStorage.setItem(key, encodeToStorageValue(value)),\n});\n\nfunction decodeStorageValue(data: string) {\n    if (!isCustomFormat(data)) return data;\n    const payload = data.substring(customValueHeaderLength);\n    const type = data.charAt(customValueHeader.length);\n    switch (type) {\n        case StorageValueEncodingType.Json:\n            try {\n                return deserialize(JSON.parse(payload));\n            } catch {\n                throw new Error('[EnhancedLocalStorage] Failed to parse JSON payload');\n            }\n        case StorageValueEncodingType.String: return payload;\n        default:\n            throw new Error(`[EnhancedLocalStorage] Unknown encoding type: ${type}`);\n    }\n}\n\nfunction encodeToStorageValue(value: any) {\n    if (typeof value === 'string') return toCustomValue(StorageValueEncodingType.String, value);\n    return toCustomValue(StorageValueEncodingType.Json, JSON.stringify(serialize(value)));\n}\n\nfunction isCustomFormat(data: string) {\n    return (\n        data.length >= customValueHeaderLength\n        && data[0] === customValueHeader[0]\n        && data[1] === customValueHeader[1]\n    );\n}\n"],"mappings":";;;AAKA,IAAK,gFAAL;AACI;AACA;;EAFC;AAKL,MAAM,oBAAoB;AAC1B,MAAM,0BAA0B;AAChC,MAAM,iBAAiB,MAAgC,YAAoB,GAAG,oBAAoB,OAAO;;;;;;;;;;;;;;;AAgBzG,MAAa,uBAAuB,OAAO,OAAO;CAI9C,aAAa,OAAO,aAAa,OAAO;CAUxC,QAAqB,KAAa;EAC9B,MAAM,WAAW,OAAO,aAAa,QAAQ,IAAI;AACjD,SAAO,WAAW,mBAAmB,SAAS,GAAQ;;CAS1D,UAAU,QAAgB,OAAO,aAAa,QAAQ,IAAI,KAAK;CAM/D,IAAI,SAAS;AACT,SAAO,OAAO,aAAa;;CAO/B,aAAa,QAAgB,OAAO,aAAa,WAAW,IAAI;CAOhE,UAAU,KAAa,UAAe,OAAO,aAAa,QAAQ,KAAK,qBAAqB,MAAM,CAAC;CACtG,CAAC;AAEF,SAAS,mBAAmB,MAAc;AACtC,KAAI,CAAC,eAAe,KAAK,CAAE,QAAO;CAClC,MAAM,UAAU,KAAK,UAAU,wBAAwB;CACvD,MAAM,OAAO,KAAK,OAAO,EAAyB;AAClD,SAAQ,MAAR;EACI,KAAK,yBAAyB,KAC1B,KAAI;AACA,UAAO,YAAY,KAAK,MAAM,QAAQ,CAAC;UACnC;AACJ,SAAM,IAAI,MAAM,sDAAsD;;EAE9E,KAAK,yBAAyB,OAAQ,QAAO;EAC7C,QACI,OAAM,IAAI,MAAM,iDAAiD,OAAO;;;AAIpF,SAAS,qBAAqB,OAAY;AACtC,KAAI,OAAO,UAAU,SAAU,QAAO,cAAc,yBAAyB,QAAQ,MAAM;AAC3F,QAAO,cAAc,yBAAyB,MAAM,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;;AAGzF,SAAS,eAAe,MAAc;AAClC,QACI,KAAK,UAAU,2BACZ,KAAK,OAAO,kBAAkB,MAC9B,KAAK,OAAO,kBAAkB"}

package/dist/storage/enhanced/local/index.d.ts

@@ -1,3 +1,3 @@
-export { enhancedLocalStorage } from './core';
-export { createKeyedEnhancedLocalStore } from './keyed-store';
-//# sourceMappingURL=index.d.ts.map
+import { enhancedLocalStorage } from "./core.js";
+import { createKeyedEnhancedLocalStore } from "./keyed-store.js";
+export { createKeyedEnhancedLocalStore, enhancedLocalStorage };

package/dist/storage/enhanced/local/index.js

@@ -0,0 +1,4 @@
+import { enhancedLocalStorage } from "./core.js";
+import { createKeyedEnhancedLocalStore } from "./keyed-store.js";
+
+export { createKeyedEnhancedLocalStore, enhancedLocalStorage };

package/dist/storage/enhanced/local/keyed-store.d.ts

@@ -1,3 +1,4 @@
+//#region src/storage/enhanced/local/keyed-store.d.ts
 /**
  * Creates a reusable, type-safe storage interface based on `enhancedLocalStorage`
  * and a dynamic key-generation function.
@@ -18,16 +19,18 @@
  * const user = userStore.getItem(123);
  * ```
  */
-export declare function createKeyedEnhancedLocalStore<D = unknown>(): <P extends any[]>(getKeyFunction: (...args: P) => string) => Readonly<{
-    getItem: (...args: P) => D | null;
-    hasItem: (...args: P) => boolean;
-    removeItem: (...args: P) => void;
-    /**
-     * Resolves the storage key from the given arguments.
-     *
-     * @returns {string} The final string key used internally
-     */
-    resolveKey: (...args: P) => string;
-    setItem: (value: D, ...args: P) => void;
+declare function createKeyedEnhancedLocalStore<D = unknown>(): <P extends any[]>(getKeyFunction: (...args: P) => string) => Readonly<{
+  getItem: (...args: P) => D | null;
+  hasItem: (...args: P) => boolean;
+  removeItem: (...args: P) => void;
+  /**
+   * Resolves the storage key from the given arguments.
+   *
+   * @returns {string} The final string key used internally
+   */
+  resolveKey: (...args: P) => string;
+  setItem: (value: D, ...args: P) => void;
 }>;
+//#endregion
+export { createKeyedEnhancedLocalStore };
 //# sourceMappingURL=keyed-store.d.ts.map

package/dist/storage/enhanced/local/keyed-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/local/keyed-store.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,GAAG,OAAO,MAC7C,CAAC,SAAS,GAAG,EAAE,EAAE,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM;uBACxC,CAAC;uBACD,CAAC;0BACE,CAAC;IACvB;;;;OAIG;0BACmB,CAAC;qBACN,CAAC,WAAW,CAAC;GAErC"}
+{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../../src/storage/enhanced/local/keyed-store.ts"],"sourcesContent":[],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;;;iBAAgB,0FACuC,iBAAY;qBACxC,MAAC;qBACD;wBACG;;;;;;wBAMA;mBACL,YAAY"}

package/dist/storage/enhanced/local/keyed-store.js

@@ -0,0 +1,36 @@
+import { enhancedLocalStorage } from "./core.js";
+
+//#region src/storage/enhanced/local/keyed-store.ts
+/**
+* Creates a reusable, type-safe storage interface based on `enhancedLocalStorage`
+* and a dynamic key-generation function.
+*
+* This utility allows you to abstract away key construction logic and work directly
+* with scoped key-value operations like `getItem`, `setItem`, and `removeItem`.
+*
+* @template D - The value type to store
+*
+* @returns A factory that accepts a key generator function and returns a scoped storage interface
+*
+* @example
+* ```typescript
+* import { createKeyedEnhancedLocalStore } from '@kikiutils/shared/storage/enhanced/local';
+*
+* const userStore = createKeyedEnhancedLocalStore<User>()((id: number) => `user:${id}`);
+* userStore.setItem({ id: 123, name: 'user' }, 123);
+* const user = userStore.getItem(123);
+* ```
+*/
+function createKeyedEnhancedLocalStore() {
+	return (getKeyFunction) => Object.freeze({
+		getItem: (...args) => enhancedLocalStorage.getItem(getKeyFunction(...args)),
+		hasItem: (...args) => enhancedLocalStorage.hasItem(getKeyFunction(...args)),
+		removeItem: (...args) => enhancedLocalStorage.removeItem(getKeyFunction(...args)),
+		resolveKey: (...args) => getKeyFunction(...args),
+		setItem: (value, ...args) => enhancedLocalStorage.setItem(getKeyFunction(...args), value)
+	});
+}
+
+//#endregion
+export { createKeyedEnhancedLocalStore };
+//# sourceMappingURL=keyed-store.js.map

package/dist/storage/enhanced/local/keyed-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../../src/storage/enhanced/local/keyed-store.ts"],"sourcesContent":["import { enhancedLocalStorage } from './core';\n\n/**\n * Creates a reusable, type-safe storage interface based on `enhancedLocalStorage`\n * and a dynamic key-generation function.\n *\n * This utility allows you to abstract away key construction logic and work directly\n * with scoped key-value operations like `getItem`, `setItem`, and `removeItem`.\n *\n * @template D - The value type to store\n *\n * @returns A factory that accepts a key generator function and returns a scoped storage interface\n *\n * @example\n * ```typescript\n * import { createKeyedEnhancedLocalStore } from '@kikiutils/shared/storage/enhanced/local';\n *\n * const userStore = createKeyedEnhancedLocalStore<User>()((id: number) => `user:${id}`);\n * userStore.setItem({ id: 123, name: 'user' }, 123);\n * const user = userStore.getItem(123);\n * ```\n */\nexport function createKeyedEnhancedLocalStore<D = unknown>() {\n    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => enhancedLocalStorage.getItem<D>(getKeyFunction(...args)),\n        hasItem: (...args: P) => enhancedLocalStorage.hasItem(getKeyFunction(...args)),\n        removeItem: (...args: P) => enhancedLocalStorage.removeItem(getKeyFunction(...args)),\n        /**\n         * Resolves the storage key from the given arguments.\n         *\n         * @returns {string} The final string key used internally\n         */\n        resolveKey: (...args: P) => getKeyFunction(...args),\n        setItem: (value: D, ...args: P) => enhancedLocalStorage.setItem(getKeyFunction(...args), value),\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,gCAA6C;AACzD,SAAyB,mBAA2C,OAAO,OAAO;EAC9E,UAAU,GAAG,SAAY,qBAAqB,QAAW,eAAe,GAAG,KAAK,CAAC;EACjF,UAAU,GAAG,SAAY,qBAAqB,QAAQ,eAAe,GAAG,KAAK,CAAC;EAC9E,aAAa,GAAG,SAAY,qBAAqB,WAAW,eAAe,GAAG,KAAK,CAAC;EAMpF,aAAa,GAAG,SAAY,eAAe,GAAG,KAAK;EACnD,UAAU,OAAU,GAAG,SAAY,qBAAqB,QAAQ,eAAe,GAAG,KAAK,EAAE,MAAM;EAClG,CAAC"}

package/dist/storage/enhanced/redis/core.d.ts

@@ -1,4 +1,7 @@
-import { Redis } from 'ioredis';
+import { Redis } from "ioredis";
+
+//#region src/storage/enhanced/redis/core.d.ts
+
 /**
  * Creates an enhanced Redis-based storage interface using SuperJSON encoding.
  *
@@ -18,63 +21,65 @@ import { Redis } from 'ioredis';
  * const user = await redisStorage.getItem<{ name: string }>('user:1');
  * ```
  */
-export declare function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string): Readonly<{
-    /**
-     * Retrieves a value from Redis and decodes it.
-     *
-     * @template T - The expected return type
-     *
-     * @param {string} key - The Redis key
-     *
-     * @returns {Promise<null | T>} The decoded value or null if not found
-     */
-    getItem<T = unknown>(key: string): Promise<T | null>;
-    /**
-     * Gets the remaining TTL (in seconds) for a given key.
-     *
-     * @param {string} key - The Redis key
-     *
-     * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set
-     */
-    getItemTtl: (key: string) => Promise<number>;
-    /**
-     * Checks whether a key exists in Redis.
-     *
-     * @param {string} key - The Redis key
-     *
-     * @returns {Promise<boolean>} True if the key exists, false otherwise
-     */
-    hasItem: (key: string) => Promise<boolean>;
-    /**
-     * The underlying Redis instance, exposed for advanced operations.
-     * Use with caution; most use cases should rely on the wrapper methods.
-     *
-     * @returns {Redis} The underlying Redis instance
-     */
-    readonly instance: Redis;
-    /**
-     * Removes a key from Redis.
-     *
-     * @param {string} key - The Redis key to delete
-     *
-     * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,
-     * or `false` if it did not exist.
-     */
-    removeItem: (key: string) => Promise<boolean>;
-    /**
-     * Stores a value in Redis without expiration.
-     *
-     * @param {string} key - The Redis key
-     * @param {any} value - The value to store. Will be serialized
-     */
-    setItem: (key: string, value: any) => Promise<"OK">;
-    /**
-     * Stores a value in Redis with a time-to-live (TTL).
-     *
-     * @param {string} key - The Redis key
-     * @param {number} seconds - Expiration time in seconds
-     * @param {any} value - The value to store. Will be serialized
-     */
-    setItemWithTtl(key: string, seconds: number, value: any): Promise<"OK">;
+declare function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string): Readonly<{
+  /**
+   * Retrieves a value from Redis and decodes it.
+   *
+   * @template T - The expected return type
+   *
+   * @param {string} key - The Redis key
+   *
+   * @returns {Promise<null | T>} The decoded value or null if not found
+   */
+  getItem<T = unknown>(key: string): Promise<T | null>;
+  /**
+   * Gets the remaining TTL (in seconds) for a given key.
+   *
+   * @param {string} key - The Redis key
+   *
+   * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set
+   */
+  getItemTtl: (key: string) => Promise<number>;
+  /**
+   * Checks whether a key exists in Redis.
+   *
+   * @param {string} key - The Redis key
+   *
+   * @returns {Promise<boolean>} True if the key exists, false otherwise
+   */
+  hasItem: (key: string) => Promise<boolean>;
+  /**
+   * The underlying Redis instance, exposed for advanced operations.
+   * Use with caution; most use cases should rely on the wrapper methods.
+   *
+   * @returns {Redis} The underlying Redis instance
+   */
+  readonly instance: Redis;
+  /**
+   * Removes a key from Redis.
+   *
+   * @param {string} key - The Redis key to delete
+   *
+   * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,
+   * or `false` if it did not exist.
+   */
+  removeItem: (key: string) => Promise<boolean>;
+  /**
+   * Stores a value in Redis without expiration.
+   *
+   * @param {string} key - The Redis key
+   * @param {any} value - The value to store. Will be serialized
+   */
+  setItem: (key: string, value: any) => Promise<"OK">;
+  /**
+   * Stores a value in Redis with a time-to-live (TTL).
+   *
+   * @param {string} key - The Redis key
+   * @param {number} seconds - Expiration time in seconds
+   * @param {any} value - The value to store. Will be serialized
+   */
+  setItemWithTtl(key: string, seconds: number, value: any): Promise<"OK">;
 }>;
+//#endregion
+export { createEnhancedRedisStorage };
 //# sourceMappingURL=core.d.ts.map

package/dist/storage/enhanced/redis/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/redis/core.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAoBhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,oBAAoB,EAAE,KAAK,GAAG,MAAM;IAGvE;;;;;;;;OAQG;YACW,CAAC,iBAAiB,MAAM;IAItC;;;;;;OAMG;sBACe,MAAM;IACxB;;;;;;OAMG;mBACkB,MAAM;IAC3B;;;;;OAKG;;IAIH;;;;;;;OAOG;sBACqB,MAAM;IAC9B;;;;;OAKG;mBACY,MAAM,SAAS,GAAG;IACjC;;;;;;OAMG;wBACiB,MAAM,WAAW,MAAM,SAAS,GAAG;GAI9D"}
+{"version":3,"file":"core.d.ts","names":[],"sources":["../../../../src/storage/enhanced/redis/core.ts"],"sourcesContent":[],"mappings":";;;;;;AAyCA;;;;;;;;;;;;;;;;;iBAAgB,0BAAA,uBAAiD,iBAAc;;;;;;;;;;qCAYjC,QAAA;;;;;;;;+BAWd;;;;;;;;4BAQG;;;;;;;;;;;;;;;;+BAkBG;;;;;;;wCAOG;;;;;;;;4DAQsB"}

package/dist/storage/enhanced/redis/core.js

@@ -0,0 +1,85 @@
+import { Buffer } from "node:buffer";
+import { deserialize, serialize } from "superjson";
+import { Redis } from "ioredis";
+
+//#region src/storage/enhanced/redis/core.ts
+var StorageValueEncodingType = /* @__PURE__ */ function(StorageValueEncodingType$1) {
+	StorageValueEncodingType$1[StorageValueEncodingType$1["Buffer"] = 0] = "Buffer";
+	StorageValueEncodingType$1[StorageValueEncodingType$1["Json"] = 1] = "Json";
+	StorageValueEncodingType$1[StorageValueEncodingType$1["String"] = 2] = "String";
+	return StorageValueEncodingType$1;
+}(StorageValueEncodingType || {});
+const customValueHeader = Buffer.of(226, 129, 160);
+const customValueHeaderLength = customValueHeader.byteLength + 1;
+/**
+* Creates an enhanced Redis-based storage interface using SuperJSON encoding.
+*
+* This utility provides a typed, serializable key-value store backed by Redis,
+* supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).
+*
+* @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string
+*
+* @returns A frozen object that wraps Redis commands with typed get/set logic and encoding
+*
+* @example
+* ```typescript
+* import { createEnhancedRedisStorage } from '@kikiutils/shared/storage/enhanced/redis';
+*
+* const redisStorage = createEnhancedRedisStorage('redis://localhost');
+* await redisStorage.setItem('user:1', { name: 'user' });
+* const user = await redisStorage.getItem<{ name: string }>('user:1');
+* ```
+*/
+function createEnhancedRedisStorage(ioRedisInstanceOrUrl) {
+	const instance = ioRedisInstanceOrUrl instanceof Redis ? ioRedisInstanceOrUrl : new Redis(ioRedisInstanceOrUrl);
+	return Object.freeze({
+		async getItem(key) {
+			const rawValue = await instance.getBuffer(key);
+			return rawValue ? decodeStorageValue(rawValue) : null;
+		},
+		getItemTtl: (key) => instance.ttl(key),
+		hasItem: async (key) => await instance.exists(key) === 1,
+		get instance() {
+			return instance;
+		},
+		removeItem: async (key) => await instance.del(key) === 1,
+		setItem: (key, value) => instance.set(key, encodeToStorageValue(value)),
+		setItemWithTtl(key, seconds, value) {
+			return instance.setex(key, seconds, encodeToStorageValue(value));
+		}
+	});
+}
+function decodeStorageValue(data) {
+	if (!isCustomFormat(data)) return data;
+	const payload = data.subarray(customValueHeaderLength);
+	const type = data[customValueHeader.byteLength];
+	switch (type) {
+		case StorageValueEncodingType.Buffer: return payload;
+		case StorageValueEncodingType.Json: try {
+			return deserialize(JSON.parse(payload.toString()));
+		} catch {
+			throw new Error("[RedisStorage] Failed to parse JSON payload");
+		}
+		case StorageValueEncodingType.String: return payload.toString();
+		default: throw new Error(`[RedisStorage] Unknown encoding type: ${type}`);
+	}
+}
+function encodeToStorageValue(value) {
+	if (Buffer.isBuffer(value)) return toCustomValue(StorageValueEncodingType.Buffer, value);
+	if (typeof value === "string") return toCustomValue(StorageValueEncodingType.String, Buffer.from(value));
+	return toCustomValue(StorageValueEncodingType.Json, Buffer.from(JSON.stringify(serialize(value))));
+}
+function isCustomFormat(buffer) {
+	return buffer.length >= customValueHeaderLength && buffer[0] === customValueHeader[0] && buffer[1] === customValueHeader[1] && buffer[2] === customValueHeader[2];
+}
+function toCustomValue(type, payload) {
+	return Buffer.concat([
+		customValueHeader,
+		Buffer.of(type),
+		payload
+	]);
+}
+
+//#endregion
+export { createEnhancedRedisStorage };
+//# sourceMappingURL=core.js.map