umt 2.12.2 → 2.13.0

package/module/DataStructure/lruCache.js

@@ -0,0 +1,172 @@
+/**
+ * A Least Recently Used (LRU) cache implementation
+ * using a Map for O(1) get/set operations.
+ *
+ * When the cache exceeds its capacity, the least recently used
+ * entry is evicted.
+ *
+ * ## Features
+ * - **get(key)**: Retrieve a value (moves it to most recently used)
+ * - **set(key, value)**: Insert or update a value
+ * - **has(key)**: Check if a key exists
+ * - **delete(key)**: Remove a specific entry
+ * - **clear()**: Remove all entries
+ * - **size**: Get the number of entries
+ *
+ * ## Time Complexity
+ * - get: O(1)
+ * - set: O(1)
+ * - has: O(1)
+ * - delete: O(1)
+ *
+ * @example
+ * ```typescript
+ * const cache = new LRUCache<string, number>(3);
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);
+ *
+ * cache.get("a"); // 1 (moves "a" to most recently used)
+ * cache.set("d", 4); // evicts "b" (least recently used)
+ *
+ * cache.has("b"); // false
+ * cache.get("a"); // 1
+ * ```
+ *
+ * @template K - The type of cache keys
+ * @template V - The type of cache values
+ */
+export class LRUCache {
+    capacity;
+    map = new Map();
+    /**
+     * Creates a new LRUCache instance.
+     * @param capacity - The maximum number of entries the cache can hold
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(100);
+     * ```
+     */
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    /**
+     * Returns the number of entries in the cache.
+     * @returns The current number of cached entries
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(10);
+     * cache.set("a", 1);
+     * console.log(cache.size); // 1
+     * ```
+     */
+    get size() {
+        return this.map.size;
+    }
+    /**
+     * Retrieves a value by key and marks it as most recently used.
+     * @param key - The key to look up
+     * @returns The value if found, or undefined if not in cache
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(10);
+     * cache.set("a", 1);
+     * cache.get("a"); // 1
+     * cache.get("b"); // undefined
+     * ```
+     */
+    get(key) {
+        const value = this.map.get(key);
+        if (value === undefined && !this.map.has(key)) {
+            return undefined;
+        }
+        // Refresh key: delete and re-insert
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+    }
+    /**
+     * Inserts or updates a key-value pair.
+     * If the cache is at capacity, the least recently used entry is evicted.
+     * @param key - The key to set
+     * @param value - The value to associate with the key
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(2);
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.set("c", 3); // evicts "a"
+     * ```
+     */
+    set(key, value) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        else if (this.map.size >= this.capacity) {
+            this.evict();
+        }
+        this.map.set(key, value);
+    }
+    /**
+     * Checks whether a key exists in the cache.
+     * Does not affect the recently-used order.
+     * @param key - The key to check
+     * @returns True if the key exists in the cache
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(10);
+     * cache.set("a", 1);
+     * cache.has("a"); // true
+     * cache.has("b"); // false
+     * ```
+     */
+    has(key) {
+        return this.map.has(key);
+    }
+    /**
+     * Removes an entry from the cache by key.
+     * @param key - The key to remove
+     * @returns True if the entry was found and removed
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(10);
+     * cache.set("a", 1);
+     * cache.delete("a"); // true
+     * cache.delete("b"); // false
+     * ```
+     */
+    delete(key) {
+        return this.map.delete(key);
+    }
+    /**
+     * Removes all entries from the cache.
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>(10);
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * console.log(cache.size); // 0
+     * ```
+     */
+    clear() {
+        this.map.clear();
+    }
+    /**
+     * Evicts the least recently used entry (first inserted).
+     */
+    evict() {
+        const iterator = this.map.keys().next();
+        if (!iterator.done) {
+            this.map.delete(iterator.value);
+        }
+    }
+}
+//# sourceMappingURL=lruCache.js.map

package/module/DataStructure/lruCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lruCache.js","sourceRoot":"","sources":["../../src/DataStructure/lruCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,OAAO,QAAQ;IACX,QAAQ,CAAS;IACjB,GAAG,GAAG,IAAI,GAAG,EAAQ,CAAC;IAE9B;;;;;;;;OAQG;IACH,YAAY,QAAgB;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;OAUG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAM;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9C,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,oCAAoC;QACpC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAU,CAAC,CAAC;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,GAAM,EAAE,KAAQ;QAClB,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACvB,CAAC;aAAM,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1C,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,GAAM;QACR,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,GAAM;QACX,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK;QACH,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;IAED;;OAEG;IACK,KAAK;QACX,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;CACF"}

package/module/DataStructure/ttlCache.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Configuration options for TTLCache.
+ */
+export interface TTLCacheOptions {
+    /** Default time-to-live in milliseconds for cache entries */
+    defaultTTL: number;
+    /** Optional maximum number of entries */
+    maxSize?: number;
+}
+/**
+ * A time-to-live (TTL) cache that automatically expires entries
+ * after a configured duration.
+ *
+ * Uses lazy deletion: expired entries are only removed
+ * when accessed via get() or has().
+ *
+ * ## Features
+ * - **get(key)**: Retrieve a value (returns undefined if expired)
+ * - **set(key, value, ttl?)**: Insert with optional per-entry TTL
+ * - **has(key)**: Check if a non-expired key exists
+ * - **delete(key)**: Remove a specific entry
+ * - **clear()**: Remove all entries
+ * - **size**: Get the number of entries (including expired)
+ *
+ * @example
+ * ```typescript
+ * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+ * cache.set("a", 1);
+ * cache.get("a"); // 1
+ *
+ * // After 5 seconds...
+ * cache.get("a"); // undefined (expired)
+ * ```
+ *
+ * @template K - The type of cache keys
+ * @template V - The type of cache values
+ */
+export declare class TTLCache<K, V> {
+    private defaultTTL;
+    private maxSize;
+    private map;
+    /**
+     * Creates a new TTLCache instance.
+     * @param options - Configuration options for the cache
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({
+     *   defaultTTL: 60000,
+     *   maxSize: 1000,
+     * });
+     * ```
+     */
+    constructor(options: TTLCacheOptions);
+    /**
+     * Returns the number of entries in the cache
+     * (including potentially expired entries).
+     * @returns The current number of entries
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * console.log(cache.size); // 1
+     * ```
+     */
+    get size(): number;
+    /**
+     * Retrieves a value by key. Returns undefined if the key
+     * does not exist or has expired.
+     * @param key - The key to look up
+     * @returns The value if found and not expired, or undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.get("a"); // 1
+     * ```
+     */
+    get(key: K): V | undefined;
+    /**
+     * Inserts or updates a key-value pair with an optional TTL override.
+     * If maxSize is configured and the cache is full, the oldest entry
+     * is removed.
+     * @param key - The key to set
+     * @param value - The value to cache
+     * @param ttl - Optional TTL in milliseconds (overrides defaultTTL)
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.set("b", 2, 10000); // custom 10s TTL
+     * ```
+     */
+    set(key: K, value: V, ttl?: number): void;
+    /**
+     * Checks whether a non-expired key exists in the cache.
+     * Removes the entry if it has expired.
+     * @param key - The key to check
+     * @returns True if the key exists and has not expired
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.has("a"); // true
+     * cache.has("b"); // false
+     * ```
+     */
+    has(key: K): boolean;
+    /**
+     * Removes an entry from the cache by key.
+     * @param key - The key to remove
+     * @returns True if the entry was found and removed
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.delete("a"); // true
+     * cache.delete("b"); // false
+     * ```
+     */
+    delete(key: K): boolean;
+    /**
+     * Removes all entries from the cache.
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.clear();
+     * console.log(cache.size); // 0
+     * ```
+     */
+    clear(): void;
+}

package/module/DataStructure/ttlCache.js

@@ -0,0 +1,172 @@
+/**
+ * A time-to-live (TTL) cache that automatically expires entries
+ * after a configured duration.
+ *
+ * Uses lazy deletion: expired entries are only removed
+ * when accessed via get() or has().
+ *
+ * ## Features
+ * - **get(key)**: Retrieve a value (returns undefined if expired)
+ * - **set(key, value, ttl?)**: Insert with optional per-entry TTL
+ * - **has(key)**: Check if a non-expired key exists
+ * - **delete(key)**: Remove a specific entry
+ * - **clear()**: Remove all entries
+ * - **size**: Get the number of entries (including expired)
+ *
+ * @example
+ * ```typescript
+ * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+ * cache.set("a", 1);
+ * cache.get("a"); // 1
+ *
+ * // After 5 seconds...
+ * cache.get("a"); // undefined (expired)
+ * ```
+ *
+ * @template K - The type of cache keys
+ * @template V - The type of cache values
+ */
+export class TTLCache {
+    defaultTTL;
+    maxSize;
+    map = new Map();
+    /**
+     * Creates a new TTLCache instance.
+     * @param options - Configuration options for the cache
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({
+     *   defaultTTL: 60000,
+     *   maxSize: 1000,
+     * });
+     * ```
+     */
+    constructor(options) {
+        this.defaultTTL = options.defaultTTL;
+        this.maxSize = options.maxSize;
+    }
+    /**
+     * Returns the number of entries in the cache
+     * (including potentially expired entries).
+     * @returns The current number of entries
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * console.log(cache.size); // 1
+     * ```
+     */
+    get size() {
+        return this.map.size;
+    }
+    /**
+     * Retrieves a value by key. Returns undefined if the key
+     * does not exist or has expired.
+     * @param key - The key to look up
+     * @returns The value if found and not expired, or undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.get("a"); // 1
+     * ```
+     */
+    get(key) {
+        const entry = this.map.get(key);
+        if (entry === undefined) {
+            return;
+        }
+        if (Date.now() >= entry.expiresAt) {
+            this.map.delete(key);
+            return;
+        }
+        return entry.value;
+    }
+    /**
+     * Inserts or updates a key-value pair with an optional TTL override.
+     * If maxSize is configured and the cache is full, the oldest entry
+     * is removed.
+     * @param key - The key to set
+     * @param value - The value to cache
+     * @param ttl - Optional TTL in milliseconds (overrides defaultTTL)
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.set("b", 2, 10000); // custom 10s TTL
+     * ```
+     */
+    set(key, value, ttl) {
+        const effectiveTTL = ttl ?? this.defaultTTL;
+        const expiresAt = Date.now() + effectiveTTL;
+        if (this.map.has(key)) {
+            this.map.set(key, { value, expiresAt });
+            return;
+        }
+        if (this.maxSize !== undefined && this.map.size >= this.maxSize) {
+            const firstKey = this.map.keys().next().value;
+            this.map.delete(firstKey);
+        }
+        this.map.set(key, { value, expiresAt });
+    }
+    /**
+     * Checks whether a non-expired key exists in the cache.
+     * Removes the entry if it has expired.
+     * @param key - The key to check
+     * @returns True if the key exists and has not expired
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.has("a"); // true
+     * cache.has("b"); // false
+     * ```
+     */
+    has(key) {
+        const entry = this.map.get(key);
+        if (entry === undefined) {
+            return false;
+        }
+        if (Date.now() >= entry.expiresAt) {
+            this.map.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Removes an entry from the cache by key.
+     * @param key - The key to remove
+     * @returns True if the entry was found and removed
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.delete("a"); // true
+     * cache.delete("b"); // false
+     * ```
+     */
+    delete(key) {
+        return this.map.delete(key);
+    }
+    /**
+     * Removes all entries from the cache.
+     *
+     * @example
+     * ```typescript
+     * const cache = new TTLCache<string, number>({ defaultTTL: 5000 });
+     * cache.set("a", 1);
+     * cache.clear();
+     * console.log(cache.size); // 0
+     * ```
+     */
+    clear() {
+        this.map.clear();
+    }
+}
+//# sourceMappingURL=ttlCache.js.map

package/module/DataStructure/ttlCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttlCache.js","sourceRoot":"","sources":["../../src/DataStructure/ttlCache.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,QAAQ;IACX,UAAU,CAAS;IACnB,OAAO,CAAqB;IAC5B,GAAG,GAAG,IAAI,GAAG,EAAsC,CAAC;IAE5D;;;;;;;;;;;OAWG;IACH,YAAY,OAAwB;QAClC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IACjC,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAM;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAClC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACrB,OAAO;QACT,CAAC;QACD,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,GAAM,EAAE,KAAQ,EAAE,GAAY;QAChC,MAAM,YAAY,GAAG,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC;QAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC;QAE5C,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;YACxC,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAU,CAAC;YACnD,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,GAAM;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAClC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACrB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,GAAM;QACX,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK;QACH,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;CACF"}

package/module/Error/flatMapResult.d.ts

@@ -0,0 +1,23 @@
+import type { Result } from "../Error/safeExecute";
+/**
+ * Transforms the value inside a successful Result using a function
+ * that itself returns a Result. If the original Result is an error,
+ * it is returned unchanged.
+ *
+ * @param result - The Result to transform.
+ * @param function_ - The function to apply to the success value,
+ *   which returns a new Result.
+ * @returns The Result returned by the mapping function, or the original error.
+ *
+ * @example
+ * ```typescript
+ * const success = { type: "success", value: 5 } as const;
+ * flatMapResult(success, (n) =>
+ *   n > 0
+ *     ? { type: "success", value: n * 2 }
+ *     : { type: "error", error: new Error("negative") }
+ * );
+ * // { type: "success", value: 10 }
+ * ```
+ */
+export declare const flatMapResult: <V, E, U, F>(result: Result<V, E>, function_: (value: V) => Result<U, F>) => Result<U, E | F>;

package/module/Error/flatMapResult.js

@@ -0,0 +1,28 @@
+/**
+ * Transforms the value inside a successful Result using a function
+ * that itself returns a Result. If the original Result is an error,
+ * it is returned unchanged.
+ *
+ * @param result - The Result to transform.
+ * @param function_ - The function to apply to the success value,
+ *   which returns a new Result.
+ * @returns The Result returned by the mapping function, or the original error.
+ *
+ * @example
+ * ```typescript
+ * const success = { type: "success", value: 5 } as const;
+ * flatMapResult(success, (n) =>
+ *   n > 0
+ *     ? { type: "success", value: n * 2 }
+ *     : { type: "error", error: new Error("negative") }
+ * );
+ * // { type: "success", value: 10 }
+ * ```
+ */
+export const flatMapResult = (result, function_) => {
+    if (result.type === "success") {
+        return function_(result.value);
+    }
+    return result;
+};
+//# sourceMappingURL=flatMapResult.js.map

package/module/Error/flatMapResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatMapResult.js","sourceRoot":"","sources":["../../src/Error/flatMapResult.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,MAAoB,EACpB,SAAqC,EACnB,EAAE;IACpB,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/module/Error/index.d.ts

@@ -1,2 +1,5 @@
+export * from "./flatMapResult";
+export * from "./mapResult";
+export * from "./matchResult";
 export * from "./retry";
 export * from "./safeExecute";

package/module/Error/index.js

@@ -1,3 +1,6 @@
+export * from "./flatMapResult";
+export * from "./mapResult";
+export * from "./matchResult";
 export * from "./retry";
 export * from "./safeExecute";
 //# sourceMappingURL=index.js.map

package/module/Error/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Error/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Error/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC"}

package/module/Error/mapResult.d.ts

@@ -0,0 +1,21 @@
+import { type Result } from "../Error/safeExecute";
+/**
+ * Transforms the value inside a successful Result using the provided
+ * mapping function. If the Result is an error, it is returned unchanged.
+ *
+ * @param result - The Result to transform.
+ * @param function_ - The function to apply to the success value.
+ * @returns A new Result with the transformed value, or the original error.
+ *
+ * @example
+ * ```typescript
+ * const success = { type: "success", value: 5 } as const;
+ * mapResult(success, (n) => n * 2);
+ * // { type: "success", value: 10 }
+ *
+ * const error = { type: "error", error: new Error("fail") } as const;
+ * mapResult(error, (n) => n * 2);
+ * // { type: "error", error: Error("fail") }
+ * ```
+ */
+export declare const mapResult: <V, E, U>(result: Result<V, E>, function_: (value: V) => U) => Result<U, E>;

package/module/Error/mapResult.js

@@ -0,0 +1,27 @@
+import { successFunction } from "../Error/safeExecute";
+/**
+ * Transforms the value inside a successful Result using the provided
+ * mapping function. If the Result is an error, it is returned unchanged.
+ *
+ * @param result - The Result to transform.
+ * @param function_ - The function to apply to the success value.
+ * @returns A new Result with the transformed value, or the original error.
+ *
+ * @example
+ * ```typescript
+ * const success = { type: "success", value: 5 } as const;
+ * mapResult(success, (n) => n * 2);
+ * // { type: "success", value: 10 }
+ *
+ * const error = { type: "error", error: new Error("fail") } as const;
+ * mapResult(error, (n) => n * 2);
+ * // { type: "error", error: Error("fail") }
+ * ```
+ */
+export const mapResult = (result, function_) => {
+    if (result.type === "success") {
+        return successFunction(function_(result.value));
+    }
+    return result;
+};
+//# sourceMappingURL=mapResult.js.map

package/module/Error/mapResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapResult.js","sourceRoot":"","sources":["../../src/Error/mapResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,MAAoB,EACpB,SAA0B,EACZ,EAAE;IAChB,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/module/Error/matchResult.d.ts

@@ -0,0 +1,25 @@
+import type { Result } from "../Error/safeExecute";
+/**
+ * Pattern-matches on a Result, applying the appropriate handler
+ * depending on whether the Result is a success or an error.
+ *
+ * @param result - The Result to match on.
+ * @param handlers - An object with onSuccess and onError callbacks.
+ * @param handlers.onSuccess - Called with the value if the Result is a success.
+ * @param handlers.onError - Called with the error if the Result is an error.
+ * @returns The return value of whichever handler is invoked.
+ *
+ * @example
+ * ```typescript
+ * const result = { type: "success", value: 42 } as const;
+ * matchResult(result, {
+ *   onSuccess: (v) => `Got ${v}`,
+ *   onError: (e) => `Failed: ${e}`,
+ * });
+ * // "Got 42"
+ * ```
+ */
+export declare const matchResult: <V, E, S, F>(result: Result<V, E>, handlers: {
+    onSuccess: (value: V) => S;
+    onError: (error: E) => F;
+}) => S | F;

package/module/Error/matchResult.js

@@ -0,0 +1,27 @@
+/**
+ * Pattern-matches on a Result, applying the appropriate handler
+ * depending on whether the Result is a success or an error.
+ *
+ * @param result - The Result to match on.
+ * @param handlers - An object with onSuccess and onError callbacks.
+ * @param handlers.onSuccess - Called with the value if the Result is a success.
+ * @param handlers.onError - Called with the error if the Result is an error.
+ * @returns The return value of whichever handler is invoked.
+ *
+ * @example
+ * ```typescript
+ * const result = { type: "success", value: 42 } as const;
+ * matchResult(result, {
+ *   onSuccess: (v) => `Got ${v}`,
+ *   onError: (e) => `Failed: ${e}`,
+ * });
+ * // "Got 42"
+ * ```
+ */
+export const matchResult = (result, handlers) => {
+    if (result.type === "success") {
+        return handlers.onSuccess(result.value);
+    }
+    return handlers.onError(result.error);
+};
+//# sourceMappingURL=matchResult.js.map

package/module/Error/matchResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchResult.js","sourceRoot":"","sources":["../../src/Error/matchResult.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,MAAoB,EACpB,QAGC,EACM,EAAE;IACT,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACxC,CAAC,CAAC"}