@typed/fx 1.0.5 → 1.0.7

package/src/operator/takeWhile.ts

@@ -1,7 +1,7 @@
 import { pipe } from '@fp-ts/data/Function'
-import { Predicate, not } from '@fp-ts/data/Predicate'
+import { type Predicate, not } from '@fp-ts/data/Predicate'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { takeUntil } from './takeUntil.js'
 

package/src/operator/tap.ts

@@ -1,7 +1,7 @@
 import * as Effect from '@effect/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { fromEffect } from '../constructor/fromEffect.js'
 
 import { flatMap } from './flatMap.js'

package/src/operator/tapDefect.ts

@@ -3,7 +3,7 @@ import * as Effect from '@effect/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 import { match } from '@fp-ts/data/Option'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { tapCause } from './tapCause.js'
 

package/src/operator/tapError.ts

@@ -3,7 +3,7 @@ import * as Effect from '@effect/io/Effect'
 import { match } from '@fp-ts/data/Either'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { tapCause } from './tapCause.js'
 

package/src/operator/throttle.ts

@@ -1,9 +1,9 @@
 import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Duration from '@fp-ts/data/Duration'
+import type * as Fiber from '@effect/io/Fiber'
+import type * as Duration from '@fp-ts/data/Duration'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { suspend } from '../constructor/suspend.js'
 
 import { filterEffect } from './filterEffect.js'

package/src/operator/tuple.ts

@@ -1,4 +1,4 @@
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { combineAll } from './combine.js'
 

package/src/operator/until.test.ts

@@ -1,47 +1,47 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as TestClock from '@effect/io/internal/testing/testClock'
-import * as TE from '@effect/io/internal/testing/testEnvironment'
-import * as Duration from '@fp-ts/data/Duration'
-import { pipe } from '@fp-ts/data/Function'
-import { describe, it } from 'vitest'
-
-import { at } from '../constructor/at.js'
-import { periodic } from '../constructor/periodic.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { until } from './until.js'
-import { withItems } from './withItems.js'
-
-describe(import.meta.url, () => {
-  describe(until.name, () => {
-    it('interrupts a stream when a signal is received', async () => {
-      const delay = 20
-      const expected = 5
-      const fx = pipe(
-        periodic(Duration.millis(delay)),
-        withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-        until(at(Duration.millis(delay * expected), null)),
-      )
-
-      const test = pipe(
-        Effect.gen(function* ($) {
-          const fiber = yield* $(Effect.fork(collectAll(fx)))
-
-          for (let i = 0; i < expected; i++) {
-            yield* $(TestClock.adjust(Duration.millis(delay)))
-          }
-
-          return yield* $(Fiber.join(fiber))
-        }),
-        Effect.provideSomeLayer(TE.TestEnvironment),
-      )
-
-      const events = await Effect.unsafeRunPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3, 4, 5])
-    })
-  })
-})
+// import { deepStrictEqual } from 'assert'
+
+// import * as Effect from '@effect/io/Effect'
+// import * as Fiber from '@effect/io/Fiber'
+// import * as TestClock from '@effect/io/internal/testing/testClock'
+// import * as TE from '@effect/io/internal/testing/testEnvironment'
+// import * as Duration from '@fp-ts/data/Duration'
+// import { pipe } from '@fp-ts/data/Function'
+// import { describe, it } from 'vitest'
+
+// import { at } from '../constructor/at.js'
+// import { periodic } from '../constructor/periodic.js'
+// import { collectAll } from '../run/collectAll.js'
+
+// import { until } from './until.js'
+// import { withItems } from './withItems.js'
+
+// describe(import.meta.url, () => {
+//   describe(until.name, () => {
+//     it('interrupts a stream when a signal is received', async () => {
+//       const delay = 20
+//       const expected = 5
+//       const fx = pipe(
+//         periodic(Duration.millis(delay)),
+//         withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+//         until(at(Duration.millis(delay * expected), null)),
+//       )
+
+//       const test = pipe(
+//         Effect.gen(function* ($) {
+//           const fiber = yield* $(Effect.fork(collectAll(fx)))
+
+//           for (let i = 0; i < expected; i++) {
+//             yield* $(TestClock.adjust(Duration.millis(delay)))
+//           }
+
+//           return yield* $(Fiber.join(fiber))
+//         }),
+//         Effect.provideSomeLayer(TE.TestEnvironment),
+//       )
+
+//       const events = await Effect.unsafeRunPromise(test)
+
+//       deepStrictEqual(events, [1, 2, 3, 4, 5])
+//     })
+//   })
+// })

package/src/operator/withItems.ts

@@ -1,6 +1,6 @@
 import { identity } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { zipItems } from './zipItems.js'
 

package/src/operator/withRuntimeFlags.ts

@@ -1,5 +1,5 @@
 import * as Effect from '@effect/io/Effect'
-import { RuntimeFlagsPatch } from '@effect/io/Fiber/Runtime/Flags/Patch'
+import type { RuntimeFlagsPatch } from '@effect/io/Fiber/Runtime/Flags/Patch'
 import { pipe } from '@fp-ts/data/Function'
 
 import { Fx } from '../Fx.js'

package/src/run/collectAll.ts

@@ -1,7 +1,7 @@
 import * as Effect from '@effect/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { reduce } from './reduce.js'
 

package/src/run/collectN.ts

@@ -1,7 +1,7 @@
 import * as Effect from '@effect/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { take } from '../operator/take.js'
 
 import { reduce } from './reduce.js'

package/src/run/drain.ts

@@ -1,6 +1,6 @@
 import * as Effect from '@effect/io/Effect'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { observe } from './observe.js'
 

package/src/run/observe.ts

@@ -1,8 +1,8 @@
 import * as Effect from '@effect/io/Effect'
-import { Scope } from '@effect/io/Scope'
+import type { Scope } from '@effect/io/Scope'
 import { flow } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { run_ } from './run.js'
 

package/src/run/reduce.ts

@@ -1,7 +1,7 @@
 import * as Effect from '@effect/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { observeSync } from './observe.js'
 

package/src/run/run.ts

@@ -1,8 +1,8 @@
-import { Cause } from '@effect/io/Cause'
+import type { Cause } from '@effect/io/Cause'
 import * as Deferred from '@effect/io/Deferred'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
-import { Scope } from '@effect/io/Scope'
+import type { Scope } from '@effect/io/Scope'
 import { flow, pipe } from '@fp-ts/data/Function'
 
 import { Fx, Sink } from '../Fx.js'

package/src/run/unsafe.ts

@@ -1,10 +1,10 @@
 import * as Effect from '@effect/io/Effect'
-import * as Exit from '@effect/io/Exit'
-import * as Fiber from '@effect/io/Fiber'
-import { Cancel } from '@effect/io/Runtime'
-import * as Scope from '@effect/io/Scope'
+import type * as Exit from '@effect/io/Exit'
+import type * as Fiber from '@effect/io/Fiber'
+import type { Cancel } from '@effect/io/Runtime'
+import type * as Scope from '@effect/io/Scope'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 import { drain } from './drain.js'
 

package/src/typeclass/Alternative.ts

@@ -1,8 +1,8 @@
-import * as A from '@fp-ts/core/typeclass/Alternative'
+import type * as A from '@fp-ts/core/typeclass/Alternative'
 
 import { CoproductRace, CoproductOrElse } from './Coproduct.js'
 import { SemiAlternativeRace, SemiAlternativeOrElse } from './SemiAlternative.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const ApplicativeRace: A.Alternative<FxTypeLambda> = {
   ...SemiAlternativeRace,

package/src/typeclass/Applicative.ts

@@ -1,11 +1,11 @@
-import * as A from '@fp-ts/core/typeclass/Applicative'
+import type * as A from '@fp-ts/core/typeclass/Applicative'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { combineAll } from '../operator/combine.js'
 
 import { Of } from './Of.js'
 import { SemiApplicative } from './SemiApplicative.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Applicative: A.Applicative<FxTypeLambda> = {
   ...SemiApplicative,

package/src/typeclass/Bicovariant.ts

@@ -1,11 +1,11 @@
 import * as B from '@fp-ts/core/typeclass/Bicovariant'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { map } from '../operator/map.js'
 import { mapError } from '../operator/mapError.js'
 
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Bicovariant: B.Bicovariant<FxTypeLambda> = {
   bimap: (f, g) => (fa) => pipe(fa, mapError(f), map(g)),

package/src/typeclass/Chainable.ts

@@ -1,8 +1,8 @@
-import * as C from '@fp-ts/core/typeclass/Chainable'
+import type * as C from '@fp-ts/core/typeclass/Chainable'
 
 import { Covariant } from './Covariant.js'
 import { FlatMap, SwitchMap, ExhaustMap } from './FlatMap.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Chainable: C.Chainable<FxTypeLambda> = {
   ...FlatMap,

package/src/typeclass/Coproduct.ts

@@ -1,14 +1,14 @@
 import * as Cause from '@effect/io/Cause'
-import * as CP from '@fp-ts/core/typeclass/Coproduct'
+import type * as CP from '@fp-ts/core/typeclass/Coproduct'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { failCause } from '../constructor/failCause.js'
 import { never } from '../constructor/never.js'
 import { orElse } from '../operator/orElse.js'
 import { raceAll } from '../operator/race.js'
 
 import { SemiCoproductRace, SemiCoproductOrElse } from './SemiCoproduct.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const CoproductRace: CP.Coproduct<FxTypeLambda> = {
   ...SemiCoproductRace,

package/src/typeclass/Covariant.ts

@@ -1,9 +1,9 @@
 import * as C from '@fp-ts/core/typeclass/Covariant'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 import { map } from '../operator/map.js'
 
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Covariant: C.Covariant<FxTypeLambda> = C.make((f) => map(f))
 

package/src/typeclass/FlatMap.ts

@@ -1,10 +1,10 @@
-import * as F from '@fp-ts/core/typeclass/FlatMap'
+import type * as F from '@fp-ts/core/typeclass/FlatMap'
 
 import { exhaustMap } from '../operator/exhaustMap.js'
 import { flatMap } from '../operator/flatMap.js'
 import { switchMap } from '../operator/switchMap.js'
 
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const FlatMap: F.FlatMap<FxTypeLambda> = {
   flatMap,

package/src/typeclass/Monad.ts

@@ -1,9 +1,9 @@
-import * as M from '@fp-ts/core/typeclass/Monad'
+import type * as M from '@fp-ts/core/typeclass/Monad'
 
 import { Covariant } from './Covariant.js'
 import { FlatMap, SwitchMap, ExhaustMap } from './FlatMap.js'
 import { Pointed } from './Pointed.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Monad: M.Monad<FxTypeLambda> = {
   ...FlatMap,

package/src/typeclass/Of.ts

@@ -1,8 +1,8 @@
-import * as O from '@fp-ts/core/typeclass/Of'
+import type * as O from '@fp-ts/core/typeclass/Of'
 
 import { succeed } from '../constructor/succeed.js'
 
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Of: O.Of<FxTypeLambda> = {
   of: succeed,

package/src/typeclass/Pointed.ts

@@ -1,8 +1,8 @@
-import * as P from '@fp-ts/core/typeclass/Pointed'
+import type * as P from '@fp-ts/core/typeclass/Pointed'
 
 import { Covariant } from './Covariant.js'
 import { Of } from './Of.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Pointed: P.Pointed<FxTypeLambda> = {
   ...Of,

package/src/typeclass/Product.ts

@@ -1,10 +1,10 @@
-import * as P from '@fp-ts/core/typeclass/Product'
+import type * as P from '@fp-ts/core/typeclass/Product'
 
 import { combineAll } from '../operator/combine.js'
 
 import { Of } from './Of.js'
 import { SemiProduct } from './SemiProduct.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const Product: P.Product<FxTypeLambda> = {
   ...SemiProduct,

package/src/typeclass/SemiAlternative.ts

@@ -1,8 +1,8 @@
-import * as SA from '@fp-ts/core/typeclass/SemiAlternative'
+import type * as SA from '@fp-ts/core/typeclass/SemiAlternative'
 
 import { Covariant } from './Covariant.js'
 import { SemiCoproductRace, SemiCoproductOrElse } from './SemiCoproduct.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const SemiAlternativeRace: SA.SemiAlternative<FxTypeLambda> = {
   ...SemiCoproductRace,

package/src/typeclass/SemiApplicative.ts

@@ -1,8 +1,8 @@
-import * as SA from '@fp-ts/core/typeclass/SemiApplicative'
+import type * as SA from '@fp-ts/core/typeclass/SemiApplicative'
 
 import { Covariant } from './Covariant.js'
 import { SemiProduct } from './SemiProduct.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const SemiApplicative: SA.SemiApplicative<FxTypeLambda> = {
   ...SemiProduct,

package/src/typeclass/SemiCoproduct.ts

@@ -1,10 +1,10 @@
-import * as SCP from '@fp-ts/core/typeclass/SemiCoproduct'
+import type * as SCP from '@fp-ts/core/typeclass/SemiCoproduct'
 
 import { orElse } from '../operator/orElse.js'
 import { race, raceAll } from '../operator/race.js'
 
 import { Covariant } from './Covariant.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const SemiCoproductRace: SCP.SemiCoproduct<FxTypeLambda> = {
   coproduct: race,

package/src/typeclass/SemiProduct.ts

@@ -3,7 +3,7 @@ import * as SP from '@fp-ts/core/typeclass/SemiProduct'
 import { combine } from '../operator/combine.js'
 
 import { Covariant } from './Covariant.js'
-import { FxTypeLambda } from './TypeLambda.js'
+import type { FxTypeLambda } from './TypeLambda.js'
 
 export const SemiProduct: SP.SemiProduct<FxTypeLambda> = {
   product: combine,

package/src/typeclass/TypeLambda.ts

@@ -1,6 +1,6 @@
-import { TypeLambda } from '@fp-ts/core/HKT'
+import type { TypeLambda } from '@fp-ts/core/HKT'
 
-import { Fx } from '../Fx.js'
+import type { Fx } from '../Fx.js'
 
 export interface FxTypeLambda extends TypeLambda {
   readonly type: Fx<this['Out2'], this['Out1'], this['Target']>