@livestore/utils 0.4.0-dev.2 → 0.4.0-dev.21

package/src/effect/WebChannel/WebChannel.ts

@@ -38,127 +38,6 @@ export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgL
     }).pipe(Effect.withSpan(`WebChannel:noopChannel`)),
   )
 
-/** Only works in browser environments */
-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.scopeWithCloseable((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)),
-        listenToDebugPing(channelName),
-      )
-
-      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
-      const supportsTransferables = false
-
-      return {
-        [WebChannelSymbol]: WebChannelSymbol,
-        send,
-        listen,
-        closedDeferred,
-        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
-        schema,
-        supportsTransferables,
-      }
-    }).pipe(Effect.withSpan(`WebChannel:broadcastChannel(${channelName})`)),
-  )
-
-/**
- * NOTE the `listenName` and `sendName` is needed for cases where both sides are using the same window
- * e.g. for a browser extension, so we need a way to know for which side a message is intended for.
- */
-export const windowChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
-  listenWindow,
-  sendWindow,
-  targetOrigin = '*',
-  ids,
-  schema: inputSchema,
-}: {
-  listenWindow: Window
-  sendWindow: Window
-  targetOrigin?: string
-  ids: { own: string; other: string }
-  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
-  Effect.scopeWithCloseable((scope) =>
-    Effect.gen(function* () {
-      const schema = mapSchema(inputSchema)
-
-      const debugInfo = {
-        sendTotal: 0,
-        listenTotal: 0,
-        targetOrigin,
-        ids,
-      }
-
-      const WindowMessageListen = Schema.Struct({
-        message: schema.listen,
-        from: Schema.Literal(ids.other),
-        to: Schema.Literal(ids.own),
-      }).annotations({ title: 'webmesh.WindowMessageListen' })
-
-      const WindowMessageSend = Schema.Struct({
-        message: schema.send,
-        from: Schema.Literal(ids.own),
-        to: Schema.Literal(ids.other),
-      }).annotations({ title: 'webmesh.WindowMessageSend' })
-
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          debugInfo.sendTotal++
-
-          const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(WindowMessageSend)({
-            message,
-            from: ids.own,
-            to: ids.other,
-          })
-          sendWindow.postMessage(messageEncoded, targetOrigin, transferables)
-        })
-
-      const listen = Stream.fromEventListener<MessageEvent>(listenWindow, 'message').pipe(
-        // Stream.tap((_) => Effect.log(`${ids.other}→${ids.own}:message`, _.data)),
-        Stream.filter((_) => Schema.is(Schema.encodedSchema(WindowMessageListen))(_.data)),
-        Stream.map((_) => {
-          debugInfo.listenTotal++
-          return Schema.decodeEither(schema.listen)(_.data.message)
-        }),
-        listenToDebugPing('window'),
-      )
-
-      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
-      const supportsTransferables = true
-
-      return {
-        [WebChannelSymbol]: WebChannelSymbol,
-        send,
-        listen,
-        closedDeferred,
-        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
-        schema,
-        supportsTransferables,
-        debugInfo,
-      }
-    }).pipe(Effect.withSpan(`WebChannel:windowChannel`)),
-  )
-
 export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
   port: MessagePort
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
@@ -225,10 +104,7 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 
       const schema = mapSchema(inputSchema)
 
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          yield* PubSub.publish(pubSub, message)
-        })
+      const send = (message: MsgSend) => PubSub.publish(pubSub, message)
 
       const listen = Stream.fromPubSub(pubSub).pipe(Stream.map(Either.right), listenToDebugPing(channelName))
 
@@ -408,8 +284,8 @@ export const queueChannelProxy = <MsgListen, MsgSend>({
 /**
  * Eagerly starts listening to a channel by buffering incoming messages in a queue.
  */
-export const toOpenChannel = (
-  channel: WebChannel<any, any>,
+export const toOpenChannel = <MsgListen, MsgSend>(
+  channel: WebChannel<MsgListen, MsgSend>,
   options?: {
     /**
      * Sends a heartbeat message to the other end of the channel every `interval`.
@@ -420,9 +296,14 @@ export const toOpenChannel = (
       timeout: DurationInput
     }
   },
-): Effect.Effect<WebChannel<any, any>, never, Scope.Scope> =>
+): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const queue = yield* Queue.unbounded<Either.Either<any, any>>().pipe(Effect.acquireRelease(Queue.shutdown))
+    const queue = yield* Queue.unbounded<Either.Either<MsgListen, any>>().pipe(Effect.acquireRelease(Queue.shutdown))
+
+    const heartbeatChannel = channel as WebChannel<
+      MsgListen | typeof WebChannelHeartbeat.Type,
+      MsgSend | typeof WebChannelHeartbeat.Type
+    >
 
     const pendingPingDeferredRef = {
       current: undefined as { deferred: Deferred.Deferred<void>; requestId: string } | undefined,
@@ -435,7 +316,7 @@ export const toOpenChannel = (
             Effect.fn(function* (msg) {
               if (msg._tag === 'Right' && Schema.is(WebChannelHeartbeat)(msg.right)) {
                 if (msg.right._tag === 'WebChannel.Ping') {
-                  yield* channel.send(WebChannelPong.make({ requestId: msg.right.requestId }))
+                  yield* heartbeatChannel.send(WebChannelPong.make({ requestId: msg.right.requestId }))
                 } else {
                   const { deferred, requestId } = pendingPingDeferredRef.current ?? shouldNeverHappen('No pending ping')
                   if (requestId !== msg.right.requestId) {
@@ -461,7 +342,7 @@ export const toOpenChannel = (
         while (true) {
           yield* Effect.sleep(interval)
           const requestId = crypto.randomUUID()
-          yield* channel.send(WebChannelPing.make({ requestId }))
+          yield* heartbeatChannel.send(WebChannelPing.make({ requestId }))
           const deferred = yield* Deferred.make<void>()
           pendingPingDeferredRef.current = { deferred, requestId }
           yield* deferred.pipe(
@@ -492,7 +373,4 @@ export const toOpenChannel = (
     }
   })
 
-export const sendDebugPing = (channel: WebChannel<any, any>) =>
-  Effect.gen(function* () {
-    yield* channel.send(DebugPingMessage.make({ message: 'ping' }))
-  })
+export const sendDebugPing = (channel: WebChannel<any, any>) => channel.send(DebugPingMessage.make({ message: 'ping' }))

package/src/effect/WebChannel/common.ts

@@ -15,7 +15,7 @@ export interface WebChannel<MsgListen, MsgSend, E = never> {
   closedDeferred: Deferred.Deferred<void>
   shutdown: Effect.Effect<void>
   schema: { listen: Schema.Schema<MsgListen, any>; send: Schema.Schema<MsgSend, any> }
-  debugInfo?: Record<string, any>
+  debugInfo?: Record<string, any> | undefined
 }
 
 export const DebugPingMessage = Schema.TaggedStruct('WebChannel.DebugPing', {

package/src/effect/WebSocket.ts

@@ -81,16 +81,17 @@ export const makeWebSocket = ({
      */
     yield* Effect.addFinalizer(
       Effect.fn(function* (exit) {
-        try {
-          if (Exit.isFailure(exit)) {
-            socket.close(3000)
-          } else {
-            socket.close(1000)
-          }
-        } catch (error) {
-          yield* Effect.die(new WebSocketError({ cause: error }))
-        }
-      }),
+        yield* Effect.try({
+          try: () => {
+            if (Exit.isFailure(exit)) {
+              socket.close(3000)
+            } else {
+              socket.close(1000)
+            }
+          },
+          catch: (error) => new WebSocketError({ cause: error }),
+        })
+      }, Effect.orDie),
     )
 
     return socket

package/src/effect/{index.ts → mod.ts}

@@ -1,6 +1,22 @@
 import '../global.ts'
 
-export * as OtelTracer from '@effect/opentelemetry/Tracer'
+export {
+  AiError,
+  LanguageModel,
+  LanguageModel as AiLanguageModel,
+  McpSchema,
+  McpServer,
+  Model,
+  Model as AiModel,
+  Prompt,
+  Tool,
+  Tool as AiTool,
+  Toolkit,
+  Toolkit as AiToolkit,
+} from '@effect/ai'
+// export { DevTools as EffectDevtools } from '@effect/experimental'
+export { Sse } from '@effect/experimental'
+export * as Otlp from '@effect/opentelemetry/Otlp'
 export {
   Command,
   CommandExecutor,
@@ -8,6 +24,11 @@ export {
   FetchHttpClient,
   FileSystem,
   Headers,
+  HttpApi,
+  HttpApiClient,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApp,
   HttpClient,
   HttpClientError,
   HttpClientRequest,
@@ -18,6 +39,7 @@ export {
   HttpServerRequest,
   HttpServerResponse,
   KeyValueStore,
+  MsgPack,
   Socket,
   Terminal,
   Transferable,
@@ -26,10 +48,10 @@ export {
   WorkerError,
   WorkerRunner,
 } from '@effect/platform'
-export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
 export {
   Rpc,
-  RpcClient,
+  // RpcClient, // TODO bring back "original" RpcClient from effect/rpc
+  RpcClientError,
   RpcGroup,
   RpcMessage,
   RpcMiddleware,
@@ -47,8 +69,9 @@ export {
   Cause,
   Channel,
   Chunk,
-  // Logger,
   Config,
+  ConfigError,
+  ConfigProvider,
   Console,
   Context,
   Data,
@@ -58,6 +81,7 @@ export {
   Equal,
   ExecutionStrategy,
   Exit,
+  FastCheck,
   Fiber,
   FiberHandle,
   FiberId,
@@ -84,6 +108,7 @@ export {
   MutableHashMap,
   MutableHashSet,
   Option,
+  Order,
   ParseResult,
   Predicate,
   Pretty,
@@ -92,12 +117,17 @@ export {
   // Subscribable,
   pipe,
   Queue,
+  RcMap,
+  RcRef,
   Record as ReadonlyRecord,
+  Redacted,
   Ref,
   Request,
   Runtime,
   RuntimeFlags,
   Scope,
+  ScopedRef,
+  Sink,
   SortedMap,
   STM,
   SynchronizedRef,
@@ -107,26 +137,26 @@ export {
   Tracer,
   Types,
 } from 'effect'
-export { dual } from 'effect/Function'
+export type { NonEmptyArray } from 'effect/Array'
+export { constVoid, dual } from 'effect/Function'
+export * as Graph from 'effect/Graph'
 export { TreeFormatter } from 'effect/ParseResult'
 export type { Serializable, SerializableWithResult } from 'effect/Schema'
-
 export * as SchemaAST from 'effect/SchemaAST'
 export * as BucketQueue from './BucketQueue.ts'
+export * as Debug from './Debug.ts'
+export * as Effect from './Effect.ts'
+export * from './Error.ts'
 export * as Logger from './Logger.ts'
+export * as OtelTracer from './OtelTracer.ts'
+export * as RpcClient from './RpcClient.ts'
+export * as Schedule from './Schedule.ts'
+export * as Scheduler from './Scheduler.ts'
 export * as Schema from './Schema/index.ts'
+export * as ServiceContext from './ServiceContext.ts'
 export * as Stream from './Stream.ts'
 export * as Subscribable from './Subscribable.ts'
 export * as SubscriptionRef from './SubscriptionRef.ts'
 export * as TaskTracing from './TaskTracing.ts'
 export * as WebChannel from './WebChannel/mod.ts'
 export * as WebSocket from './WebSocket.ts'
-
-// export { DevTools as EffectDevtools } from '@effect/experimental'
-
-export * as Effect from './Effect.ts'
-export * from './Error.ts'
-export * as Schedule from './Schedule.ts'
-export * as Scheduler from './Scheduler.ts'
-export * as ServiceContext from './ServiceContext.ts'
-export * as WebLock from './WebLock.ts'

package/src/global.ts

@@ -1,5 +1,10 @@
 declare global {
   export type TODO<_Reason extends string = 'unknown'> = any
+  export type UNUSED<_Reason extends string = 'unknown'> = any
+
+  interface ImportMeta {
+    main: boolean
+  }
 }
 
 export {}

package/src/guards.ts

@@ -1,8 +1,23 @@
+/** Type guard that narrows `T | undefined` to `T`. Useful for filtering arrays. */
 export const isNotUndefined = <T>(_: T | undefined): _ is T => _ !== undefined
 
+/** Type guard that narrows `T | null` to `T`. */
 export const isNotNull = <T>(_: T | null): _ is T => _ !== null
+
+/** Type guard that checks if a value is `undefined`. */
 export const isUndefined = <T>(_: T | undefined): _ is undefined => _ === undefined
 
+/** Type guard that checks if a value is `null` or `undefined`. */
 export const isNil = (val: any): val is null | undefined => val === null || val === undefined
 
+/**
+ * Type guard that narrows `T | undefined | null` to `T`.
+ * Commonly used to filter out nullish values from arrays.
+ *
+ * @example
+ * ```ts
+ * const values = [1, null, 2, undefined, 3]
+ * const nonNil = values.filter(isNotNil) // [1, 2, 3] (type: number[])
+ * ```
+ */
 export const isNotNil = <T>(val: T | undefined | null): val is T => val !== null && val !== undefined

package/src/misc.ts

@@ -10,7 +10,7 @@ export const isDevEnv = () => {
   }
 
   // @ts-expect-error Only exists in Expo / RN
-  if (typeof globalThis !== 'undefined' && globalThis.__DEV__) {
+  if (globalThis?.__DEV__) {
     return true
   }