@kikiutils/shared 10.3.0 → 10.4.0

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

@@ -34,11 +34,11 @@ export const enhancedLocalStorage = Object.freeze({
     /**
      * Retrieves a value by key and decodes it using SuperJSON or raw string.
      *
-     * @template T - The expected type of the value.
+     * @template T - The expected type of the value
      *
-     * @param {string} key - The key of the value to retrieve.
+     * @param {string} key - The key of the value to retrieve
      *
-     * @returns {null | T} The decoded value or null if not found.
+     * @returns {null | T} The decoded value or null if not found
      */
     getItem<T = unknown>(key: string) {
         const rawValue = window.localStorage.getItem(key);
@@ -47,15 +47,15 @@ export const enhancedLocalStorage = Object.freeze({
     /**
      * Checks whether a key exists in localStorage.
      *
-     * @param {string} key - The key to check.
+     * @param {string} key - The key to check
      *
-     * @returns {boolean} True if the key exists, false otherwise.
+     * @returns {boolean} True if the key exists, false otherwise
      */
     hasItem: (key: string) => window.localStorage.getItem(key) !== null,
     /**
      * Returns the number of items stored in localStorage.
      *
-     * @returns {number} The number of items stored in localStorage.
+     * @returns {number} The number of items stored in localStorage
      */
     get length() {
         return window.localStorage.length;
@@ -63,14 +63,14 @@ export const enhancedLocalStorage = Object.freeze({
     /**
      * Removes a specific key from localStorage.
      *
-     * @param {string} key - The key to remove.
+     * @param {string} key - The key to remove
      */
     removeItem: (key: string) => window.localStorage.removeItem(key),
     /**
      * Stores a value in localStorage with automatic serialization.
      *
-     * @param {string} key - The key to store the value under.
-     * @param {any} value - The value to store.
+     * @param {string} key - The key to store the value under
+     * @param {any} value - The value to store
      */
     setItem: (key: string, value: any) => window.localStorage.setItem(key, encodeToStorageValue(value)),
 });
@@ -84,11 +84,11 @@ function decodeStorageValue(data: string) {
             try {
                 return deserialize(JSON.parse(payload));
             } catch {
-                throw new Error('[EnhancedLocalStorage] Failed to parse JSON payload.');
+                throw new Error('[EnhancedLocalStorage] Failed to parse JSON payload');
             }
         case StorageValueEncodingType.String: return payload;
         default:
-            throw new Error(`[EnhancedLocalStorage] Unknown encoding type: ${type}.`);
+            throw new Error(`[EnhancedLocalStorage] Unknown encoding type: ${type}`);
     }
 }
 

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

@@ -7,9 +7,9 @@ import { enhancedLocalStorage } from './core';
  * This utility allows you to abstract away key construction logic and work directly
  * with scoped key-value operations like `getItem`, `setItem`, and `removeItem`.
  *
- * @template D - The value type to store.
+ * @template D - The value type to store
  *
- * @returns A factory that accepts a key generator function and returns a scoped storage interface.
+ * @returns A factory that accepts a key generator function and returns a scoped storage interface
  *
  * @example
  * ```typescript
@@ -28,7 +28,7 @@ export function createKeyedEnhancedLocalStore<D = unknown>() {
         /**
          * Resolves the storage key from the given arguments.
          *
-         * @returns {string} The final string key used internally.
+         * @returns {string} The final string key used internally
          */
         resolveKey: (...args: P) => getKeyFunction(...args),
         setItem: (value: D, ...args: P) => enhancedLocalStorage.setItem(getKeyFunction(...args), value),

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

@@ -26,9 +26,9 @@ const customValueHeaderLength = customValueHeader.byteLength + 1;
  * This utility provides a typed, serializable key-value store backed by Redis,
  * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).
  *
- * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string.
+ * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string
  *
- * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding.
+ * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding
  *
  * @example
  * ```typescript
@@ -45,11 +45,11 @@ export function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string)
         /**
          * Retrieves a value from Redis and decodes it.
          *
-         * @template T - The expected return type.
+         * @template T - The expected return type
          *
-         * @param {string} key - The Redis key.
+         * @param {string} key - The Redis key
          *
-         * @returns {Promise<null | T>} The decoded value or null if not found.
+         * @returns {Promise<null | T>} The decoded value or null if not found
          */
         async getItem<T = unknown>(key: string) {
             const rawValue = await instance.getBuffer(key);
@@ -58,24 +58,24 @@ export function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string)
         /**
          * Gets the remaining TTL (in seconds) for a given key.
          *
-         * @param {string} key - The Redis key.
+         * @param {string} key - The Redis key
          *
-         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set.
+         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set
          */
         getItemTtl: (key: string) => instance.ttl(key),
         /**
          * Checks whether a key exists in Redis.
          *
-         * @param {string} key - The Redis key.
+         * @param {string} key - The Redis key
          *
-         * @returns {Promise<boolean>} True if the key exists, false otherwise.
+         * @returns {Promise<boolean>} True if the key exists, false otherwise
          */
         hasItem: async (key: string) => await instance.exists(key) === 1,
         /**
          * The underlying Redis instance, exposed for advanced operations.
          * Use with caution; most use cases should rely on the wrapper methods.
          *
-         * @returns {Redis} The underlying Redis instance.
+         * @returns {Redis} The underlying Redis instance
          */
         get instance() {
             return instance;
@@ -83,7 +83,7 @@ export function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string)
         /**
          * Removes a key from Redis.
          *
-         * @param {string} key - The Redis key to delete.
+         * @param {string} key - The Redis key to delete
          *
          * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,
          * or `false` if it did not exist.
@@ -92,16 +92,16 @@ export function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string)
         /**
          * Stores a value in Redis without expiration.
          *
-         * @param {string} key - The Redis key.
-         * @param {any} value - The value to store. Will be serialized.
+         * @param {string} key - The Redis key
+         * @param {any} value - The value to store. Will be serialized
          */
         setItem: (key: string, value: any) => instance.set(key, encodeToStorageValue(value)),
         /**
          * Stores a value in Redis with a time-to-live (TTL).
          *
-         * @param {string} key - The Redis key.
-         * @param {number} seconds - Expiration time in seconds.
-         * @param {any} value - The value to store. Will be serialized.
+         * @param {string} key - The Redis key
+         * @param {number} seconds - Expiration time in seconds
+         * @param {any} value - The value to store. Will be serialized
          */
         setItemWithTtl(key: string, seconds: number, value: any) {
             return instance.setex(key, seconds, encodeToStorageValue(value));
@@ -119,11 +119,11 @@ function decodeStorageValue(data: Buffer) {
             try {
                 return deserialize(JSON.parse(payload.toString()));
             } catch {
-                throw new Error('[RedisStorage] Failed to parse JSON payload.');
+                throw new Error('[RedisStorage] Failed to parse JSON payload');
             }
         case StorageValueEncodingType.String: return payload.toString();
         default:
-            throw new Error(`[RedisStorage] Unknown encoding type: ${type}.`);
+            throw new Error(`[RedisStorage] Unknown encoding type: ${type}`);
     }
 }
 

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

@@ -8,11 +8,11 @@ import type { createEnhancedRedisStorage } from './core';
  * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.
  * It is ideal for namespaced data, caching, and session handling.
  *
- * @template D - The value type to store.
+ * @template D - The value type to store
  *
- * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance.
+ * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance
  *
- * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface.
+ * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface
  *
  * @example
  * ```typescript
@@ -32,7 +32,7 @@ export function createKeyedEnhancedRedisStore<D = unknown>(storage: ReturnType<t
         /**
          * Resolves the storage key from the given arguments.
          *
-         * @returns {string} The final string key used internally.
+         * @returns {string} The final string key used internally
          */
         resolveKey: (...args: P) => getKeyFunction(...args),
         setItem: (value: D, ...args: P) => storage.setItem(getKeyFunction(...args), value),

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

@@ -5,11 +5,11 @@ 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 D - The specific value type exposed by this store (must extend `V`)
  *
- * @param {LRUCache<any, any, any>} 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.
+ * @returns A factory that accepts a key generator and returns a scoped, type-safe LRU-based store
  *
  * @example
  * ```typescript

package/src/string.ts

@@ -23,12 +23,12 @@ const CHARSETS: Record<RandomStringMode, string> = {
 /**
  * Generates a random string of a given length using a specified character set.
  *
- * @param {number} length - The length of the string to generate. Must be a positive integer.
- * @param {RandomStringMode} [mode] - The character set to use.
+ * @param {number} length - The length of the string to generate. Must be a positive integer
+ * @param {RandomStringMode} [mode] - The character set to use
  *
- * @returns {string} The generated random string.
+ * @returns {string} The generated random string
  *
- * @throws {Error} If the length is not a positive integer or the mode is unsupported.
+ * @throws {Error} If the length is not a positive integer or the mode is unsupported
  *
  * @example
  * ```typescript
@@ -41,7 +41,7 @@ const CHARSETS: Record<RandomStringMode, string> = {
  */
 export function randomString(length: number, mode: RandomStringMode = 'alphabetic') {
     if (!Number.isInteger(length) || length <= 0) {
-        throw new Error(`Invalid length: ${length}. Must be a positive integer.`);
+        throw new Error(`Invalid length: ${length}. Must be a positive integer`);
     }
 
     const charset = CHARSETS[mode];

package/src/url.ts

@@ -3,10 +3,10 @@
  *
  * Typically used to preserve the user's current path for post-login navigation.
  *
- * @param {string} url - The target URL to modify.
- * @param {string} redirectPath - The path to use as the redirect destination.
+ * @param {string} url - The target URL to modify
+ * @param {string} redirectPath - The path to use as the redirect destination
  *
- * @returns {string} A new URL string with the `redirect` query parameter.
+ * @returns {string} A new URL string with the `redirect` query parameter
  */
 export function appendRedirectParamToUrl(url: string, redirectPath: string) {
     const [base, rawQuery = ''] = url.split('?');

package/src/vue.ts

@@ -10,9 +10,9 @@ import { appendRedirectParamToUrl } from './url';
 /**
  * Appends the current Vue Router route's fullPath as the `redirect` query parameter to the given URL.
  *
- * @param {string} url - The base URL to modify.
+ * @param {string} url - The base URL to modify
  *
- * @returns {string} A new URL with the current route fullPath as the `redirect` parameter.
+ * @returns {string} A new URL with the current route fullPath as the `redirect` parameter
  */
 export function appendRedirectParamFromCurrentRouteToUrl(url: string) {
     return appendRedirectParamToUrl(url, useRoute().fullPath);
@@ -21,7 +21,7 @@ export function appendRedirectParamFromCurrentRouteToUrl(url: string) {
 /**
  * Clears an interval referenced by a Vue ref and sets it to null.
  *
- * @param {Ref<null | ReturnType<typeof setInterval>>} intervalRef - A Vue ref holding a NodeJS.Timeout or null.
+ * @param {Ref<null | ReturnType<typeof setInterval>>} intervalRef - A Vue ref holding a NodeJS.Timeout or null
  */
 export function clearIntervalRef(intervalRef: Ref<null | ReturnType<typeof setInterval>>) {
     if (intervalRef.value) clearInterval(intervalRef.value);
@@ -31,7 +31,7 @@ export function clearIntervalRef(intervalRef: Ref<null | ReturnType<typeof setIn
 /**
  * Clears a timeout referenced by a Vue ref and sets it to null.
  *
- * @param {Ref<null | ReturnType<typeof setTimeout>>} timeoutRef - A Vue ref holding a NodeJS.Timeout or null.
+ * @param {Ref<null | ReturnType<typeof setTimeout>>} timeoutRef - A Vue ref holding a NodeJS.Timeout or null
  */
 export function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof setTimeout>>) {
     if (timeoutRef.value) clearTimeout(timeoutRef.value);
@@ -42,9 +42,9 @@ export function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof setTime
  * A Vue composition function that remembers and restores scroll position
  * of a scrollable container across route changes and keep-alive activation.
  *
- * @template T - The type of the scrollable element (defaults to HTMLElement).
+ * @template T - The type of the scrollable element (defaults to HTMLElement)
  *
- * @param {Ref<null | T>} containerRef - A ref to the scrollable HTML element.
+ * @param {Ref<null | T>} containerRef - A ref to the scrollable HTML element
  */
 export function usePreserveScroll<T extends Element = HTMLElement>(containerRef: Ref<null | T>) {
     let scrollLeft = 0;

package/src/web.ts

@@ -3,9 +3,9 @@ import { appendRedirectParamToUrl } from './url';
 /**
  * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.
  *
- * @param {string} url - The base URL to modify.
+ * @param {string} url - The base URL to modify
  *
- * @returns {string} A new URL with the current location as the `redirect` parameter.
+ * @returns {string} A new URL with the current location as the `redirect` parameter
  */
 export function appendRedirectParamFromCurrentLocationToUrl(url: string) {
     const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;
@@ -19,8 +19,8 @@ export function appendRedirectParamFromCurrentLocationToUrl(url: string) {
  * 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.
+ * @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));