{"version":3,"file":"vest-utils.cjs","names":["isFunction","resolve: (value: T | PromiseLike<T>) => void","reject: (reason?: any) => void","isNumeric","cacheStorage: Array<[unknown[], T, number]>","isNullish","lengthEquals","isObject","isFunction","isFunction","isObject","isEmpty","isObject","isNullish","value: S","isEmpty","assign"],"sources":["../src/noop.ts","../src/withResolvers.ts","../src/greaterThan.ts","../src/longerThan.ts","../src/cache.ts","../src/asArray.ts","../src/callEach.ts","../src/isPromise.ts","../src/dynamicValue.ts","../src/assign.ts","../src/defaultTo.ts","../src/invariant.ts","../src/either.ts","../src/isBooleanValue.ts","../src/deferThrow.ts","../src/bus.ts","../src/seq.ts","../src/mapFirst.ts","../src/isEmptySet.ts","../src/isPositive.ts","../src/text.ts","../src/Result.ts","../src/SimpleStateMachine.ts","../src/nonnullish.ts","../src/tinyState.ts","../src/StringObject.ts","../src/Predicates.ts","../src/freezeAssign.ts","../src/withCatch.ts","../src/Brand.ts","../src/toNumber.ts"],"sourcesContent":["export function noop() {}\n","import isFunction from './isFunction';\nimport { noop } from './noop';\n\n// Type declaration for Promise.withResolvers (ES2024 feature)\ndeclare global {\n  interface PromiseConstructor {\n    withResolvers<T>(): {\n      promise: Promise<T>;\n      resolve: (value: T | PromiseLike<T>) => void;\n      reject: (reason?: any) => void;\n    };\n  }\n}\n\nexport function withResolvers<T>() {\n  if (isFunction(Promise.withResolvers)) {\n    return Promise.withResolvers<T>();\n  }\n\n  let resolve: (value: T | PromiseLike<T>) => void = noop,\n    reject: (reason?: any) => void = noop;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return {\n    promise,\n    resolve,\n    reject,\n  };\n}\n","import { isNumeric } from './isNumeric';\n\nexport function greaterThan(\n  value: number | string,\n  gt: number | string,\n): boolean {\n  return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);\n}\n","import { greaterThan } from './greaterThan';\n\nexport function longerThan(\n  value: string | unknown[],\n  arg1: string | number,\n): boolean {\n  return greaterThan(value.length, arg1);\n}\n","import { lengthEquals } from './lengthEquals';\nimport { longerThan } from './longerThan';\nimport { DynamicValue, Nullable } from './utilityTypes';\nimport { dynamicValue, isNullish, isObject } from './vest-utils';\n\nexport type CacheConfig = {\n  maxSize?: number;\n  ttl?: number;\n};\n\n/**\n * Creates a cache function\n */\nexport default function createCache<T = unknown>(\n  maxSizeOrConfig?: number | CacheConfig,\n): CacheApi<T> {\n  const { maxSize, ttl } = getCacheConfig(maxSizeOrConfig);\n\n  const cacheStorage: Array<[unknown[], T, number]> = [];\n\n  const cache = (deps: unknown[], cacheAction: DynamicValue<T>): T => {\n    const cacheHit = cache.get(deps);\n    // cache hit is not null\n    if (cacheHit) return cacheHit[1];\n\n    const result = dynamicValue(cacheAction);\n    cacheStorage.unshift([deps.concat(), result, Date.now()]);\n\n    trimToSize();\n\n    return result;\n  };\n\n  // invalidate an item in the cache by its dependencies\n  cache.invalidate = (deps: any[]): void => {\n    const index = findIndex(deps);\n    if (index > -1) cacheStorage.splice(index, 1);\n  };\n\n  // Retrieves an item from the cache.\n  cache.get = (deps: unknown[]): Nullable<[unknown[], T]> => {\n    const index = findIndex(deps);\n    const item = cacheStorage[index];\n\n    if (!item) return null;\n\n    if (!isNullish(ttl) && Date.now() - item[2] > ttl) {\n      cacheStorage.splice(index, 1);\n      return null;\n    }\n\n    return [item[0], item[1]];\n  };\n\n  // sets a value to the cache by its dependencies, updating if a hit is found.\n  cache.set = (deps: unknown[], value: T): void => {\n    const index = findIndex(deps);\n    if (index > -1) {\n      cacheStorage[index] = [deps, value, Date.now()];\n    } else {\n      cacheStorage.unshift([deps, value, Date.now()]);\n    }\n    trimToSize();\n  };\n\n  return cache;\n\n  function trimToSize() {\n    if (longerThan(cacheStorage, maxSize)) {\n      cacheStorage.length = maxSize;\n    }\n  }\n\n  function findIndex(deps: unknown[]): number {\n    return cacheStorage.findIndex(\n      ([cachedDeps]) =>\n        lengthEquals(deps, cachedDeps.length) &&\n        deps.every((dep, i) => dep === cachedDeps[i]),\n    );\n  }\n}\n\nexport type CacheApi<T = unknown> = {\n  (deps: unknown[], cacheAction: DynamicValue<T>): T;\n  get(deps: unknown[]): Nullable<[unknown[], T]>;\n  set(deps: unknown[], value: T): void;\n  invalidate(item: any): void;\n};\n\nfunction getCacheConfig(\n  maxSizeOrConfig?: number | CacheConfig,\n): Required<Pick<CacheConfig, 'maxSize'>> & Pick<CacheConfig, 'ttl'> {\n  const config = isObject(maxSizeOrConfig)\n    ? maxSizeOrConfig\n    : { maxSize: maxSizeOrConfig as number | undefined };\n  return {\n    maxSize: config.maxSize ?? 1,\n    ttl: config.ttl,\n  };\n}\n","export default function asArray<T>(possibleArg: T | readonly T[]): T[] {\n  return ([] as T[]).concat(possibleArg);\n}\n","import type { CB } from './utilityTypes';\n\nexport default function callEach(arr: CB[]): void {\n  return arr.forEach(fn => fn());\n}\n","import isFunction from './isFunction';\n\nexport default function isPromise(value: any): value is Promise<unknown> {\n  return !!value && isFunction(value.then);\n}\n","import isFunction from './isFunction';\nimport { DynamicValue } from './utilityTypes';\n\nexport default function dynamicValue<T>(\n  value: DynamicValue<T>,\n  ...args: unknown[]\n): T {\n  return isFunction(value) ? value(...args) : value;\n}\n","export default Object.assign;\n","import dynamicValue from './dynamicValue';\nimport { DynamicValue, Nullish } from './utilityTypes';\n\nexport default function defaultTo<T>(\n  value: DynamicValue<Nullish<T>>,\n  defaultValue: DynamicValue<T>,\n): T {\n  return dynamicValue(value) ?? dynamicValue(defaultValue);\n}\n","import dynamicValue from './dynamicValue';\nimport type { Stringable } from './utilityTypes';\n\nexport default function invariant(\n  condition: any,\n\n  message?: String | Stringable,\n): asserts condition {\n  if (condition) {\n    return;\n  }\n\n  // If message is a string object (rather than string literal)\n  // Throw the value directly as a string\n  // Alternatively, throw an error with the message\n  throw message instanceof String\n    ? message.valueOf()\n    : new Error(message ? dynamicValue(message) : message);\n}\n","export default function either(a: unknown, b: unknown): boolean {\n  return !!a !== !!b;\n}\n","export default function isBoolean(value: unknown): value is boolean {\n  return !!value === value;\n}\n","export default function deferThrow(message?: string): void {\n  setTimeout(() => {\n    throw new Error(message);\n  }, 0);\n}\n\nexport type TDeferThrow = typeof deferThrow;\n","import type { CB } from './utilityTypes';\n\nconst EVENT_WILDCARD = '*';\ntype TEventsWildcard = typeof EVENT_WILDCARD;\n\nexport function createBus<\n  TEvents extends Record<string, any> = Record<string, any>,\n>(): BusType<TEvents> {\n  const listeners = {} as Record<keyof TEvents | TEventsWildcard, CB[]>;\n\n  return {\n    emit(event: keyof TEvents | TEventsWildcard, payload?: any) {\n      getListeners(event)\n        .concat(getListeners(EVENT_WILDCARD))\n        .forEach(handler => {\n          handler(payload);\n        });\n    },\n\n    on(event: keyof TEvents | TEventsWildcard, handler: CB): OnReturn {\n      listeners[event] = getListeners(event).concat(handler);\n\n      return {\n        off() {\n          listeners[event] = getListeners(event).filter(h => h !== handler);\n        },\n      };\n    },\n  };\n\n  function getListeners(event: keyof TEvents | TEventsWildcard): CB[] {\n    return listeners[event] || [];\n  }\n}\n\ntype OnReturn = { off: CB<void> };\n\nexport type BusType<TEvents extends Record<string, any>> = {\n  on<T extends keyof TEvents>(\n    event: T,\n    handler: (payload: TEvents[T]) => void,\n  ): OnReturn;\n  on(event: TEventsWildcard, handler: (payload: any) => void): OnReturn;\n\n  emit<T extends keyof TEvents>(\n    event: T,\n    ...args: TEvents[T] extends void\n      ? [payload?: TEvents[T]]\n      : [payload: TEvents[T]]\n  ): void;\n  emit(event: TEventsWildcard, payload?: any): void;\n};\n","/**\n * @returns a unique numeric id.\n */\n\nimport { CB } from './utilityTypes';\n\nconst seq = genSeq();\n\nexport default seq;\n\nexport function genSeq(namespace?: string): CB<string> {\n  return (\n    (n: number) => () =>\n      `${namespace ? namespace + '_' : ''}${n++}`\n  )(0);\n}\n","export default function mapFirst<T>(\n  array: T[],\n  callback: (\n    item: T,\n    breakout: (conditional: boolean, value: unknown) => void,\n    index: number,\n  ) => unknown,\n): any {\n  let broke = false;\n  let breakoutValue = null;\n  for (let i = 0; i < array.length; i++) {\n    callback(array[i], breakout, i);\n\n    if (broke) {\n      return breakoutValue;\n    }\n  }\n\n  function breakout(conditional: boolean, value: unknown) {\n    if (conditional) {\n      broke = true;\n      breakoutValue = value;\n    }\n  }\n}\n","/**\n * Checks if a given set is empty.\n * @param value value to check\n */\nexport function isEmptySet(value: Set<unknown>): boolean {\n  return value.size === 0;\n}\n\n/**\n * Checks if a given set is NOT empty.\n * @param value value to check\n */\nexport function isNotEmptySet(value: Set<unknown>): boolean {\n  return value.size > 0;\n}\n","import { greaterThan } from './greaterThan';\n\nexport function isPositive(value: number | string): boolean {\n  return greaterThan(value, 0);\n}\n","import { isEmpty } from './isEmpty';\nimport { isObject } from './valueIsObject';\n\nconst regexp = /{([^}]*)}/g;\n\nexport function text(str: string, ...substitutions: Array<unknown>): string {\n  const first = substitutions[0];\n\n  if (isObject(first)) {\n    return str.replace(regexp, (placeholder, key: string) => {\n      return `${first[key] ?? placeholder}`;\n    });\n  }\n\n  const subs = [...substitutions];\n\n  return str.replace(regexp, placeholder => {\n    return `${isEmpty(subs) ? placeholder : subs.shift()}`;\n  });\n}\n","import { isObject } from './valueIsObject';\n\nexport type Result<T, E = unknown> = Success<T, E> | Failure<T, E>;\n\ntype Success<T, E> = {\n  chain<U, E2 = E>(fn: (value: T) => Result<U, E2>): Result<U, E | E2>;\n  map<U>(fn: (value: T) => U): Result<U, E>;\n  mapError<E2>(fn: (error: E) => E2): Result<T, E2>;\n  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U;\n  readonly type: 'ok';\n  unwrap(): T;\n  unwrapOr(defaultValue: T): T;\n  readonly value: T;\n};\n\nexport type Failure<T, E> = {\n  chain<U, E2 = E>(fn: (value: T) => Result<U, E2>): Result<U, E | E2>;\n  readonly error: E;\n  map<U>(fn: (value: T) => U): Result<U, E>;\n  mapError<E2>(fn: (error: E) => E2): Result<T, E2>;\n  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U;\n  readonly type: 'err';\n  unwrap(): T;\n  unwrapOr(defaultValue: T): T;\n};\n\nfunction ok<T, E = unknown>(value: T): Success<T, E> {\n  return {\n    chain<U, E2 = E>(fn: (inner: T) => Result<U, E2>) {\n      return fn(value) as Result<U, E | E2>;\n    },\n    map<U>(fn: (inner: T) => U) {\n      return ok<U, E>(fn(value));\n    },\n    mapError<E2>(_fn: (error: E) => E2) {\n      return this as unknown as Success<T, E2>;\n    },\n    match<U>(handlers: { ok: (val: T) => U; err: (err: E) => U }) {\n      return handlers.ok(value);\n    },\n    type: 'ok',\n    unwrap() {\n      return value;\n    },\n    unwrapOr(_defaultValue: T) {\n      return value;\n    },\n    value,\n  };\n}\n\nfunction err<T = never, E = unknown>(error: E): Failure<T, E> {\n  return {\n    chain<U, E2 = E>(_fn: (inner: T) => Result<U, E2>) {\n      return this as unknown as Failure<U, E | E2>;\n    },\n    error,\n    map<U>(_fn: (inner: T) => U) {\n      return this as unknown as Failure<U, E>;\n    },\n    mapError<E2>(fn: (inner: E) => E2) {\n      return err<T, E2>(fn(error));\n    },\n    match<U>(handlers: { ok: (val: T) => U; err: (err: E) => U }) {\n      return handlers.err(error);\n    },\n    type: 'err',\n    unwrap() {\n      throw error instanceof Error ? error : new Error(String(error));\n    },\n    unwrapOr(defaultValue: T) {\n      return defaultValue;\n    },\n  };\n}\n\nexport const makeResult = { Ok: ok, Err: err } as const;\n\nconst hasResultType = (candidate: { type?: unknown }): boolean =>\n  candidate.type === 'ok' || candidate.type === 'err';\n\nconst hasResultShape = (candidate: Record<string, unknown>): boolean =>\n  'value' in candidate || 'error' in candidate;\n\nexport function isResult(value: unknown): value is Result<unknown, unknown> {\n  if (!isObject(value)) {\n    return false;\n  }\n\n  const candidate = value as { type?: unknown } & Record<string, unknown>;\n\n  if (!hasResultShape(candidate)) {\n    return false;\n  }\n\n  return hasResultType(candidate);\n}\n\nexport function isSuccess<T, E>(value: Result<T, E>): value is Success<T, E> {\n  return value.type === 'ok';\n}\n\nexport function isFailure<T, E>(value: Result<T, E>): value is Failure<T, E> {\n  return value.type === 'err';\n}\n\n/**\n * Unwraps a Result.\n * If the Result is Success, it returns the value.\n * If the Result is Failure, it throws the error.\n */\nexport function unwrap<T>(result: Result<T, any>): T {\n  if (isFailure(result)) {\n    // Ensure we always throw an Error object for better stack traces\n    throw result.error instanceof Error\n      ? result.error\n      : new Error(String(result.error));\n  }\n\n  return result.value;\n}\n","import { isFailure, makeResult, Result } from './Result';\nimport { CB } from './utilityTypes';\n\nconst STATE_WILD_CARD = '*';\ntype TStateWildCard = typeof STATE_WILD_CARD;\n\ntype TransitionTarget<S extends string> = S | [S, CB<boolean, [payload?: any]>];\ntype StatesMap<S extends string = string, A extends string = string> = Record<\n  S | TStateWildCard,\n  Partial<Record<A, TransitionTarget<S>>>\n>;\n\nexport type TStateMachine<\n  S extends string = string,\n  A extends string = string,\n> = {\n  initial: S;\n  states: Partial<StatesMap<S, A>>;\n};\n\nexport type TStateMachineApi<\n  S extends string = string,\n  A extends string = string,\n> = {\n  getState: CB<S>;\n  initial: CB<S>;\n  staticTransition: (from: S, action: A, payload?: any) => S;\n  transition: (action: A, payload?: any) => Result<void, string>;\n};\n\ntype TransitionValue<V> = V extends [infer T, any]\n  ? T extends string\n    ? T\n    : never\n  : V extends string\n    ? V\n    : never;\n\ntype Values<T> = T[keyof T];\n\ntype StateConfigs<M extends { states: Record<string, any> }> = Values<\n  M['states']\n>;\n\ntype ActionFromConfig<M extends { states: Record<string, any> }> =\n  StateConfigs<M> extends infer SC\n    ? SC extends any\n      ? Extract<keyof SC, string>\n      : never\n    : never;\n\ntype TargetStatesFromConfig<M extends { states: Record<string, any> }> =\n  StateConfigs<M> extends infer SC\n    ? SC extends any\n      ? TransitionValue<Values<SC>>\n      : never\n    : never;\n\ntype StateFromConfig<\n  M extends { initial: string; states: Record<string, any> },\n> =\n  | M['initial']\n  | Extract<keyof M['states'], string>\n  | TargetStatesFromConfig<M>;\n\nexport function StateMachine<\n  M extends { initial: string; states: Record<string, any> },\n>(machine: M): TStateMachineApi<StateFromConfig<M>, ActionFromConfig<M>> {\n  type SMState = StateFromConfig<M>;\n  type SMAction = ActionFromConfig<M>;\n\n  const typedMachine = machine as TStateMachine<SMState, SMAction>;\n\n  let state = typedMachine.initial;\n\n  const api = { getState, initial, staticTransition, transition };\n\n  return api;\n\n  function getState(): SMState {\n    return state;\n  }\n\n  function initial(): SMState {\n    return machine.initial;\n  }\n\n  function transition(action: SMAction, payload?: any): Result<void, string> {\n    const result = calculateNextState(typedMachine, state, action, payload);\n\n    if (isFailure(result)) {\n      return makeResult.Err(result.error);\n    }\n\n    state = result.value;\n    return makeResult.Ok(undefined);\n  }\n\n  function staticTransition(\n    from: SMState,\n    action: SMAction,\n    payload?: any,\n  ): SMState {\n    const transitionTo = getTransitionTarget(typedMachine, from, action);\n    const target = Array.isArray(transitionTo)\n      ? evaluateConditionalTarget(transitionTo, from, payload)\n      : transitionTo;\n\n    return !target || target === from ? from : (target as SMState);\n  }\n}\n\nfunction getTransitionTarget<S extends string, A extends string>(\n  machine: TStateMachine<S, A>,\n  from: S,\n  action: A,\n): TransitionTarget<S> | undefined {\n  return (\n    machine.states[from]?.[action] ?? machine.states[STATE_WILD_CARD]?.[action]\n  );\n}\n\nfunction evaluateConditionalTarget<S extends string>(\n  target: [S, CB<boolean, [payload?: any]>],\n  from: S,\n  payload?: any,\n): S {\n  const [nextState, conditional] = target;\n  return conditional(payload) ? nextState : from;\n}\n\nfunction calculateNextState<S extends string, A extends string>(\n  machine: TStateMachine<S, A>,\n  from: S,\n  action: A,\n  payload?: any,\n): Result<S, string> {\n  const transitionTo = getTransitionTarget(machine, from, action);\n\n  if (!transitionTo) {\n    return makeResult.Err(\n      `Invalid transition: \"${action}\" from state \"${from}\"`,\n    );\n  }\n\n  if (Array.isArray(transitionTo)) {\n    const [candidateState, conditional] = transitionTo;\n    if (!conditional(payload)) {\n      return makeResult.Err(\n        `Invalid transition: \"${action}\" from state \"${from}\" (conditional failed)`,\n      );\n    }\n    return makeResult.Ok(candidateState);\n  }\n\n  return makeResult.Ok(transitionTo as S);\n}\n","import invariant from './invariant';\nimport { isNullish } from './isNullish';\nimport { Nullish } from './utilityTypes';\n\nexport function nonnullish<T>(value: Nullish<T>, error?: string): T {\n  invariant(!isNullish(value), error);\n\n  return value;\n}\n","import dynamicValue from './dynamicValue';\nimport { DynamicValue } from './utilityTypes';\n\nexport function createTinyState<S>(\n  initialValue: SetValueInput<S>,\n): TinyState<S> {\n  let value: S;\n\n  resetValue();\n\n  return () => [value, setValue, resetValue];\n\n  function setValue(nextValue: SetValueInput<S>) {\n    value = dynamicValue(nextValue, value);\n  }\n\n  function resetValue() {\n    setValue(dynamicValue(initialValue));\n  }\n}\n\nexport type TinyState<S> = () => [\n  value: S,\n  setValue: (next: SetValueInput<S>) => void,\n  resetValue: () => void,\n];\n\ntype SetValueInput<S> = DynamicValue<S, [prev: S]>;\n","import dynamicValue from './dynamicValue';\nimport type { Stringable } from './utilityTypes';\n\nexport function StringObject(value?: Stringable): String {\n  return new String(dynamicValue(value));\n}\n","import dynamicValue from './dynamicValue';\nimport { isEmpty } from './isEmpty';\nimport { Predicate } from './utilityTypes';\n\nexport function all<T = any>(...p: Predicate<T>[]): (value: T) => boolean {\n  return (value: T) =>\n    isEmpty(p) ? false : p.every(predicate => dynamicValue(predicate, value));\n}\n\nexport function any<T = any>(...p: Predicate<T>[]): (value: T) => boolean {\n  return (value: T) =>\n    isEmpty(p) ? false : p.some(predicate => dynamicValue(predicate, value));\n}\n","import assign from './assign';\n\nexport function freezeAssign<T extends object>(...args: Partial<T>[]): T {\n  return Object.freeze(assign(...(args as [Partial<T>])));\n}\n","import { CB } from './utilityTypes';\n\nexport function withCatch<T>(cb: CB<T>): () => T | unknown {\n  return () => {\n    try {\n      return cb();\n    } catch (error) {\n      return error;\n    }\n  };\n}\n","// Utility for creating opaque branded types to avoid primitive mixing\n// Brand is represented as an intersection type with a unique symbol index\n// This pattern prevents accidental assignment between different domain primitives\n\nexport type Brand<T, B> = T & { readonly __brand: B };\n\nexport function makeBrand<T extends Brand<any, any>>(value: unknown): T {\n  return value as T;\n}\n","import { makeResult, Result } from './Result';\n\nexport function toNumber(value: any): Result<number, string> {\n  const num = Number(value);\n\n  if (Number.isNaN(num)) {\n    return makeResult.Err(`Value \"${value}\" is not a number`);\n  }\n\n  return makeResult.Ok(num);\n}\n"],"mappings":"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"}