@livestore/utils 0.4.0-dev.9 → 0.5.0-dev.0

package/src/effect/Stream.ts

@@ -1,11 +1,9 @@
-/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: Biome bug */
 export * from 'effect/Stream'
 
-import { type Cause, Chunk, Effect, Option, pipe, Ref, Stream } from 'effect'
-import { dual } from 'effect/Function'
+import { type Cause, Array, Effect, Function, Option, pipe, Ref, Stream } from 'effect'
 
 export const tapLog = <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
-  tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
+  tapArray<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
 
 export const tapSync =
   <A>(tapFn: (a: A) => unknown) =>
@@ -15,15 +13,24 @@ export const tapSync =
 export const tapLogWithLabel =
   (label: string) =>
   <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
-    tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(label, _))))(stream)
+    tapArray<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(label, _))))(stream)
 
-export const tapChunk =
-  <R1, E1, A, Z>(f: (a: Chunk.Chunk<A>) => Effect.Effect<Z, E1, R1>) =>
+/**
+ * Runs an effect once for each array batch emitted by the stream, preserving
+ * the original stream elements.
+ *
+ * Use this for batch-oriented side effects such as `Queue.offerAll`. For
+ * element-wise side effects, prefer `Stream.tap`.
+ *
+ * @see {@link Stream.tap} for running an effect once per element.
+ */
+export const tapArray =
+  <R1, E1, A, Z>(f: (a: ReadonlyArray<A>) => Effect.Effect<Z, E1, R1>) =>
   <R, E>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E1 | E, R1 | R> =>
-    Stream.mapChunksEffect(self, (chunks) =>
+    Stream.mapArrayEffect(self, (array) =>
       pipe(
-        f(chunks),
-        Effect.map(() => chunks),
+        f(array),
+        Effect.map(() => array),
       ),
     )
 
@@ -68,18 +75,18 @@ export const skipRepeated_ = <R, E, A>(
  * It's different than `Stream.runHead` which runs the stream to completion.
  * */
 export const runFirst = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
-  stream.pipe(Stream.take(1), Stream.runCollect, Effect.map(Chunk.head))
+  stream.pipe(Stream.take(1), Stream.runCollect, Effect.map(Array.head))
 
 /**
- * Returns the first element of the stream or throws a `NoSuchElementException` if the stream is empty.
+ * Returns the first element of the stream or throws a `NoSuchElementError` if the stream is empty.
  * It's different than `Stream.runHead` which runs the stream to completion.
  * */
 export const runFirstUnsafe = <A, E, R>(
   stream: Stream.Stream<A, E, R>,
-): Effect.Effect<A, Cause.NoSuchElementException | E, R> => runFirst(stream).pipe(Effect.flatten)
+): Effect.Effect<A, Cause.NoSuchElementError | E, R> => runFirst(stream).pipe(Effect.flatMap(Effect.fromOption))
 
 export const runCollectReadonlyArray = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<readonly A[], E, R> =>
-  stream.pipe(Stream.runCollect, Effect.map(Chunk.toReadonlyArray))
+  stream.pipe(Stream.runCollect)
 
 /**
  * Concatenates two streams where the second stream has access to the last element
@@ -120,7 +127,7 @@ export const concatWithLastElement: {
     stream: Stream.Stream<A1, E1, R1>,
     getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
   ): Stream.Stream<A1 | A2, E1 | E2, R1 | R2>
-} = dual(
+} = Function.dual(
   2,
   <A1, E1, R1, A2, E2, R2>(
     stream1: Stream.Stream<A1, E1, R1>,
@@ -163,7 +170,7 @@ export const concatWithLastElement: {
 export const emitIfEmpty: {
   <A>(fallbackValue: A): <E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>
   <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R>
-} = dual(
+} = Function.dual(
   2,
   <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R> =>
     concatWithLastElement(stream, (lastElement) =>

package/src/effect/Subscribable.ts

@@ -4,10 +4,15 @@
  * @since 2.0.0
  */
 
-import type { SubscriptionRef } from 'effect'
-import { Effect, Effectable, Readable, Stream } from 'effect'
-import { dual } from 'effect/Function'
-import { hasProperty } from 'effect/Predicate'
+import { Effect, Effectable, Function, Predicate, Stream, SubscriptionRef } from 'effect'
+
+const ReadableTypeId: unique symbol = Symbol.for('effect/Readable')
+type ReadableTypeId = typeof ReadableTypeId
+
+interface Readable<A, E = never, R = never> {
+  readonly [ReadableTypeId]: ReadableTypeId
+  readonly get: Effect.Effect<A, E, R>
+}
 
 /**
  * @since 2.0.0
@@ -25,7 +30,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R>, Effect.Effect<A, E, R> {
+export interface Subscribable<A, E = never, R = never> extends Readable<A, E, R>, Effect.Effect<A, E, R> {
   readonly [TypeId]: TypeId
   readonly changes: Stream.Stream<A, E, R>
 }
@@ -34,52 +39,36 @@ export interface Subscribable<A, E = never, R = never> extends Readable.Readable
  * @since 2.0.0
  * @category refinements
  */
-export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
-
-// const Proto: Omit<Subscribable<any>, 'get' | 'changes'> = {
-//   [Readable.TypeId]: Readable.TypeId,
-//   [TypeId]: TypeId,
-//   pipe() {
-//     return pipeArguments(this, arguments)
-//   },
-// }
-
-class SubscribableImpl<in out A> extends Effectable.Class<A> implements Subscribable<A> {
-  // @ts-expect-error type symbol
-  readonly [TypeId] = TypeId
-  // @ts-expect-error type symbol
-  readonly [Readable.TypeId] = Readable.TypeId
-  readonly get: Effect.Effect<A>
-  readonly changes: Stream.Stream<A>
-  constructor(get: Effect.Effect<A>, changes: Stream.Stream<A>) {
-    super()
-    this.get = get
-    this.changes = changes
-  }
-
-  commit() {
-    return this.get
-  }
-}
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> =>
+  Predicate.hasProperty(u, TypeId)
+
+const Proto: Omit<Subscribable<unknown, unknown, unknown>, 'get' | 'changes'> = Object.assign(
+  Effectable.Prototype<Subscribable<unknown, unknown, unknown>>({
+    label: 'Subscribable',
+    evaluate() {
+      // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- vendored fork; this shared prototype is generic over all A, E, R, so `unknown` in the error/requirements channels is structural, not a real error type
+      return this.get
+    },
+  }),
+  {
+    [ReadableTypeId]: ReadableTypeId,
+    [TypeId]: TypeId,
+  } as const,
+)
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-// export const make = <A, E, R>(options: {
-//   readonly get: Effect.Effect<A, E, R>
-//   readonly changes: Stream.Stream<A, E, R>
-// }): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
-
 export const make = <A, E, R>(options: {
   readonly get: Effect.Effect<A, E, R>
   readonly changes: Stream.Stream<A, E, R>
-}): Subscribable<A, E, R> => new SubscribableImpl(options.get as any, options.changes as any) as Subscribable<A, E, R>
+}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
 
 export const fromSubscriptionRef = <A>(ref: SubscriptionRef.SubscriptionRef<A>): Subscribable<A> =>
   make({
-    get: ref.get,
-    changes: ref.changes,
+    get: SubscriptionRef.get(ref),
+    changes: SubscriptionRef.changes(ref),
   })
 
 /**
@@ -97,7 +86,7 @@ export const map: {
    * @category combinators
    */
   <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
-} = dual(
+} = Function.dual(
   2,
   <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
     make({
@@ -126,7 +115,7 @@ export const mapEffect: {
     self: Subscribable<A, E, R>,
     f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
   ): Subscribable<B, E | E2, R | R2>
-} = dual(
+} = Function.dual(
   2,
   <A, E, R, B, E2, R2>(
     self: Subscribable<A, E, R>,

package/src/effect/SubscriptionRef.ts

@@ -1,23 +1,19 @@
-import { Chunk, Effect, pipe, Stream, SubscriptionRef } from 'effect'
-import { dual } from 'effect/Function'
-import type { Predicate, Refinement } from 'effect/Predicate'
+import { Effect, Function, pipe, Stream, SubscriptionRef, type Predicate } from 'effect'
 
 export * from 'effect/SubscriptionRef'
 
 export const waitUntil: {
   <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>,
-  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B, never, never>
-  <A, B extends A>(
-    predicate: Predicate<B>,
-  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A, never, never>
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B>
+  <A, B extends A>(predicate: Predicate.Predicate<B>): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A>
   <A, B extends A>(
     sref: SubscriptionRef.SubscriptionRef<A>,
-    refinement: Refinement<NoInfer<A>, B>,
-  ): Effect.Effect<B, never, never>
-  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate<B>): Effect.Effect<A, never, never>
-} = dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
-  pipe(sref.changes, Stream.filter(predicate), Stream.take(1), Stream.runCollect, Effect.map(Chunk.unsafeHead)),
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
+  ): Effect.Effect<B>
+  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate.Predicate<B>): Effect.Effect<A>
+} = Function.dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
+  pipe(SubscriptionRef.changes(sref), Stream.filter(predicate), Stream.runHead, Effect.flatMap(Effect.fromOption)),
 )
 
 export const fromStream = <A>(stream: Stream.Stream<A>, initialValue: A) =>

package/src/effect/TaskTracing.ts

@@ -1,9 +1,4 @@
-import { Predicate } from 'effect'
-import * as Context from 'effect/Context'
-import * as Effect from 'effect/Effect'
-import { pipe } from 'effect/Function'
-import * as Layer from 'effect/Layer'
-import * as Tracer from 'effect/Tracer'
+import { Context, Effect, Layer, Predicate, Tracer } from 'effect'
 
 export const withAsyncTaggingTracing =
   (makeTrace: (name: string) => { run: (fn: any) => any }) =>
@@ -14,30 +9,32 @@ export const withAsyncTaggingTracing =
 
     const makeTracer = Effect.gen(function* () {
       const oldTracer = yield* Effect.tracer
+      const evaluate = <X>(primitive: Tracer.EffectPrimitive<X>, fiber: any) =>
+        oldTracer.context?.(primitive, fiber) ?? primitive['~effect/Effect/evaluate'](fiber)
       return Tracer.make({
-        span: (name, ...args) => {
-          const span = oldTracer.span(name, ...args)
-          const trace = makeTrace(name)
+        span: (options) => {
+          const span = oldTracer.span(options)
+          const trace = makeTrace(options.name)
           ;(span as any).runInTask = (f: any) => trace.run(f)
           return span
         },
-        context: (f, fiber) => {
-          const maybeParentSpan = Context.getOption(Tracer.ParentSpan)(fiber.currentContext)
+        context: (primitive, fiber) => {
+          const maybeParentSpan = Context.getOption(fiber.context, Tracer.ParentSpan)
 
-          if (maybeParentSpan._tag === 'None') return oldTracer.context(f, fiber)
+          if (maybeParentSpan._tag === 'None') return evaluate(primitive, fiber)
           const parentSpan = maybeParentSpan.value
-          if (parentSpan._tag === 'ExternalSpan') return oldTracer.context(f, fiber)
+          if (parentSpan._tag === 'ExternalSpan') return evaluate(primitive, fiber)
           const span = parentSpan
           if ('runInTask' in span && typeof span.runInTask === 'function') {
-            return span.runInTask(() => oldTracer.context(f, fiber))
+            return span.runInTask(() => evaluate(primitive, fiber))
           }
 
-          return oldTracer.context(f, fiber)
+          return evaluate(primitive, fiber)
         },
       })
     })
 
-    const withTracerLayer = pipe(makeTracer, Effect.map(Layer.setTracer), Layer.unwrapEffect)
+    const withTracerLayer = Layer.effect(Tracer.Tracer, makeTracer)
 
     return Effect.provide(eff, withTracerLayer)
   }

package/src/effect/WebChannel/WebChannel.test.ts

@@ -1,12 +1,12 @@
 import * as Vitest from '@effect/vitest'
-import { Effect, Schema, Stream } from 'effect'
+import { Effect, Fiber, Schema, Stream } from 'effect'
 import { JSDOM } from 'jsdom'
 
-import * as WebChannel from './WebChannel.ts'
+import * as WebChannel from '../../browser/WebChannelBrowser.ts'
 
 Vitest.describe('WebChannel', () => {
   Vitest.describe('windowChannel', () => {
-    Vitest.scopedLive('should work with 2 windows', () =>
+    Vitest.live('should work with 2 windows', () =>
       Effect.gen(function* () {
         const windowA = new JSDOM().window as unknown as globalThis.Window
         const windowB = new JSDOM().window as unknown as globalThis.Window
@@ -16,19 +16,19 @@ Vitest.describe('WebChannel', () => {
             listenWindow: windowA,
             sendWindow: windowB,
             ids: { own: 'a', other: 'b' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromBFiber = yield* channelToB.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToB.send(1)
 
-          Vitest.expect(yield* msgFromBFiber).toEqual(2)
+          Vitest.expect(yield* Fiber.join(msgFromBFiber)).toEqual(2)
         })
 
         const codeSideB = Effect.gen(function* () {
@@ -36,26 +36,26 @@ Vitest.describe('WebChannel', () => {
             listenWindow: windowB,
             sendWindow: windowA,
             ids: { own: 'b', other: 'a' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromAFiber = yield* channelToA.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToA.send(2)
 
-          Vitest.expect(yield* msgFromAFiber).toEqual(1)
+          Vitest.expect(yield* Fiber.join(msgFromAFiber)).toEqual(1)
         })
 
         yield* Effect.all([codeSideA, codeSideB], { concurrency: 'unbounded' })
       }),
     )
 
-    Vitest.scopedLive('should work with the same window', () =>
+    Vitest.live('should work with the same window', () =>
       Effect.gen(function* () {
         const window = new JSDOM().window as unknown as globalThis.Window
 
@@ -64,19 +64,19 @@ Vitest.describe('WebChannel', () => {
             listenWindow: window,
             sendWindow: window,
             ids: { own: 'a', other: 'b' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromBFiber = yield* channelToB.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToB.send(1)
 
-          Vitest.expect(yield* msgFromBFiber).toEqual(2)
+          Vitest.expect(yield* Fiber.join(msgFromBFiber)).toEqual(2)
         })
 
         const codeSideB = Effect.gen(function* () {
@@ -84,19 +84,19 @@ Vitest.describe('WebChannel', () => {
             listenWindow: window,
             sendWindow: window,
             ids: { own: 'b', other: 'a' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromAFiber = yield* channelToA.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToA.send(2)
 
-          Vitest.expect(yield* msgFromAFiber).toEqual(1)
+          Vitest.expect(yield* Fiber.join(msgFromAFiber)).toEqual(1)
         })
 
         yield* Effect.all([codeSideA, codeSideB], { concurrency: 'unbounded' })