@nlozgachev/pipelined 0.62.0 → 0.64.0

package/dist/composition.cjs

@@ -277,9 +277,9 @@ var memoize = (f, options) => {
     const result = f(a);
     cache.set(key, result);
     if (maxSize !== void 0 && cache.size > maxSize) {
-      const firstKey = cache.keys().next().value;
-      if (firstKey !== void 0) {
-        cache.delete(firstKey);
+      for (const k of cache.keys()) {
+        cache.delete(k);
+        break;
       }
     }
     return result;
@@ -389,32 +389,151 @@ pipe.try = (f, onError) => (a) => {
 var import_node_util = require("util");
 
 // src/Types/Brand.ts
-var Brand;
-((Brand2) => {
-  Brand2.wrap = () => (value) => value;
-  Brand2.unwrap = (branded) => branded;
-})(Brand || (Brand = {}));
+var Brand = {
+  /**
+   * Returns a constructor that wraps a value of type T in brand K.
+   * The resulting function performs an unchecked cast — only use when the raw
+   * value is known to satisfy the brand's invariants.
+   *
+   * @example
+   * ```ts
+   * type PositiveNumber = Brand<"PositiveNumber", number>;
+   * const toPositiveNumber = Brand.wrap<"PositiveNumber", number>();
+   *
+   * const n: PositiveNumber = toPositiveNumber(42);
+   * ```
+   */
+  wrap: () => (value) => value,
+  /**
+   * Strips the brand and returns the underlying value.
+   * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
+   *
+   * @example
+   * ```ts
+   * type UserId = Brand<"UserId", string>;
+   * const toUserId = Brand.wrap<"UserId", string>();
+   * const userId: UserId = toUserId("user-123");
+   * const raw: string = Brand.unwrap(userId); // "user-123"
+   * ```
+   */
+  unwrap: (branded) => branded
+};
 
 // src/Types/Duration.ts
-var Duration;
-((Duration2) => {
-  const wrap = Brand.wrap();
-  Duration2.milliseconds = (ms) => wrap(ms);
-  Duration2.seconds = (s) => wrap(s * 1e3);
-  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
-  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
-  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
-  let to;
-  ((to2) => {
-    to2.milliseconds = (d) => Brand.unwrap(d);
-    to2.seconds = (d) => Brand.unwrap(d) / 1e3;
-    to2.minutes = (d) => Brand.unwrap(d) / (60 * 1e3);
-    to2.hours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
-    to2.days = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
-  })(to = Duration2.to || (Duration2.to = {}));
-  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
-  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
-})(Duration || (Duration = {}));
+var wrap = Brand.wrap();
+var Duration = {
+  /**
+   * Creates a Duration from milliseconds.
+   *
+   * @example
+   * ```ts
+   * Duration.milliseconds(500); // 500ms Duration
+   * ```
+   */
+  milliseconds: (ms) => wrap(ms),
+  /**
+   * Creates a Duration from seconds.
+   *
+   * @example
+   * ```ts
+   * Duration.seconds(2); // 2000ms Duration
+   * ```
+   */
+  seconds: (s) => wrap(s * 1e3),
+  /**
+   * Creates a Duration from minutes.
+   *
+   * @example
+   * ```ts
+   * Duration.minutes(5); // 300000ms Duration
+   * ```
+   */
+  minutes: (m) => wrap(m * 60 * 1e3),
+  /**
+   * Creates a Duration from hours.
+   *
+   * @example
+   * ```ts
+   * Duration.hours(1); // 3600000ms Duration
+   * ```
+   */
+  hours: (h) => wrap(h * 60 * 60 * 1e3),
+  /**
+   * Creates a Duration from days.
+   *
+   * @example
+   * ```ts
+   * Duration.days(1); // 86400000ms Duration
+   * ```
+   */
+  days: (d) => wrap(d * 24 * 60 * 60 * 1e3),
+  // --- to ---
+  to: {
+    /**
+     * Converts a Duration back to raw milliseconds.
+     *
+     * @example
+     * ```ts
+     * Duration.to.milliseconds(Duration.seconds(2)); // 2000
+     * ```
+     */
+    milliseconds: (d) => Brand.unwrap(d),
+    /**
+     * Converts a Duration to seconds.
+     *
+     * @example
+     * ```ts
+     * Duration.to.seconds(Duration.milliseconds(2500)); // 2.5
+     * ```
+     */
+    seconds: (d) => Brand.unwrap(d) / 1e3,
+    /**
+     * Converts a Duration to minutes.
+     *
+     * @example
+     * ```ts
+     * Duration.to.minutes(Duration.seconds(120)); // 2
+     * ```
+     */
+    minutes: (d) => Brand.unwrap(d) / (60 * 1e3),
+    /**
+     * Converts a Duration to hours.
+     *
+     * @example
+     * ```ts
+     * Duration.to.hours(Duration.minutes(90)); // 1.5
+     * ```
+     */
+    hours: (d) => Brand.unwrap(d) / (60 * 60 * 1e3),
+    /**
+     * Converts a Duration to days.
+     *
+     * @example
+     * ```ts
+     * Duration.to.days(Duration.hours(36)); // 1.5
+     * ```
+     */
+    days: (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3)
+  },
+  /**
+   * Adds two Durations together.
+   *
+   * @example
+   * ```ts
+   * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
+   * ```
+   */
+  add: (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other)),
+  /**
+   * Subtracts the other Duration from this one.
+   *
+   * @example
+   * ```ts
+   * pipe(Duration.seconds(1), Duration.subtract(Duration.milliseconds(500))); // 500ms
+   * ```
+   */
+  subtract: (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other))
+};
 
 // src/Composition/tap.ts
 function tap(f) {
@@ -423,83 +542,85 @@ function tap(f) {
     return a;
   };
 }
-((tap2) => {
-  tap2.log = (options) => (a) => {
-    const logger = options?.logger ?? console.log;
-    const formatter = options?.formatter ?? ((val) => {
-      try {
-        return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
-      } catch {
-        return String(val);
-      }
-    });
-    const formatted = formatter(a);
-    if (options?.label !== void 0) {
-      logger(`[${options.label}]: ${formatted}`);
-    } else {
-      logger(formatted);
-    }
-    return a;
-  };
-  tap2.inspect = (options) => (a) => {
-    const label = options?.label;
-    const depth = options?.depth ?? null;
-    const colors = options?.colors ?? true;
-    let formatted;
-    if (typeof import_node_util.inspect === "function") {
-      formatted = (0, import_node_util.inspect)(a, { depth, colors });
-    } else {
-      try {
-        formatted = JSON.stringify(a, null, 2);
-      } catch {
-        formatted = String(a);
-      }
+var log = (options) => (a) => {
+  const logger = options?.logger ?? console.log;
+  const formatter = options?.formatter ?? ((val) => {
+    try {
+      return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
+    } catch {
+      return String(val);
+    }
+  });
+  const formatted = formatter(a);
+  if (options?.label !== void 0) {
+    logger(`[${options.label}]: ${formatted}`);
+  } else {
+    logger(formatted);
+  }
+  return a;
+};
+var inspect = (options) => (a) => {
+  const label = options?.label;
+  const depth = options?.depth ?? null;
+  const colors = options?.colors ?? true;
+  let formatted;
+  if (typeof import_node_util.inspect === "function") {
+    formatted = (0, import_node_util.inspect)(a, { depth, colors });
+  } else {
+    try {
+      formatted = JSON.stringify(a, null, 2);
+    } catch {
+      formatted = String(a);
     }
-    if (label !== void 0) {
-      console.log(`[${label}]: ${formatted}`);
+  }
+  if (label !== void 0) {
+    console.log(`[${label}]: ${formatted}`);
+  } else {
+    console.log(formatted);
+  }
+  return a;
+};
+var async3 = (fn, options) => (a) => {
+  const onError = options?.onError ?? console.error;
+  Promise.resolve(fn(a)).catch((err) => {
+    onError(err);
+  });
+  return a;
+};
+var time = (fn, config) => (a) => {
+  const start = performance.now();
+  const triggerFinish = (duration) => {
+    if (config.label !== void 0) {
+      console.log(`[${config.label}]: ${Duration.to.milliseconds(duration)}ms`);
     } else {
-      console.log(formatted);
+      config.onFinish(duration);
     }
-    return a;
-  };
-  tap2.async = (fn, options) => (a) => {
-    const onError = options?.onError ?? console.error;
-    Promise.resolve(fn(a)).catch((err) => {
-      onError(err);
-    });
-    return a;
   };
-  tap2.time = (fn, config) => (a) => {
-    const start = performance.now();
-    const triggerFinish = (duration) => {
-      if (config.label !== void 0) {
-        console.log(`[${config.label}]: ${Duration.to.milliseconds(duration)}ms`);
-      } else {
-        config.onFinish(duration);
-      }
-    };
-    try {
-      const res = fn(a);
-      if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
-        res.then(() => {
-          const duration = Duration.milliseconds(performance.now() - start);
-          triggerFinish(duration);
-        }, () => {
-          const duration = Duration.milliseconds(performance.now() - start);
-          triggerFinish(duration);
-        });
-      } else {
+  try {
+    const res = fn(a);
+    if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
+      res.then(() => {
         const duration = Duration.milliseconds(performance.now() - start);
         triggerFinish(duration);
-      }
-    } catch (err) {
+      }, () => {
+        const duration = Duration.milliseconds(performance.now() - start);
+        triggerFinish(duration);
+      });
+    } else {
       const duration = Duration.milliseconds(performance.now() - start);
       triggerFinish(duration);
-      throw err;
     }
-    return a;
-  };
-})(tap || (tap = {}));
+  } catch (err) {
+    const duration = Duration.milliseconds(performance.now() - start);
+    triggerFinish(duration);
+    throw err;
+  }
+  return a;
+};
+tap.log = log;
+tap.inspect = inspect;
+tap.async = async3;
+tap.time = time;
 
 // src/Composition/uncurry.ts
 function uncurry(f) {

package/dist/composition.d.cts

@@ -1,5 +1,5 @@
-import { A as Awaitable, T as Thenable } from './InternalTypes-DuK_XpTi.cjs';
-import { D as Duration } from './Duration-B8joKzro.cjs';
+import { A as Awaitable, T as Thenable } from './InternalTypes-GFn4RTwD.cjs';
+import { D as Duration } from './Duration-DeyxG6VQ.cjs';
 
 /**
  * Composes functions from right to left, returning a new function.
@@ -829,6 +829,12 @@ interface pipe {
  * @see {@link Maybe.tap} for Maybe-specific tap that only runs on Some
  */
 declare function tap<A>(f: (a: A) => void): (a: A) => A;
+declare namespace tap {
+    var log: <A>(options?: tap.LogOptions<A>) => (a: A) => A;
+    var inspect: <A>(options?: tap.InspectOptions) => (a: A) => A;
+    var async: <A>(fn: (a: A) => Thenable<unknown>, options?: tap.AsyncOptions) => (a: A) => A;
+    var time: <A>(fn: (a: A) => unknown, config: tap.TimeConfig) => (a: A) => A;
+}
 declare namespace tap {
     /**
      * Configuration options for {@link tap.log}.
@@ -888,80 +894,6 @@ declare namespace tap {
         onFinish: (duration: Duration) => void;
         label?: never;
     };
-    /**
-     * Logs the piped value to the console or a custom logger, returning the value unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   42,
-     *   tap.log(), // logs: 42
-     *   tap.log({ label: "Count" }) // logs: [Count]: 42
-     * );
-     * ```
-     */
-    const log: <A>(options?: LogOptions<A>) => (a: A) => A;
-    /**
-     * Performs a deep structured inspect formatting on the piped value, returning it unchanged.
-     * In Node.js environments, this utilizes Node's `node:util` `inspect` utility.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   { user: { name: "Alice", details: { age: 30 } } },
-     *   tap.inspect({ label: "User Object", depth: 2 })
-     * );
-     * ```
-     */
-    const inspect: <A>(options?: InspectOptions) => (a: A) => A;
-    /**
-     * Triggers a fire-and-forget asynchronous side effect in the background,
-     * returning the piped value immediately and synchronously.
-     * Any errors thrown by the async function are caught and forwarded to `onError`.
-     *
-     * @example
-     * ```ts
-     * const user = { id: 1 };
-     * const saveToDatabase = async (u: typeof user) => {};
-     * const logError = (err: unknown) => console.error(err);
-     *
-     * pipe(
-     *   user,
-     *   tap.async(async (u) => {
-     *     await saveToDatabase(u);
-     *   }, { onError: (err) => logError(err) })
-     * );
-     * ```
-     */
-    const async: <A>(fn: (a: A) => Thenable<unknown>, options?: AsyncOptions) => (a: A) => A;
-    /**
-     * Runs a function and measures its execution duration, returning the value unchanged.
-     * Supports both synchronous and asynchronous functions. If the timed function returns
-     * a Promise, duration measurement resolves asynchronously upon resolution/rejection.
-     *
-     * @example
-     * ```ts
-     * const data = [1, 2, 3];
-     * const processData = (d: typeof data) => d.map(n => n * 2);
-     * const fetchData = async (d: typeof data) => d.length;
-     * const metrics = { histogram: (name: string, ms: number) => {} };
-     *
-     * // Time a synchronous computation
-     * pipe(
-     *   data,
-     *   tap.time(processData, { label: "sync-process" })
-     * );
-     *
-     * // Time an asynchronous fetch with custom metrics callback
-     * pipe(
-     *   data,
-     *   tap.time(fetchData, {
-     *     onFinish: (dur) => metrics.histogram("api.time", Duration.to.milliseconds(dur))
-     *   })
-     * );
-     * ```
-     */
-    const time: <A>(fn: (a: A) => unknown, config: TimeConfig) => (a: A) => A;
 }
 
 /**

package/dist/composition.d.ts

@@ -1,5 +1,5 @@
-import { A as Awaitable, T as Thenable } from './InternalTypes-LdhLQx3N.js';
-import { D as Duration } from './Duration-B8joKzro.js';
+import { A as Awaitable, T as Thenable } from './InternalTypes-CCXa8Kvr.js';
+import { D as Duration } from './Duration-DeyxG6VQ.js';
 
 /**
  * Composes functions from right to left, returning a new function.
@@ -829,6 +829,12 @@ interface pipe {
  * @see {@link Maybe.tap} for Maybe-specific tap that only runs on Some
  */
 declare function tap<A>(f: (a: A) => void): (a: A) => A;
+declare namespace tap {
+    var log: <A>(options?: tap.LogOptions<A>) => (a: A) => A;
+    var inspect: <A>(options?: tap.InspectOptions) => (a: A) => A;
+    var async: <A>(fn: (a: A) => Thenable<unknown>, options?: tap.AsyncOptions) => (a: A) => A;
+    var time: <A>(fn: (a: A) => unknown, config: tap.TimeConfig) => (a: A) => A;
+}
 declare namespace tap {
     /**
      * Configuration options for {@link tap.log}.
@@ -888,80 +894,6 @@ declare namespace tap {
         onFinish: (duration: Duration) => void;
         label?: never;
     };
-    /**
-     * Logs the piped value to the console or a custom logger, returning the value unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   42,
-     *   tap.log(), // logs: 42
-     *   tap.log({ label: "Count" }) // logs: [Count]: 42
-     * );
-     * ```
-     */
-    const log: <A>(options?: LogOptions<A>) => (a: A) => A;
-    /**
-     * Performs a deep structured inspect formatting on the piped value, returning it unchanged.
-     * In Node.js environments, this utilizes Node's `node:util` `inspect` utility.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   { user: { name: "Alice", details: { age: 30 } } },
-     *   tap.inspect({ label: "User Object", depth: 2 })
-     * );
-     * ```
-     */
-    const inspect: <A>(options?: InspectOptions) => (a: A) => A;
-    /**
-     * Triggers a fire-and-forget asynchronous side effect in the background,
-     * returning the piped value immediately and synchronously.
-     * Any errors thrown by the async function are caught and forwarded to `onError`.
-     *
-     * @example
-     * ```ts
-     * const user = { id: 1 };
-     * const saveToDatabase = async (u: typeof user) => {};
-     * const logError = (err: unknown) => console.error(err);
-     *
-     * pipe(
-     *   user,
-     *   tap.async(async (u) => {
-     *     await saveToDatabase(u);
-     *   }, { onError: (err) => logError(err) })
-     * );
-     * ```
-     */
-    const async: <A>(fn: (a: A) => Thenable<unknown>, options?: AsyncOptions) => (a: A) => A;
-    /**
-     * Runs a function and measures its execution duration, returning the value unchanged.
-     * Supports both synchronous and asynchronous functions. If the timed function returns
-     * a Promise, duration measurement resolves asynchronously upon resolution/rejection.
-     *
-     * @example
-     * ```ts
-     * const data = [1, 2, 3];
-     * const processData = (d: typeof data) => d.map(n => n * 2);
-     * const fetchData = async (d: typeof data) => d.length;
-     * const metrics = { histogram: (name: string, ms: number) => {} };
-     *
-     * // Time a synchronous computation
-     * pipe(
-     *   data,
-     *   tap.time(processData, { label: "sync-process" })
-     * );
-     *
-     * // Time an asynchronous fetch with custom metrics callback
-     * pipe(
-     *   data,
-     *   tap.time(fetchData, {
-     *     onFinish: (dur) => metrics.histogram("api.time", Duration.to.milliseconds(dur))
-     *   })
-     * );
-     * ```
-     */
-    const time: <A>(fn: (a: A) => unknown, config: TimeConfig) => (a: A) => A;
 }
 
 /**