@typed/fx 1.18.2 → 1.18.4

package/src/RefSubject.ts

@@ -16,17 +16,17 @@ import { dual } from "effect/Function"
 import type * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
-import { Computed, fromTag } from "./Computed"
-import { Filtered } from "./Filtered"
-import type * as Fx from "./Fx"
-import { fromStream, provide, skipRepeatsWith } from "./internal/core"
-import * as coreRefSubject from "./internal/core-ref-subject"
-import { exit, fromFxEffect } from "./internal/fx"
-import { FxEffectBase } from "./internal/protos"
-import { fromRefSubject, toRefSubject } from "./internal/schema-ref-subject"
-import type * as Subject from "./Subject"
-import { ComputedTypeId, RefSubjectTypeId } from "./TypeId"
-import * as Versioned from "./Versioned"
+import { Computed, fromTag } from "./Computed.js"
+import { Filtered } from "./Filtered.js"
+import type * as Fx from "./Fx.js"
+import * as coreRefSubject from "./internal/core-ref-subject.js"
+import { fromStream, provide, skipRepeatsWith } from "./internal/core.js"
+import { exit, fromFxEffect } from "./internal/fx.js"
+import { FxEffectBase } from "./internal/protos.js"
+import { fromRefSubject, toRefSubject } from "./internal/schema-ref-subject.js"
+import type * as Subject from "./Subject.js"
+import { ComputedTypeId, RefSubjectTypeId } from "./TypeId.js"
+import * as Versioned from "./Versioned.js"
 
 /**
  * A RefSubject is a Subject that has a current value that can be read and updated.

package/src/Stream.ts

@@ -11,8 +11,8 @@ import * as Option from "effect/Option"
 import * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import * as Fx from "./Fx"
-import { Sink } from "./Sink"
+import * as Fx from "./Fx.js"
+import { Sink } from "./Sink.js"
 
 /**
  * Convert an Fx to a Stream

package/src/Subject.ts

@@ -8,11 +8,11 @@ import * as C from "@typed/context"
 import type { Cause } from "effect/Cause"
 import * as Effect from "effect/Effect"
 import type * as Layer from "effect/Layer"
-import { type Fx, ToFx } from "./Fx"
-import { provide } from "./internal/core"
-import * as internal from "./internal/core-subject"
-import { fromFxEffect } from "./internal/fx"
-import type { WithContext } from "./Sink"
+import { type Fx, ToFx } from "./Fx.js"
+import * as internal from "./internal/core-subject.js"
+import { provide } from "./internal/core.js"
+import { fromFxEffect } from "./internal/fx.js"
+import type { WithContext } from "./Sink.js"
 
 /**
  * A Subject is an Fx which is also a Sink, and can be used to

package/src/TypeId.ts

@@ -2,7 +2,7 @@
  * @since 1.18.0
  * @category symbols
  */
-export const TypeId = Symbol.for("./Fx")
+export const TypeId = Symbol.for("./Fx.js")
 
 /**
  * @since 1.18.0
@@ -14,7 +14,7 @@ export type TypeId = typeof TypeId
  * @since 1.18.0
  * @category symbols
  */
-export const RefSubjectTypeId = Symbol.for("./RefSubject")
+export const RefSubjectTypeId = Symbol.for("./RefSubject.js")
 
 /**
  * @since 1.18.0
@@ -26,7 +26,7 @@ export type RefSubjectTypeId = typeof RefSubjectTypeId
  * @since 1.18.0
  * @category symbols
  */
-export const ComputedTypeId = Symbol.for("./Computed")
+export const ComputedTypeId = Symbol.for("./Computed.js")
 
 /**
  * @since 1.18.0
@@ -38,7 +38,7 @@ export type ComputedTypeId = typeof ComputedTypeId
  * @since 1.18.0
  * @category symbols
  */
-export const FilteredTypeId = Symbol.for("./Filtered")
+export const FilteredTypeId = Symbol.for("./Filtered.js")
 
 /**
  * @since 1.18.0

package/src/Typeclass.ts

@@ -23,10 +23,10 @@ import type { Either } from "effect/Either"
 import { dual } from "effect/Function"
 import type * as HKT from "effect/HKT"
 import { getLeft, getRight } from "effect/Option"
-import type { Fx } from "./Fx"
+import type { Fx } from "./Fx.js"
 
-import * as core from "./internal/core"
-import { multicast } from "./internal/share"
+import * as core from "./internal/core.js"
+import { multicast } from "./internal/share.js"
 
 /**
  * TypeLambda for an Fx

package/src/Versioned.ts

@@ -9,10 +9,10 @@ import type { Context, Layer, Runtime } from "effect"
 import { Effect, identity } from "effect"
 import { dual } from "effect/Function"
 import { sum } from "effect/Number"
-import type * as Fx from "./Fx"
-import * as core from "./internal/core"
-import * as fxEffectProto from "./internal/fx-effect-proto"
-import { VersionedTransform } from "./internal/versioned-transform"
+import type * as Fx from "./Fx.js"
+import * as core from "./internal/core.js"
+import * as fxEffectProto from "./internal/fx-effect-proto.js"
+import { VersionedTransform } from "./internal/versioned-transform.js"
 
 /**
  * A data type which is both an Fx and an Effect. This is a more advanced type, and is the basis

package/src/index.ts

@@ -13,52 +13,52 @@
  * [Computed documentation](https://tylors.github.io/typed/fx/Computed.ts.html)
  * @since 1.18.0
  */
-export * as Computed from "./Computed"
+export * as Computed from "./Computed.js"
 
 /**
  * [Filtered documentation](https://tylors.github.io/typed/fx/Filtered.ts.html)
  * @since 1.18.0
  */
-export * as Filtered from "./Filtered"
+export * as Filtered from "./Filtered.js"
 
 /**
  * [Fx documentation](https://tylors.github.io/typed/fx/Fx.ts.html)
  * @since 1.18.0
  */
-export * from "./Fx"
+export * from "./Fx.js"
 
 /**
  * [RefArray documentation](https://tylors.github.io/typed/fx/RefArray.ts.html)
  * @since 1.18.0
  */
-export * as RefArray from "./RefArray"
+export * as RefArray from "./RefArray.js"
 
 /**
  * [RefSubject documentation](https://tylors.github.io/typed/fx/RefSubject.ts.html)
  * @since 1.18.0
  */
-export * as RefSubject from "./RefSubject"
+export * as RefSubject from "./RefSubject.js"
 
 /**
  * [Sink documentation](https://tylors.github.io/typed/fx/Sink.ts.html)
  * @since 1.18.0
  */
-export * as Sink from "./Sink"
+export * as Sink from "./Sink.js"
 
 /**
  * [Subject documentation](https://tylors.github.io/typed/fx/Subject.ts.html)
  * @since 1.18.0
  */
-export * as Subject from "./Subject"
+export * as Subject from "./Subject.js"
 
 /**
  * [Typeclass documentation](https://tylors.github.io/typed/fx/Typeclass.ts.html)
  * @since 1.18.0
  */
-export * as Typeclass from "./Typeclass"
+export * as Typeclass from "./Typeclass.js"
 
 /**
  * [TypeId documentation](https://tylors.github.io/typed/fx/TypeId.ts.html)
  * @since 1.18.0
  */
-export * from "./TypeId"
+export * from "./TypeId.js"

package/src/internal/core-ref-subject.ts

@@ -10,22 +10,22 @@ import { sum } from "effect/Number"
 import * as Option from "effect/Option"
 import { getEquivalence } from "effect/ReadonlyArray"
 import type * as Scope from "effect/Scope"
-import { Computed } from "../Computed"
-import { Filtered } from "../Filtered"
-import type { Fx, FxInput } from "../Fx"
-import { type RefSubject } from "../RefSubject"
-import { Sink, WithContext } from "../Sink"
-import type * as Subject from "../Subject"
-import { ComputedTypeId, RefSubjectTypeId } from "../TypeId"
-import { transformFx } from "../Versioned"
-import * as core from "./core"
-import { makeHoldSubject } from "./core-subject"
-import { DeferredRef } from "./deferred-ref"
-import { fromFxEffect } from "./fx"
-import { matchFxInput } from "./matchers"
-import { FxEffectBase } from "./protos"
-import { run } from "./run"
-import { share } from "./share"
+import { Computed } from "../Computed.js"
+import { Filtered } from "../Filtered.js"
+import type { Fx, FxInput } from "../Fx.js"
+import { type RefSubject } from "../RefSubject.js"
+import { Sink, WithContext } from "../Sink.js"
+import type * as Subject from "../Subject.js"
+import { ComputedTypeId, RefSubjectTypeId } from "../TypeId.js"
+import { transformFx } from "../Versioned.js"
+import { makeHoldSubject } from "./core-subject.js"
+import * as core from "./core.js"
+import { DeferredRef } from "./deferred-ref.js"
+import { fromFxEffect } from "./fx.js"
+import { matchFxInput } from "./matchers.js"
+import { FxEffectBase } from "./protos.js"
+import { run } from "./run.js"
+import { share } from "./share.js"
 
 export class RefSubjectImpl<R, E, A> extends FxEffectBase<R, E, A, R, E, A> implements RefSubject<R, E, A> {
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId

package/src/internal/core-subject.ts

@@ -4,12 +4,12 @@ import * as Exit from "effect/Exit"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import * as Scope from "effect/Scope"
-import type { Fx } from "../Fx"
-import type { Sink } from "../Sink"
-import type { Subject } from "../Subject"
-import { fromSink } from "./core"
-import { ToFx } from "./fx-primitive"
-import { RingBuffer } from "./helpers"
+import type { Fx } from "../Fx.js"
+import type { Sink } from "../Sink.js"
+import type { Subject } from "../Subject.js"
+import { fromSink } from "./core.js"
+import { ToFx } from "./fx-primitive.js"
+import { RingBuffer } from "./helpers.js"
 
 export function makeSubject<E, A>(): Subject<never, E, A> {
   return new SubjectImpl<E, A>()

package/src/internal/core.ts

@@ -27,16 +27,16 @@ import {
   liftSyncOperator,
   MapEffect,
   TapEffect
-} from "./effect-operator"
-import * as helpers from "./helpers"
-import * as Provide from "./provide"
-import * as strategies from "./strategies"
-import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator"
+} from "./effect-operator.js"
+import * as helpers from "./helpers.js"
+import * as Provide from "./provide.js"
+import * as strategies from "./strategies.js"
+import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator.js"
 
 import type { DurationInput } from "effect/Duration"
 import type { Equivalence } from "effect/Equivalence"
 import type { Runtime } from "effect/Runtime"
-import * as Emitter from "../Emitter"
+import * as Emitter from "../Emitter.js"
 import type {
   FlattenStrategy,
   Fx,
@@ -45,10 +45,10 @@ import type {
   WithEarlyExitParams,
   WithFlattenStrategyParams,
   WithScopedForkParams
-} from "../Fx"
-import * as Sink from "../Sink"
-import { type Bounds, boundsFrom, mergeBounds } from "./bounds"
-import { type InternalEffect, matchEffectPrimitive } from "./effect-primitive"
+} from "../Fx.js"
+import * as Sink from "../Sink.js"
+import { type Bounds, boundsFrom, mergeBounds } from "./bounds.js"
+import { type InternalEffect, matchEffectPrimitive } from "./effect-primitive.js"
 import {
   Empty,
   Fail,
@@ -65,11 +65,11 @@ import {
   WithEarlyExit,
   WithFlattenStrategy,
   WithScopedFork
-} from "./fx-primitive"
-import { adjustTime } from "./helpers"
-import { matchFxInput } from "./matchers"
-import { OnceEffect } from "./protos"
-import { run } from "./run"
+} from "./fx-primitive.js"
+import { adjustTime } from "./helpers.js"
+import { matchFxInput } from "./matchers.js"
+import { OnceEffect } from "./protos.js"
+import { run } from "./run.js"
 
 const constUnit = () => Effect.unit
 

package/src/internal/effect-operator.ts

@@ -1,8 +1,8 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import { WithContext } from "../Sink"
-import type { SyncOperator } from "./sync-operator"
+import { WithContext } from "../Sink.js"
+import type { SyncOperator } from "./sync-operator.js"
 
 // Effect operators are a subset of operators which can be safely fused together assynchronously
 

package/src/internal/fx-effect-proto.ts

@@ -1,8 +1,8 @@
 import * as Effect from "effect/Effect"
-import type { Fx } from "../Fx"
-import type { Versioned } from "../Versioned"
-import { succeed } from "./core"
-import { FxEffectBase } from "./protos"
+import type { Fx } from "../Fx.js"
+import type { Versioned } from "../Versioned.js"
+import { succeed } from "./core.js"
+import { FxEffectBase } from "./protos.js"
 
 /**
  * Construct a Versioned type.

package/src/internal/fx-primitive.ts

@@ -2,12 +2,12 @@ import type * as Cause from "effect/Cause"
 import type * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
 
-import type * as Sink from "../Sink"
-import { type EffectOperator, fuseEffectOperators, liftSyncOperator } from "./effect-operator"
-import * as syncOperator from "./sync-operator"
+import type * as Sink from "../Sink.js"
+import { type EffectOperator, fuseEffectOperators, liftSyncOperator } from "./effect-operator.js"
+import * as syncOperator from "./sync-operator.js"
 
-import type { FlattenStrategy, Fx, FxFork, WithEarlyExitParams, WithScopedForkParams } from "../Fx"
-import { FxProto } from "./protos"
+import type { FlattenStrategy, Fx, FxFork, WithEarlyExitParams, WithScopedForkParams } from "../Fx.js"
+import { FxProto } from "./protos.js"
 
 export type Primitive =
   | Empty

package/src/internal/fx.ts

@@ -22,12 +22,12 @@ import type * as Request from "effect/Request"
 import type { Scheduler } from "effect/Scheduler"
 import type * as Scope from "effect/Scope"
 import * as Tracer from "effect/Tracer"
-import type { Fx, FxInput } from "../Fx"
-import * as Sink from "../Sink"
-import * as Typeclass from "../Typeclass"
-import * as core from "./core"
-import { run } from "./run"
-import { multicast } from "./share"
+import type { Fx, FxInput } from "../Fx.js"
+import * as Sink from "../Sink.js"
+import * as Typeclass from "../Typeclass.js"
+import * as core from "./core.js"
+import { run } from "./run.js"
+import { multicast } from "./share.js"
 
 /**
  * Create an Fx which will emit a value after waiting for a specified duration.

package/src/internal/helpers.ts

@@ -9,10 +9,10 @@ import * as Ref from "effect/Ref"
 import * as Runtime from "effect/Runtime"
 import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
-import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx"
-import type * as Sink from "../Sink"
-import type { InternalEffect } from "./effect-primitive"
-import { matchEffectPrimitive } from "./effect-primitive"
+import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx.js"
+import type * as Sink from "../Sink.js"
+import type { InternalEffect } from "./effect-primitive.js"
+import { matchEffectPrimitive } from "./effect-primitive.js"
 
 export function withScopedFork<R, E, A>(
   f: (fork: ScopedFork, scope: Scope.Scope) => Effect.Effect<R, E, A>

package/src/internal/keyed.ts

@@ -6,14 +6,14 @@ import * as MutableHashMap from "effect/MutableHashMap"
 import * as Option from "effect/Option"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 import * as Scope from "effect/Scope"
-import type * as Fx from "../Fx"
-import { fromEffect, type RefSubject } from "../RefSubject"
-import { WithContext } from "../Sink"
-import type { Subject } from "../Subject"
-import { from, skipRepeatsWith, withScopedFork } from "./core"
-import { makeHoldSubject } from "./core-subject"
-import { adjustTime } from "./helpers"
-import { run } from "./run"
+import type * as Fx from "../Fx.js"
+import { fromEffect, type RefSubject } from "../RefSubject.js"
+import { WithContext } from "../Sink.js"
+import type { Subject } from "../Subject.js"
+import { makeHoldSubject } from "./core-subject.js"
+import { from, skipRepeatsWith, withScopedFork } from "./core.js"
+import { adjustTime } from "./helpers.js"
+import { run } from "./run.js"
 
 export function keyed<R, E, A, B, R2, E2, C>(
   fx: Fx.Fx<R, E, ReadonlyArray<A>>,

package/src/internal/matchers.ts

@@ -1,12 +1,12 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
-import * as TypeId from "../TypeId"
+import * as TypeId from "../TypeId.js"
 
-import type * as Sink from "../Sink"
+import type * as Sink from "../Sink.js"
 
-import type { Fx, FxInput } from "../Fx"
-import type { RefSubject } from "../RefSubject"
-import type * as Primitive from "./fx-primitive"
+import type { Fx, FxInput } from "../Fx.js"
+import type { RefSubject } from "../RefSubject.js"
+import type * as Primitive from "./fx-primitive.js"
 
 export function matchFxPrimitive<B>(
   matchers: {

package/src/internal/protos.ts

@@ -8,8 +8,8 @@ import { Effectable } from "effect"
 import * as Fiber from "effect/Fiber"
 import { NodeInspectSymbol } from "effect/Inspectable"
 import type { Inspectable } from "effect/Inspectable"
-import type { Fx, ToFx } from "../Fx"
-import { TypeId } from "../TypeId"
+import type { Fx, ToFx } from "../Fx.js"
+import { TypeId } from "../TypeId.js"
 
 export const Variance: Fx<any, any, any>[TypeId] = {
   _R: identity,

package/src/internal/run.ts

@@ -1,12 +1,12 @@
 import * as Effect from "effect/Effect"
 
-import * as Sink from "../Sink"
-import { compileCauseEffectOperatorSink, compileEffectOperatorSink } from "./effect-operator"
-import * as helpers from "./helpers"
-import { compileSyncOperatorFailureSink, compileSyncOperatorSink } from "./sync-operator"
+import * as Sink from "../Sink.js"
+import { compileCauseEffectOperatorSink, compileEffectOperatorSink } from "./effect-operator.js"
+import * as helpers from "./helpers.js"
+import { compileSyncOperatorFailureSink, compileSyncOperatorSink } from "./sync-operator.js"
 
-import type { Fx } from "../Fx"
-import { matchFxPrimitive } from "./matchers"
+import type { Fx } from "../Fx.js"
+import { matchFxPrimitive } from "./matchers.js"
 
 const constUnit = () => Effect.unit
 

package/src/internal/schema-ref-subject.ts

@@ -5,12 +5,12 @@ import { Option } from "effect"
 import * as Effect from "effect/Effect"
 import type * as Equivalence from "effect/Equivalence"
 import type * as Scope from "effect/Scope"
-import type { Fx, FxInput } from "../Fx"
-import type { MakeRefSubject, RefSubject, ToRefSubject } from "../RefSubject"
-import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "../TypeId"
-import { map } from "./core"
-import { make, struct } from "./core-ref-subject"
-import { matchFxInput } from "./matchers"
+import type { Fx, FxInput } from "../Fx.js"
+import type { MakeRefSubject, RefSubject, ToRefSubject } from "../RefSubject.js"
+import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "../TypeId.js"
+import { make, struct } from "./core-ref-subject.js"
+import { map } from "./core.js"
+import { matchFxInput } from "./matchers.js"
 
 const makeSchema = <O>(
   f: <R, E>(

package/src/internal/share.ts

@@ -3,12 +3,12 @@ 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"
-import type { Subject } from "../Subject"
-import { withScopedFork } from "./core"
-import { makeHoldSubject, makeReplaySubject, makeSubject } from "./core-subject"
-import { ToFx } from "./fx-primitive"
-import { run } from "./run"
+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"
 
 export function share<R, E, A, R2>(
   fx: Fx<R, E, A>,

package/src/internal/strategies.ts

@@ -1,4 +1,4 @@
-import type * as Fx from "../Fx"
+import type * as Fx from "../Fx.js"
 
 export const Unbounded: Fx.Unbounded = { _tag: "Unbounded" }
 

package/src/internal/sync-operator.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import { WithContext } from "../Sink"
+import { WithContext } from "../Sink.js"
 
 // Sync operators are a subset of operators which can be safely fused together synchronously
 

package/src/internal/versioned-transform.ts

@@ -1,9 +1,9 @@
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import type { Fx } from "../Fx"
-import type { Versioned } from "../Versioned"
-import { MulticastEffect } from "./helpers"
-import { FxEffectBase } from "./protos"
+import type { Fx } from "../Fx.js"
+import type { Versioned } from "../Versioned.js"
+import { MulticastEffect } from "./helpers.js"
+import { FxEffectBase } from "./protos.js"
 
 export class VersionedTransform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>
   extends FxEffectBase<R3, E3, C, R0 | R4, E0 | E4, D>

package/src/internal/withKey.ts

@@ -3,12 +3,12 @@ import { equals } from "effect/Equal"
 import * as Fiber from "effect/Fiber"
 import * as Option from "effect/Option"
 import * as Scope from "effect/Scope"
-import type { Fx, FxInput } from "../Fx"
-import * as RefSubject from "../RefSubject"
-import * as Sink from "../Sink"
-import * as core from "./core"
-import { adjustTime } from "./helpers"
-import { run } from "./run"
+import type { Fx, FxInput } 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"
 
 export function withKey<R, E, A, B, R2, E2, C>(
   fx: Fx<R, E, A>,