@livestore/utils 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/effect/ServiceContext.ts

@@ -0,0 +1,108 @@
+import type { Runtime } from 'effect'
+import { Cause, Effect, Exit, Fiber, Layer, pipe, Scope } from 'effect'
+
+export interface MainLayer<Ctx> {
+  layer: Layer.Layer<Ctx>
+  close: Effect.Effect<void>
+}
+
+export const unsafeMainLayer = <Ctx>(original: Layer.Layer<Ctx>): MainLayer<Ctx> => {
+  const scope = Effect.runSync(Scope.make())
+  const layer = pipe(
+    original,
+    Layer.memoize,
+    Effect.parallelFinalizers, // NOTE this runs the layer teardown in parallel
+    Effect.provideService(Scope.Scope, scope),
+    Effect.runSync,
+  )
+  return { layer, close: Scope.close(scope, Exit.void) }
+}
+
+export const make = <TStaticData, Ctx>(
+  staticData: TStaticData,
+  runtime: Runtime.Runtime<Ctx>,
+  close: Effect.Effect<void> = Effect.dieMessage('close not implemented'),
+): ServiceContext<Ctx, TStaticData> => {
+  return {
+    provide: (self) => Effect.provide(runtime)(self),
+    runWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) => runWithErrorLog(Effect.provide(runtime)(self)),
+    runSync: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runSync(Effect.provide(runtime)(self)),
+    runPromiseWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) =>
+      runPromiseWithErrorLog(Effect.provide(runtime)(self)),
+    runPromiseExit: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runPromiseExit(Effect.provide(runtime)(self)),
+    runPromise: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runPromise(Effect.provide(runtime)(self)),
+    withRuntime: (fn) => fn(runtime),
+    close: close,
+    closePromise: () => Effect.runPromise(close),
+    staticData,
+  }
+}
+
+export interface ServiceContext<Ctx, TStaticData> {
+  readonly provide: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.Effect<A, E>
+
+  /**
+   * Fire and Forget. Errors are logged however.
+   */
+  readonly runWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) => AbortCallback
+
+  readonly runSync: <E, A>(self: Effect.Effect<A, E, Ctx>) => A
+
+  /**
+   * Fire and Forget. A promise that never fails nor returns any value.
+   * Errors are logged however.
+   */
+  readonly runPromiseWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) => Promise<A | undefined>
+
+  /**
+   * A Promise that never fails, the Resolved value is an Exit result that can be either Success or Failed
+   */
+  readonly runPromiseExit: <E, A>(self: Effect.Effect<A, E, Ctx>) => Promise<Exit.Exit<A, E>>
+  readonly runPromise: <E, A>(self: Effect.Effect<A, E, Ctx>) => Promise<A>
+
+  readonly withRuntime: (fn: (runtime: Runtime.Runtime<Ctx>) => void) => void
+
+  /** Closes the ServiceContext and closing all its layers */
+  readonly close: Effect.Effect<void>
+  readonly closePromise: () => Promise<void>
+  readonly staticData: TStaticData
+}
+
+export type AbortCallback = () => void
+
+export const runWithErrorLog = <E, A>(self: Effect.Effect<A, E>) => {
+  const fiber = Effect.runFork(self)
+  fiber.addObserver((ex) => {
+    if (ex._tag === 'Failure' && Cause.isInterruptedOnly(ex.cause) === false) {
+      console.error(Cause.pretty(ex.cause))
+    }
+  })
+  return () => {
+    Effect.runFork(Fiber.interrupt(fiber))
+  }
+}
+
+export const runPromiseWithErrorLog = <E, A>(self: Effect.Effect<A, E>) =>
+  Effect.runPromiseExit(self).then((ex) => {
+    if (ex._tag === 'Failure') {
+      console.error(Cause.pretty(ex.cause))
+      return undefined
+    } else {
+      return ex.value
+    }
+  })
+
+export const MissingContext = Effect.die('service context not provided, wrap your app in LiveServiceContext')
+
+export const empty = <Ctx, TStaticData>(): ServiceContext<Ctx, TStaticData> => ({
+  provide: () => MissingContext,
+  runWithErrorLog: () => runWithErrorLog(MissingContext),
+  runSync: () => Effect.runSync(MissingContext),
+  runPromiseWithErrorLog: () => runPromiseWithErrorLog(MissingContext),
+  runPromiseExit: () => Effect.runPromiseExit(MissingContext),
+  runPromise: () => Effect.runPromise(MissingContext),
+  withRuntime: () => Effect.runSync(MissingContext),
+  close: Effect.dieMessage('Empty ServiceContext cannot be closed'),
+  closePromise: () => Promise.reject('Empty ServiceContext cannot be closed'),
+  staticData: {} as TStaticData,
+})

package/src/effect/Stream.ts

@@ -0,0 +1,63 @@
+export * from 'effect/Stream'
+
+import type { Chunk } from 'effect'
+import { Effect, 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)
+
+export const tapSync =
+  <A>(tapFn: (a: A) => unknown) =>
+  <R, E>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+    Stream.tap(stream, (a) => Effect.sync(() => tapFn(a)))
+
+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)
+
+export const tapChunk =
+  <R1, E1, A, Z>(f: (a: Chunk.Chunk<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) =>
+      pipe(
+        f(chunks),
+        Effect.map(() => chunks),
+      ),
+    )
+
+const isIdentity = <A>(a1: A, a2: A): boolean => a1 === a2
+
+export const skipRepeated =
+  <A>(isEqual: (prevEl: A, newEl: A) => boolean = isIdentity) =>
+  <R, E>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+    skipRepeated_(stream, isEqual)
+
+export const skipRepeated_ = <R, E, A>(
+  stream: Stream.Stream<A, E, R>,
+  isEqual: (prevEl: A, newEl: A) => boolean = isIdentity,
+): Stream.Stream<A, E, R> =>
+  pipe(
+    Ref.make<Option.Option<A>>(Option.none()),
+    Stream.fromEffect,
+    Stream.flatMap((ref) =>
+      pipe(
+        stream,
+        Stream.filterEffect((el) =>
+          pipe(
+            Ref.get(ref),
+            Effect.flatMap((prevEl) => {
+              if (prevEl._tag === 'None' || isEqual(prevEl.value, el) === false) {
+                return pipe(
+                  Ref.set(ref, Option.some(el)),
+                  Effect.map(() => true),
+                )
+              } else {
+                return Effect.succeed(false)
+              }
+            }),
+          ),
+        ),
+      ),
+    ),
+  )

package/src/effect/SubscriptionRef.ts

@@ -0,0 +1,22 @@
+import type { SubscriptionRef } from 'effect'
+import { Chunk, Effect, pipe, Stream } from 'effect'
+import { dual } from 'effect/Function'
+import type { Predicate, Refinement } from 'effect/Predicate'
+
+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>
+  <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)),
+)

package/src/effect/WebChannel.ts

@@ -0,0 +1,116 @@
+import type { ParseResult, Scope } from 'effect'
+import { Deferred, Effect, Either, Queue, Stream } from 'effect'
+
+import * as Schema from './Schema/index.js'
+
+export type WebChannel<MsgIn, MsgOut, E = never> = {
+  send: (a: MsgOut) => Effect.Effect<void, ParseResult.ParseError | E>
+  listen: Stream.Stream<Either.Either<MsgIn, ParseResult.ParseError>, E>
+  closedDeferred: Deferred.Deferred<void>
+}
+
+export const broadcastChannel = <MsgIn, MsgOut, MsgInEncoded, MsgOutEncoded>({
+  channelName,
+  listenSchema,
+  sendSchema,
+}: {
+  channelName: string
+  listenSchema: Schema.Schema<MsgIn, MsgInEncoded>
+  sendSchema: Schema.Schema<MsgOut, MsgOutEncoded>
+}): Effect.Effect<WebChannel<MsgIn, MsgOut>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const channel = new BroadcastChannel(channelName)
+
+    yield* Effect.addFinalizer(() => Effect.try(() => channel.close()).pipe(Effect.ignoreLogged))
+
+    const send = (message: MsgOut) =>
+      Effect.gen(function* () {
+        const messageEncoded = yield* Schema.encode(sendSchema)(message)
+        channel.postMessage(messageEncoded)
+      })
+
+    // TODO also listen to `messageerror` in parallel
+    const listen = Stream.fromEventListener<MessageEvent>(channel, 'message').pipe(
+      Stream.map((_) => Schema.decodeEither(listenSchema)(_.data)),
+    )
+
+    const closedDeferred = yield* Deferred.make<void>()
+
+    return { send, listen, closedDeferred }
+  }).pipe(Effect.withSpan(`WebChannel:broadcastChannel(${channelName})`))
+
+export const windowChannel = <MsgIn, MsgOut, MsgInEncoded, MsgOutEncoded>({
+  window,
+  targetOrigin = '*',
+  listenSchema,
+  sendSchema,
+}: {
+  window: Window
+  targetOrigin?: string
+  listenSchema: Schema.Schema<MsgIn, MsgInEncoded>
+  sendSchema: Schema.Schema<MsgOut, MsgOutEncoded>
+}): Effect.Effect<WebChannel<MsgIn, MsgOut>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const send = (message: MsgOut) =>
+      Effect.gen(function* () {
+        const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(sendSchema)(message)
+        window.postMessage(messageEncoded, targetOrigin, transferables)
+      })
+
+    const listen = Stream.fromEventListener<MessageEvent>(window, 'message').pipe(
+      Stream.map((_) => Schema.decodeEither(listenSchema)(_.data)),
+    )
+
+    const closedDeferred = yield* Deferred.make<void>()
+
+    return { send, listen, closedDeferred }
+  }).pipe(Effect.withSpan(`WebChannel:windowChannel`))
+
+export const messagePortChannel = <MsgIn, MsgOut, MsgInEncoded, MsgOutEncoded>({
+  port,
+  listenSchema,
+  sendSchema,
+}: {
+  port: MessagePort
+  listenSchema: Schema.Schema<MsgIn, MsgInEncoded>
+  sendSchema: Schema.Schema<MsgOut, MsgOutEncoded>
+}): Effect.Effect<WebChannel<MsgIn, MsgOut>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const send = (message: MsgOut) =>
+      Effect.gen(function* () {
+        const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(sendSchema)(message)
+        port.postMessage(messageEncoded, transferables)
+      })
+
+    const listen = Stream.fromEventListener<MessageEvent>(port, 'message').pipe(
+      Stream.map((_) => Schema.decodeEither(listenSchema)(_.data)),
+    )
+
+    port.start()
+
+    const closedDeferred = yield* Deferred.make<void>()
+
+    yield* Effect.addFinalizer(() => Effect.try(() => port.close()).pipe(Effect.ignoreLogged))
+
+    return { send, listen, closedDeferred }
+  }).pipe(Effect.withSpan(`WebChannel:messagePortChannel`))
+
+export const queueChannelProxy = <MsgIn, MsgOut>(): Effect.Effect<
+  { webChannel: WebChannel<MsgIn, MsgOut>; sendQueue: Queue.Queue<MsgOut>; listenQueue: Queue.Queue<MsgIn> },
+  never,
+  Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const sendQueue = yield* Queue.unbounded<MsgOut>().pipe(Effect.acquireRelease(Queue.shutdown))
+    const listenQueue = yield* Queue.unbounded<MsgIn>().pipe(Effect.acquireRelease(Queue.shutdown))
+
+    const send = (message: MsgOut) => Queue.offer(sendQueue, message)
+
+    const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right))
+
+    const closedDeferred = yield* Deferred.make<void>()
+
+    const webChannel = { send, listen, closedDeferred }
+
+    return { webChannel, sendQueue, listenQueue }
+  })

package/src/effect/WebLock.ts

@@ -0,0 +1,95 @@
+import type { Exit } from 'effect'
+import { Deferred, Effect, Runtime } from 'effect'
+
+// See https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
+export const withLock =
+  <E2>({
+    lockName,
+    onTaken,
+    options,
+  }: {
+    lockName: string
+    onTaken?: Effect.Effect<void, E2>
+    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>()
+
+      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
+                }
+              }
+              return
+            }
+
+            // 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)
+      } else {
+        return exit.value
+      }
+    })
+
+export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
+  Effect.async<void>((cb, signal) => {
+    if (signal.aborted) return
+
+    navigator.locks
+      .request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, (_lock) => {
+        // immediately continuing calling Effect since we have the lock
+        cb(Effect.void)
+
+        // the code below is still running
+
+        // holding lock until deferred is resolved
+        return Effect.runPromise(Deferred.await(deferred))
+      })
+      .catch((error) => {
+        if (error.code === 20 && error.message === 'signal is aborted without reason') {
+          // Given signal interruption is handled via Effect, we can ignore this case
+        } else {
+          throw error
+        }
+      })
+  })
+
+export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
+  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 Promise.race([
+        Effect.runPromise(Deferred.await(deferred)),
+        // .finally(() =>
+        //   console.log('[@livestore/utils:WebLock] tryGetDeferredLock. finally', lockName),
+        // ),
+        abortPromise,
+      ])
+    })
+  })

package/src/effect/index.ts

@@ -0,0 +1,91 @@
+import '../global.js'
+
+export {
+  Scope,
+  Ref,
+  SynchronizedRef,
+  Queue,
+  Fiber,
+  FiberId,
+  FiberSet,
+  FiberMap,
+  FiberHandle,
+  Inspectable,
+  RuntimeFlags,
+  PubSub,
+  Exit,
+  Cause,
+  Runtime,
+  FiberRef,
+  FiberRefs,
+  FiberRefsPatch,
+  Deferred,
+  Metric,
+  MetricState,
+  Request,
+  Tracer,
+  Context,
+  Data,
+  Either,
+  Brand,
+  Hash,
+  Equal,
+  Chunk,
+  Duration,
+  Array as ReadonlyArray,
+  Record as ReadonlyRecord,
+  SortedMap,
+  HashMap,
+  HashSet,
+  MutableHashSet,
+  MutableHashMap,
+  Option,
+  LogLevel,
+  Logger,
+  Layer,
+  STM,
+  TRef,
+  Channel,
+  pipe,
+  identity,
+  GlobalValue,
+  Match,
+} from 'effect'
+
+export { dual } from 'effect/Function'
+
+export * as Stream from './Stream.js'
+
+export * as SubscriptionRef from './SubscriptionRef.js'
+
+export * as WebChannel from './WebChannel.js'
+
+export * as SchemaAST from 'effect/SchemaAST'
+export { TreeFormatter } from 'effect/ParseResult'
+export { ParseResult, Pretty } from 'effect'
+export type { Serializable, SerializableWithResult } from 'effect/Schema'
+export * as Schema from './Schema/index.js'
+export * as OtelTracer from '@effect/opentelemetry/Tracer'
+
+export {
+  Transferable,
+  FileSystem,
+  Worker,
+  WorkerError,
+  WorkerRunner,
+  Terminal,
+  HttpServer,
+  HttpClient,
+  HttpClientError,
+  HttpClientRequest,
+  HttpClientResponse,
+  FetchHttpClient,
+} from '@effect/platform'
+export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+
+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'

package/src/fast-deep-equal.ts

@@ -0,0 +1,72 @@
+/* eslint-disable no-var */
+
+// Copied from fast-deep-equal
+// MIT License
+
+export const deepEqual = <T>(a: T, b: T): boolean => {
+  if (a === b) return true
+
+  if (a && b && typeof a == 'object' && typeof b == 'object') {
+    if (a.constructor !== b.constructor) return false
+
+    var length, i, keys
+    if (Array.isArray(a)) {
+      length = a.length
+      // @ts-expect-error ...
+      if (length != b.length) return false
+      for (i = length; i-- !== 0; )
+        // @ts-expect-error ...
+        if (!deepEqual(a[i], b[i])) return false
+      return true
+    }
+
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) return false
+      for (i of a.entries()) if (!b.has(i[0])) return false
+      for (i of a.entries()) if (!deepEqual(i[1], b.get(i[0]))) return false
+      return true
+    }
+
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) return false
+      for (i of a.entries()) if (!b.has(i[0])) return false
+      return true
+    }
+
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      // @ts-expect-error ...
+      length = a.length
+      // @ts-expect-error ...
+      if (length != b.length) return false
+      for (i = length; i-- !== 0; )
+        // @ts-expect-error ...
+        if (a[i] !== b[i]) return false
+      return true
+    }
+
+    // @ts-expect-error ...
+    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags
+    if (a.valueOf !== undefined && a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf()
+    if (a.toString !== undefined && a.toString !== Object.prototype.toString) return a.toString() === b.toString()
+
+    keys = Object.keys(a)
+    length = keys.length
+    if (length !== Object.keys(b).length) return false
+
+    for (i = length; i-- !== 0; )
+      // @ts-expect-error ...
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false
+
+    for (i = length; i-- !== 0; ) {
+      var key = keys[i]
+
+      // @ts-expect-error ...
+      if (!deepEqual(a[key], b[key])) return false
+    }
+
+    return true
+  }
+
+  // true if both NaN, false otherwise
+  return a !== a && b !== b
+}

package/src/global.ts

@@ -0,0 +1,5 @@
+declare global {
+  export type TODO<_Reason extends string = 'unknown'> = any
+}
+
+export {}

package/src/guards.ts

@@ -0,0 +1,8 @@
+export const isNotUndefined = <T>(_: T | undefined): _ is T => _ !== undefined
+
+export const isNotNull = <T>(_: T | null): _ is T => _ !== null
+export const isUndefined = <T>(_: T | undefined): _ is undefined => _ === undefined
+
+export const isNil = (val: any): val is null | undefined => val === null || val === undefined
+
+export const isNotNil = <T>(val: T | undefined | null): val is T => val !== null && val !== undefined