@livestore/utils 0.3.1 → 0.3.2-dev.1

package/src/cuid/cuid.node.ts

@@ -15,32 +15,31 @@
 import crypto from 'node:crypto'
 import os from 'node:os'
 
-const lim = Math.pow(2, 32) - 1
+const lim = 2 ** 32 - 1
 
 const getRandomValue = () => {
   return Math.abs(crypto.randomBytes(4).readInt32BE() / lim)
 }
 
 const pad = (num: number | string, size: number) => {
-  const s = '000000000' + num
+  const s = `000000000${num}`
   return s.slice(s.length - size)
 }
 
 const fingerprint = () => {
-  const padding = 2,
-    pid = pad(process.pid.toString(36), padding),
-    hostname = os.hostname(),
-    length = hostname.length,
-    hostId = pad(
-      hostname
-        .split('')
-        .reduce((prev, char) => {
-          // eslint-disable-next-line unicorn/prefer-code-point
-          return +prev + char.charCodeAt(0)
-        }, +length + 36)
-        .toString(36),
-      padding,
-    )
+  const padding = 2
+  const pid = pad(process.pid.toString(36), padding)
+  const hostname = os.hostname()
+  const length = hostname.length
+  const hostId = pad(
+    hostname
+      .split('')
+      .reduce((prev, char) => {
+        return +prev + char.charCodeAt(0)
+      }, +length + 36)
+      .toString(36),
+    padding,
+  )
 
   return pid + hostId
 }
@@ -48,7 +47,7 @@ const fingerprint = () => {
 let c = 0
 const blockSize = 4
 const base = 36
-const discreteValues = Math.pow(base, blockSize)
+const discreteValues = base ** blockSize
 
 const randomBlock = () => {
   return pad(Math.trunc(getRandomValue() * discreteValues).toString(base), blockSize)
@@ -63,28 +62,28 @@ const safeCounter = () => {
 export const cuid = () => {
   // Starting with a lowercase letter makes
   // it HTML element ID friendly.
-  const letter = 'c', // hard-coded allows for sequential access
-    // timestamp
-    // warning: this exposes the exact date and time
-    // that the uid was created.
-    timestamp = Date.now().toString(base),
-    // Prevent same-machine collisions.
-    counter = pad(safeCounter().toString(base), blockSize),
-    // A few chars to generate distinct ids for different
-    // clients (so different computers are far less
-    // likely to generate the same id)
-    print = fingerprint(),
-    // Grab some more chars from Math.random()
-    random = randomBlock() + randomBlock()
+  const letter = 'c' // hard-coded allows for sequential access
+  // timestamp
+  // warning: this exposes the exact date and time
+  // that the uid was created.
+  const timestamp = Date.now().toString(base)
+  // Prevent same-machine collisions.
+  const counter = pad(safeCounter().toString(base), blockSize)
+  // A few chars to generate distinct ids for different
+  // clients (so different computers are far less
+  // likely to generate the same id)
+  const print = fingerprint()
+  // Grab some more chars from Math.random()
+  const random = randomBlock() + randomBlock()
 
   return letter + timestamp + counter + print + random
 }
 
 export const slug = () => {
-  const date = Date.now().toString(36),
-    counter = safeCounter().toString(36).slice(-4),
-    print = fingerprint().slice(0, 1) + fingerprint().slice(-1),
-    random = randomBlock().slice(-2)
+  const date = Date.now().toString(36)
+  const counter = safeCounter().toString(36).slice(-4)
+  const print = fingerprint().slice(0, 1) + fingerprint().slice(-1)
+  const random = randomBlock().slice(-2)
 
   return date.slice(-2) + counter + print + random
 }

package/src/effect/Effect.ts

@@ -5,8 +5,8 @@ import type { UnknownException } from 'effect/Cause'
 import { log } from 'effect/Console'
 import type { LazyArg } from 'effect/Function'
 
-import { isPromise } from '../index.js'
-import { UnknownError } from './Error.js'
+import { isPromise } from '../index.ts'
+import { UnknownError } from './Error.ts'
 
 export * from 'effect/Effect'
 
@@ -57,7 +57,10 @@ export const tryAll = <Res>(
 export const acquireReleaseLog = (label: string) =>
   Effect.acquireRelease(Effect.log(`${label} acquire`), (_, ex) => Effect.log(`${label} release`, ex))
 
-export const addFinalizerLog = (...msgs: any[]) => Effect.addFinalizer(() => Effect.log(...msgs))
+export const addFinalizerLog = (...msgs: any[]) =>
+  Effect.addFinalizer((exit) =>
+    Effect.log(...msgs, exit._tag === 'Success' ? 'with success' : `with failure: ${Cause.pretty(exit.cause)}`),
+  )
 
 export const logBefore =
   (...msgs: any[]) =>

package/src/effect/Scheduler.ts

@@ -9,6 +9,5 @@ export const messageChannel = (shouldYield: Scheduler.Scheduler['shouldYield'] =
 
     messageChannel.port1.postMessage(undefined)
 
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
     messageChannel.port2.onmessage = task
   }, shouldYield)

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

@@ -1,8 +1,8 @@
 import { Schema } from 'effect'
 import { describe, expect, test } from 'vitest'
 
-import type { DiffItem } from './debug-diff.js'
-import { debugDiff } from './debug-diff.js'
+import type { DiffItem } from './debug-diff.ts'
+import { debugDiff } from './debug-diff.ts'
 
 describe('debug-diff', () => {
   test('simple object', () => {

package/src/effect/Schema/index.ts

@@ -4,11 +4,11 @@ import { Effect, Hash, ParseResult, Schema } from 'effect'
 import type { ParseError } from 'effect/ParseResult'
 import type { ParseOptions } from 'effect/SchemaAST'
 
-import { shouldNeverHappen } from '../../index.js'
+import { shouldNeverHappen } from '../../index.ts'
 
 export * from 'effect/Schema'
-export * from './debug-diff.js'
-export * from './msgpack.js'
+export * from './debug-diff.ts'
+export * from './msgpack.ts'
 
 // 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/Subscribable.ts

@@ -49,13 +49,14 @@ class SubscribableImpl<in out A> extends Effectable.Class<A> implements Subscrib
   readonly [TypeId] = TypeId
   // @ts-expect-error type symbol
   readonly [Readable.TypeId] = Readable.TypeId
-  constructor(
-    readonly get: Effect.Effect<A>,
-    readonly changes: Stream.Stream<A>,
-  ) {
+  readonly get: Effect.Effect<A>
+  readonly changes: Stream.Stream<A>
+  constructor(get: Effect.Effect<A>, changes: Stream.Stream<A>) {
     super()
+    this.get = get
+    this.changes = changes
   }
-  // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+
   commit() {
     return this.get
   }

package/src/effect/WebChannel/WebChannel.test.ts

@@ -2,7 +2,7 @@ import * as Vitest from '@effect/vitest'
 import { Effect, Schema, Stream } from 'effect'
 import { JSDOM } from 'jsdom'
 
-import * as WebChannel from './WebChannel.js'
+import * as WebChannel from './WebChannel.ts'
 
 Vitest.describe('WebChannel', () => {
   Vitest.describe('windowChannel', () => {

package/src/effect/WebChannel/WebChannel.ts

@@ -1,20 +1,21 @@
 import { Deferred, Either, Exit, GlobalValue, identity, Option, PubSub, Queue, Scope } from 'effect'
 import type { DurationInput } from 'effect/Duration'
 
-import { shouldNeverHappen } from '../../misc.js'
-import * as Effect from '../Effect.js'
-import * as Schema from '../Schema/index.js'
-import * as Stream from '../Stream.js'
+import { shouldNeverHappen } from '../../misc.ts'
+import * as Effect from '../Effect.ts'
+import * as Schema from '../Schema/index.ts'
+import * as Stream from '../Stream.ts'
 import {
   DebugPingMessage,
   type InputSchema,
+  listenToDebugPing,
+  mapSchema,
   type WebChannel,
   WebChannelHeartbeat,
   WebChannelPing,
   WebChannelPong,
   WebChannelSymbol,
-} from './common.js'
-import { listenToDebugPing, mapSchema } from './common.js'
+} from './common.ts'
 
 export const shutdown = <MsgListen, MsgSend>(webChannel: WebChannel<MsgListen, MsgSend>): Effect.Effect<void> =>
   Deferred.done(webChannel.closedDeferred, Exit.void)
@@ -158,13 +159,11 @@ export const windowChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncod
     }).pipe(Effect.withSpan(`WebChannel:windowChannel`)),
   )
 
-export const messagePortChannel: {
-  <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
-    port: MessagePort
-    schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-    debugId?: string | number
-  }): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope>
-} = ({ port, schema: inputSchema, debugId }) =>
+export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
+  port: MessagePort
+  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
+  debugId?: string | number
+}) => Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> = ({ port, schema: inputSchema, debugId }) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
       const schema = mapSchema(inputSchema)
@@ -247,13 +246,11 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
     }),
   )
 
-export const messagePortChannelWithAck: {
-  <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
-    port: MessagePort
-    schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-    debugId?: string | number
-  }): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope>
-} = ({ port, schema: inputSchema, debugId }) =>
+export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
+  port: MessagePort
+  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
+  debugId?: string | number
+}) => Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> = ({ port, schema: inputSchema, debugId }) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
       const schema = mapSchema(inputSchema)
@@ -273,7 +270,6 @@ export const messagePortChannelWithAck: {
       const ChannelMessage = Schema.Union(ChannelRequest, ChannelRequestAck).annotations({
         title: 'webmesh.ChannelMessage',
       })
-      type ChannelMessage = typeof ChannelMessage.Type
 
       const debugInfo = {
         sendTotal: 0,

package/src/effect/WebChannel/broadcastChannelWithAck.ts

@@ -1,8 +1,8 @@
 import { Deferred, Exit, Predicate, Queue, Schema, Scope, Stream } from 'effect'
 
-import * as Effect from '../Effect.js'
-import type { InputSchema, WebChannel } from './common.js'
-import { listenToDebugPing, mapSchema, WebChannelSymbol } from './common.js'
+import * as Effect from '../Effect.ts'
+import type { InputSchema, WebChannel } from './common.ts'
+import { listenToDebugPing, mapSchema, WebChannelSymbol } from './common.ts'
 
 const ConnectMessage = Schema.TaggedStruct('ConnectMessage', {
   from: Schema.String,

package/src/effect/WebChannel/mod.ts

@@ -1,3 +1,3 @@
-export * from './WebChannel.js'
-export * from './broadcastChannelWithAck.js'
-export * from './common.js'
+export * from './broadcastChannelWithAck.ts'
+export * from './common.ts'
+export * from './WebChannel.ts'

package/src/effect/WebLock.ts

@@ -12,7 +12,7 @@ export const withLock =
     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> =>
+  <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A, E | E2, Ctx> =>
     Effect.gen(function* () {
       const runtime = yield* Effect.runtime<Ctx>()
 
@@ -35,7 +35,7 @@ export const withLock =
 
             // TODO also propagate Effect interruption to the execution
             return Runtime.runPromiseExit(runtime)(eff)
-          })
+          }) as unknown as Promise<Exit.Exit<A, E>>
         },
         catch: (err) => err as any as E,
       })

package/src/effect/WebSocket.test.ts

@@ -2,7 +2,7 @@ import { FetchHttpClient } from '@effect/platform'
 import * as Vitest from '@effect/vitest'
 import { Effect, Exit } from 'effect'
 
-import { makeWebSocket } from './WebSocket.js'
+import { makeWebSocket } from './WebSocket.ts'
 
 Vitest.describe('WebSocket', () => {
   Vitest.scopedLive(

package/src/effect/index.ts

@@ -1,137 +1,131 @@
-import '../global.js'
+import '../global.ts'
 
+export * as OtelTracer from '@effect/opentelemetry/Tracer'
 export {
-  Scope,
-  Ref,
-  SynchronizedRef,
-  Queue,
+  Command,
+  CommandExecutor,
+  Error as PlatformError,
+  FetchHttpClient,
+  FileSystem,
+  Headers,
+  HttpClient,
+  HttpClientError,
+  HttpClientRequest,
+  HttpClientResponse,
+  HttpMiddleware,
+  HttpRouter,
+  HttpServer,
+  HttpServerRequest,
+  HttpServerResponse,
+  KeyValueStore,
+  Socket,
+  Terminal,
+  Transferable,
+  UrlParams,
+  Worker,
+  WorkerError,
+  WorkerRunner,
+} from '@effect/platform'
+export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+export {
+  Rpc,
+  RpcClient,
+  RpcGroup,
+  RpcMessage,
+  RpcMiddleware,
+  RpcSchema,
+  RpcSerialization,
+  RpcServer,
+  RpcTest,
+  RpcWorker,
+} from '@effect/rpc'
+export * as StandardSchema from '@standard-schema/spec'
+export {
+  Array as ReadonlyArray,
+  Brand,
+  Cache,
+  Cause,
+  Channel,
+  Chunk,
+  // Logger,
+  Config,
+  Context,
+  Data,
+  Deferred,
+  Duration,
+  Either,
+  Equal,
+  ExecutionStrategy,
+  Exit,
   Fiber,
+  FiberHandle,
   FiberId,
-  FiberSet,
   FiberMap,
-  FiberHandle,
-  Inspectable,
-  RuntimeFlags,
-  PubSub,
-  Exit,
-  Cause,
-  Runtime,
   FiberRef,
   FiberRefs,
   FiberRefsPatch,
-  Deferred,
-  Metric,
-  MetricState,
-  Request,
-  Tracer,
-  Context,
-  Data,
-  Either,
-  Brand,
+  FiberSet,
+  GlobalValue,
   Hash,
-  Equal,
-  Chunk,
-  Duration,
-  Array as ReadonlyArray,
-  Record as ReadonlyRecord,
-  SortedMap,
   HashMap,
   HashSet,
+  Inspectable,
+  identity,
+  Layer,
+  List,
+  LogLevel,
+  LogSpan,
+  Mailbox,
   ManagedRuntime,
-  MutableHashSet,
+  Match,
+  Metric,
+  MetricState,
   MutableHashMap,
-  TQueue,
+  MutableHashSet,
   Option,
-  LogLevel,
-  // Logger,
-  Config,
-  Layer,
-  STM,
-  TRef,
-  Channel,
+  ParseResult,
   Predicate,
+  Pretty,
+  PrimaryKey,
+  PubSub,
   // Subscribable,
   pipe,
-  identity,
-  GlobalValue,
-  Match,
+  Queue,
+  Record as ReadonlyRecord,
+  Ref,
+  Request,
+  Runtime,
+  RuntimeFlags,
+  Scope,
+  SortedMap,
+  STM,
+  SynchronizedRef,
   TestServices,
-  Mailbox,
-  ExecutionStrategy,
-  PrimaryKey,
+  TQueue,
+  TRef,
+  Tracer,
   Types,
-  Cache,
 } from 'effect'
-
-export * as StandardSchema from '@standard-schema/spec'
-
 export { dual } from 'effect/Function'
-
-export * as Stream from './Stream.js'
-
-export * as BucketQueue from './BucketQueue.js'
-
-export * as SubscriptionRef from './SubscriptionRef.js'
-export * as Subscribable from './Subscribable.js'
-
-export * as Logger from './Logger.js'
-
-export * as WebChannel from './WebChannel/mod.js'
-export * as WebSocket from './WebSocket.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 * as TaskTracing from './TaskTracing.js'
-
-export {
-  Rpc,
-  RpcGroup,
-  RpcClient,
-  RpcMessage,
-  RpcSchema,
-  RpcMiddleware,
-  RpcServer,
-  RpcSerialization,
-  RpcTest,
-  RpcWorker,
-} from '@effect/rpc'
 
-export {
-  Transferable,
-  FileSystem,
-  Worker,
-  WorkerError,
-  WorkerRunner,
-  Terminal,
-  HttpServer,
-  HttpClient,
-  HttpClientError,
-  HttpClientRequest,
-  HttpClientResponse,
-  FetchHttpClient,
-  Socket,
-  UrlParams,
-  HttpServerRequest,
-  Headers,
-  HttpMiddleware,
-  HttpRouter,
-  HttpServerResponse,
-  Command,
-  CommandExecutor,
-  KeyValueStore,
-  Error as PlatformError,
-} from '@effect/platform'
-export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+export * as SchemaAST from 'effect/SchemaAST'
+export * as BucketQueue from './BucketQueue.ts'
+export * as Logger from './Logger.ts'
+export * as Schema from './Schema/index.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.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'
+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/env.ts

@@ -1,4 +1,4 @@
-import { envTruish } from './misc.js'
+import { envTruish } from './misc.ts'
 
 export const env = (name: string): string | undefined => {
   if (typeof process !== 'undefined' && process.env !== undefined) {

package/src/fast-deep-equal.ts

@@ -1,19 +1,19 @@
-/* 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 && b && typeof a === 'object' && typeof b === 'object') {
     if (a.constructor !== b.constructor) return false
 
-    var length, i, keys
+    let length: number
+    let i: any
+    let keys: any
     if (Array.isArray(a)) {
       length = a.length
       // @ts-expect-error ...
-      if (length != b.length) return false
+      if (length !== b.length) return false
       for (i = length; i-- !== 0; )
         // @ts-expect-error ...
         if (!deepEqual(a[i], b[i])) return false
@@ -37,7 +37,7 @@ export const deepEqual = <T>(a: T, b: T): boolean => {
       // @ts-expect-error ...
       length = a.length
       // @ts-expect-error ...
-      if (length != b.length) return false
+      if (length !== b.length) return false
       for (i = length; i-- !== 0; )
         // @ts-expect-error ...
         if (a[i] !== b[i]) return false
@@ -53,12 +53,10 @@ export const deepEqual = <T>(a: T, b: T): boolean => {
     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; ) if (!Object.hasOwn(b, keys[i])) return false
 
     for (i = length; i-- !== 0; ) {
-      var key = keys[i]
+      const key = keys[i]
 
       // @ts-expect-error ...
       if (!deepEqual(a[key], b[key])) return false
@@ -68,5 +66,6 @@ export const deepEqual = <T>(a: T, b: T): boolean => {
   }
 
   // true if both NaN, false otherwise
+  // biome-ignore lint/suspicious/noSelfCompare: comparing to itself is fine here
   return a !== a && b !== b
 }