@kikiutils/shared 15.0.3 → 15.1.0

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

@@ -9,7 +9,7 @@ import type { LRUCache } from 'lru-cache';
  *
  * @returns {(keyFn: (...args: P) => string) => Readonly<{
  *   getItem, getItemTtl, hasItem, removeItem, resolveKey, setItem
- * }>} A keyed store factory that takes a key resolution function
+ * }>} A factory that accepts a key resolver and returns a frozen keyed cache facade
  *
  * @example
  * ```typescript
@@ -18,8 +18,8 @@ import type { LRUCache } from 'lru-cache';
  *
  * const lru = new LRUCache({ max: 100 });
  * const keyedStore = createLruKeyedStore(lru)((userId: string) => `user:${userId}`);
- * await keyedStore.setItem({ name: 'Alice' }, 'user-123');
- * const user = await keyedStore.getItem('user-123'); // { name: 'Alice' }
+ * keyedStore.setItem({ name: 'Alice' }, 'user-123');
+ * const user = keyedStore.getItem('user-123'); // { name: 'Alice' }
  * ```
  */
 export function createLruKeyedStore<D = unknown>(lruInstance: LRUCache<any, any, any>) {

package/src/storages/redis/keyed-store.ts

@@ -11,7 +11,7 @@ import type { RedisLikeStorage } from './types';
  *
  * @returns {(keyFn: (...args: P) => string) => Readonly<{
  *   getItem, getItemTtl, hasItem, removeItem, resolveKey, setItem, setItemWithTtl
- * }>} A keyed store factory that takes a key resolution function
+ * }>} A factory that accepts a key resolver and returns a frozen Redis keyed-store facade
  *
  * @example
  * ```typescript

package/src/string.ts

@@ -1,3 +1,6 @@
+/**
+ * Character-set presets supported by `randomString`.
+ */
 export type RandomStringMode =
   | 'alphabetic'
   | 'alphanumeric'
@@ -21,10 +24,13 @@ const CHARSETS: Record<RandomStringMode, string> = {
 };
 
 /**
- * Generates a random string of a given length using a specified character set.
+ * Generates a random string of a given length using a predefined character set.
+ *
+ * Uses `Math.random`, so this helper is suitable for display tokens, placeholders,
+ * and test data, but not for passwords, API keys, or other cryptographic secrets.
  *
- * @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 positive integer length of the string to generate
+ * @param {RandomStringMode} [mode] - The character set to use (default: `'alphabetic'`)
  *
  * @returns {string} The generated random string
  *
@@ -34,9 +40,9 @@ const CHARSETS: Record<RandomStringMode, string> = {
  * ```typescript
  * import { randomString } from '@kikiutils/shared/string';
  *
- * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)
- * console.log(randomString(6, 'numeric')); // e.g. '402398'
- * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'
+ * randomString(8); // e.g. 'aZbXwTyQ'
+ * randomString(6, 'numeric'); // e.g. '402398'
+ * randomString(10, 'alphanumeric'); // e.g. 'a9Z4pQ8xY2'
  * ```
  */
 export function randomString(length: number, mode: RandomStringMode = 'alphabetic') {

package/src/types/index.ts

@@ -6,13 +6,52 @@ import type {
 
 export type { FilteredKeyPath } from './filtered-key-path';
 
+/**
+ * A generic string-keyed object for utility APIs that intentionally accept any value shape.
+ */
 export type AnyRecord = Record<string, any>;
+
+/**
+ * Binary-like inputs accepted by `toBuffer` across browser and Node.js runtimes.
+ */
 export type BinaryInput = ArrayBuffer | Blob | Buffer | File | NodeBlob | NodeFile | Uint8Array;
+
+/**
+ * Boolean values represented either as booleans or common string literals.
+ */
 export type Booleanish = 'false' | 'true' | boolean;
+
+/**
+ * Accepts either a full object or a partial patch of that object.
+ */
 export type MaybePartial<T> = Partial<T> | T;
+
+/**
+ * Accepts either a mutable value or a readonly view of that value.
+ */
 export type MaybeReadonly<T> = Readonly<T> | T;
+
+/**
+ * Explicitly nullable value helper.
+ */
 export type Nullable<T> = null | T;
+
+/**
+ * Number-like value represented as a number or a numeric string.
+ */
 export type Numberish = number | string;
+
+/**
+ * A `Record` where every key is optional.
+ */
 export type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>;
+
+/**
+ * A readonly `PartialRecord`.
+ */
 export type ReadonlyPartialRecord<K extends keyof any, T> = Readonly<PartialRecord<K, T>>;
+
+/**
+ * A readonly `Record`.
+ */
 export type ReadonlyRecord<K extends keyof any, T> = Readonly<Record<K, T>>;