@typed/fx 1.31.0 → 2.0.0-beta.0

package/dist/Fx/combinators/keyed.js

@@ -0,0 +1,199 @@
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual, identity } from "effect/Function";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import { MaxOpsBeforeYield } from "effect/Scheduler";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import * as SynchronizedRef from "effect/SynchronizedRef";
+import * as RefSubject from "../../RefSubject/RefSubject.js";
+import * as Sink from "../../Sink/Sink.js";
+import { diff, getKeyMap } from "../internal/diff.js";
+import { withScopedFork } from "../internal/scope.js";
+import { FxTypeId } from "../TypeId.js";
+/**
+ * Efficiently transforms a list of values into a list of Fx streams, using keys to track identity.
+ *
+ * This is crucial for performance when rendering lists or managing collections of stateful entities.
+ * When the input list changes:
+ * - New keys cause `onValue` to be called.
+ * - Existing keys have their `RefSubject` updated with the new value.
+ * - Removed keys have their corresponding Fx and scope cleaned up.
+ *
+ * @param fx - An `Fx` emitting an array of values.
+ * @param options - Configuration options.
+ * @returns An `Fx` emitting an array of results.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const keyed = dual(2, function keyed(fx, options) {
+    return new Keyed(fx, options);
+});
+const StateContext = ServiceMap.Service("@services/StateContext");
+const VARIANCE = {
+    _A: identity,
+    _E: identity,
+    _R: identity,
+};
+class Keyed {
+    [FxTypeId] = VARIANCE;
+    fx;
+    options;
+    constructor(fx, options) {
+        this.fx = fx;
+        this.options = options;
+    }
+    run(sink) {
+        return Effect.withFiber((fiber) => runKeyed(this.fx, this.options, sink, fiber.id)).pipe(Effect.provideService(MaxOpsBeforeYield, Infinity));
+    }
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+}
+function emptyKeyedState() {
+    return {
+        entries: new Map(),
+        indices: new Map(),
+        previousValues: [],
+    };
+}
+function runKeyed(fx, options, sink, id) {
+    return withDebounceFork((debounceFork, parentScope) => {
+        const state = emptyKeyedState();
+        const emit = Effect.suspend(() => sink.onSuccess(getReadyIndices(state)));
+        const scheduleNextEmit = debounceFork(emit);
+        let first = true;
+        let previousKeyMap = new Map();
+        return fx.run(Sink.make(sink.onFailure, Effect.fn(function* (values) {
+            const previous = state.previousValues;
+            const keyMap = getKeyMap(values, options.getKey);
+            let changed = first;
+            first = false;
+            for (const patch of diff(previous, values, {
+                getKey: options.getKey,
+                previousKeyMap,
+                keyMap,
+            })) {
+                if (patch._tag === "Remove") {
+                    changed = true;
+                    yield* removeValue(state, patch, state.entries.get(patch.key));
+                }
+                else if (patch._tag === "Add") {
+                    changed = true;
+                    yield* addValue({
+                        state,
+                        values,
+                        patch,
+                        id,
+                        parentScope,
+                        keyedOptions: options,
+                        sink,
+                        scheduleNextEmit,
+                    });
+                }
+                else {
+                    yield* updateValue(state, values, patch);
+                }
+            }
+            state.previousValues = values;
+            previousKeyMap = keyMap;
+            if (changed) {
+                yield* scheduleNextEmit;
+            }
+            else {
+                yield* adjustTime();
+            }
+        })));
+    }, options.debounce || 1);
+}
+class KeyedEntry {
+    value;
+    index;
+    output;
+    ref;
+    interrupt;
+    constructor(value, index, output, ref, interrupt) {
+        this.value = value;
+        this.index = index;
+        this.output = output;
+        this.ref = ref;
+        this.interrupt = interrupt;
+    }
+}
+function getReadyIndices({ entries, indices, previousValues, }) {
+    const output = [];
+    for (let i = 0; i < previousValues.length; ++i) {
+        const key = indices.get(i);
+        if (key === undefined)
+            break;
+        const entry = entries.get(key);
+        if (Option.isSome(entry.output)) {
+            output.push(entry.output.value);
+        }
+        else {
+            break;
+        }
+    }
+    return output;
+}
+function* addValue(options) {
+    const { id, keyedOptions, parentScope, patch, scheduleNextEmit, sink, state, values } = options;
+    const { entries, indices } = state;
+    const value = values[patch.index];
+    const childScope = yield* Scope.fork(parentScope, "sequential");
+    const ref = yield* RefSubject.make(Effect.sync(() => entry.value)).pipe(Effect.provideService(Scope.Scope, childScope));
+    const entry = new KeyedEntry(value, patch.index, Option.none(), ref, Scope.close(childScope, Exit.interrupt(id)));
+    entries.set(patch.key, entry);
+    indices.set(patch.index, patch.key);
+    yield* Effect.forkIn(keyedOptions
+        .onValue(ref, patch.key)
+        .run(Sink.make((cause) => sink.onFailure(cause), (output) => {
+        entry.output = Option.some(output);
+        return scheduleNextEmit;
+    }))
+        .pipe(Effect.provideService(Scope.Scope, childScope)), parentScope);
+}
+function removeValue({ entries, indices }, patch, entry) {
+    entries.delete(patch.key);
+    indices.delete(patch.index);
+    return entry.interrupt;
+}
+function updateValue({ entries, indices }, values, patch) {
+    const key = patch.key;
+    const entry = entries.get(key);
+    if (patch._tag === "Moved") {
+        const currentKey = indices.get(patch.index);
+        if (currentKey === key) {
+            indices.delete(patch.index);
+        }
+        indices.set(patch.to, key);
+        entry.value = values[(entry.index = patch.to)];
+    }
+    else {
+        entry.value = values[(entry.index = patch.index)];
+    }
+    return RefSubject.set(entry.ref, entry.value);
+}
+function withDebounceFork(f, duration) {
+    return withScopedFork((fork, scope) => Effect.flatMap(SynchronizedRef.make(Option.none()), (ref) => Effect.flatMap(f((effect) => SynchronizedRef.updateEffect(ref, Option.match({
+        onNone: () => Effect.asSome(fork(Effect.delay(effect, duration))),
+        onSome: (fiber) => Fiber.interrupt(fiber).pipe(Effect.flatMap(() => fork(Effect.delay(effect, duration))), Effect.asSome),
+    })), scope), () => SynchronizedRef.updateEffect(ref, Option.match({
+        onNone: () => Effect.succeedNone,
+        onSome: (fiber) => Fiber.join(fiber).pipe(Effect.as(Option.none())),
+    })))), "sequential");
+}
+function* adjustTime() {
+    const services = yield* Effect.services();
+    const clock = ServiceMap.get(services, Clock.Clock);
+    if ("adjust" in clock) {
+        yield* clock.adjust(Duration.millis(1));
+    }
+    else {
+        yield* clock.sleep(Duration.millis(1));
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Loops over an Fx with an accumulator, producing a new value for each element
+ * and updating the accumulator.
+ *
+ * @param seed - The initial value of the accumulator.
+ * @param f - A function that takes the accumulator and an element, returning a tuple of the emitted value and the new accumulator.
+ * @returns An `Fx` that emits the transformed values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const loop: {
+    <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): <E, R>(self: Fx<A, E, R>) => Fx<C, E, R>;
+    <A, E, R, B, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<C, E, R>;
+};
+//# sourceMappingURL=loop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/loop.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GACnC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5C,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKhG,CAAC"}

package/dist/Fx/combinators/loop.js

@@ -0,0 +1,14 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Loops over an Fx with an accumulator, producing a new value for each element
+ * and updating the accumulator.
+ *
+ * @param seed - The initial value of the accumulator.
+ * @param f - A function that takes the accumulator and an element, returning a tuple of the emitted value and the new accumulator.
+ * @returns An `Fx` that emits the transformed values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const loop = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.loop(sink, seed, f))));

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

@@ -0,0 +1,16 @@
+import type * as Cause from "effect/Cause";
+import type { Fx } from "../Fx.js";
+/**
+ * Loops over the failure causes of an Fx with an accumulator.
+ *
+ * @param seed - The initial state.
+ * @param f - The loop function for causes.
+ * @returns An `Fx` with transformed errors.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const loopCause: {
+    <B, A, C>(seed: B, f: (acc: B, a: Cause.Cause<A>) => readonly [Cause.Cause<C>, B]): <E, R>(self: Fx<A, E, R>) => Fx<A, C, R>;
+    <A, E, R, B, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]): Fx<A, C, R>;
+};
+//# sourceMappingURL=loopCause.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loopCause.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/loopCause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAI3C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAC7D,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5C,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACZ,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAC7D,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAQhB,CAAC"}

package/dist/Fx/combinators/loopCause.js

@@ -0,0 +1,13 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Loops over the failure causes of an Fx with an accumulator.
+ *
+ * @param seed - The initial state.
+ * @param f - The loop function for causes.
+ * @returns An `Fx` with transformed errors.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const loopCause = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.loopCause(sink, seed, f))));

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

@@ -0,0 +1,17 @@
+import type * as Cause from "effect/Cause";
+import type * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Effectfully loops over the failure causes of an Fx with an accumulator.
+ *
+ * @param seed - The initial state.
+ * @param f - The effectful loop function for causes.
+ * @returns An `Fx` with transformed errors.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const loopCauseEffect: {
+    <B, A, E, R2, C>(seed: B, f: (acc: B, a: Cause.Cause<A>) => Effect.Effect<readonly [Cause.Cause<C>, B], R2>): <R>(self: Fx<A, E, R>) => Fx<A, C | E, R | R2>;
+    <A, E, R, B, R2, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E, R2>): Fx<A, C, R | R2>;
+};
+//# sourceMappingURL=loopCauseEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loopCauseEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/loopCauseEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAI7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EACb,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAChF,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAElD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAChB,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GACnF,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CASrB,CAAC"}

package/dist/Fx/combinators/loopCauseEffect.js

@@ -0,0 +1,13 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Effectfully loops over the failure causes of an Fx with an accumulator.
+ *
+ * @param seed - The initial state.
+ * @param f - The effectful loop function for causes.
+ * @returns An `Fx` with transformed errors.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const loopCauseEffect = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.loopCauseEffect(sink, seed, f))));

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

@@ -0,0 +1,16 @@
+import type * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Effectfully loops over an Fx with an accumulator, producing a new value for each element.
+ *
+ * @param seed - The initial state.
+ * @param f - The effectful loop function.
+ * @returns An `Fx` emitting the transformed values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const loopEffect: {
+    <B, A, E2, R2, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>): <E, R>(self: Fx<A, E | E2, R>) => Fx<C, E | E2, R | R2>;
+    <A, E, R, B, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>): Fx<C, E, R>;
+};
+//# sourceMappingURL=loopEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loopEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/loopEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAI7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EACd,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1D,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,CAAC,EAAE,CAAC,EACZ,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GACxD,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAQhB,CAAC"}

package/dist/Fx/combinators/loopEffect.js

@@ -0,0 +1,13 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Effectfully loops over an Fx with an accumulator, producing a new value for each element.
+ *
+ * @param seed - The initial state.
+ * @param f - The effectful loop function.
+ * @returns An `Fx` emitting the transformed values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const loopEffect = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.loopEffect(seed, f)(sink))));

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

@@ -0,0 +1,14 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Transforms the elements of an Fx using a provided function.
+ *
+ * @param f - A function that transforms values of type `A` to `B`.
+ * @returns An `Fx` that emits values of type `B`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const map: {
+    <A, B>(f: (a: A) => B): <E, R>(self: Fx<A, E, R>) => Fx<B, E, R>;
+    <A, E, R, B>(self: Fx<A, E, R>, f: (a: A) => B): Fx<B, E, R>;
+};
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/map.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEjE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAK9D,CAAC"}

package/dist/Fx/combinators/map.js

@@ -0,0 +1,12 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Transforms the elements of an Fx using a provided function.
+ *
+ * @param f - A function that transforms values of type `A` to `B`.
+ * @returns An `Fx` that emits values of type `B`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const map = dual(2, (self, f) => make((sink) => self.run(sinkCore.map(sink, f))));

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

@@ -0,0 +1,15 @@
+import type * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Transforms the elements of an Fx using a provided Effectful function.
+ *
+ * @param f - A function that transforms values of type `A` to an Effect of `B`.
+ * @returns An `Fx` that emits values of type `B`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const mapEffect: {
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(fx: Fx<A, E | E2, R>) => Fx<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E | E2, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Fx<B, E | E2, R | R2>;
+};
+//# sourceMappingURL=mapEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/mapEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAK7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACpC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,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;IAEzD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EACpB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACpC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAQ1B,CAAC"}

package/dist/Fx/combinators/mapEffect.js

@@ -0,0 +1,12 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Transforms the elements of an Fx using a provided Effectful function.
+ *
+ * @param f - A function that transforms values of type `A` to an Effect of `B`.
+ * @returns An `Fx` that emits values of type `B`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapEffect = dual(2, (self, f) => make((sink) => self.run(sinkCore.mapEffect(sink, f))));

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

@@ -0,0 +1,11 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Merges multiple Fx streams into a single Fx that emits values from all input streams concurrently.
+ *
+ * @param fx - The Fx streams to merge.
+ * @returns An `Fx` that emits values from all input streams.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const mergeAll: <FX extends ReadonlyArray<Fx<any, any, any>>>(...fx: FX) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>>;
+//# sourceMappingURL=mergeAll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeAll.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/mergeAll.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,EAAE,SAAS,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAClE,GAAG,IAAI,EAAE,KACR,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAMxE,CAAC"}

package/dist/Fx/combinators/mergeAll.js

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import { skipInterrupt } from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Merges multiple Fx streams into a single Fx that emits values from all input streams concurrently.
+ *
+ * @param fx - The Fx streams to merge.
+ * @returns An `Fx` that emits values from all input streams.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mergeAll = (...fx) => make((sink) => Effect.forEach(fx, (fx) => fx.run(skipInterrupt(sink)), {
+    concurrency: fx.length,
+    discard: true,
+}));

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

@@ -0,0 +1,14 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Merges multiple Fx streams concurrently but emits values in the order of the input streams.
+ *
+ * This ensures that values from the first Fx are emitted before values from the second Fx, and so on.
+ * Values from later streams are buffered until earlier streams complete or emit their values (depending on semantics, but usually this means strictly ordered emission).
+ *
+ * @param fx - The Fx streams to merge.
+ * @returns An `Fx` that emits values in order.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(...fx: FX): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>>;
+//# sourceMappingURL=mergeOrdered.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeOrdered.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/mergeOrdered.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,EAAE,SAAS,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EACtE,GAAG,EAAE,EAAE,EAAE,GACR,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAW3E"}

package/dist/Fx/combinators/mergeOrdered.js

@@ -0,0 +1,89 @@
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Sink from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+/**
+ * Merges multiple Fx streams concurrently but emits values in the order of the input streams.
+ *
+ * This ensures that values from the first Fx are emitted before values from the second Fx, and so on.
+ * Values from later streams are buffered until earlier streams complete or emit their values (depending on semantics, but usually this means strictly ordered emission).
+ *
+ * @param fx - The Fx streams to merge.
+ * @returns An `Fx` that emits values in order.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function mergeOrdered(...fx) {
+    return make(Effect.fn(function* (sink) {
+        const { makeSink, onEnd } = withBuffers(fx.length, sink);
+        yield* Effect.forEach(fx, (fx, i) => Effect.onExit(fx.run(makeSink(i)), () => onEnd(i)), {
+            concurrency: "unbounded",
+            discard: true,
+        });
+    }));
+}
+function withBuffers(size, sink) {
+    const buffers = indexedBuffers(size, sink);
+    const onSuccess = (index, value) => buffers.get(index).onSuccess(value);
+    const onEnd = (index) => buffers.get(index).onEnd;
+    const makeSink = (index) => Sink.make((cause) => (Cause.hasInterruptsOnly(cause) ? onEnd(index) : sink.onFailure(cause)), (value) => onSuccess(index, value));
+    return {
+        onSuccess,
+        onEnd,
+        makeSink,
+    };
+}
+function indexedBuffers(size, sink) {
+    const buffers = new Map();
+    const last = size - 1;
+    for (let i = 0; i < size; i++) {
+        const deferred = Deferred.makeUnsafe();
+        const state = {
+            ready: i === 0,
+            deferred,
+        };
+        // First should start immediately
+        if (i === 0) {
+            Deferred.doneUnsafe(deferred, Exit.void);
+        }
+        buffers.set(i, IndexedBuffer(state, sink, i === last
+            ? Effect.void
+            : Effect.suspend(() => {
+                const next = buffers.get(i + 1);
+                next.state.ready = true;
+                return Deferred.done(next.state.deferred, Exit.void);
+            })));
+    }
+    return buffers;
+}
+function IndexedBuffer(state, sink, onDone) {
+    let buffer = [];
+    const onSuccess = (value) => {
+        if (state.ready) {
+            if (buffer.length === 0)
+                return sink.onSuccess(value);
+            buffer.push(value);
+            const effect = Effect.forEach(buffer, sink.onSuccess);
+            buffer = [];
+            return effect;
+        }
+        else {
+            buffer.push(value);
+            return Effect.void;
+        }
+    };
+    const onEnd = Effect.flatMap(Deferred.await(state.deferred), () => {
+        if (buffer.length === 0)
+            return onDone;
+        const effect = Effect.forEach(buffer, sink.onSuccess);
+        buffer = [];
+        return Effect.ensuring(effect, onDone);
+    });
+    return {
+        state,
+        onSuccess,
+        onEnd,
+    };
+}

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

@@ -0,0 +1,17 @@
+import type * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Adds an `Effect.onError`-style finalizer to an `Fx`.
+ *
+ * The cleanup is run only if the stream fails (including defects / interrupts
+ * carried in the `Cause`).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const onError: {
+    <E, X, R2>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
+    <A, E, R, X, R2>(self: Fx<A, E, R>, cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>): Fx<A, E, R | R2>;
+};
+//# sourceMappingURL=onError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"onError.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EACP,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9D,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAEjD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9D,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAerB,CAAC"}

package/dist/Fx/combinators/onError.js

@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+/**
+ * Adds an `Effect.onError`-style finalizer to an `Fx`.
+ *
+ * The cleanup is run only if the stream fails (including defects / interrupts
+ * carried in the `Cause`).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const onError = dual(2, (self, cleanup) => make((sink) => self.run(makeSink((cause) => Effect.flatMap(sink.onFailure(cause), () => Effect.ignore(cleanup(cause))), sink.onSuccess))));

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

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import type { Fx } from "../Fx.js";
+/**
+ * Adds an `Effect.onExit`-style finalizer to an `Fx`.
+ *
+ * The finalizer is run when the `Fx` terminates (success, failure, or interruption).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const onExit: {
+    <A, E, XE = never, XR = never>(f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>): <R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;
+    <A, E, R, XE = never, XR = never>(self: Fx<A, E, R>, f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>): Fx<A, E | XE, R | XR>;
+};
+//# sourceMappingURL=onExit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"onExit.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onExit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAMpC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AASnC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC3B,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAClE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAEnD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC9B,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAClE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAiD1B,CAAC"}