@typed/fx 1.31.0 → 2.0.0-beta.0

package/dist/esm/RefSubject.js

@@ -1,1076 +0,0 @@
-/**
- * A RefSubject is a Subject that can be used to read and write a value.
- * @since 1.20.0
- */
-import * as C from "@typed/context";
-import * as Array from "effect/Array";
-import * as Boolean from "effect/Boolean";
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as ExecutionStrategy from "effect/ExecutionStrategy";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import { dual, identity } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as MutableRef from "effect/MutableRef";
-import { sum } from "effect/Number";
-import * as Option from "effect/Option";
-import * as Scope from "effect/Scope";
-import * as Unify from "effect/Unify";
-import * as internal from "./internal/core.js";
-import * as DeferredRef from "./internal/DeferredRef.js";
-import { getExitEquivalence, matchEffectPrimitive, withScope } from "./internal/helpers.js";
-import { FxEffectBase } from "./internal/protos.js";
-import { runtimeToLayer } from "./internal/provide.js";
-import { hold } from "./internal/share.js";
-import * as Sink from "./Sink.js";
-import * as Subject from "./Subject.js";
-import { ComputedTypeId, FilteredTypeId, FxTypeId, RefSubjectTypeId } from "./TypeId.js";
-import * as Versioned from "./Versioned.js";
-const UNBOUNDED = { concurrency: "unbounded" };
-// TODO: Kind of a Hack, but I don't really want to pollute the public API with this. What should we do with this?
-const CURRENT_ENVIRONMENT_TAG = C.Tagged("@typed/environment/CurrentEnvironment");
-const checkIsDOM = (ctx) => C.getOption(ctx, CURRENT_ENVIRONMENT_TAG).pipe(Option.map((s) => s === "dom" || s === "test:dom"), 
-// Default behavior should allow multiple updates via Fx interface
-Option.getOrElse(() => true));
-/**
- * @since 1.20.0
- */
-export function fromEffect(effect, options) {
-    return Effect.map(makeCore(effect, options), (core) => new RefSubjectImpl(core));
-}
-/**
- * @since 1.20.0
- */
-export function fromFx(fx, options) {
-    return DeferredRef.make(getExitEquivalence(options?.eq ?? internal.deepEquals)).pipe(Effect.bindTo("deferredRef"), Effect.bind("core", ({ deferredRef }) => makeCore(deferredRef, options)), Effect.tap(({ core, deferredRef }) => Effect.forkIn(fx.run(Sink.make((cause) => Effect.flatMap(Effect.sync(() => deferredRef.done(Exit.failCause(cause))), () => core.subject.onFailure(cause)), (value) => Effect.flatMap(Effect.sync(() => deferredRef.done(Exit.succeed(value))), () => setCore(core, value)))), core.scope)), Effect.map(({ core }) => new RefSubjectImpl(core)));
-}
-/**
- * @since 1.20.0
- */
-export function fromRefSubject(ref, options) {
-    return DeferredRef.make(getExitEquivalence(options?.eq ?? internal.deepEquals)).pipe(Effect.bindTo("deferredRef"), Effect.bind("core", ({ deferredRef }) => makeCore(deferredRef, options)), Effect.tap(({ core, deferredRef }) => Effect.forkIn(ref.run(Sink.make((cause) => Effect.sync(() => deferredRef.done(Exit.failCause(cause))), (value) => Effect.sync(() => deferredRef.done(Exit.succeed(value))))), core.scope)), Effect.map(({ core }) => new DerivedImpl(core, persistCore(ref, core))));
-}
-function persistCore(ref, core) {
-    // Log any errors that fail to persist, but don't fail the consumer
-    return Effect.ignoreLogged(Effect.provide(Effect.flatMap(core.deferredRef, (value) => set(ref, value)), core.runtime.context));
-}
-/**
- * @since 1.20.0
- */
-export const make = function make(fxOrEffect, options) {
-    if (RefSubjectTypeId in fxOrEffect)
-        return fromRefSubject(fxOrEffect, options);
-    else if (FxTypeId in fxOrEffect)
-        return fromFx(fxOrEffect, options);
-    else
-        return fromEffect(fxOrEffect, options);
-};
-/**
- * @since 1.20.0
- */
-export function of(a, options) {
-    return Effect.acquireRelease(withScopeAndFiberId((scope, id) => unsafeMake({
-        id,
-        initial: Effect.succeed(a),
-        initialValue: a,
-        options,
-        scope
-    }), options?.executionStrategy ?? ExecutionStrategy.sequential), (ref) => ref.interrupt);
-}
-const withScopeAndFiberId = (f, strategy) => Effect.fiberIdWith((id) => withScope((scope) => f(scope, id), strategy));
-/**
- * @since 1.20.0
- */
-export function unsafeMake(params) {
-    const { id, initial, options, scope } = params;
-    return Effect.flatMap(Effect.runtime(), (runtime) => {
-        const core = unsafeMakeCore(initial, id, runtime, scope, options);
-        const current = MutableRef.get(core.deferredRef.current);
-        // Sometimes we might be instantiating directly from a known value
-        // Here we seed the value and ensure the subject has it as well for re-broadcasting
-        if ("initialValue" in params && Option.isNone(current)) {
-            core.deferredRef.done(Exit.succeed(params.initialValue));
-            return Effect.map(core.subject.onSuccess(params.initialValue), () => new RefSubjectImpl(core));
-        }
-        else if (Option.isSome(current)) {
-            return Effect.map(Effect.matchCauseEffect(current.value, core.subject), () => new RefSubjectImpl(core));
-        }
-        else {
-            return Effect.succeed(new RefSubjectImpl(core));
-        }
-    });
-}
-class RefSubjectImpl extends FxEffectBase {
-    core;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    getSetDelete;
-    constructor(core) {
-        super();
-        this.core = core;
-        this.version = Effect.sync(() => core.deferredRef.version);
-        this.interrupt = Effect.provide(interruptCore(core), core.runtime.context);
-        this.subscriberCount = Effect.provide(core.subject.subscriberCount, core.runtime.context);
-        this.getSetDelete = getSetDelete(core);
-        this.runUpdates = this.runUpdates.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-        this.onFailure = this.onFailure.bind(this);
-    }
-    run(sink) {
-        return Effect.matchCauseEffect(getOrInitializeCore(this.core, true), {
-            onFailure: (cause) => sink.onFailure(cause),
-            onSuccess: () => Effect.provide(this.core.subject.run(sink), this.core.runtime.context)
-        });
-    }
-    runUpdates(run) {
-        return this.core.semaphore.withPermits(1)(run(this.getSetDelete));
-    }
-    unsafeGet = () => Option.getOrThrowWith(MutableRef.get(this.core.deferredRef.current), () => new Cause.NoSuchElementException());
-    onSuccess(value) {
-        return setCore(this.core, value);
-    }
-    onFailure(cause) {
-        return onFailureCore(this.core, cause);
-    }
-    toEffect() {
-        return getOrInitializeCore(this.core, true);
-    }
-}
-class DerivedImpl extends RefSubjectImpl {
-    persist;
-    constructor(core, persist) {
-        super(core);
-        this.persist = persist;
-    }
-}
-/**
- * @since 1.20.0
- */
-export const set = dual(2, function set(ref, a) {
-    return ref.runUpdates((ref) => ref.set(a));
-});
-/**
- * @since 1.20.0
- */
-export function reset(ref) {
-    return ref.runUpdates((ref) => ref.delete);
-}
-/**
- * @since 1.20.0
- */
-export { 
-/**
- * @since 1.20.0
- */
-reset as delete };
-function getSetDelete(ref) {
-    return {
-        get: getOrInitializeCore(ref, false),
-        set: (a) => setCore(ref, a),
-        delete: deleteCore(ref)
-    };
-}
-/**
- * @since 1.20.0
- */
-export const updateEffect = dual(2, function updateEffect(ref, f) {
-    return ref.runUpdates((ref) => Effect.flatMap(Effect.flatMap(ref.get, f), ref.set));
-});
-/**
- * @since 1.20.0
- */
-export const update = dual(2, function update(ref, f) {
-    return updateEffect(ref, (value) => Effect.succeed(f(value)));
-});
-/**
- * @since 1.20.0
- */
-export const modifyEffect = dual(2, function modifyEffect(ref, f) {
-    return ref.runUpdates((ref) => Effect.flatMap(ref.get, (value) => Effect.flatMap(f(value), ([b, a]) => Effect.flatMap(ref.set(a), () => Effect.succeed(b)))));
-});
-/**
- * @since 1.20.0
- */
-export const modify = dual(2, function modify(ref, f) {
-    return modifyEffect(ref, (value) => Effect.succeed(f(value)));
-});
-const isRefSubjectDataFirst = (args) => isRefSubject(args[0]);
-/**
- * @since 1.20.0
- */
-export const runUpdates = dual(isRefSubjectDataFirst, function runUpdates(ref, f, options) {
-    if (!options) {
-        return ref.runUpdates(f);
-    }
-    else if (options.value === "initial") {
-        return ref.runUpdates((ref) => Effect.uninterruptibleMask((restore) => Effect.flatMap(ref.get, (initial) => f(ref).pipe(restore, Effect.tapErrorCause(Unify.unify((cause) => Cause.isInterruptedOnly(cause)
-            ? options.onInterrupt(initial)
-            : Effect.void))))));
-    }
-    else {
-        return ref.runUpdates((ref) => Effect.uninterruptibleMask((restore) => f(ref).pipe(restore, Effect.tapErrorCause(Unify.unify((cause) => Cause.isInterruptedOnly(cause)
-            ? Effect.flatMap(ref.get, options.onInterrupt)
-            : Effect.void)))));
-    }
-});
-class RefSubjectCore {
-    initial;
-    subject;
-    runtime;
-    scope;
-    deferredRef;
-    semaphore;
-    constructor(initial, subject, runtime, scope, deferredRef, semaphore) {
-        this.initial = initial;
-        this.subject = subject;
-        this.runtime = runtime;
-        this.scope = scope;
-        this.deferredRef = deferredRef;
-        this.semaphore = semaphore;
-    }
-    _fiber = undefined;
-}
-function makeCore(initial, options) {
-    return Effect.runtime().pipe(Effect.bindTo("runtime"), Effect.let("executionStrategy", () => options?.executionStrategy ?? ExecutionStrategy.parallel), Effect.bind("scope", ({ executionStrategy, runtime }) => Scope.fork(C.get(runtime.context, Scope.Scope), executionStrategy)), Effect.bind("id", () => Effect.fiberId), Effect.map(({ id, runtime, scope }) => unsafeMakeCore(initial, id, runtime, scope, options)), Effect.tap((core) => Scope.addFinalizer(core.scope, Effect.provide(core.subject.interrupt, core.runtime.context))));
-}
-function unsafeMakeCore(initial, id, runtime, scope, options) {
-    const subject = new Subject.HoldSubjectImpl();
-    const core = new RefSubjectCore(initial, subject, runtime, scope, DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? internal.deepEquals), subject.lastValue), Effect.unsafeMakeSemaphore(1));
-    const onSuccess = (a) => core.deferredRef.done(Exit.succeed(a));
-    const onCause = (cause) => core.deferredRef.done(Exit.failCause(cause));
-    const onError = (e) => onCause(Cause.fail(e));
-    // Initialize the core with the initial value if it is synchronous
-    matchEffectPrimitive(initial, {
-        Success: onSuccess,
-        Failure: onCause,
-        Some: onSuccess,
-        None: onError,
-        Left: onError,
-        Right: onSuccess,
-        Sync: (f) => onSuccess(f()),
-        Otherwise: () => false
-    });
-    return core;
-}
-function getOrInitializeCore(core, lockInitialize) {
-    return Effect.suspend(() => {
-        if (core._fiber === undefined && Option.isNone(MutableRef.get(core.deferredRef.current))) {
-            return initializeCoreAndTap(core, lockInitialize);
-        }
-        else {
-            return core.deferredRef;
-        }
-    });
-}
-function initializeCoreEffect(core, lock) {
-    const initialize = Effect.onExit(Effect.provide(core.initial, core.runtime.context), (exit) => Effect.sync(() => {
-        core._fiber = undefined;
-        core.deferredRef.done(exit);
-    }));
-    return Effect.flatMap(Effect.forkIn(lock ? core.semaphore.withPermits(1)(initialize) : initialize, core.scope), (fiber) => Effect.sync(() => core._fiber = fiber));
-}
-function initializeCore(core, lock) {
-    const onSuccess = (a) => {
-        core.deferredRef.done(Exit.succeed(a));
-        return Effect.succeed(Fiber.succeed(a));
-    };
-    const onCause = (cause) => {
-        core.deferredRef.done(Exit.failCause(cause));
-        return Effect.succeed(Fiber.failCause(cause));
-    };
-    const onError = (e) => onCause(Cause.fail(e));
-    return matchEffectPrimitive(core.initial, {
-        Success: onSuccess,
-        Failure: onCause,
-        Some: onSuccess,
-        None: onError,
-        Left: onError,
-        Right: onSuccess,
-        Sync: (f) => Effect.suspend(() => onSuccess(f())),
-        Otherwise: () => initializeCoreEffect(core, lock)
-    });
-}
-function initializeCoreAndTap(core, lock) {
-    return Effect.zipRight(initializeCore(core, lock), tapEventCore(core, core.deferredRef));
-}
-function setCore(core, a) {
-    const exit = Exit.succeed(a);
-    return Effect.suspend(() => {
-        if (core.deferredRef.done(exit)) {
-            // If the value changed, send an event
-            return Effect.as(sendEvent(core, exit), a);
-        }
-        else {
-            // Otherwise, just return the current value
-            return Effect.succeed(a);
-        }
-    });
-}
-function onFailureCore(core, cause) {
-    const exit = Exit.failCause(cause);
-    return Effect.suspend(() => {
-        if (core.deferredRef.done(exit)) {
-            return sendEvent(core, exit);
-        }
-        else {
-            return Effect.void;
-        }
-    });
-}
-function interruptCore(core) {
-    return Effect.fiberIdWith((id) => {
-        core.deferredRef.reset();
-        const closeScope = Scope.close(core.scope, Exit.interrupt(id));
-        const interruptFiber = core._fiber ? Fiber.interrupt(core._fiber) : Effect.void;
-        const interruptSubject = core.subject.interrupt;
-        return Effect.all([closeScope, interruptFiber, interruptSubject], { discard: true });
-    });
-}
-function deleteCore(core) {
-    return Effect.suspend(() => {
-        const current = MutableRef.get(core.deferredRef.current);
-        core.deferredRef.reset();
-        if (Option.isNone(current)) {
-            return Effect.succeed(Option.none());
-        }
-        return core.subject.subscriberCount.pipe(Effect.provide(core.runtime.context), Effect.flatMap((count) => count > 0 && !core._fiber ? initializeCore(core, false) : Effect.void), Effect.zipRight(Effect.asSome(current.value)));
-    });
-}
-function tapEventCore(core, effect) {
-    return effect.pipe(Effect.exit, Effect.tap((exit) => sendEvent(core, exit)), Effect.flatten);
-}
-function sendEvent(core, exit) {
-    if (Exit.isSuccess(exit)) {
-        return Effect.provide(core.subject.onSuccess(exit.value), core.runtime.context);
-    }
-    else {
-        return Effect.provide(core.subject.onFailure(exit.cause), core.runtime.context);
-    }
-}
-/**
- * @since 1.20.0
- */
-export const mapEffect = dual(2, function mapEffect(versioned, f) {
-    return FilteredTypeId in versioned
-        ? FilteredImpl.make(versioned, (a) => Effect.asSome(f(a)))
-        : ComputedImpl.make(versioned, f);
-});
-/**
- * @since 1.20.0
- */
-export const map = dual(2, function map(versioned, f) {
-    return mapEffect(versioned, (a) => Effect.succeed(f(a)));
-});
-/**
- * @since 1.20.0
- */
-export const filterMapEffect = dual(2, function filterMapEffect(versioned, f) {
-    return FilteredImpl.make(versioned, f);
-});
-/**
- * @since 1.20.0
- */
-export const filterMap = dual(2, function filterMap(versioned, f) {
-    return FilteredImpl.make(versioned, (a) => Effect.succeed(f(a)));
-});
-/**
- * @since 1.20.0
- */
-export const compact = function compact(versioned) {
-    return FilteredImpl.make(versioned, Effect.succeed);
-};
-/**
- * @since 1.20.0
- */
-export const filterEffect = dual(2, function filterEffect(versioned, f) {
-    return FilteredImpl.make(versioned, (a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()));
-});
-/**
- * @since 1.20.0
- */
-export const filter = dual(2, function filter(versioned, f) {
-    return FilteredImpl.make(versioned, (a) => Effect.succeed(f(a) ? Option.some(a) : Option.none()));
-});
-class ComputedImpl extends Versioned.VersionedTransform {
-    input;
-    f;
-    [ComputedTypeId] = ComputedTypeId;
-    _computed;
-    constructor(input, f) {
-        super(input, (fx) => internal.mapEffect(fx, f), Effect.flatMap(f));
-        this.input = input;
-        this.f = f;
-        this._computed = hold(internal.fromFxEffect(Effect.contextWith((ctx) => {
-            if (checkIsDOM(ctx)) {
-                return internal.fromEffect(input).pipe((_) => internal.continueWith(_, () => input), internal.skipRepeats, (_) => internal.mapEffect(_, f), internal.skipRepeats);
-            }
-            return internal.fromEffect(Effect.flatMap(input, f));
-        })));
-    }
-    run(sink) {
-        return this._computed.run(sink);
-    }
-    unsafeGet = () => Option.getOrThrowWith(this._currentValue, () => new Cause.NoSuchElementException());
-    static make(input, f) {
-        return new ComputedImpl(input, f);
-    }
-}
-class FilteredImpl extends Versioned.VersionedTransform {
-    input;
-    f;
-    [FilteredTypeId] = FilteredTypeId;
-    _filtered;
-    constructor(input, f) {
-        super(input, (fx) => internal.filterMapEffect(fx, f), (effect) => Effect.flatten(Effect.flatMap(effect, f)));
-        this.input = input;
-        this.f = f;
-        this._filtered = hold(internal.fromFxEffect(Effect.contextWith((ctx) => {
-            if (checkIsDOM(ctx)) {
-                return internal.fromEffect(input).pipe((_) => internal.continueWith(_, () => input), internal.skipRepeats, (_) => internal.filterMapEffect(_, f), internal.skipRepeats);
-            }
-            return Effect.flatMap(input, f).pipe(internal.fromEffect, (_) => internal.filterMap(_, identity));
-        })));
-    }
-    static make(input, f) {
-        return new FilteredImpl(input, f);
-    }
-    asComputed() {
-        return ComputedImpl.make(this.input, this.f);
-    }
-    run(sink) {
-        return this._filtered.run(sink);
-    }
-    unsafeGet = () => Option.getOrThrowWith(this._currentValue, () => new Cause.NoSuchElementException());
-}
-/**
- * @since 1.20.0
- */
-export const skipRepeatsWith = dual(2, function skipRepeatsWith(ref, eq) {
-    const versioned = Versioned.transform(ref, (fx) => internal.skipRepeatsWith(fx, eq), identity);
-    if (FilteredTypeId in ref) {
-        return FilteredImpl.make(versioned, Effect.succeedSome);
-    }
-    else {
-        return ComputedImpl.make(versioned, Effect.succeed);
-    }
-});
-export function skipRepeats(ref) {
-    return skipRepeatsWith(ref, internal.deepEquals);
-}
-/**
- * @since 1.20.0
- */
-export function transform(ref, from, to) {
-    return new RefSubjectTransform(ref, from, to);
-}
-/**
- * @since 1.20.0
- */
-export function transformOrFail(ref, from, to) {
-    return new RefSubjectTransformEffect(ref, from, to);
-}
-class RefSubjectTransform extends FxEffectBase {
-    ref;
-    from;
-    to;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    constructor(ref, from, to) {
-        super();
-        this.ref = ref;
-        this.from = from;
-        this.to = to;
-        this.version = ref.version;
-        this.interrupt = ref.interrupt;
-        this.subscriberCount = ref.subscriberCount;
-    }
-    run(sink) {
-        return this.ref.run(Sink.map(sink, this.from));
-    }
-    runUpdates(run) {
-        return this.ref.runUpdates((ref) => run({
-            get: Effect.map(ref.get, this.from),
-            set: (b) => Effect.map(ref.set(this.to(b)), this.from),
-            delete: Effect.map(ref.delete, Option.map(this.from))
-        }));
-    }
-    unsafeGet = () => {
-        const exit = this.ref.unsafeGet();
-        return Exit.map(exit, this.from);
-    };
-    onFailure(cause) {
-        return this.ref.onFailure(cause);
-    }
-    onSuccess(value) {
-        return this.ref.onSuccess(this.to(value));
-    }
-    toEffect() {
-        return Effect.map(this.ref, this.from);
-    }
-}
-class RefSubjectTransformEffect extends FxEffectBase {
-    ref;
-    from;
-    to;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    subject;
-    constructor(ref, from, to) {
-        super();
-        this.ref = ref;
-        this.from = from;
-        this.to = to;
-        this.version = ref.version;
-        this.interrupt = ref.interrupt;
-        this.subscriberCount = ref.subscriberCount;
-        this.subject = new Subject.HoldSubjectImpl();
-    }
-    run(sink) {
-        return internal.skipRepeats(internal.merge(internal.tapEffect(internal.mapEffect(this.ref, this.from), this.subject.onSuccess), this.subject)).run(sink);
-    }
-    runUpdates(run) {
-        return this.ref.runUpdates((ref) => run({
-            get: Effect.flatMap(ref.get, this.from),
-            set: (b) => Effect.matchCauseEffect(Effect.flatMap(this.to(b), ref.set), {
-                onFailure: (cause) => Effect.as(this.subject.onFailure(cause), b),
-                onSuccess: () => Effect.as(this.subject.onSuccess(b), b)
-            }),
-            delete: Effect.flatMap(ref.delete, Option.match({
-                onNone: () => Effect.succeedNone,
-                onSome: (b) => Effect.asSome(this.from(b))
-            }))
-        }));
-    }
-    unsafeGet = () => {
-        return Option.getOrThrowWith(MutableRef.get(this.subject.lastValue), () => new Cause.NoSuchElementException());
-    };
-    onFailure(cause) {
-        return this.subject.onFailure(cause);
-    }
-    onSuccess(value) {
-        return Effect.matchCauseEffect(this.to(value), {
-            onFailure: (cause) => this.subject.onFailure(cause),
-            onSuccess: (a) => this.ref.onSuccess(a)
-        });
-    }
-    toEffect() {
-        return Effect.flatMap(this.ref, this.from);
-    }
-}
-/**
- * @since 1.20.0
- */
-export function tuple(refs) {
-    const kind = getRefKind(refs);
-    switch (kind) {
-        case "r":
-            return makeTupleRef(refs);
-        case "c":
-            return makeTupleComputed(refs);
-        case "f":
-            return makeTupleFiltered(refs);
-    }
-}
-const join = (a, b) => {
-    if (a === "r")
-        return b;
-    if (b === "r")
-        return a;
-    if (a === "f")
-        return a;
-    if (b === "f")
-        return b;
-    return "c";
-};
-function getRefKind(refs) {
-    let kind = "r";
-    for (const ref of refs) {
-        if (FilteredTypeId in ref) {
-            kind = "f";
-            break;
-        }
-        else if (!(RefSubjectTypeId in ref)) {
-            kind = join(kind, "c");
-        }
-    }
-    return kind;
-}
-function makeTupleRef(refs) {
-    return new RefSubjectTuple(refs);
-}
-class RefSubjectTuple extends FxEffectBase {
-    refs;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    versioned;
-    getSetDelete;
-    constructor(refs) {
-        super();
-        this.refs = refs;
-        this.versioned = Versioned.hold(Versioned.tuple(refs));
-        this.version = this.versioned.version;
-        this.interrupt = Effect.all(refs.map((r) => r.interrupt), UNBOUNDED);
-        this.subscriberCount = Effect.map(Effect.all(refs.map((r) => r.subscriberCount), UNBOUNDED), Array.reduce(0, sum));
-        this.getSetDelete = {
-            get: this.versioned,
-            set: (a) => Effect.all(refs.map((r, i) => set(r, a[i])), UNBOUNDED),
-            delete: Effect.map(Effect.all(refs.map((r) => reset(r)), UNBOUNDED), Option.all)
-        };
-        this.runUpdates = this.runUpdates.bind(this);
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
-    run(sink) {
-        return this.versioned.run(sink);
-    }
-    toEffect() {
-        return this.versioned;
-    }
-    runUpdates(run) {
-        return run(this.getSetDelete);
-    }
-    unsafeGet = () => {
-        return Option.getOrThrowWith(Exit.all(this.refs.map((r) => r.unsafeGet())), () => new Cause.NoSuchElementException());
-    };
-    onFailure(cause) {
-        return Effect.all(this.refs.map((ref) => ref.onFailure(cause)));
-    }
-    onSuccess(value) {
-        return Effect.catchAllCause(this.getSetDelete.set(value), (c) => this.onFailure(c));
-    }
-}
-function makeTupleComputed(refs) {
-    return new ComputedImpl(Versioned.tuple(refs), Effect.succeed);
-}
-function makeTupleFiltered(refs) {
-    return new FilteredImpl(Versioned.tuple(refs), Effect.succeedSome);
-}
-/**
- * @since 1.20.0
- */
-export function struct(refs) {
-    const kind = getRefKind(Object.values(refs));
-    switch (kind) {
-        case "r":
-            return makeStructRef(refs);
-        case "c":
-            return makeStructComputed(refs);
-        case "f":
-            return makeStructFiltered(refs);
-    }
-}
-function makeStructRef(refs) {
-    return new RefSubjectStruct(refs);
-}
-class RefSubjectStruct extends FxEffectBase {
-    refs;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    versioned;
-    getSetDelete;
-    constructor(refs) {
-        super();
-        this.refs = refs;
-        this.versioned = Versioned.hold(Versioned.struct(refs));
-        this.version = this.versioned.version;
-        this.interrupt = Effect.all(Object.values(refs).map((r) => r.interrupt), UNBOUNDED);
-        this.subscriberCount = Effect.map(Effect.all(Object.values(refs).map((r) => r.subscriberCount), UNBOUNDED), Array.reduce(0, sum));
-        this.getSetDelete = {
-            get: this.versioned,
-            set: (a) => Effect.all(Object.keys(refs).map((k) => set(refs[k], a[k])), UNBOUNDED),
-            delete: Effect.map(Effect.all(Object.values(refs).map((r) => reset(r)), UNBOUNDED), Option.all)
-        };
-        this.runUpdates = this.runUpdates.bind(this);
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
-    run(sink) {
-        return this.versioned.run(sink);
-    }
-    toEffect() {
-        return this.versioned;
-    }
-    runUpdates(run) {
-        return run(this.getSetDelete);
-    }
-    unsafeGet = () => {
-        const entries = Object.entries(this.refs).map(([k, r]) => Exit.map(r.unsafeGet(), (a) => [k, a]));
-        const exit = Option.getOrThrowWith(Exit.all(entries), () => new Cause.NoSuchElementException());
-        return Exit.map(exit, (entries) => Object.fromEntries(entries));
-    };
-    onFailure(cause) {
-        return Effect.all(Object.values(this.refs).map((ref) => ref.onFailure(cause)));
-    }
-    onSuccess(value) {
-        return Effect.catchAllCause(this.getSetDelete.set(value), (c) => this.onFailure(c));
-    }
-}
-function makeStructComputed(refs) {
-    return new ComputedImpl(Versioned.struct(refs), Effect.succeed);
-}
-function makeStructFiltered(refs) {
-    return new FilteredImpl(Versioned.struct(refs), Effect.succeedSome);
-}
-/**
- * @since 1.20.0
- */
-export function tagged(replay) {
-    return (identifier) => new RefSubjectTagged(C.Tagged(identifier), replay);
-}
-class RefSubjectTagged extends FxEffectBase {
-    tag;
-    replay;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    constructor(tag, replay = 0) {
-        super();
-        this.tag = tag;
-        this.replay = replay;
-        this.version = tag.withEffect((ref) => ref.version);
-        this.interrupt = tag.withEffect((ref) => ref.interrupt);
-        this.subscriberCount = tag.withEffect((ref) => ref.subscriberCount);
-        this.runUpdates = this.runUpdates.bind(this);
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
-    run(sink) {
-        return this.tag.withEffect((ref) => ref.run(sink));
-    }
-    toEffect() {
-        return this.tag.withEffect((ref) => ref);
-    }
-    runUpdates(run) {
-        return this.tag.withEffect((ref) => ref.runUpdates(run));
-    }
-    unsafeGet = () => {
-        throw new Error(`Unable to unsafely get a tagged RefSubject because it requires the Effect context by defnition.`);
-    };
-    onFailure(cause) {
-        return this.tag.withEffect((ref) => ref.onFailure(cause));
-    }
-    onSuccess(value) {
-        return this.tag.withEffect((ref) => ref.onSuccess(value));
-    }
-    layer = (make) => this.tag.scoped(make);
-    make = (fxOrEffect, options) => {
-        return this.tag.scoped(Effect.gen(function* (_) {
-            let ref = yield* make(fxOrEffect, options);
-            if (options?.drop || options?.take) {
-                ref = slice(ref, options.drop ?? 0, options.take ?? Infinity);
-            }
-            return ref;
-        }));
-    };
-}
-/**
- * @since 1.20.0
- */
-export function fromTag(tag, f) {
-    return new RefSubjectFromTag(tag, f);
-}
-class RefSubjectFromTag extends FxEffectBase {
-    tag;
-    f;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    _get;
-    _fx;
-    constructor(tag, f) {
-        super();
-        this.tag = tag;
-        this.f = f;
-        this._get = Effect.map(tag, f);
-        this._fx = internal.fromFxEffect(this._get);
-        this.version = Effect.flatMap(this._get, (ref) => ref.version);
-        this.interrupt = Effect.flatMap(this._get, (ref) => ref.interrupt);
-        this.subscriberCount = Effect.flatMap(this._get, (ref) => ref.subscriberCount);
-    }
-    run(sink) {
-        return this._fx.run(sink);
-    }
-    toEffect() {
-        return Effect.flatten(this._get);
-    }
-    runUpdates(run) {
-        return Effect.flatMap(this._get, (ref) => ref.runUpdates(run));
-    }
-    unsafeGet = () => {
-        throw new Error(`Unable to unsafely get a tagged RefSubject because it requires the Effect context by defnition.`);
-    };
-    onFailure(cause) {
-        return Effect.flatMap(this._get, (ref) => ref.onFailure(cause));
-    }
-    onSuccess(value) {
-        return Effect.flatMap(this._get, (ref) => ref.onSuccess(value));
-    }
-}
-export function isRefSubject(u) {
-    return isObjectLike(u) && RefSubjectTypeId in u;
-}
-export function isComputed(u) {
-    return isObjectLike(u) && ComputedTypeId in u;
-}
-export function isFiltered(u) {
-    return isObjectLike(u) && FilteredTypeId in u;
-}
-export function isDerived(u) {
-    return isRefSubject(u) && "persist" in u;
-}
-function isObjectLike(u) {
-    if (u == null)
-        return false;
-    const type = typeof u;
-    return (type === "object" && !Array.isArray(u)) || type === "function";
-}
-/**
- * @since 1.20.0
- */
-export function computedFromTag(tag, f) {
-    return new ComputedFromTag(tag, f);
-}
-class ComputedFromTag extends FxEffectBase {
-    tag;
-    f;
-    [ComputedTypeId] = ComputedTypeId;
-    version;
-    _get;
-    constructor(tag, f) {
-        super();
-        this.tag = tag;
-        this.f = f;
-        this._get = Effect.map(tag, f);
-        this.version = Effect.flatMap(this._get, (ref) => ref.version);
-    }
-    run(sink) {
-        return Effect.flatMap(this._get, (ref) => ref.run(sink));
-    }
-    toEffect() {
-        return Effect.flatten(this._get);
-    }
-    unsafeGet = () => {
-        throw new Error(`Unable to unsafely get a tagged Computed because it requires the Effect context by defnition.`);
-    };
-}
-/**
- * @since 1.20.0
- */
-export function filteredFromTag(tag, f) {
-    return new FilteredFromTag(tag, f);
-}
-class FilteredFromTag extends FxEffectBase {
-    tag;
-    f;
-    [FilteredTypeId] = FilteredTypeId;
-    version;
-    _get;
-    constructor(tag, f) {
-        super();
-        this.tag = tag;
-        this.f = f;
-        this._get = Effect.map(tag, f);
-        this.version = Effect.flatMap(this._get, (ref) => ref.version);
-    }
-    run(sink) {
-        return Effect.flatMap(this._get, (ref) => ref.run(sink));
-    }
-    toEffect() {
-        return Effect.flatten(this._get);
-    }
-    asComputed() {
-        return new ComputedFromTag(this.tag, (s) => this.f(s).asComputed());
-    }
-    unsafeGet = () => {
-        throw new Error(`Unable to unsafely get a tagged Filtered because it requires the Effect context by defnition.`);
-    };
-}
-/**
- * @since 1.20.0
- */
-export const provide = dual(2, function provide(ref, providing) {
-    const layer = Layer.isLayer(providing)
-        ? providing
-        : C.isContext(providing)
-            ? Layer.succeedContext(providing)
-            : runtimeToLayer(providing);
-    if (isComputed(ref)) {
-        return ComputedImpl.make(Versioned.provide(ref, layer), Effect.succeed);
-    }
-    else if (isFiltered(ref)) {
-        return FilteredImpl.make(Versioned.provide(ref, layer), Effect.succeedSome);
-    }
-    else {
-        return new RefSubjectProvide(ref, layer);
-    }
-});
-class RefSubjectProvide extends FxEffectBase {
-    ref;
-    layer;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    interrupt;
-    subscriberCount;
-    constructor(ref, layer) {
-        super();
-        this.ref = ref;
-        this.layer = layer;
-        this.interrupt = Effect.provide(ref.interrupt, layer);
-        this.subscriberCount = Effect.provide(ref.subscriberCount, layer);
-    }
-    run(sink) {
-        return Effect.provide(this.ref.run(sink), this.layer);
-    }
-    toEffect() {
-        return Effect.provide(this.ref, this.layer);
-    }
-}
-/**
- * Set the value to true
- * @since 1.18.0
- */
-export const asTrue = (ref) => set(ref, true);
-/**
- * Set the value to false
- * @since 1.18.0
- */
-export const asFalse = (ref) => set(ref, false);
-/**
- * Toggle the boolean value between true and false
- * @since 1.18.0
- */
-export const toggle = (ref) => update(ref, Boolean.not);
-const add = (x) => x + 1;
-/**
- * Set the value to true
- * @since 1.18.0
- */
-export const increment = (ref) => update(ref, add);
-const sub = (x) => x - 1;
-/**
- * Set the value to false
- * @since 1.18.0
- */
-export const decrement = (ref) => update(ref, sub);
-/**
- * @since 1.20.0
- */
-export const slice = dual(3, function slice(ref, drop, take) {
-    return new RefSubjectSimpleTransform(ref, (_) => internal.slice(_, drop, take), identity);
-});
-/**
- * @since 1.20.0
- */
-export const drop = dual(2, function drop(ref, drop) {
-    return slice(ref, drop, Infinity);
-});
-/**
- * @since 1.20.0
- */
-export const take = dual(2, function take(ref, take) {
-    return slice(ref, 0, take);
-});
-/**
- * Get the current value of the RefSubject. If it has not been set yet, a Fiber will be used to wait for the value to be set.
- *
- * @since 1.25.0
- */
-export const get = (ref) => ref;
-/**
- * Synchronously get the current Exit value of the RefSubject. If it has not been set yet, a Cause.NoSuchElementException will be thrown.
- *
- * Note: This is unimplemented for RefSubject.tagged and RefSubject.fromTag because they require the Effect context by definition.
- * It will throw immediately.
- *
- * @since 1.25.0
- */
-export const unsafeGetExit = (ref) => ref.unsafeGet();
-/**
- * Synchronously get the current value of the RefSubject.
- *
- * @since 1.25.0
- */
-export const unsafeGet = (ref) => Effect.runSync(unsafeGetExit(ref));
-/**
- * Extract all values from an object using a Proxy
- *
- * @since 2.0.0
- */
-export const proxy = (source) => {
-    const target = {};
-    return new Proxy(target, {
-        get(self, prop) {
-            if (prop in self)
-                return self[prop];
-            return self[prop] = map(source, (a) => a[prop]);
-        }
-    });
-};
-/**
- * @since 2.0.0
- */
-export const withSpan = dual(isRefSubjectDataFirst, (ref, name, options) => new RefSubjectSimpleTransform(ref, (fx) => internal.withSpan(fx, name, options), Effect.withSpan(name, options)));
-class RefSubjectSimpleTransform extends FxEffectBase {
-    ref;
-    transformFx;
-    transformEffect;
-    [ComputedTypeId] = ComputedTypeId;
-    [RefSubjectTypeId] = RefSubjectTypeId;
-    version;
-    interrupt;
-    subscriberCount;
-    _fx;
-    constructor(ref, transformFx, transformEffect) {
-        super();
-        this.ref = ref;
-        this.transformFx = transformFx;
-        this.transformEffect = transformEffect;
-        this.version = ref.version;
-        this.interrupt = ref.interrupt;
-        this.subscriberCount = ref.subscriberCount;
-        this._fx = transformFx(ref);
-    }
-    run(sink) {
-        return this._fx.run(sink);
-    }
-    toEffect() {
-        return this.transformEffect(this.ref);
-    }
-    runUpdates(run) {
-        return this.ref.runUpdates(run);
-    }
-    unsafeGet = () => this.ref.unsafeGet();
-    onFailure(cause) {
-        return this.ref.onFailure(cause);
-    }
-    onSuccess(value) {
-        return this.ref.onSuccess(value);
-    }
-}
-/**
- * @since 2.0.0
- */
-export const when = dual(2, function when(ref, options) {
-    return map(ref, (a) => a ? options.onTrue : options.onFalse);
-});
-//# sourceMappingURL=RefSubject.js.map