@livestore/utils 0.3.1 → 0.3.2-dev.1

package/src/index.ts

@@ -1,22 +1,22 @@
-export * from './string.js'
-export * from './guards.js'
-export * from './object/index.js'
-export * from './promise.js'
-export * from './time.js'
-export * from './NoopTracer.js'
-export * from './set.js'
-export * from './browser.js'
-export * from './Deferred.js'
-export * from './misc.js'
-export * from './env.js'
-export * from './fast-deep-equal.js'
-export * as base64 from './base64.js'
 export { default as prettyBytes } from 'pretty-bytes'
+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
 
@@ -53,6 +53,7 @@ export const debugCatch = <T>(try_: () => T): T => {
   try {
     return try_()
   } catch (e: any) {
+    // biome-ignore lint/suspicious/noDebugger: debugging
     debugger
     throw e
   }
@@ -72,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] =>
@@ -85,33 +91,37 @@ 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
   throw new Error(`A case was not handled for value: ${truncate(objectToString(unexpectedCase), 1000)}`)
 }
 
 export const assertNever = (failIfFalse: boolean, msg?: string): void => {
   if (failIfFalse === false) {
+    // biome-ignore lint/suspicious/noDebugger: debugging
     debugger
     throw new Error(`This should never happen: ${msg}`)
   }
 }
 
 export const debuggerPipe = <T>(val: T): T => {
+  // biome-ignore lint/suspicious/noDebugger: debugging
   debugger
   return val
 }
 
 const truncate = (str: string, length: number): string => {
   if (str.length > length) {
-    return str.slice(0, length) + '...'
+    return `${str.slice(0, length)}...`
   } else {
     return str
   }
 }
 
 export const notYetImplemented = (msg?: string): never => {
+  // biome-ignore lint/suspicious/noDebugger: debugging
   debugger
   throw new Error(`Not yet implemented: ${msg}`)
 }
@@ -223,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/misc.ts

@@ -26,7 +26,7 @@ export const objectToString = (error: any): string => {
   } catch (e: any) {
     console.log(error)
 
-    return 'Error while printing error: ' + e
+    return `Error while printing error: ${e}`
   }
 }
 
@@ -37,8 +37,7 @@ 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) {
+  } catch (_e) {
     // @ts-expect-error try out as function
     return fnOrConstructor(arg)
   }
@@ -50,6 +49,7 @@ export const envTruish = (env: string | undefined) =>
 export const shouldNeverHappen = (msg?: string, ...args: any[]): never => {
   console.error(msg, ...args)
   if (isDevEnv()) {
+    // biome-ignore lint/suspicious/noDebugger: debugging
     debugger
   }
 

package/src/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -1,4 +1,3 @@
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
 import process from 'node:process'
 
 import { WorkerError } from '@effect/platform/WorkerError'
@@ -30,6 +29,7 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
         Effect.sync(() => port.postMessage([1, message] /*, transfers as any*/))
 
       const run = Effect.fnUntraced(function* <A, E, R>(
+        // biome-ignore lint/suspicious/noConfusingVoidType: need to support void
         handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void,
       ) {
         const runtime = (yield* Effect.interruptible(Effect.runtime<R | Scope.Scope>())).pipe(

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/ChildProcessRunner/ChildProcessWorker.ts

@@ -1,9 +1,6 @@
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
-
+import type * as ChildProcess from 'node:child_process'
 import * as Worker from '@effect/platform/Worker'
 import { WorkerError } from '@effect/platform/WorkerError'
-// eslint-disable-next-line unicorn/prefer-node-protocol
-import type * as ChildProcess from 'child_process'
 import * as Deferred from 'effect/Deferred'
 import * as Effect from 'effect/Effect'
 import * as Exit from 'effect/Exit'

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(' ')
+}