@typed/fx 1.18.4 → 1.20.0

package/src/internal/share.ts

@@ -1,19 +1,19 @@
+import { ExecutionStrategy, type Scope } from "effect"
 import * as Effect from "effect/Effect"
 import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import type { Fx } from "../Fx.js"
-import type { Subject } from "../Subject.js"
-import { makeHoldSubject, makeReplaySubject, makeSubject } from "./core-subject.js"
-import { withScopedFork } from "./core.js"
-import { ToFx } from "./fx-primitive.js"
-import { run } from "./run.js"
+import type { Sink } from "../Sink.js"
+import * as Subject from "../Subject.js"
+import { withScopedFork } from "./helpers.js"
+import { FxBase } from "./protos.js"
 
 export function share<R, E, A, R2>(
   fx: Fx<R, E, A>,
-  subject: Subject<R2, E, A>
-): Fx<R | R2, E, A> {
+  subject: Subject.Subject<R2, E, A>
+): Fx<R | R2 | Scope.Scope, E, A> {
   return new Share(fx, subject)
 }
 
@@ -29,32 +29,34 @@ class RefCounter {
   }
 }
 
-export class Share<R, E, A, R2> extends ToFx<R | R2, E, A> {
+export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
   _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<never, unknown>>> = MutableRef.make(Option.none())
   _RefCount = new RefCounter()
 
   constructor(
     readonly i0: Fx<R, E, A>,
-    readonly i1: Subject<R2, E, A>
+    readonly i1: Subject.Subject<R2, E, A>
   ) {
-    super(i0, i1)
+    super()
   }
 
-  toFx(): Fx<R | R2, E, A> {
-    return withScopedFork(({ fork, sink }) =>
-      Effect.flatMap(
-        fork(
-          Effect.onExit(run(this.i1, sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.unit)
+  run<R3>(sink: Sink<R3, E, A>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+    return withScopedFork(
+      (fork) =>
+        Effect.flatMap(
+          fork(
+            Effect.onExit(this.i1.run(sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.unit)
+          ),
+          () => this.initialize()
         ),
-        () => this.initialize()
-      )
+      ExecutionStrategy.sequential
     )
   }
 
   private initialize(): Effect.Effect<R | R2, never, unknown> {
     return Effect.suspend(() => {
       if (this._RefCount.increment() === 1) {
-        return run(this.i0, this.i1).pipe(
+        return this.i0.run(this.i1).pipe(
           Effect.onExit(() => Effect.sync(() => MutableRef.set(this._FxFiber, Option.none()))),
           Effect.interruptible,
           Effect.forkDaemon,
@@ -84,14 +86,14 @@ export class Share<R, E, A, R2> extends ToFx<R | R2, E, A> {
 
 export function multicast<R, E, A>(
   fx: Fx<R, E, A>
-): Fx<R, E, A> {
-  return new Share(fx, makeSubject<E, A>())
+): Fx<R | Scope.Scope, E, A> {
+  return new Share(fx, Subject.unsafeMake<E, A>(0))
 }
 
 export function hold<R, E, A>(
   fx: Fx<R, E, A>
-): Fx<R, E, A> {
-  return new Share(fx, makeHoldSubject<E, A>())
+): Fx<R | Scope.Scope, E, A> {
+  return new Share(fx, Subject.unsafeMake<E, A>(1))
 }
 
 export const replay: {
@@ -100,6 +102,6 @@ export const replay: {
 } = dual(2, function replay<R, E, A>(
   fx: Fx<R, E, A>,
   capacity: number
-): Fx<R, E, A> {
-  return new Share(fx, makeReplaySubject<E, A>(capacity))
+): Fx<R | Scope.Scope, E, A> {
+  return new Share(fx, Subject.unsafeMake<E, A>(capacity))
 })

package/src/internal/sync-operator.ts

@@ -1,6 +1,10 @@
+import * as ReadonlyArray from "effect/ReadonlyArray"
+
 import * as Effect from "effect/Effect"
+import { flow } from "effect/Function"
 import * as Option from "effect/Option"
-import { WithContext } from "../Sink.js"
+import * as Sink from "../Sink.js"
+import * as SyncProducer from "./sync-producer.js"
 
 // Sync operators are a subset of operators which can be safely fused together synchronously
 
@@ -41,13 +45,13 @@ type SyncOperatorFusionMap = {
 
 const SyncOperatorFusionMap: SyncOperatorFusionMap = {
   Map: {
-    Map: (op1, op2) => Map((a: any) => op2.f(op1.f(a))),
+    Map: (op1, op2) => Map(flow(op1.f, op2.f)),
     Filter: (op1, op2) =>
       FilterMap((a: any) => {
         const b = op1.f(a)
         return op2.f(b) ? Option.some(b) : Option.none()
       }),
-    FilterMap: (op1, op2) => FilterMap((a: any) => op2.f(op1.f(a)))
+    FilterMap: (op1, op2) => FilterMap(flow(op1.f, op2.f))
   },
   Filter: {
     Map: (op1, op2) => FilterMap((a: any) => op1.f(a) ? Option.some(op2.f(a)) : Option.none()),
@@ -71,41 +75,29 @@ export function matchSyncOperator<A>(operator: SyncOperator, matchers: {
   readonly Filter: (f: Filter<any>) => A
   readonly FilterMap: (f: FilterMap<any, any>) => A
 }): A {
-  switch (operator._tag) {
-    case "Map":
-      return matchers.Map(operator)
-    case "Filter":
-      return matchers.Filter(operator)
-    case "FilterMap":
-      return matchers.FilterMap(operator)
-  }
+  return matchers[operator._tag](operator as any)
 }
 
 export function compileSyncOperatorSink<R>(
   operator: SyncOperator,
-  sink: WithContext<R, any, any>
-): WithContext<R, any, any> {
+  sink: Sink.Sink<R, any, any>
+): Sink.Sink<R, any, any> {
   return matchSyncOperator(operator, {
-    Map: (op) => WithContext(sink.onFailure, (a) => sink.onSuccess(op.f(a))),
-    Filter: (op) => WithContext(sink.onFailure, (a) => op.f(a) ? sink.onSuccess(a) : Effect.unit),
-    FilterMap: (op) =>
-      WithContext(sink.onFailure, (a) =>
-        Option.match(op.f(a), {
-          onNone: () => Effect.unit,
-          onSome: sink.onSuccess
-        }))
+    Map: (op) => Sink.map(sink, op.f),
+    Filter: (op) => Sink.filter(sink, op.f),
+    FilterMap: (op) => Sink.filterMap(sink, op.f)
   })
 }
 
-export function compileSyncOperatorFailureSink<R>(
+export function compileCauseSyncOperatorSink<R>(
   operator: SyncOperator,
-  sink: WithContext<R, any, any>
-): WithContext<R, any, any> {
+  sink: Sink.Sink<R, any, any>
+): Sink.Sink<R, any, any> {
   return matchSyncOperator(operator, {
-    Map: (op) => WithContext((a) => sink.onFailure(op.f(a)), sink.onSuccess),
-    Filter: (op) => WithContext((a) => op.f(a) ? sink.onFailure(a) : Effect.unit, sink.onSuccess),
+    Map: (op) => Sink.make((a) => sink.onFailure(op.f(a)), sink.onSuccess),
+    Filter: (op) => Sink.make((a) => op.f(a) ? sink.onFailure(a) : Effect.unit, sink.onSuccess),
     FilterMap: (op) =>
-      WithContext((a) =>
+      Sink.make((a) =>
         Option.match(op.f(a), {
           onNone: () => Effect.unit,
           onSome: sink.onFailure
@@ -123,3 +115,52 @@ export function compileSyncReducer<A, B, C>(
     FilterMap: (op) => (b, i) => Option.map(op.f(i), (a) => f(b, a))
   })
 }
+
+export function applyArray<A, B>(array: ReadonlyArray<A>, operator: SyncOperator): ReadonlyArray<B> {
+  return matchSyncOperator(operator, {
+    Map: (op) => ReadonlyArray.map(array, op.f),
+    Filter: (op) => ReadonlyArray.filter(array, op.f),
+    FilterMap: (op) => ReadonlyArray.filterMap(array, op.f)
+  })
+}
+
+export function applyArrayReducer<A, B>(
+  array: Iterable<any>,
+  operator: SyncOperator,
+  seed: B,
+  f: (acc: B, a: A) => B
+): B {
+  return matchSyncOperator(operator, {
+    Map: (op) => ReadonlyArray.reduce(array, seed, (b, a) => f(b, op.f(a))),
+    Filter: (op) => ReadonlyArray.reduce(array, seed, (b, a) => op.f(a) ? f(b, a) : b),
+    FilterMap: (op) =>
+      ReadonlyArray.reduce(array, seed, (b, a) => {
+        const o = op.f(a)
+        if (Option.isSome(o)) return f(b, o.value)
+        else return b
+      })
+  })
+}
+
+export function runSyncReduce<A, B>(
+  producer: SyncProducer.SyncProducer<A>,
+  op: SyncOperator,
+  seed: B,
+  f: (acc: B, a: any) => B
+): B {
+  return SyncProducer.matchSyncProducer(producer, {
+    Success: (a) =>
+      matchSyncOperator(op, {
+        Map: (op) => f(seed, op.f(a)),
+        Filter: (op) => op.f(a) ? f(seed, a) : seed,
+        FilterMap: (op) =>
+          Option.match(op.f(a), {
+            onNone: () => seed,
+            onSome: (a) => f(seed, a)
+          })
+      }),
+    FromSync: (g) => f(seed, g()),
+    FromArray: (array) => applyArrayReducer(array, op, seed, f),
+    FromIterable: (iterable) => applyArrayReducer(iterable, op, seed, f)
+  })
+}

package/src/internal/sync-producer.ts

@@ -0,0 +1,146 @@
+import { Effect, Option, ReadonlyArray } from "effect"
+import type { Sink } from "../Sink.js"
+
+const DISCARD = { discard: true } as const
+
+export type SyncProducer<A> = Success<A> | FromSync<A> | FromArray<A> | FromIterable<A>
+
+export interface Success<A> {
+  readonly _tag: "Success"
+  readonly source: A
+}
+
+export const Success = <A>(value: A): Success<A> => ({ _tag: "Success", source: value })
+
+export interface FromSync<A> {
+  readonly _tag: "FromSync"
+  readonly source: () => A
+}
+
+export const FromSync = <A>(f: () => A): FromSync<A> => ({ _tag: "FromSync", source: f })
+
+export interface FromArray<A> {
+  readonly _tag: "FromArray"
+  readonly source: ReadonlyArray<A>
+}
+
+export const FromArray = <A>(array: ReadonlyArray<A>): FromArray<A> => ({ _tag: "FromArray", source: array })
+
+export interface FromIterable<A> {
+  readonly _tag: "FromIterable"
+  readonly source: Iterable<A>
+}
+
+export const FromIterable = <A>(iterable: Iterable<A>): FromIterable<A> => ({ _tag: "FromIterable", source: iterable })
+
+export const matchSyncProducer = <A, R>(
+  producer: SyncProducer<A>,
+  matchers: {
+    readonly Success: (a: A) => R
+    readonly FromSync: (a: () => A) => R
+    readonly FromArray: (a: ReadonlyArray<A>) => R
+    readonly FromIterable: (a: Iterable<A>) => R
+  }
+): R => {
+  return matchers[producer._tag](producer.source as any)
+}
+
+export function runSink<A, R, E>(
+  producer: SyncProducer<A>,
+  sink: Sink<R, E, A>
+): Effect.Effect<R, never, unknown> {
+  return matchSyncProducer(producer, {
+    Success: (a) => sink.onSuccess(a),
+    FromSync: (a) => Effect.suspend(() => sink.onSuccess(a())),
+    FromArray: (a) => arrayToSink(a, sink),
+    FromIterable: (a) => iterableToSink(a, sink)
+  })
+}
+
+export function runReduce<A, B>(
+  producer: SyncProducer<A>,
+  initial: B,
+  f: (b: B, a: any) => B
+): Effect.Effect<never, never, B> {
+  return matchSyncProducer(producer, {
+    Success: (a) => syncOnce(() => f(initial, a)),
+    FromSync: (a) => syncOnce(() => f(initial, a())),
+    FromArray: (a) => syncOnce(() => ReadonlyArray.reduce(a, initial, f)),
+    FromIterable: (a) => syncOnce(() => ReadonlyArray.reduce(a, initial, f))
+  })
+}
+
+export function runReduceEffect<A, R2, E2, B>(
+  producer: SyncProducer<A>,
+  initial: B,
+  f: (b: B, a: any) => Effect.Effect<R2, E2, B>
+): Effect.Effect<R2, E2, B> {
+  return matchSyncProducer(producer, {
+    Success: (a) => effectOnce(() => f(initial, a)),
+    FromSync: (a) => Effect.suspend(() => f(initial, a())),
+    FromArray: (a) => Effect.reduce(a, initial, f),
+    FromIterable: (a) => Effect.reduce(a, initial, f)
+  })
+}
+
+function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<R2, never, A>): Effect.Effect<R2, never, unknown> {
+  if (array.length === 0) return Effect.unit
+  else if (array.length === 1) return sink.onSuccess(array[0])
+  else {
+    const [first, ...rest] = array
+    let effect = sink.onSuccess(first)
+    for (const item of rest) {
+      effect = Effect.zipRight(effect, sink.onSuccess(item))
+    }
+    return effect
+  }
+}
+
+function iterableToSink<A, R2>(array: Iterable<A>, sink: Sink<R2, never, A>): Effect.Effect<R2, never, unknown> {
+  let effect: Effect.Effect<R2, never, any> = Effect.unit
+
+  for (const item of array) {
+    effect = Effect.zipRight(effect, sink.onSuccess(item))
+  }
+
+  return effect
+}
+
+export const syncOnce = <A>(f: () => A): Effect.Effect<never, never, A> => {
+  let memoized: Option.Option<A> = Option.none()
+  const get = () => {
+    if (Option.isSome(memoized)) {
+      return memoized.value
+    } else {
+      const a = f()
+      memoized = Option.some(a)
+      return a
+    }
+  }
+
+  return Effect.sync(get)
+}
+
+export const effectOnce = <R, E, A>(f: () => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> => {
+  let memoized: Option.Option<A> = Option.none()
+
+  return Effect.suspend(() => {
+    if (Option.isSome(memoized)) {
+      return Effect.succeed(memoized.value)
+    } else {
+      return Effect.tap(f(), (a) => Effect.sync(() => memoized = Option.some(a)))
+    }
+  })
+}
+
+export function runEffect<A, R2, E2, B>(
+  producer: SyncProducer<A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>
+): Effect.Effect<R2, E2, void> {
+  return matchSyncProducer(producer, {
+    Success: (a): Effect.Effect<R2, E2, void> => f(a),
+    FromSync: (a) => Effect.suspend(() => f(a())),
+    FromArray: (a) => Effect.forEach(a, f, DISCARD),
+    FromIterable: (a) => Effect.forEach(a, f, DISCARD)
+  })
+}

package/src/internal/withKey.ts

@@ -1,92 +1,82 @@
 import * as Effect from "effect/Effect"
-import { equals } from "effect/Equal"
-import * as Fiber from "effect/Fiber"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Option from "effect/Option"
-import * as Scope from "effect/Scope"
-import type { Fx, FxInput } from "../Fx.js"
+import type * as Scope from "effect/Scope"
+
+import type { Fx, WithKeyOptions } from "../Fx.js"
 import * as RefSubject from "../RefSubject.js"
 import * as Sink from "../Sink.js"
-import * as core from "./core.js"
-import { adjustTime } from "./helpers.js"
-import { run } from "./run.js"
+import { withSwitchFork } from "./helpers.js"
+import { FxBase } from "./protos.js"
 
-export function withKey<R, E, A, B, R2, E2, C>(
+export function withKey<R, E, A, B extends PropertyKey, R2, E2, C>(
   fx: Fx<R, E, A>,
-  getKey: (a: A) => B,
-  onValue: (ref: RefSubject.RefSubject<never, never, A>, key: B) => FxInput<R2, E2, C>
-): Fx<R | R2, E | E2, C> {
-  return core.withScopedFork(({ fork, scope, sink }) =>
-    Effect.gen(function*(_) {
-      let current: Option.Option<
-        [B, { value: A }, RefSubject.RefSubject<never, never, A>, Fiber.Fiber<never, unknown>]
-      > = Option.none()
+  options: WithKeyOptions<A, B, R2, E2, C>
+): Fx<R | R2 | Scope.Scope, E | E2, C> {
+  return new WithKey(fx, options)
+}
+
+class WithKey<R, E, A, B extends PropertyKey, R2, E2, C> extends FxBase<R | R2 | Scope.Scope, E | E2, C> {
+  constructor(readonly fx: Fx<R, E, A>, readonly options: WithKeyOptions<A, B, R2, E2, C>) {
+    super()
+  }
 
-      const lock = (yield* _(Effect.makeSemaphore(1))).withPermits(1)
+  run<R3>(sink: Sink.Sink<R3, E | E2, C>) {
+    return runWithKey(this.fx, this.options, sink)
+  }
+}
 
-      const make = (a: A) =>
-        Effect.uninterruptibleMask((restore) =>
-          Effect.gen(function*(_) {
-            const key = getKey(a)
-            // We use a simple mutable object to track the current value
-            // of the state coming from the "outside", such that any internal
-            // usage of RefSubject.delete will reset to the latest value emitted
-            // from here.
-            const currentValue = { value: a }
-            const ref = yield* _(
-              RefSubject.fromEffect(Effect.sync(() => currentValue.value)),
-              Effect.provideService(Scope.Scope, scope)
-            )
-            const fiber = yield* _(
-              run(core.from(onValue(ref, key)), sink),
-              restore,
-              fork
-            )
+function runWithKey<R, E, A, B extends PropertyKey, R2, E2, C, R3>(
+  fx: Fx<R, E, A>,
+  options: WithKeyOptions<A, B, R2, E2, C>,
+  sink: Sink.Sink<R3, E | E2, C>
+) {
+  return withSwitchFork((fork) => {
+    let previous: Option.Option<WithKeyState<A, B>> = Option.none()
 
-            // Save our state
-            current = Option.some([key, currentValue, ref, fiber])
+    const run = fx.run(Sink.make(
+      (cause) => sink.onFailure(cause),
+      (value) =>
+        Effect.gen(function*(_) {
+          const key = options.getKey(value)
 
-            // Allow our Fibers to start
-            yield* _(adjustTime(1))
-          })
-        )
+          // We don't need to do anything if the key is the same as the previous one
+          if (Option.isSome(previous)) {
+            const prev = previous.value
 
-      yield* _(run(
-        fx,
-        Sink.WithContext(
-          sink.onFailure,
-          (a) =>
-            lock(Effect.gen(function*(_) {
-              if (Option.isNone(current)) {
-                yield _(make(a))
-              } else {
-                const [key, currentValue, ref, fiber] = current.value
+            // If the key is the same, we just need to update the value
+            if (prev.key === key) {
+              prev.value = value
+              yield* _(RefSubject.set(prev.ref, value))
+              return
+            } else {
+              // Otherwise, we need to remove the previous value
+              yield* _(prev.ref.interrupt)
+            }
+          }
 
-                if (equals(key, getKey(a))) {
-                  // Key didn't change, so we just set an updated value.
+          const ref = yield* _(RefSubject.fromEffect(Effect.sync(() => state.value)))
 
-                  currentValue.value = a
-                  yield* _(ref.set(a))
-                } else {
-                  // Cleanup previous resources
-                  yield* _(Fiber.interrupt(fiber))
+          // Create a new state
+          const state: WithKeyState<A, B> = {
+            value,
+            key,
+            ref
+          }
 
-                  // Create a new RefSubject
-                  yield* _(make(a))
-                }
-              }
-            }))
-        )
-      ))
+          previous = Option.some(state)
 
-      if (Option.isSome(current)) {
-        const [, , ref, fiber] = current.value
+          // Create a new listener
+          yield* _(fork(options.onValue(state.ref, state.key).run(sink)))
+        })
+    ))
 
-        // Signal there will be no more input events
-        yield* _(fork(ref.interrupt))
+    return Effect.flatMap(run, () => Option.isSome(previous) ? previous.value.ref.interrupt : Effect.unit)
+  }, ExecutionStrategy.sequential)
+}
 
-        // Wait for the last Fiber to complete
-        yield* _(Effect.fromFiber(fiber))
-      }
-    })
-  )
+type WithKeyState<A, B> = {
+  value: A
+  key: B
+  ref: RefSubject.RefSubject<never, never, A>
 }

package/dist/cjs/Computed.js

@@ -1,115 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Computed = Computed;
-exports.combine = combine;
-exports.provide = exports.fromTag = void 0;
-exports.struct = struct;
-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 _Filtered = /*#__PURE__*/require("./Filtered.js");
-var core = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/core.js"));
-var _fx = /*#__PURE__*/require("./internal/fx.js");
-var _protos = /*#__PURE__*/require("./internal/protos.js");
-var _share = /*#__PURE__*/require("./internal/share.js");
-var _versionedTransform = /*#__PURE__*/require("./internal/versioned-transform.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 && 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 Computed is a Subject that has a current value that can be read and observed
- * @since 1.18.0
- */
-
-// eslint-disable-next-line import/no-cycle
-
-/**
- * Create a Computed from a data type which is an Fx and an Effect.
- * @since 1.18.0
- */
-function Computed(input, f) {
-  return new ComputedImpl(input, f);
-}
-class ComputedImpl extends _versionedTransform.VersionedTransform {
-  input;
-  f;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  constructor(input, f) {
-    super(input, fx => {
-      const computed = core.skipRepeats(core.mapEffect(fx, f));
-      return core.suspend(() => {
-        if (Option.isSome(this._currentValue)) {
-          return core.startWith(computed, this._currentValue.value);
-        } else {
-          return computed;
-        }
-      });
-    }, Effect.flatMap(f));
-    this.input = input;
-    this.f = f;
-  }
-  mapEffect = f => Computed(this, f);
-  map = f => this.mapEffect(a => Effect.sync(() => f(a)));
-  filterMapEffect = f => (0, _Filtered.Filtered)(this, f);
-  filterMap = f => this.filterMapEffect(a => Effect.sync(() => f(a)));
-  filterEffect = f => this.filterMapEffect(a => Effect.map(f(a), b => b ? Option.some(a) : Option.none()));
-  filter = f => this.filterEffect(a => Effect.sync(() => f(a)));
-  skipRepeats = (eq = _Equal.equals) => Computed(Versioned.transformFx(this, core.skipRepeatsWith(eq)), Effect.succeed);
-}
-/**
- * @since 1.18.0
- */
-function combine(computeds) {
-  return Computed(Versioned.combine(computeds), Effect.succeed);
-}
-/**
- * @since 1.18.0
- */
-function struct(computeds) {
-  return Computed(Versioned.struct(computeds), Effect.succeed);
-}
-/**
- * @since 1.18.0
- */
-const fromTag = exports.fromTag = /*#__PURE__*/(0, _Function.dual)(2, function fromTag(tag, f) {
-  return new ContextImpl(tag, f);
-});
-class ContextImpl extends _protos.FxEffectBase {
-  tag;
-  f;
-  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
-  _computed;
-  version;
-  constructor(tag, f) {
-    super();
-    this.tag = tag;
-    this.f = f;
-    this._computed = Effect.map(this.tag, this.f);
-    this.version = Effect.flatMap(this._computed, c => c.version);
-  }
-  toFx() {
-    return (0, _share.hold)((0, _fx.fromFxEffect)(this._computed));
-  }
-  toEffect() {
-    return Effect.flatten(this._computed);
-  }
-  mapEffect = f => Computed(this, f);
-  map = f => this.mapEffect(a => Effect.sync(() => f(a)));
-  filterMapEffect = f => (0, _Filtered.Filtered)(this, f);
-  filterMap = f => this.filterMapEffect(a => Effect.sync(() => f(a)));
-  filterEffect = f => this.filterMapEffect(a => Effect.map(f(a), b => b ? Option.some(a) : Option.none()));
-  filter = f => this.filterEffect(a => Effect.sync(() => f(a)));
-  skipRepeats = (eq = _Equal.equals) => new ContextImpl(this.tag, s => this.f(s).skipRepeats(eq));
-}
-/**
- * @since 1.18.0
- */
-const provide = exports.provide = /*#__PURE__*/(0, _Function.dual)(2, function provide(computed, layer) {
-  return Computed(Versioned.provide(computed, layer), Effect.succeed);
-});
-//# sourceMappingURL=Computed.js.map

package/dist/cjs/Computed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Computed.js","names":["Effect","_interopRequireWildcard","require","_Equal","_Function","Option","_Filtered","core","_fx","_protos","_share","_versionedTransform","_TypeId","Versioned","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","prototype","hasOwnProperty","call","i","set","Computed","input","f","ComputedImpl","VersionedTransform","ComputedTypeId","constructor","fx","computed","skipRepeats","mapEffect","suspend","isSome","_currentValue","startWith","value","flatMap","map","sync","filterMapEffect","Filtered","filterMap","filterEffect","b","some","none","filter","eq","equals","transformFx","skipRepeatsWith","succeed","combine","computeds","struct","fromTag","exports","dual","tag","ContextImpl","FxEffectBase","_computed","version","c","toFx","hold","fromFxEffect","toEffect","flatten","s","provide","layer"],"sources":["../../src/Computed.ts"],"sourcesContent":[null],"mappings":"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"}