@kikiutils/shared 12.0.0 → 13.0.1

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

@@ -0,0 +1 @@
+{"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 +1,3 @@
-export { createEnhancedRedisStorage } from './core';
-export { createKeyedEnhancedRedisStore } from './keyed-store';
-//# sourceMappingURL=index.d.ts.map
+import { createEnhancedRedisStorage } from "./core.js";
+import { createKeyedEnhancedRedisStore } from "./keyed-store.js";
+export { createEnhancedRedisStorage, createKeyedEnhancedRedisStore };

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

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

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

@@ -1,4 +1,7 @@
-import type { createEnhancedRedisStorage } from './core';
+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.
@@ -22,18 +25,20 @@ import type { createEnhancedRedisStorage } from './core';
  * const user = await userStore.getItem(123);
  * ```
  */
-export 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">;
+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 +1 @@
-{"version":3,"file":"keyed-store.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,IACrG,CAAC,SAAS,GAAG,EAAE,EAAE,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM;uBACxC,CAAC;0BACE,CAAC;uBACJ,CAAC;0BACE,CAAC;IACvB;;;;OAIG;0BACmB,CAAC;qBACN,CAAC,WAAW,CAAC;4BACN,MAAM,SAAS,CAAC,WAAW,CAAC;GAI3D"}
+{"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;EAAA,OAAA,EAAA,CAAA,GAAA,IAAA,EACxC,CADwC,EAAA,GACvC,OADuC,CACvC,CADuC,GAAA,IAAA,CAAA;wBAErC,MAAC;qBACJ,MAAC;wBACE,MAAC;;;;;;wBAMD;mBACL,YAAY,MAAC;yCACS,YAAY,IAAC"}

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

@@ -0,0 +1,41 @@
+//#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

@@ -0,0 +1 @@
+{"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,4 +1,7 @@
-import type { LRUCache } from 'lru-cache';
+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.
  *
@@ -20,20 +23,22 @@ import type { LRUCache } from 'lru-cache';
  * const user = userStore.getItem(1);
  * ```
  */
-export 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;
+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 +1 @@
-{"version":3,"file":"keyed-store.d.ts","sourceRoot":"","sources":["../../../src/storage/lru/keyed-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,IACzE,CAAC,SAAS,GAAG,EAAE,EAAE,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM;IAC3D;;;;OAIG;qBACc,CAAC;0BAII,CAAC;uBACJ,CAAC;0BACE,CAAC;IACvB;;OAEG;0BACmB,CAAC;mBACR,CAAC,WAAW,CAAC;GAInC"}
+{"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

@@ -0,0 +1,40 @@
+//#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

@@ -0,0 +1 @@
+{"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/dist/string.d.ts

@@ -1,4 +1,5 @@
-export type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lowercase-numeric' | 'numeric' | 'uppercase' | 'uppercase-numeric';
+//#region src/string.d.ts
+type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lowercase-numeric' | 'numeric' | 'uppercase' | 'uppercase-numeric';
 /**
  * Generates a random string of a given length using a specified character set.
  *
@@ -18,5 +19,7 @@ export type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lo
  * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'
  * ```
  */
-export declare function randomString(length: number, mode?: RandomStringMode): string;
+declare function randomString(length: number, mode?: RandomStringMode): string;
+//#endregion
+export { RandomStringMode, randomString };
 //# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ,cAAc,GACd,WAAW,GACX,mBAAmB,GACnB,SAAS,GACT,WAAW,GACX,mBAAmB,CAAC;AAexB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,gBAA+B,UAQjF"}
+{"version":3,"file":"string.d.ts","names":[],"sources":["../src/string.ts"],"sourcesContent":[],"mappings":";KAAY,gBAAA;AAAZ;AAyCA;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,wBAAmC"}

package/dist/string.js

@@ -0,0 +1,42 @@
+//#region src/string.ts
+const DIGITS = "0123456789";
+const LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+const UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const CHARSETS = {
+	"alphabetic": LOWERCASE + UPPERCASE,
+	"alphanumeric": DIGITS + LOWERCASE + UPPERCASE,
+	"lowercase": LOWERCASE,
+	"lowercase-numeric": DIGITS + LOWERCASE,
+	"numeric": DIGITS,
+	"uppercase": UPPERCASE,
+	"uppercase-numeric": DIGITS + UPPERCASE
+};
+/**
+* Generates a random string of a given length using a specified character set.
+*
+* @param {number} length - The length of the string to generate. Must be a positive integer
+* @param {RandomStringMode} [mode] - The character set to use
+*
+* @returns {string} The generated random string
+*
+* @throws {Error} If the length is not a positive integer or the mode is unsupported
+*
+* @example
+* ```typescript
+* import { randomString } from '@kikiutils/shared/string';
+*
+* console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)
+* console.log(randomString(6, 'numeric')); // e.g. '402398'
+* console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'
+* ```
+*/
+function randomString(length, mode = "alphabetic") {
+	if (!Number.isInteger(length) || length <= 0) throw new Error(`Invalid length: ${length}. Must be a positive integer`);
+	const charset = CHARSETS[mode];
+	if (!charset) throw new Error(`Unsupported mode: ${mode}`);
+	return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join("");
+}
+
+//#endregion
+export { randomString };
+//# sourceMappingURL=string.js.map

package/dist/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","names":["CHARSETS: Record<RandomStringMode, string>"],"sources":["../src/string.ts"],"sourcesContent":["export type RandomStringMode =\n  | 'alphabetic'\n  | 'alphanumeric'\n  | 'lowercase'\n  | 'lowercase-numeric'\n  | 'numeric'\n  | 'uppercase'\n  | 'uppercase-numeric';\n\nconst DIGITS = '0123456789';\nconst LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst CHARSETS: Record<RandomStringMode, string> = {\n    'alphabetic': LOWERCASE + UPPERCASE,\n    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,\n    'lowercase': LOWERCASE,\n    'lowercase-numeric': DIGITS + LOWERCASE,\n    'numeric': DIGITS,\n    'uppercase': UPPERCASE,\n    'uppercase-numeric': DIGITS + UPPERCASE,\n};\n\n/**\n * Generates a random string of a given length using a specified character set.\n *\n * @param {number} length - The length of the string to generate. Must be a positive integer\n * @param {RandomStringMode} [mode] - The character set to use\n *\n * @returns {string} The generated random string\n *\n * @throws {Error} If the length is not a positive integer or the mode is unsupported\n *\n * @example\n * ```typescript\n * import { randomString } from '@kikiutils/shared/string';\n *\n * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)\n * console.log(randomString(6, 'numeric')); // e.g. '402398'\n * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'\n * ```\n */\nexport function randomString(length: number, mode: RandomStringMode = 'alphabetic') {\n    if (!Number.isInteger(length) || length <= 0) {\n        throw new Error(`Invalid length: ${length}. Must be a positive integer`);\n    }\n\n    const charset = CHARSETS[mode];\n    if (!charset) throw new Error(`Unsupported mode: ${mode}`);\n    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');\n}\n"],"mappings":";AASA,MAAM,SAAS;AACf,MAAM,YAAY;AAClB,MAAM,YAAY;AAClB,MAAMA,WAA6C;CAC/C,cAAc,YAAY;CAC1B,gBAAgB,SAAS,YAAY;CACrC,aAAa;CACb,qBAAqB,SAAS;CAC9B,WAAW;CACX,aAAa;CACb,qBAAqB,SAAS;CACjC;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,aAAa,QAAgB,OAAyB,cAAc;AAChF,KAAI,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACvC,OAAM,IAAI,MAAM,mBAAmB,OAAO,8BAA8B;CAG5E,MAAM,UAAU,SAAS;AACzB,KAAI,CAAC,QAAS,OAAM,IAAI,MAAM,qBAAqB,OAAO;AAC1D,QAAO,MAAM,KAAK,EAAE,QAAQ,QAAQ,QAAQ,KAAK,MAAM,KAAK,QAAQ,GAAG,QAAQ,OAAO,EAAE,CAAC,KAAK,GAAG"}

package/dist/url.d.ts

@@ -1,3 +1,4 @@
+//#region src/url.d.ts
 /**
  * Appends or updates the `redirect` query parameter on a given URL.
  *
@@ -8,5 +9,7 @@
  *
  * @returns {string} A new URL string with the `redirect` query parameter
  */
-export declare function appendRedirectParamToUrl(url: string, redirectPath: string): string;
+declare function appendRedirectParamToUrl(url: string, redirectPath: string): string;
+//#endregion
+export { appendRedirectParamToUrl };
 //# sourceMappingURL=url.d.ts.map

package/dist/url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../src/url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAKzE"}
+{"version":3,"file":"url.d.ts","names":[],"sources":["../src/url.ts"],"sourcesContent":[],"mappings":";;AAUA;;;;;;;;;iBAAgB,wBAAA"}

package/dist/url.js

@@ -0,0 +1,21 @@
+//#region src/url.ts
+/**
+* Appends or updates the `redirect` query parameter on a given URL.
+*
+* Typically used to preserve the user's current path for post-login navigation.
+*
+* @param {string} url - The target URL to modify
+* @param {string} redirectPath - The path to use as the redirect destination
+*
+* @returns {string} A new URL string with the `redirect` query parameter
+*/
+function appendRedirectParamToUrl(url, redirectPath) {
+	const [base, rawQuery = ""] = url.split("?");
+	const searchParams = new URLSearchParams(rawQuery);
+	searchParams.set("redirect", redirectPath);
+	return `${base}?${searchParams.toString()}`;
+}
+
+//#endregion
+export { appendRedirectParamToUrl };
+//# sourceMappingURL=url.js.map

package/dist/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":[],"sources":["../src/url.ts"],"sourcesContent":["/**\n * Appends or updates the `redirect` query parameter on a given URL.\n *\n * Typically used to preserve the user's current path for post-login navigation.\n *\n * @param {string} url - The target URL to modify\n * @param {string} redirectPath - The path to use as the redirect destination\n *\n * @returns {string} A new URL string with the `redirect` query parameter\n */\nexport function appendRedirectParamToUrl(url: string, redirectPath: string) {\n    const [base, rawQuery = ''] = url.split('?');\n    const searchParams = new URLSearchParams(rawQuery);\n    searchParams.set('redirect', redirectPath);\n    return `${base}?${searchParams.toString()}`;\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAgB,yBAAyB,KAAa,cAAsB;CACxE,MAAM,CAAC,MAAM,WAAW,MAAM,IAAI,MAAM,IAAI;CAC5C,MAAM,eAAe,IAAI,gBAAgB,SAAS;AAClD,cAAa,IAAI,YAAY,aAAa;AAC1C,QAAO,GAAG,KAAK,GAAG,aAAa,UAAU"}

package/dist/vue.d.ts

@@ -1,4 +1,7 @@
-import type { Ref } from 'vue';
+import { Ref } from "vue";
+
+//#region src/vue.d.ts
+
 /**
  * Appends the current Vue Router route's fullPath as the `redirect` query parameter to the given URL.
  *
@@ -6,19 +9,19 @@ import type { Ref } from 'vue';
  *
  * @returns {string} A new URL with the current route fullPath as the `redirect` parameter
  */
-export declare function appendRedirectParamFromCurrentRouteToUrl(url: string): string;
+declare function appendRedirectParamFromCurrentRouteToUrl(url: string): string;
 /**
  * Clears an interval referenced by a Vue ref and sets it to null.
  *
  * @param {Ref<null | ReturnType<typeof setInterval>>} intervalRef - A Vue ref holding a NodeJS.Timeout or null
  */
-export declare function clearIntervalRef(intervalRef: Ref<null | ReturnType<typeof setInterval>>): void;
+declare function clearIntervalRef(intervalRef: Ref<null | ReturnType<typeof setInterval>>): void;
 /**
  * Clears a timeout referenced by a Vue ref and sets it to null.
  *
  * @param {Ref<null | ReturnType<typeof setTimeout>>} timeoutRef - A Vue ref holding a NodeJS.Timeout or null
  */
-export declare function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof setTimeout>>): void;
+declare function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof setTimeout>>): void;
 /**
  * A Vue composition function that remembers and restores scroll position
  * of a scrollable container across route changes and keep-alive activation.
@@ -27,5 +30,7 @@ export declare function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof
  *
  * @param {Ref<null | T>} containerRef - A ref to the scrollable HTML element
  */
-export declare function usePreserveScroll<T extends Element = HTMLElement>(containerRef: Ref<null | T>): void;
+declare function usePreserveScroll<T extends Element = HTMLElement>(containerRef: Ref<null | T>): void;
+//#endregion
+export { appendRedirectParamFromCurrentRouteToUrl, clearIntervalRef, clearTimeoutRef, usePreserveScroll };
 //# sourceMappingURL=vue.d.ts.map

package/dist/vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue.d.ts","sourceRoot":"","sources":["../src/vue.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAQ/B;;;;;;GAMG;AACH,wBAAgB,wCAAwC,CAAC,GAAG,EAAE,MAAM,UAEnE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,GAAG,CAAC,IAAI,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,QAGvF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,GAAG,CAAC,IAAI,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,QAGpF;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,OAAO,GAAG,WAAW,EAAE,YAAY,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,QAa7F"}
+{"version":3,"file":"vue.d.ts","names":[],"sources":["../src/vue.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;AASA;;;;AAA8C,iBAT9B,wCAAA,CAS8B,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;AAU9C;;;;AAA4C,iBAV5B,gBAAA,CAU4B,WAAA,EAVE,GAUF,CAAA,IAAA,GAVa,UAUb,CAAA,OAV+B,WAU/B,CAAA,CAAA,CAAA,EAAA,IAAA;;AAa5C;;;;AAA4F,iBAb5E,eAAA,CAa4E,UAAA,EAbhD,GAagD,CAAA,IAAA,GAbrC,UAaqC,CAAA,OAbnB,UAamB,CAAA,CAAA,CAAA,EAAA,IAAA;;;;;;;;;iBAA5E,4BAA4B,UAAU,2BAA2B,WAAW"}

package/dist/vue.js

@@ -0,0 +1,58 @@
+import { appendRedirectParamToUrl } from "./url.js";
+import { onActivated } from "vue";
+import { onBeforeRouteLeave, useRoute } from "vue-router";
+
+//#region src/vue.ts
+/**
+* Appends the current Vue Router route's fullPath as the `redirect` query parameter to the given URL.
+*
+* @param {string} url - The base URL to modify
+*
+* @returns {string} A new URL with the current route fullPath as the `redirect` parameter
+*/
+function appendRedirectParamFromCurrentRouteToUrl(url) {
+	return appendRedirectParamToUrl(url, useRoute().fullPath);
+}
+/**
+* Clears an interval referenced by a Vue ref and sets it to null.
+*
+* @param {Ref<null | ReturnType<typeof setInterval>>} intervalRef - A Vue ref holding a NodeJS.Timeout or null
+*/
+function clearIntervalRef(intervalRef) {
+	if (intervalRef.value) clearInterval(intervalRef.value);
+	intervalRef.value = null;
+}
+/**
+* Clears a timeout referenced by a Vue ref and sets it to null.
+*
+* @param {Ref<null | ReturnType<typeof setTimeout>>} timeoutRef - A Vue ref holding a NodeJS.Timeout or null
+*/
+function clearTimeoutRef(timeoutRef) {
+	if (timeoutRef.value) clearTimeout(timeoutRef.value);
+	timeoutRef.value = null;
+}
+/**
+* A Vue composition function that remembers and restores scroll position
+* of a scrollable container across route changes and keep-alive activation.
+*
+* @template T - The type of the scrollable element (defaults to HTMLElement)
+*
+* @param {Ref<null | T>} containerRef - A ref to the scrollable HTML element
+*/
+function usePreserveScroll(containerRef) {
+	let scrollLeft = 0;
+	let scrollTop = 0;
+	onActivated(() => {
+		if (!containerRef.value) return;
+		containerRef.value.scrollLeft = scrollLeft;
+		containerRef.value.scrollTop = scrollTop;
+	});
+	onBeforeRouteLeave(() => {
+		scrollLeft = containerRef.value?.scrollLeft || 0;
+		scrollTop = containerRef.value?.scrollTop || 0;
+	});
+}
+
+//#endregion
+export { appendRedirectParamFromCurrentRouteToUrl, clearIntervalRef, clearTimeoutRef, usePreserveScroll };
+//# sourceMappingURL=vue.js.map

package/dist/vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue.js","names":[],"sources":["../src/vue.ts"],"sourcesContent":["import { onActivated } from 'vue';\nimport type { Ref } from 'vue';\nimport {\n    onBeforeRouteLeave,\n    useRoute,\n} from 'vue-router';\n\nimport { appendRedirectParamToUrl } from '@/url';\n\n/**\n * Appends the current Vue Router route's fullPath as the `redirect` query parameter to the given URL.\n *\n * @param {string} url - The base URL to modify\n *\n * @returns {string} A new URL with the current route fullPath as the `redirect` parameter\n */\nexport function appendRedirectParamFromCurrentRouteToUrl(url: string) {\n    return appendRedirectParamToUrl(url, useRoute().fullPath);\n}\n\n/**\n * Clears an interval referenced by a Vue ref and sets it to null.\n *\n * @param {Ref<null | ReturnType<typeof setInterval>>} intervalRef - A Vue ref holding a NodeJS.Timeout or null\n */\nexport function clearIntervalRef(intervalRef: Ref<null | ReturnType<typeof setInterval>>) {\n    if (intervalRef.value) clearInterval(intervalRef.value);\n    intervalRef.value = null;\n}\n\n/**\n * Clears a timeout referenced by a Vue ref and sets it to null.\n *\n * @param {Ref<null | ReturnType<typeof setTimeout>>} timeoutRef - A Vue ref holding a NodeJS.Timeout or null\n */\nexport function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof setTimeout>>) {\n    if (timeoutRef.value) clearTimeout(timeoutRef.value);\n    timeoutRef.value = null;\n}\n\n/**\n * A Vue composition function that remembers and restores scroll position\n * of a scrollable container across route changes and keep-alive activation.\n *\n * @template T - The type of the scrollable element (defaults to HTMLElement)\n *\n * @param {Ref<null | T>} containerRef - A ref to the scrollable HTML element\n */\nexport function usePreserveScroll<T extends Element = HTMLElement>(containerRef: Ref<null | T>) {\n    let scrollLeft = 0;\n    let scrollTop = 0;\n    onActivated(() => {\n        if (!containerRef.value) return;\n        containerRef.value.scrollLeft = scrollLeft;\n        containerRef.value.scrollTop = scrollTop;\n    });\n\n    onBeforeRouteLeave(() => {\n        scrollLeft = containerRef.value?.scrollLeft || 0;\n        scrollTop = containerRef.value?.scrollTop || 0;\n    });\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,yCAAyC,KAAa;AAClE,QAAO,yBAAyB,KAAK,UAAU,CAAC,SAAS;;;;;;;AAQ7D,SAAgB,iBAAiB,aAAyD;AACtF,KAAI,YAAY,MAAO,eAAc,YAAY,MAAM;AACvD,aAAY,QAAQ;;;;;;;AAQxB,SAAgB,gBAAgB,YAAuD;AACnF,KAAI,WAAW,MAAO,cAAa,WAAW,MAAM;AACpD,YAAW,QAAQ;;;;;;;;;;AAWvB,SAAgB,kBAAmD,cAA6B;CAC5F,IAAI,aAAa;CACjB,IAAI,YAAY;AAChB,mBAAkB;AACd,MAAI,CAAC,aAAa,MAAO;AACzB,eAAa,MAAM,aAAa;AAChC,eAAa,MAAM,YAAY;GACjC;AAEF,0BAAyB;AACrB,eAAa,aAAa,OAAO,cAAc;AAC/C,cAAY,aAAa,OAAO,aAAa;GAC/C"}

package/dist/web.d.ts

@@ -1,3 +1,4 @@
+//#region src/web.d.ts
 /**
  * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.
  *
@@ -5,7 +6,7 @@
  *
  * @returns {string} A new URL with the current location as the `redirect` parameter
  */
-export declare function appendRedirectParamFromCurrentLocationToUrl(url: string): string;
+declare function appendRedirectParamFromCurrentLocationToUrl(url: string): string;
 /**
  * Navigates to the given URL, appending the current browser location
  * (path, query, and hash) as the `redirect` query parameter.
@@ -16,5 +17,7 @@ export declare function appendRedirectParamFromCurrentLocationToUrl(url: string)
  * @param {string} url - The destination URL to navigate to
  * @param {number} [delayMs] - Optional delay in milliseconds before navigation
  */
-export declare function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number): NodeJS.Timeout | undefined;
+declare function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number): NodeJS.Timeout | undefined;
+//#endregion
+export { appendRedirectParamFromCurrentLocationToUrl, assignUrlWithRedirectParamFromCurrentLocation };
 //# sourceMappingURL=web.d.ts.map

package/dist/web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,2CAA2C,CAAC,GAAG,EAAE,MAAM,UAGtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,6CAA6C,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,8BAG1F"}
+{"version":3,"file":"web.d.ts","names":[],"sources":["../src/web.ts"],"sourcesContent":[],"mappings":";;AASA;AAeA;;;;;iBAfgB,2CAAA;;;;;;;;;;;iBAeA,6CAAA,iCAA2E,MAAA,CAAA"}

package/dist/web.js

@@ -0,0 +1,32 @@
+import { appendRedirectParamToUrl } from "./url.js";
+
+//#region src/web.ts
+/**
+* Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.
+*
+* @param {string} url - The base URL to modify
+*
+* @returns {string} A new URL with the current location as the `redirect` parameter
+*/
+function appendRedirectParamFromCurrentLocationToUrl(url) {
+	const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+	return appendRedirectParamToUrl(url, currentPath);
+}
+/**
+* Navigates to the given URL, appending the current browser location
+* (path, query, and hash) as the `redirect` query parameter.
+*
+* Useful for redirecting to login or other gateways while preserving
+* the current location for post-auth navigation.
+*
+* @param {string} url - The destination URL to navigate to
+* @param {number} [delayMs] - Optional delay in milliseconds before navigation
+*/
+function assignUrlWithRedirectParamFromCurrentLocation(url, delayMs) {
+	if (delayMs === void 0) window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));
+	else return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);
+}
+
+//#endregion
+export { appendRedirectParamFromCurrentLocationToUrl, assignUrlWithRedirectParamFromCurrentLocation };
+//# sourceMappingURL=web.js.map

package/dist/web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.js","names":[],"sources":["../src/web.ts"],"sourcesContent":["import { appendRedirectParamToUrl } from '@/url';\n\n/**\n * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.\n *\n * @param {string} url - The base URL to modify\n *\n * @returns {string} A new URL with the current location as the `redirect` parameter\n */\nexport function appendRedirectParamFromCurrentLocationToUrl(url: string) {\n    const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;\n    return appendRedirectParamToUrl(url, currentPath);\n}\n\n/**\n * Navigates to the given URL, appending the current browser location\n * (path, query, and hash) as the `redirect` query parameter.\n *\n * Useful for redirecting to login or other gateways while preserving\n * the current location for post-auth navigation.\n *\n * @param {string} url - The destination URL to navigate to\n * @param {number} [delayMs] - Optional delay in milliseconds before navigation\n */\nexport function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number) {\n    if (delayMs === undefined) window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));\n    else return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,4CAA4C,KAAa;CACrE,MAAM,cAAc,GAAG,OAAO,SAAS,WAAW,OAAO,SAAS,SAAS,OAAO,SAAS;AAC3F,QAAO,yBAAyB,KAAK,YAAY;;;;;;;;;;;;AAarD,SAAgB,8CAA8C,KAAa,SAAkB;AACzF,KAAI,YAAY,OAAW,QAAO,SAAS,OAAO,4CAA4C,IAAI,CAAC;KAC9F,QAAO,iBAAiB,OAAO,SAAS,OAAO,4CAA4C,IAAI,CAAC,EAAE,QAAQ"}