umt 2.12.2 → 2.13.0

package/module/es5/DataStructure/lruCache.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LRUCache = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * 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
+ */
+var LRUCache = exports.LRUCache = /*#__PURE__*/function () {
+  /**
+   * 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);
+   * ```
+   */
+  function LRUCache(capacity) {
+    _classCallCheck(this, LRUCache);
+    _defineProperty(this, "map", new Map());
+    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
+   * ```
+   */
+  return _createClass(LRUCache, [{
+    key: "size",
+    get: function get() {
+      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
+     * ```
+     */
+  }, {
+    key: "get",
+    value: function get(key) {
+      var 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"
+     * ```
+     */
+  }, {
+    key: "set",
+    value: function 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
+     * ```
+     */
+  }, {
+    key: "has",
+    value: function 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
+     * ```
+     */
+  }, {
+    key: "delete",
+    value: function _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
+     * ```
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.map.clear();
+    }
+
+    /**
+     * Evicts the least recently used entry (first inserted).
+     */
+  }, {
+    key: "evict",
+    value: function evict() {
+      var iterator = this.map.keys().next();
+      if (!iterator.done) {
+        this.map["delete"](iterator.value);
+      }
+    }
+  }]);
+}();

package/module/es5/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/es5/DataStructure/ttlCache.js

@@ -0,0 +1,211 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TTLCache = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Configuration options for TTLCache.
+ */
+/**
+ * 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
+ */
+var TTLCache = exports.TTLCache = /*#__PURE__*/function () {
+  /**
+   * Creates a new TTLCache instance.
+   * @param options - Configuration options for the cache
+   *
+   * @example
+   * ```typescript
+   * const cache = new TTLCache<string, number>({
+   *   defaultTTL: 60000,
+   *   maxSize: 1000,
+   * });
+   * ```
+   */
+  function TTLCache(options) {
+    _classCallCheck(this, TTLCache);
+    _defineProperty(this, "map", new Map());
+    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
+   * ```
+   */
+  return _createClass(TTLCache, [{
+    key: "size",
+    get: function get() {
+      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
+     * ```
+     */
+  }, {
+    key: "get",
+    value: function get(key) {
+      var 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
+     * ```
+     */
+  }, {
+    key: "set",
+    value: function set(key, value, ttl) {
+      var effectiveTTL = ttl !== null && ttl !== void 0 ? ttl : this.defaultTTL;
+      var expiresAt = Date.now() + effectiveTTL;
+      if (this.map.has(key)) {
+        this.map.set(key, {
+          value: value,
+          expiresAt: expiresAt
+        });
+        return;
+      }
+      if (this.maxSize !== undefined && this.map.size >= this.maxSize) {
+        var firstKey = this.map.keys().next().value;
+        this.map["delete"](firstKey);
+      }
+      this.map.set(key, {
+        value: value,
+        expiresAt: 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
+     * ```
+     */
+  }, {
+    key: "has",
+    value: function has(key) {
+      var 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
+     * ```
+     */
+  }, {
+    key: "delete",
+    value: function _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
+     * ```
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.map.clear();
+    }
+  }]);
+}();

package/module/es5/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/es5/Error/flatMapResult.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flatMapResult = void 0;
+/**
+ * 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 }
+ * ```
+ */
+var flatMapResult = exports.flatMapResult = function flatMapResult(result, function_) {
+  if (result.type === "success") {
+    return function_(result.value);
+  }
+  return result;
+};

package/module/es5/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/es5/Error/index.js

@@ -3,6 +3,39 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _flatMapResult = require("./flatMapResult");
+Object.keys(_flatMapResult).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _flatMapResult[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _flatMapResult[key];
+    }
+  });
+});
+var _mapResult = require("./mapResult");
+Object.keys(_mapResult).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mapResult[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mapResult[key];
+    }
+  });
+});
+var _matchResult = require("./matchResult");
+Object.keys(_matchResult).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _matchResult[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _matchResult[key];
+    }
+  });
+});
 var _retry = require("./retry");
 Object.keys(_retry).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/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>;