@livestore/utils 0.0.0

package/src/effect/Otel/lib-tracer/TracerProvider.ts

@@ -0,0 +1,16 @@
+import * as Context from '@effect/data/Context'
+import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base'
+
+//
+// ets_tracing Provider
+//
+
+export const TracerProviderSymbol = Symbol.for('effect-otel/TracerProvider')
+export type TracerProviderSymbol = typeof TracerProviderSymbol
+
+export interface TracerProvider {
+  readonly [TracerProviderSymbol]: TracerProviderSymbol
+  readonly tracerProvider: BasicTracerProvider
+}
+
+export const TracerProvider = Context.Tag<TracerProvider>(TracerProviderSymbol)

package/src/effect/Otel/lib-tracer/WebProvider.ts

@@ -0,0 +1,48 @@
+import * as Context from '@effect/data/Context'
+import { identity, pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import type { WebTracerConfig } from '@opentelemetry/sdk-trace-web'
+import { WebTracerProvider } from '@opentelemetry/sdk-trace-web'
+
+import { TracerProvider, TracerProviderSymbol } from './TracerProvider.js'
+
+export const WebTracerProviderConfigSymbol = Symbol.for('effect-otel/WebTracerProviderConfig')
+type WebTracerProviderConfigSymbol = typeof WebTracerProviderConfigSymbol
+
+export interface WebTracerProviderConfig {
+  [WebTracerProviderConfigSymbol]: WebTracerProviderConfigSymbol
+
+  readonly config: WebTracerConfig
+}
+
+export const WebTracerProviderConfig = Context.Tag<WebTracerProviderConfig>(WebTracerProviderConfigSymbol)
+
+export const LiveWebTracerProviderConfig = (config: WebTracerConfig) =>
+  Layer.succeed(WebTracerProviderConfig, {
+    [WebTracerProviderConfigSymbol]: WebTracerProviderConfigSymbol,
+    config,
+  })
+
+export const makeWebTracingProvider = Effect.gen(function* ($) {
+  const ctx = yield* $(Effect.context<never>())
+
+  const config = pipe(
+    Context.getOption(ctx, WebTracerProviderConfig),
+    Option.map((_) => _.config),
+    Option.getOrUndefined,
+  )
+
+  const tracerProvider = yield* $(Effect.sync(() => new WebTracerProvider(config)))
+
+  return identity<TracerProvider>({
+    [TracerProviderSymbol]: TracerProviderSymbol,
+    tracerProvider,
+  })
+})
+
+export const WebProviderLayer = Layer.scoped(TracerProvider, makeWebTracingProvider)
+
+export const WebProvider = (config?: WebTracerConfig) =>
+  config ? Layer.provide(LiveWebTracerProviderConfig(config), WebProviderLayer) : WebProviderLayer

package/src/effect/Schedule.ts

@@ -0,0 +1,12 @@
+import * as Duration from '@effect/data/Duration'
+import { pipe } from '@effect/data/Function'
+import * as Schedule from '@effect/io/Schedule'
+
+export * from '@effect/io/Schedule'
+
+export const exponentialBackoff10Sec: Schedule.Schedule<never, unknown, 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/ServiceContext.ts

@@ -0,0 +1,116 @@
+import { pipe } from '@effect/data/Function'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+import * as Fiber from '@effect/io/Fiber'
+import * as Layer from '@effect/io/Layer'
+import type * as Runtime from '@effect/io/Runtime'
+import * as Scope from '@effect/io/Scope'
+
+export interface MainLayer<Ctx> {
+  layer: Layer.Layer<never, never, Ctx>
+  close: Effect.Effect<never, never, void>
+}
+
+export const unsafeMainLayer = <Ctx>(original: Layer.Layer<never, never, Ctx>): MainLayer<Ctx> => {
+  const scope = Effect.runSync(Scope.make())
+  const layer = pipe(
+    original,
+    Layer.memoize,
+    Effect.parallelFinalizers, // NOTE this runs the layer teardown in parallel
+    Effect.provideService(Scope.Scope, scope),
+    Effect.runSync,
+  )
+  return { layer, close: Scope.close(scope, Exit.unit) }
+}
+
+export const make = <TStaticData, Ctx>(
+  staticData: TStaticData,
+  runtime: Runtime.Runtime<Ctx>,
+  close: Effect.Effect<never, never, void> = Effect.dieMessage('close not implemented'),
+): ServiceContext<Ctx, TStaticData> => {
+  return {
+    provide: (self) => Effect.provideSomeRuntime(runtime)(self),
+    runWithErrorLog: <E, A>(self: Effect.Effect<Ctx, E, A>) =>
+      runWithErrorLog(Effect.provideSomeRuntime(runtime)(self)),
+    runSync: <E, A>(self: Effect.Effect<Ctx, E, A>) => Effect.runSync(Effect.provideSomeRuntime(runtime)(self)),
+    runPromiseWithErrorLog: <E, A>(self: Effect.Effect<Ctx, E, A>) =>
+      runPromiseWithErrorLog(Effect.provideSomeRuntime(runtime)(self)),
+    runPromiseExit: <E, A>(self: Effect.Effect<Ctx, E, A>) =>
+      Effect.runPromiseExit(Effect.provideSomeRuntime(runtime)(self)),
+    runPromise: <E, A>(self: Effect.Effect<Ctx, E, A>) => Effect.runPromise(Effect.provideSomeRuntime(runtime)(self)),
+    withRuntime: (fn) => fn(runtime),
+    close: close,
+    closePromise: () => Effect.runPromise(close),
+    staticData,
+  }
+}
+
+export interface ServiceContext<Ctx, TStaticData> {
+  readonly provide: <E, A>(self: Effect.Effect<Ctx, E, A>) => Effect.Effect<never, E, A>
+
+  /**
+   * Fire and Forget. Errors are logged however.
+   */
+  readonly runWithErrorLog: <E, A>(self: Effect.Effect<Ctx, E, A>) => AbortCallback
+
+  readonly runSync: <E, A>(self: Effect.Effect<Ctx, E, A>) => A
+
+  /**
+   * Fire and Forget. A promise that never fails nor returns any value.
+   * Errors are logged however.
+   */
+  readonly runPromiseWithErrorLog: <E, A>(self: Effect.Effect<Ctx, E, A>) => Promise<A | undefined>
+
+  /**
+   * A Promise that never fails, the Resolved value is an Exit result that can be either Success or Failed
+   */
+  readonly runPromiseExit: <E, A>(self: Effect.Effect<Ctx, E, A>) => Promise<Exit.Exit<E, A>>
+  readonly runPromise: <E, A>(self: Effect.Effect<Ctx, E, A>) => Promise<A>
+
+  readonly withRuntime: (fn: (runtime: Runtime.Runtime<Ctx>) => void) => void
+
+  /** Closes the ServiceContext and closing all its layers */
+  readonly close: Effect.Effect<never, never, void>
+  readonly closePromise: () => Promise<void>
+  readonly staticData: TStaticData
+}
+
+export type AbortCallback = () => void
+
+export const runWithErrorLog = <E, A>(self: Effect.Effect<never, E, A>) => {
+  const fiber = Effect.runFork(self)
+  fiber.unsafeAddObserver((ex) => {
+    if (ex._tag === 'Failure' && Cause.isInterruptedOnly(ex.cause) === false) {
+      console.error(Cause.pretty(ex.cause))
+    }
+  })
+  return () => {
+    Effect.runFork(Fiber.interrupt(fiber))
+  }
+}
+
+export const runPromiseWithErrorLog = <E, A>(self: Effect.Effect<never, E, A>) =>
+  Effect.runPromiseExit(self).then((ex) => {
+    if (ex._tag === 'Failure') {
+      console.error(Cause.pretty(ex.cause))
+      return undefined
+    } else {
+      return ex.value
+    }
+  })
+
+export const MissingContext = Effect.die('service context not provided, wrap your app in LiveServiceContext')
+
+export const empty = <Ctx, TStaticData>(): ServiceContext<Ctx, TStaticData> => ({
+  provide: () => MissingContext,
+  runWithErrorLog: () => runWithErrorLog(MissingContext),
+  runSync: () => Effect.runSync(MissingContext),
+  runPromiseWithErrorLog: () => runPromiseWithErrorLog(MissingContext),
+  runPromiseExit: () => Effect.runPromiseExit(MissingContext),
+  runPromise: () => Effect.runPromise(MissingContext),
+  withRuntime: () => Effect.runSync(MissingContext),
+  close: Effect.dieMessage('Empty ServiceContext cannot be closed'),
+  closePromise: () => Promise.reject('Empty ServiceContext cannot be closed'),
+  staticData: {} as TStaticData,
+})

package/src/effect/index.ts

@@ -0,0 +1,65 @@
+import '../global.js'
+
+// io
+export * as Effect from './Effect.js'
+export * as Scope from '@effect/io/Scope'
+export * as Schedule from './Schedule.js'
+export * as Layer from '@effect/io/Layer'
+export * as Ref from '@effect/io/Ref'
+export * as SynchronizedRef from '@effect/io/SynchronizedRef'
+export * as Queue from '@effect/io/Queue'
+export * as Fiber from '@effect/io/Fiber'
+export * as FiberId from '@effect/io/FiberId'
+export * as RuntimeFlags from '@effect/io/RuntimeFlags'
+export * as Hub from '@effect/io/Hub'
+export * as Exit from '@effect/io/Exit'
+export * as Cause from '@effect/io/Cause'
+export * as Runtime from '@effect/io/Runtime'
+export * as Scheduler from '@effect/io/Scheduler'
+export * as FiberRef from '@effect/io/FiberRef'
+export * as FiberRefs from '@effect/io/FiberRefs'
+export * as FiberRefsPatch from '@effect/io/FiberRefsPatch'
+export * as Deferred from '@effect/io/Deferred'
+export * as Metric from '@effect/io/Metric'
+export * as MetricState from '@effect/io/MetricState'
+export * as Request from '@effect/io/Request'
+
+// data
+export * as Context from '@effect/data/Context'
+export * as Data from '@effect/data/Data'
+export { TaggedClass as Tagged } from '@effect/data/Data'
+export * as Either from '@effect/data/Either'
+export * as Brand from '@effect/data/Brand'
+export * as Hash from '@effect/data/Hash'
+export * as Equal from '@effect/data/Equal'
+export * as Ord from '@effect/data/Order'
+export * as Chunk from '@effect/data/Chunk'
+export * as Duration from '@effect/data/Duration'
+export * as ReadonlyArray from '@effect/data/ReadonlyArray'
+export * as ReadonlyRecord from '@effect/data/ReadonlyRecord'
+export * as SortedMap from '@effect/data/SortedMap'
+export * as HashMap from '@effect/data/HashMap'
+export * as HashSet from '@effect/data/HashSet'
+export * as MutableHashSet from '@effect/data/MutableHashSet'
+export * as Option from '@effect/data/Option'
+export { pipe, identity } from '@effect/data/Function'
+
+// stream
+export * as Stream from '@effect/stream/Stream'
+export * as Channel from '@effect/stream/Channel'
+export * as SubscriptionRef from '@effect/stream/SubscriptionRef'
+
+// schema
+export * as Schema from '@effect/schema/Schema'
+
+// match
+export * as Match from '@effect/match'
+
+// otel
+export * as Otel from './Otel/index.js'
+
+// error
+export * from './Error.js'
+
+// ServiceContext
+export * as ServiceContext from './ServiceContext.js'

package/src/global.ts

@@ -0,0 +1,5 @@
+declare global {
+  export type TODO = any
+}
+
+export {}

package/src/guards.ts

@@ -0,0 +1,8 @@
+export const isNotUndefined = <T>(_: T | undefined): _ is T => _ !== undefined
+
+export const isNotNull = <T>(_: T | null): _ is T => _ !== null
+export const isUndefined = <T>(_: T | undefined): _ is undefined => _ === undefined
+
+export const isNil = (val: any): val is null | undefined => val === null || val === undefined
+
+export const isNotNil = <T>(val: T | undefined | null): val is T => val !== null && val !== undefined

package/src/index.ts

@@ -0,0 +1,217 @@
+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 * as base64 from './base64.js'
+export { default as prettyBytes } from 'pretty-bytes'
+
+export { v4 as uuid } from 'uuid'
+
+import type * as otel from '@opentelemetry/api'
+
+export * as dateFns from 'date-fns'
+
+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 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+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 debugDeepCopy = <T>(val: T): T => JSON.parse(JSON.stringify(val))
+
+export const prop =
+  <T extends {}, K extends keyof T>(key: K) =>
+  (obj: T): T[K] =>
+    obj[key]
+
+export const objectToString = (error: any): string => {
+  const stack = typeof process !== 'undefined' && process.env.CL_DEBUG ? error.stack : undefined
+  const str = error.toString()
+  const stackStr = stack ? `\n${stack}` : ''
+  if (str !== '[object Object]') return str + stackStr
+
+  try {
+    return JSON.stringify({ ...error, stack }, null, 2)
+  } catch (e: any) {
+    console.log(error)
+
+    return 'Error while printing error: ' + e
+  }
+}
+
+export const errorToString = objectToString
+
+export const capitalizeFirstLetter = (str: string): string => str.charAt(0).toUpperCase() + str.slice(1)
+
+/**
+ * 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): never => {
+  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 getEnv = (varName: string) => {
+  let value: string | undefined
+
+  // @ts-expect-error `import.meta.env` might not be defined
+  if (import.meta.env !== undefined) {
+    // @ts-expect-error `import.meta.env` might not be defined
+    value = import.meta.env[varName]
+    // eslint-disable-next-line unicorn/no-negated-condition
+  } else if (globalThis.process?.env !== undefined) {
+    value = globalThis.process.env[varName]
+  } else {
+    throw new Error(`No environment variables found (neither import.meta.env nor process.env)`)
+  }
+
+  return value
+}

package/src/object/index.ts

@@ -0,0 +1,24 @@
+import { pipe } from '@effect/data/Function'
+
+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,2 @@
+export const lowercaseFirstChar = (str: string) => str.charAt(0).toLowerCase() + str.slice(1)
+export const uppercaseFirstChar = (str: string) => str.charAt(0).toUpperCase() + str.slice(1)

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,13 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo.json"
+  },
+  "include": [
+    "./src"
+  ],
+  "references": []
+}