@kikiutils/shared 9.3.1 → 10.1.0

package/README.md

@@ -90,6 +90,10 @@ Console logger integration.
 - `getDateRangeFromDate`
 - `getMidnightDateFromToday`
 
+### [element-plus](./src/element-plus.ts)
+
+- `createElFormItemRuleWithDefaults`
+
 ### [enum](./src/enum.ts)
 
 - `getEnumStringValues`

package/dist/clipboard.cjs

@@ -17,6 +17,8 @@
  *
  * @example
  * ```typescript
+ * import { copyBlobToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const blob = new Blob(['Hello world'], { type: 'text/plain' });
  * const result = await copyBlobToClipboard(blob);
  * if (result.ok) {
@@ -61,6 +63,8 @@ async function copyBlobToClipboard(blob, options) {
  *
  * @example
  * ```typescript
+ * import { copyTextToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const result = await copyTextToClipboard('Hello!');
  * if (result.ok) {
  *     console.log('Copied!');

package/dist/clipboard.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.cjs","sources":["../src/clipboard.ts"],"sourcesContent":["type CopyResult =\n  | { error: unknown; ok: false }\n  | { ok: true };\n\n/**\n * Attempts to copy a Blob (e.g. image, plain text, HTML) to the user's clipboard using the ClipboardItem API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in Safari and some older browsers.\n *\n * @param {Blob} blob - The Blob object to copy (e.g. from a File, image, or text content).\n * @param {ClipboardItemOptions} [options] - Optional options passed to the ClipboardItem constructor.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * const blob = new Blob(['Hello world'], { type: 'text/plain' });\n * const result = await copyBlobToClipboard(blob);\n * if (result.ok) {\n *     console.log('Copied blob!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyBlobToClipboard(blob: Blob, options?: ClipboardItemOptions): Promise<CopyResult> {\n    if (!navigator.clipboard?.write) {\n        return {\n            error: new Error('Clipboard.write is not supported in this browser.'),\n            ok: false,\n        };\n    }\n\n    try {\n        const item = new ClipboardItem({ [blob.type]: blob }, options);\n        await navigator.clipboard.write([item]);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n\n/**\n * Attempts to copy the given text to the user's clipboard using the modern Clipboard API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in some older browsers (especially legacy Safari).\n *\n * @param {string} text - The string to be copied to the clipboard.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * const result = await copyTextToClipboard('Hello!');\n * if (result.ok) {\n *     console.log('Copied!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyTextToClipboard(text: string): Promise<CopyResult> {\n    try {\n        await navigator.clipboard.writeText(text);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n"],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,eAAe,mBAAmB,CAAC,IAAU,EAAE,OAA8B,EAAA;AAChF,IAAA,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE;QAC7B,OAAO;AACH,YAAA,KAAK,EAAE,IAAI,KAAK,CAAC,mDAAmD,CAAC;AACrE,YAAA,EAAE,EAAE,KAAK;SACZ;;AAGL,IAAA,IAAI;AACA,QAAA,MAAM,IAAI,GAAG,IAAI,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,EAAE,OAAO,CAAC;QAC9D,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AACvC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;AAEA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,eAAe,mBAAmB,CAAC,IAAY,EAAA;AAClD,IAAA,IAAI;QACA,MAAM,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC;AACzC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;;;;;"}
+{"version":3,"file":"clipboard.cjs","sources":["../src/clipboard.ts"],"sourcesContent":["type CopyResult =\n  | { error: unknown; ok: false }\n  | { ok: true };\n\n/**\n * Attempts to copy a Blob (e.g. image, plain text, HTML) to the user's clipboard using the ClipboardItem API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in Safari and some older browsers.\n *\n * @param {Blob} blob - The Blob object to copy (e.g. from a File, image, or text content).\n * @param {ClipboardItemOptions} [options] - Optional options passed to the ClipboardItem constructor.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * import { copyBlobToClipboard } from '@kikiutils/shared/clipboard';\n *\n * const blob = new Blob(['Hello world'], { type: 'text/plain' });\n * const result = await copyBlobToClipboard(blob);\n * if (result.ok) {\n *     console.log('Copied blob!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyBlobToClipboard(blob: Blob, options?: ClipboardItemOptions): Promise<CopyResult> {\n    if (!navigator.clipboard?.write) {\n        return {\n            error: new Error('Clipboard.write is not supported in this browser.'),\n            ok: false,\n        };\n    }\n\n    try {\n        const item = new ClipboardItem({ [blob.type]: blob }, options);\n        await navigator.clipboard.write([item]);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n\n/**\n * Attempts to copy the given text to the user's clipboard using the modern Clipboard API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in some older browsers (especially legacy Safari).\n *\n * @param {string} text - The string to be copied to the clipboard.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * import { copyTextToClipboard } from '@kikiutils/shared/clipboard';\n *\n * const result = await copyTextToClipboard('Hello!');\n * if (result.ok) {\n *     console.log('Copied!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyTextToClipboard(text: string): Promise<CopyResult> {\n    try {\n        await navigator.clipboard.writeText(text);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n"],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,eAAe,mBAAmB,CAAC,IAAU,EAAE,OAA8B,EAAA;AAChF,IAAA,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE;QAC7B,OAAO;AACH,YAAA,KAAK,EAAE,IAAI,KAAK,CAAC,mDAAmD,CAAC;AACrE,YAAA,EAAE,EAAE,KAAK;SACZ;;AAGL,IAAA,IAAI;AACA,QAAA,MAAM,IAAI,GAAG,IAAI,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,EAAE,OAAO,CAAC;QAC9D,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AACvC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,eAAe,mBAAmB,CAAC,IAAY,EAAA;AAClD,IAAA,IAAI;QACA,MAAM,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC;AACzC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;;;;;"}

package/dist/clipboard.d.ts

@@ -21,6 +21,8 @@ type CopyResult = {
  *
  * @example
  * ```typescript
+ * import { copyBlobToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const blob = new Blob(['Hello world'], { type: 'text/plain' });
  * const result = await copyBlobToClipboard(blob);
  * if (result.ok) {
@@ -47,6 +49,8 @@ export declare function copyBlobToClipboard(blob: Blob, options?: ClipboardItemO
  *
  * @example
  * ```typescript
+ * import { copyTextToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const result = await copyTextToClipboard('Hello!');
  * if (result.ok) {
  *     console.log('Copied!');

package/dist/clipboard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../src/clipboard.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GACX;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,GAC7B;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,CAkBzG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAU3E"}
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../src/clipboard.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GACX;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,GAC7B;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,CAkBzG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAU3E"}

package/dist/clipboard.mjs

@@ -15,6 +15,8 @@
  *
  * @example
  * ```typescript
+ * import { copyBlobToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const blob = new Blob(['Hello world'], { type: 'text/plain' });
  * const result = await copyBlobToClipboard(blob);
  * if (result.ok) {
@@ -59,6 +61,8 @@ async function copyBlobToClipboard(blob, options) {
  *
  * @example
  * ```typescript
+ * import { copyTextToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const result = await copyTextToClipboard('Hello!');
  * if (result.ok) {
  *     console.log('Copied!');

package/dist/clipboard.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.mjs","sources":["../src/clipboard.ts"],"sourcesContent":["type CopyResult =\n  | { error: unknown; ok: false }\n  | { ok: true };\n\n/**\n * Attempts to copy a Blob (e.g. image, plain text, HTML) to the user's clipboard using the ClipboardItem API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in Safari and some older browsers.\n *\n * @param {Blob} blob - The Blob object to copy (e.g. from a File, image, or text content).\n * @param {ClipboardItemOptions} [options] - Optional options passed to the ClipboardItem constructor.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * const blob = new Blob(['Hello world'], { type: 'text/plain' });\n * const result = await copyBlobToClipboard(blob);\n * if (result.ok) {\n *     console.log('Copied blob!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyBlobToClipboard(blob: Blob, options?: ClipboardItemOptions): Promise<CopyResult> {\n    if (!navigator.clipboard?.write) {\n        return {\n            error: new Error('Clipboard.write is not supported in this browser.'),\n            ok: false,\n        };\n    }\n\n    try {\n        const item = new ClipboardItem({ [blob.type]: blob }, options);\n        await navigator.clipboard.write([item]);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n\n/**\n * Attempts to copy the given text to the user's clipboard using the modern Clipboard API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in some older browsers (especially legacy Safari).\n *\n * @param {string} text - The string to be copied to the clipboard.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * const result = await copyTextToClipboard('Hello!');\n * if (result.ok) {\n *     console.log('Copied!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyTextToClipboard(text: string): Promise<CopyResult> {\n    try {\n        await navigator.clipboard.writeText(text);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,eAAe,mBAAmB,CAAC,IAAU,EAAE,OAA8B,EAAA;AAChF,IAAA,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE;QAC7B,OAAO;AACH,YAAA,KAAK,EAAE,IAAI,KAAK,CAAC,mDAAmD,CAAC;AACrE,YAAA,EAAE,EAAE,KAAK;SACZ;;AAGL,IAAA,IAAI;AACA,QAAA,MAAM,IAAI,GAAG,IAAI,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,EAAE,OAAO,CAAC;QAC9D,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AACvC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;AAEA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,eAAe,mBAAmB,CAAC,IAAY,EAAA;AAClD,IAAA,IAAI;QACA,MAAM,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC;AACzC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;;;;"}
+{"version":3,"file":"clipboard.mjs","sources":["../src/clipboard.ts"],"sourcesContent":["type CopyResult =\n  | { error: unknown; ok: false }\n  | { ok: true };\n\n/**\n * Attempts to copy a Blob (e.g. image, plain text, HTML) to the user's clipboard using the ClipboardItem API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in Safari and some older browsers.\n *\n * @param {Blob} blob - The Blob object to copy (e.g. from a File, image, or text content).\n * @param {ClipboardItemOptions} [options] - Optional options passed to the ClipboardItem constructor.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * import { copyBlobToClipboard } from '@kikiutils/shared/clipboard';\n *\n * const blob = new Blob(['Hello world'], { type: 'text/plain' });\n * const result = await copyBlobToClipboard(blob);\n * if (result.ok) {\n *     console.log('Copied blob!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyBlobToClipboard(blob: Blob, options?: ClipboardItemOptions): Promise<CopyResult> {\n    if (!navigator.clipboard?.write) {\n        return {\n            error: new Error('Clipboard.write is not supported in this browser.'),\n            ok: false,\n        };\n    }\n\n    try {\n        const item = new ClipboardItem({ [blob.type]: blob }, options);\n        await navigator.clipboard.write([item]);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n\n/**\n * Attempts to copy the given text to the user's clipboard using the modern Clipboard API.\n *\n * ⚠️ Usage Notes:\n * - Must be called in a **secure context** (HTTPS or localhost).\n * - Must be called **in response to a user interaction** (e.g. click, input).\n * - Not supported in some older browsers (especially legacy Safari).\n *\n * @param {string} text - The string to be copied to the clipboard.\n *\n * @returns {Promise<CopyResult>} A promise resolving to a `CopyResult`:\n *   - `{ ok: true }` if the copy succeeded\n *   - `{ ok: false, error }` if the copy failed, with the error included\n *\n * @example\n * ```typescript\n * import { copyTextToClipboard } from '@kikiutils/shared/clipboard';\n *\n * const result = await copyTextToClipboard('Hello!');\n * if (result.ok) {\n *     console.log('Copied!');\n * } else {\n *     console.error('Copy failed:', result.error);\n * }\n * ```\n */\nexport async function copyTextToClipboard(text: string): Promise<CopyResult> {\n    try {\n        await navigator.clipboard.writeText(text);\n        return { ok: true };\n    } catch (error) {\n        return {\n            error,\n            ok: false,\n        };\n    }\n}\n"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,eAAe,mBAAmB,CAAC,IAAU,EAAE,OAA8B,EAAA;AAChF,IAAA,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE;QAC7B,OAAO;AACH,YAAA,KAAK,EAAE,IAAI,KAAK,CAAC,mDAAmD,CAAC;AACrE,YAAA,EAAE,EAAE,KAAK;SACZ;;AAGL,IAAA,IAAI;AACA,QAAA,MAAM,IAAI,GAAG,IAAI,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,EAAE,OAAO,CAAC;QAC9D,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AACvC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,eAAe,mBAAmB,CAAC,IAAY,EAAA;AAClD,IAAA,IAAI;QACA,MAAM,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC;AACzC,QAAA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE;;IACrB,OAAO,KAAK,EAAE;QACZ,OAAO;YACH,KAAK;AACL,YAAA,EAAE,EAAE,KAAK;SACZ;;AAET;;;;"}

package/dist/element-plus.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.
+ *
+ * This utility provides default values for `required`, `trigger`, and `type`,
+ * while allowing overrides via the `options` parameter. It simplifies common
+ * form validation rule creation and ensures consistency across forms.
+ *
+ * @param {string} message - The validation message to display when the rule fails.
+ * @param {FormItemRule} [options] - Optional overrides for the rule fields.
+ * @param {boolean} [options.required] - Whether the field is required (default: `true`).
+ * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`).
+ * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`).
+ *
+ * @returns A `FormItemRule` object that can be used in Element Plus form validation.
+ *
+ * @example
+ * ```typescript
+ * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';
+ *
+ * const rule = createElFormItemRuleWithDefaults('This field is required');
+ * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });
+ * ```
+ */
+function createElFormItemRuleWithDefaults(message, options = {}) {
+    return {
+        ...options,
+        message,
+        required: options.required ?? true,
+        trigger: options.trigger ?? 'blur',
+        type: options.type ?? 'string',
+    };
+}
+
+exports.createElFormItemRuleWithDefaults = createElFormItemRuleWithDefaults;
+//# sourceMappingURL=element-plus.cjs.map

package/dist/element-plus.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-plus.cjs","sources":["../src/element-plus.ts"],"sourcesContent":["import type { RuleType } from 'async-validator';\nimport type { FormItemRule } from 'element-plus';\n\nexport type DoNotRemoveOrUseThisType = RuleType;\n\n/**\n * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.\n *\n * This utility provides default values for `required`, `trigger`, and `type`,\n * while allowing overrides via the `options` parameter. It simplifies common\n * form validation rule creation and ensures consistency across forms.\n *\n * @param {string} message - The validation message to display when the rule fails.\n * @param {FormItemRule} [options] - Optional overrides for the rule fields.\n * @param {boolean} [options.required] - Whether the field is required (default: `true`).\n * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`).\n * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`).\n *\n * @returns A `FormItemRule` object that can be used in Element Plus form validation.\n *\n * @example\n * ```typescript\n * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';\n *\n * const rule = createElFormItemRuleWithDefaults('This field is required');\n * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });\n * ```\n */\nexport function createElFormItemRuleWithDefaults(message: string, options: FormItemRule = {}): FormItemRule {\n    return {\n        ...options,\n        message,\n        required: options.required ?? true,\n        trigger: options.trigger ?? 'blur',\n        type: options.type ?? 'string',\n    };\n}\n"],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;;;;;;;;;;AAsBG;SACa,gCAAgC,CAAC,OAAe,EAAE,UAAwB,EAAE,EAAA;IACxF,OAAO;AACH,QAAA,GAAG,OAAO;QACV,OAAO;AACP,QAAA,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI;AAClC,QAAA,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,MAAM;AAClC,QAAA,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,QAAQ;KACjC;AACL;;;;"}

package/dist/element-plus.d.ts

@@ -0,0 +1,28 @@
+import type { RuleType } from 'async-validator';
+import type { FormItemRule } from 'element-plus';
+export type DoNotRemoveOrUseThisType = RuleType;
+/**
+ * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.
+ *
+ * This utility provides default values for `required`, `trigger`, and `type`,
+ * while allowing overrides via the `options` parameter. It simplifies common
+ * form validation rule creation and ensures consistency across forms.
+ *
+ * @param {string} message - The validation message to display when the rule fails.
+ * @param {FormItemRule} [options] - Optional overrides for the rule fields.
+ * @param {boolean} [options.required] - Whether the field is required (default: `true`).
+ * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`).
+ * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`).
+ *
+ * @returns A `FormItemRule` object that can be used in Element Plus form validation.
+ *
+ * @example
+ * ```typescript
+ * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';
+ *
+ * const rule = createElFormItemRuleWithDefaults('This field is required');
+ * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });
+ * ```
+ */
+export declare function createElFormItemRuleWithDefaults(message: string, options?: FormItemRule): FormItemRule;
+//# sourceMappingURL=element-plus.d.ts.map

package/dist/element-plus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-plus.d.ts","sourceRoot":"","sources":["../src/element-plus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,YAAY,CAQ1G"}

package/dist/element-plus.mjs

@@ -0,0 +1,35 @@
+/**
+ * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.
+ *
+ * This utility provides default values for `required`, `trigger`, and `type`,
+ * while allowing overrides via the `options` parameter. It simplifies common
+ * form validation rule creation and ensures consistency across forms.
+ *
+ * @param {string} message - The validation message to display when the rule fails.
+ * @param {FormItemRule} [options] - Optional overrides for the rule fields.
+ * @param {boolean} [options.required] - Whether the field is required (default: `true`).
+ * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`).
+ * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`).
+ *
+ * @returns A `FormItemRule` object that can be used in Element Plus form validation.
+ *
+ * @example
+ * ```typescript
+ * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';
+ *
+ * const rule = createElFormItemRuleWithDefaults('This field is required');
+ * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });
+ * ```
+ */
+function createElFormItemRuleWithDefaults(message, options = {}) {
+    return {
+        ...options,
+        message,
+        required: options.required ?? true,
+        trigger: options.trigger ?? 'blur',
+        type: options.type ?? 'string',
+    };
+}
+
+export { createElFormItemRuleWithDefaults };
+//# sourceMappingURL=element-plus.mjs.map

package/dist/element-plus.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-plus.mjs","sources":["../src/element-plus.ts"],"sourcesContent":["import type { RuleType } from 'async-validator';\nimport type { FormItemRule } from 'element-plus';\n\nexport type DoNotRemoveOrUseThisType = RuleType;\n\n/**\n * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.\n *\n * This utility provides default values for `required`, `trigger`, and `type`,\n * while allowing overrides via the `options` parameter. It simplifies common\n * form validation rule creation and ensures consistency across forms.\n *\n * @param {string} message - The validation message to display when the rule fails.\n * @param {FormItemRule} [options] - Optional overrides for the rule fields.\n * @param {boolean} [options.required] - Whether the field is required (default: `true`).\n * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`).\n * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`).\n *\n * @returns A `FormItemRule` object that can be used in Element Plus form validation.\n *\n * @example\n * ```typescript\n * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';\n *\n * const rule = createElFormItemRuleWithDefaults('This field is required');\n * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });\n * ```\n */\nexport function createElFormItemRuleWithDefaults(message: string, options: FormItemRule = {}): FormItemRule {\n    return {\n        ...options,\n        message,\n        required: options.required ?? true,\n        trigger: options.trigger ?? 'blur',\n        type: options.type ?? 'string',\n    };\n}\n"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;AAsBG;SACa,gCAAgC,CAAC,OAAe,EAAE,UAAwB,EAAE,EAAA;IACxF,OAAO;AACH,QAAA,GAAG,OAAO;QACV,OAAO;AACP,QAAA,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI;AAClC,QAAA,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,MAAM;AAClC,QAAA,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,QAAQ;KACjC;AACL;;;;"}

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

@@ -18,6 +18,8 @@ const toCustomValue = (type, payload) => `${customValueHeader}${type}${payload}`
  *
  * @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');
  * ```

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

@@ -1 +1 @@
-{"version":3,"file":"core.cjs","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 * 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"],"names":["deserialize","serialize"],"mappings":";;;;AAKA,IAAK,wBAGJ;AAHD,CAAA,UAAK,wBAAwB,EAAA;AACzB,IAAA,wBAAA,CAAA,MAAA,CAAA,GAAA,GAAU;AACV,IAAA,wBAAA,CAAA,QAAA,CAAA,GAAA,GAAY;AAChB,CAAC,EAHI,wBAAwB,KAAxB,wBAAwB,GAG5B,EAAA,CAAA,CAAA;AAED,MAAM,iBAAiB,GAAG,IAAI;AAC9B,MAAM,uBAAuB,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC;AAC5D,MAAM,aAAa,GAAG,CAAC,IAA8B,EAAE,OAAe,KAAK,CAAA,EAAG,iBAAiB,CAAG,EAAA,IAAI,CAAG,EAAA,OAAO,EAAE;AAElH;;;;;;;;;;;AAWG;AACU,MAAA,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC;AAC9C;;AAEG;IACH,KAAK,EAAE,MAAM,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE;AACxC;;;;;;;;AAQG;AACH,IAAA,OAAO,CAAc,GAAW,EAAA;QAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC;AACjD,QAAA,OAAO,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAM,GAAG,IAAI;KAC7D;AACD;;;;;;AAMG;AACH,IAAA,OAAO,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI;AACnE;;;;AAIG;AACH,IAAA,IAAI,MAAM,GAAA;AACN,QAAA,OAAO,MAAM,CAAC,YAAY,CAAC,MAAM;KACpC;AACD;;;;AAIG;AACH,IAAA,UAAU,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC;AAChE;;;;;AAKG;IACH,OAAO,EAAE,CAAC,GAAW,EAAE,KAAU,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;AACtG,CAAA;AAED,SAAS,kBAAkB,CAAC,IAAY,EAAA;AACpC,IAAA,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;AAAE,QAAA,OAAO,IAAI;IACtC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;IACvD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC;IAClD,QAAQ,IAAI;QACR,KAAK,wBAAwB,CAAC,IAAI;AAC9B,YAAA,IAAI;gBACA,OAAOA,qBAAW,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;;AACzC,YAAA,MAAM;AACJ,gBAAA,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC;;AAE/E,QAAA,KAAK,wBAAwB,CAAC,MAAM,EAAE,OAAO,OAAO;AACpD,QAAA;AACI,YAAA,MAAM,IAAI,KAAK,CAAC,iDAAiD,IAAI,CAAA,CAAA,CAAG,CAAC;;AAErF;AAEA,SAAS,oBAAoB,CAAC,KAAU,EAAA;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,aAAa,CAAC,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3F,IAAA,OAAO,aAAa,CAAC,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAACC,mBAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACzF;AAEA,SAAS,cAAc,CAAC,IAAY,EAAA;AAChC,IAAA,QACI,IAAI,CAAC,MAAM,IAAI;AACZ,WAAA,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC;WAC/B,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC,CAAC;AAE3C;;;;"}
+{"version":3,"file":"core.cjs","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"],"names":["deserialize","serialize"],"mappings":";;;;AAKA,IAAK,wBAGJ;AAHD,CAAA,UAAK,wBAAwB,EAAA;AACzB,IAAA,wBAAA,CAAA,MAAA,CAAA,GAAA,GAAU;AACV,IAAA,wBAAA,CAAA,QAAA,CAAA,GAAA,GAAY;AAChB,CAAC,EAHI,wBAAwB,KAAxB,wBAAwB,GAG5B,EAAA,CAAA,CAAA;AAED,MAAM,iBAAiB,GAAG,IAAI;AAC9B,MAAM,uBAAuB,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC;AAC5D,MAAM,aAAa,GAAG,CAAC,IAA8B,EAAE,OAAe,KAAK,CAAA,EAAG,iBAAiB,CAAG,EAAA,IAAI,CAAG,EAAA,OAAO,EAAE;AAElH;;;;;;;;;;;;;AAaG;AACU,MAAA,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC;AAC9C;;AAEG;IACH,KAAK,EAAE,MAAM,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE;AACxC;;;;;;;;AAQG;AACH,IAAA,OAAO,CAAc,GAAW,EAAA;QAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC;AACjD,QAAA,OAAO,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAM,GAAG,IAAI;KAC7D;AACD;;;;;;AAMG;AACH,IAAA,OAAO,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI;AACnE;;;;AAIG;AACH,IAAA,IAAI,MAAM,GAAA;AACN,QAAA,OAAO,MAAM,CAAC,YAAY,CAAC,MAAM;KACpC;AACD;;;;AAIG;AACH,IAAA,UAAU,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC;AAChE;;;;;AAKG;IACH,OAAO,EAAE,CAAC,GAAW,EAAE,KAAU,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;AACtG,CAAA;AAED,SAAS,kBAAkB,CAAC,IAAY,EAAA;AACpC,IAAA,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;AAAE,QAAA,OAAO,IAAI;IACtC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;IACvD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC;IAClD,QAAQ,IAAI;QACR,KAAK,wBAAwB,CAAC,IAAI;AAC9B,YAAA,IAAI;gBACA,OAAOA,qBAAW,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;;AACzC,YAAA,MAAM;AACJ,gBAAA,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC;;AAE/E,QAAA,KAAK,wBAAwB,CAAC,MAAM,EAAE,OAAO,OAAO;AACpD,QAAA;AACI,YAAA,MAAM,IAAI,KAAK,CAAC,iDAAiD,IAAI,CAAA,CAAA,CAAG,CAAC;;AAErF;AAEA,SAAS,oBAAoB,CAAC,KAAU,EAAA;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,aAAa,CAAC,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3F,IAAA,OAAO,aAAa,CAAC,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAACC,mBAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACzF;AAEA,SAAS,cAAc,CAAC,IAAY,EAAA;AAChC,IAAA,QACI,IAAI,CAAC,MAAM,IAAI;AACZ,WAAA,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC;WAC/B,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC,CAAC;AAE3C;;;;"}

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

@@ -6,6 +6,8 @@
  *
  * @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');
  * ```

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;;;;;;;;;;;GAWG;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","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"}

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

@@ -16,6 +16,8 @@ const toCustomValue = (type, payload) => `${customValueHeader}${type}${payload}`
  *
  * @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');
  * ```

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

@@ -1 +1 @@
-{"version":3,"file":"core.mjs","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 * 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"],"names":[],"mappings":";;AAKA,IAAK,wBAGJ;AAHD,CAAA,UAAK,wBAAwB,EAAA;AACzB,IAAA,wBAAA,CAAA,MAAA,CAAA,GAAA,GAAU;AACV,IAAA,wBAAA,CAAA,QAAA,CAAA,GAAA,GAAY;AAChB,CAAC,EAHI,wBAAwB,KAAxB,wBAAwB,GAG5B,EAAA,CAAA,CAAA;AAED,MAAM,iBAAiB,GAAG,IAAI;AAC9B,MAAM,uBAAuB,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC;AAC5D,MAAM,aAAa,GAAG,CAAC,IAA8B,EAAE,OAAe,KAAK,CAAA,EAAG,iBAAiB,CAAG,EAAA,IAAI,CAAG,EAAA,OAAO,EAAE;AAElH;;;;;;;;;;;AAWG;AACU,MAAA,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC;AAC9C;;AAEG;IACH,KAAK,EAAE,MAAM,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE;AACxC;;;;;;;;AAQG;AACH,IAAA,OAAO,CAAc,GAAW,EAAA;QAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC;AACjD,QAAA,OAAO,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAM,GAAG,IAAI;KAC7D;AACD;;;;;;AAMG;AACH,IAAA,OAAO,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI;AACnE;;;;AAIG;AACH,IAAA,IAAI,MAAM,GAAA;AACN,QAAA,OAAO,MAAM,CAAC,YAAY,CAAC,MAAM;KACpC;AACD;;;;AAIG;AACH,IAAA,UAAU,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC;AAChE;;;;;AAKG;IACH,OAAO,EAAE,CAAC,GAAW,EAAE,KAAU,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;AACtG,CAAA;AAED,SAAS,kBAAkB,CAAC,IAAY,EAAA;AACpC,IAAA,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;AAAE,QAAA,OAAO,IAAI;IACtC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;IACvD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC;IAClD,QAAQ,IAAI;QACR,KAAK,wBAAwB,CAAC,IAAI;AAC9B,YAAA,IAAI;gBACA,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;;AACzC,YAAA,MAAM;AACJ,gBAAA,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC;;AAE/E,QAAA,KAAK,wBAAwB,CAAC,MAAM,EAAE,OAAO,OAAO;AACpD,QAAA;AACI,YAAA,MAAM,IAAI,KAAK,CAAC,iDAAiD,IAAI,CAAA,CAAA,CAAG,CAAC;;AAErF;AAEA,SAAS,oBAAoB,CAAC,KAAU,EAAA;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,aAAa,CAAC,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3F,IAAA,OAAO,aAAa,CAAC,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACzF;AAEA,SAAS,cAAc,CAAC,IAAY,EAAA;AAChC,IAAA,QACI,IAAI,CAAC,MAAM,IAAI;AACZ,WAAA,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC;WAC/B,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC,CAAC;AAE3C;;;;"}
+{"version":3,"file":"core.mjs","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"],"names":[],"mappings":";;AAKA,IAAK,wBAGJ;AAHD,CAAA,UAAK,wBAAwB,EAAA;AACzB,IAAA,wBAAA,CAAA,MAAA,CAAA,GAAA,GAAU;AACV,IAAA,wBAAA,CAAA,QAAA,CAAA,GAAA,GAAY;AAChB,CAAC,EAHI,wBAAwB,KAAxB,wBAAwB,GAG5B,EAAA,CAAA,CAAA;AAED,MAAM,iBAAiB,GAAG,IAAI;AAC9B,MAAM,uBAAuB,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC;AAC5D,MAAM,aAAa,GAAG,CAAC,IAA8B,EAAE,OAAe,KAAK,CAAA,EAAG,iBAAiB,CAAG,EAAA,IAAI,CAAG,EAAA,OAAO,EAAE;AAElH;;;;;;;;;;;;;AAaG;AACU,MAAA,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC;AAC9C;;AAEG;IACH,KAAK,EAAE,MAAM,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE;AACxC;;;;;;;;AAQG;AACH,IAAA,OAAO,CAAc,GAAW,EAAA;QAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC;AACjD,QAAA,OAAO,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAM,GAAG,IAAI;KAC7D;AACD;;;;;;AAMG;AACH,IAAA,OAAO,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI;AACnE;;;;AAIG;AACH,IAAA,IAAI,MAAM,GAAA;AACN,QAAA,OAAO,MAAM,CAAC,YAAY,CAAC,MAAM;KACpC;AACD;;;;AAIG;AACH,IAAA,UAAU,EAAE,CAAC,GAAW,KAAK,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC;AAChE;;;;;AAKG;IACH,OAAO,EAAE,CAAC,GAAW,EAAE,KAAU,KAAK,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;AACtG,CAAA;AAED,SAAS,kBAAkB,CAAC,IAAY,EAAA;AACpC,IAAA,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;AAAE,QAAA,OAAO,IAAI;IACtC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;IACvD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC;IAClD,QAAQ,IAAI;QACR,KAAK,wBAAwB,CAAC,IAAI;AAC9B,YAAA,IAAI;gBACA,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;;AACzC,YAAA,MAAM;AACJ,gBAAA,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC;;AAE/E,QAAA,KAAK,wBAAwB,CAAC,MAAM,EAAE,OAAO,OAAO;AACpD,QAAA;AACI,YAAA,MAAM,IAAI,KAAK,CAAC,iDAAiD,IAAI,CAAA,CAAA,CAAG,CAAC;;AAErF;AAEA,SAAS,oBAAoB,CAAC,KAAU,EAAA;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,aAAa,CAAC,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3F,IAAA,OAAO,aAAa,CAAC,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACzF;AAEA,SAAS,cAAc,CAAC,IAAY,EAAA;AAChC,IAAA,QACI,IAAI,CAAC,MAAM,IAAI;AACZ,WAAA,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC;WAC/B,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC,CAAC;AAE3C;;;;"}

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

@@ -15,6 +15,8 @@ const core = require('./core.cjs');
  *
  * @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);

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.cjs","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 * 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"],"names":["enhancedLocalStorage"],"mappings":";;;;AAEA;;;;;;;;;;;;;;;;;AAiBG;SACa,6BAA6B,GAAA;IACzC,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAKA,yBAAoB,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAKA,yBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9E,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAKA,yBAAoB,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpF;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAKA,yBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClG,KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"keyed-store.cjs","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"],"names":["enhancedLocalStorage"],"mappings":";;;;AAEA;;;;;;;;;;;;;;;;;;;AAmBG;SACa,6BAA6B,GAAA;IACzC,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAKA,yBAAoB,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAKA,yBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9E,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAKA,yBAAoB,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpF;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAKA,yBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClG,KAAA,CAAC;AACN;;;;"}

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

@@ -11,6 +11,8 @@
  *
  * @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);

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;;;;;;;;;;;;;;;;;GAiBG;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","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"}

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

@@ -13,6 +13,8 @@ import { enhancedLocalStorage } from './core.mjs';
  *
  * @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);

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.mjs","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 * 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"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;AAiBG;SACa,6BAA6B,GAAA;IACzC,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9E,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpF;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClG,KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"keyed-store.mjs","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"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;AAmBG;SACa,6BAA6B,GAAA;IACzC,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9E,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpF;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClG,KAAA,CAAC;AACN;;;;"}

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

@@ -24,6 +24,8 @@ const customValueHeaderLength = customValueHeader.byteLength + 1;
  *
  * @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');

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

@@ -1 +1 @@
-{"version":3,"file":"core.cjs","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 * 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"],"names":["Buffer","Redis","deserialize","serialize"],"mappings":"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"}
+{"version":3,"file":"core.cjs","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"],"names":["Buffer","Redis","deserialize","serialize"],"mappings":"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"}

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

@@ -11,6 +11,8 @@ import { Redis } from 'ioredis';
  *
  * @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');

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;;;;;;;;;;;;;;;;GAgBG;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","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"}

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

@@ -22,6 +22,8 @@ const customValueHeaderLength = customValueHeader.byteLength + 1;
  *
  * @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');

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

@@ -1 +1 @@
-{"version":3,"file":"core.mjs","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 * 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"],"names":[],"mappings":"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"}
+{"version":3,"file":"core.mjs","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"],"names":[],"mappings":"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"}

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

@@ -16,6 +16,8 @@
  *
  * @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);

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.cjs","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 * 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"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,6BAA6B,CAAc,OAAsD,EAAA;IAC7G,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClF,QAAA,cAAc,CAAC,OAAe,EAAE,KAAQ,EAAE,GAAG,IAAO,EAAA;AAChD,YAAA,OAAO,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC;SACzE;AACJ,KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"keyed-store.cjs","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"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,6BAA6B,CAAc,OAAsD,EAAA;IAC7G,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClF,QAAA,cAAc,CAAC,OAAe,EAAE,KAAQ,EAAE,GAAG,IAAO,EAAA;AAChD,YAAA,OAAO,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC;SACzE;AACJ,KAAA,CAAC;AACN;;;;"}

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

@@ -15,6 +15,8 @@ import type { createEnhancedRedisStorage } from './core';
  *
  * @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);

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;;;;;;;;;;;;;;;;;;;;GAoBG;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","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"}

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

@@ -14,6 +14,8 @@
  *
  * @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);

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.mjs","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 * 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"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,6BAA6B,CAAc,OAAsD,EAAA;IAC7G,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClF,QAAA,cAAc,CAAC,OAAe,EAAE,KAAQ,EAAE,GAAG,IAAO,EAAA;AAChD,YAAA,OAAO,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC;SACzE;AACJ,KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"keyed-store.mjs","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"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,6BAA6B,CAAc,OAAsD,EAAA;IAC7G,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClF,QAAA,cAAc,CAAC,OAAe,EAAE,KAAQ,EAAE,GAAG,IAAO,EAAA;AAChD,YAAA,OAAO,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC;SACzE;AACJ,KAAA,CAAC;AACN;;;;"}

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

@@ -6,23 +6,21 @@
  * 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`).
- * @template K - The type of keys used in the LRU cache (default: string).
- * @template V - The type of values stored in the LRU cache.
- * @template FC - The value used by `lru-cache` fetch context (if any).
  *
- * @param {LRUCache<K, V, FC>} lruInstance - An instance of `lru-cache`.
+ * @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
- * const lruCache = new LRUCache<string, { id: number }>();
+ * 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);
  * ```
  */
-// eslint-disable-next-line ts/no-empty-object-type
 function createKeyedLruStore(lruInstance) {
     return (getKeyFunction) => Object.freeze({
         /**
@@ -41,7 +39,9 @@ function createKeyedLruStore(lruInstance) {
          * Resolves the full cache key from the given arguments.
          */
         resolveKey: (...args) => getKeyFunction(...args),
-        setItem: (value, ...args) => lruInstance.set(getKeyFunction(...args), value),
+        setItem(value, ...args) {
+            lruInstance.set(getKeyFunction(...args), value);
+        },
     });
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.cjs","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 * @template K - The type of keys used in the LRU cache (default: string).\n * @template V - The type of values stored in the LRU cache.\n * @template FC - The value used by `lru-cache` fetch context (if any).\n *\n * @param {LRUCache<K, V, FC>} 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 * const lruCache = new LRUCache<string, { id: number }>();\n * const userStore = createKeyedLruStore<User>(lruCache)((id: number) => `user:${id}`);\n * userStore.setItem({ id: 1 }, 1);\n * const user = userStore.getItem(1);\n * ```\n */\n// eslint-disable-next-line ts/no-empty-object-type\nexport function createKeyedLruStore<D extends V, K extends {}, V extends {}, FC = unknown>(\n    lruInstance: LRUCache<K, V, FC>,\n) {\n    return <P extends any[]>(getKeyFunction: (...args: P) => K) => 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 ?? 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) => lruInstance.set(getKeyFunction(...args), value),\n    });\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH;AACM,SAAU,mBAAmB,CAC/B,WAA+B,EAAA;IAE/B,OAAO,CAAkB,cAAiC,KAAK,MAAM,CAAC,MAAM,CAAC;AACzE;;;;AAIG;QACH,OAAO,CAAC,GAAG,IAAO,EAAA;AACd,YAAA,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;YACzD,OAAO,QAAQ,IAAI,IAAI;SAC1B;AACD,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAChF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;AAEG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AACrF,KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"keyed-store.cjs","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"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,mBAAmB,CAAc,WAAoC,EAAA;IACjF,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E;;;;AAIG;QACH,OAAO,CAAC,GAAG,IAAO,EAAA;AACd,YAAA,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;YACzD,OAAO,QAAa,IAAI,IAAI;SAC/B;AACD,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAChF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;AAEG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;AACnD,QAAA,OAAO,CAAC,KAAQ,EAAE,GAAG,IAAO,EAAA;YACxB,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;SAClD;AACJ,KAAA,CAAC;AACN;;;;"}

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

@@ -5,36 +5,35 @@ import type { LRUCache } from 'lru-cache';
  * 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`).
- * @template K - The type of keys used in the LRU cache (default: string).
- * @template V - The type of values stored in the LRU cache.
- * @template FC - The value used by `lru-cache` fetch context (if any).
  *
- * @param {LRUCache<K, V, FC>} lruInstance - An instance of `lru-cache`.
+ * @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
- * const lruCache = new LRUCache<string, { id: number }>();
+ * 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);
  * ```
  */
-export declare function createKeyedLruStore<D extends V, K extends {}, V extends {}, FC = unknown>(lruInstance: LRUCache<K, V, FC>): <P extends any[]>(getKeyFunction: (...args: P) => K) => Readonly<{
+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): V | 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) => K;
-    setItem: (value: D, ...args: P) => LRUCache<K, V, FC>;
+    resolveKey: (...args: P) => string;
+    setItem(value: D, ...args: P): void;
 }>;
 //# 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;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,EAAE,EAAE,GAAG,OAAO,EACrF,WAAW,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAEvB,CAAC,SAAS,GAAG,EAAE,EAAE,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC;IACtD;;;;OAIG;qBACc,CAAC;0BAII,CAAC;uBACJ,CAAC;0BACE,CAAC;IACvB;;OAEG;0BACmB,CAAC;qBACN,CAAC,WAAW,CAAC;GAErC"}
+{"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"}

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

@@ -4,23 +4,21 @@
  * 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`).
- * @template K - The type of keys used in the LRU cache (default: string).
- * @template V - The type of values stored in the LRU cache.
- * @template FC - The value used by `lru-cache` fetch context (if any).
  *
- * @param {LRUCache<K, V, FC>} lruInstance - An instance of `lru-cache`.
+ * @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
- * const lruCache = new LRUCache<string, { id: number }>();
+ * 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);
  * ```
  */
-// eslint-disable-next-line ts/no-empty-object-type
 function createKeyedLruStore(lruInstance) {
     return (getKeyFunction) => Object.freeze({
         /**
@@ -39,7 +37,9 @@ function createKeyedLruStore(lruInstance) {
          * Resolves the full cache key from the given arguments.
          */
         resolveKey: (...args) => getKeyFunction(...args),
-        setItem: (value, ...args) => lruInstance.set(getKeyFunction(...args), value),
+        setItem(value, ...args) {
+            lruInstance.set(getKeyFunction(...args), value);
+        },
     });
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.mjs","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 * @template K - The type of keys used in the LRU cache (default: string).\n * @template V - The type of values stored in the LRU cache.\n * @template FC - The value used by `lru-cache` fetch context (if any).\n *\n * @param {LRUCache<K, V, FC>} 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 * const lruCache = new LRUCache<string, { id: number }>();\n * const userStore = createKeyedLruStore<User>(lruCache)((id: number) => `user:${id}`);\n * userStore.setItem({ id: 1 }, 1);\n * const user = userStore.getItem(1);\n * ```\n */\n// eslint-disable-next-line ts/no-empty-object-type\nexport function createKeyedLruStore<D extends V, K extends {}, V extends {}, FC = unknown>(\n    lruInstance: LRUCache<K, V, FC>,\n) {\n    return <P extends any[]>(getKeyFunction: (...args: P) => K) => 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 ?? 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) => lruInstance.set(getKeyFunction(...args), value),\n    });\n}\n"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH;AACM,SAAU,mBAAmB,CAC/B,WAA+B,EAAA;IAE/B,OAAO,CAAkB,cAAiC,KAAK,MAAM,CAAC,MAAM,CAAC;AACzE;;;;AAIG;QACH,OAAO,CAAC,GAAG,IAAO,EAAA;AACd,YAAA,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;YACzD,OAAO,QAAQ,IAAI,IAAI;SAC1B;AACD,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAChF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;AAEG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AACrF,KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"keyed-store.mjs","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"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,mBAAmB,CAAc,WAAoC,EAAA;IACjF,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E;;;;AAIG;QACH,OAAO,CAAC,GAAG,IAAO,EAAA;AACd,YAAA,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;YACzD,OAAO,QAAa,IAAI,IAAI;SAC/B;AACD,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAChF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;AAEG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;AACnD,QAAA,OAAO,CAAC,KAAQ,EAAE,GAAG,IAAO,EAAA;YACxB,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;SAClD;AACJ,KAAA,CAAC;AACN;;;;"}

package/dist/web.cjs

@@ -13,6 +13,23 @@ function appendRedirectParamFromCurrentLocationToUrl(url$1) {
     const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;
     return url.appendRedirectParamToUrl(url$1, 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 === undefined)
+        window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));
+    else
+        return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);
+}
 
 exports.appendRedirectParamFromCurrentLocationToUrl = appendRedirectParamFromCurrentLocationToUrl;
+exports.assignUrlWithRedirectParamFromCurrentLocation = assignUrlWithRedirectParamFromCurrentLocation;
 //# sourceMappingURL=web.cjs.map

package/dist/web.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"web.cjs","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"],"names":["url","appendRedirectParamToUrl"],"mappings":";;;;AAEA;;;;;;AAMG;AACG,SAAU,2CAA2C,CAACA,KAAW,EAAA;IACnE,MAAM,WAAW,GAAG,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE;AACjG,IAAA,OAAOC,4BAAwB,CAACD,KAAG,EAAE,WAAW,CAAC;AACrD;;;;"}
+{"version":3,"file":"web.cjs","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"],"names":["url","appendRedirectParamToUrl"],"mappings":";;;;AAEA;;;;;;AAMG;AACG,SAAU,2CAA2C,CAACA,KAAW,EAAA;IACnE,MAAM,WAAW,GAAG,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE;AACjG,IAAA,OAAOC,4BAAwB,CAACD,KAAG,EAAE,WAAW,CAAC;AACrD;AAEA;;;;;;;;;AASG;AACa,SAAA,6CAA6C,CAAC,GAAW,EAAE,OAAgB,EAAA;IACvF,IAAI,OAAO,KAAK,SAAS;QAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,2CAA2C,CAAC,GAAG,CAAC,CAAC;;AAC9F,QAAA,OAAO,UAAU,CAAC,MAAM,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,2CAA2C,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC;AACnH;;;;;"}

package/dist/web.d.ts

@@ -6,4 +6,15 @@
  * @returns {string} A new URL with the current location as the `redirect` parameter.
  */
 export 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.
+ *
+ * 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.
+ */
+export declare function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number): NodeJS.Timeout | undefined;
 //# 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"}
+{"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"}

package/dist/web.mjs

@@ -11,6 +11,22 @@ 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 === undefined)
+        window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));
+    else
+        return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);
+}
 
-export { appendRedirectParamFromCurrentLocationToUrl };
+export { appendRedirectParamFromCurrentLocationToUrl, assignUrlWithRedirectParamFromCurrentLocation };
 //# sourceMappingURL=web.mjs.map

package/dist/web.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"web.mjs","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"],"names":[],"mappings":";;AAEA;;;;;;AAMG;AACG,SAAU,2CAA2C,CAAC,GAAW,EAAA;IACnE,MAAM,WAAW,GAAG,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE;AACjG,IAAA,OAAO,wBAAwB,CAAC,GAAG,EAAE,WAAW,CAAC;AACrD;;;;"}
+{"version":3,"file":"web.mjs","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"],"names":[],"mappings":";;AAEA;;;;;;AAMG;AACG,SAAU,2CAA2C,CAAC,GAAW,EAAA;IACnE,MAAM,WAAW,GAAG,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAG,EAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE;AACjG,IAAA,OAAO,wBAAwB,CAAC,GAAG,EAAE,WAAW,CAAC;AACrD;AAEA;;;;;;;;;AASG;AACa,SAAA,6CAA6C,CAAC,GAAW,EAAE,OAAgB,EAAA;IACvF,IAAI,OAAO,KAAK,SAAS;QAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,2CAA2C,CAAC,GAAG,CAAC,CAAC;;AAC9F,QAAA,OAAO,UAAU,CAAC,MAAM,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,2CAA2C,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC;AACnH;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kikiutils/shared",
-  "version": "9.3.1",
+  "version": "10.1.0",
   "description": "A lightweight and modular utility library for modern JavaScript and TypeScript — includes secure hashing, flexible logging, datetime tools, Vue/web helpers, storage abstraction, and more.",
   "author": "kiki-kanri",
   "license": "MIT",
@@ -71,11 +71,13 @@
     "@kikiutils/tsconfigs": "^5.0.1",
     "@noble/hashes": "^1.8.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.15.14",
+    "@types/node": "^22.15.16",
+    "async-validator": "^4.2.5",
     "consola": "^3.4.2",
     "cross-env": "^7.0.3",
     "date-fns": "^4.1.0",
     "decimal.js": "^10.5.0",
+    "element-plus": "^2.9.9",
     "ioredis": "^5.6.1",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
@@ -93,7 +95,8 @@
   "pnpm": {
     "onlyBuiltDependencies": [
       "esbuild",
-      "unrs-resolver"
+      "unrs-resolver",
+      "vue-demi"
     ]
   }
 }

package/src/clipboard.ts

@@ -19,6 +19,8 @@ type CopyResult =
  *
  * @example
  * ```typescript
+ * import { copyBlobToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const blob = new Blob(['Hello world'], { type: 'text/plain' });
  * const result = await copyBlobToClipboard(blob);
  * if (result.ok) {
@@ -64,6 +66,8 @@ export async function copyBlobToClipboard(blob: Blob, options?: ClipboardItemOpt
  *
  * @example
  * ```typescript
+ * import { copyTextToClipboard } from '@kikiutils/shared/clipboard';
+ *
  * const result = await copyTextToClipboard('Hello!');
  * if (result.ok) {
  *     console.log('Copied!');

package/src/element-plus.ts

@@ -0,0 +1,37 @@
+import type { RuleType } from 'async-validator';
+import type { FormItemRule } from 'element-plus';
+
+export type DoNotRemoveOrUseThisType = RuleType;
+
+/**
+ * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.
+ *
+ * This utility provides default values for `required`, `trigger`, and `type`,
+ * while allowing overrides via the `options` parameter. It simplifies common
+ * form validation rule creation and ensures consistency across forms.
+ *
+ * @param {string} message - The validation message to display when the rule fails.
+ * @param {FormItemRule} [options] - Optional overrides for the rule fields.
+ * @param {boolean} [options.required] - Whether the field is required (default: `true`).
+ * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`).
+ * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`).
+ *
+ * @returns A `FormItemRule` object that can be used in Element Plus form validation.
+ *
+ * @example
+ * ```typescript
+ * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';
+ *
+ * const rule = createElFormItemRuleWithDefaults('This field is required');
+ * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });
+ * ```
+ */
+export function createElFormItemRuleWithDefaults(message: string, options: FormItemRule = {}): FormItemRule {
+    return {
+        ...options,
+        message,
+        required: options.required ?? true,
+        trigger: options.trigger ?? 'blur',
+        type: options.type ?? 'string',
+    };
+}

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

@@ -20,6 +20,8 @@ const toCustomValue = (type: StorageValueEncodingType, payload: string) => `${cu
  *
  * @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');
  * ```

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

@@ -13,6 +13,8 @@ import { enhancedLocalStorage } from './core';
  *
  * @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);

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

@@ -32,6 +32,8 @@ const customValueHeaderLength = customValueHeader.byteLength + 1;
  *
  * @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');

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

@@ -16,6 +16,8 @@ import type { createEnhancedRedisStorage } from './core';
  *
  * @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);

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

@@ -6,27 +6,23 @@ import type { LRUCache } from 'lru-cache';
  * 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`).
- * @template K - The type of keys used in the LRU cache (default: string).
- * @template V - The type of values stored in the LRU cache.
- * @template FC - The value used by `lru-cache` fetch context (if any).
  *
- * @param {LRUCache<K, V, FC>} lruInstance - An instance of `lru-cache`.
+ * @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
- * const lruCache = new LRUCache<string, { id: number }>();
+ * 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);
  * ```
  */
-// eslint-disable-next-line ts/no-empty-object-type
-export function createKeyedLruStore<D extends V, K extends {}, V extends {}, FC = unknown>(
-    lruInstance: LRUCache<K, V, FC>,
-) {
-    return <P extends any[]>(getKeyFunction: (...args: P) => K) => Object.freeze({
+export function createKeyedLruStore<D = unknown>(lruInstance: LRUCache<any, any, any>) {
+    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({
         /**
          * Return a value from the cache. Will update the recency of the cache entry found.
          *
@@ -34,7 +30,7 @@ export function createKeyedLruStore<D extends V, K extends {}, V extends {}, FC
          */
         getItem(...args: P) {
             const rawValue = lruInstance.get(getKeyFunction(...args));
-            return rawValue ?? null;
+            return rawValue as D ?? null;
         },
         getItemTtl: (...args: P) => lruInstance.getRemainingTTL(getKeyFunction(...args)),
         hasItem: (...args: P) => lruInstance.has(getKeyFunction(...args)),
@@ -43,6 +39,8 @@ export function createKeyedLruStore<D extends V, K extends {}, V extends {}, FC
          * Resolves the full cache key from the given arguments.
          */
         resolveKey: (...args: P) => getKeyFunction(...args),
-        setItem: (value: D, ...args: P) => lruInstance.set(getKeyFunction(...args), value),
+        setItem(value: D, ...args: P) {
+            lruInstance.set(getKeyFunction(...args), value);
+        },
     });
 }

package/src/web.ts

@@ -11,3 +11,18 @@ export function appendRedirectParamFromCurrentLocationToUrl(url: string) {
     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.
+ */
+export function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number) {
+    if (delayMs === undefined) window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));
+    else return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);
+}