@kikiutils/shared 13.6.1 → 14.0.1

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

@@ -1,36 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,85 +0,0 @@
-import { Redis } from "ioredis";
-
-//#region src/storage/enhanced/redis/core.d.ts
-
-/**
- * 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');
- * ```
- */
-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 +0,0 @@
-{"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

@@ -1,85 +0,0 @@
-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

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

@@ -1 +0,0 @@
-{"version":3,"file":"core.js","names":[],"sources":["../../../../src/storage/enhanced/redis/core.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport { Redis } from 'ioredis';\nimport {\n    deserialize,\n    serialize,\n} from 'superjson';\n\nenum StorageValueEncodingType {\n    Buffer = 0,\n    Json = 1,\n    String = 2,\n}\n\nconst customValueHeader = Buffer.of(\n    0xE2,\n    0x81,\n    0xA0,\n);\n\nconst customValueHeaderLength = customValueHeader.byteLength + 1;\n\n/**\n * Creates an enhanced Redis-based storage interface using SuperJSON encoding.\n *\n * This utility provides a typed, serializable key-value store backed by Redis,\n * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).\n *\n * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string\n *\n * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding\n *\n * @example\n * ```typescript\n * import { createEnhancedRedisStorage } from '@kikiutils/shared/storage/enhanced/redis';\n *\n * const redisStorage = createEnhancedRedisStorage('redis://localhost');\n * await redisStorage.setItem('user:1', { name: 'user' });\n * const user = await redisStorage.getItem<{ name: string }>('user:1');\n * ```\n */\nexport function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string) {\n    const instance = ioRedisInstanceOrUrl instanceof Redis ? ioRedisInstanceOrUrl : new Redis(ioRedisInstanceOrUrl);\n    return Object.freeze({\n        /**\n         * Retrieves a value from Redis and decodes it.\n         *\n         * @template T - The expected return type\n         *\n         * @param {string} key - The Redis key\n         *\n         * @returns {Promise<null | T>} The decoded value or null if not found\n         */\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await instance.getBuffer(key);\n            return rawValue ? decodeStorageValue(rawValue) as T : null;\n        },\n        /**\n         * Gets the remaining TTL (in seconds) for a given key.\n         *\n         * @param {string} key - The Redis key\n         *\n         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set\n         */\n        getItemTtl: (key: string) => instance.ttl(key),\n        /**\n         * Checks whether a key exists in Redis.\n         *\n         * @param {string} key - The Redis key\n         *\n         * @returns {Promise<boolean>} True if the key exists, false otherwise\n         */\n        hasItem: async (key: string) => await instance.exists(key) === 1,\n        /**\n         * The underlying Redis instance, exposed for advanced operations.\n         * Use with caution; most use cases should rely on the wrapper methods.\n         *\n         * @returns {Redis} The underlying Redis instance\n         */\n        get instance() {\n            return instance;\n        },\n        /**\n         * Removes a key from Redis.\n         *\n         * @param {string} key - The Redis key to delete\n         *\n         * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,\n         * or `false` if it did not exist.\n         */\n        removeItem: async (key: string) => await instance.del(key) === 1,\n        /**\n         * Stores a value in Redis without expiration.\n         *\n         * @param {string} key - The Redis key\n         * @param {any} value - The value to store. Will be serialized\n         */\n        setItem: (key: string, value: any) => instance.set(key, encodeToStorageValue(value)),\n        /**\n         * Stores a value in Redis with a time-to-live (TTL).\n         *\n         * @param {string} key - The Redis key\n         * @param {number} seconds - Expiration time in seconds\n         * @param {any} value - The value to store. Will be serialized\n         */\n        setItemWithTtl(key: string, seconds: number, value: any) {\n            return instance.setex(key, seconds, encodeToStorageValue(value));\n        },\n    });\n}\n\nfunction decodeStorageValue(data: Buffer) {\n    if (!isCustomFormat(data)) return data;\n    const payload = data.subarray(customValueHeaderLength);\n    const type = data[customValueHeader.byteLength];\n    switch (type) {\n        case StorageValueEncodingType.Buffer: return payload;\n        case StorageValueEncodingType.Json:\n            try {\n                return deserialize(JSON.parse(payload.toString()));\n            } catch {\n                throw new Error('[RedisStorage] Failed to parse JSON payload');\n            }\n        case StorageValueEncodingType.String: return payload.toString();\n        default:\n            throw new Error(`[RedisStorage] Unknown encoding type: ${type}`);\n    }\n}\n\nfunction encodeToStorageValue(value: any) {\n    if (Buffer.isBuffer(value)) return toCustomValue(StorageValueEncodingType.Buffer, value);\n    if (typeof value === 'string') return toCustomValue(StorageValueEncodingType.String, Buffer.from(value));\n    return toCustomValue(StorageValueEncodingType.Json, Buffer.from(JSON.stringify(serialize(value))));\n}\n\nfunction isCustomFormat(buffer: Buffer) {\n    return (\n        buffer.length >= customValueHeaderLength\n        && buffer[0] === customValueHeader[0]\n        && buffer[1] === customValueHeader[1]\n        && buffer[2] === customValueHeader[2]\n    );\n}\n\nfunction toCustomValue(type: StorageValueEncodingType, payload: Buffer) {\n    return Buffer.concat([\n        customValueHeader,\n        Buffer.of(type),\n        payload,\n    ]);\n}\n"],"mappings":";;;;;AAQA,IAAK,gFAAL;AACI;AACA;AACA;;EAHC;AAML,MAAM,oBAAoB,OAAO,GAC7B,KACA,KACA,IACH;AAED,MAAM,0BAA0B,kBAAkB,aAAa;;;;;;;;;;;;;;;;;;;;AAqB/D,SAAgB,2BAA2B,sBAAsC;CAC7E,MAAM,WAAW,gCAAgC,QAAQ,uBAAuB,IAAI,MAAM,qBAAqB;AAC/G,QAAO,OAAO,OAAO;EAUjB,MAAM,QAAqB,KAAa;GACpC,MAAM,WAAW,MAAM,SAAS,UAAU,IAAI;AAC9C,UAAO,WAAW,mBAAmB,SAAS,GAAQ;;EAS1D,aAAa,QAAgB,SAAS,IAAI,IAAI;EAQ9C,SAAS,OAAO,QAAgB,MAAM,SAAS,OAAO,IAAI,KAAK;EAO/D,IAAI,WAAW;AACX,UAAO;;EAUX,YAAY,OAAO,QAAgB,MAAM,SAAS,IAAI,IAAI,KAAK;EAO/D,UAAU,KAAa,UAAe,SAAS,IAAI,KAAK,qBAAqB,MAAM,CAAC;EAQpF,eAAe,KAAa,SAAiB,OAAY;AACrD,UAAO,SAAS,MAAM,KAAK,SAAS,qBAAqB,MAAM,CAAC;;EAEvE,CAAC;;AAGN,SAAS,mBAAmB,MAAc;AACtC,KAAI,CAAC,eAAe,KAAK,CAAE,QAAO;CAClC,MAAM,UAAU,KAAK,SAAS,wBAAwB;CACtD,MAAM,OAAO,KAAK,kBAAkB;AACpC,SAAQ,MAAR;EACI,KAAK,yBAAyB,OAAQ,QAAO;EAC7C,KAAK,yBAAyB,KAC1B,KAAI;AACA,UAAO,YAAY,KAAK,MAAM,QAAQ,UAAU,CAAC,CAAC;UAC9C;AACJ,SAAM,IAAI,MAAM,8CAA8C;;EAEtE,KAAK,yBAAyB,OAAQ,QAAO,QAAQ,UAAU;EAC/D,QACI,OAAM,IAAI,MAAM,yCAAyC,OAAO;;;AAI5E,SAAS,qBAAqB,OAAY;AACtC,KAAI,OAAO,SAAS,MAAM,CAAE,QAAO,cAAc,yBAAyB,QAAQ,MAAM;AACxF,KAAI,OAAO,UAAU,SAAU,QAAO,cAAc,yBAAyB,QAAQ,OAAO,KAAK,MAAM,CAAC;AACxG,QAAO,cAAc,yBAAyB,MAAM,OAAO,KAAK,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC,CAAC;;AAGtG,SAAS,eAAe,QAAgB;AACpC,QACI,OAAO,UAAU,2BACd,OAAO,OAAO,kBAAkB,MAChC,OAAO,OAAO,kBAAkB,MAChC,OAAO,OAAO,kBAAkB;;AAI3C,SAAS,cAAc,MAAgC,SAAiB;AACpE,QAAO,OAAO,OAAO;EACjB;EACA,OAAO,GAAG,KAAK;EACf;EACH,CAAC"}

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

@@ -1,3 +0,0 @@
-import { createEnhancedRedisStorage } from "./core.js";
-import { createKeyedEnhancedRedisStore } from "./keyed-store.js";
-export { createEnhancedRedisStorage, createKeyedEnhancedRedisStore };

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

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

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

@@ -1,44 +0,0 @@
-import { createEnhancedRedisStorage } from "./core.js";
-
-//#region src/storage/enhanced/redis/keyed-store.d.ts
-
-/**
- * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`
- * and a dynamic key-generation function.
- *
- * This utility abstracts away key construction and provides high-level access
- * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.
- * It is ideal for namespaced data, caching, and session handling.
- *
- * @template D - The value type to store
- *
- * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance
- *
- * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface
- *
- * @example
- * ```typescript
- * import { createKeyedEnhancedRedisStore } from '@kikiutils/shared/storage/enhanced/redis';
- *
- * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);
- * await userStore.setItem({ id: 123, name: 'user' }, 123);
- * const user = await userStore.getItem(123);
- * ```
- */
-declare function createKeyedEnhancedRedisStore<D = unknown>(storage: ReturnType<typeof createEnhancedRedisStorage>): <P extends any[]>(getKeyFunction: (...args: P) => string) => Readonly<{
-  getItem: (...args: P) => Promise<D | null>;
-  getItemTtl: (...args: P) => Promise<number>;
-  hasItem: (...args: P) => Promise<boolean>;
-  removeItem: (...args: P) => Promise<boolean>;
-  /**
-   * 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) => Promise<"OK">;
-  setItemWithTtl(seconds: number, value: D, ...args: P): Promise<"OK">;
-}>;
-//#endregion
-export { createKeyedEnhancedRedisStore };
-//# sourceMappingURL=keyed-store.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;;;;;;AACmE,iBADnD,6BACmD,CAAA,IAAA,OAAA,CAAA,CAAA,OAAA,EADC,UACD,CAAA,OADmB,0BACnB,CAAA,CAAA,EAAA,CAAA,UAAA,GAAA,EAAA,CAAA,CAAA,cAAA,EAAA,CAAA,GAAA,IAAA,EAAZ,CAAY,EAAA,GAAA,MAAA,EAAA,GAAA,QAAA,CAAA;qBACxC,MAAC,QAAA;wBACE,MAAC;qBACJ,MAAC;wBACE,MAAC;;;;;;wBAMD;mBACL,YAAY,MAAC;yCACS,YAAY,IAAC"}

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

@@ -1,41 +0,0 @@
-//#region src/storage/enhanced/redis/keyed-store.ts
-/**
-* Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`
-* and a dynamic key-generation function.
-*
-* This utility abstracts away key construction and provides high-level access
-* to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.
-* It is ideal for namespaced data, caching, and session handling.
-*
-* @template D - The value type to store
-*
-* @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance
-*
-* @returns A factory that accepts a key generator function and returns a scoped Redis storage interface
-*
-* @example
-* ```typescript
-* import { createKeyedEnhancedRedisStore } from '@kikiutils/shared/storage/enhanced/redis';
-*
-* const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);
-* await userStore.setItem({ id: 123, name: 'user' }, 123);
-* const user = await userStore.getItem(123);
-* ```
-*/
-function createKeyedEnhancedRedisStore(storage) {
-	return (getKeyFunction) => Object.freeze({
-		getItem: (...args) => storage.getItem(getKeyFunction(...args)),
-		getItemTtl: (...args) => storage.getItemTtl(getKeyFunction(...args)),
-		hasItem: (...args) => storage.hasItem(getKeyFunction(...args)),
-		removeItem: (...args) => storage.removeItem(getKeyFunction(...args)),
-		resolveKey: (...args) => getKeyFunction(...args),
-		setItem: (value, ...args) => storage.setItem(getKeyFunction(...args), value),
-		setItemWithTtl(seconds, value, ...args) {
-			return storage.setItemWithTtl(getKeyFunction(...args), seconds, value);
-		}
-	});
-}
-
-//#endregion
-export { createKeyedEnhancedRedisStore };
-//# sourceMappingURL=keyed-store.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"sourcesContent":["import type { createEnhancedRedisStorage } from './core';\n\n/**\n * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`\n * and a dynamic key-generation function.\n *\n * This utility abstracts away key construction and provides high-level access\n * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.\n * It is ideal for namespaced data, caching, and session handling.\n *\n * @template D - The value type to store\n *\n * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance\n *\n * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface\n *\n * @example\n * ```typescript\n * import { createKeyedEnhancedRedisStore } from '@kikiutils/shared/storage/enhanced/redis';\n *\n * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);\n * await userStore.setItem({ id: 123, name: 'user' }, 123);\n * const user = await userStore.getItem(123);\n * ```\n */\nexport function createKeyedEnhancedRedisStore<D = unknown>(storage: ReturnType<typeof createEnhancedRedisStorage>) {\n    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => storage.getItem<D>(getKeyFunction(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(getKeyFunction(...args)),\n        hasItem: (...args: P) => storage.hasItem(getKeyFunction(...args)),\n        removeItem: (...args: P) => storage.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) => storage.setItem(getKeyFunction(...args), value),\n        setItemWithTtl(seconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(getKeyFunction(...args), seconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,8BAA2C,SAAwD;AAC/G,SAAyB,mBAA2C,OAAO,OAAO;EAC9E,UAAU,GAAG,SAAY,QAAQ,QAAW,eAAe,GAAG,KAAK,CAAC;EACpE,aAAa,GAAG,SAAY,QAAQ,WAAW,eAAe,GAAG,KAAK,CAAC;EACvE,UAAU,GAAG,SAAY,QAAQ,QAAQ,eAAe,GAAG,KAAK,CAAC;EACjE,aAAa,GAAG,SAAY,QAAQ,WAAW,eAAe,GAAG,KAAK,CAAC;EAMvE,aAAa,GAAG,SAAY,eAAe,GAAG,KAAK;EACnD,UAAU,OAAU,GAAG,SAAY,QAAQ,QAAQ,eAAe,GAAG,KAAK,EAAE,MAAM;EAClF,eAAe,SAAiB,OAAU,GAAG,MAAS;AAClD,UAAO,QAAQ,eAAe,eAAe,GAAG,KAAK,EAAE,SAAS,MAAM;;EAE7E,CAAC"}

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

@@ -1,44 +0,0 @@
-import { LRUCache } from "lru-cache";
-
-//#region src/storage/lru/keyed-store.d.ts
-
-/**
- * Creates a reusable, type-safe keyed store wrapper for an LRUCache instance.
- *
- * This utility allows structured access to cache entries using a dynamic key-generation function.
- *
- * @template D - The specific value type exposed by this store (must extend `V`)
- *
- * @param {LRUCache<any, any, any>} lruInstance - An instance of `lru-cache`
- *
- * @returns A factory that accepts a key generator and returns a scoped, type-safe LRU-based store
- *
- * @example
- * ```typescript
- * import { createKeyedLruStore } from '@kikiutils/shared/storage/lru/keyed-store';
- *
- * const lruCache = new LRUCache({ max: 5000 });
- * const userStore = createKeyedLruStore<User>(lruCache)((id: number) => `user:${id}`);
- * userStore.setItem({ id: 1 }, 1);
- * const user = userStore.getItem(1);
- * ```
- */
-declare function createKeyedLruStore<D = unknown>(lruInstance: LRUCache<any, any, any>): <P extends any[]>(getKeyFunction: (...args: P) => string) => Readonly<{
-  /**
-   * Return a value from the cache. Will update the recency of the cache entry found.
-   *
-   * If the key is not found, returns `null`.
-   */
-  getItem(...args: P): NonNullable<D> | null;
-  getItemTtl: (...args: P) => number;
-  hasItem: (...args: P) => boolean;
-  removeItem: (...args: P) => boolean;
-  /**
-   * Resolves the full cache key from the given arguments.
-   */
-  resolveKey: (...args: P) => string;
-  setItem(value: D, ...args: P): void;
-}>;
-//#endregion
-export { createKeyedLruStore };
-//# sourceMappingURL=keyed-store.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storage/lru/keyed-store.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;;;;;;;;;;;;;;;iBAAgB,8CAA8C,sEACP,iBAAY;;;;;;mBAM1C,IAAC,YAAA;wBAII;qBACH;wBACG;;;;wBAIA;iBACP,YAAY"}

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

@@ -1,40 +0,0 @@
-//#region src/storage/lru/keyed-store.ts
-/**
-* Creates a reusable, type-safe keyed store wrapper for an LRUCache instance.
-*
-* This utility allows structured access to cache entries using a dynamic key-generation function.
-*
-* @template D - The specific value type exposed by this store (must extend `V`)
-*
-* @param {LRUCache<any, any, any>} lruInstance - An instance of `lru-cache`
-*
-* @returns A factory that accepts a key generator and returns a scoped, type-safe LRU-based store
-*
-* @example
-* ```typescript
-* import { createKeyedLruStore } from '@kikiutils/shared/storage/lru/keyed-store';
-*
-* const lruCache = new LRUCache({ max: 5000 });
-* const userStore = createKeyedLruStore<User>(lruCache)((id: number) => `user:${id}`);
-* userStore.setItem({ id: 1 }, 1);
-* const user = userStore.getItem(1);
-* ```
-*/
-function createKeyedLruStore(lruInstance) {
-	return (getKeyFunction) => Object.freeze({
-		getItem(...args) {
-			return lruInstance.get(getKeyFunction(...args)) ?? null;
-		},
-		getItemTtl: (...args) => lruInstance.getRemainingTTL(getKeyFunction(...args)),
-		hasItem: (...args) => lruInstance.has(getKeyFunction(...args)),
-		removeItem: (...args) => lruInstance.delete(getKeyFunction(...args)),
-		resolveKey: (...args) => getKeyFunction(...args),
-		setItem(value, ...args) {
-			lruInstance.set(getKeyFunction(...args), value);
-		}
-	});
-}
-
-//#endregion
-export { createKeyedLruStore };
-//# sourceMappingURL=keyed-store.js.map

package/dist/storage/lru/keyed-store.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storage/lru/keyed-store.ts"],"sourcesContent":["import type { LRUCache } from 'lru-cache';\n\n/**\n * Creates a reusable, type-safe keyed store wrapper for an LRUCache instance.\n *\n * This utility allows structured access to cache entries using a dynamic key-generation function.\n *\n * @template D - The specific value type exposed by this store (must extend `V`)\n *\n * @param {LRUCache<any, any, any>} lruInstance - An instance of `lru-cache`\n *\n * @returns A factory that accepts a key generator and returns a scoped, type-safe LRU-based store\n *\n * @example\n * ```typescript\n * import { createKeyedLruStore } from '@kikiutils/shared/storage/lru/keyed-store';\n *\n * const lruCache = new LRUCache({ max: 5000 });\n * const userStore = createKeyedLruStore<User>(lruCache)((id: number) => `user:${id}`);\n * userStore.setItem({ id: 1 }, 1);\n * const user = userStore.getItem(1);\n * ```\n */\nexport function createKeyedLruStore<D = unknown>(lruInstance: LRUCache<any, any, any>) {\n    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({\n        /**\n         * Return a value from the cache. Will update the recency of the cache entry found.\n         *\n         * If the key is not found, returns `null`.\n         */\n        getItem(...args: P) {\n            const rawValue = lruInstance.get(getKeyFunction(...args));\n            return rawValue as D ?? null;\n        },\n        getItemTtl: (...args: P) => lruInstance.getRemainingTTL(getKeyFunction(...args)),\n        hasItem: (...args: P) => lruInstance.has(getKeyFunction(...args)),\n        removeItem: (...args: P) => lruInstance.delete(getKeyFunction(...args)),\n        /**\n         * Resolves the full cache key from the given arguments.\n         */\n        resolveKey: (...args: P) => getKeyFunction(...args),\n        setItem(value: D, ...args: P) {\n            lruInstance.set(getKeyFunction(...args), value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,oBAAiC,aAAsC;AACnF,SAAyB,mBAA2C,OAAO,OAAO;EAM9E,QAAQ,GAAG,MAAS;AAEhB,UADiB,YAAY,IAAI,eAAe,GAAG,KAAK,CAAC,IACjC;;EAE5B,aAAa,GAAG,SAAY,YAAY,gBAAgB,eAAe,GAAG,KAAK,CAAC;EAChF,UAAU,GAAG,SAAY,YAAY,IAAI,eAAe,GAAG,KAAK,CAAC;EACjE,aAAa,GAAG,SAAY,YAAY,OAAO,eAAe,GAAG,KAAK,CAAC;EAIvE,aAAa,GAAG,SAAY,eAAe,GAAG,KAAK;EACnD,QAAQ,OAAU,GAAG,MAAS;AAC1B,eAAY,IAAI,eAAe,GAAG,KAAK,EAAE,MAAM;;EAEtD,CAAC"}

package/src/storage/enhanced/local/core.ts

@@ -1,106 +0,0 @@
-import {
-    deserialize,
-    serialize,
-} from 'superjson';
-
-enum StorageValueEncodingType {
-    Json = '0',
-    String = '1',
-}
-
-const customValueHeader = '​⁠';
-const customValueHeaderLength = customValueHeader.length + 1;
-const toCustomValue = (type: StorageValueEncodingType, payload: string) => `${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');
- * ```
- */
-export const enhancedLocalStorage = Object.freeze({
-    /**
-     * Removes all items from localStorage.
-     */
-    clear: () => window.localStorage.clear(),
-    /**
-     * 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) {
-        const rawValue = window.localStorage.getItem(key);
-        return rawValue ? decodeStorageValue(rawValue) as 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) => window.localStorage.getItem(key) !== null,
-    /**
-     * Returns the number of items stored in localStorage.
-     *
-     * @returns {number} The number of items stored in localStorage
-     */
-    get length() {
-        return window.localStorage.length;
-    },
-    /**
-     * Removes a specific key from localStorage.
-     *
-     * @param {string} key - The key to remove
-     */
-    removeItem: (key: string) => window.localStorage.removeItem(key),
-    /**
-     * 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) => window.localStorage.setItem(key, encodeToStorageValue(value)),
-});
-
-function decodeStorageValue(data: string) {
-    if (!isCustomFormat(data)) return data;
-    const payload = data.substring(customValueHeaderLength);
-    const type = data.charAt(customValueHeader.length);
-    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: any) {
-    if (typeof value === 'string') return toCustomValue(StorageValueEncodingType.String, value);
-    return toCustomValue(StorageValueEncodingType.Json, JSON.stringify(serialize(value)));
-}
-
-function isCustomFormat(data: string) {
-    return (
-        data.length >= customValueHeaderLength
-        && data[0] === customValueHeader[0]
-        && data[1] === customValueHeader[1]
-    );
-}

package/src/storage/enhanced/local/index.ts

@@ -1,2 +0,0 @@
-export { enhancedLocalStorage } from './core';
-export { createKeyedEnhancedLocalStore } from './keyed-store';

package/src/storage/enhanced/local/keyed-store.ts

@@ -1,36 +0,0 @@
-import { enhancedLocalStorage } from './core';
-
-/**
- * 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);
- * ```
- */
-export function createKeyedEnhancedLocalStore<D = unknown>() {
-    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({
-        getItem: (...args: P) => enhancedLocalStorage.getItem<D>(getKeyFunction(...args)),
-        hasItem: (...args: P) => enhancedLocalStorage.hasItem(getKeyFunction(...args)),
-        removeItem: (...args: P) => enhancedLocalStorage.removeItem(getKeyFunction(...args)),
-        /**
-         * Resolves the storage key from the given arguments.
-         *
-         * @returns {string} The final string key used internally
-         */
-        resolveKey: (...args: P) => getKeyFunction(...args),
-        setItem: (value: D, ...args: P) => enhancedLocalStorage.setItem(getKeyFunction(...args), value),
-    });
-}