@kikiutils/shared 18.0.1 → 18.1.0

package/dist/storages/redis/keyed-store.js

@@ -1,28 +1,19 @@
 //#region src/storages/redis/keyed-store.ts
 /**
-* Creates a keyed store wrapper around a Redis-like storage.
+* Creates a keyed store factory sharing a caller-owned Redis-like storage facade.
 *
-* @template D - The data type stored in the keyed store
+* @remarks
+* The key resolver is called synchronously once per operation with the operation's key arguments.
+* Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.
+* `setItemWithTtl` accepts its TTL in seconds before the value and key arguments.
+* The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.
 *
-* @param {MaybeReadonly<RedisLikeStorage>} storage - The underlying Redis-like storage instance
+* @typeParam D - The stored value type used by reads and writes.
 *
-* @returns {(keyFn: (...args: P) => string) => Readonly<{
-*   getItem, getItemTtl, hasItem, removeItem, resolveKey, setItem, setItemWithTtl
-* }>} A factory that accepts a key resolver and returns a frozen Redis keyed-store facade
+* @param storage - The shared Redis-like storage instance.
 *
-* @example
-* ```typescript
-* import { createRedisKeyedStore } from '@kikiutils/shared/storages/redis/keyed-store';
-* import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';
-* import { createClient } from 'redis';
-*
-* const client = createClient();
-* await client.connect();
-* const storage = createRedisMsgpackStorage(client as unknown as RedisLikeAdapter);
-* const keyedStore = createRedisKeyedStore(storage)((userId: string) => `user:${userId}`);
-* await keyedStore.setItem({ name: 'Alice' }, 'user-123');
-* const user = await keyedStore.getItem('user-123'); // { name: 'Alice' }
-* ```
+* @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.
+* Reads, writes, removals, and TTL results retain the underlying storage contract.
 */
 function createRedisKeyedStore(storage) {
 	return (keyFn) => Object.freeze({

package/dist/storages/redis/keyed-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"sourcesContent":["import type { MaybeReadonly } from '../../types';\n\nimport type { RedisLikeStorage } from './types';\n\n/**\n * Creates a keyed store wrapper around a Redis-like storage.\n *\n * @template D - The data type stored in the keyed store\n *\n * @param {MaybeReadonly<RedisLikeStorage>} storage - The underlying Redis-like storage instance\n *\n * @returns {(keyFn: (...args: P) => string) => Readonly<{\n *   getItem, getItemTtl, hasItem, removeItem, resolveKey, setItem, setItemWithTtl\n * }>} A factory that accepts a key resolver and returns a frozen Redis keyed-store facade\n *\n * @example\n * ```typescript\n * import { createRedisKeyedStore } from '@kikiutils/shared/storages/redis/keyed-store';\n * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';\n * import { createClient } from 'redis';\n *\n * const client = createClient();\n * await client.connect();\n * const storage = createRedisMsgpackStorage(client as unknown as RedisLikeAdapter);\n * const keyedStore = createRedisKeyedStore(storage)((userId: string) => `user:${userId}`);\n * await keyedStore.setItem({ name: 'Alice' }, 'user-123');\n * const user = await keyedStore.getItem('user-123'); // { name: 'Alice' }\n * ```\n */\nexport function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {\n    return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),\n        hasItem: (...args: P) => storage.hasItem(keyFn(...args)),\n        removeItem: (...args: P) => storage.removeItem(keyFn(...args)),\n        resolveKey: (...args: P) => keyFn(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(keyFn(...args), value),\n        setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,sBAAmC,SAA0C;CACzF,QAAyB,UAAkC,OAAO,OAAO;EACrE,UAAU,GAAG,SAAY,QAAQ,QAAW,MAAM,GAAG,IAAI,CAAC;EAC1D,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,UAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC;EACvD,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,aAAa,GAAG,SAAY,MAAM,GAAG,IAAI;EACzC,UAAU,OAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,GAAG,KAAK;EACxE,eAAe,YAAoB,OAAU,GAAG,MAAS;GACrD,OAAO,QAAQ,eAAe,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACnE;CACJ,CAAC;AACL"}
+{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"sourcesContent":["import type { MaybeReadonly } from '../../types';\n\nimport type { RedisLikeStorage } from './types';\n\n/**\n * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.\n *\n * @remarks\n * The key resolver is called synchronously once per operation with the operation's key arguments.\n * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.\n * `setItemWithTtl` accepts its TTL in seconds before the value and key arguments.\n * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.\n *\n * @typeParam D - The stored value type used by reads and writes.\n *\n * @param storage - The shared Redis-like storage instance.\n *\n * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.\n * Reads, writes, removals, and TTL results retain the underlying storage contract.\n */\nexport function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {\n    return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),\n        hasItem: (...args: P) => storage.hasItem(keyFn(...args)),\n        removeItem: (...args: P) => storage.removeItem(keyFn(...args)),\n        resolveKey: (...args: P) => keyFn(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(keyFn(...args), value),\n        setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,sBAAmC,SAA0C;CACzF,QAAyB,UAAkC,OAAO,OAAO;EACrE,UAAU,GAAG,SAAY,QAAQ,QAAW,MAAM,GAAG,IAAI,CAAC;EAC1D,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,UAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC;EACvD,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,aAAa,GAAG,SAAY,MAAM,GAAG,IAAI;EACzC,UAAU,OAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,GAAG,KAAK;EACxE,eAAe,YAAoB,OAAU,GAAG,MAAS;GACrD,OAAO,QAAQ,eAAe,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACnE;CACJ,CAAC;AACL"}

package/dist/storages/redis/msgpack.d.ts

@@ -1,26 +1,46 @@
 import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
 //#region src/storages/redis/msgpack.d.ts
 /**
- * Creates a Redis-like storage using msgpack serialization.
+ * Creates a frozen Redis-like storage facade using MessagePack serialization.
  *
- * @param {RedisLikeAdapter} adapter - The Redis-like adapter to use for raw buffer operations
+ * @remarks
+ * Adapter rejections and MessagePack serialization errors propagate to the caller.
+ * Reads resolve to `null` when no raw value exists. Writes resolve to `true` only when the adapter returns `OK`;
+ * removal resolves to `true` only when exactly one key is deleted.
+ * The adapter remains caller-owned; creating the facade does not open or close a connection.
  *
- * @returns {Readonly<RedisLikeStorage>} A readonly storage instance
- *   with getItem, setItem, hasItem, removeItem, getItemTtl, setItemWithTtl
+ * @param adapter - The caller-owned adapter for raw binary operations.
+ *
+ * @returns A new frozen facade sharing the supplied adapter.
  *
  * @example
- * ```typescript
+ *
+ * ```ts
  * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';
- * import { createClient } from 'redis';
+ * import type { RedisLikeAdapter } from '@kikiutils/shared/storages/redis/types';
+ *
+ * // This in-memory adapter demonstrates non-expiring operations without an external service.
+ * const values = new Map<string, Uint8Array>();
+ * const adapter: RedisLikeAdapter = {
+ *     delete: async (key) => values.delete(key) ? 1 : 0,
+ *     getBuffer: async (key) => values.get(key) ?? null,
+ *     has: async (key) => values.has(key),
+ *     setBuffer: async (key, value) => {
+ *         values.set(key, value);
+ *         return 'OK';
+ *     },
+ *     setBufferEx: async () => {
+ *         throw new Error('TTL writes are not supported by this example adapter');
+ *     },
+ *     ttl: async (key) => values.has(key) ? -1 : -2,
+ * };
  *
- * const client = createClient();
- * await client.connect();
- * const storage = createRedisMsgpackStorage(client as unknown as RedisLikeAdapter);
- * await storage.setItem('key', { foo: 'bar' });
- * const value = await storage.getItem('key'); // { foo: 'bar' }
+ * const storage = createRedisMsgpackStorage(adapter);
+ * await storage.setItem('profile', { name: 'Alice' });
+ * const profile = await storage.getItem<{ name: string }>('profile');
+ * console.log(profile); // => { name: 'Alice' }
  * ```
  */
-declare function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage>;
+export declare function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage>;
 //#endregion
-export { createRedisMsgpackStorage };
 //# sourceMappingURL=msgpack.d.ts.map

package/dist/storages/redis/msgpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"msgpack.d.ts","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAmCgB,0BAA0B,SAAS,mBAAmB,SAAS"}
+{"version":3,"file":"msgpack.d.ts","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDgB,0BAA0B,SAAS,mBAAmB,SAAS"}

package/dist/storages/redis/msgpack.js

@@ -2,23 +2,44 @@ import { decode, encode, isNativeAccelerationEnabled } from "msgpackr";
 //#region src/storages/redis/msgpack.ts
 if (!isNativeAccelerationEnabled) console.warn("Native acceleration not enabled for msgpackr, verify that install finished properly");
 /**
-* Creates a Redis-like storage using msgpack serialization.
+* Creates a frozen Redis-like storage facade using MessagePack serialization.
 *
-* @param {RedisLikeAdapter} adapter - The Redis-like adapter to use for raw buffer operations
+* @remarks
+* Adapter rejections and MessagePack serialization errors propagate to the caller.
+* Reads resolve to `null` when no raw value exists. Writes resolve to `true` only when the adapter returns `OK`;
+* removal resolves to `true` only when exactly one key is deleted.
+* The adapter remains caller-owned; creating the facade does not open or close a connection.
 *
-* @returns {Readonly<RedisLikeStorage>} A readonly storage instance
-*   with getItem, setItem, hasItem, removeItem, getItemTtl, setItemWithTtl
+* @param adapter - The caller-owned adapter for raw binary operations.
+*
+* @returns A new frozen facade sharing the supplied adapter.
 *
 * @example
-* ```typescript
+*
+* ```ts
 * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';
-* import { createClient } from 'redis';
+* import type { RedisLikeAdapter } from '@kikiutils/shared/storages/redis/types';
+*
+* // This in-memory adapter demonstrates non-expiring operations without an external service.
+* const values = new Map<string, Uint8Array>();
+* const adapter: RedisLikeAdapter = {
+*     delete: async (key) => values.delete(key) ? 1 : 0,
+*     getBuffer: async (key) => values.get(key) ?? null,
+*     has: async (key) => values.has(key),
+*     setBuffer: async (key, value) => {
+*         values.set(key, value);
+*         return 'OK';
+*     },
+*     setBufferEx: async () => {
+*         throw new Error('TTL writes are not supported by this example adapter');
+*     },
+*     ttl: async (key) => values.has(key) ? -1 : -2,
+* };
 *
-* const client = createClient();
-* await client.connect();
-* const storage = createRedisMsgpackStorage(client as unknown as RedisLikeAdapter);
-* await storage.setItem('key', { foo: 'bar' });
-* const value = await storage.getItem('key'); // { foo: 'bar' }
+* const storage = createRedisMsgpackStorage(adapter);
+* await storage.setItem('profile', { name: 'Alice' });
+* const profile = await storage.getItem<{ name: string }>('profile');
+* console.log(profile); // => { name: 'Alice' }
 * ```
 */
 function createRedisMsgpackStorage(adapter) {

package/dist/storages/redis/msgpack.js.map

@@ -1 +1 @@
-{"version":3,"file":"msgpack.js","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"sourcesContent":["import {\n    decode,\n    encode,\n    isNativeAccelerationEnabled,\n} from 'msgpackr';\n\nimport type {\n    RedisLikeAdapter,\n    RedisLikeStorage,\n} from './types';\n\nif (!isNativeAccelerationEnabled) {\n    console.warn('Native acceleration not enabled for msgpackr, verify that install finished properly');\n}\n\n/**\n * Creates a Redis-like storage using msgpack serialization.\n *\n * @param {RedisLikeAdapter} adapter - The Redis-like adapter to use for raw buffer operations\n *\n * @returns {Readonly<RedisLikeStorage>} A readonly storage instance\n *   with getItem, setItem, hasItem, removeItem, getItemTtl, setItemWithTtl\n *\n * @example\n * ```typescript\n * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';\n * import { createClient } from 'redis';\n *\n * const client = createClient();\n * await client.connect();\n * const storage = createRedisMsgpackStorage(client as unknown as RedisLikeAdapter);\n * await storage.setItem('key', { foo: 'bar' });\n * const value = await storage.getItem('key'); // { foo: 'bar' }\n * ```\n */\nexport function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage> {\n    return Object.freeze({\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await adapter.getBuffer(key);\n            return rawValue ? decode(rawValue) as T : null;\n        },\n        getItemTtl: (key: string) => adapter.ttl(key),\n        hasItem: (key: string) => adapter.has(key),\n        removeItem: async (key: string) => await adapter.delete(key) === 1,\n        setItem: async (key: string, value: any) => await adapter.setBuffer(key, encode(value)) === 'OK',\n        async setItemWithTtl(key: string, ttlSeconds: number, value: any) {\n            return await adapter.setBufferEx(key, ttlSeconds, encode(value)) === 'OK';\n        },\n    });\n}\n"],"mappings":";;AAWA,IAAI,CAAC,6BACD,QAAQ,KAAK,qFAAqF;;;;;;;;;;;;;;;;;;;;;AAuBtG,SAAgB,0BAA0B,SAAuD;CAC7F,OAAO,OAAO,OAAO;EACjB,MAAM,QAAqB,KAAa;GACpC,MAAM,WAAW,MAAM,QAAQ,UAAU,GAAG;GAC5C,OAAO,WAAW,OAAO,QAAQ,IAAS;EAC9C;EACA,aAAa,QAAgB,QAAQ,IAAI,GAAG;EAC5C,UAAU,QAAgB,QAAQ,IAAI,GAAG;EACzC,YAAY,OAAO,QAAgB,MAAM,QAAQ,OAAO,GAAG,MAAM;EACjE,SAAS,OAAO,KAAa,UAAe,MAAM,QAAQ,UAAU,KAAK,OAAO,KAAK,CAAC,MAAM;EAC5F,MAAM,eAAe,KAAa,YAAoB,OAAY;GAC9D,OAAO,MAAM,QAAQ,YAAY,KAAK,YAAY,OAAO,KAAK,CAAC,MAAM;EACzE;CACJ,CAAC;AACL"}
+{"version":3,"file":"msgpack.js","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"sourcesContent":["import {\n    decode,\n    encode,\n    isNativeAccelerationEnabled,\n} from 'msgpackr';\n\nimport type {\n    RedisLikeAdapter,\n    RedisLikeStorage,\n} from './types';\n\nif (!isNativeAccelerationEnabled) {\n    console.warn('Native acceleration not enabled for msgpackr, verify that install finished properly');\n}\n\n/**\n * Creates a frozen Redis-like storage facade using MessagePack serialization.\n *\n * @remarks\n * Adapter rejections and MessagePack serialization errors propagate to the caller.\n * Reads resolve to `null` when no raw value exists. Writes resolve to `true` only when the adapter returns `OK`;\n * removal resolves to `true` only when exactly one key is deleted.\n * The adapter remains caller-owned; creating the facade does not open or close a connection.\n *\n * @param adapter - The caller-owned adapter for raw binary operations.\n *\n * @returns A new frozen facade sharing the supplied adapter.\n *\n * @example\n *\n * ```ts\n * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';\n * import type { RedisLikeAdapter } from '@kikiutils/shared/storages/redis/types';\n *\n * // This in-memory adapter demonstrates non-expiring operations without an external service.\n * const values = new Map<string, Uint8Array>();\n * const adapter: RedisLikeAdapter = {\n *     delete: async (key) => values.delete(key) ? 1 : 0,\n *     getBuffer: async (key) => values.get(key) ?? null,\n *     has: async (key) => values.has(key),\n *     setBuffer: async (key, value) => {\n *         values.set(key, value);\n *         return 'OK';\n *     },\n *     setBufferEx: async () => {\n *         throw new Error('TTL writes are not supported by this example adapter');\n *     },\n *     ttl: async (key) => values.has(key) ? -1 : -2,\n * };\n *\n * const storage = createRedisMsgpackStorage(adapter);\n * await storage.setItem('profile', { name: 'Alice' });\n * const profile = await storage.getItem<{ name: string }>('profile');\n * console.log(profile); // => { name: 'Alice' }\n * ```\n */\nexport function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage> {\n    return Object.freeze({\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await adapter.getBuffer(key);\n            return rawValue ? decode(rawValue) as T : null;\n        },\n        getItemTtl: (key: string) => adapter.ttl(key),\n        hasItem: (key: string) => adapter.has(key),\n        removeItem: async (key: string) => await adapter.delete(key) === 1,\n        setItem: async (key: string, value: any) => await adapter.setBuffer(key, encode(value)) === 'OK',\n        async setItemWithTtl(key: string, ttlSeconds: number, value: any) {\n            return await adapter.setBufferEx(key, ttlSeconds, encode(value)) === 'OK';\n        },\n    });\n}\n"],"mappings":";;AAWA,IAAI,CAAC,6BACD,QAAQ,KAAK,qFAAqF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CtG,SAAgB,0BAA0B,SAAuD;CAC7F,OAAO,OAAO,OAAO;EACjB,MAAM,QAAqB,KAAa;GACpC,MAAM,WAAW,MAAM,QAAQ,UAAU,GAAG;GAC5C,OAAO,WAAW,OAAO,QAAQ,IAAS;EAC9C;EACA,aAAa,QAAgB,QAAQ,IAAI,GAAG;EAC5C,UAAU,QAAgB,QAAQ,IAAI,GAAG;EACzC,YAAY,OAAO,QAAgB,MAAM,QAAQ,OAAO,GAAG,MAAM;EACjE,SAAS,OAAO,KAAa,UAAe,MAAM,QAAQ,UAAU,KAAK,OAAO,KAAK,CAAC,MAAM;EAC5F,MAAM,eAAe,KAAa,YAAoB,OAAY;GAC9D,OAAO,MAAM,QAAQ,YAAY,KAAK,YAAY,OAAO,KAAK,CAAC,MAAM;EACzE;CACJ,CAAC;AACL"}

package/dist/storages/redis/types.d.ts

@@ -1,62 +1,79 @@
 //#region src/storages/redis/types.d.ts
 /**
- * Low-level Redis-like adapter interface for raw buffer operations.
+ * A caller-owned asynchronous adapter for Redis-like binary operations.
+ *
+ * @remarks
+ * Each callback performs one operation and rejects its promise on backend failure.
+ * TTL results use Redis conventions: `-1` means no expiry, and `-2` means the key is missing.
  */
-interface RedisLikeAdapter {
+export interface RedisLikeAdapter {
   /**
-   * Deletes a key and returns the number of keys deleted.
+   * Deletes a key and resolves to the number of keys deleted.
    */
   delete: (key: string) => Promise<number>;
   /**
-   * Gets the raw buffer value for a key.
+   * Reads a key and resolves to its raw bytes, or `null` when the key is missing.
    */
   getBuffer: (key: string) => Promise<null | Uint8Array>;
   /**
-   * Checks if a key exists.
+   * Checks a key and resolves to whether it exists.
    */
   has: (key: string) => Promise<boolean>;
   /**
-   * Sets a raw buffer value for a key.
+   * Writes raw bytes and resolves to the backend acknowledgment, or no value.
    */
   setBuffer: (key: string, value: Uint8Array) => Promise<'OK' | void>;
   /**
-   * Sets a raw buffer value for a key with a TTL.
+   * Writes raw bytes with an expiry and resolves to the backend acknowledgment, or no value.
+   *
+   * @param key - The storage key.
+   * @param ttlSeconds - The expiry duration in seconds.
+   * @param value - The raw bytes to store.
    */
   setBufferEx: (key: string, ttlSeconds: number, value: Uint8Array) => Promise<'OK' | void>;
   /**
-   * Gets the TTL of a key in seconds.
+   * Reads a key's remaining TTL in seconds, or `-1` for no expiry and `-2` for a missing key.
    */
   ttl: (key: string) => Promise<number>;
 }
 /**
- * High-level Redis-like storage interface with typed get/set operations.
+ * An asynchronous Redis-like storage contract with typed reads and serialized writes.
+ *
+ * @remarks
+ * Operations reject on backend or serialization failure. TTL values are in seconds;
+ * `-1` means no expiry, and `-2` means the key is missing. Connection cleanup remains caller-owned.
  */
-interface RedisLikeStorage {
+export interface RedisLikeStorage {
   /**
-   * Gets a deserialized value by key.
+   * Reads a deserialized value and resolves to `null` when the key is missing.
+   *
+   * @typeParam T - The expected value type; deserialization does not validate this type.
    */
   getItem: <T = unknown>(key: string) => Promise<null | T>;
   /**
-   * Gets the TTL of a key in seconds.
+   * Reads a key's remaining TTL in seconds, or `-1` for no expiry and `-2` for a missing key.
    */
   getItemTtl: (key: string) => Promise<number>;
   /**
-   * Checks if a key exists.
+   * Checks a key and resolves to whether it exists.
    */
   hasItem: (key: string) => Promise<boolean>;
   /**
-   * Removes a key.
+   * Removes a key and resolves to whether a key was deleted.
    */
   removeItem: (key: string) => Promise<boolean>;
   /**
-   * Sets a value for a key.
+   * Stores a value and resolves to whether the backend acknowledges the write.
    */
   setItem: (key: string, value: any) => Promise<boolean>;
   /**
-   * Sets a value for a key with a TTL.
+   * Stores a value with an expiry and resolves to whether the backend acknowledges the write.
+   *
+   * @param key - The storage key.
+   * @param ttlSeconds - The expiry duration in seconds.
+   * @param value - The value to serialize and store.
    */
   setItemWithTtl: (key: string, ttlSeconds: number, value: any) => Promise<boolean>;
 }
 //#endregion
-export { RedisLikeAdapter, RedisLikeStorage };
 //# sourceMappingURL=types.d.ts.map

package/dist/storages/redis/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/storages/redis/types.ts"],"mappings":";;;;UAGiB;;;;EAIb,SAAS,gBAAgB;;;;EAKzB,YAAY,gBAAgB,eAAe;;;;EAK3C,MAAM,gBAAgB;;;;EAKtB,YAAY,aAAa,OAAO,eAAe;;;;EAK/C,cAAc,aAAa,oBAAoB,OAAO,eAAe;;;;EAKrE,MAAM,gBAAgB;;;;;UAMT;;;;EAIb,UAAU,aAAa,gBAAgB,eAAe;;;;EAKtD,aAAa,gBAAgB;;;;EAK7B,UAAU,gBAAgB;;;;EAK1B,aAAa,gBAAgB;;;;EAK7B,UAAU,aAAa,eAAe;;;;EAKtC,iBAAiB,aAAa,oBAAoB,eAAe"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/storages/redis/types.ts"],"mappings":";;;;;;;;iBAOiB;;;;EAIb,SAAS,gBAAgB;;;;EAKzB,YAAY,gBAAgB,eAAe;;;;EAK3C,MAAM,gBAAgB;;;;EAKtB,YAAY,aAAa,OAAO,eAAe;;;;;;;;EAS/C,cAAc,aAAa,oBAAoB,OAAO,eAAe;;;;EAKrE,MAAM,gBAAgB;;;;;;;;;iBAUT;;;;;;EAMb,UAAU,aAAa,gBAAgB,eAAe;;;;EAKtD,aAAa,gBAAgB;;;;EAK7B,UAAU,gBAAgB;;;;EAK1B,aAAa,gBAAgB;;;;EAK7B,UAAU,aAAa,eAAe;;;;;;;;EAStC,iBAAiB,aAAa,oBAAoB,eAAe"}

package/dist/string.d.ts

@@ -2,30 +2,31 @@
 /**
  * Character-set presets supported by `randomString`.
  */
-type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lowercase-numeric' | 'numeric' | 'uppercase' | 'uppercase-numeric';
+export type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lowercase-numeric' | 'numeric' | 'uppercase' | 'uppercase-numeric';
 /**
  * Generates a random string of a given length using a predefined character set.
  *
+ * @remarks
  * 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 positive integer length of the string to generate
- * @param {RandomStringMode} [mode] - The character set to use (default: `'alphabetic'`)
+ * @param length - The positive integer length of the string to generate.
+ * @param mode - The character set to use (default: `'alphabetic'`).
  *
- * @returns {string} The generated random string
+ * @returns 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
+ *
+ * ```ts
  * import { randomString } from '@kikiutils/shared/string';
  *
- * randomString(8); // e.g. 'aZbXwTyQ'
- * randomString(6, 'numeric'); // e.g. '402398'
- * randomString(10, 'alphanumeric'); // e.g. 'a9Z4pQ8xY2'
+ * randomString(8); // For example, 'aZbXwTyQ'.
+ * randomString(6, 'numeric'); // For example, '402398'.
+ * randomString(10, 'alphanumeric'); // For example, 'a9Z4pQ8xY2'.
  * ```
  */
-declare function randomString(length: number, mode?: RandomStringMode): string;
+export declare function randomString(length: number, mode?: RandomStringMode): string;
 //#endregion
-export { RandomStringMode, randomString };
 //# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","names":[],"sources":["../src/string.ts"],"mappings":";;;;KAGY;;;;;;;;;;;;;;;;;;;;;;;iBA4CI,aAAa,gBAAgB,OAAM"}
+{"version":3,"file":"string.d.ts","names":[],"sources":["../src/string.ts"],"mappings":";;;;YAGY;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CI,aAAa,gBAAgB,OAAM"}

package/dist/string.js

@@ -1,33 +1,38 @@
 //#region src/string.ts
+const DIGITS = "0123456789";
+const LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+const UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const CHARSETS = {
-	"alphabetic": "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-	"alphanumeric": "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-	"lowercase": "abcdefghijklmnopqrstuvwxyz",
-	"lowercase-numeric": "0123456789abcdefghijklmnopqrstuvwxyz",
-	"numeric": "0123456789",
-	"uppercase": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
-	"uppercase-numeric": "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	"alphabetic": LOWERCASE + UPPERCASE,
+	"alphanumeric": DIGITS + LOWERCASE + UPPERCASE,
+	"lowercase": LOWERCASE,
+	"lowercase-numeric": DIGITS + LOWERCASE,
+	"numeric": DIGITS,
+	"uppercase": UPPERCASE,
+	"uppercase-numeric": DIGITS + UPPERCASE
 };
 /**
 * Generates a random string of a given length using a predefined character set.
 *
+* @remarks
 * 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 positive integer length of the string to generate
-* @param {RandomStringMode} [mode] - The character set to use (default: `'alphabetic'`)
+* @param length - The positive integer length of the string to generate.
+* @param mode - The character set to use (default: `'alphabetic'`).
 *
-* @returns {string} The generated random string
+* @returns 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
+*
+* ```ts
 * import { randomString } from '@kikiutils/shared/string';
 *
-* randomString(8); // e.g. 'aZbXwTyQ'
-* randomString(6, 'numeric'); // e.g. '402398'
-* randomString(10, 'alphanumeric'); // e.g. 'a9Z4pQ8xY2'
+* randomString(8); // For example, 'aZbXwTyQ'.
+* randomString(6, 'numeric'); // For example, '402398'.
+* randomString(10, 'alphanumeric'); // For example, 'a9Z4pQ8xY2'.
 * ```
 */
 function randomString(length, mode = "alphabetic") {

package/dist/string.js.map

@@ -1 +1 @@
-{"version":3,"file":"string.js","names":[],"sources":["../src/string.ts"],"sourcesContent":["/**\n * Character-set presets supported by `randomString`.\n */\nexport type RandomStringMode =\n  | 'alphabetic'\n  | 'alphanumeric'\n  | 'lowercase'\n  | 'lowercase-numeric'\n  | 'numeric'\n  | 'uppercase'\n  | 'uppercase-numeric';\n\nconst DIGITS = '0123456789';\nconst LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst CHARSETS: Record<RandomStringMode, string> = {\n    'alphabetic': LOWERCASE + UPPERCASE,\n    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,\n    'lowercase': LOWERCASE,\n    'lowercase-numeric': DIGITS + LOWERCASE,\n    'numeric': DIGITS,\n    'uppercase': UPPERCASE,\n    'uppercase-numeric': DIGITS + UPPERCASE,\n};\n\n/**\n * Generates a random string of a given length using a predefined character set.\n *\n * Uses `Math.random`, so this helper is suitable for display tokens, placeholders,\n * and test data, but not for passwords, API keys, or other cryptographic secrets.\n *\n * @param {number} length - The positive integer length of the string to generate\n * @param {RandomStringMode} [mode] - The character set to use (default: `'alphabetic'`)\n *\n * @returns {string} The generated random string\n *\n * @throws {Error} If the length is not a positive integer or the mode is unsupported\n *\n * @example\n * ```typescript\n * import { randomString } from '@kikiutils/shared/string';\n *\n * randomString(8); // e.g. 'aZbXwTyQ'\n * randomString(6, 'numeric'); // e.g. '402398'\n * randomString(10, 'alphanumeric'); // e.g. 'a9Z4pQ8xY2'\n * ```\n */\nexport function randomString(length: number, mode: RandomStringMode = 'alphabetic') {\n    if (!Number.isInteger(length) || length <= 0) {\n        throw new Error(`Invalid length: ${length}. Must be a positive integer`);\n    }\n\n    const charset = CHARSETS[mode];\n    if (!charset) throw new Error(`Unsupported mode: ${mode}`);\n    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');\n}\n"],"mappings":";AAeA,MAAM,WAA6C;CAC/C,cAAc;CACd,gBAAgB;CAChB,aAAa;CACb,qBAAqB;CACrB,WAAW;CACX,aAAa;CACb,qBAAqB;AACzB;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,aAAa,QAAgB,OAAyB,cAAc;CAChF,IAAI,CAAC,OAAO,UAAU,MAAM,KAAK,UAAU,GACvC,MAAM,IAAI,MAAM,mBAAmB,OAAO,6BAA6B;CAG3E,MAAM,UAAU,SAAS;CACzB,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qBAAqB,MAAM;CACzD,OAAO,MAAM,KAAK,EAAE,OAAO,SAAS,QAAQ,KAAK,MAAM,KAAK,OAAO,IAAI,QAAQ,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE;AACpG"}
+{"version":3,"file":"string.js","names":[],"sources":["../src/string.ts"],"sourcesContent":["/**\n * Character-set presets supported by `randomString`.\n */\nexport type RandomStringMode =\n  | 'alphabetic'\n  | 'alphanumeric'\n  | 'lowercase'\n  | 'lowercase-numeric'\n  | 'numeric'\n  | 'uppercase'\n  | 'uppercase-numeric';\n\nconst DIGITS = '0123456789';\nconst LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst CHARSETS: Record<RandomStringMode, string> = {\n    'alphabetic': LOWERCASE + UPPERCASE,\n    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,\n    'lowercase': LOWERCASE,\n    'lowercase-numeric': DIGITS + LOWERCASE,\n    'numeric': DIGITS,\n    'uppercase': UPPERCASE,\n    'uppercase-numeric': DIGITS + UPPERCASE,\n};\n\n/**\n * Generates a random string of a given length using a predefined character set.\n *\n * @remarks\n * Uses `Math.random`, so this helper is suitable for display tokens, placeholders,\n * and test data, but not for passwords, API keys, or other cryptographic secrets.\n *\n * @param length - The positive integer length of the string to generate.\n * @param mode - The character set to use (default: `'alphabetic'`).\n *\n * @returns The generated random string.\n *\n * @throws Error if the length is not a positive integer or the mode is unsupported.\n *\n * @example\n *\n * ```ts\n * import { randomString } from '@kikiutils/shared/string';\n *\n * randomString(8); // For example, 'aZbXwTyQ'.\n * randomString(6, 'numeric'); // For example, '402398'.\n * randomString(10, 'alphanumeric'); // For example, 'a9Z4pQ8xY2'.\n * ```\n */\nexport function randomString(length: number, mode: RandomStringMode = 'alphabetic') {\n    if (!Number.isInteger(length) || length <= 0) {\n        throw new Error(`Invalid length: ${length}. Must be a positive integer`);\n    }\n\n    const charset = CHARSETS[mode];\n    if (!charset) throw new Error(`Unsupported mode: ${mode}`);\n    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');\n}\n"],"mappings":";AAYA,MAAM,SAAS;AACf,MAAM,YAAY;AAClB,MAAM,YAAY;AAClB,MAAM,WAA6C;CAC/C,cAAc,YAAY;CAC1B,gBAAgB,SAAS,YAAY;CACrC,aAAa;CACb,qBAAqB,SAAS;CAC9B,WAAW;CACX,aAAa;CACb,qBAAqB,SAAS;AAClC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAa,QAAgB,OAAyB,cAAc;CAChF,IAAI,CAAC,OAAO,UAAU,MAAM,KAAK,UAAU,GACvC,MAAM,IAAI,MAAM,mBAAmB,OAAO,6BAA6B;CAG3E,MAAM,UAAU,SAAS;CACzB,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qBAAqB,MAAM;CACzD,OAAO,MAAM,KAAK,EAAE,OAAO,SAAS,QAAQ,KAAK,MAAM,KAAK,OAAO,IAAI,QAAQ,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE;AACpG"}

package/dist/time.d.ts

@@ -1,44 +1,49 @@
 //#region src/time.d.ts
 /**
- * Delays execution until the specified duration elapses or the signal is aborted.
+ * Waits until a duration elapses or cancellation occurs without rejecting on cancellation.
  *
- * Aborting the signal resolves the promise normally without throwing.
+ * @remarks
+ * The promise resolves without a value when the timer completes or the signal aborts.
+ * An already aborted signal resolves immediately; completion removes the abort listener and clears the timer.
  *
- * @param {number} ms - Delay duration in milliseconds
- * @param {AbortSignal} [signal] - Optional signal used to end the delay early
- *
- * @returns {Promise<void>} Resolves when the delay completes or the signal is aborted
+ * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.
+ * @param signal - The signal that ends the wait early.
  *
  * @example
- * ```typescript
+ *
+ * ```ts
  * import { delay } from '@kikiutils/shared/time';
  *
  * const controller = new AbortController();
- * setTimeout(() => controller.abort(), 1000);
- * await delay(5000, controller.signal); // resolves after ~1s
+ * controller.abort();
+ * await delay(5000, controller.signal);
  * ```
  */
-declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
 /**
- * Delays execution until the specified duration elapses or the signal is aborted.
+ * Waits until a duration elapses and rejects on cancellation.
  *
- * Aborting the signal rejects the promise with the signal's abort reason.
+ * @remarks
+ * The promise resolves without a value when the timer completes and rejects with `signal.reason` if aborted.
+ * An already aborted signal rejects immediately. Aborting clears the timer; timer completion removes the listener.
  *
- * @param {number} ms - Delay duration in milliseconds
- * @param {AbortSignal} [signal] - Optional signal used to abort the delay
- *
- * @returns {Promise<void>} Resolves when the delay completes or rejects when the signal is aborted
+ * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.
+ * @param signal - The signal that cancels the wait.
  *
  * @example
- * ```typescript
+ *
+ * ```ts
  * import { delayOrThrow } from '@kikiutils/shared/time';
  *
  * const controller = new AbortController();
- * setTimeout(() => controller.abort(), 1000);
- * await delayOrThrow(5000, controller.signal); // rejects after ~1s
+ * controller.abort(new Error('Canceled'));
+ * try {
+ *     await delayOrThrow(5000, controller.signal);
+ * } catch (error) {
+ *     console.error(error);
+ * }
  * ```
  */
-declare function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void>;
 //#endregion
-export { delay, delayOrThrow };
 //# sourceMappingURL=time.d.ts.map

package/dist/time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","names":[],"sources":["../src/time.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAmBgB,MAAM,YAAY,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;iBAsCzC,aAAa,YAAY,SAAS,cAAc"}
+{"version":3,"file":"time.d.ts","names":[],"sources":["../src/time.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBAoBgB,MAAM,YAAY,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CzC,aAAa,YAAY,SAAS,cAAc"}

package/dist/time.js

@@ -1,21 +1,22 @@
 //#region src/time.ts
 /**
-* Delays execution until the specified duration elapses or the signal is aborted.
+* Waits until a duration elapses or cancellation occurs without rejecting on cancellation.
 *
-* Aborting the signal resolves the promise normally without throwing.
+* @remarks
+* The promise resolves without a value when the timer completes or the signal aborts.
+* An already aborted signal resolves immediately; completion removes the abort listener and clears the timer.
 *
-* @param {number} ms - Delay duration in milliseconds
-* @param {AbortSignal} [signal] - Optional signal used to end the delay early
-*
-* @returns {Promise<void>} Resolves when the delay completes or the signal is aborted
+* @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.
+* @param signal - The signal that ends the wait early.
 *
 * @example
-* ```typescript
+*
+* ```ts
 * import { delay } from '@kikiutils/shared/time';
 *
 * const controller = new AbortController();
-* setTimeout(() => controller.abort(), 1000);
-* await delay(5000, controller.signal); // resolves after ~1s
+* controller.abort();
+* await delay(5000, controller.signal);
 * ```
 */
 function delay(ms, signal) {
@@ -34,22 +35,27 @@ function delay(ms, signal) {
 	});
 }
 /**
-* Delays execution until the specified duration elapses or the signal is aborted.
+* Waits until a duration elapses and rejects on cancellation.
 *
-* Aborting the signal rejects the promise with the signal's abort reason.
+* @remarks
+* The promise resolves without a value when the timer completes and rejects with `signal.reason` if aborted.
+* An already aborted signal rejects immediately. Aborting clears the timer; timer completion removes the listener.
 *
-* @param {number} ms - Delay duration in milliseconds
-* @param {AbortSignal} [signal] - Optional signal used to abort the delay
-*
-* @returns {Promise<void>} Resolves when the delay completes or rejects when the signal is aborted
+* @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.
+* @param signal - The signal that cancels the wait.
 *
 * @example
-* ```typescript
+*
+* ```ts
 * import { delayOrThrow } from '@kikiutils/shared/time';
 *
 * const controller = new AbortController();
-* setTimeout(() => controller.abort(), 1000);
-* await delayOrThrow(5000, controller.signal); // rejects after ~1s
+* controller.abort(new Error('Canceled'));
+* try {
+*     await delayOrThrow(5000, controller.signal);
+* } catch (error) {
+*     console.error(error);
+* }
 * ```
 */
 function delayOrThrow(ms, signal) {

package/dist/time.js.map

@@ -1 +1 @@
-{"version":3,"file":"time.js","names":[],"sources":["../src/time.ts"],"sourcesContent":["/**\n * Delays execution until the specified duration elapses or the signal is aborted.\n *\n * Aborting the signal resolves the promise normally without throwing.\n *\n * @param {number} ms - Delay duration in milliseconds\n * @param {AbortSignal} [signal] - Optional signal used to end the delay early\n *\n * @returns {Promise<void>} Resolves when the delay completes or the signal is aborted\n *\n * @example\n * ```typescript\n * import { delay } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * setTimeout(() => controller.abort(), 1000);\n * await delay(5000, controller.signal); // resolves after ~1s\n * ```\n */\nexport function delay(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve) => {\n        if (signal?.aborted) {\n            resolve();\n            return;\n        }\n\n        const done = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            signal?.removeEventListener('abort', done);\n            resolve();\n        };\n\n        const timeout = setTimeout(done, ms);\n        signal?.addEventListener('abort', done, { once: true });\n    });\n}\n\n/**\n * Delays execution until the specified duration elapses or the signal is aborted.\n *\n * Aborting the signal rejects the promise with the signal's abort reason.\n *\n * @param {number} ms - Delay duration in milliseconds\n * @param {AbortSignal} [signal] - Optional signal used to abort the delay\n *\n * @returns {Promise<void>} Resolves when the delay completes or rejects when the signal is aborted\n *\n * @example\n * ```typescript\n * import { delayOrThrow } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * setTimeout(() => controller.abort(), 1000);\n * await delayOrThrow(5000, controller.signal); // rejects after ~1s\n * ```\n */\nexport function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve, reject) => {\n        if (signal?.aborted) {\n            reject(signal.reason);\n            return;\n        }\n\n        const onAbort = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            reject(signal!.reason);\n        };\n\n        const timeout = setTimeout(\n            () => {\n                signal?.removeEventListener('abort', onAbort);\n                resolve();\n            },\n            ms,\n        );\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,MAAM,IAAY,QAAqC;CACnE,OAAO,IAAI,SAAS,YAAY;EAC5B,IAAI,QAAQ,SAAS;GACjB,QAAQ;GACR;EACJ;EAEA,MAAM,aAAa;GAEf,aAAa,OAAO;GACpB,QAAQ,oBAAoB,SAAS,IAAI;GACzC,QAAQ;EACZ;EAEA,MAAM,UAAU,WAAW,MAAM,EAAE;EACnC,QAAQ,iBAAiB,SAAS,MAAM,EAAE,MAAM,KAAK,CAAC;CAC1D,CAAC;AACL;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,aAAa,IAAY,QAAqC;CAC1E,OAAO,IAAI,SAAS,SAAS,WAAW;EACpC,IAAI,QAAQ,SAAS;GACjB,OAAO,OAAO,MAAM;GACpB;EACJ;EAEA,MAAM,gBAAgB;GAElB,aAAa,OAAO;GACpB,OAAO,OAAQ,MAAM;EACzB;EAEA,MAAM,UAAU,iBACN;GACF,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACZ,GACA,EACJ;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC7D,CAAC;AACL"}
+{"version":3,"file":"time.js","names":[],"sources":["../src/time.ts"],"sourcesContent":["/**\n * Waits until a duration elapses or cancellation occurs without rejecting on cancellation.\n *\n * @remarks\n * The promise resolves without a value when the timer completes or the signal aborts.\n * An already aborted signal resolves immediately; completion removes the abort listener and clears the timer.\n *\n * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.\n * @param signal - The signal that ends the wait early.\n *\n * @example\n *\n * ```ts\n * import { delay } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * controller.abort();\n * await delay(5000, controller.signal);\n * ```\n */\nexport function delay(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve) => {\n        if (signal?.aborted) {\n            resolve();\n            return;\n        }\n\n        const done = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            signal?.removeEventListener('abort', done);\n            resolve();\n        };\n\n        const timeout = setTimeout(done, ms);\n        signal?.addEventListener('abort', done, { once: true });\n    });\n}\n\n/**\n * Waits until a duration elapses and rejects on cancellation.\n *\n * @remarks\n * The promise resolves without a value when the timer completes and rejects with `signal.reason` if aborted.\n * An already aborted signal rejects immediately. Aborting clears the timer; timer completion removes the listener.\n *\n * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.\n * @param signal - The signal that cancels the wait.\n *\n * @example\n *\n * ```ts\n * import { delayOrThrow } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * controller.abort(new Error('Canceled'));\n * try {\n *     await delayOrThrow(5000, controller.signal);\n * } catch (error) {\n *     console.error(error);\n * }\n * ```\n */\nexport function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve, reject) => {\n        if (signal?.aborted) {\n            reject(signal.reason);\n            return;\n        }\n\n        const onAbort = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            reject(signal!.reason);\n        };\n\n        const timeout = setTimeout(\n            () => {\n                signal?.removeEventListener('abort', onAbort);\n                resolve();\n            },\n            ms,\n        );\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,MAAM,IAAY,QAAqC;CACnE,OAAO,IAAI,SAAS,YAAY;EAC5B,IAAI,QAAQ,SAAS;GACjB,QAAQ;GACR;EACJ;EAEA,MAAM,aAAa;GAEf,aAAa,OAAO;GACpB,QAAQ,oBAAoB,SAAS,IAAI;GACzC,QAAQ;EACZ;EAEA,MAAM,UAAU,WAAW,MAAM,EAAE;EACnC,QAAQ,iBAAiB,SAAS,MAAM,EAAE,MAAM,KAAK,CAAC;CAC1D,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAa,IAAY,QAAqC;CAC1E,OAAO,IAAI,SAAS,SAAS,WAAW;EACpC,IAAI,QAAQ,SAAS;GACjB,OAAO,OAAO,MAAM;GACpB;EACJ;EAEA,MAAM,gBAAgB;GAElB,aAAa,OAAO;GACpB,OAAO,OAAQ,MAAM;EACzB;EAEA,MAAM,UAAU,iBACN;GACF,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACZ,GACA,EACJ;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC7D,CAAC;AACL"}