@livestore/utils 0.3.0-dev.5 → 0.3.0-dev.51

package/src/effect/WebChannel.ts

@@ -1,305 +0,0 @@
-import type { Scope } from 'effect'
-import { Deferred, Effect, Either, Option, Predicate, Queue } from 'effect'
-
-import * as Schema from './Schema/index.js'
-import * as Stream from './Stream.js'
-import { type WebChannel, WebChannelSymbol } from './WebChannel/common.js'
-
-export * from './WebChannel/broadcastChannelWithAck.js'
-
-export * from './WebChannel/common.js'
-
-export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgListen, MsgSend>> =>
-  Effect.gen(function* () {
-    return {
-      [WebChannelSymbol]: WebChannelSymbol,
-      send: () => Effect.void,
-      listen: Stream.never,
-      closedDeferred: yield* Deferred.make<void>(),
-      schema: {
-        listen: Schema.Any,
-        send: Schema.Any,
-      } as any,
-      supportsTransferables: false,
-    }
-  })
-
-export const broadcastChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
-  channelName,
-  schema: inputSchema,
-}: {
-  channelName: string
-  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
-  Effect.gen(function* () {
-    const schema = mapSchema(inputSchema)
-
-    const channel = new BroadcastChannel(channelName)
-
-    yield* Effect.addFinalizer(() => Effect.try(() => channel.close()).pipe(Effect.ignoreLogged))
-
-    const send = (message: MsgSend) =>
-      Effect.gen(function* () {
-        const messageEncoded = yield* Schema.encode(schema.send)(message)
-        channel.postMessage(messageEncoded)
-      })
-
-    // TODO also listen to `messageerror` in parallel
-    const listen = Stream.fromEventListener<MessageEvent>(channel, 'message').pipe(
-      Stream.map((_) => Schema.decodeEither(schema.listen)(_.data)),
-    )
-
-    const closedDeferred = yield* Deferred.make<void>()
-    const supportsTransferables = false
-
-    return {
-      [WebChannelSymbol]: WebChannelSymbol,
-      send,
-      listen,
-      closedDeferred,
-      schema,
-      supportsTransferables,
-    }
-  }).pipe(Effect.withSpan(`WebChannel:broadcastChannel(${channelName})`))
-
-export const windowChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
-  window,
-  targetOrigin = '*',
-  schema: inputSchema,
-}: {
-  window: Window
-  targetOrigin?: string
-  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
-  Effect.gen(function* () {
-    const schema = mapSchema(inputSchema)
-
-    const send = (message: MsgSend) =>
-      Effect.gen(function* () {
-        const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(schema.send)(message)
-        window.postMessage(messageEncoded, targetOrigin, transferables)
-      })
-
-    const listen = Stream.fromEventListener<MessageEvent>(window, 'message').pipe(
-      Stream.map((_) => Schema.decodeEither(schema.listen)(_.data)),
-    )
-
-    const closedDeferred = yield* Deferred.make<void>()
-    const supportsTransferables = true
-
-    return {
-      [WebChannelSymbol]: WebChannelSymbol,
-      send,
-      listen,
-      closedDeferred,
-      schema,
-      supportsTransferables,
-    }
-  }).pipe(Effect.withSpan(`WebChannel:windowChannel`))
-
-export const messagePortChannel: {
-  <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
-    port: MessagePort
-    schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-  }): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope>
-} = ({ port, schema: inputSchema }) =>
-  Effect.gen(function* () {
-    const schema = mapSchema(inputSchema)
-
-    const send = (message: any) =>
-      Effect.gen(function* () {
-        const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(schema.send)(message)
-        port.postMessage(messageEncoded, transferables)
-      })
-
-    const listen = Stream.fromEventListener<MessageEvent>(port, 'message').pipe(
-      Stream.map((_) => Schema.decodeEither(schema.listen)(_.data)),
-    )
-
-    port.start()
-
-    const closedDeferred = yield* Deferred.make<void>()
-    const supportsTransferables = true
-
-    yield* Effect.addFinalizer(() => Effect.try(() => port.close()).pipe(Effect.ignoreLogged))
-
-    return {
-      [WebChannelSymbol]: WebChannelSymbol,
-      send,
-      listen,
-      closedDeferred,
-      schema,
-      supportsTransferables,
-    }
-  }).pipe(Effect.withSpan(`WebChannel:messagePortChannel`))
-
-export const messagePortChannelWithAck: {
-  <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
-    port: MessagePort
-    schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-  }): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope>
-} = ({ port, schema: inputSchema }) =>
-  Effect.gen(function* () {
-    const schema = mapSchema(inputSchema)
-
-    type RequestId = string
-    const requestAckMap = new Map<RequestId, Deferred.Deferred<void>>()
-
-    const ChannelRequest = Schema.TaggedStruct('ChannelRequest', {
-      id: Schema.String,
-      payload: Schema.Union(schema.listen, schema.send),
-    })
-    const ChannelRequestAck = Schema.TaggedStruct('ChannelRequestAck', {
-      reqId: Schema.String,
-    })
-    const ChannelMessage = Schema.Union(ChannelRequest, ChannelRequestAck)
-    type ChannelMessage = typeof ChannelMessage.Type
-
-    const send = (message: any) =>
-      Effect.gen(function* () {
-        const id = crypto.randomUUID()
-        const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(ChannelMessage)({
-          _tag: 'ChannelRequest',
-          id,
-          payload: message,
-        })
-
-        const ack = yield* Deferred.make<void>()
-        requestAckMap.set(id, ack)
-
-        port.postMessage(messageEncoded, transferables)
-
-        yield* ack
-
-        requestAckMap.delete(id)
-      })
-
-    const listen = Stream.fromEventListener<MessageEvent>(port, 'message').pipe(
-      Stream.map((_) => Schema.decodeEither(ChannelMessage)(_.data)),
-      Stream.tap((msg) =>
-        Effect.gen(function* () {
-          if (msg._tag === 'Right') {
-            if (msg.right._tag === 'ChannelRequestAck') {
-              yield* Deferred.succeed(requestAckMap.get(msg.right.reqId)!, void 0)
-            } else if (msg.right._tag === 'ChannelRequest') {
-              port.postMessage(Schema.encodeSync(ChannelMessage)({ _tag: 'ChannelRequestAck', reqId: msg.right.id }))
-            }
-          }
-        }),
-      ),
-      Stream.filterMap((msg) =>
-        msg._tag === 'Left'
-          ? Option.some(msg as any)
-          : msg.right._tag === 'ChannelRequest'
-            ? Option.some(Either.right(msg.right.payload))
-            : Option.none(),
-      ),
-    )
-
-    port.start()
-
-    const closedDeferred = yield* Deferred.make<void>()
-    const supportsTransferables = true
-
-    yield* Effect.addFinalizer(() => Effect.try(() => port.close()).pipe(Effect.ignoreLogged))
-
-    return {
-      [WebChannelSymbol]: WebChannelSymbol,
-      send,
-      listen,
-      closedDeferred,
-      schema,
-      supportsTransferables,
-    }
-  }).pipe(Effect.withSpan(`WebChannel:messagePortChannelWithAck`))
-
-export type InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =
-  | Schema.Schema<MsgListen | MsgSend, MsgListenEncoded | MsgSendEncoded>
-  | {
-      listen: Schema.Schema<MsgListen, MsgListenEncoded>
-      send: Schema.Schema<MsgSend, MsgSendEncoded>
-    }
-
-export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
-  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>,
-): {
-  listen: Schema.Schema<MsgListen, MsgListenEncoded>
-  send: Schema.Schema<MsgSend, MsgSendEncoded>
-} =>
-  Predicate.hasProperty(schema, 'send') && Predicate.hasProperty(schema, 'listen')
-    ? { send: schema.send, listen: schema.listen }
-    : ({ send: schema, listen: schema } as any)
-
-export type QueueChannelProxy<MsgListen, MsgSend> = {
-  /** Only meant to be used externally */
-  webChannel: WebChannel<MsgListen, MsgSend>
-  /**
-   * Meant to be listened to (e.g. via `Stream.fromQueue`) for messages that have been sent
-   * via `webChannel.send()`.
-   */
-  sendQueue: Queue.Dequeue<MsgSend>
-  /**
-   * Meant to be pushed to (e.g. via `Queue.offer`) for messages that will be received
-   * via `webChannel.listen()`.
-   */
-  listenQueue: Queue.Enqueue<MsgListen>
-}
-
-/**
- * From the outside the `sendQueue` is only accessible read-only,
- * and the `listenQueue` is only accessible write-only.
- */
-export const queueChannelProxy = <MsgListen, MsgSend>({
-  schema: inputSchema,
-}: {
-  schema:
-    | Schema.Schema<MsgListen | MsgSend, any>
-    | { listen: Schema.Schema<MsgListen, any>; send: Schema.Schema<MsgSend, any> }
-}): Effect.Effect<QueueChannelProxy<MsgListen, MsgSend>, never, Scope.Scope> =>
-  Effect.gen(function* () {
-    const sendQueue = yield* Queue.unbounded<MsgSend>().pipe(Effect.acquireRelease(Queue.shutdown))
-    const listenQueue = yield* Queue.unbounded<MsgListen>().pipe(Effect.acquireRelease(Queue.shutdown))
-
-    const send = (message: MsgSend) => Queue.offer(sendQueue, message)
-
-    const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right))
-
-    const closedDeferred = yield* Deferred.make<void>()
-    const supportsTransferables = true
-
-    const schema = mapSchema(inputSchema)
-
-    const webChannel = {
-      [WebChannelSymbol]: WebChannelSymbol,
-      send,
-      listen,
-      closedDeferred,
-      schema,
-      supportsTransferables,
-    }
-
-    return { webChannel, sendQueue, listenQueue }
-  })
-
-// export const proxy = <MsgListen, MsgSend>({
-//   originWebChannel,
-//   proxyWebChannel,
-// }: {
-//   originWebChannel: WebChannel<MsgListen, MsgSend>
-//   proxyWebChannel: QueueChannelProxy<MsgListen, MsgSend>
-// }) =>
-//   Effect.gen(function* () {
-//     const proxyListen = originWebChannel.listen.pipe(
-//       Stream.flatten(),
-//       Stream.tap((_) => Queue.offer(proxyWebChannel.listenQueue, _)),
-//       Stream.runDrain,
-//     )
-
-//     const proxySend = proxyWebChannel.sendQueue.pipe(
-//       Stream.fromQueue,
-//       Stream.tap(originWebChannel.send),
-//       Stream.runDrain,
-//     )
-
-//     yield* Effect.all([proxyListen, proxySend], { concurrency: 2 })
-//   })

package/src/nanoid/index.browser.ts

@@ -1,2 +0,0 @@
-// @ts-expect-error TODO
-export { nanoid } from 'nanoid/index.browser.js'

package/tmp/effect-deferred-repro.ts

@@ -1,29 +0,0 @@
-/// <reference lib="es2024" />
-
-import { Effect, Logger } from 'effect'
-
-const main = Effect.gen(function* () {
-  yield* Effect.addFinalizer((_) => Effect.log('finalizer', _))
-
-  // const finished = yield* Deferred.make<void>()
-
-  const def = Promise.withResolvers()
-
-  setTimeout(() => {
-    def.resolve(undefined)
-  }, 1000)
-
-  console.log('awaiting')
-
-  // const fiber = yield* Deferred.await(finished).pipe(Effect.fork)
-  // yield* Fiber.join(fiber)
-  // yield* finished
-  yield* Effect.promise(() => def.promise)
-  console.log('finished')
-})
-
-main
-  .pipe(Effect.scoped, Effect.provide(Logger.pretty), Effect.tapErrorCause(Effect.logError), Effect.runPromise)
-  .finally(() => {
-    console.log('finally')
-  })

package/tmp/effect-semaphore-repro.ts

@@ -1,93 +0,0 @@
-/// <reference lib="es2024" />
-import * as NodePlatform from '@effect/platform-node'
-import { Deferred, Effect, FiberSet, Logger, Ref, Scheduler } from 'effect'
-
-const main = Effect.gen(function* () {
-  const semaphore = yield* Effect.makeSemaphore(1)
-
-  const fiberset = yield* FiberSet.make()
-
-  // setInterval(() => {
-  //   // semaphore.release(1)
-  // }, 1_000_000)
-
-  const stateRef = yield* Ref.make<'open' | 'closed'>('open')
-
-  // let counter = 0
-  // const nextExpectedCounter = 0
-  // const def = Promise.withResolvers()
-
-  const finished = yield* Deferred.make<void>()
-
-  const MAX = 100
-
-  const doWorkWithSemaphore = (counter: number) =>
-    Effect.gen(function* () {
-      // yield* Effect.log(`doWorkWithSemaphore: ${counter} - waiting for semaphore`)
-      // yield* semaphore.take(1)
-      // if (counter !== nextExpectedCounter) {
-      //   throw new Error(`Expected counter ${nextExpectedCounter} but got ${counter}`)
-      // }
-      // nextExpectedCounter = counter + 1
-      yield* Effect.log(`doWorkWithSemaphore: ${counter} - got semaphore`)
-      // setTimeout(() => {}, 120)
-      yield* Effect.sleep(40)
-      // yield* Effect.yieldNow()
-      yield* Effect.log(`doWorkWithSemaphore: ${counter} - releasing semaphore`)
-      yield* Ref.set(stateRef, 'open')
-      yield* semaphore.release(1)
-
-      if (counter === MAX - 1) {
-        yield* Deferred.succeed(finished, undefined)
-        // def.resolve(undefined)
-      }
-    }).pipe(Effect.scoped)
-
-  for (let i = 0; i < MAX; i++) {
-    yield* doWorkWithSemaphore(i).pipe(FiberSet.run(fiberset))
-    // yield* Effect.sleep(20)
-    yield* Effect.gen(function* () {
-      const state = yield* Ref.get(stateRef)
-      if (state === 'open') {
-        yield* Effect.logWarning(`loop: ${i} - semaphore is open, taking`)
-      } else {
-        yield* Effect.log(`loop: ${i} - semaphore is closed, waiting`)
-      }
-
-      yield* semaphore.take(1)
-      yield* Ref.set(stateRef, 'closed')
-
-      yield* doWorkWithSemaphore(i).pipe(Effect.fork)
-
-      const sleepTime = Math.random() * 40
-      yield* Effect.log(`loop: ${i} - sleeping for ${sleepTime}ms`)
-      yield* Effect.sleep(sleepTime)
-
-      // yield* Effect.yieldNow()
-    }).pipe(FiberSet.run(fiberset))
-  }
-
-  // yield* Effect.never
-
-  yield* finished
-  // yield* Effect.promise(() => def.promise)
-  // console.log('finished')
-})
-
-export const messageChannel = (shouldYield: Scheduler.Scheduler['shouldYield'] = Scheduler.defaultShouldYield) =>
-  Scheduler.makeBatched((task) => {
-    const messageChannel = new MessageChannel()
-
-    messageChannel.port1.postMessage(undefined)
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    messageChannel.port2.onmessage = task
-  }, shouldYield)
-
-main.pipe(
-  Effect.scoped,
-  Effect.provide(Logger.pretty),
-  Effect.tapErrorCause(Effect.logError),
-  Effect.withScheduler(messageChannel()),
-  NodePlatform.NodeRuntime.runMain,
-)

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "tsBuildInfoFile": "./dist/.tsbuildinfo.json"
-  },
-  "include": ["./src"],
-  "references": [{ "path": "../db-schema"}]
-}