@livestore/utils 0.0.55-dev.1 → 0.0.55-dev.3

package/src/effect/browser-worker-tmp/internal/worker.ts

@@ -1,71 +0,0 @@
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
-import * as Deferred from 'effect/Deferred'
-import * as Effect from 'effect/Effect'
-import * as Layer from 'effect/Layer'
-import * as Queue from 'effect/Queue'
-
-import * as Worker from '../../worker-tmp/Worker.js'
-import { WorkerError } from '../../worker-tmp/WorkerError.js'
-
-const platformWorkerImpl = Worker.PlatformWorker.of({
-  [Worker.PlatformWorkerTypeId]: Worker.PlatformWorkerTypeId,
-  spawn<I, O>(worker_: unknown) {
-    return Effect.gen(function* (_) {
-      const worker = worker_ as globalThis.SharedWorker | globalThis.Worker | MessagePort
-      let port: globalThis.Worker | MessagePort
-      if ('port' in worker) {
-        port = worker.port
-      } else {
-        port = worker
-      }
-
-      yield* _(Effect.addFinalizer(() => Effect.sync(() => port.postMessage([1]))))
-
-      const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
-      const latch = yield* Deferred.make<void>()
-
-      const fiber = yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
-          function onMessage(event: MessageEvent) {
-            queue.unsafeOffer((event as MessageEvent).data)
-          }
-          function onError(event: ErrorEvent) {
-            resume(new WorkerError({ reason: 'unknown', error: event.error ?? event.message }))
-          }
-          port.addEventListener('message', onMessage as any)
-          port.addEventListener('error', onError as any)
-          Deferred.unsafeDone(latch, Effect.void)
-          return Effect.sync(() => {
-            port.removeEventListener('message', onMessage as any)
-            port.removeEventListener('error', onError as any)
-          })
-        }),
-        Effect.interruptible,
-        Effect.forkScoped,
-      )
-      yield* Deferred.await(latch)
-
-      if ('start' in port) {
-        port.start()
-      }
-
-      const send = (message: I, transfers?: ReadonlyArray<unknown>) =>
-        Effect.try({
-          try: () => port.postMessage([0, message], transfers as any),
-          catch: (error) => new WorkerError({ reason: 'send', error }),
-        })
-
-      return { fiber, queue, send }
-    })
-  },
-})
-
-/** @internal */
-export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerImpl)
-
-/** @internal */
-export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
-
-/** @internal */
-export const layer = (spawn: (id: number) => globalThis.Worker | globalThis.SharedWorker | MessagePort) =>
-  Layer.merge(layerManager, Worker.layerSpawner(spawn))

package/src/effect/browser-worker-tmp/internal/workerRunner.ts

@@ -1,119 +0,0 @@
-/// <reference lib="webworker" />
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
-import * as Cause from 'effect/Cause'
-import * as Effect from 'effect/Effect'
-import * as FiberSet from 'effect/FiberSet'
-import { globalValue } from 'effect/GlobalValue'
-import * as Layer from 'effect/Layer'
-import * as Queue from 'effect/Queue'
-import * as Schedule from 'effect/Schedule'
-
-import { WorkerError } from '../../worker-tmp/WorkerError.js'
-import * as WorkerRunner from '../../worker-tmp/WorkerRunner.js'
-
-const cachedPorts = globalValue('@effect/platform-browser/Worker/cachedPorts', () => new Set<MessagePort>())
-function globalHandleConnect(event: MessageEvent) {
-  cachedPorts.add((event as MessageEvent).ports[0]!)
-}
-if (typeof self !== 'undefined' && 'onconnect' in self) {
-  // @ts-expect-error TODO
-  self.addEventListener('connect', globalHandleConnect)
-}
-
-const platformRunnerImpl = WorkerRunner.PlatformRunner.of({
-  [WorkerRunner.PlatformRunnerTypeId]: WorkerRunner.PlatformRunnerTypeId,
-  start<I, O>(shutdown: Effect.Effect<void>) {
-    return Effect.gen(function* () {
-      let currentPortId = 0
-
-      yield* Effect.addFinalizer(() => Effect.sync(() => self.close()))
-
-      const queue = yield* Queue.unbounded<readonly [portId: number, message: I]>()
-      const runFork = yield* FiberSet.makeRuntime<never>()
-      const ports = new Map<number, MessagePort>()
-      const send = (portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
-        Effect.sync(() => {
-          ports.get(portId)?.postMessage([1, message], {
-            transfer: transfer as any,
-          })
-        })
-
-      function handlePort(port: MessagePort, sharedWorker: boolean) {
-        const portId = currentPortId++
-        ports.set(portId, port)
-
-        Effect.async<never, WorkerError, never>((resume) => {
-          function onMessage(event: MessageEvent) {
-            const message = (event as MessageEvent).data as WorkerRunner.BackingRunner.Message<I>
-            if (message[0] === 0) {
-              queue.unsafeOffer([portId, message[1]])
-            } else if (sharedWorker && ports.size > 1) {
-              resume(Effect.interrupt)
-            } else {
-              Effect.runFork(shutdown)
-            }
-          }
-          function onMessageError(error: ErrorEvent) {
-            resume(new WorkerError({ reason: 'decode', error: error.error ?? error.message }))
-          }
-          function onError(error: ErrorEvent) {
-            resume(new WorkerError({ reason: 'unknown', error: error.error ?? error.message }))
-          }
-          port.addEventListener('message', onMessage as any)
-          port.addEventListener('messageerror', onMessageError as any)
-          port.addEventListener('error', onError as any)
-
-          // ready
-          if ('start' in port) {
-            port.start()
-          }
-          port.postMessage([0])
-
-          return Effect.sync(() => {
-            port.removeEventListener('message', onMessage as any)
-            port.removeEventListener('messageerror', onMessageError as any)
-            port.removeEventListener('error', onError as any)
-          })
-        }).pipe(
-          Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logDebug(cause))),
-          Effect.retry(Schedule.forever),
-          Effect.annotateLogs({
-            package: '@effect/platform-browser',
-            module: 'WorkerRunner',
-          }),
-          Effect.ensuring(
-            Effect.sync(() => {
-              ports.delete(portId)
-            }),
-          ),
-          Effect.interruptible,
-          runFork,
-        )
-      }
-
-      if ('onconnect' in self) {
-        // @ts-expect-error TODO
-        self.addEventListener('connect', (event: MessageEvent) => {
-          const port = (event as MessageEvent).ports[0]
-          handlePort(port!, true)
-        })
-        yield* Effect.addFinalizer(() =>
-          Effect.sync(() => {
-            ;(self as any).addEventListener('connect', globalHandleConnect)
-          }),
-        )
-        for (const port of cachedPorts) {
-          handlePort(port, true)
-        }
-        cachedPorts.clear()
-      } else {
-        handlePort(self as any, false)
-      }
-
-      return { queue, send }
-    })
-  },
-})
-
-/** @internal */
-export const layer = Layer.succeed(WorkerRunner.PlatformRunner, platformRunnerImpl)

package/src/effect/browser-worker-tmp/port-platform-runner.ts

@@ -1,74 +0,0 @@
-import { Deferred } from 'effect'
-import * as Cause from 'effect/Cause'
-import * as Effect from 'effect/Effect'
-import * as Layer from 'effect/Layer'
-import * as Queue from 'effect/Queue'
-import * as Schedule from 'effect/Schedule'
-
-import { WorkerError } from '../worker-tmp/WorkerError.js'
-import * as Runner from '../worker-tmp/WorkerRunner.js'
-
-const platformRunnerImpl = (port: MessagePort) =>
-  Runner.PlatformRunner.of({
-    [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
-    start: <I, O>(shutdown: Effect.Effect<void>) => {
-      return Effect.gen(function* () {
-        const queue = yield* Queue.unbounded<readonly [portId: number, message: I]>()
-
-        const latch = yield* Deferred.make<void>()
-
-        yield* Effect.async<never, WorkerError>((resume) => {
-          const onMessage = (msg: MessageEvent<Runner.BackingRunner.Message<I>>) => {
-            const message = msg.data
-            if (message[0] === 0) {
-              queue.unsafeOffer([0, message[1]])
-            } else {
-              Effect.runFork(shutdown)
-            }
-          }
-
-          const onError = (error: any) => {
-            resume(new WorkerError({ reason: 'decode', error }))
-          }
-
-          port.addEventListener('message', onMessage)
-          port.addEventListener('messageerror', onError)
-          port.addEventListener('error', onError)
-
-          Deferred.unsafeDone(latch, Effect.void)
-
-          return Effect.sync(() => {
-            port.removeEventListener('message', onMessage as any)
-            port.removeEventListener('error', onError as any)
-          })
-        }).pipe(
-          Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logDebug(cause))),
-          Effect.retry(Schedule.forever),
-          Effect.annotateLogs({
-            package: '@livestore/utils/effect',
-            module: 'PortPlatformRunner',
-          }),
-          Effect.interruptible,
-          Effect.forkScoped,
-        )
-
-        yield* Deferred.await(latch)
-
-        port.start()
-
-        const send = (_portId: number, message: O, transfers?: ReadonlyArray<unknown>) =>
-          Effect.try({
-            try: () => port.postMessage([1, message], transfers as any),
-            catch: (error) => new WorkerError({ reason: 'send', error }),
-          }).pipe(Effect.catchTag('WorkerError', Effect.orDie))
-
-        // ready
-        port.postMessage([0])
-
-        return { queue, send }
-      })
-    },
-  })
-
-/** @internal */
-export const layerMessagePort = (port: MessagePort) => Layer.succeed(Runner.PlatformRunner, platformRunnerImpl(port))

package/src/effect/worker-tmp/Worker.ts

@@ -1,374 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as ParseResult from '@effect/schema/ParseResult'
-import type * as Schema from '@effect/schema/Schema'
-import type * as Serializable from '@effect/schema/Serializable'
-import type * as Context from 'effect/Context'
-import type * as Duration from 'effect/Duration'
-import type * as Effect from 'effect/Effect'
-import type * as Fiber from 'effect/Fiber'
-import type { LazyArg } from 'effect/Function'
-import type * as Layer from 'effect/Layer'
-import type * as Option from 'effect/Option'
-import type * as Pool from 'effect/Pool'
-import type * as Queue from 'effect/Queue'
-import type * as Scope from 'effect/Scope'
-import type * as Stream from 'effect/Stream'
-import type * as Tracer from 'effect/Tracer'
-
-import * as internal from './internal/worker.js'
-import type { WorkerError, WorkerErrorFrom } from './WorkerError.js'
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface BackingWorker<I, O> {
-  readonly fiber: Fiber.Fiber<never, WorkerError>
-  readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<void, WorkerError>
-  readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export declare namespace BackingWorker {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Message<O> = readonly [ready: 0] | readonly [data: 1, O]
-}
-
-/**
- * @since 1.0.0
- * @category type ids
- */
-export const PlatformWorkerTypeId: unique symbol = internal.PlatformWorkerTypeId
-
-/**
- * @since 1.0.0
- * @category type ids
- */
-export type PlatformWorkerTypeId = typeof PlatformWorkerTypeId
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface PlatformWorker {
-  readonly [PlatformWorkerTypeId]: PlatformWorkerTypeId
-  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<BackingWorker<I, O>, WorkerError, Scope.Scope>
-}
-
-/**
- * @since 1.0.0
- * @category tags
- */
-export const PlatformWorker: Context.Tag<PlatformWorker, PlatformWorker> = internal.PlatformWorker
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface Worker<I, O, E = never> {
-  readonly id: number
-  readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
-  readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface Spawner {
-  readonly _: unique symbol
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface SpawnerFn<W = unknown> {
-  (id: number): W
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export declare namespace Worker {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Options<I> {
-    readonly encode?: ((message: I) => Effect.Effect<unknown, WorkerError>) | undefined
-    readonly transfers?: ((message: I) => ReadonlyArray<unknown>) | undefined
-    readonly queue?: WorkerQueue<I> | undefined
-    readonly initialMessage?: LazyArg<I> | undefined
-  }
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Request<I = unknown> =
-    | readonly [id: number, data: 0, I, trace: Span | undefined]
-    | readonly [id: number, interrupt: 1]
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Span = readonly [traceId: string, spanId: string, sampled: boolean]
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Response<E, O = unknown> =
-    | readonly [id: number, data: 0, ReadonlyArray<O>]
-    | readonly [id: number, end: 1]
-    | readonly [id: number, end: 1, ReadonlyArray<O>]
-    | readonly [id: number, error: 2, E]
-    | readonly [id: number, defect: 3, Schema.CauseEncoded<WorkerErrorFrom, unknown>]
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface WorkerPool<I, O, E = never> {
-  readonly backing: Pool.Pool<Worker<I, O, E>, WorkerError>
-  readonly broadcast: (message: I) => Effect.Effect<void, E | WorkerError>
-  readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
-  readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export declare namespace WorkerPool {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Options<I> = Worker.Options<I> &
-    (
-      | {
-          readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-          readonly size: number
-          readonly concurrency?: number | undefined
-          readonly targetUtilization?: number | undefined
-        }
-      | {
-          readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-          readonly minSize: number
-          readonly maxSize: number
-          readonly concurrency?: number | undefined
-          readonly targetUtilization?: number | undefined
-          readonly timeToLive: Duration.DurationInput
-        }
-    )
-}
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface WorkerQueue<I> {
-  readonly offer: (id: number, item: I, span: Option.Option<Tracer.Span>) => Effect.Effect<void>
-  readonly take: Effect.Effect<readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>
-  readonly shutdown: Effect.Effect<void>
-}
-
-/**
- * @since 1.0.0
- * @category type ids
- */
-export const WorkerManagerTypeId: unique symbol = internal.WorkerManagerTypeId
-
-/**
- * @since 1.0.0
- * @category type ids
- */
-export type WorkerManagerTypeId = typeof WorkerManagerTypeId
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface WorkerManager {
-  readonly [WorkerManagerTypeId]: WorkerManagerTypeId
-  readonly spawn: <I, O, E>(
-    options: Worker.Options<I>,
-  ) => Effect.Effect<Worker<I, O, E>, WorkerError, Scope.Scope | Spawner>
-}
-
-/**
- * @since 1.0.0
- * @category tags
- */
-export const WorkerManager: Context.Tag<WorkerManager, WorkerManager> = internal.WorkerManager
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makeManager: Effect.Effect<WorkerManager, never, PlatformWorker> = internal.makeManager
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerManager: Layer.Layer<WorkerManager, never, PlatformWorker> = internal.layerManager
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makePool: <I, O, E>(
-  options: WorkerPool.Options<I>,
-) => Effect.Effect<WorkerPool<I, O, E>, WorkerError, WorkerManager | Spawner | Scope.Scope> = internal.makePool
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makePoolLayer: <Tag, I, O, E>(
-  tag: Context.Tag<Tag, WorkerPool<I, O, E>>,
-  options: WorkerPool.Options<I>,
-) => Layer.Layer<Tag, WorkerError, WorkerManager | Spawner> = internal.makePoolLayer
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface SerializedWorker<I extends Schema.TaggedRequest.All> {
-  readonly id: number
-  readonly execute: <Req extends I>(
-    message: Req,
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
-    ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
-    : never
-  readonly executeEffect: <Req extends I>(
-    message: Req,
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
-    ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
-    : never
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export declare namespace SerializedWorker {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Options<I> =
-    Extract<I, { readonly _tag: 'InitialMessage' }> extends never
-      ? BaseOptions<I> & {
-          readonly initialMessage?: LazyArg<I>
-        }
-      : BaseOptions<I> & {
-          readonly initialMessage: LazyArg<Extract<I, { readonly _tag: 'InitialMessage' }>>
-        }
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface BaseOptions<I> {
-    readonly queue?: WorkerQueue<I> | undefined
-  }
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface SerializedWorkerPool<I extends Schema.TaggedRequest.All> {
-  readonly backing: Pool.Pool<SerializedWorker<I>, WorkerError>
-  readonly broadcast: <Req extends I>(
-    message: Req,
-  ) => Req extends Serializable.WithResult<infer _A, infer _I, infer E, infer _EI, infer R>
-    ? Effect.Effect<void, E | WorkerError | ParseResult.ParseError, R>
-    : never
-  readonly execute: <Req extends I>(
-    message: Req,
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
-    ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
-    : never
-  readonly executeEffect: <Req extends I>(
-    message: Req,
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
-    ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
-    : never
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export declare namespace SerializedWorkerPool {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Options<I> = SerializedWorker.Options<I> &
-    (
-      | {
-          readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-          readonly size: number
-          readonly concurrency?: number | undefined
-          readonly targetUtilization?: number | undefined
-        }
-      | {
-          readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-          readonly minSize: number
-          readonly maxSize: number
-          readonly concurrency?: number | undefined
-          readonly targetUtilization?: number | undefined
-          readonly timeToLive: Duration.DurationInput
-        }
-    )
-}
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makeSerialized: <I extends Schema.TaggedRequest.All>(
-  options: SerializedWorker.Options<I>,
-) => Effect.Effect<SerializedWorker<I>, WorkerError, WorkerManager | Spawner | Scope.Scope> = internal.makeSerialized
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makePoolSerialized: <I extends Schema.TaggedRequest.All>(
-  options: SerializedWorkerPool.Options<I>,
-) => Effect.Effect<SerializedWorkerPool<I>, WorkerError, WorkerManager | Spawner | Scope.Scope> =
-  internal.makePoolSerialized
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const makePoolSerializedLayer: <Tag, I extends Schema.TaggedRequest.All>(
-  tag: Context.Tag<Tag, SerializedWorkerPool<I>>,
-  options: SerializedWorkerPool.Options<I>,
-) => Layer.Layer<Tag, WorkerError, WorkerManager | Spawner> = internal.makePoolSerializedLayer
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerSpawner: <W = unknown>(spawner: SpawnerFn<W>) => Layer.Layer<Spawner, never, never> =
-  internal.layerSpawner