@typed/fx 1.32.0 → 2.0.0-beta.1

package/dist/Fx/combinators/takeUntil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeUntil.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/takeUntil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CActE,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAmB1B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKvE,CAAC"}

package/dist/Fx/combinators/takeUntil.js

@@ -0,0 +1,45 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as combinators from "../../Sink/combinators.js";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make as makeFx } from "../constructors/make.js";
+/**
+ * Takes elements from an Fx until a predicate returns true.
+ * The element that satisfies the predicate is not included in the output.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that completes when the predicate matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeUntil = dual(2, (fx, predicate) => {
+    return makeFx((sink) => combinators.withEarlyExit(sink, (sink) => fx.run(makeSink(sink.onFailure, (a) => {
+        if (predicate(a)) {
+            return sink.earlyExit;
+        }
+        return sink.onSuccess(a);
+    }))));
+});
+/**
+ * Takes elements from an Fx until an effectful predicate returns true.
+ * The element that satisfies the predicate is not included in the output.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that completes when the predicate matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeUntilEffect = dual(2, (fx, predicate) => makeFx((sink) => combinators.withEarlyExit(sink, (sink) => fx.run(makeSink(sink.onFailure, (a) => Effect.matchCauseEffect(predicate(a), {
+    onFailure: sink.onFailure,
+    onSuccess: (matches) => (matches ? sink.earlyExit : sink.onSuccess(a)),
+}))))));
+/**
+ * Drops elements from an Fx after a predicate returns true.
+ * The element that satisfies the predicate is included in the output.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that stops emitting when the predicate matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const dropAfter = dual(2, (fx, predicate) => makeFx((sink) => combinators.dropAfter(sink, predicate, (sink) => fx.run(sink))));

package/dist/Fx/combinators/takeWhile.d.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Takes elements from an Fx while a predicate returns true.
+ * Stops at the first element for which the predicate returns false; that element is not included.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that emits while the predicate holds.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const takeWhile: {
+    <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R>;
+};
+/**
+ * Takes elements from an Fx while an effectful predicate returns true.
+ * Stops at the first element for which the predicate effect succeeds with false; that element is not included.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that emits while the predicate holds.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const takeWhileEffect: {
+    <A, E2, R2>(predicate: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+//# sourceMappingURL=takeWhile.d.ts.map

package/dist/Fx/combinators/takeWhile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeWhile.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/takeWhile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKvE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAO1B,CAAC"}

package/dist/Fx/combinators/takeWhile.js

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { takeUntil, takeUntilEffect } from "./takeUntil.js";
+/**
+ * Takes elements from an Fx while a predicate returns true.
+ * Stops at the first element for which the predicate returns false; that element is not included.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that emits while the predicate holds.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeWhile = dual(2, (fx, predicate) => takeUntil(fx, (a) => !predicate(a)));
+/**
+ * Takes elements from an Fx while an effectful predicate returns true.
+ * Stops at the first element for which the predicate effect succeeds with false; that element is not included.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that emits while the predicate holds.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeWhileEffect = dual(2, (fx, predicate) => takeUntilEffect(fx, (a) => Effect.map(predicate(a), (b) => !b)));

package/dist/Fx/combinators/tapEffect.d.ts

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Performs an effect for each element of the Fx, without changing the elements.
+ *
+ * @param f - An effectful function to apply to each element.
+ * @returns An `Fx` that emits the original elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const tap: {
+    <A, E2 = never, R2 = never>(f: (a: A) => void | Effect.Effect<unknown, E2, R2>): <E, R>(self: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2 = never, R2 = never>(self: Fx<A, E | E2, R>, f: (a: A) => void | Effect.Effect<unknown, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+//# sourceMappingURL=tapEffect.d.ts.map

package/dist/Fx/combinators/tapEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/tapEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB,CAAC,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EACxB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GACjD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC9B,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GACjD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAgB1B,CAAC"}

package/dist/Fx/combinators/tapEffect.js

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Performs an effect for each element of the Fx, without changing the elements.
+ *
+ * @param f - An effectful function to apply to each element.
+ * @returns An `Fx` that emits the original elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const tap = dual(2, (self, f) => make((sink) => self.run(sinkCore.tapEffect(sink, (a) => {
+    const x = f(a);
+    if (Effect.isEffect(x))
+        return x;
+    return Effect.void;
+}))));

package/dist/Fx/combinators/tuple.d.ts

@@ -0,0 +1,27 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Combines multiple Fx streams into a single Fx that emits a tuple of the latest values from each stream.
+ * The resulting Fx waits for all input streams to emit at least once before emitting the first tuple.
+ * Afterwards, it emits a new tuple whenever any input stream emits a new value.
+ *
+ * @param fxs - The Fx streams to combine.
+ * @returns An `Fx` emitting tuples of values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function tuple<FX extends ReadonlyArray<Fx<any, any, any>>>(...fxs: FX): Fx<{
+    readonly [K in keyof FX]: Fx.Success<FX[K]>;
+}, Fx.Error<FX[number]>, Fx.Services<FX[number]>>;
+/**
+ * Combines a record of Fx streams into a single Fx that emits a record of the latest values.
+ * Similar to `tuple`, but for objects.
+ *
+ * @param fxs - A record of Fx streams.
+ * @returns An `Fx` emitting records of values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function struct<FXS extends Readonly<Record<string, Fx<any, any, any>>>>(fxs: FXS): Fx<{
+    readonly [K in keyof FXS]: Fx.Success<FXS[K]>;
+}, Fx.Error<FXS[keyof FXS]>, Fx.Services<FXS[keyof FXS]>>;
+//# sourceMappingURL=tuple.d.ts.map

package/dist/Fx/combinators/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/tuple.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAC/D,GAAG,GAAG,EAAE,EAAE,GACT,EAAE,CACH;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CAAE,EAC/C,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EACpB,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CACxB,CA+BA;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,GAAG,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAC5E,GAAG,EAAE,GAAG,GACP,EAAE,CACH;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,EACjD,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,EACxB,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAC5B,CAOA"}

package/dist/Fx/combinators/tuple.js

@@ -0,0 +1,46 @@
+import * as Effect from "effect/Effect";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { succeed } from "../constructors/succeed.js";
+import { map } from "./map.js";
+/**
+ * Combines multiple Fx streams into a single Fx that emits a tuple of the latest values from each stream.
+ * The resulting Fx waits for all input streams to emit at least once before emitting the first tuple.
+ * Afterwards, it emits a new tuple whenever any input stream emits a new value.
+ *
+ * @param fxs - The Fx streams to combine.
+ * @returns An `Fx` emitting tuples of values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function tuple(...fxs) {
+    if (fxs.length === 0)
+        return succeed([]);
+    if (fxs.length === 1)
+        return fxs[0];
+    return make(Effect.fn(function* (sink) {
+        const len = fxs.length;
+        // oxlint-disable-next-line unicorn/no-new-array
+        const result = new Array(len);
+        const filled = new Set();
+        return yield* Effect.forEach(fxs, (fx, i) => fx.run(makeSink(sink.onFailure, Effect.fn(function* (value) {
+            result[i] = value;
+            filled.add(i);
+            if (filled.size === len) {
+                yield* sink.onSuccess(result);
+            }
+        }))), { concurrency: "unbounded", discard: true });
+    }));
+}
+/**
+ * Combines a record of Fx streams into a single Fx that emits a record of the latest values.
+ * Similar to `tuple`, but for objects.
+ *
+ * @param fxs - A record of Fx streams.
+ * @returns An `Fx` emitting records of values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function struct(fxs) {
+    return map(tuple(...Object.entries(fxs).map(([key, fx]) => map(fx, (value) => [key, value]))), Object.fromEntries);
+}

package/dist/Fx/combinators/unwrap.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Unwraps an Effect that produces an Fx into a single Fx.
+ *
+ * @param effect - An `Effect` that produces an `Fx`.
+ * @returns An `Fx` that runs the effect and then the produced Fx.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const unwrap: <A, E, R, E2, R2>(effect: Effect.Effect<Fx<A, E, R>, E2, R2>) => Fx<A, E | E2, R | R2>;
+//# sourceMappingURL=unwrap.d.ts.map

package/dist/Fx/combinators/unwrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/unwrap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACpC,QAAQ,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KACzC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAMpB,CAAC"}

package/dist/Fx/combinators/unwrap.js

@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import { make } from "../constructors/make.js";
+/**
+ * Unwraps an Effect that produces an Fx into a single Fx.
+ *
+ * @param effect - An `Effect` that produces an `Fx`.
+ * @returns An `Fx` that runs the effect and then the produced Fx.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const unwrap = (effect) => make((sink) => Effect.matchCauseEffect(effect, {
+    onFailure: (cause) => sink.onFailure(cause),
+    onSuccess: (fx) => fx.run(sink),
+}));

package/dist/Fx/combinators/unwrapScoped.d.ts

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { Fx } from "../Fx.js";
+/**
+ * Unwraps an Effect that produces an Fx into a single Fx, managing the scope of the effect.
+ *
+ * The scope of the effect is closed when the Fx completes or is interrupted.
+ *
+ * @param effect - An `Effect` that produces an `Fx`.
+ * @returns An `Fx` that runs the effect and then the produced Fx.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const unwrapScoped: <A, E, R, E2, R2>(effect: Effect.Effect<Fx<A, E, R>, E2, R2 | Scope.Scope>) => Fx<A, E | E2, Exclude<R | R2, Scope.Scope>>;
+//# sourceMappingURL=unwrapScoped.d.ts.map

package/dist/Fx/combinators/unwrapScoped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapScoped.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/unwrapScoped.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAC1C,QAAQ,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,KACvD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAQ1C,CAAC"}

package/dist/Fx/combinators/unwrapScoped.js

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import { make } from "../constructors/make.js";
+/**
+ * Unwraps an Effect that produces an Fx into a single Fx, managing the scope of the effect.
+ *
+ * The scope of the effect is closed when the Fx completes or is interrupted.
+ *
+ * @param effect - An `Effect` that produces an `Fx`.
+ * @returns An `Fx` that runs the effect and then the produced Fx.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const unwrapScoped = (effect) => make((sink) => Effect.scoped(Effect.matchCauseEffect(effect, {
+    onFailure: (cause) => sink.onFailure(cause),
+    onSuccess: (fx) => fx.run(sink),
+})));

package/dist/Fx/combinators/when.d.ts

@@ -0,0 +1,36 @@
+import type { Scope } from "effect/Scope";
+import type { Fx } from "../Fx.js";
+/**
+ * Conditionally runs one of two Fx streams based on the boolean value emitted by the condition stream.
+ *
+ * @param condition - An `Fx` emitting booleans.
+ * @param matchers - An object containing `onTrue` and `onFalse` Fx streams.
+ * @returns An `Fx` that switches between `onTrue` and `onFalse` based on the condition.
+ * @since 1.0.0
+ * @category combinators
+ */
+declare const if_: {
+    <B, E2, R2, C, E3, R3>(matchers: {
+        onTrue: Fx<B, E2, R2>;
+        onFalse: Fx<C, E3, R3>;
+    }): <E, R>(condition: Fx<boolean, E, R>) => Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope>;
+    <E, R, B, E2, R2, C, E3, R3>(condition: Fx<boolean, E, R>, matchers: {
+        onTrue: Fx<B, E2, R2>;
+        onFalse: Fx<C, E3, R3>;
+    }): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope>;
+};
+export { if_ as if };
+/**
+ * Conditionally emits one of two values based on the boolean value emitted by the condition stream.
+ *
+ * @param condition - An `Fx` emitting booleans.
+ * @param matchers - An object containing `onTrue` and `onFalse` values.
+ * @returns An `Fx` that emits the matched value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const when: <E, R, B, C>(condition: Fx<boolean, E, R>, matchers: {
+    onTrue: B;
+    onFalse: C;
+}) => Fx<B | C, E, R | Scope>;
+//# sourceMappingURL=when.d.ts.map

package/dist/Fx/combinators/when.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/when.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;GAQG;AACH,QAAA,MAAM,GAAG,EAAE;IACT,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE;QAC/B,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACtB,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;KACxB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC;IAExF,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACzB,SAAS,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,QAAQ,EAAE;QACR,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACtB,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;KACxB,GACA,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC;CAehD,CAAC;AAEF,OAAO,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC;AAErB;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,UAAU;IACR,MAAM,EAAE,CAAC,CAAC;IACV,OAAO,EAAE,CAAC,CAAC;CACZ,KACA,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAExB,CAAC"}

package/dist/Fx/combinators/when.js

@@ -0,0 +1,28 @@
+import { dual } from "effect/Function";
+import { succeed } from "../constructors/succeed.js";
+import { switchMap } from "./switchMap.js";
+/**
+ * Conditionally runs one of two Fx streams based on the boolean value emitted by the condition stream.
+ *
+ * @param condition - An `Fx` emitting booleans.
+ * @param matchers - An object containing `onTrue` and `onFalse` Fx streams.
+ * @returns An `Fx` that switches between `onTrue` and `onFalse` based on the condition.
+ * @since 1.0.0
+ * @category combinators
+ */
+const if_ = dual(2, (condition, matchers) => {
+    return switchMap(condition, (pass) => (pass ? matchers.onTrue : matchers.onFalse));
+});
+export { if_ as if };
+/**
+ * Conditionally emits one of two values based on the boolean value emitted by the condition stream.
+ *
+ * @param condition - An `Fx` emitting booleans.
+ * @param matchers - An object containing `onTrue` and `onFalse` values.
+ * @returns An `Fx` that emits the matched value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const when = (condition, matchers) => {
+    return if_(condition, { onTrue: succeed(matchers.onTrue), onFalse: succeed(matchers.onFalse) });
+};

package/dist/Fx/combinators/withSpan.d.ts

@@ -0,0 +1,4 @@
+import type { SpanOptionsNoTrace } from "effect/Tracer";
+import type { Fx } from "../Fx.js";
+export declare const withSpan: <A, E, R>(fx: Fx<A, E, R>, name: string, options?: SpanOptionsNoTrace) => Fx<A, E, R>;
+//# sourceMappingURL=withSpan.d.ts.map

package/dist/Fx/combinators/withSpan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withSpan.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/withSpan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC9B,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,MAAM,MAAM,EACZ,UAAU,kBAAkB,KAC3B,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAaZ,CAAC"}

package/dist/Fx/combinators/withSpan.js

@@ -0,0 +1,6 @@
+import * as Effect from "effect/Effect";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+export const withSpan = (fx, name, options) => {
+    return make((sink) => Effect.withSpan(fx.run(makeSink((cause) => Effect.withSpan(sink.onFailure(cause), `onFailure(${name})`, options), (value) => Effect.withSpan(sink.onSuccess(value), `onSuccess(${name})`, options))), `Fx(${name})`, options));
+};

package/dist/Fx/combinators/zip.d.ts

@@ -0,0 +1,75 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Zips two Fx streams in strict lockstep: emits a pair `[a, b]` only when both
+ * streams have produced their next value. Emits the i-th pair when both have
+ * produced at least i values.
+ *
+ * **Completion:** The zipped stream completes when the **first** of the two
+ * streams completes (no further pairs are emitted). The other stream is
+ * interrupted.
+ *
+ * **Errors:** The first failure from either stream fails the zipped stream.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits pairs `[A, B]`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const zip: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<readonly [A, A2], E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<readonly [A, A2], E | E2, R | R2>;
+};
+/**
+ * Zips two Fx streams in strict lockstep and combines each pair with a function.
+ * Emits `f(a, b)` when both streams have produced their next value.
+ *
+ * **Completion:** Completes when the **first** of the two streams completes.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the pair `(a, b)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const zipWith: {
+    <A, A2, E2, R2, B>(that: Fx<A2, E2, R2>, f: (a: A, b: A2) => B): <E, R>(self: Fx<A, E, R>) => Fx<B, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2, B>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>, f: (a: A, b: A2) => B): Fx<B, E | E2, R | R2>;
+};
+/**
+ * Zips two Fx streams by latest values: waits for both to emit at least once,
+ * then emits `[left, right]` whenever **either** stream emits (using the latest
+ * value from the other). No strict pairing; output count is the sum of
+ * emissions from both after the first pair.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits `[AL, AR]` on every update from either stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const zipLatest: {
+    <AR, ER, RR>(that: Fx<AR, ER, RR>): <AL, EL, RL>(self: Fx<AL, EL, RL>) => Fx<readonly [AL, AR], EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR>(self: Fx<AL, EL, RL>, that: Fx<AR, ER, RR>): Fx<readonly [AL, AR], EL | ER, RL | RR>;
+};
+/**
+ * Zips two Fx streams by latest values and combines each pair with a function.
+ * Waits for both to emit at least once, then emits `f(left, right)` whenever
+ * either stream emits.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the latest `(left, right)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const zipLatestWith: {
+    <AL, AR, ER, RR, B>(that: Fx<AR, ER, RR>, f: (left: AL, right: AR) => B): <EL, RL>(self: Fx<AL, EL, RL>) => Fx<B, EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR, B>(self: Fx<AL, EL, RL>, that: Fx<AR, ER, RR>, f: (left: AL, right: AR) => B): Fx<B, EL | ER, RL | RR>;
+};
+//# sourceMappingURL=zip.d.ts.map

package/dist/Fx/combinators/zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/zip.ts"],"names":[],"mappings":"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"}

package/dist/Fx/combinators/zip.js

@@ -0,0 +1,100 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Queue from "effect/Queue";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { map } from "./map.js";
+import { tuple } from "./tuple.js";
+/**
+ * Zips two Fx streams in strict lockstep: emits a pair `[a, b]` only when both
+ * streams have produced their next value. Emits the i-th pair when both have
+ * produced at least i values.
+ *
+ * **Completion:** The zipped stream completes when the **first** of the two
+ * streams completes (no further pairs are emitted). The other stream is
+ * interrupted.
+ *
+ * **Errors:** The first failure from either stream fails the zipped stream.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits pairs `[A, B]`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zip = dual(2, (self, that) => make((sink) => Effect.gen(function* () {
+    const leftQueue = yield* Queue.unbounded();
+    const rightQueue = yield* Queue.unbounded();
+    const leftSink = makeSink(sink.onFailure, (a) => Queue.offer(leftQueue, Option.some(a)));
+    const rightSink = makeSink(sink.onFailure, (b) => Queue.offer(rightQueue, Option.some(b)));
+    const runLeft = self
+        .run(leftSink)
+        .pipe(Effect.ensuring(Queue.offer(leftQueue, Option.none())));
+    const runRight = that
+        .run(rightSink)
+        .pipe(Effect.ensuring(Queue.offer(rightQueue, Option.none())));
+    const consumer = Effect.gen(function* () {
+        while (true) {
+            const exitA = yield* Effect.exit(Queue.take(leftQueue));
+            if (Exit.isFailure(exitA))
+                return;
+            if (Option.isNone(exitA.value))
+                return;
+            const exitB = yield* Effect.exit(Queue.take(rightQueue));
+            if (Exit.isFailure(exitB))
+                return;
+            if (Option.isNone(exitB.value))
+                return;
+            yield* sink.onSuccess([exitA.value.value, exitB.value.value]);
+        }
+    });
+    const leftFiber = yield* Effect.forkChild(runLeft);
+    const rightFiber = yield* Effect.forkChild(runRight);
+    yield* consumer.pipe(Effect.ensuring(Fiber.interrupt(leftFiber)), Effect.ensuring(Fiber.interrupt(rightFiber)));
+})));
+/**
+ * Zips two Fx streams in strict lockstep and combines each pair with a function.
+ * Emits `f(a, b)` when both streams have produced their next value.
+ *
+ * **Completion:** Completes when the **first** of the two streams completes.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the pair `(a, b)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zipWith = dual(3, (self, that, f) => map(zip(self, that), (pair) => f(pair[0], pair[1])));
+/**
+ * Zips two Fx streams by latest values: waits for both to emit at least once,
+ * then emits `[left, right]` whenever **either** stream emits (using the latest
+ * value from the other). No strict pairing; output count is the sum of
+ * emissions from both after the first pair.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits `[AL, AR]` on every update from either stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zipLatest = dual(2, (self, that) => tuple(self, that));
+/**
+ * Zips two Fx streams by latest values and combines each pair with a function.
+ * Waits for both to emit at least once, then emits `f(left, right)` whenever
+ * either stream emits.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the latest `(left, right)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zipLatestWith = dual(3, (self, that, f) => map(zipLatest(self, that), (pair) => f(pair[0], pair[1])));

package/dist/Fx/constructors/at.d.ts

@@ -0,0 +1,16 @@
+import type * as Duration from "effect/Duration";
+import type { Fx } from "../Fx.js";
+/**
+ * Creates an Fx that emits a single value after a specified delay.
+ *
+ * @param value - The value to emit.
+ * @param delay - The duration to wait before emitting.
+ * @returns An `Fx` that emits the value after the delay.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const at: {
+    (delay: Duration.Input): <A>(value: A) => Fx<A>;
+    <A>(value: A, delay: Duration.Input): Fx<A>;
+};
+//# sourceMappingURL=at.d.ts.map

package/dist/Fx/constructors/at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"at.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/at.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;GAQG;AACH,eAAO,MAAM,EAAE,EAAE;IACf,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;CAK7C,CAAC"}

package/dist/Fx/constructors/at.js

@@ -0,0 +1,13 @@
+import { flatMap, sleep } from "effect/Effect";
+import { dual } from "effect/Function";
+import { make } from "./make.js";
+/**
+ * Creates an Fx that emits a single value after a specified delay.
+ *
+ * @param value - The value to emit.
+ * @param delay - The duration to wait before emitting.
+ * @returns An `Fx` that emits the value after the delay.
+ * @since 1.0.0
+ * @category constructors
+ */
+export const at = dual(2, (value, delay) => make((sink) => flatMap(sleep(delay), () => sink.onSuccess(value))));

package/dist/Fx/constructors/die.d.ts

@@ -0,0 +1,11 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Creates an Fx that immediately terminates with a defect (unexpected error).
+ *
+ * @param defect - The defect value.
+ * @returns An `Fx` that dies immediately.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const die: (defect: unknown) => Fx<never, never, never>;
+//# sourceMappingURL=die.d.ts.map

package/dist/Fx/constructors/die.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/die.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAG5D,CAAC"}

package/dist/Fx/constructors/die.js

@@ -0,0 +1,12 @@
+import * as Cause from "effect/Cause";
+import { flow } from "effect/Function";
+import { failCause } from "./failCause.js";
+/**
+ * Creates an Fx that immediately terminates with a defect (unexpected error).
+ *
+ * @param defect - The defect value.
+ * @returns An `Fx` that dies immediately.
+ * @since 1.0.0
+ * @category constructors
+ */
+export const die = /*#__PURE__*/ flow(Cause.die, failCause);