@livestore/utils 0.4.0 → 0.5.0-dev.0

package/src/browser/WebError.ts

@@ -1,5 +1,5 @@
 import './QuotaExceededError.ts'
-import { Either, ParseResult, Predicate, Schema } from 'effect'
+import { Predicate, Schema } from 'effect'
 
 /**
  * Unique identifier for web errors.
@@ -23,7 +23,7 @@ const TypeId = '~@livestore/utils/WebError' as const
  * })
  *
  * console.log(WebError.isWebError(someError)) // false
- * console.log(WebError.isWebError(webError))   // true
+ * console.log(WebError.isWebError(webError)) // true
  * ```
  */
 export const isWebError = (u: unknown): u is WebError => Predicate.hasProperty(u, TypeId)
@@ -43,9 +43,7 @@ export const isWebError = (u: unknown): u is WebError => Predicate.hasProperty(u
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Evalerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#exceptiondef-evalerror | Specification}
  */
-export class EvalError extends Schema.TaggedError<EvalError>(
-  `${TypeId}/EvalError`,
-)('EvalError', {
+export class EvalError extends Schema.TaggedError<EvalError>(`${TypeId}/EvalError`)('EvalError', {
   cause: Schema.instanceOf(globalThis.EvalError),
 }) {
   readonly [TypeId] = TypeId
@@ -59,9 +57,7 @@ export class EvalError extends Schema.TaggedError<EvalError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Rangeerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#exceptiondef-rangeerror | Specification}
  */
-export class RangeError extends Schema.TaggedError<RangeError>(
-  `${TypeId}/RangeError`,
-)('RangeError', {
+export class RangeError extends Schema.TaggedError<RangeError>(`${TypeId}/RangeError`)('RangeError', {
   cause: Schema.instanceOf(globalThis.RangeError),
 }) {
   readonly [TypeId] = TypeId
@@ -75,9 +71,7 @@ export class RangeError extends Schema.TaggedError<RangeError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Referenceerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#exceptiondef-referenceerror | Specification}
  */
-export class ReferenceError extends Schema.TaggedError<ReferenceError>(
-  `${TypeId}/ReferenceError`,
-)('ReferenceError', {
+export class ReferenceError extends Schema.TaggedError<ReferenceError>(`${TypeId}/ReferenceError`)('ReferenceError', {
   cause: Schema.instanceOf(globalThis.ReferenceError),
 }) {
   readonly [TypeId] = TypeId
@@ -91,9 +85,7 @@ export class ReferenceError extends Schema.TaggedError<ReferenceError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Typeerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#exceptiondef-typeerror | Specification}
  */
-export class TypeError extends Schema.TaggedError<TypeError>(
-  `${TypeId}/TypeError`,
-)('TypeError', {
+export class TypeError extends Schema.TaggedError<TypeError>(`${TypeId}/TypeError`)('TypeError', {
   cause: Schema.instanceOf(globalThis.TypeError),
 }) {
   readonly [TypeId] = TypeId
@@ -107,9 +99,7 @@ export class TypeError extends Schema.TaggedError<TypeError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#exceptiondef-urierror | Specification}
  */
-export class URIError extends Schema.TaggedError<URIError>(
-  `${TypeId}/URIError`,
-)('URIError', {
+export class URIError extends Schema.TaggedError<URIError>(`${TypeId}/URIError`)('URIError', {
   cause: Schema.instanceOf(globalThis.URIError),
 }) {
   readonly [TypeId] = TypeId
@@ -123,13 +113,11 @@ export class URIError extends Schema.TaggedError<URIError>(
 // [Specification](https://webidl.spec.whatwg.org/#idl-DOMException-derived-predefineds)
 
 const domExceptionWithName = (expectedName: string) =>
-  Schema.instanceOf(DOMException).pipe(
-    Schema.filter((a, options) =>
-      ParseResult.validateEither(
-        Schema.Struct({
-          name: Schema.Literal(expectedName),
-        }),
-      )(a, options).pipe(Either.flip, Either.getOrUndefined),
+  Schema.instanceOf(DOMException).check(
+    Schema.makeFilter((domException) =>
+      domException.name === expectedName
+        ? undefined
+        : `Expected DOMException with name "${expectedName}", got "${domException.name}"`,
     ),
   )
 
@@ -141,17 +129,18 @@ const domExceptionWithName = (expectedName: string) =>
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/QuotaExceededError | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#quotaexceedederror | Specification}
  */
-export class QuotaExceededError extends Schema.TaggedError<QuotaExceededError>(
-  `${TypeId}/QuotaExceededError`,
-)('QuotaExceededError', {
-  cause: Schema.Union(
-    typeof globalThis.QuotaExceededError === 'function'
-      ? Schema.instanceOf(globalThis.QuotaExceededError)
-      : Schema.Never,
-    // Deprecated but still in use in some browsers
-    domExceptionWithName('QuotaExceededError'),
-  ),
-}) {
+export class QuotaExceededError extends Schema.TaggedError<QuotaExceededError>(`${TypeId}/QuotaExceededError`)(
+  'QuotaExceededError',
+  {
+    cause: Schema.Union([
+      typeof globalThis.QuotaExceededError === 'function'
+        ? Schema.instanceOf(globalThis.QuotaExceededError)
+        : Schema.Never,
+      // Deprecated but still in use in some browsers
+      domExceptionWithName('QuotaExceededError'),
+    ]),
+  },
+) {
   readonly [TypeId] = TypeId
   override get message(): string {
     return this.cause.message
@@ -192,9 +181,7 @@ export class NoModificationAllowedError extends Schema.TaggedError<NoModificatio
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#notfounderror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#notfounderror | Specification}
  */
-export class NotFoundError extends Schema.TaggedError<NotFoundError>(
-  `${TypeId}/NotFoundError`,
-)('NotFoundError', {
+export class NotFoundError extends Schema.TaggedError<NotFoundError>(`${TypeId}/NotFoundError`)('NotFoundError', {
   cause: domExceptionWithName('NotFoundError'),
 }) {
   readonly [TypeId] = TypeId
@@ -211,11 +198,12 @@ export class NotFoundError extends Schema.TaggedError<NotFoundError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#notallowederror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#notallowederror | Specification}
  */
-export class NotAllowedError extends Schema.TaggedError<NotAllowedError>(
-  `${TypeId}/NotAllowedError`,
-)('NotAllowedError', {
-  cause: domExceptionWithName('NotAllowedError'),
-}) {
+export class NotAllowedError extends Schema.TaggedError<NotAllowedError>(`${TypeId}/NotAllowedError`)(
+  'NotAllowedError',
+  {
+    cause: domExceptionWithName('NotAllowedError'),
+  },
+) {
   readonly [TypeId] = TypeId
   override get message(): string {
     return this.cause.message
@@ -230,11 +218,12 @@ export class NotAllowedError extends Schema.TaggedError<NotAllowedError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#typemismatcherror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#typemismatcherror | Specification}
  */
-export class TypeMismatchError extends Schema.TaggedError<TypeMismatchError>(
-  `${TypeId}/TypeMismatchError`,
-)('TypeMismatchError', {
-  cause: domExceptionWithName('TypeMismatchError'),
-}) {
+export class TypeMismatchError extends Schema.TaggedError<TypeMismatchError>(`${TypeId}/TypeMismatchError`)(
+  'TypeMismatchError',
+  {
+    cause: domExceptionWithName('TypeMismatchError'),
+  },
+) {
   readonly [TypeId] = TypeId
   override get message(): string {
     return this.cause.message
@@ -249,11 +238,12 @@ export class TypeMismatchError extends Schema.TaggedError<TypeMismatchError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#invalidstateerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#invalidstateerror | Specification}
  */
-export class InvalidStateError extends Schema.TaggedError<InvalidStateError>(
-  `${TypeId}/InvalidStateError`,
-)('InvalidStateError', {
-  cause: domExceptionWithName('InvalidStateError'),
-}) {
+export class InvalidStateError extends Schema.TaggedError<InvalidStateError>(`${TypeId}/InvalidStateError`)(
+  'InvalidStateError',
+  {
+    cause: domExceptionWithName('InvalidStateError'),
+  },
+) {
   readonly [TypeId] = TypeId
   override get message(): string {
     return this.cause.message
@@ -268,9 +258,7 @@ export class InvalidStateError extends Schema.TaggedError<InvalidStateError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#aborterror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#aborterror | Specification}
  */
-export class AbortError extends Schema.TaggedError<AbortError>(
-  `${TypeId}/AbortError`,
-)('AbortError', {
+export class AbortError extends Schema.TaggedError<AbortError>(`${TypeId}/AbortError`)('AbortError', {
   cause: domExceptionWithName('AbortError'),
 }) {
   readonly [TypeId] = TypeId
@@ -306,9 +294,7 @@ export class InvalidModificationError extends Schema.TaggedError<InvalidModifica
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#securityerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#securityerror | Specification}
  */
-export class SecurityError extends Schema.TaggedError<SecurityError>(
-  `${TypeId}/SecurityError`,
-)('SecurityError', {
+export class SecurityError extends Schema.TaggedError<SecurityError>(`${TypeId}/SecurityError`)('SecurityError', {
   cause: domExceptionWithName('SecurityError'),
 }) {
   readonly [TypeId] = TypeId
@@ -325,9 +311,7 @@ export class SecurityError extends Schema.TaggedError<SecurityError>(
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#datacloneerror | MDN Reference}
  * @see {@link https://webidl.spec.whatwg.org/#datacloneerror | Specification}
  */
-export class DataCloneError extends Schema.TaggedError<DataCloneError>(
-  `${TypeId}/DataCloneError`,
-)('DataCloneError', {
+export class DataCloneError extends Schema.TaggedError<DataCloneError>(`${TypeId}/DataCloneError`)('DataCloneError', {
   cause: domExceptionWithName('DataCloneError'),
 }) {
   readonly [TypeId] = TypeId
@@ -375,13 +359,11 @@ export class DataCloneError extends Schema.TaggedError<DataCloneError>(
  * )
  * ```
  */
-export class UnknownError extends Schema.TaggedError<UnknownError>(
-  `${TypeId}/UnknownError`,
-)('UnknownError', {
+export class UnknownError extends Schema.TaggedError<UnknownError>(`${TypeId}/UnknownError`)('UnknownError', {
   module: Schema.optional(Schema.String),
   method: Schema.optional(Schema.String),
   description: Schema.optional(Schema.String),
-  cause: Schema.optional(Schema.Defect),
+  cause: Schema.optional(Schema.Defect()),
 }) {
   readonly [TypeId] = TypeId
   override get message(): string {
@@ -467,7 +449,7 @@ export const WebError: Schema.Union<
     // Custom Errors
     typeof UnknownError,
   ]
-> = Schema.Union(
+> = Schema.Union([
   // Simple Exception Errors
   EvalError,
   RangeError,
@@ -488,7 +470,7 @@ export const WebError: Schema.Union<
   DataCloneError,
   // Custom Errors
   UnknownError,
-)
+])
 
 /**
  * Constructor type for any `WebError` variant exposed by the schema union.
@@ -498,65 +480,6 @@ export const WebError: Schema.Union<
  */
 type WebErrorConstructor = (typeof WebError.members)[number]
 
-/**
- * Schema transform for converting unknown values to WebError instances.
- *
- * This transform handles various web error types and converts them to
- * properly typed WebError instances while preserving the original cause.
- */
-const WebErrorFromUnknown = Schema.transform(Schema.Unknown, WebError, {
-  strict: true,
-  decode: (value) => {
-    // Already a WebError
-    if (isWebError(value) === true) return value
-
-    // Simple Exception Errors
-    if (value instanceof globalThis.EvalError) return new EvalError({ cause: value })
-    if (value instanceof globalThis.RangeError) return new RangeError({ cause: value })
-    if (value instanceof globalThis.ReferenceError) return new ReferenceError({ cause: value })
-    if (value instanceof globalThis.TypeError) return new TypeError({ cause: value })
-    if (value instanceof globalThis.URIError) return new URIError({ cause: value })
-
-    // Predefined DOMException Errors
-    if (typeof globalThis.QuotaExceededError === 'function' && value instanceof globalThis.QuotaExceededError) {
-      return new QuotaExceededError({ cause: value })
-    }
-
-    // Base DOMException Errors
-    if (value instanceof DOMException) {
-      switch (value.name) {
-        case 'QuotaExceededError':
-          return new QuotaExceededError({ cause: value })
-        case 'NoModificationAllowedError':
-          return new NoModificationAllowedError({ cause: value })
-        case 'NotFoundError':
-          return new NotFoundError({ cause: value })
-        case 'NotAllowedError':
-          return new NotAllowedError({ cause: value })
-        case 'TypeMismatchError':
-          return new TypeMismatchError({ cause: value })
-        case 'InvalidStateError':
-          return new InvalidStateError({ cause: value })
-        case 'AbortError':
-          return new AbortError({ cause: value })
-        case 'InvalidModificationError':
-          return new InvalidModificationError({ cause: value })
-        case 'SecurityError':
-          return new SecurityError({ cause: value })
-        case 'DataCloneError':
-          return new DataCloneError({ cause: value })
-        default:
-          break
-      }
-    }
-
-    if (value instanceof Error) return new UnknownError({ description: value.message, cause: value })
-
-    return new UnknownError({ cause: value })
-  },
-  encode: (webError) => webError,
-})
-
 /**
  * Parses an unknown value into a typed WebError instance.
  *
@@ -596,18 +519,69 @@ const WebErrorFromUnknown = Schema.transform(Schema.Unknown, WebError, {
  * // anyError is typed as WebError (all possible error types)
  * ```
  */
-export function parseWebError(value: unknown): WebError
-export function parseWebError<BECs extends readonly WebErrorConstructor[]>(
+export function classifyWebError(value: unknown): WebError
+export function classifyWebError<BECs extends readonly WebErrorConstructor[]>(
   value: unknown,
   expected: BECs,
 ): InstanceType<BECs[number]> | UnknownError
-export function parseWebError(value: unknown, expected: readonly WebErrorConstructor[] = []): WebError {
-  const parsed = Schema.decodeUnknownSync(WebErrorFromUnknown)(value)
+export function classifyWebError(value: unknown, expected: readonly WebErrorConstructor[] = []): WebError {
+  const parsed = parseWebError(value)
 
   if (expected.length === 0) return parsed
 
-  const expectedTags = new Set(expected.map((ErrorConstructor) => ErrorConstructor._tag))
-  if (expectedTags.has(parsed._tag) === true) return parsed
+  if (expected.some((ErrorConstructor) => parsed instanceof ErrorConstructor) === true) return parsed
 
   return parsed instanceof UnknownError ? parsed : new UnknownError({ cause: parsed })
 }
+
+/**
+ * Converts web-native exception shapes to LiveStore's `WebError`
+ * classes while preserving the original value as `cause`.
+ */
+const parseWebError = (cause: unknown): WebError => {
+  if (isWebError(cause) === true) return cause
+
+  // Simple Exception Errors
+  if (cause instanceof globalThis.EvalError) return new EvalError({ cause: cause })
+  if (cause instanceof globalThis.RangeError) return new RangeError({ cause: cause })
+  if (cause instanceof globalThis.ReferenceError) return new ReferenceError({ cause: cause })
+  if (cause instanceof globalThis.TypeError) return new TypeError({ cause: cause })
+  if (cause instanceof globalThis.URIError) return new URIError({ cause: cause })
+
+  // Predefined DOMException Errors
+  if (typeof globalThis.QuotaExceededError === 'function' && cause instanceof globalThis.QuotaExceededError) {
+    return new QuotaExceededError({ cause: cause })
+  }
+
+  // Base DOMException Errors
+  if (cause instanceof DOMException) {
+    switch (cause.name) {
+      case 'QuotaExceededError':
+        return new QuotaExceededError({ cause: cause })
+      case 'NoModificationAllowedError':
+        return new NoModificationAllowedError({ cause: cause })
+      case 'NotFoundError':
+        return new NotFoundError({ cause: cause })
+      case 'NotAllowedError':
+        return new NotAllowedError({ cause: cause })
+      case 'TypeMismatchError':
+        return new TypeMismatchError({ cause: cause })
+      case 'InvalidStateError':
+        return new InvalidStateError({ cause: cause })
+      case 'AbortError':
+        return new AbortError({ cause: cause })
+      case 'InvalidModificationError':
+        return new InvalidModificationError({ cause: cause })
+      case 'SecurityError':
+        return new SecurityError({ cause: cause })
+      case 'DataCloneError':
+        return new DataCloneError({ cause: cause })
+      default:
+        break
+    }
+  }
+
+  if (cause instanceof Error) return new UnknownError({ description: cause.message, cause: cause })
+
+  return new UnknownError({ cause: cause })
+}

package/src/browser/WebLock.ts

@@ -1,5 +1,4 @@
-import type { Exit } from 'effect'
-import { Deferred, Effect, Runtime } from 'effect'
+import { Deferred, Effect, type Exit } from 'effect'
 
 // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
 export const withLock =
@@ -14,7 +13,7 @@ export const withLock =
   }) =>
   <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A, E | E2, Ctx> =>
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime<Ctx>()
+      const services = yield* Effect.context<Ctx>()
 
       const exit = yield* Effect.tryPromise<Exit.Exit<A, E>, E | E2>({
         try: (signal) => {
@@ -25,7 +24,7 @@ export const withLock =
           return navigator.locks.request(lockName, requestOptions, async (lock: Lock | null) => {
             if (lock === null) {
               if (onTaken !== undefined) {
-                const onTakenExit = await Runtime.runPromiseExit(runtime)(onTaken)
+                const onTakenExit = await Effect.runPromiseExitWith(services)(onTaken)
                 if (onTakenExit._tag === 'Failure') {
                   return onTakenExit
                 }
@@ -34,7 +33,7 @@ export const withLock =
             }
 
             // TODO also propagate Effect interruption to the execution
-            return Runtime.runPromiseExit(runtime)(eff)
+            return Effect.runPromiseExitWith(services)(eff)
           }) as unknown as Promise<Exit.Exit<A, E>>
         },
         catch: (err) => err as any as E,
@@ -48,7 +47,7 @@ export const withLock =
     })
 
 export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<void>((cb, signal) => {
+  Effect.callback<void>((cb, signal) => {
     if (signal.aborted === true) return
 
     navigator.locks
@@ -71,7 +70,7 @@ export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName:
   })
 
 export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<boolean>((cb, signal) => {
+  Effect.callback<boolean>((cb, signal) => {
     navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, (lock: Lock | null) => {
       cb(Effect.succeed(lock !== null))
 
@@ -95,7 +94,7 @@ export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName:
   })
 
 export const stealDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<boolean>((cb, signal) => {
+  Effect.callback<boolean>((cb, signal) => {
     navigator.locks.request(lockName, { mode: 'exclusive', steal: true }, (lock: Lock | null) => {
       cb(Effect.succeed(lock !== null))
 
@@ -116,24 +115,24 @@ export const stealDeferredLock = (deferred: Deferred.Deferred<void>, lockName: s
   })
 
 export const waitForLock = (lockName: string) =>
-  Effect.async<void>((cb, signal) => {
+  Effect.callback<void>((cb, signal) => {
     if (signal.aborted === true) return
 
     navigator.locks.request(lockName, { mode: 'shared', signal, ifAvailable: false }, (_lock: Lock | null) => {
-      cb(Effect.succeed(void 0))
+      cb(Effect.void)
     })
   })
 
 /** Attempts to get the lock if available and waits for it to be stolen */
 export const getLockAndWaitForSteal = (lockName: string) =>
-  Effect.async<void>((cb, signal) => {
+  Effect.callback<void>((cb, signal) => {
     if (signal.aborted === true) return
 
     navigator.locks
       .request(lockName, { mode: 'exclusive', ifAvailable: true }, async (lock: Lock | null) => {
         if (lock === null) {
           // Lock wasn't available, resolve immediately
-          cb(Effect.succeed(void 0))
+          cb(Effect.void)
           return
         }
 
@@ -151,7 +150,7 @@ export const getLockAndWaitForSteal = (lockName: string) =>
           return Promise.race([holdLock, signal.aborted === true ? Promise.resolve() : holdLock]).catch(() => {})
         }).catch(() => {})
 
-        cb(Effect.succeed(void 0))
+        cb(Effect.void)
       })
       .catch((error) => {
         if (
@@ -161,7 +160,7 @@ export const getLockAndWaitForSteal = (lockName: string) =>
         ) {
           // Given signal interruption is handled via Effect, we can ignore this case
           // or the case when the lock is stolen
-          cb(Effect.succeed(void 0))
+          cb(Effect.void)
         } else {
           console.error('[@livestore/utils:WebLock] getLockAndWaitForSteal. error', error)
           throw error