@livestore/utils 0.4.0-dev.8 → 0.4.0

package/src/node/ChildProcessRunner/ChildProcessWorker.ts

@@ -1,4 +1,5 @@
 import type * as ChildProcess from 'node:child_process'
+
 import * as Worker from '@effect/platform/Worker'
 import { WorkerError } from '@effect/platform/WorkerError'
 import * as Deferred from 'effect/Deferred'
@@ -14,7 +15,7 @@ const childProcesses = new Set<ChildProcess.ChildProcess>()
 const forceCleanupChildren = (signal: NodeJS.Signals = 'SIGKILL') => {
   for (const child of childProcesses) {
     try {
-      if (!child.killed) {
+      if (child.killed === false) {
         child.kill(signal)
       }
     } catch {
@@ -28,7 +29,7 @@ const forceCleanupChildren = (signal: NodeJS.Signals = 'SIGKILL') => {
 let signalHandlersInstalled = false
 
 const installSignalHandlers = () => {
-  if (signalHandlersInstalled) return
+  if (signalHandlersInstalled === true) return
   signalHandlersInstalled = true
 
   // Use 'beforeExit' instead of signal handlers since tests may interfere with signals
@@ -95,14 +96,14 @@ const platformWorkerImpl = Worker.makePlatform<ChildProcess.ChildProcess>()({
             Effect.catchAllCause(() =>
               Effect.sync(() => {
                 // Enhanced cleanup with escalating signals
-                if (!childProcess.killed) {
+                if (childProcess.killed === false) {
                   try {
                     // First try SIGTERM
                     childProcess.kill('SIGTERM')
 
                     // If still running after a short delay, use SIGKILL
                     setTimeout(() => {
-                      if (!childProcess.killed) {
+                      if (childProcess.killed === false) {
                         childProcess.kill('SIGKILL')
                       }
                     }, 1000)

package/src/node/mod.ts

@@ -1,8 +1,9 @@
 import * as http from 'node:http'
 
+import { layer as ParcelWatcherLayer } from '@effect/platform-node/NodeFileSystem/ParcelWatcher'
 import { Effect, Layer } from 'effect'
 
-import { OtelTracer, UnknownError } from '../effect/index.ts'
+import { OtelTracer, UnknownError } from '../effect/mod.ts'
 import { makeNoopTracer } from '../NoopTracer.ts'
 
 export * as Cli from '@effect/cli'
@@ -28,7 +29,7 @@ export const getFreePort: Effect.Effect<number, UnknownError> = Effect.async<num
   server.listen(0, () => {
     const address = server.address()
 
-    if (address && typeof address === 'object') {
+    if (address !== null && typeof address === 'object') {
       const port = address.port
       server.close(() => cb(Effect.succeed(port)))
     } else {
@@ -51,3 +52,41 @@ export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend((
 
   return TracingLive
 })
+
+/**
+ * Layer that provides WatchBackend for recursive file watching via @parcel/watcher.
+ * This layer alone does NOT provide FileSystem - it only provides the watch backend.
+ *
+ * IMPORTANT: Layer ordering matters! When composing with NodeFileSystem.layer, use
+ * `NodeFileSystemWithWatch` instead, or ensure WatchBackend is available when FileSystem
+ * is constructed by using `Layer.provideMerge`:
+ *
+ * ```ts
+ * // ✅ CORRECT: Use the pre-composed layer
+ * Effect.provide(NodeFileSystemWithWatch)
+ *
+ * // ✅ CORRECT: Manual composition with Layer.provideMerge
+ * const layer = PlatformNode.NodeFileSystem.layer.pipe(Layer.provideMerge(NodeRecursiveWatchLayer))
+ * Effect.provide(layer)
+ *
+ * // ❌ WRONG: Chained Effect.provide - WatchBackend won't be used!
+ * Effect.provide(NodeRecursiveWatchLayer).pipe(Effect.provide(PlatformNode.NodeFileSystem.layer))
+ * ```
+ *
+ * @see https://github.com/Effect-TS/effect/issues/5913
+ */
+export const NodeRecursiveWatchLayer = ParcelWatcherLayer
+
+/**
+ * Pre-composed layer providing FileSystem with recursive file watching via @parcel/watcher.
+ * This is the recommended way to get a FileSystem that supports recursive watching.
+ *
+ * Use this layer when you need to watch files recursively (e.g., watching nested directories).
+ * Without recursive watching, Node.js's built-in fs.watch only detects changes in the
+ * immediate directory, not in subdirectories.
+ */
+export { NodeFileSystem } from '@effect/platform-node'
+
+import { NodeFileSystem } from '@effect/platform-node'
+
+export const NodeFileSystemWithWatch = NodeFileSystem.layer.pipe(Layer.provideMerge(ParcelWatcherLayer))

package/src/object/index.ts

@@ -22,4 +22,4 @@ export const keyObjectFromObject = <TObj extends Record<string, any>>(obj: TObj)
   pipe(
     objectEntries(obj).map(([k]) => [k, k]),
     Object.fromEntries,
-  ) as any
+  )

package/src/object/omit.ts

@@ -9,7 +9,7 @@ export const omit = <Obj extends Record<string, any>, Keys extends keyof Obj>(
   keys: Keys[],
 ): Omit<Obj, Keys> => {
   return Object.keys(obj).reduce((acc, key: any) => {
-    if (!keys.includes(key)) {
+    if (keys.includes(key) === false) {
       acc[key] = (obj as any)[key]
     }
     return acc

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest'
+
 import { stringifyObject } from './stringify-object.ts'
 
 describe('stringifyObject', () => {

package/src/object/stringify-object.ts

@@ -11,10 +11,10 @@ export const stringifyObject = (obj: object, prefix = ''): string => {
   for (const [key, value] of Object.entries(obj)) {
     const fullKey = prefix !== '' ? `${prefix}.${key}` : key
 
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+    if (typeof value === 'object' && value !== null && Array.isArray(value) === false) {
       // Recursively stringify nested objects with dot notation
       entries.push(stringifyObject(value, fullKey))
-    } else if (Array.isArray(value)) {
+    } else if (Array.isArray(value) === true) {
       // Arrays get converted to comma-separated values
       entries.push(`${fullKey}=${value.join(',')}`)
     } else {

package/src/qr.ts

@@ -0,0 +1,125 @@
+import qrcode from 'qrcode-generator'
+
+export { default as QR } from 'qrcode-generator'
+
+export type QRErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H'
+
+export type PrintQrTerminalOptions = {
+  errorCorrectionLevel?: QRErrorCorrectionLevel
+  /** number of white-cell rows/cols around the QR (default 2) */
+  margin?: number
+  /** Swap dark/light rendering (default false) */
+  invert?: boolean
+  /** Use ANSI colors for compact half-block rendering. Default: auto (true on TTY) */
+  useAnsi?: boolean
+}
+
+/**
+ * Print a QR code to the terminal using Unicode block characters.
+ *
+ * Notes
+ * - Uses `qrcode-generator` under the hood. `typeNumber` is set to `0` which means
+ *   “auto-select the smallest QR version (1..40) that fits the data”. Larger versions
+ *   create larger matrices (each version adds 4 modules per side). See the library:
+ *   - Types (TypeNumber, ErrorCorrectionLevel):
+ *     https://unpkg.com/qrcode-generator@2.0.4/dist/qrcode.d.ts
+ *   - Repository / README:
+ *     https://github.com/kazuhikoarase/qrcode-generator
+ * - Error correction level (ECL) controls how much damage/occlusion can be
+ *   tolerated by adding redundancy. Higher ECL means bigger codes and lower
+ *   payload capacity:
+ *   - L ≈ 7% recovery (highest capacity, lowest redundancy)
+ *   - M ≈ 15% recovery (balanced, common default)
+ *   - Q ≈ 25% recovery (more robust in noisy/low-contrast prints)
+ *   - H ≈ 30% recovery (most robust; largest symbols)
+ *   Reference: https://www.qrcode.com/en/about/error_correction.html
+ * - `small` mode compresses two QR rows into one terminal row using the half-block
+ *   character `▀` and optional ANSI colors (foreground=top, background=bottom).
+ *   This roughly halves the height while keeping readability in modern terminals.
+ * - The QR “quiet zone” (margin) is important for scanners. If scanning is unreliable,
+ *   consider increasing `margin` to 2–4.
+ */
+export const printQrTerminal = (text: string, options?: PrintQrTerminalOptions): void => {
+  const ec: QRErrorCorrectionLevel = options?.errorCorrectionLevel ?? 'M'
+  const margin = options?.margin ?? 2
+  const invert = options?.invert ?? false
+  // Auto-enable ANSI on TTY; avoid in browsers
+  const useAnsi = options?.useAnsi ?? (typeof process !== 'undefined' && !!(process as any)?.stdout?.isTTY)
+
+  // Create the QR code. `0` means: choose the smallest possible version automatically.
+  // Error correction level (L/M/Q/H) trades capacity for redundancy.
+  const qr = qrcode(0, ec)
+  qr.addData(text)
+  qr.make()
+
+  const size = qr.getModuleCount()
+
+  // Helper: read a module, applying margin and optional inversion.
+  // qrcode-generator’s `isDark` signature is (row, col) i.e. (y, x).
+  const isDarkAt = (x: number, y: number): boolean => {
+    const row = y - margin
+    const col = x - margin
+    if (row < 0 || col < 0 || row >= size || col >= size) return false
+    const bit = qr.isDark(row, col)
+    return invert === true ? !bit : bit
+  }
+
+  const lines: string[] = []
+
+  // Compact rendering: combine two QR rows into one terminal row using half-blocks.
+  // With ANSI enabled: use `▀` and paint top as FG, bottom as BG (clear and crisp).
+  // Without ANSI: fall back to block chars (`█`, `▀`, `▄`, space). Note that the
+  // non-ANSI fallback cannot enforce a white background on dark themes, which may
+  // reduce scanner reliability—prefer ANSI when possible.
+  const width = size + 2 * margin
+  const height = size + 2 * margin
+
+  // ANSI helpers (only used when enabled)
+  // Use bright white for a strong “paper-like” background on dark terminals.
+  const RESET = '\x1b[0m'
+  const FG_BLACK = '\x1b[30m'
+  const FG_WHITE = '\x1b[97m'
+  const BG_BLACK = '\x1b[40m'
+  const BG_WHITE = '\x1b[107m'
+
+  for (let y = 0; y < height; y += 2) {
+    let row = ''
+    let currentStyle = ''
+    const setStyle = (style: string) => {
+      if (style !== currentStyle) {
+        if (currentStyle !== undefined) row += RESET
+        if (style !== undefined) row += style
+        currentStyle = style
+      }
+    }
+
+    for (let x = 0; x < width; x++) {
+      const top = isDarkAt(x, y)
+      const bottom = isDarkAt(x, y + 1)
+
+      if (useAnsi === true) {
+        // Represent two stacked modules with a single `▀` character.
+        // Foreground corresponds to the top pixel; background to the bottom pixel.
+        // Always paint both halves to enforce a white quiet zone even on dark terminals.
+        const fg = top === true ? FG_BLACK : FG_WHITE
+        const bg = bottom === true ? BG_BLACK : BG_WHITE
+        setStyle(fg + bg)
+        row += '▀'
+      } else {
+        // No ANSI: approximate using block characters.
+        let ch = ' '
+        if (top === true && bottom === true) ch = '█'
+        else if (top === true && bottom === false) ch = '▀'
+        else if (top === false && bottom === true) ch = '▄'
+        row += ch
+      }
+    }
+
+    if (useAnsi === true) {
+      if (currentStyle !== undefined) row += RESET
+    }
+    lines.push(row)
+  }
+
+  console.log(lines.join('\n'))
+}

package/src/set.ts

@@ -1,7 +1,7 @@
 export const difference = <T>(a: Set<T>, b: Set<T>) => {
   const diff = new Set<T>()
   for (const item of a) {
-    if (!b.has(item)) {
+    if (b.has(item) === false) {
       diff.add(item)
     }
   }

package/src/time.ts

@@ -17,7 +17,7 @@ export const msAsTimeString = (ms: number) => {
   const remainingSeconds = (seconds % 60).toString().padStart(2, '0')
   const remainingMinutes = hours > 0 ? (minutes % 60).toString().padStart(2, '0') : minutes % 60
 
-  const timeString = [hours > 0 ? `${hours}:` : '', `${remainingMinutes}:`, `${remainingSeconds}`]
+  const timeString = [hours > 0 ? `${hours}:` : '', `${remainingMinutes}:`, remainingSeconds]
     .filter((val) => val !== '')
     .join('')