umt 2.12.2 → 2.13.0

package/module/es5/Error/mapResult.js

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

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

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

package/module/es5/Error/safeExecute.d.ts

@@ -2,7 +2,7 @@
  * Represents a successful execution result containing a value
  * @template V The type of the success value
  */
-interface SuccessType<V> {
+export interface SuccessType<V> {
     type: "success";
     value: V;
 }
@@ -10,7 +10,7 @@ interface SuccessType<V> {
  * Represents an error result containing an error object
  * @template E The type of the error
  */
-interface ErrorType<E> {
+export interface ErrorType<E> {
     type: "error";
     error: E;
 }
@@ -20,6 +20,20 @@ interface ErrorType<E> {
  * @template E The type of the error
  */
 export type Result<V, E> = SuccessType<V> | ErrorType<E>;
+/**
+ * Creates an error result
+ * @template E The type of the error
+ * @param error The error object
+ * @returns An ErrorType containing the error
+ */
+export declare const errorFunction: <E>(error: E) => ErrorType<E>;
+/**
+ * Creates a success result
+ * @template V The type of the success value
+ * @param value The success value
+ * @returns A SuccessType containing the value
+ */
+export declare const successFunction: <V>(value: V) => SuccessType<V>;
 /**
  * Safely executes a callback function and returns a Result type
  * Catches any errors and wraps them in a Result type
@@ -29,4 +43,3 @@ export type Result<V, E> = SuccessType<V> | ErrorType<E>;
  * @returns A Result containing either the successful value or the caught error
  */
 export declare const safeExecute: <V, E = Error>(callback: () => V) => Result<V, E>;
-export {};

package/module/es5/Error/safeExecute.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.safeExecute = void 0;
+exports.successFunction = exports.safeExecute = exports.errorFunction = void 0;
 /**
  * Represents a successful execution result containing a value
  * @template V The type of the success value
@@ -26,7 +26,7 @@ exports.safeExecute = void 0;
  * @param error The error object
  * @returns An ErrorType containing the error
  */
-var errorFunction = function errorFunction(error) {
+var errorFunction = exports.errorFunction = function errorFunction(error) {
   return {
     type: "error",
     error: error
@@ -38,7 +38,7 @@ var errorFunction = function errorFunction(error) {
  * @param value The success value
  * @returns A SuccessType containing the value
  */
-var successFunction = function successFunction(value) {
+var successFunction = exports.successFunction = function successFunction(value) {
   return {
     type: "success",
     value: value

package/module/es5/Function/debounce.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Options for the debounce function.
+ */
+export interface DebounceOptions {
+    /** Whether to invoke on the leading edge of the timeout. */
+    leading?: boolean;
+    /** Whether to invoke on the trailing edge of the timeout. */
+    trailing?: boolean;
+}
+/**
+ * A debounced function with a cancel method.
+ */
+export interface DebouncedFunction<T extends (...arguments_: unknown[]) => unknown> {
+    (...arguments_: Parameters<T>): void;
+    /** Cancels any pending debounced invocation. */
+    cancel: () => void;
+}
+/**
+ * Creates a debounced version of the provided function that delays
+ * invoking it until after the specified wait time has elapsed since
+ * the last time the debounced function was called.
+ *
+ * @param function_ - The function to debounce.
+ * @param wait - The number of milliseconds to delay.
+ * @param options - Configuration for leading/trailing invocation.
+ * @param options.leading - If true, invoke on the leading edge.
+ * @param options.trailing - If true, invoke on the trailing edge (default).
+ * @returns The debounced function with a cancel method.
+ *
+ * @example
+ * ```typescript
+ * const debounced = debounce(() => console.log("called"), 300);
+ * debounced();
+ * debounced();
+ * debounced.cancel();
+ * ```
+ */
+export declare const debounce: <T extends (...arguments_: unknown[]) => unknown>(function_: T, wait: number, options?: DebounceOptions) => DebouncedFunction<T>;

package/module/es5/Function/debounce.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debounce = void 0;
+/**
+ * Options for the debounce function.
+ */
+
+/**
+ * A debounced function with a cancel method.
+ */
+
+/**
+ * Creates a debounced version of the provided function that delays
+ * invoking it until after the specified wait time has elapsed since
+ * the last time the debounced function was called.
+ *
+ * @param function_ - The function to debounce.
+ * @param wait - The number of milliseconds to delay.
+ * @param options - Configuration for leading/trailing invocation.
+ * @param options.leading - If true, invoke on the leading edge.
+ * @param options.trailing - If true, invoke on the trailing edge (default).
+ * @returns The debounced function with a cancel method.
+ *
+ * @example
+ * ```typescript
+ * const debounced = debounce(() => console.log("called"), 300);
+ * debounced();
+ * debounced();
+ * debounced.cancel();
+ * ```
+ */
+var debounce = exports.debounce = function debounce(function_, wait) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var _options$leading = options.leading,
+    leading = _options$leading === void 0 ? false : _options$leading,
+    _options$trailing = options.trailing,
+    trailing = _options$trailing === void 0 ? true : _options$trailing;
+  var timerId;
+  var lastArguments;
+  var thisReference = {
+    value: undefined
+  };
+  var lastCallTime = 0;
+  var _scheduleCheck = function scheduleCheck() {
+    timerId = setTimeout(function () {
+      var elapsed = Date.now() - lastCallTime;
+      var remaining = wait - elapsed;
+      if (remaining <= 0) {
+        timerId = undefined;
+        if (trailing && lastArguments !== undefined) {
+          function_.apply(thisReference.value, lastArguments);
+          lastArguments = undefined;
+        }
+      } else {
+        _scheduleCheck();
+      }
+    }, wait - (Date.now() - lastCallTime));
+  };
+  var debounced = function debounced() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    lastArguments = arguments_;
+    thisReference.value = this;
+    lastCallTime = Date.now();
+    var isFirstCall = timerId === undefined;
+    if (leading && isFirstCall) {
+      function_.apply(thisReference.value, lastArguments);
+      lastArguments = undefined;
+    }
+    if (isFirstCall) {
+      _scheduleCheck();
+    }
+  };
+  debounced.cancel = function () {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    timerId = undefined;
+    lastArguments = undefined;
+    thisReference.value = undefined;
+    lastCallTime = 0;
+  };
+  return debounced;
+};

package/module/es5/Function/index.d.ts

@@ -1 +1,5 @@
 export * from "./curry";
+export * from "./debounce";
+export * from "./memoize";
+export * from "./once";
+export * from "./throttle";

package/module/es5/Function/index.js

@@ -13,4 +13,48 @@ Object.keys(_curry).forEach(function (key) {
       return _curry[key];
     }
   });
+});
+var _debounce = require("./debounce");
+Object.keys(_debounce).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _debounce[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _debounce[key];
+    }
+  });
+});
+var _memoize = require("./memoize");
+Object.keys(_memoize).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _memoize[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _memoize[key];
+    }
+  });
+});
+var _once = require("./once");
+Object.keys(_once).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _once[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _once[key];
+    }
+  });
+});
+var _throttle = require("./throttle");
+Object.keys(_throttle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _throttle[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _throttle[key];
+    }
+  });
 });

package/module/es5/Function/memoize.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Options for the memoize function.
+ */
+export interface MemoizeOptions<K> {
+    /** Maximum number of entries to store in the cache. */
+    maxSize?: number;
+    /** Custom function to generate cache keys from arguments. */
+    resolver?: (...arguments_: unknown[]) => K;
+}
+/**
+ * A memoized function with an exposed cache.
+ */
+export interface MemoizedFunction<A extends unknown[], R, K = unknown> {
+    (...arguments_: A): R;
+    /** The underlying cache Map. */
+    cache: Map<K, R>;
+}
+/**
+ * Creates a memoized version of the provided function. Results are
+ * cached in a Map keyed by the first argument (or a custom resolver).
+ *
+ * @param function_ - The function to memoize.
+ * @param options - Configuration for cache behavior.
+ * @param options.maxSize - Maximum cache entries before evicting the oldest.
+ * @param options.resolver - Custom key resolver function.
+ * @returns The memoized function with an exposed cache property.
+ *
+ * @example
+ * ```typescript
+ * const memoized = memoize((n: number) => n * 2);
+ * memoized(5); // 10 (computed)
+ * memoized(5); // 10 (cached)
+ * memoized.cache.size; // 1
+ * ```
+ */
+export declare const memoize: <A extends unknown[], R, K = unknown>(function_: (...arguments_: A) => R, options?: MemoizeOptions<K>) => MemoizedFunction<A, R, K>;

package/module/es5/Function/memoize.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.memoize = void 0;
+/**
+ * Options for the memoize function.
+ */
+
+/**
+ * A memoized function with an exposed cache.
+ */
+
+/**
+ * Creates a memoized version of the provided function. Results are
+ * cached in a Map keyed by the first argument (or a custom resolver).
+ *
+ * @param function_ - The function to memoize.
+ * @param options - Configuration for cache behavior.
+ * @param options.maxSize - Maximum cache entries before evicting the oldest.
+ * @param options.resolver - Custom key resolver function.
+ * @returns The memoized function with an exposed cache property.
+ *
+ * @example
+ * ```typescript
+ * const memoized = memoize((n: number) => n * 2);
+ * memoized(5); // 10 (computed)
+ * memoized(5); // 10 (cached)
+ * memoized.cache.size; // 1
+ * ```
+ */
+var memoize = exports.memoize = function memoize(function_) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var maxSize = options.maxSize,
+    resolver = options.resolver;
+  var cache = new Map();
+  var memoized = resolver ? function () {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    var key = resolver.apply(void 0, arguments_);
+    var cached = cache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    var result = function_.apply(this, arguments_);
+    if (maxSize !== undefined && cache.size >= maxSize) {
+      var firstKey = cache.keys().next().value;
+      cache["delete"](firstKey);
+    }
+    cache.set(key, result);
+    return result;
+  } : function () {
+    for (var _len2 = arguments.length, arguments_ = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      arguments_[_key2] = arguments[_key2];
+    }
+    var key = arguments_[0];
+    var cached = cache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    var result = function_.apply(this, arguments_);
+    if (maxSize !== undefined && cache.size >= maxSize) {
+      var firstKey = cache.keys().next().value;
+      cache["delete"](firstKey);
+    }
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  return memoized;
+};

package/module/es5/Function/once.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a function that is restricted to be called only once.
+ * Subsequent calls return the result of the first invocation.
+ *
+ * @param function_ - The function to restrict.
+ * @returns A function that invokes the original only on its first call.
+ *
+ * @example
+ * ```typescript
+ * const initialize = once(() => {
+ *   console.log("initialized");
+ *   return 42;
+ * });
+ * initialize(); // logs "initialized", returns 42
+ * initialize(); // returns 42 (no log)
+ * ```
+ */
+export declare const once: <A extends unknown[], R>(function_: (...arguments_: A) => R) => ((...arguments_: A) => R);

package/module/es5/Function/once.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.once = void 0;
+/**
+ * Creates a function that is restricted to be called only once.
+ * Subsequent calls return the result of the first invocation.
+ *
+ * @param function_ - The function to restrict.
+ * @returns A function that invokes the original only on its first call.
+ *
+ * @example
+ * ```typescript
+ * const initialize = once(() => {
+ *   console.log("initialized");
+ *   return 42;
+ * });
+ * initialize(); // logs "initialized", returns 42
+ * initialize(); // returns 42 (no log)
+ * ```
+ */
+var once = exports.once = function once(function_) {
+  var called = false;
+  var result;
+  return function () {
+    if (!called) {
+      called = true;
+      for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+        arguments_[_key] = arguments[_key];
+      }
+      result = function_.apply(this, arguments_);
+    }
+    return result;
+  };
+};

package/module/es5/Function/throttle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A throttled function with a cancel method.
+ */
+export interface ThrottledFunction<T extends (...arguments_: unknown[]) => unknown> {
+    (...arguments_: Parameters<T>): void;
+    /** Cancels any pending throttled invocation. */
+    cancel: () => void;
+}
+/**
+ * Creates a throttled version of the provided function that only
+ * invokes it at most once per the specified wait period.
+ *
+ * @param function_ - The function to throttle.
+ * @param wait - The minimum time between invocations in milliseconds.
+ * @returns The throttled function with a cancel method.
+ *
+ * @example
+ * ```typescript
+ * const throttled = throttle(() => console.log("called"), 300);
+ * throttled();
+ * throttled();
+ * throttled.cancel();
+ * ```
+ */
+export declare const throttle: <T extends (...arguments_: unknown[]) => unknown>(function_: T, wait: number) => ThrottledFunction<T>;

package/module/es5/Function/throttle.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.throttle = void 0;
+/**
+ * A throttled function with a cancel method.
+ */
+
+/**
+ * Creates a throttled version of the provided function that only
+ * invokes it at most once per the specified wait period.
+ *
+ * @param function_ - The function to throttle.
+ * @param wait - The minimum time between invocations in milliseconds.
+ * @returns The throttled function with a cancel method.
+ *
+ * @example
+ * ```typescript
+ * const throttled = throttle(() => console.log("called"), 300);
+ * throttled();
+ * throttled();
+ * throttled.cancel();
+ * ```
+ */
+var throttle = exports.throttle = function throttle(function_, wait) {
+  var lastCallTime = 0;
+  var timerId;
+  var lastContext;
+  var invoke = function invoke() {
+    lastCallTime = Date.now();
+    var context = lastContext;
+    function_.apply(context.thisArg, context.arguments_);
+    lastContext = undefined;
+  };
+  var throttled = function throttled() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    lastContext = {
+      arguments_: arguments_,
+      thisArg: this
+    };
+    var elapsed = Date.now() - lastCallTime;
+    var remaining = wait - elapsed;
+    if (remaining <= 0) {
+      if (timerId !== undefined) {
+        clearTimeout(timerId);
+        timerId = undefined;
+      }
+      invoke();
+    } else {
+      timerId !== null && timerId !== void 0 ? timerId : timerId = setTimeout(function () {
+        timerId = undefined;
+        invoke();
+      }, remaining);
+    }
+  };
+  throttled.cancel = function () {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    timerId = undefined;
+    lastContext = undefined;
+    lastCallTime = 0;
+  };
+  return throttled;
+};

package/module/es5/IP/cidrToLong.d.ts

@@ -2,6 +2,5 @@
  * Converts CIDR notation to a subnet mask number
  * @param {number} cidr - CIDR notation (0-32)
  * @returns {number} Subnet mask as a 32-bit number
- * @throws {Error} If CIDR is not between 0 and 32
  */
 export declare const cidrToLong: (cidr: number) => number;

package/module/es5/IP/cidrToLong.js

@@ -8,11 +8,7 @@ exports.cidrToLong = void 0;
  * Converts CIDR notation to a subnet mask number
  * @param {number} cidr - CIDR notation (0-32)
  * @returns {number} Subnet mask as a 32-bit number
- * @throws {Error} If CIDR is not between 0 and 32
  */
 var cidrToLong = exports.cidrToLong = function cidrToLong(cidr) {
-  if (!Number.isInteger(cidr) || cidr < 0 || cidr > 32) {
-    throw new Error("CIDR must be an integer between 0 and 32");
-  }
   return Number.parseInt("1".repeat(cidr).padEnd(32, "0"), 2) >>> 0;
 };

package/module/es5/IP/cidrToSubnetMask.d.ts

@@ -2,6 +2,5 @@
  * Converts CIDR notation to a subnet mask
  * @param {number} cidr - CIDR notation (0-32)
  * @returns {string} Subnet mask in IPv4 format (e.g., "255.255.255.0")
- * @throws {Error} If CIDR is not between 0 and 32
  */
 export declare const cidrToSubnetMask: (cidr: number) => string;

package/module/es5/IP/cidrToSubnetMask.js

@@ -10,7 +10,6 @@ var _longToIp = require("./longToIp");
  * Converts CIDR notation to a subnet mask
  * @param {number} cidr - CIDR notation (0-32)
  * @returns {string} Subnet mask in IPv4 format (e.g., "255.255.255.0")
- * @throws {Error} If CIDR is not between 0 and 32
  */
 var cidrToSubnetMask = exports.cidrToSubnetMask = function cidrToSubnetMask(cidr) {
   return (0, _longToIp.longToIp)((0, _cidrToLong.cidrToLong)(cidr));

package/module/es5/IP/getNetworkAddress.d.ts

@@ -3,6 +3,5 @@
  * @param {string} ip - IPv4 address (e.g., "192.168.1.1")
  * @param {string} subnetMask - Subnet mask (e.g., "255.255.255.0")
  * @returns {number} Network address as a 32-bit unsigned integer
- * @throws {Error} If IP address or subnet mask is invalid
  */
 export declare const getNetworkAddress: (ip: string, subnetMask: string) => number;