@livestore/utils 0.3.2-dev.0 → 0.3.2-dev.10

package/src/effect/WebChannel/WebChannel.ts

@@ -1,10 +1,10 @@
 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,
@@ -15,7 +15,7 @@ import {
   WebChannelPing,
   WebChannelPong,
   WebChannelSymbol,
-} from './common.js'
+} from './common.ts'
 
 export const shutdown = <MsgListen, MsgSend>(webChannel: WebChannel<MsgListen, MsgSend>): Effect.Effect<void> =>
   Deferred.done(webChannel.closedDeferred, Exit.void)

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

@@ -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,5 +1,3 @@
-/* eslint-disable no-var */
-
 // Copied from fast-deep-equal
 // MIT License
 

package/src/global.ts

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

package/src/misc.ts

@@ -37,7 +37,6 @@ export const tryAsFunctionAndNew = <TArg, TResult>(
   try {
     // @ts-expect-error try out as constructor
     return new fnOrConstructor(arg)
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (_e) {
     // @ts-expect-error try out as function
     return fnOrConstructor(arg)

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

@@ -1,22 +1,22 @@
 export { default as prettyBytes } from 'pretty-bytes'
-export * as base64 from './base64.js'
-export * from './browser.js'
-export * from './Deferred.js'
-export * from './env.js'
-export * from './fast-deep-equal.js'
-export * from './guards.js'
-export * from './misc.js'
-export * from './NoopTracer.js'
-export * from './object/index.js'
-export * from './promise.js'
-export * from './set.js'
-export * from './string.js'
-export * from './time.js'
+export * as base64 from './base64.ts'
+export * from './browser.ts'
+export * from './Deferred.ts'
+export * from './env.ts'
+export * from './fast-deep-equal.ts'
+export * from './guards.ts'
+export * from './misc.ts'
+export * from './NoopTracer.ts'
+export * from './object/index.ts'
+export * from './promise.ts'
+export * from './set.ts'
+export * from './string.ts'
+export * from './time.ts'
 
 import type * as otel from '@opentelemetry/api'
 import type { Types } from 'effect'
 
-import { objectToString } from './misc.js'
+import { objectToString } from './misc.ts'
 
 export type Prettify<T> = T extends infer U ? { [K in keyof U]: Prettify<U[K]> } : never
 
@@ -73,6 +73,11 @@ export const recRemoveUndefinedValues = (val: any): void => {
   }
 }
 
+/**
+ * Replace non-alphanumeric characters with a dash.
+ */
+export const sluggify = (str: string, separator = '-') => str.replace(/[^a-zA-Z0-9]/g, separator)
+
 export const prop =
   <T extends {}, K extends keyof T>(key: K) =>
   (obj: T): T[K] =>
@@ -86,7 +91,7 @@ export const isReadonlyArray = <I, T>(value: ReadonlyArray<I> | T): value is Rea
  * Use this to make assertion at end of if-else chain that all members of a
  * union have been accounted for.
  */
-/* eslint-disable-next-line prefer-arrow/prefer-arrow-functions */
+
 export function casesHandled(unexpectedCase: never): never {
   // biome-ignore lint/suspicious/noDebugger: debugging
   debugger
@@ -228,4 +233,4 @@ export const isPromise = (value: any): value is Promise<unknown> => typeof value
 
 export const isIterable = <T>(value: any): value is Iterable<T> => typeof value?.[Symbol.iterator] === 'function'
 
-export { objectToString as errorToString } from './misc.js'
+export { objectToString as errorToString } from './misc.ts'

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/ChildProcessRunner.test.ts

@@ -5,9 +5,9 @@ import * as EffectWorker from '@effect/platform/Worker'
 import { assert, describe, it } from '@effect/vitest'
 import { Chunk, Effect, Stream } from 'effect'
 
-import * as ChildProcessWorker from '../ChildProcessWorker.js'
-import type { WorkerMessage } from './schema.js'
-import { GetPersonById, GetUserById, InitialMessage, Person, User } from './schema.js'
+import * as ChildProcessWorker from '../ChildProcessWorker.ts'
+import type { WorkerMessage } from './schema.ts'
+import { GetPersonById, GetUserById, InitialMessage, Person, User } from './schema.ts'
 
 const WorkerLive = ChildProcessWorker.layer(() =>
   ChildProcess.fork(

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.ts

@@ -2,9 +2,9 @@ import * as Runner from '@effect/platform/WorkerRunner'
 import { Context, Effect, Layer, Option, Stream } from 'effect'
 
 // import { NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
-import { PlatformNode } from '../../mod.js'
-import * as ChildProcessRunner from '../ChildProcessRunner.js'
-import { Person, User, WorkerMessage } from './schema.js'
+import { PlatformNode } from '../../mod.ts'
+import * as ChildProcessRunner from '../ChildProcessRunner.ts'
+import { Person, User, WorkerMessage } from './schema.ts'
 
 interface Name {
   readonly _: unique symbol

package/src/node/mod.ts

@@ -2,15 +2,15 @@ import * as http from 'node:http'
 
 import { Effect, Layer } from 'effect'
 
-import { OtelTracer, UnknownError } from '../effect/index.js'
-import { makeNoopTracer } from '../NoopTracer.js'
+import { OtelTracer, UnknownError } from '../effect/index.ts'
+import { makeNoopTracer } from '../NoopTracer.ts'
 
 export * as Cli from '@effect/cli'
-export * as PlatformNode from '@effect/platform-node'
 export * as SocketServer from '@effect/platform/SocketServer'
+export * as PlatformNode from '@effect/platform-node'
 
-export * as ChildProcessRunner from './ChildProcessRunner/ChildProcessRunner.js'
-export * as ChildProcessWorker from './ChildProcessRunner/ChildProcessWorker.js'
+export * as ChildProcessRunner from './ChildProcessRunner/ChildProcessRunner.ts'
+export * as ChildProcessWorker from './ChildProcessRunner/ChildProcessWorker.ts'
 
 // Enable debug logging for OpenTelemetry
 // otel.diag.setLogger(new otel.DiagConsoleLogger(), otel.DiagLogLevel.ERROR)
@@ -47,7 +47,7 @@ export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend((
 
   const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
     Layer.provideMerge(OtelTracerLive),
-  ) as any as Layer.Layer<OtelTracer.OtelTracer>
+  )
 
   return TracingLive
 })

package/src/object/index.ts

@@ -1,7 +1,8 @@
 import { pipe } from 'effect'
 
-export * from './pick.js'
-export * from './omit.js'
+export * from './omit.ts'
+export * from './pick.ts'
+export * from './stringify-object.ts'
 
 type ValueOfRecord<R extends Record<any, any>> = R extends Record<any, infer V> ? V : never
 

package/src/object/stringify-object.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+import { stringifyObject } from './stringify-object.ts'
+
+describe('stringifyObject', () => {
+  it('stringifies a flat object', () => {
+    const obj = { a: 1, b: 'test', c: true }
+    expect(stringifyObject(obj)).toBe('a=1 b=test c=true')
+  })
+
+  it('stringifies a nested object with dot notation', () => {
+    const obj = { a: 1, b: { c: 2, d: 'x' } }
+    expect(stringifyObject(obj)).toBe('a=1 b.c=2 b.d=x')
+  })
+
+  it('stringifies an object with array values', () => {
+    const obj = { a: [1, 2, 3], b: 'x' }
+    expect(stringifyObject(obj)).toBe('a=1,2,3 b=x')
+  })
+
+  it('handles objects with undefined and null values', () => {
+    const obj = { a: undefined, b: null, c: 1 }
+    expect(stringifyObject(obj)).toBe('a=undefined b=null c=1')
+  })
+
+  it('handles deeply nested objects', () => {
+    const obj = { a: { b: { c: { d: 1 } } } }
+    expect(stringifyObject(obj)).toBe('a.b.c.d=1')
+  })
+
+  it('handles complex nested objects with arrays', () => {
+    const obj = {
+      config: {
+        values: [1, 2],
+        settings: { enabled: true },
+      },
+      name: 'test',
+    }
+    expect(stringifyObject(obj)).toBe('config.values=1,2 config.settings.enabled=true name=test')
+  })
+
+  it('handles empty object', () => {
+    expect(stringifyObject({})).toBe('')
+  })
+})

package/src/object/stringify-object.ts

@@ -0,0 +1,27 @@
+/**
+ * Stringifies object into the following format:
+ *
+ * `prop1=value prop2=value prop3.key1=value prop3.key2=value prop4.key1=[value1, value2]`
+ *
+ * This is useful for logging and debugging.
+ */
+export const stringifyObject = (obj: object, prefix = ''): string => {
+  const entries: string[] = []
+
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix !== '' ? `${prefix}.${key}` : key
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      // Recursively stringify nested objects with dot notation
+      entries.push(stringifyObject(value, fullKey))
+    } else if (Array.isArray(value)) {
+      // Arrays get converted to comma-separated values
+      entries.push(`${fullKey}=${value.join(',')}`)
+    } else {
+      // Primitive values
+      entries.push(`${fullKey}=${value}`)
+    }
+  }
+
+  return entries.join(' ')
+}