@livestore/utils 0.0.54-dev.26 → 0.0.54-dev.28

package/src/effect/Schema/debug-diff.test.ts

@@ -0,0 +1,102 @@
+import { Schema } from '@effect/schema'
+import { describe, expect, test } from 'vitest'
+
+import type { DiffItem } from './debug-diff.js'
+import { debugDiff } from './debug-diff.js'
+
+describe('debug-diff', () => {
+  test('simple object', () => {
+    const schema = Schema.Struct({
+      a: Schema.String,
+      b: Schema.Number,
+    })
+
+    const a = { a: 'hello', b: 1 }
+    const b = { a: 'world', b: 2 }
+
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": "hello",
+          "b": "world",
+          "path": ".a",
+        },
+        {
+          "a": 1,
+          "b": 2,
+          "path": ".b",
+        },
+      ]
+    `)
+  })
+
+  test('simple object with nested object', () => {
+    const schema = Schema.Struct({
+      a: Schema.String,
+      b: Schema.Struct({
+        c: Schema.Number,
+      }),
+    })
+    const a = { a: 'hello', b: { c: 1 } }
+    const b = { a: 'world', b: { c: 2 } }
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": "hello",
+          "b": "world",
+          "path": ".a",
+        },
+        {
+          "a": 1,
+          "b": 2,
+          "path": ".b.c",
+        },
+      ]
+    `)
+  })
+
+  test('union', () => {
+    const schema = Schema.Union(Schema.String, Schema.Number)
+    const a = 'hello'
+    const b = 1
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": "hello",
+          "b": 1,
+          "path": "",
+        },
+      ]
+    `)
+  })
+
+  test('tagged union', () => {
+    const schema = Schema.Union(
+      Schema.Struct({ _tag: Schema.Literal('a'), a: Schema.String }),
+      Schema.Struct({ _tag: Schema.Literal('b'), b: Schema.Number }),
+    )
+    const a = { _tag: 'a', a: 'hello' } as const
+    const b = { _tag: 'b', b: 1 } as const
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": {
+            "_tag": "a",
+            "a": "hello",
+          },
+          "b": {
+            "_tag": "b",
+            "b": 1,
+          },
+          "path": "",
+        },
+      ]
+    `)
+  })
+})
+
+const trimAst = (diffItems: DiffItem[]) => diffItems.map(({ ast: _ast, ...rest }) => rest)

package/src/effect/Schema/debug-diff.ts

@@ -0,0 +1,59 @@
+import type { Schema } from '@effect/schema'
+import { AST, Equivalence } from '@effect/schema'
+
+export type DiffItem = {
+  path: string
+  a: any
+  b: any
+  ast: AST.AST
+}
+
+/**
+ * Diffs two values for a given schema and traverses downwards and returns a list of differences.
+ */
+export const debugDiff =
+  <A, I, R>(base: Schema.Schema<A, I, R>) =>
+  (a: A, b: A): DiffItem[] => {
+    const bag = [] as DiffItem[]
+    debugDiffImpl(base.ast, a, b, '', bag)
+    return bag
+  }
+
+const debugDiffImpl = (ast: AST.AST, a: any, b: any, path: string, bag: DiffItem[]) => {
+  const eq = Equivalence.make({ ast } as any)
+  if (eq(a, b) === false) {
+    // bag.push({ path, a, b, ast })
+
+    if (AST.isUnion(ast)) {
+      if (isTaggedUnion(ast)) {
+        bag.push({ path, a, b, ast })
+        return
+      } else {
+        for (const type of ast.types) {
+          try {
+            debugDiffImpl(type, a, b, path, bag)
+            return
+          } catch {}
+        }
+      }
+    } else if (AST.isTypeLiteral(ast)) {
+      const props = AST.getPropertySignatures(ast)
+      for (const prop of props) {
+        debugDiffImpl(prop.type, a[prop.name], b[prop.name], `${path}.${prop.name.toString()}`, bag)
+      }
+    } else {
+      // debugger
+      bag.push({ path, a, b, ast })
+    }
+  }
+}
+
+const isTaggedUnion = (ast: AST.AST) => {
+  if (AST.isUnion(ast)) {
+    return ast.types.every((type) => {
+      if (AST.isTypeLiteral(type) === false) return false
+      const props = AST.getPropertySignatures(type)
+      return props.some((prop) => prop.name.toString() === '_tag')
+    })
+  }
+}

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

@@ -4,9 +4,10 @@ import type { ParseOptions } from '@effect/schema/AST'
 import type { ParseError } from '@effect/schema/ParseResult'
 import { Effect, Hash } from 'effect'
 
-import { objectToString } from '../misc.js'
+import { objectToString } from '../../misc.js'
 
 export * from '@effect/schema/Schema'
+export * from './debug-diff.js'
 
 // NOTE this is a temporary workaround until Effect schema has a better way to hash schemas
 // https://github.com/Effect-TS/effect/issues/2719

package/src/effect/WebLock.ts

@@ -13,37 +13,35 @@ export const withLock =
     options?: Omit<LockOptions, 'signal'>
   }) =>
   <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A | void, E | E2, Ctx> =>
-    Effect.gen(function* ($) {
-      const runtime = yield* $(Effect.runtime<Ctx>())
+    Effect.gen(function* () {
+      const runtime = yield* Effect.runtime<Ctx>()
 
-      const exit = yield* $(
-        Effect.tryPromise<Exit.Exit<A, E>, E | E2>({
-          try: (signal) => {
-            if (signal.aborted) return 'aborted' as never
+      const exit = yield* Effect.tryPromise<Exit.Exit<A, E>, E | E2>({
+        try: (signal) => {
+          if (signal.aborted) return 'aborted' as never
 
-            // NOTE The 'signal' and 'ifAvailable' options cannot be used together.
-            const requestOptions = options?.ifAvailable === true ? options : { ...options, signal }
-            return navigator.locks.request(lockName, requestOptions, async (lock) => {
-              if (lock === null) {
-                if (onTaken) {
-                  const exit = await Runtime.runPromiseExit(runtime)(onTaken)
-                  if (exit._tag === 'Failure') {
-                    return exit
-                  }
+          // NOTE The 'signal' and 'ifAvailable' options cannot be used together.
+          const requestOptions = options?.ifAvailable === true ? options : { ...options, signal }
+          return navigator.locks.request(lockName, requestOptions, async (lock) => {
+            if (lock === null) {
+              if (onTaken) {
+                const exit = await Runtime.runPromiseExit(runtime)(onTaken)
+                if (exit._tag === 'Failure') {
+                  return exit
                 }
-                return
               }
+              return
+            }
 
-              // TODO also propagate Effect interruption to the execution
-              return Runtime.runPromiseExit(runtime)(eff)
-            })
-          },
-          catch: (err) => err as any as E,
-        }),
-      )
+            // TODO also propagate Effect interruption to the execution
+            return Runtime.runPromiseExit(runtime)(eff)
+          })
+        },
+        catch: (err) => err as any as E,
+      })
 
       if (exit._tag === 'Failure') {
-        return yield* $(Effect.failCause(exit.cause))
+        return yield* Effect.failCause(exit.cause)
       } else {
         return exit.value
       }
@@ -73,13 +71,25 @@ export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName:
   })
 
 export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<boolean>((cb) => {
+  Effect.async<boolean>((cb, signal) => {
     navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, (lock) => {
       cb(Effect.succeed(lock !== null))
 
       // the code below is still running
 
+      const abortPromise = new Promise<void>((resolve) => {
+        signal.addEventListener('abort', () => {
+          resolve()
+        })
+      })
+
       // holding lock until deferred is resolved
-      return Effect.runPromise(Deferred.await(deferred))
+      return Promise.race([
+        Effect.runPromise(Deferred.await(deferred)),
+        // .finally(() =>
+        //   console.log('[@livestore/utils:WebLock] tryGetDeferredLock. finally', lockName),
+        // ),
+        abortPromise,
+      ])
     })
   })

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

@@ -0,0 +1,26 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Layer from 'effect/Layer'
+
+import type * as Worker from '../worker-tmp/Worker.js'
+import * as internal from './internal/worker.js'
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerManager: Layer.Layer<Worker.WorkerManager> = internal.layerManager
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWorker: Layer.Layer<Worker.PlatformWorker> = internal.layerWorker
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: (
+  spawn: (id: number) => Worker | SharedWorker | MessagePort,
+) => Layer.Layer<Worker.WorkerManager | Worker.Spawner, never, never> = internal.layer

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

@@ -0,0 +1,14 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Layer from 'effect/Layer'
+
+import type * as Runner from '../worker-tmp/WorkerRunner.js'
+import * as internal from './internal/workerRunner.js'
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: Layer.Layer<Runner.PlatformRunner> = internal.layer
+export { layerMessagePort } from './port-platform-runner.js'

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

@@ -0,0 +1,71 @@
+/* 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

@@ -0,0 +1,119 @@
+/// <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/{port-platform-runner.ts → browser-worker-tmp/port-platform-runner.ts}

@@ -1,5 +1,3 @@
-import { WorkerError } from '@effect/platform/WorkerError'
-import * as Runner from '@effect/platform/WorkerRunner'
 import { Deferred } from 'effect'
 import * as Cause from 'effect/Cause'
 import * as Effect from 'effect/Effect'
@@ -7,6 +5,9 @@ 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,
@@ -70,4 +71,4 @@ const platformRunnerImpl = (port: MessagePort) =>
   })
 
 /** @internal */
-export const layer = (port: MessagePort) => Layer.succeed(Runner.PlatformRunner, platformRunnerImpl(port))
+export const layerMessagePort = (port: MessagePort) => Layer.succeed(Runner.PlatformRunner, platformRunnerImpl(port))

package/src/effect/index.ts

@@ -12,7 +12,6 @@ export {
   Exit,
   Cause,
   Runtime,
-  Scheduler,
   FiberRef,
   FiberRefs,
   FiberRefsPatch,
@@ -62,15 +61,21 @@ export {
   JSONSchema,
   ParseResult,
 } from '@effect/schema'
-export * as Schema from './Schema.js'
+export * as Schema from './Schema/index.js'
 export * as OtelTracer from '@effect/opentelemetry/Tracer'
 
-export { Transferable, FileSystem, Worker, WorkerError, WorkerRunner, Terminal, HttpServer } from '@effect/platform'
-export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
-export * as PortPlatformRunner from './port-platform-runner.js'
+// export { Transferable, FileSystem, Worker, WorkerError, WorkerRunner, Terminal, HttpServer } from '@effect/platform'
+// export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+export { Transferable, FileSystem, Terminal, HttpServer } from '@effect/platform'
+export * as Worker from './worker-tmp/Worker.js'
+export * as WorkerError from './worker-tmp/WorkerError.js'
+export * as WorkerRunner from './worker-tmp/WorkerRunner.js'
+export * as BrowserWorker from './browser-worker-tmp/BrowserWorker.js'
+export * as BrowserWorkerRunner from './browser-worker-tmp/BrowserWorkerRunner.js'
 
 export * as Effect from './Effect.js'
 export * as Schedule from './Schedule.js'
+export * as Scheduler from './Scheduler.js'
 export * from './Error.js'
 export * as ServiceContext from './ServiceContext.js'
 export * as WebLock from './WebLock.js'