@livestore/utils 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/index.ts

@@ -0,0 +1,240 @@
+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 './fast-deep-equal.js'
+export * as base64 from './base64.js'
+export { default as prettyBytes } from 'pretty-bytes'
+
+import type * as otel from '@opentelemetry/api'
+
+import { objectToString } from './misc.js'
+
+export type Prettify<T> = T extends infer U ? { [K in keyof U]: Prettify<U[K]> } : never
+export type PrettifyFlat<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
+
+export type TypeEq<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
+
+/** `A` is subtype of `B` */
+export type IsSubtype<A, B> = A extends B ? true : false
+export type AssertTrue<T extends true> = T
+
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] }
+export type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]> }
+
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint
+
+export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>)
+
+export type GetValForKey<T, K> = K extends keyof T ? T[K] : never
+
+export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+export const ref = <T>(val: T): { current: T } => ({ current: val })
+
+export const times = (n: number, fn: (index: number) => {}): void => {
+  for (let i = 0; i < n; i++) {
+    fn(i)
+  }
+}
+
+export const debugCatch = <T>(try_: () => T): T => {
+  try {
+    return try_()
+  } catch (e: any) {
+    debugger
+    throw e
+  }
+}
+
+export const recRemoveUndefinedValues = (val: any): void => {
+  if (Array.isArray(val)) {
+    val.forEach(recRemoveUndefinedValues)
+  } else if (typeof val === 'object') {
+    Object.keys(val).forEach((key) => {
+      if (val[key] === undefined) {
+        delete val[key]
+      } else {
+        recRemoveUndefinedValues(val[key])
+      }
+    })
+  }
+}
+
+export const prop =
+  <T extends {}, K extends keyof T>(key: K) =>
+  (obj: T): T[K] =>
+    obj[key]
+
+export const capitalizeFirstLetter = (str: string): string => str.charAt(0).toUpperCase() + str.slice(1)
+
+export const isReadonlyArray = <I, T>(value: ReadonlyArray<I> | T): value is ReadonlyArray<I> => Array.isArray(value)
+
+/**
+ * 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 {
+  debugger
+  throw new Error(`A case was not handled for value: ${truncate(objectToString(unexpectedCase), 1000)}`)
+}
+
+export const shouldNeverHappen = (msg?: string, ...args: any[]): never => {
+  console.error(msg, ...args)
+  if (isDev()) {
+    debugger
+  }
+
+  throw new Error(`This should never happen: ${msg}`)
+}
+
+export const assertNever = (failIfFalse: boolean, msg?: string): void => {
+  if (failIfFalse === false) {
+    debugger
+    throw new Error(`This should never happen: ${msg}`)
+  }
+}
+
+export const debuggerPipe = <T>(val: T): T => {
+  debugger
+  return val
+}
+
+const truncate = (str: string, length: number): string => {
+  if (str.length > length) {
+    return str.slice(0, length) + '...'
+  } else {
+    return str
+  }
+}
+
+export const notYetImplemented = (msg?: string): never => {
+  debugger
+  throw new Error(`Not yet implemented: ${msg}`)
+}
+
+export const noop = () => {}
+
+export type Thunk<T> = () => T
+
+export const unwrapThunk = <T>(_: T | (() => T)): T => {
+  if (typeof _ === 'function') {
+    return (_ as any)()
+  } else {
+    return _
+  }
+}
+
+export type NullableFieldsToOptional<T> = PrettifyFlat<
+  Partial<T> & {
+    [K in keyof T as null extends T[K] ? K : never]?: Exclude<T[K], null>
+  } & {
+    [K in keyof T as null extends T[K] ? never : K]: T[K]
+  }
+>
+
+/** `end` is not included */
+export const range = (start: number, end: number): number[] => {
+  const length = end - start
+  return Array.from({ length }, (_, i) => start + i)
+}
+
+export const throttle = (fn: () => void, ms: number) => {
+  let shouldWait = false
+  let shouldCallAgain = false
+
+  const timeoutFunc = () => {
+    if (shouldCallAgain) {
+      fn()
+      shouldCallAgain = false
+      setTimeout(timeoutFunc, ms)
+    } else {
+      shouldWait = false
+    }
+  }
+
+  return () => {
+    if (shouldWait) {
+      shouldCallAgain = true
+      return
+    }
+
+    fn()
+    shouldWait = true
+    setTimeout(timeoutFunc, ms)
+  }
+}
+
+export const getTraceParentHeader = (parentSpan: otel.Span) => {
+  const spanContext = parentSpan.spanContext()
+  // Format: {version}-{trace_id}-{span_id}-{trace_flags}
+  // https://www.w3.org/TR/trace-context/#examples-of-http-traceparent-headers
+  return `00-${spanContext.traceId}-${spanContext.spanId}-01`
+}
+
+export const assertTag = <TObj extends { _tag: string }, TTag extends TObj['_tag']>(
+  obj: TObj,
+  tag: TTag,
+): Extract<TObj, { _tag: TTag }> => {
+  if (obj._tag !== tag) {
+    throw new Error(`Expected tag ${tag} but got ${obj._tag}`)
+  }
+
+  return obj as any
+}
+
+export const memoizeByStringifyArgs = <T extends (...args: any[]) => any>(fn: T): T => {
+  const cache = new Map<string, ReturnType<T>>()
+
+  return ((...args: any[]) => {
+    const key = JSON.stringify(args)
+    if (cache.has(key)) {
+      return cache.get(key)
+    }
+
+    const result = fn(...args)
+    cache.set(key, result)
+    return result
+  }) as any
+}
+
+export const memoizeByRef = <T extends (arg: any) => any>(fn: T): T => {
+  const cache = new Map<Parameters<T>[0], ReturnType<T>>()
+
+  return ((arg: any) => {
+    if (cache.has(arg)) {
+      return cache.get(arg)
+    }
+
+    const result = fn(arg)
+    cache.set(arg, result)
+    return result
+  }) as any
+}
+
+export const isNonEmptyString = (str: string | undefined | null): str is string => {
+  return typeof str === 'string' && str.length > 0
+}
+
+export const isPromise = (value: any): value is Promise<unknown> => typeof value?.then === 'function'
+
+export const isIterable = <T>(value: any): value is Iterable<T> => typeof value?.[Symbol.iterator] === 'function'
+
+export { objectToString as errorToString } from './misc.js'
+
+const isDev = memoizeByRef(() => {
+  if (import.meta.env !== undefined) {
+    return import.meta.env.DEV || import.meta.env.VITE_DEV
+  } else if (typeof process !== 'undefined' && process.env !== undefined) {
+    return process.env.DEV
+  } else {
+    return false
+  }
+})

package/src/misc.ts

@@ -0,0 +1,26 @@
+export const objectToString = (error: any): string => {
+  const str = error?.toString()
+  if (str !== '[object Object]') return str
+
+  try {
+    return JSON.stringify(error, null, 2)
+  } catch (e: any) {
+    console.log(error)
+
+    return 'Error while printing error: ' + e
+  }
+}
+
+export const tryAsFunctionAndNew = <TArg, TResult>(
+  fnOrConstructor: ((arg: TArg) => TResult) | (new (arg: TArg) => TResult),
+  arg: 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/nanoid/index.ts

@@ -0,0 +1 @@
+export { nanoid } from 'nanoid'

package/src/object/index.ts

@@ -0,0 +1,24 @@
+import { pipe } from 'effect'
+
+export * from './pick.js'
+export * from './omit.js'
+
+type ValueOfRecord<R extends Record<any, any>> = R extends Record<any, infer V> ? V : never
+
+export const mapObjectValues = <O_In extends Record<string, any>, V_Out>(
+  obj: O_In,
+  mapValue: (key: keyof O_In, val: ValueOfRecord<O_In>) => V_Out,
+): { [K in keyof O_In]: V_Out } => {
+  const mappedEntries = Object.entries(obj).map(([key, val]) => [key, mapValue(key as keyof O_In, val)] as const)
+  return Object.fromEntries(mappedEntries) as any
+}
+
+export type Entries<T> = { [K in keyof T]: [K, T[K]] }[keyof T][]
+
+export const objectEntries = <T extends Record<string, any>>(obj: T): Entries<T> => Object.entries(obj) as Entries<T>
+
+export const keyObjectFromObject = <TObj extends Record<string, any>>(obj: TObj): { [K in keyof TObj]: K } =>
+  pipe(
+    objectEntries(obj).map(([k]) => [k, k]),
+    Object.fromEntries,
+  ) as any

package/src/object/omit.ts

@@ -0,0 +1,17 @@
+// type ConvertUndefined<T> = OrUndefined<{ [K in keyof T as undefined extends T[K] ? K : never]-?: T[K] }>
+// type OrUndefined<T> = { [K in keyof T]: T[K] | undefined }
+// type PickRequired<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] }
+// type ConvertPick<T> = ConvertUndefined<T> & PickRequired<T>
+
+/** Returns a shallowly cloned object with the provided keys omitted */
+export const omit = <Obj extends Record<string, any>, Keys extends keyof Obj>(
+  obj: Obj,
+  keys: Keys[],
+): Omit<Obj, Keys> => {
+  return Object.keys(obj).reduce((acc, key: any) => {
+    if (!keys.includes(key)) {
+      acc[key] = (obj as any)[key]
+    }
+    return acc
+  }, {} as any)
+}

package/src/object/pick.ts

@@ -0,0 +1,27 @@
+type ConvertUndefined<T> = OrUndefined<{ [K in keyof T as undefined extends T[K] ? K : never]-?: T[K] }>
+type OrUndefined<T> = { [K in keyof T]: T[K] | undefined }
+type PickRequired<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] }
+type ConvertPick<T> = ConvertUndefined<T> & PickRequired<T>
+
+export const pick = <Obj, Keys extends keyof Obj>(obj: Obj, keys: Keys[]): ConvertPick<{ [K in Keys]: Obj[K] }> => {
+  return keys.reduce((acc, key) => {
+    acc[key] = obj[key]
+    return acc
+  }, {} as any)
+}
+
+export const pickAllOrElse = <Obj, Keys extends keyof Obj, TElse>(
+  obj: Obj,
+  keys: Keys[],
+  elseValue: TElse,
+): ConvertPick<{ [K in Keys]: NonNullable<Obj[K]> }> | TElse => {
+  const ret = {} as any
+  for (const key of keys) {
+    if (obj[key] === undefined) {
+      return elseValue
+    }
+    ret[key] = obj[key]
+  }
+
+  return ret
+}

package/src/promise.ts

@@ -0,0 +1,43 @@
+/** Promise.all + Array.map */
+export const promiseMap = <T, Res>(arr: T[], map: (el: T, index?: number) => Res | Promise<Res>) =>
+  Promise.all(arr.map(map))
+
+export const promiseMapDict = async <T, Res>(
+  dict: Record<string, T>,
+  map: (el: T, index?: number) => Res | Promise<Res>,
+): Promise<Record<string, Res>> => {
+  const mappedEntries = await Promise.all(Object.entries(dict).map(async ([key, val]) => [key, await map(val)]))
+  return Object.fromEntries(mappedEntries)
+}
+
+export const promiseMapToDict = async <T, Res>(
+  arr: T[],
+  mapValue: (el: T, index?: number) => Res | Promise<Res>,
+  mapKey: (el: T, index?: number) => string,
+): Promise<Record<string, Res>> => {
+  const mappedEntries = await Promise.all(arr.map(async (el, index) => [mapKey(el, index), await mapValue(el, index)]))
+
+  return Object.fromEntries(mappedEntries)
+}
+
+export const promiseMapPool = async <T, Res>(
+  arr: T[],
+  map: (el: T, index?: number) => Promise<Res>,
+  poolLimit: number,
+): Promise<Res[]> => {
+  const ret: Promise<Res>[] = []
+  const executing: Promise<Res>[] = []
+  for (const [index, item] of arr.entries()) {
+    const p = Promise.resolve().then(() => map(item, index))
+    ret.push(p)
+
+    if (poolLimit <= arr.length) {
+      const e: any = p.then(() => executing.splice(executing.indexOf(e), 1))
+      executing.push(e)
+      if (executing.length >= poolLimit) {
+        await Promise.race(executing)
+      }
+    }
+  }
+  return Promise.all(ret)
+}

package/src/set.ts

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

package/src/string.ts

@@ -0,0 +1,9 @@
+export const lowercaseFirstChar = (str: string) => str.charAt(0).toLowerCase() + str.slice(1)
+export const uppercaseFirstChar = (str: string) => str.charAt(0).toUpperCase() + str.slice(1)
+
+/** Indents a string each line by `n` characters (default: spaces) */
+export const indent = (str: string, n: number, char = ' '): string =>
+  str
+    .split('\n')
+    .map((line) => char.repeat(n) + line)
+    .join('\n')

package/src/time.ts

@@ -0,0 +1,25 @@
+export const minuteInMs = 1000 * 60
+
+export const time = {
+  ms: 1,
+  sec: 1000,
+  min: 60 * 1000,
+  hour: 60 * 60 * 1000,
+  day: 24 * 60 * 60 * 1000,
+  week: 7 * 24 * 60 * 60 * 1000,
+}
+
+/** Returns a string of format `m:ss` / `mm:ss` / `h:mm:ss` / ... */
+export const msAsTimeString = (ms: number) => {
+  const seconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+  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}`]
+    .filter((val) => val !== '')
+    .join('')
+
+  return timeString
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo.json"
+  },
+  "include": ["./src"],
+  "references": [{ "path": "../db-schema"}]
+}