@typed/fx 1.32.0 → 2.0.0-beta.0

package/dist/cjs/RefSubject.js

@@ -1,1115 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.compact = exports.asTrue = exports.asFalse = void 0;
-exports.computedFromTag = computedFromTag;
-exports.filterMapEffect = exports.filterMap = exports.filterEffect = exports.filter = exports.drop = exports.decrement = void 0;
-exports.filteredFromTag = filteredFromTag;
-exports.fromEffect = fromEffect;
-exports.fromFx = fromFx;
-exports.fromRefSubject = fromRefSubject;
-exports.fromTag = fromTag;
-exports.increment = exports.get = void 0;
-exports.isComputed = isComputed;
-exports.isDerived = isDerived;
-exports.isFiltered = isFiltered;
-exports.isRefSubject = isRefSubject;
-exports.modifyEffect = exports.modify = exports.mapEffect = exports.map = exports.make = void 0;
-exports.of = of;
-exports.proxy = exports.provide = void 0;
-exports.delete = exports.reset = reset;
-exports.set = exports.runUpdates = void 0;
-exports.skipRepeats = skipRepeats;
-exports.slice = exports.skipRepeatsWith = void 0;
-exports.struct = struct;
-exports.tagged = tagged;
-exports.toggle = exports.take = void 0;
-exports.transform = transform;
-exports.transformOrFail = transformOrFail;
-exports.tuple = tuple;
-exports.unsafeGetExit = exports.unsafeGet = void 0;
-exports.unsafeMake = unsafeMake;
-exports.withSpan = exports.when = exports.updateEffect = exports.update = void 0;
-var C = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@typed/context"));
-var Array = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Array"));
-var Boolean = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Boolean"));
-var Cause = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Cause"));
-var Effect = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Effect"));
-var ExecutionStrategy = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/ExecutionStrategy"));
-var Exit = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Exit"));
-var Fiber = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Fiber"));
-var _Function = /*#__PURE__*/require("effect/Function");
-var Layer = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Layer"));
-var MutableRef = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/MutableRef"));
-var _Number = /*#__PURE__*/require("effect/Number");
-var Option = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Option"));
-var Scope = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Scope"));
-var Unify = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Unify"));
-var internal = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./internal/core.js"));
-var DeferredRef = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./internal/DeferredRef.js"));
-var _helpers = /*#__PURE__*/require("./internal/helpers.js");
-var _protos = /*#__PURE__*/require("./internal/protos.js");
-var _provide = /*#__PURE__*/require("./internal/provide.js");
-var _share = /*#__PURE__*/require("./internal/share.js");
-var Sink = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./Sink.js"));
-var Subject = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./Subject.js"));
-var _TypeId = /*#__PURE__*/require("./TypeId.js");
-var Versioned = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./Versioned.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/**
- * A RefSubject is a Subject that can be used to read and write a value.
- * @since 1.20.0
- */
-
-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 = /*#__PURE__*/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
- */
-function fromEffect(effect, options) {
-  return Effect.map(makeCore(effect, options), core => new RefSubjectImpl(core));
-}
-/**
- * @since 1.20.0
- */
-function fromFx(fx, options) {
-  return DeferredRef.make((0, _helpers.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
- */
-function fromRefSubject(ref, options) {
-  return DeferredRef.make((0, _helpers.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
- */
-const make = exports.make = function make(fxOrEffect, options) {
-  if (_TypeId.RefSubjectTypeId in fxOrEffect) return fromRefSubject(fxOrEffect, options);else if (_TypeId.FxTypeId in fxOrEffect) return fromFx(fxOrEffect, options);else return fromEffect(fxOrEffect, options);
-};
-/**
- * @since 1.20.0
- */
-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 => (0, _helpers.withScope)(scope => f(scope, id), strategy));
-/**
- * @since 1.20.0
- */
-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 _protos.FxEffectBase {
-  core;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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
- */
-const set = exports.set = /*#__PURE__*/(0, _Function.dual)(2, function set(ref, a) {
-  return ref.runUpdates(ref => ref.set(a));
-});
-/**
- * @since 1.20.0
- */
-function reset(ref) {
-  return ref.runUpdates(ref => ref.delete);
-}
-/**
- * @since 1.20.0
- */
-
-function getSetDelete(ref) {
-  return {
-    get: getOrInitializeCore(ref, false),
-    set: a => setCore(ref, a),
-    delete: deleteCore(ref)
-  };
-}
-/**
- * @since 1.20.0
- */
-const updateEffect = exports.updateEffect = /*#__PURE__*/(0, _Function.dual)(2, function updateEffect(ref, f) {
-  return ref.runUpdates(ref => Effect.flatMap(Effect.flatMap(ref.get, f), ref.set));
-});
-/**
- * @since 1.20.0
- */
-const update = exports.update = /*#__PURE__*/(0, _Function.dual)(2, function update(ref, f) {
-  return updateEffect(ref, value => Effect.succeed(f(value)));
-});
-/**
- * @since 1.20.0
- */
-const modifyEffect = exports.modifyEffect = /*#__PURE__*/(0, _Function.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
- */
-const modify = exports.modify = /*#__PURE__*/(0, _Function.dual)(2, function modify(ref, f) {
-  return modifyEffect(ref, value => Effect.succeed(f(value)));
-});
-const isRefSubjectDataFirst = args => isRefSubject(args[0]);
-/**
- * @since 1.20.0
- */
-const runUpdates = exports.runUpdates = /*#__PURE__*/(0, _Function.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, (0, _helpers.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
-  (0, _helpers.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 (0, _helpers.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
- */
-const mapEffect = exports.mapEffect = /*#__PURE__*/(0, _Function.dual)(2, function mapEffect(versioned, f) {
-  return _TypeId.FilteredTypeId in versioned ? FilteredImpl.make(versioned, a => Effect.asSome(f(a))) : ComputedImpl.make(versioned, f);
-});
-/**
- * @since 1.20.0
- */
-const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, function map(versioned, f) {
-  return mapEffect(versioned, a => Effect.succeed(f(a)));
-});
-/**
- * @since 1.20.0
- */
-const filterMapEffect = exports.filterMapEffect = /*#__PURE__*/(0, _Function.dual)(2, function filterMapEffect(versioned, f) {
-  return FilteredImpl.make(versioned, f);
-});
-/**
- * @since 1.20.0
- */
-const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, function filterMap(versioned, f) {
-  return FilteredImpl.make(versioned, a => Effect.succeed(f(a)));
-});
-/**
- * @since 1.20.0
- */
-const compact = exports.compact = function compact(versioned) {
-  return FilteredImpl.make(versioned, Effect.succeed);
-};
-/**
- * @since 1.20.0
- */
-const filterEffect = exports.filterEffect = /*#__PURE__*/(0, _Function.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
- */
-const filter = exports.filter = /*#__PURE__*/(0, _Function.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;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  _computed;
-  constructor(input, f) {
-    super(input, fx => internal.mapEffect(fx, f), Effect.flatMap(f));
-    this.input = input;
-    this.f = f;
-    this._computed = (0, _share.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;
-  [_TypeId.FilteredTypeId] = _TypeId.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 = (0, _share.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(_, _Function.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
- */
-const skipRepeatsWith = exports.skipRepeatsWith = /*#__PURE__*/(0, _Function.dual)(2, function skipRepeatsWith(ref, eq) {
-  const versioned = Versioned.transform(ref, fx => internal.skipRepeatsWith(fx, eq), _Function.identity);
-  if (_TypeId.FilteredTypeId in ref) {
-    return FilteredImpl.make(versioned, Effect.succeedSome);
-  } else {
-    return ComputedImpl.make(versioned, Effect.succeed);
-  }
-});
-function skipRepeats(ref) {
-  return skipRepeatsWith(ref, internal.deepEquals);
-}
-/**
- * @since 1.20.0
- */
-function transform(ref, from, to) {
-  return new RefSubjectTransform(ref, from, to);
-}
-/**
- * @since 1.20.0
- */
-function transformOrFail(ref, from, to) {
-  return new RefSubjectTransformEffect(ref, from, to);
-}
-class RefSubjectTransform extends _protos.FxEffectBase {
-  ref;
-  from;
-  to;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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 _protos.FxEffectBase {
-  ref;
-  from;
-  to;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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
- */
-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 (_TypeId.FilteredTypeId in ref) {
-      kind = "f";
-      break;
-    } else if (!(_TypeId.RefSubjectTypeId in ref)) {
-      kind = join(kind, "c");
-    }
-  }
-  return kind;
-}
-function makeTupleRef(refs) {
-  return new RefSubjectTuple(refs);
-}
-class RefSubjectTuple extends _protos.FxEffectBase {
-  refs;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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, _Number.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
- */
-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 _protos.FxEffectBase {
-  refs;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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, _Number.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
- */
-function tagged(replay) {
-  return identifier => new RefSubjectTagged(C.Tagged(identifier), replay);
-}
-class RefSubjectTagged extends _protos.FxEffectBase {
-  tag;
-  replay;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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
- */
-function fromTag(tag, f) {
-  return new RefSubjectFromTag(tag, f);
-}
-class RefSubjectFromTag extends _protos.FxEffectBase {
-  tag;
-  f;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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));
-  }
-}
-function isRefSubject(u) {
-  return isObjectLike(u) && _TypeId.RefSubjectTypeId in u;
-}
-function isComputed(u) {
-  return isObjectLike(u) && _TypeId.ComputedTypeId in u;
-}
-function isFiltered(u) {
-  return isObjectLike(u) && _TypeId.FilteredTypeId in u;
-}
-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
- */
-function computedFromTag(tag, f) {
-  return new ComputedFromTag(tag, f);
-}
-class ComputedFromTag extends _protos.FxEffectBase {
-  tag;
-  f;
-  [_TypeId.ComputedTypeId] = _TypeId.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
- */
-function filteredFromTag(tag, f) {
-  return new FilteredFromTag(tag, f);
-}
-class FilteredFromTag extends _protos.FxEffectBase {
-  tag;
-  f;
-  [_TypeId.FilteredTypeId] = _TypeId.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
- */
-const provide = exports.provide = /*#__PURE__*/(0, _Function.dual)(2, function provide(ref, providing) {
-  const layer = Layer.isLayer(providing) ? providing : C.isContext(providing) ? Layer.succeedContext(providing) : (0, _provide.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 _protos.FxEffectBase {
-  ref;
-  layer;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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
- */
-const asTrue = ref => set(ref, true);
-/**
- * Set the value to false
- * @since 1.18.0
- */
-exports.asTrue = asTrue;
-const asFalse = ref => set(ref, false);
-/**
- * Toggle the boolean value between true and false
- * @since 1.18.0
- */
-exports.asFalse = asFalse;
-const toggle = ref => update(ref, Boolean.not);
-exports.toggle = toggle;
-const add = x => x + 1;
-/**
- * Set the value to true
- * @since 1.18.0
- */
-const increment = ref => update(ref, add);
-exports.increment = increment;
-const sub = x => x - 1;
-/**
- * Set the value to false
- * @since 1.18.0
- */
-const decrement = ref => update(ref, sub);
-/**
- * @since 1.20.0
- */
-exports.decrement = decrement;
-const slice = exports.slice = /*#__PURE__*/(0, _Function.dual)(3, function slice(ref, drop, take) {
-  return new RefSubjectSimpleTransform(ref, _ => internal.slice(_, drop, take), _Function.identity);
-});
-/**
- * @since 1.20.0
- */
-const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, function drop(ref, drop) {
-  return slice(ref, drop, Infinity);
-});
-/**
- * @since 1.20.0
- */
-const take = exports.take = /*#__PURE__*/(0, _Function.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
- */
-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
- */
-exports.get = get;
-const unsafeGetExit = ref => ref.unsafeGet();
-/**
- * Synchronously get the current value of the RefSubject.
- *
- * @since 1.25.0
- */
-exports.unsafeGetExit = unsafeGetExit;
-const unsafeGet = ref => Effect.runSync(unsafeGetExit(ref));
-/**
- * Extract all values from an object using a Proxy
- *
- * @since 2.0.0
- */
-exports.unsafeGet = unsafeGet;
-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
- */
-exports.proxy = proxy;
-const withSpan = exports.withSpan = /*#__PURE__*/(0, _Function.dual)(isRefSubjectDataFirst, (ref, name, options) => new RefSubjectSimpleTransform(ref, fx => internal.withSpan(fx, name, options), Effect.withSpan(name, options)));
-class RefSubjectSimpleTransform extends _protos.FxEffectBase {
-  ref;
-  transformFx;
-  transformEffect;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  [_TypeId.RefSubjectTypeId] = _TypeId.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
- */
-const when = exports.when = /*#__PURE__*/(0, _Function.dual)(2, function when(ref, options) {
-  return map(ref, a => a ? options.onTrue : options.onFalse);
-});
-//# sourceMappingURL=RefSubject.js.map