@nlozgachev/pipelined 0.57.0 → 0.59.0

package/dist/core.d.ts

@@ -1327,6 +1327,148 @@ declare namespace Optional {
     const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
 }
 
+/**
+ * Pair<A, B> represents a pair of two values that are always both present.
+ * It is a typed alias for `readonly [A, B]`.
+ *
+ * Use Pair when two values always travel together through a pipeline and you
+ * want to transform either or both sides without destructuring.
+ *
+ * @example
+ * ```ts
+ * import { Pair } from "@nlozgachev/pipelined/core";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const entry = Pair.from.pair("alice", 42);
+ *
+ * pipe(
+ *   entry,
+ *   Pair.mapFirst((name) => name.toUpperCase()),
+ *   Pair.mapSecond((score) => score * 2),
+ *   Pair.fold((name, score) => `${name}: ${score}`),
+ * ); // "ALICE: 84"
+ * ```
+ */
+type Pair<A, B> = readonly [A, B];
+declare namespace Pair {
+    namespace from {
+        /**
+         * Creates a Pair from two values.
+         *
+         * @example
+         * ```ts
+         * Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
+         * ```
+         */
+        const pair: <A, B>(first: A, second: B) => Pair<A, B>;
+        /**
+         * Creates a Pair from a two-element array.
+         *
+         * @example
+         * ```ts
+         * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+         * ```
+         */
+        const array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
+    }
+    /**
+     * Returns the first value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"
+     * ```
+     */
+    const first: <A, B>(p: Pair<A, B>) => A;
+    /**
+     * Returns the second value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
+     * ```
+     */
+    const second: <A, B>(p: Pair<A, B>) => B;
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * ```
+     */
+    const mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
+     * ```
+     */
+    const mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+    /**
+     * Transforms both values independently in a single step.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("alice", 42),
+     *   Pair.mapBoth(
+     *     (name) => name.toUpperCase(),
+     *     (score) => score * 2,
+     *   ),
+     * ); // ["ALICE", 84]
+     * ```
+     */
+    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: Pair<A, B>) => Pair<C, D>;
+    /**
+     * Applies a binary function to both values, collapsing the pair into a single value.
+     * Useful as the final step when consuming a pair in a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
+     * // "Alice: 100"
+     * ```
+     */
+    const fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+    /**
+     * Swaps the two values: `[A, B]` becomes `[B, A]`.
+     *
+     * @example
+     * ```ts
+     * Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
+     * ```
+     */
+    const swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    namespace to {
+        /**
+         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+         *
+         * @example
+         * ```ts
+         * Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]
+         * ```
+         */
+        const Array: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
+    }
+    /**
+     * Runs a side effect with both values without changing the pair.
+     * Useful for logging or debugging in the middle of a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("Paris", 2_161_000),
+     *   Pair.tap((city, pop) => console.log(`${city}: ${pop}`)),
+     *   Pair.mapSecond((n) => n / 1_000_000),
+     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
+     * ```
+     */
+    const tap: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
+}
+
 /**
  * A boolean-valued function over a type `A`.
  *
@@ -2877,146 +3019,4 @@ declare namespace These {
     const swap: <A, B>(data: These<A, B>) => These<B, A>;
 }
 
-/**
- * Tuple<A, B> represents a pair of two values that are always both present.
- * It is a typed alias for `readonly [A, B]`.
- *
- * Use Tuple when two values always travel together through a pipeline and you
- * want to transform either or both sides without destructuring.
- *
- * @example
- * ```ts
- * import { Tuple } from "@nlozgachev/pipelined/core";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const entry = Tuple.from.pair("alice", 42);
- *
- * pipe(
- *   entry,
- *   Tuple.mapFirst((name) => name.toUpperCase()),
- *   Tuple.mapSecond((score) => score * 2),
- *   Tuple.fold((name, score) => `${name}: ${score}`),
- * ); // "ALICE: 84"
- * ```
- */
-type Tuple<A, B> = readonly [A, B];
-declare namespace Tuple {
-    namespace from {
-        /**
-         * Creates a pair from two values.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
-         * ```
-         */
-        const pair: <A, B>(first: A, second: B) => Tuple<A, B>;
-        /**
-         * Creates a Tuple from a two-element array.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
-         * ```
-         */
-        const array: <A, B>(arr: readonly [A, B]) => Tuple<A, B>;
-    }
-    /**
-     * Returns the first value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.first(Tuple.from.pair("Paris", 2_161_000)); // "Paris"
-     * ```
-     */
-    const first: <A, B>(tuple: Tuple<A, B>) => A;
-    /**
-     * Returns the second value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.second(Tuple.from.pair("Paris", 2_161_000)); // 2161000
-     * ```
-     */
-    const second: <A, B>(tuple: Tuple<A, B>) => B;
-    /**
-     * Transforms the first value, leaving the second unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
-     * ```
-     */
-    const mapFirst: <A, C>(f: (a: A) => C) => <B>(tuple: Tuple<A, B>) => Tuple<C, B>;
-    /**
-     * Transforms the second value, leaving the first unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
-     * ```
-     */
-    const mapSecond: <B, D>(f: (b: B) => D) => <A>(tuple: Tuple<A, B>) => Tuple<A, D>;
-    /**
-     * Transforms both values independently in a single step.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("alice", 42),
-     *   Tuple.mapBoth(
-     *     (name) => name.toUpperCase(),
-     *     (score) => score * 2,
-     *   ),
-     * ); // ["ALICE", 84]
-     * ```
-     */
-    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (tuple: Tuple<A, B>) => Tuple<C, D>;
-    /**
-     * Applies a binary function to both values, collapsing the pair into a single value.
-     * Useful as the final step when consuming a pair in a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
-     * // "Alice: 100"
-     * ```
-     */
-    const fold: <A, B, C>(f: (a: A, b: B) => C) => (tuple: Tuple<A, B>) => C;
-    /**
-     * Swaps the two values: `[A, B]` becomes `[B, A]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.swap(Tuple.from.pair("key", 1)); // [1, "key"]
-     * ```
-     */
-    const swap: <A, B>(tuple: Tuple<A, B>) => Tuple<B, A>;
-    namespace to {
-        /**
-         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
-         *
-         * @example
-         * ```ts
-         * Tuple.to.Array(Tuple.from.pair("hello", 42)); // ["hello", 42]
-         * ```
-         */
-        const Array: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
-    }
-    /**
-     * Runs a side effect with both values without changing the pair.
-     * Useful for logging or debugging in the middle of a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("Paris", 2_161_000),
-     *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
-     *   Tuple.mapSecond((n) => n / 1_000_000),
-     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
-     * ```
-     */
-    const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
-}
-
-export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond };

package/dist/{chunk-YMHKIN4I.js → core.mjs}

@@ -1,7 +1,3 @@
-import {
-  Duration
-} from "./chunk-OIIOGDHK.js";
-
 // src/Core/Combinable.ts
 var Combinable;
 ((Combinable2) => {
@@ -232,6 +228,34 @@ var Maybe;
   Maybe3.transposeResult = (data) => is.none(data) ? Result.make.ok(make.none()) : Result.is.ok(data.value) ? Result.make.ok(make.some(data.value.value)) : Result.make.err(data.value.error);
 })(Maybe || (Maybe = {}));
 
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// 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 = {}));
+
 // src/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -1402,6 +1426,34 @@ var Ordering;
   };
 })(Ordering || (Ordering = {}));
 
+// src/Core/Pair.ts
+var Pair;
+((Pair2) => {
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Pair2.from || (Pair2.from = {}));
+  Pair2.first = (p) => p[0];
+  Pair2.second = (p) => p[1];
+  Pair2.mapFirst = (f) => (p) => [f(p[0]), p[1]];
+  Pair2.mapSecond = (f) => (p) => [p[0], f(p[1])];
+  Pair2.mapBoth = (onFirst, onSecond) => (p) => [
+    onFirst(p[0]),
+    onSecond(p[1])
+  ];
+  Pair2.fold = (f) => (p) => f(p[0], p[1]);
+  Pair2.swap = (p) => [p[1], p[0]];
+  let to;
+  ((to2) => {
+    to2.Array = (p) => [...p];
+  })(to = Pair2.to || (Pair2.to = {}));
+  Pair2.tap = (f) => (p) => {
+    f(p[0], p[1]);
+    return p;
+  };
+})(Pair || (Pair = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -2460,34 +2512,6 @@ var These;
   };
 })(These || (These = {}));
 
-// src/Core/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  let from;
-  ((from2) => {
-    from2.pair = (first2, second2) => [first2, second2];
-    from2.array = (arr) => arr;
-  })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
-  ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  let to;
-  ((to2) => {
-    to2.Array = (tuple) => [...tuple];
-  })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
-  };
-})(Tuple || (Tuple = {}));
-
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
@@ -2593,7 +2617,6 @@ var Validation;
     return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
   };
 })(Validation || (Validation = {}));
-
 export {
   Combinable,
   Deferred,
@@ -2605,6 +2628,7 @@ export {
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -2613,9 +2637,7 @@ export {
   Result,
   State,
   Stream,
-  isNonEmptyArr,
   Task,
   These,
-  Tuple,
   Validation
 };