@livestore/utils 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/cuid/cuid.browser.ts

@@ -0,0 +1,95 @@
+/* eslint-disable unicorn/prefer-global-this */
+/**
+ * Based on:
+ *
+ * cuid.js
+ * Collision-resistant UID generator for browsers and node.
+ * Sequential for fast db lookups and recency sorting.
+ * Safe for element IDs and server-side lookups.
+ *
+ * Extracted from CLCTR
+ *
+ * Copyright (c) Eric Elliott 2012
+ * MIT License
+ */
+
+const lim = Math.pow(2, 32) - 1
+
+const crypto = globalThis.crypto
+
+const getRandomValue = () => {
+  return Math.abs(crypto.getRandomValues(new Uint32Array(1))[0]! / lim)
+}
+
+const pad = (num: number | string, size: number) => {
+  const s = '000000000' + num
+  return s.slice(s.length - size)
+}
+
+const env = typeof window === 'object' ? window : self
+const globalCount = Object.keys(env).length
+
+// To make it work in React Native https://github.com/paralleldrive/cuid/issues/54#issuecomment-222957293
+const clientId =
+  navigator.product === 'ReactNative'
+    ? 'rn'
+    : pad(navigator.userAgent.length.toString(36) + globalCount.toString(36), 4)
+
+const fingerprint = () => clientId
+
+let c = 0
+const blockSize = 4
+const base = 36
+const discreteValues = Math.pow(base, blockSize)
+
+const randomBlock = () => {
+  return pad(Math.trunc(getRandomValue() * discreteValues).toString(base), blockSize)
+}
+
+const safeCounter = () => {
+  c = c < discreteValues ? c : 0
+  c++ // this is not subliminal
+  return c - 1
+}
+
+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()
+
+  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)
+
+  return date.slice(-2) + counter + print + random
+}
+
+export const isCuid = (stringToCheck: string) => {
+  if (typeof stringToCheck !== 'string') return false
+  if (stringToCheck.startsWith('c')) return true
+  return false
+}
+
+export const isSlug = (stringToCheck: string) => {
+  if (typeof stringToCheck !== 'string') return false
+  const stringLength = stringToCheck.length
+  if (stringLength >= 7 && stringLength <= 10) return true
+  return false
+}

package/src/cuid/cuid.node.ts

@@ -0,0 +1,103 @@
+/**
+ * Based on:
+ *
+ * cuid.js
+ * Collision-resistant UID generator for browsers and node.
+ * Sequential for fast db lookups and recency sorting.
+ * Safe for element IDs and server-side lookups.
+ *
+ * Extracted from CLCTR
+ *
+ * Copyright (c) Eric Elliott 2012
+ * MIT License
+ */
+
+import crypto from 'node:crypto'
+import os from 'node:os'
+
+const lim = Math.pow(2, 32) - 1
+
+const getRandomValue = () => {
+  return Math.abs(crypto.randomBytes(4).readInt32BE() / lim)
+}
+
+const pad = (num: number | string, size: number) => {
+  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,
+    )
+
+  return pid + hostId
+}
+
+let c = 0
+const blockSize = 4
+const base = 36
+const discreteValues = Math.pow(base, blockSize)
+
+const randomBlock = () => {
+  return pad(Math.trunc(getRandomValue() * discreteValues).toString(base), blockSize)
+}
+
+const safeCounter = () => {
+  c = c < discreteValues ? c : 0
+  c++ // this is not subliminal
+  return c - 1
+}
+
+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()
+
+  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)
+
+  return date.slice(-2) + counter + print + random
+}
+
+export const isCuid = (stringToCheck: string) => {
+  if (typeof stringToCheck !== 'string') return false
+  if (stringToCheck.startsWith('c')) return true
+  return false
+}
+
+export const isSlug = (stringToCheck: string) => {
+  if (typeof stringToCheck !== 'string') return false
+  const stringLength = stringToCheck.length
+  if (stringLength >= 7 && stringLength <= 10) return true
+  return false
+}

package/src/effect/Effect.ts

@@ -0,0 +1,180 @@
+import * as OtelTracer from '@effect/opentelemetry/Tracer'
+import type { Context, Duration, Scope } from 'effect'
+import { Cause, Deferred, Effect, Fiber, pipe } from 'effect'
+import type { UnknownException } from 'effect/Cause'
+import { log } from 'effect/Console'
+import type { LazyArg } from 'effect/Function'
+
+import { isNonEmptyString, isPromise } from '../index.js'
+import { UnknownError } from './Error.js'
+
+export * from 'effect/Effect'
+
+// export const log = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
+//   Effect.sync(() => {
+//     console.log(message, ...rest)
+//   })
+
+// export const logWarn = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
+//   Effect.sync(() => {
+//     console.warn(message, ...rest)
+//   })
+
+// export const logError = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
+//   Effect.sync(() => {
+//     console.error(message, ...rest)
+//   })
+
+export const tryAll = <Res>(
+  fn: () => Res,
+): Res extends Effect.Effect<infer A, infer E, never>
+  ? Effect.Effect<A, E | UnknownException, never>
+  : Res extends Promise<infer A>
+    ? Effect.Effect<A, UnknownException, never>
+    : Effect.Effect<Res, UnknownException, never> =>
+  Effect.try(() => fn()).pipe(
+    Effect.andThen((fnRes) =>
+      Effect.isEffect(fnRes)
+        ? (fnRes as any as Effect.Effect<any>)
+        : isPromise(fnRes)
+          ? Effect.promise(() => fnRes)
+          : Effect.succeed(fnRes),
+    ),
+  ) as any
+
+const getThreadName = () => {
+  // @ts-expect-error TODO fix types
+  const globalName = globalThis.name
+  return isNonEmptyString(globalName)
+    ? globalName
+    : // eslint-disable-next-line unicorn/prefer-global-this
+      typeof window === 'object'
+      ? 'Browser Main Thread'
+      : 'unknown-thread'
+}
+
+export const acquireReleaseLog = (label: string) =>
+  Effect.acquireRelease(Effect.log(`${label} acquire`), (_, ex) => Effect.log(`${label} release`, ex))
+
+export const logBefore =
+  (...msgs: any[]) =>
+  <A, E, R>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.andThen(Effect.log(...msgs), eff)
+
+/** Logs both on errors and defects */
+export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.tapErrorCause(eff, (cause) =>
+    Effect.gen(function* () {
+      if (Cause.isInterruptedOnly(cause)) {
+        // console.log('interrupted', Cause.pretty(err), err)
+        return
+      }
+
+      const span = yield* OtelTracer.currentOtelSpan.pipe(
+        Effect.catchTag('NoSuchElementException', (_) => Effect.succeed(undefined)),
+      )
+
+      const threadName = getThreadName()
+      const firstErrLine = cause.toString().split('\n')[0]
+      yield* Effect.logError(`Error on ${threadName}: ${firstErrLine}`, cause).pipe((_) =>
+        span === undefined
+          ? _
+          : Effect.annotateLogs({ spanId: span.spanContext().spanId, traceId: span.spanContext().traceId })(_),
+      )
+    }),
+  )
+
+export const logWarnIfTakesLongerThan =
+  ({ label, duration }: { label: string; duration: Duration.DurationInput }) =>
+  <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.gen(function* () {
+      const runtime = yield* Effect.runtime<never>()
+
+      let timedOut = false
+
+      const timeoutFiber = Effect.sleep(duration).pipe(
+        Effect.tap(() => {
+          timedOut = true
+          // TODO include span info
+          return Effect.logWarning(`${label}: Took longer than ${duration}ms`)
+        }),
+        Effect.provide(runtime),
+        Effect.runFork,
+      )
+
+      const start = Date.now()
+      const res = yield* eff
+
+      if (timedOut) {
+        const end = Date.now()
+        yield* Effect.logWarning(`${label}: Actual duration: ${end - start}ms`)
+      }
+
+      yield* Fiber.interrupt(timeoutFiber)
+
+      return res
+    })
+
+export const logDuration =
+  (label: string) =>
+  <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.gen(function* () {
+      const start = Date.now()
+      const res = yield* eff
+      const end = Date.now()
+      yield* Effect.log(`${label}: ${end - start}ms`)
+      return res
+    })
+
+export const tapSync =
+  <A>(tapFn: (a: A) => unknown) =>
+  <R, E>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.tap(eff, (a) => Effect.sync(() => tapFn(a)))
+
+export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>> =>
+  pipe(
+    Effect.context<never>(),
+    Effect.tap((env) => log(msg ?? 'debugLogEnv', env)),
+  )
+
+export const timeoutDie =
+  <E1>(options: { onTimeout: LazyArg<E1>; duration: Duration.DurationInput }) =>
+  <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.orDie(Effect.timeoutFail(options)(self))
+
+export const timeoutDieMsg =
+  (options: { error: string; duration: Duration.DurationInput }) =>
+  <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.orDie(
+      Effect.timeoutFail({ onTimeout: () => new UnknownError({ cause: options.error }), duration: options.duration })(
+        self,
+      ),
+    )
+
+export const toForkedDeferred = <R, E, A>(
+  eff: Effect.Effect<A, E, R>,
+): Effect.Effect<Deferred.Deferred<A, E>, never, R | Scope.Scope> =>
+  pipe(
+    Deferred.make<A, E>(),
+    Effect.tap((deferred) =>
+      pipe(
+        Effect.exit(eff),
+        Effect.flatMap((ex) => Deferred.done(deferred, ex)),
+        tapCauseLogPretty,
+        Effect.forkScoped,
+      ),
+    ),
+  )
+
+export const withPerformanceMeasure =
+  (meaureLabel: string) =>
+  <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.acquireUseRelease(
+      Effect.sync(() => performance.mark(`${meaureLabel}:start`)),
+      () => eff,
+      () =>
+        Effect.sync(() => {
+          performance.mark(`${meaureLabel}:end`)
+          performance.measure(meaureLabel, `${meaureLabel}:start`, `${meaureLabel}:end`)
+        }),
+    )

package/src/effect/Error.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'effect'
+
+export class UnknownError extends Schema.TaggedError<'UnknownError'>()('UnknownError', {
+  cause: Schema.Any,
+  payload: Schema.optional(Schema.Any),
+}) {}

package/src/effect/Schedule.ts

@@ -0,0 +1,10 @@
+import { Duration, pipe, Schedule } from 'effect'
+
+export * from 'effect/Schedule'
+
+export const exponentialBackoff10Sec: Schedule.Schedule<Duration.DurationInput> = pipe(
+  Schedule.exponential(Duration.millis(10), 4), // 10ms, 40ms, 160ms, 640ms, 2560ms, ...
+  Schedule.andThenEither(Schedule.spaced(Duration.seconds(1))),
+  Schedule.compose(Schedule.elapsed),
+  Schedule.whileOutput(Duration.lessThanOrEqualTo(Duration.seconds(10))), // max 10 seconds
+)

package/src/effect/Scheduler.ts

@@ -0,0 +1,14 @@
+export * from 'effect/Scheduler'
+
+import { Scheduler } from 'effect'
+
+// Based on https://github.com/astoilkov/main-thread-scheduling/blob/4b99c26ab96781bc35a331f5c225ad9c8a62cb95/src/utils/waitNextTask.ts#L25
+export const messageChannel = (shouldYield: Scheduler.Scheduler['shouldYield'] = Scheduler.defaultShouldYield) =>
+  Scheduler.makeBatched((task) => {
+    const messageChannel = new MessageChannel()
+
+    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

@@ -0,0 +1,102 @@
+import { Schema } from 'effect'
+import { describe, expect, test } from 'vitest'
+
+import type { DiffItem } from './debug-diff.js'
+import { debugDiff } from './debug-diff.js'
+
+describe('debug-diff', () => {
+  test('simple object', () => {
+    const schema = Schema.Struct({
+      a: Schema.String,
+      b: Schema.Number,
+    })
+
+    const a = { a: 'hello', b: 1 }
+    const b = { a: 'world', b: 2 }
+
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": "hello",
+          "b": "world",
+          "path": ".a",
+        },
+        {
+          "a": 1,
+          "b": 2,
+          "path": ".b",
+        },
+      ]
+    `)
+  })
+
+  test('simple object with nested object', () => {
+    const schema = Schema.Struct({
+      a: Schema.String,
+      b: Schema.Struct({
+        c: Schema.Number,
+      }),
+    })
+    const a = { a: 'hello', b: { c: 1 } }
+    const b = { a: 'world', b: { c: 2 } }
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": "hello",
+          "b": "world",
+          "path": ".a",
+        },
+        {
+          "a": 1,
+          "b": 2,
+          "path": ".b.c",
+        },
+      ]
+    `)
+  })
+
+  test('union', () => {
+    const schema = Schema.Union(Schema.String, Schema.Number)
+    const a = 'hello'
+    const b = 1
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": "hello",
+          "b": 1,
+          "path": "",
+        },
+      ]
+    `)
+  })
+
+  test('tagged union', () => {
+    const schema = Schema.Union(
+      Schema.Struct({ _tag: Schema.Literal('a'), a: Schema.String }),
+      Schema.Struct({ _tag: Schema.Literal('b'), b: Schema.Number }),
+    )
+    const a = { _tag: 'a', a: 'hello' } as const
+    const b = { _tag: 'b', b: 1 } as const
+    const diff = debugDiff(schema)(a, b)
+    expect(trimAst(diff)).toMatchInlineSnapshot(`
+      [
+        {
+          "a": {
+            "_tag": "a",
+            "a": "hello",
+          },
+          "b": {
+            "_tag": "b",
+            "b": 1,
+          },
+          "path": "",
+        },
+      ]
+    `)
+  })
+})
+
+const trimAst = (diffItems: DiffItem[]) => diffItems.map(({ ast: _ast, ...rest }) => rest)

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

@@ -0,0 +1,58 @@
+import { Schema, SchemaAST } from 'effect'
+
+export type DiffItem = {
+  path: string
+  a: any
+  b: any
+  ast: SchemaAST.AST
+}
+
+/**
+ * Diffs two values for a given schema and traverses downwards and returns a list of differences.
+ */
+export const debugDiff =
+  <A, I, R>(base: Schema.Schema<A, I, R>) =>
+  (a: A, b: A): DiffItem[] => {
+    const bag = [] as DiffItem[]
+    debugDiffImpl(base.ast, a, b, '', bag)
+    return bag
+  }
+
+const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: DiffItem[]) => {
+  const eq = Schema.equivalence({ ast } as any)
+  if (eq(a, b) === false) {
+    // bag.push({ path, a, b, ast })
+
+    if (SchemaAST.isUnion(ast)) {
+      if (isTaggedUnion(ast)) {
+        bag.push({ path, a, b, ast })
+        return
+      } else {
+        for (const type of ast.types) {
+          try {
+            debugDiffImpl(type, a, b, path, bag)
+            return
+          } catch {}
+        }
+      }
+    } else if (SchemaAST.isTypeLiteral(ast)) {
+      const props = SchemaAST.getPropertySignatures(ast)
+      for (const prop of props) {
+        debugDiffImpl(prop.type, a[prop.name], b[prop.name], `${path}.${prop.name.toString()}`, bag)
+      }
+    } else {
+      // debugger
+      bag.push({ path, a, b, ast })
+    }
+  }
+}
+
+const isTaggedUnion = (ast: SchemaAST.AST) => {
+  if (SchemaAST.isUnion(ast)) {
+    return ast.types.every((type) => {
+      if (SchemaAST.isTypeLiteral(type) === false) return false
+      const props = SchemaAST.getPropertySignatures(type)
+      return props.some((prop) => prop.name.toString() === '_tag')
+    })
+  }
+}

package/src/effect/Schema/index.ts

@@ -0,0 +1,58 @@
+import { Transferable } from '@effect/platform'
+import { Effect, Hash, ParseResult, Schema } from 'effect'
+import type { ParseError } from 'effect/ParseResult'
+import type { ParseOptions } from 'effect/SchemaAST'
+
+export * from 'effect/Schema'
+export * from './debug-diff.js'
+export * from './msgpack.js'
+
+// NOTE this is a temporary workaround until Effect schema has a better way to hash schemas
+// https://github.com/Effect-TS/effect/issues/2719
+// TODO remove this once the issue is resolved
+export const hash = (schema: Schema.Schema<any>) => {
+  try {
+    return Hash.string(JSON.stringify(schema.ast, null, 2))
+  } catch {
+    console.warn(
+      `Schema hashing failed, falling back to hashing the shortend schema AST string. This is less reliable and may cause false positives.`,
+    )
+    return Hash.hash(schema.ast.toString())
+  }
+}
+
+export const encodeWithTransferables =
+  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) =>
+  (a: A, overrideOptions?: ParseOptions | undefined): Effect.Effect<[I, Transferable[]], ParseError, R> =>
+    Effect.gen(function* () {
+      const collector = yield* Transferable.makeCollector
+
+      const encoded: I = yield* Schema.encode(schema, options)(a, overrideOptions).pipe(
+        Effect.provideService(Transferable.Collector, collector),
+      )
+
+      return [encoded, collector.unsafeRead() as Transferable[]]
+    })
+
+export const swap = <A, I, R>(schema: Schema.Schema<A, I, R>): Schema.Schema<I, A, R> =>
+  Schema.transformOrFail(Schema.typeSchema(schema), Schema.encodedSchema(schema), {
+    decode: ParseResult.encode(schema),
+    encode: ParseResult.decode(schema),
+  })
+
+export const Base64FromUint8Array: Schema.Schema<string, Uint8Array> = swap(Schema.Uint8ArrayFromBase64)
+
+export interface JsonArray extends ReadonlyArray<JsonValue> {}
+export interface JsonObject {
+  [key: string]: JsonValue
+}
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray
+
+export const JsonValue: Schema.Schema<JsonValue> = Schema.Union(
+  Schema.String,
+  Schema.Number,
+  Schema.Boolean,
+  Schema.Null,
+  Schema.Array(Schema.suspend(() => JsonValue)),
+  Schema.Record({ key: Schema.String, value: Schema.suspend(() => JsonValue) }),
+)

package/src/effect/Schema/msgpack.ts

@@ -0,0 +1,8 @@
+import { Schema } from 'effect'
+import * as msgpack from 'msgpackr'
+
+export const MsgPack = <A, I>(schema: Schema.Schema<A, I>) =>
+  Schema.transform(Schema.Uint8ArrayFromSelf, schema, {
+    encode: (decoded) => msgpack.pack(decoded),
+    decode: (encodedBytes) => msgpack.unpack(encodedBytes),
+  })