@nlozgachev/pipelined 0.64.0 → 0.65.0

package/dist/types.cjs

@@ -1,228 +1,198 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/Types/Brand.ts
+const 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
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+//#endregion
+//#region src/Types/RetryPolicy.ts
+const RetryPolicy = {
+	/**
+	* Creates a RetryPolicy with a constant delay between retry attempts.
+	*
+	* @example
+	* ```ts
+	* const policy = RetryPolicy.constant({
+	*   attempts: 3,
+	*   delay: Duration.seconds(1),
+	* });
+	* ```
+	*/
+	constant: (options) => ({
+		attempts: Math.max(1, options.attempts),
+		getDelay: () => options.delay
+	}),
+	/**
+	* Creates a RetryPolicy with exponential backoff delays between attempts.
+	* An optional `factor` (default 2) controls the growth rate.
+	* An optional `jitter` (default false) adds randomized variance to prevent thundering herd problems.
+	*
+	* @example
+	* ```ts
+	* const policy = RetryPolicy.exponential({
+	*   attempts: 5,
+	*   initial: Duration.milliseconds(100),
+	*   factor: 2,
+	*   jitter: true,
+	* });
+	* ```
+	*/
+	exponential: (options) => {
+		const attempts = Math.max(1, options.attempts);
+		const initialMs = Duration.to.milliseconds(options.initial);
+		const factor = options.factor ?? 2;
+		const jitter = options.jitter ?? false;
+		return {
+			attempts,
+			getDelay: (attempt) => {
+				const rawMs = initialMs * factor ** Math.max(0, attempt - 1);
+				const finalMs = jitter ? Math.random() * rawMs : rawMs;
+				return Duration.milliseconds(finalMs);
+			}
+		};
+	}
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Types/index.ts
-var Types_exports = {};
-__export(Types_exports, {
-  Brand: () => Brand,
-  Duration: () => Duration,
-  RetryPolicy: () => RetryPolicy
-});
-module.exports = __toCommonJS(Types_exports);
-
-// src/Types/Brand.ts
-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
+//#endregion
+//#region src/Types/Duration.ts
+const wrap = Brand.wrap();
+const 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: {
+		/**
+		* 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) / 6e4,
+		/**
+		* Converts a Duration to hours.
+		*
+		* @example
+		* ```ts
+		* Duration.to.hours(Duration.minutes(90)); // 1.5
+		* ```
+		*/
+		hours: (d) => Brand.unwrap(d) / 36e5,
+		/**
+		* Converts a Duration to days.
+		*
+		* @example
+		* ```ts
+		* Duration.to.days(Duration.hours(36)); // 1.5
+		* ```
+		*/
+		days: (d) => Brand.unwrap(d) / 864e5
+	},
+	/**
+	* 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/Types/Duration.ts
-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/Types/RetryPolicy.ts
-var RetryPolicy = {
-  /**
-   * Creates a RetryPolicy with a constant delay between retry attempts.
-   *
-   * @example
-   * ```ts
-   * const policy = RetryPolicy.constant({
-   *   attempts: 3,
-   *   delay: Duration.seconds(1),
-   * });
-   * ```
-   */
-  constant: (options) => ({
-    attempts: Math.max(1, options.attempts),
-    getDelay: () => options.delay
-  }),
-  /**
-   * Creates a RetryPolicy with exponential backoff delays between attempts.
-   * An optional `factor` (default 2) controls the growth rate.
-   * An optional `jitter` (default false) adds randomized variance to prevent thundering herd problems.
-   *
-   * @example
-   * ```ts
-   * const policy = RetryPolicy.exponential({
-   *   attempts: 5,
-   *   initial: Duration.milliseconds(100),
-   *   factor: 2,
-   *   jitter: true,
-   * });
-   * ```
-   */
-  exponential: (options) => {
-    const attempts = Math.max(1, options.attempts);
-    const initialMs = Duration.to.milliseconds(options.initial);
-    const factor = options.factor ?? 2;
-    const jitter = options.jitter ?? false;
-    return {
-      attempts,
-      getDelay: (attempt) => {
-        const rawMs = initialMs * factor ** Math.max(0, attempt - 1);
-        const finalMs = jitter ? Math.random() * rawMs : rawMs;
-        return Duration.milliseconds(finalMs);
-      }
-    };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Brand,
-  Duration,
-  RetryPolicy
-});
+//#endregion
+exports.Brand = Brand;
+exports.Duration = Duration;
+exports.RetryPolicy = RetryPolicy;

package/dist/types.d.cts

@@ -1,58 +1,2 @@
-import { D as Duration } from './Duration-DeyxG6VQ.cjs';
-export { B as Brand } from './Duration-DeyxG6VQ.cjs';
-
-/**
- * An immutable policy describing retry limits and backoff delay strategies.
- *
- * @example
- * ```ts
- * const policy: RetryPolicy = RetryPolicy.constant({
- *   attempts: 3,
- *   delay: Duration.seconds(1),
- * });
- * ```
- */
-type RetryPolicy = {
-    readonly attempts: number;
-    readonly getDelay: (attempt: number) => Duration;
-};
-declare const RetryPolicy: {
-    /**
-     * Creates a RetryPolicy with a constant delay between retry attempts.
-     *
-     * @example
-     * ```ts
-     * const policy = RetryPolicy.constant({
-     *   attempts: 3,
-     *   delay: Duration.seconds(1),
-     * });
-     * ```
-     */
-    constant: (options: {
-        attempts: number;
-        delay: Duration;
-    }) => RetryPolicy;
-    /**
-     * Creates a RetryPolicy with exponential backoff delays between attempts.
-     * An optional `factor` (default 2) controls the growth rate.
-     * An optional `jitter` (default false) adds randomized variance to prevent thundering herd problems.
-     *
-     * @example
-     * ```ts
-     * const policy = RetryPolicy.exponential({
-     *   attempts: 5,
-     *   initial: Duration.milliseconds(100),
-     *   factor: 2,
-     *   jitter: true,
-     * });
-     * ```
-     */
-    exponential: (options: {
-        attempts: number;
-        initial: Duration;
-        factor?: number;
-        jitter?: boolean;
-    }) => RetryPolicy;
-};
-
-export { Duration, RetryPolicy };
+import { n as Duration, r as Brand, t as RetryPolicy } from "./index-Bs8En5LJ.cjs";
+export { Brand, Duration, RetryPolicy };

package/dist/types.d.ts

@@ -1,58 +1,2 @@
-import { D as Duration } from './Duration-DeyxG6VQ.js';
-export { B as Brand } from './Duration-DeyxG6VQ.js';
-
-/**
- * An immutable policy describing retry limits and backoff delay strategies.
- *
- * @example
- * ```ts
- * const policy: RetryPolicy = RetryPolicy.constant({
- *   attempts: 3,
- *   delay: Duration.seconds(1),
- * });
- * ```
- */
-type RetryPolicy = {
-    readonly attempts: number;
-    readonly getDelay: (attempt: number) => Duration;
-};
-declare const RetryPolicy: {
-    /**
-     * Creates a RetryPolicy with a constant delay between retry attempts.
-     *
-     * @example
-     * ```ts
-     * const policy = RetryPolicy.constant({
-     *   attempts: 3,
-     *   delay: Duration.seconds(1),
-     * });
-     * ```
-     */
-    constant: (options: {
-        attempts: number;
-        delay: Duration;
-    }) => RetryPolicy;
-    /**
-     * Creates a RetryPolicy with exponential backoff delays between attempts.
-     * An optional `factor` (default 2) controls the growth rate.
-     * An optional `jitter` (default false) adds randomized variance to prevent thundering herd problems.
-     *
-     * @example
-     * ```ts
-     * const policy = RetryPolicy.exponential({
-     *   attempts: 5,
-     *   initial: Duration.milliseconds(100),
-     *   factor: 2,
-     *   jitter: true,
-     * });
-     * ```
-     */
-    exponential: (options: {
-        attempts: number;
-        initial: Duration;
-        factor?: number;
-        jitter?: boolean;
-    }) => RetryPolicy;
-};
-
-export { Duration, RetryPolicy };
+import { n as Duration, r as Brand, t as RetryPolicy } from "./index-Bs8En5LJ.js";
+export { Brand, Duration, RetryPolicy };