umt 2.12.3 → 2.14.0

package/module/es5/DataStructure/lruCache.d.ts

@@ -0,0 +1,139 @@
+/**
+ * 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 declare class LRUCache<K, V> {
+    private capacity;
+    private 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: number);
+    /**
+     * 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(): number;
+    /**
+     * 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: K): V | undefined;
+    /**
+     * 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: K, value: V): void;
+    /**
+     * 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: 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 LRUCache<string, number>(10);
+     * 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 LRUCache<string, number>(10);
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * console.log(cache.size); // 0
+     * ```
+     */
+    clear(): void;
+    /**
+     * Evicts the least recently used entry (first inserted).
+     */
+    private evict;
+}

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();
+    }
+  }]);
+}();