@typed/fx 1.17.4 → 1.18.0

package/dist/cjs/RefSubject.js

@@ -1,436 +1,239 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asRef = exports.isRefSubject = exports.RefSubject = exports.makeRef = exports.RefSubjectTypeId = void 0;
-const Context = __importStar(require("@effect/data/Context"));
-const Equal = __importStar(require("@effect/data/Equal"));
-const Equivalence = __importStar(require("@effect/data/Equivalence"));
-const Function_1 = require("@effect/data/Function");
-const Hash = __importStar(require("@effect/data/Hash"));
-const MutableRef = __importStar(require("@effect/data/MutableRef"));
-const Option = __importStar(require("@effect/data/Option"));
-const Pipeable_1 = require("@effect/data/Pipeable");
-const Deferred = __importStar(require("@effect/io/Deferred"));
-const Effect = __importStar(require("@effect/io/Effect"));
-const Fiber = __importStar(require("@effect/io/Fiber"));
-const Scope = __importStar(require("@effect/io/Scope"));
-const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const Computed_js_1 = require("./Computed.js");
-const Filtered_js_1 = require("./Filtered.js");
-const Fx_js_1 = require("./Fx.js");
-const RefTransform_js_1 = require("./RefTransform.js");
-const combineAll_js_1 = require("./combineAll.js");
-const hold_js_1 = require("./hold.js");
-const mergeAll_js_1 = require("./mergeAll.js");
-const never_js_1 = require("./never.js");
-const observe_js_1 = require("./observe.js");
-const struct_js_1 = require("./struct.js");
-const succeed_js_1 = require("./succeed.js");
-const switchMatch_js_1 = require("./switchMatch.js");
-const unboundedConcurrency = { concurrency: 'unbounded' };
-const refVariance = {
-    _R: Function_1.identity,
-    _E: Function_1.identity,
-    _A: Function_1.identity,
+exports.compact = void 0;
+exports.deriveFromSchema = deriveFromSchema;
+exports.deriveToSchema = deriveToSchema;
+exports.fromEffect = fromEffect;
+exports.fromSubscriptionRef = fromSubscriptionRef;
+exports.make = make;
+exports.makeWithExtension = makeWithExtension;
+exports.of = of;
+exports.struct = exports.split = void 0;
+exports.sync = sync;
+exports.tagged = tagged;
+exports.unsafeMake = exports.tuple = exports.transform = void 0;
+var C = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@typed/context"));
+var _effect = /*#__PURE__*/require("effect");
+var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
+var _Equal = /*#__PURE__*/require("effect/Equal");
+var _Function = /*#__PURE__*/require("effect/Function");
+var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Option"));
+var _Computed = /*#__PURE__*/require("./Computed");
+var _Filtered = /*#__PURE__*/require("./Filtered");
+var _core = /*#__PURE__*/require("./internal/core");
+var coreRefSubject = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/core-ref-subject"));
+var _fx = /*#__PURE__*/require("./internal/fx");
+var _protos = /*#__PURE__*/require("./internal/protos");
+var _schemaRefSubject = /*#__PURE__*/require("./internal/schema-ref-subject");
+var _TypeId = /*#__PURE__*/require("./TypeId");
+var Versioned = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Versioned"));
+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 && Object.prototype.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 the core abstraction for keeping state and subscribing to its
+ * changes over time.
+ *
+ * @since 1.18.0
+ */
+
+/**
+ * Construct a RefSubject with a lazily initialized value.
+ * @since 1.18.0
+ * @category constructors
+ */
+function fromEffect(initial, eq) {
+  return coreRefSubject.fromEffect(initial, eq);
+}
+/**
+ * Construct a RefSubject from a synchronous value.
+ * @since 1.18.0
+ * @category constructors
+ */
+function of(initial, eq) {
+  return fromEffect(Effect.succeed(initial), eq);
+}
+/**
+ * Construct a RefSubject from a synchronous value.
+ * @since 1.18.0
+ * @category constructors
+ */
+function sync(initial, eq) {
+  return fromEffect(Effect.sync(initial), eq);
+}
+function make(fx, eq) {
+  return coreRefSubject.make(fx, eq);
+}
+function tagged(defaultEq) {
+  function makeTagged(identifier) {
+    return new ContextImpl(C.Tagged(identifier), defaultEq);
+  }
+  return makeTagged;
+}
+class ContextImpl extends _protos.FxEffectBase {
+  tag;
+  defaultEq;
+  [_TypeId.RefSubjectTypeId] = _TypeId.RefSubjectTypeId;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  version;
+  subscriberCount;
+  get;
+  delete;
+  interrupt;
+  constructor(tag, defaultEq) {
+    super();
+    this.tag = tag;
+    this.defaultEq = defaultEq;
+    this.version = tag.withEffect(ref => ref.version);
+    this.subscriberCount = tag.withEffect(ref => ref.subscriberCount);
+    this.get = tag.withEffect(ref => ref.get);
+    this.delete = tag.withEffect(ref => ref.delete);
+    this.interrupt = tag.withEffect(r => r.interrupt);
+  }
+  toFx() {
+    return (0, _fx.fromFxEffect)(this.tag);
+  }
+  toEffect() {
+    return this.get;
+  }
+  runUpdate = (f, onInterrupt) => this.tag.withEffect(ref => ref.runUpdate(f, onInterrupt));
+  modifyEffect = f => this.tag.withEffect(ref => ref.modifyEffect(f));
+  modify = f => this.tag.withEffect(ref => ref.modify(f));
+  updateEffect = f => this.tag.withEffect(ref => ref.updateEffect(f));
+  update = f => this.tag.withEffect(ref => ref.update(f));
+  set = a => this.tag.withEffect(ref => ref.set(a));
+  mapEffect = f => (0, _Computed.Computed)(this, f);
+  map = f => (0, _Computed.Computed)(this, a => Effect.sync(() => f(a)));
+  filterMapEffect = f => (0, _Filtered.Filtered)(this, f);
+  filterMap = f => (0, _Filtered.Filtered)(this, a => Effect.sync(() => f(a)));
+  filter = f => this.filterMap(a => f(a) ? Option.some(a) : Option.none());
+  filterEffect = f => this.filterMapEffect(a => Effect.map(f(a), b => b ? Option.some(a) : Option.none()));
+  skipRepeats = (eq = _Equal.equals) => (0, _Computed.fromTag)(this.tag, s => s.skipRepeats(eq));
+  onFailure = cause => this.tag.withEffect(ref => ref.onFailure(cause));
+  onSuccess = a => this.tag.withEffect(ref => ref.onSuccess(a));
+  make = (fx, eq) => this.tag.scoped(make(fx, eq || this.defaultEq));
+  of = (value, eq) => this.tag.scoped(of(value, eq));
+  provide = (fx, eq) => Effect.provide(this.make(fx, eq || this.defaultEq));
+  provideFx = (fx, eq) => (0, _core.provide)(this.make(fx, eq || this.defaultEq));
+}
+function makeWithExtension(fx, f, eq) {
+  return coreRefSubject.makeWithExtension(fx, f, eq);
+}
+/**
+ * Construct a RefSubject with an initial value and the specified subject.
+ * @since 1.18.0
+ * @category constructors
+ */
+const unsafeMake = exports.unsafeMake = coreRefSubject.unsafeMake;
+/**
+ * Flatten an RefSubject of an Option into a Filtered.
+ * @since 1.18.0
+ * @category combinators
+ */
+const compact = refSubject => refSubject.filterMap(_effect.identity);
+/**
+ * Split a RefSubject's into 2 Filtered values that track its errors and
+ * success values separately.
+ * @since 1.18.0
+ * @category combinators
+ */
+exports.compact = compact;
+const split = refSubject => {
+  const versioned = Versioned.transform(refSubject, _fx.exit, Effect.exit);
+  const left = (0, _Filtered.Filtered)(versioned, getLeft);
+  const right = (0, _Filtered.Filtered)(versioned, getRight);
+  return [left, right];
 };
-exports.RefSubjectTypeId = Symbol.for('@typed/fx/RefSubject');
-function makeRef(effect, eq) {
-    return Effect.contextWithEffect((context) => Effect.suspend(() => {
-        const ref = RefSubject.unsafeMake(Effect.provideContext(effect, context), Context.get(context, Scope.Scope), eq);
-        return Effect.as(Effect.addFinalizer(() => ref.end()), ref);
-    }));
-}
-exports.makeRef = makeRef;
-var RefSubject;
-(function (RefSubject) {
-    function unsafeMake(initial, scope, eq = fast_deep_equal_1.default) {
-        return makeRefFromPrimitive(unsafeMakeRefPrimitive(initial, scope, eq));
-    }
-    RefSubject.unsafeMake = unsafeMake;
-    function tuple(...refs) {
-        return makeRefFromPrimitive(tupleRefPrimitive(refs));
-    }
-    RefSubject.tuple = tuple;
-    function struct(refs) {
-        return makeRefFromPrimitive(structRefPrimitive(refs));
-    }
-    RefSubject.struct = struct;
-    function all(...subjects) {
-        /// MUST be a tuple if more than one argument
-        if (subjects.length > 1) {
-            return tuple(...subjects);
-        }
-        // Otherwise a single param is either a tuple or a struct
-        const singleParam = subjects[0];
-        if (Array.isArray(singleParam)) {
-            return tuple(...singleParam);
-        }
-        return struct(singleParam);
-    }
-    RefSubject.all = all;
-})(RefSubject || (exports.RefSubject = RefSubject = {}));
-function isRefSubject(u) {
-    return (0, Fx_js_1.isFx)(u) && exports.RefSubjectTypeId in u;
-}
-exports.isRefSubject = isRefSubject;
-// Internals for RefSubject
-function makeGetFromContext(ctx) {
-    return Effect.suspend(() => {
-        const current = MutableRef.get(ctx.currentRef);
-        if (Option.isSome(current)) {
-            return Effect.succeed(current.value);
-        }
-        const fiber = MutableRef.get(ctx.initializingFiberRef);
-        if (Option.isSome(fiber)) {
-            return Fiber.join(fiber.value);
-        }
-        return Effect.tap(ctx.lock(initializeFromContext(ctx)), (a) => ctx.hold.event(a));
-    });
-}
-function initializeFromContext(ctx) {
-    return Effect.uninterruptibleMask((restore) => Effect.flatMap(Effect.forkIn(restore(ctx.initial), ctx.scope), (fiber) => {
-        MutableRef.set(ctx.initializingFiberRef, Option.some(fiber));
-        return Fiber.join(fiber).pipe(Effect.tap((a) => Effect.sync(() => {
-            MutableRef.increment(ctx.version);
-            MutableRef.set(ctx.currentRef, Option.some(a));
-        })), Effect.ensuring(Effect.sync(() => MutableRef.set(ctx.initializingFiberRef, Option.none()))));
-    }));
-}
-function makeRefMethods(primitive) {
-    const modify = makeModify(primitive.modifyEffect);
-    const updateEffect = makeUpdateEffect(primitive.modifyEffect);
-    const update = makeUpdate(updateEffect);
-    return {
-        modify,
-        updateEffect,
-        update,
-    };
-}
-function makeModifyEffectFromContext(get, ctx) {
-    return (f) => Effect.flatMap(get, (a1) => ctx.lock(Effect.flatMap(f(a1), ([b, a2]) => Effect.suspend(() => {
-        MutableRef.set(ctx.currentRef, Option.some(a2));
-        if (ctx.eq(a1, a2)) {
-            return Effect.succeed(b);
-        }
-        MutableRef.increment(ctx.version);
-        return Effect.as(ctx.hold.event(a2), b);
-    }))));
-}
-function makeMultiUpdateFromContext(get, set, lock) {
-    return (f) => get.pipe(Effect.flatMap((current) => lock(f(current, set))));
-}
-function makeModify(modifyEffect) {
-    return (f) => modifyEffect((a) => Effect.sync(() => f(a)));
-}
-function makeUpdateEffect(modifyEffect) {
-    return (f) => modifyEffect((a) => Effect.map(f(a), (a) => [a, a]));
-}
-function makeUpdate(updateEffect) {
-    return (f) => updateEffect((a) => Effect.sync(() => f(a)));
-}
-function makeSetFromContext(ctx) {
-    return (a) => Effect.suspend(() => {
-        const fiber = MutableRef.get(ctx.initializingFiberRef);
-        return (0, Function_1.pipe)(fiber, Option.match({ onNone: () => Effect.unit, onSome: Fiber.await }), 
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        Effect.flatMap((_) => {
-            const current = MutableRef.get(ctx.currentRef);
-            MutableRef.set(ctx.currentRef, Option.some(a));
-            // Only emit if the value has changed
-            if (Option.isNone(current) || (Option.isSome(current) && !ctx.eq(current.value, a))) {
-                // Increment the version
-                MutableRef.increment(ctx.version);
-                return Effect.as(ctx.hold.event(a), a);
-            }
-            return Effect.succeed(a);
-        }));
-    });
-}
-function makeDeleteFromContext(ctx, get) {
-    return Effect.suspend(() => {
-        const current = MutableRef.get(ctx.currentRef);
-        if (Option.isSome(current)) {
-            MutableRef.set(ctx.version, 0);
-            MutableRef.set(ctx.currentRef, Option.none());
-            // Attempt to reinitialize the subject if there are observers
-            if (ctx.hold.observers.length > 0) {
-                return Effect.forkDaemon(get).pipe(Effect.as(current));
-            }
-        }
-        return Effect.succeed(current);
-    });
-}
-function makeEndFromContext(ctx) {
-    return () => Effect.suspend(() => {
-        MutableRef.set(ctx.version, 0);
-        const fibers = [
-            ctx.hold.fiber || Fiber.unit,
-            Option.getOrElse(MutableRef.get(ctx.initializingFiberRef), () => Fiber.unit),
-        ];
-        return Fiber.interruptAll(fibers);
-    });
-}
-function makeFiltered(f) {
-    const get = makeMemoizedGet(f);
-    function filterMapEffect(f) {
-        return new Filtered_js_1.FilteredImpl(get(), f);
-    }
-    function filterMap(f) {
-        return filterMapEffect((a) => Effect.sync(() => f(a)));
-    }
-    function filterEffect(f) {
-        return filterMapEffect((a) => Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())));
-    }
-    function filter(f) {
-        return filterEffect((a) => Effect.sync(() => f(a)));
-    }
-    function filterNotEffect(f) {
-        return filterEffect((a) => Effect.map(f(a), (b) => !b));
-    }
-    function filterNot(f) {
-        return filterNotEffect((a) => Effect.sync(() => f(a)));
-    }
-    return {
-        filterMapEffect,
-        filterMap,
-        filterEffect,
-        filter,
-        filterNotEffect,
-        filterNot,
-    };
-}
-function makeComputedMethods(f) {
-    const get = makeMemoizedGet(f);
-    function mapEffect(f) {
-        return new Computed_js_1.ComputedImpl(get(), f);
-    }
-    function map(f) {
-        return mapEffect((a) => Effect.sync(() => f(a)));
-    }
-    return {
-        mapEffect,
-        map,
-    };
-}
-function makeTransformMethods(f) {
-    const get = makeMemoizedGet(f);
-    function transformBoth(f, g) {
-        return new RefTransform_js_1.RefTransformImpl(get(), f, g);
-    }
-    function transform(f) {
-        return transformBoth(f, Function_1.identity);
-    }
-    function transformGet(f) {
-        return transformBoth(Function_1.identity, f);
-    }
-    return {
-        transformBoth,
-        transform,
-        transformGet,
-    };
-}
-const placeholders = {
-    _tag: 'Commit',
-    [Effect.EffectTypeId]: refVariance,
-    i0: undefined,
-    i1: undefined,
-    i2: undefined,
-    [Equal.symbol](that) {
-        return this === that;
-    },
-    [Hash.symbol]() {
-        return Hash.random(this);
-    },
-    pipe() {
-        // eslint-disable-next-line prefer-rest-params
-        return (0, Pipeable_1.pipeArguments)(this, arguments);
-    },
-};
-function makeEffectMethods(get) {
-    return Object.assign({
-        commit() {
-            return get;
-        },
-    }, placeholders);
-}
-function makeMemoizedGet(f) {
-    let memoized = Option.none();
-    return () => {
-        if (Option.isNone(memoized)) {
-            memoized = Option.some(f());
-        }
-        return memoized.value;
-    };
-}
-function makeRefSubjectContext(initial, scope, eq = fast_deep_equal_1.default) {
-    const hold = new hold_js_1.HoldFx((0, never_js_1.never)());
-    const ctx = {
-        initial,
-        currentRef: hold.current,
-        initializingFiberRef: MutableRef.make(Option.none()),
-        lock: Effect.unsafeMakeSemaphore(1).withPermits(1),
-        scope,
-        eq,
-        hold,
-        version: MutableRef.make(0),
-    };
-    return ctx;
-}
-function unsafeMakeRefPrimitive(initial, scope, eq) {
-    const ctx = makeRefSubjectContext(initial, scope, eq);
-    const get = makeGetFromContext(ctx);
-    const set = makeSetFromContext(ctx);
-    const multiUpdate = makeMultiUpdateFromContext(get, set, ctx.lock);
-    function run(sink) {
-        return Effect.suspend(() => {
-            const current = MutableRef.get(ctx.hold.current);
-            if (Option.isNone(current)) {
-                return (0, Function_1.pipe)(primitive.get, Effect.catchAllCause(sink.error), Effect.flatMap(() => ctx.hold.run(sink)));
-            }
-            return ctx.hold.run(sink);
-        });
-    }
-    const primitive = {
-        delete: makeDeleteFromContext(ctx, get),
-        end: makeEndFromContext(ctx),
-        eq,
-        error: (cause) => ctx.hold.error(cause),
-        event: set,
-        get,
-        modifyEffect: makeModifyEffectFromContext(get, ctx),
-        run,
-        set,
-        multiUpdate,
-        version: ctx.version,
-    };
-    return primitive;
-}
-function makeRefFromPrimitive(primitive) {
-    const ref = {
-        [Fx_js_1.FxTypeId]: refVariance,
-        [exports.RefSubjectTypeId]: exports.RefSubjectTypeId,
-        [Computed_js_1.ComputedTypeId]: Computed_js_1.ComputedTypeId,
-        ...primitive,
-        ...makeRefMethods(primitive),
-        ...makeEffectMethods(primitive.get),
-        ...makeFiltered(() => ref),
-        ...makeComputedMethods(() => ref),
-        ...makeTransformMethods(() => ref),
-        version() {
-            return MutableRef.get(primitive.version);
-        },
-    };
-    return ref;
-}
-// Internals for RefSubject.tuple
-function tupleRefPrimitive(refs) {
-    const hold = new hold_js_1.HoldFx((0, combineAll_js_1.combineAll)(...refs));
-    const eq = Equivalence.tuple(...refs.map((ref) => ref.eq));
-    const get = Effect.all(refs.map((ref) => ref.get), unboundedConcurrency);
-    const set = (value) => Effect.all(value.map((v, i) => refs[i].set(v)), unboundedConcurrency);
-    const multiUpdate = makeMultiUpdateFromContext(get, set, Function_1.identity);
-    const primitive = {
-        multiUpdate,
-        delete: Effect.map(Effect.all(refs.map((ref) => ref.delete), unboundedConcurrency), (values) => Option.all(values)),
-        end: () => Effect.all(refs.map((ref) => ref.end()), unboundedConcurrency),
-        eq,
-        error: (error) => hold.error(error),
-        event: (value) => Effect.all(value.map((v, i) => refs[i].event(v)), unboundedConcurrency),
-        get,
-        modifyEffect: makeModifyEffectTuple(refs, get, eq),
-        run: (sink) => hold.run(sink),
-        set,
-        version: MutableRef.make(0),
-    };
-    return primitive;
-}
-function makeModifyEffectTuple(refs, get, eq) {
-    return (f) => {
-        return Effect.gen(function* ($) {
-            const current = yield* $(get);
-            const [b, a] = yield* $(f(current));
-            if (eq(a, current)) {
-                return b;
-            }
-            yield* $(Effect.all(refs.map((ref, i) => ref.set(a[i])), unboundedConcurrency));
-            return b;
-        });
-    };
-}
-function structRefPrimitive(refs) {
-    const hold = new hold_js_1.HoldFx((0, struct_js_1.struct)(refs));
-    const eq = Equivalence.struct(mapRecord(refs, (ref) => ref.eq));
-    const get = Effect.all(mapRecord(refs, (ref) => ref.get), unboundedConcurrency);
-    const set = (value) => Effect.all(mapRecord(value, (v, i) => refs[i].set(v)), unboundedConcurrency);
-    const multiUpdate = makeMultiUpdateFromContext(get, set, Function_1.identity);
-    const primitive = {
-        multiUpdate,
-        delete: Effect.map(Effect.all(mapRecord(refs, (ref) => ref.delete), unboundedConcurrency), (values) => Option.all(values)),
-        end: () => Effect.all(mapRecord(refs, (ref) => ref.end()), unboundedConcurrency),
-        eq,
-        error: (error) => hold.error(error),
-        event: (value) => Effect.all(mapRecord(value, (v, i) => refs[i].event(v)), unboundedConcurrency),
-        get,
-        modifyEffect: makeModifyEffectStruct(refs, get, eq),
-        run: (sink) => hold.run(sink),
-        set: (value) => Effect.all(mapRecord(value, (v, i) => refs[i].set(v)), unboundedConcurrency),
-        version: MutableRef.make(0),
-    };
-    return primitive;
-}
-function makeModifyEffectStruct(refs, get, eq) {
-    return (f) => {
-        return Effect.gen(function* ($) {
-            const current = yield* $(get);
-            const [b, a] = yield* $(f(current));
-            if (eq(a, current)) {
-                return b;
-            }
-            yield* $(Effect.all(mapRecord(refs, (ref, i) => ref.set(a[i])), unboundedConcurrency));
-            return b;
-        });
-    };
-}
-function mapRecord(record, f) {
-    const result = {};
-    for (const k in record) {
-        result[k] = f(record[k], k);
-    }
-    return result;
-}
-function asRef(fx, params = {}) {
-    return Effect.flatMap(Deferred.make(), (deferred) => Effect.flatMap(makeRef(Deferred.await(deferred), params.eq), (ref) => {
-        const event = (value) => Effect.flatMap(Deferred.succeed(deferred, value), (closed) => closed ? Effect.unit : ref.set(value));
-        const to = (0, switchMatch_js_1.switchMatchCauseEffect)(fx, ref.error, event);
-        const from = params.onValue ? (0, switchMatch_js_1.switchMatchCauseEffect)(ref, ref.error, params.onValue) : succeed_js_1.unit;
-        const both = (0, mergeAll_js_1.merge)(from, to);
-        return Effect.as(Effect.forkScoped(Effect.catchAllCause((0, observe_js_1.drain)(both), ref.error)), ref);
-    }));
+exports.split = split;
+const getLeft = exit => Effect.succeed(_effect.Exit.match(exit, {
+  onFailure: cause => _effect.Cause.failureOption(cause),
+  onSuccess: () => Option.none()
+}));
+const getRight = exit => Effect.succeed(_effect.Exit.match(exit, {
+  onFailure: Option.none,
+  onSuccess: Option.some
+}));
+/**
+ * Derive a RefSubjectSchema using the "from" or "encoded" value represented by a Schema.
+ * @since 1.18.0
+ */
+function deriveFromSchema(schema) {
+  return (0, _schemaRefSubject.fromRefSubject)(schema);
+}
+/**
+ * Derive a RefSubjectSchema using the "to" or "decoded" value represented by a Schema.
+ * @since 1.18.0
+ */
+function deriveToSchema(schema) {
+  return (0, _schemaRefSubject.toRefSubject)(schema);
+}
+/**
+ * @since 1.18.0
+ */
+const tuple = exports.tuple = coreRefSubject.tuple;
+/**
+ * @since 1.18.0
+ */
+const struct = exports.struct = coreRefSubject.struct;
+/**
+ * @since 1.18.0
+ */
+function fromSubscriptionRef(subscriptionRef) {
+  return coreRefSubject.make((0, _core.fromStream)(subscriptionRef.changes));
+}
+/**
+ * @since 1.18.0
+ */
+const transform = exports.transform = /*#__PURE__*/(0, _Function.dual)(3, function transform(ref, from, to) {
+  return new TransformImpl(ref, from, to);
+});
+class TransformImpl extends _protos.FxEffectBase {
+  ref;
+  from;
+  to;
+  [_TypeId.RefSubjectTypeId] = _TypeId.RefSubjectTypeId;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  version;
+  subscriberCount;
+  get;
+  delete;
+  interrupt;
+  constructor(ref, from, to) {
+    super();
+    this.ref = ref;
+    this.from = from;
+    this.to = to;
+    this.version = ref.version;
+    this.subscriberCount = ref.subscriberCount;
+    this.get = Effect.map(ref.get, from);
+    this.delete = Effect.map(ref.delete, Option.map(from));
+    this.interrupt = ref.interrupt;
+  }
+  toFx() {
+    return this.ref.map(this.from);
+  }
+  toEffect() {
+    return this.ref.map(this.from);
+  }
+  set = b => Effect.map(this.ref.set(this.to(b)), this.from);
+  update = f => Effect.map(this.ref.update(a => this.to(f(this.from(a)))), this.from);
+  updateEffect = f => Effect.map(this.ref.updateEffect(a => Effect.map(f(this.from(a)), this.to)), this.from);
+  modifyEffect = f => this.ref.modifyEffect(a => Effect.map(f(this.from(a)), ([c, b]) => [c, this.to(b)]));
+  modify = f => this.ref.modify(a => {
+    const [c, b] = f(this.from(a));
+    return [c, this.to(b)];
+  });
+  runUpdate = f => this.ref.runUpdate((get, set) => f(Effect.map(get, this.from), b => Effect.map(set(this.to(b)), this.from)));
+  mapEffect = f => (0, _Computed.Computed)(this, f);
+  map = f => this.mapEffect(b => Effect.sync(() => f(b)));
+  filterMapEffect = f => (0, _Filtered.Filtered)(this, f);
+  filterMap = f => (0, _Filtered.Filtered)(this, a => Effect.sync(() => f(a)));
+  filter = f => this.filterMap(a => f(a) ? Option.some(a) : Option.none());
+  filterEffect = f => this.filterMapEffect(a => Effect.map(f(a), b => b ? Option.some(a) : Option.none()));
+  onSuccess = b => this.ref.onSuccess(this.to(b));
+  onFailure = b => this.ref.onFailure(b);
+  skipRepeats = (eq = _Equal.equals) => (0, _Computed.Computed)(Versioned.transformFx(this, (0, _core.skipRepeatsWith)(eq)), Effect.succeed);
 }
-exports.asRef = asRef;
 //# sourceMappingURL=RefSubject.js.map