@kikiutils/shared 10.2.1 → 10.4.0

package/src/enum.ts

@@ -1,10 +1,12 @@
 /**
- * Extracts the numeric values from an enumeration-like object.
+ * Extracts only the numeric values from an enumeration-like object.
  *
- * @param {Record<number | string, number | string>} data - The enumeration-like object to extract numeric values from.
- * The keys can be numbers or strings, and the values can be numbers or strings.
+ * @template T - The type of the enum object
  *
- * @returns {number[]} An array of numeric values extracted from the object.
+ * @param {T} enumObject - The enumeration-like object to extract numeric values from,
+ * the object can contain numeric values, string values, or both.
+ *
+ * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -19,17 +21,19 @@
  * console.log(getEnumNumberValues(RecordType)); // [0, 1]
  * ```
  */
-export function getEnumNumberValues(data: Record<number | string, number | string>) {
-    return Object.values(data).filter((value) => typeof value === 'number');
+export function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[] {
+    return getEnumValues(enumObject).filter((value) => typeof value === 'number');
 }
 
 /**
- * Extracts the string values from an enumeration-like object.
+ * Extracts only the string values from an enumeration-like object.
+ *
+ * @template T - The type of the enum object
  *
- * @param {Record<number | string, number | string>} data - The enumeration-like object to extract string values from.
- * The keys can be numbers or strings, and the values can be numbers or strings.
+ * @param {T} enumObject - The enumeration-like object to extract string values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {string[]} An array of string values extracted from the object.
+ * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -44,19 +48,59 @@ export function getEnumNumberValues(data: Record<number | string, number | strin
  * console.log(getEnumStringValues(RecordType)); // ['unknown']
  * ```
  */
-export function getEnumStringValues(data: Record<number | string, number | string>) {
-    const keys: string[] = [];
-    const keysCount: Record<string, number> = {};
-    const values: any[] = [];
-    Object.entries(data).forEach(([key, value]) => {
-        keys.push(key);
-        values.push(value);
-        if (typeof value !== 'string') return;
-        keysCount[key] = (keysCount[key] ?? 0) + 1;
-        keysCount[value] = (keysCount[value] ?? 0) + 1;
-    });
+export function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[] {
+    return getEnumValues(enumObject).filter((value) => typeof value === 'string');
+}
 
-    return values.filter((value) => {
-        return typeof value === 'string' && (!keys.includes(value) || (keysCount[value] && keysCount[value] > 1));
-    });
+/**
+ * Extracts all values from an enumeration-like object.
+ *
+ * This function handles TypeScript enums correctly by accounting for the reverse mapping
+ * that occurs with numeric enums. It works with pure numeric enums, pure string enums,
+ * and mixed enums.
+ *
+ * @template T - The type of the enum object
+ *
+ * @param {T} enumObject - The enumeration-like object to extract values from,
+ * the object can contain numeric values, string values, or both.
+ *
+ * @returns {(T[keyof T])[]} An array containing all the values from the enum object
+ *
+ * @example
+ * ```typescript
+ * import { getEnumValues } from '@kikiutils/shared/enum';
+ *
+ * // Numeric enum
+ * enum Status {
+ *   Active = 0,
+ *   Inactive = 1,
+ *   Pending = 2
+ * }
+ *
+ * console.log(getEnumValues(Status)); // [0, 1, 2]
+ *
+ * // String enum
+ * enum Color {
+ *   Red = 'RED',
+ *   Green = 'GREEN',
+ *   Blue = 'BLUE'
+ * }
+ *
+ * console.log(getEnumValues(Color)); // ['RED', 'GREEN', 'BLUE']
+ *
+ * // Mixed enum
+ * enum RecordType {
+ *   Receive = 0,
+ *   Send = 1,
+ *   Unknown = 'unknown'
+ * }
+ *
+ * console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']
+ * ```
+ */
+export function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[] {
+    const values = Object.values(enumObject);
+    const hasNumberValues = values.some((value) => typeof value === 'number');
+    if (!hasNumberValues) return values;
+    return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);
 }

package/src/env.ts

@@ -11,7 +11,7 @@ export class EnvironmentNotFoundError extends Error {
     /**
      * Creates a new EnvironmentNotFoundError.
      *
-     * @param {string} key - The missing environment variable key.
+     * @param {string} key - The missing environment variable key
      */
     constructor(key: string) {
         super(`Missing environment variable: ${key}`);
@@ -27,11 +27,11 @@ export class EnvironmentNotFoundError extends Error {
  * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string
  * value like `'0'` or `'false'` is considered a valid (defined) value.
  *
- * @param {string} key - The environment variable key to retrieve.
+ * @param {string} key - The environment variable key to retrieve
  *
- * @returns {string} The value of the environment variable.
+ * @returns {string} The value of the environment variable
  *
- * @throws {EnvironmentNotFoundError} If the environment variable is not defined.
+ * @throws {EnvironmentNotFoundError} If the environment variable is not defined
  *
  * @example
  * ```typescript

package/src/general.ts

@@ -7,13 +7,13 @@
  * - If `value` is not an array, returns `value` directly.
  * - If the result is `null` or `undefined`, and `defaultValue` is provided, returns `defaultValue` instead.
  *
- * @template T - The type of the input value(s).
- * @template D - The type of the default value (if provided).
+ * @template T - The type of the input value(s)
+ * @template D - The type of the default value (if provided)
  *
- * @param {T | T[]} value - A single value or an array of values.
- * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`.
+ * @param {T | T[]} value - A single value or an array of values
+ * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`
  *
- * @returns {T | D | undefined} The first value or the fallback.
+ * @returns {T | D | undefined} The first value or the fallback
  *
  * @example
  * ```typescript

package/src/math.ts

@@ -28,11 +28,11 @@ export interface ToPercentageStringOptions {
  * - Supports custom decimal places and optional percentage symbol.
  * - Returns `'0.00%'` if result is `NaN` or division is invalid.
  *
- * @param {CalculableValue} molecular - The numerator of the fraction.
- * @param {CalculableValue} denominator - The denominator of the fraction.
- * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @param {CalculableValue} molecular - The numerator of the fraction
+ * @param {CalculableValue} denominator - The denominator of the fraction
+ * @param {ToPercentageStringOptions} [options] - Optional output settings
  *
- * @returns {string} Formatted percentage string.
+ * @returns {string} Formatted percentage string
  *
  * @example
  * ```typescript

package/src/number.ts

@@ -5,10 +5,10 @@ import { millify } from 'millify';
  *
  * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
  *
- * @param {number} value - The number to format.
- * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @param {number} value - The number to format
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`
  *
- * @returns {string} The compact number string.
+ * @returns {string} The compact number string
  *
  * @example
  * ```typescript

package/src/object.ts

@@ -8,10 +8,10 @@
  * It is designed for use cases such as signature generation, cache key construction,
  * or any context requiring consistent and predictable object serialization.
  *
- * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays.
- * @param {string} kvSeparator - The string used to separate each key from its value (default: '=').
- * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&').
- * @returns {string} A deterministic string representation of the input object.
+ * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays
+ * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')
+ * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')
+ * @returns {string} A deterministic string representation of the input object
  *
  * @example
  * ```typescript

package/src/random.ts

@@ -8,15 +8,15 @@
  *
  * This function supports any return type by using a generic type parameter.
  *
- * @template T - The return type of the generator function.
+ * @template T - The return type of the generator function
  *
- * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T.
- * @param {number} minMin - Lower bound of the first random range.
- * @param {number} minMax - Upper bound of the first random range.
- * @param {number} maxMin - Lower bound of the second random range.
- * @param {number} maxMax - Upper bound of the second random range.
+ * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T
+ * @param {number} minMin - Lower bound of the first random range
+ * @param {number} minMax - Upper bound of the first random range
+ * @param {number} maxMin - Lower bound of the second random range
+ * @param {number} maxMax - Upper bound of the second random range
  *
- * @returns {T} The result of the generator function using the computed final length.
+ * @returns {T} The result of the generator function using the computed final length
  */
 export function generateWithNestedRandomLength<T = string>(
     generator: (length: number) => T,

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));