vest-utils 1.5.0 → 2.0.1

package/src/vest-utils.ts

@@ -0,0 +1,73 @@
+export { withResolvers } from './withResolvers';
+export { default as cache } from './cache';
+export type { CacheApi } from './cache';
+export type { BusType } from './bus';
+export type { TinyState } from './tinyState';
+export { isNullish, isNotNullish } from './isNullish';
+export { default as asArray } from './asArray';
+export { default as callEach } from './callEach';
+export { default as hasOwnProperty } from './hasOwnProperty';
+export { default as isPromise } from './isPromise';
+export { default as dynamicValue } from './dynamicValue';
+export { default as assign } from './assign';
+export { default as defaultTo } from './defaultTo';
+export { default as invariant } from './invariant';
+export { default as isStringValue } from './isStringValue';
+export { default as isUnsafeKey } from './isUnsafeKey';
+export { default as bindNot } from './bindNot';
+export { default as either } from './either';
+export { default as isBoolean } from './isBooleanValue';
+export { default as deferThrow } from './deferThrow';
+export * as bus from './bus';
+export { default as seq, genSeq } from './seq';
+export { default as isFunction } from './isFunction';
+export { default as mapFirst } from './mapFirst';
+export { greaterThan } from './greaterThan';
+export { longerThan } from './longerThan';
+export { isNumeric, isNotNumeric } from './isNumeric';
+export { isObject } from './valueIsObject';
+export { lengthEquals, lengthNotEquals } from './lengthEquals';
+export { numberEquals, numberNotEquals } from './numberEquals';
+export { isNull, isNotNull } from './isNull';
+export { isUndefined, isNotUndefined } from './isUndefined';
+export { isArray, isNotArray } from './isArrayValue';
+export { isEmpty, isNotEmpty } from './isEmpty';
+export { isEmptySet, isNotEmptySet } from './isEmptySet';
+export { isPositive } from './isPositive';
+export { text } from './text';
+export { StateMachine } from './SimpleStateMachine';
+export type { TStateMachine, TStateMachineApi } from './SimpleStateMachine';
+export { nonnullish } from './nonnullish';
+export * as tinyState from './tinyState';
+export { StringObject } from './StringObject';
+export { noop } from './noop';
+export * as Predicates from './Predicates';
+export { freezeAssign } from './freezeAssign';
+export { withCatch } from './withCatch';
+export { makeBrand } from './Brand';
+export type { Brand } from './Brand';
+export { toNumber } from './toNumber';
+export type { IO } from './IO';
+export {
+  makeResult,
+  isResult,
+  isSuccess,
+  isFailure,
+  unwrap,
+  type Result,
+  type Failure,
+} from './Result';
+
+export type {
+  DropFirst,
+  Stringable,
+  CB,
+  ValueOf,
+  Nullish,
+  Nullable,
+  Maybe,
+  OneOrMoreOf,
+  DynamicValue,
+  BlankValue,
+  Predicate,
+} from './utilityTypes';

package/src/withCatch.ts

@@ -0,0 +1,11 @@
+import { CB } from './utilityTypes';
+
+export function withCatch<T>(cb: CB<T>): () => T | unknown {
+  return () => {
+    try {
+      return cb();
+    } catch (error) {
+      return error;
+    }
+  };
+}

package/src/withResolvers.ts

@@ -0,0 +1,33 @@
+import isFunction from './isFunction';
+import { noop } from './noop';
+
+// Type declaration for Promise.withResolvers (ES2024 feature)
+declare global {
+  interface PromiseConstructor {
+    withResolvers<T>(): {
+      promise: Promise<T>;
+      resolve: (value: T | PromiseLike<T>) => void;
+      reject: (reason?: any) => void;
+    };
+  }
+}
+
+export function withResolvers<T>() {
+  if (isFunction(Promise.withResolvers)) {
+    return Promise.withResolvers<T>();
+  }
+
+  let resolve: (value: T | PromiseLike<T>) => void = noop,
+    reject: (reason?: any) => void = noop;
+
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return {
+    promise,
+    resolve,
+    reject,
+  };
+}

package/standardSchemaSpec/package.json

@@ -0,0 +1,14 @@
+{
+  "exports": {
+    ".": {
+      "default": "../dist/exports/standardSchemaSpec.mjs",
+      "import": "../dist/exports/standardSchemaSpec.mjs",
+      "require": "../dist/exports/standardSchemaSpec.cjs",
+      "types": "../types/exports/standardSchemaSpec.d.mts"
+    }
+  },
+  "main": "../dist/exports/standardSchemaSpec.cjs",
+  "module": "../dist/exports/standardSchemaSpec.mjs",
+  "type": "module",
+  "types": "../types/exports/standardSchemaSpec.d.mts"
+}

package/types/{minifyObject.d.ts → exports/minifyObject.d.cts}

@@ -1,5 +1,7 @@
+//#region src/exports/minifyObject.d.ts
 declare function minifyObject(obj: any, replacer?: MinifyObjectReplacer): [any, any];
 declare function expandObject(minifiedObj: any, map: Record<string, any>): any;
 type MinifyObjectReplacer = (value: any, key: string) => any;
-export { minifyObject, expandObject, MinifyObjectReplacer };
-//# sourceMappingURL=minifyObject.d.ts.map
+//#endregion
+export { MinifyObjectReplacer, expandObject, minifyObject };
+//# sourceMappingURL=minifyObject.d.cts.map

package/types/exports/minifyObject.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minifyObject.d.cts","names":["minifyObject","MinifyObjectReplacer","expandObject","Record"],"sources":["../../src/exports/minifyObject.d.ts"],"sourcesContent":["export declare function minifyObject(obj: any, replacer?: MinifyObjectReplacer): [any, any];\nexport declare function expandObject(minifiedObj: any, map: Record<string, any>): any;\nexport type MinifyObjectReplacer = (value: any, key: string) => any;\n"],"mappings":";iBAAwBA,YAAAA,sBAAkCC;AAAlCD,iBACAE,YAAAA,CADkCD,WAAAA,EAAAA,GAAoB,EAAA,GAAA,EAClBE,MADkB,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA,GAAA;AACtDD,KACZD,oBAAAA,GADgDE,CAAAA,KAAM,EAAA,GAAA,EAAA,GAAA,EAAA,MAAA,EAAA,GAAA,GAAA"}

package/types/exports/minifyObject.d.mts

@@ -0,0 +1,7 @@
+//#region src/exports/minifyObject.d.ts
+declare function minifyObject(obj: any, replacer?: MinifyObjectReplacer): [any, any];
+declare function expandObject(minifiedObj: any, map: Record<string, any>): any;
+type MinifyObjectReplacer = (value: any, key: string) => any;
+//#endregion
+export { MinifyObjectReplacer, expandObject, minifyObject };
+//# sourceMappingURL=minifyObject.d.mts.map

package/types/exports/minifyObject.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minifyObject.d.mts","names":["minifyObject","MinifyObjectReplacer","expandObject","Record"],"sources":["../../src/exports/minifyObject.d.ts"],"sourcesContent":["export declare function minifyObject(obj: any, replacer?: MinifyObjectReplacer): [any, any];\nexport declare function expandObject(minifiedObj: any, map: Record<string, any>): any;\nexport type MinifyObjectReplacer = (value: any, key: string) => any;\n"],"mappings":";iBAAwBA,YAAAA,sBAAkCC;AAAlCD,iBACAE,YAAAA,CADkCD,WAAAA,EAAAA,GAAoB,EAAA,GAAA,EAClBE,MADkB,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA,GAAA;AACtDD,KACZD,oBAAAA,GADgDE,CAAAA,KAAM,EAAA,GAAA,EAAA,GAAA,EAAA,MAAA,EAAA,GAAA,GAAA"}

package/types/exports/standardSchemaSpec.d.cts

@@ -0,0 +1,59 @@
+//#region src/exports/standardSchemaSpec.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+//#endregion
+export { StandardSchemaV1 };
+//# sourceMappingURL=standardSchemaSpec.d.cts.map

package/types/exports/standardSchemaSpec.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardSchemaSpec.d.cts","names":["StandardSchemaV1","Input","Output","Props","Schema","Result","Promise","Types","SuccessResult","FailureResult","Issue","ReadonlyArray","PropertyKey","PathSegment","NonNullable"],"sources":["../../src/exports/standardSchemaSpec.d.ts"],"sourcesContent":["/** The Standard Schema interface. */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n    /** The Standard Schema properties. */\n    readonly '~standard': StandardSchemaV1.Props<Input, Output>;\n}\nexport declare namespace StandardSchemaV1 {\n    /** The Standard Schema properties interface. */\n    interface Props<Input = unknown, Output = Input> {\n        /** The version number of the standard. */\n        readonly version: 1;\n        /** The vendor name of the schema library. */\n        readonly vendor: string;\n        /** Validates unknown input values. */\n        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;\n        /** Inferred types associated with the schema. */\n        readonly types?: Types<Input, Output> | undefined;\n    }\n    /** The result interface of the validate function. */\n    type Result<Output> = SuccessResult<Output> | FailureResult;\n    /** The result interface if validation succeeds. */\n    interface SuccessResult<Output> {\n        /** The typed output value. */\n        readonly value: Output;\n        /** The non-existent issues. */\n        readonly issues?: undefined;\n    }\n    /** The result interface if validation fails. */\n    interface FailureResult {\n        /** The issues of failed validation. */\n        readonly issues: ReadonlyArray<Issue>;\n    }\n    /** The issue interface of the failure output. */\n    interface Issue {\n        /** The error message of the issue. */\n        readonly message: string;\n        /** The path of the issue, if any. */\n        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;\n    }\n    /** The path segment interface of the issue. */\n    interface PathSegment {\n        /** The key representing a path segment. */\n        readonly key: PropertyKey;\n    }\n    /** The Standard Schema types interface. */\n    interface Types<Input = unknown, Output = Input> {\n        /** The input type of the schema. */\n        readonly input: Input;\n        /** The output type of the schema. */\n        readonly output: Output;\n    }\n    /** Infers the input type of a Standard Schema. */\n    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];\n    /** Infers the output type of a Standard Schema. */\n    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];\n}\n"],"mappings":";;AACiBA,UAAAA,gBAAgBC,CAAAA,QAAAC,OAAA,EAAA,SAA2BD,KAA3B,CAAA,CAAA;EAA2BA;EAEXA,SAAAA,WAAAA,EAAvBD,gBAAAA,CAAiBG,KAAMF,CAAAA,KAAAA,EAAOC,MAAPD,CAAAA;;AAAvBD,kBAEDA,gBAAAA,CAFkBG;EAAK;EAEvBH,UAAAA,KAAAA,CAAAA,QAAgBC,OAAAC,EAAAA,SAEKD,KAFLG,CAAAA,CAAAA;IAEKH;IAMQC,SAAAA,OAAAA,EAAAA,CAAAA;IAAPG;IAAgCH,SAAAA,MAAAA,EAAAA,MAAAA;IAAPG;IAARC,SAAAA,QAAAA,EAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,GAAjBD,MAAiBC,CAAVJ,MAAUI,CAAAA,GAAAA,OAAAA,CAAQD,MAARC,CAAeJ,MAAfI,CAAAA,CAAAA;IAEjCL;IAAOC,SAAAA,KAAAA,CAAAA,EAAbK,KAAaL,CAAPD,KAAOC,EAAAA,MAAAA,CAAAA,GAAAA,SAAAA;EAAbK;EAGeL;EAAdM,KAAAA,MAAAA,CAAAA,MAAAA,CAAAA,GAAAA,aAAAA,CAAcN,MAAdM,CAAAA,GAAwBC,aAAxBD;EAAwBC;EAI1BP,UAAAA,aAAAA,CAAAA,MAAAA,CAAAA,CAAAA;IAOeQ;IAAdC,SAAAA,KAAAA,EAPDT,MAOCS;IAOaC;IAAcC,SAAAA,MAAAA,CAAAA,EAAAA,SAAAA;EAA5BF;EAKFC;EAGwBX,UAAAA,aAAAA,CAAAA;IAEtBA;IAECC,SAAAA,MAAAA,EAnBAS,aAmBAT,CAnBcQ,KAmBdR,CAAAA;EAGUF;EAAgCI;EAAZU,UAAAA,KAAAA,CAAAA;IAEnBd;IAAgCI,SAAAA,OAAAA,EAAAA,MAAAA;IAAZU;IAAW,SAAA,IAAA,CAAA,EAjB3CH,aAiB2C,CAjB7BC,WAiB6B,GAjBfC,WAiBe,CAAA,GAAA,SAAA;;;;;kBAZ7CD;;;4CAGwBX;;oBAEtBA;;qBAECC;;;iCAGUF,oBAAoBc,YAAYV;;kCAE/BJ,oBAAoBc,YAAYV"}

package/types/exports/standardSchemaSpec.d.mts

@@ -0,0 +1,59 @@
+//#region src/exports/standardSchemaSpec.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+//#endregion
+export { StandardSchemaV1 };
+//# sourceMappingURL=standardSchemaSpec.d.mts.map

package/types/exports/standardSchemaSpec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardSchemaSpec.d.mts","names":["StandardSchemaV1","Input","Output","Props","Schema","Result","Promise","Types","SuccessResult","FailureResult","Issue","ReadonlyArray","PropertyKey","PathSegment","NonNullable"],"sources":["../../src/exports/standardSchemaSpec.d.ts"],"sourcesContent":["/** The Standard Schema interface. */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n    /** The Standard Schema properties. */\n    readonly '~standard': StandardSchemaV1.Props<Input, Output>;\n}\nexport declare namespace StandardSchemaV1 {\n    /** The Standard Schema properties interface. */\n    interface Props<Input = unknown, Output = Input> {\n        /** The version number of the standard. */\n        readonly version: 1;\n        /** The vendor name of the schema library. */\n        readonly vendor: string;\n        /** Validates unknown input values. */\n        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;\n        /** Inferred types associated with the schema. */\n        readonly types?: Types<Input, Output> | undefined;\n    }\n    /** The result interface of the validate function. */\n    type Result<Output> = SuccessResult<Output> | FailureResult;\n    /** The result interface if validation succeeds. */\n    interface SuccessResult<Output> {\n        /** The typed output value. */\n        readonly value: Output;\n        /** The non-existent issues. */\n        readonly issues?: undefined;\n    }\n    /** The result interface if validation fails. */\n    interface FailureResult {\n        /** The issues of failed validation. */\n        readonly issues: ReadonlyArray<Issue>;\n    }\n    /** The issue interface of the failure output. */\n    interface Issue {\n        /** The error message of the issue. */\n        readonly message: string;\n        /** The path of the issue, if any. */\n        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;\n    }\n    /** The path segment interface of the issue. */\n    interface PathSegment {\n        /** The key representing a path segment. */\n        readonly key: PropertyKey;\n    }\n    /** The Standard Schema types interface. */\n    interface Types<Input = unknown, Output = Input> {\n        /** The input type of the schema. */\n        readonly input: Input;\n        /** The output type of the schema. */\n        readonly output: Output;\n    }\n    /** Infers the input type of a Standard Schema. */\n    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];\n    /** Infers the output type of a Standard Schema. */\n    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];\n}\n"],"mappings":";;AACiBA,UAAAA,gBAAgBC,CAAAA,QAAAC,OAAA,EAAA,SAA2BD,KAA3B,CAAA,CAAA;EAA2BA;EAEXA,SAAAA,WAAAA,EAAvBD,gBAAAA,CAAiBG,KAAMF,CAAAA,KAAAA,EAAOC,MAAPD,CAAAA;;AAAvBD,kBAEDA,gBAAAA,CAFkBG;EAAK;EAEvBH,UAAAA,KAAAA,CAAAA,QAAgBC,OAAAC,EAAAA,SAEKD,KAFLG,CAAAA,CAAAA;IAEKH;IAMQC,SAAAA,OAAAA,EAAAA,CAAAA;IAAPG;IAAgCH,SAAAA,MAAAA,EAAAA,MAAAA;IAAPG;IAARC,SAAAA,QAAAA,EAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,GAAjBD,MAAiBC,CAAVJ,MAAUI,CAAAA,GAAAA,OAAAA,CAAQD,MAARC,CAAeJ,MAAfI,CAAAA,CAAAA;IAEjCL;IAAOC,SAAAA,KAAAA,CAAAA,EAAbK,KAAaL,CAAPD,KAAOC,EAAAA,MAAAA,CAAAA,GAAAA,SAAAA;EAAbK;EAGeL;EAAdM,KAAAA,MAAAA,CAAAA,MAAAA,CAAAA,GAAAA,aAAAA,CAAcN,MAAdM,CAAAA,GAAwBC,aAAxBD;EAAwBC;EAI1BP,UAAAA,aAAAA,CAAAA,MAAAA,CAAAA,CAAAA;IAOeQ;IAAdC,SAAAA,KAAAA,EAPDT,MAOCS;IAOaC;IAAcC,SAAAA,MAAAA,CAAAA,EAAAA,SAAAA;EAA5BF;EAKFC;EAGwBX,UAAAA,aAAAA,CAAAA;IAEtBA;IAECC,SAAAA,MAAAA,EAnBAS,aAmBAT,CAnBcQ,KAmBdR,CAAAA;EAGUF;EAAgCI;EAAZU,UAAAA,KAAAA,CAAAA;IAEnBd;IAAgCI,SAAAA,OAAAA,EAAAA,MAAAA;IAAZU;IAAW,SAAA,IAAA,CAAA,EAjB3CH,aAiB2C,CAjB7BC,WAiB6B,GAjBfC,WAiBe,CAAA,GAAA,SAAA;;;;;kBAZ7CD;;;4CAGwBX;;oBAEtBA;;qBAECC;;;iCAGUF,oBAAoBc,YAAYV;;kCAE/BJ,oBAAoBc,YAAYV"}

package/types/vest-utils.d.cts

@@ -0,0 +1,296 @@
+//#endregion
+//#region src/withResolvers.d.ts
+declare global {
+  interface PromiseConstructor {
+    withResolvers<T$1>(): {
+      promise: Promise<T$1>;
+      resolve: (value: T$1 | PromiseLike<T$1>) => void;
+      reject: (reason?: any) => void;
+    };
+  }
+}
+declare function withResolvers<T$1>(): {
+  promise: Promise<T$1>;
+  resolve: (value: T$1 | PromiseLike<T$1>) => void;
+  reject: (reason?: any) => void;
+};
+//#endregion
+//#region src/utilityTypes.d.ts
+type DropFirst<T$1 extends unknown[]> = T$1 extends [unknown, ...infer U] ? U : never;
+type Stringable = string | CB<string>;
+type CB<T$1 = any, Args extends TArgs = TArgs> = (...args: Args) => T$1;
+type ValueOf<T$1> = T$1[keyof T$1];
+type Nullish<T$1 = void> = Nullable<T$1> | Maybe<T$1>;
+type Nullable<T$1> = T$1 | null;
+type Maybe<T$1> = T$1 | undefined;
+type OneOrMoreOf<T$1> = T$1 | T$1[];
+type DynamicValue<T$1, Args extends TArgs = TArgs> = T$1 | CB<T$1, Args>;
+type BlankValue = Maybe<''>;
+type TArgs = any[];
+type Predicate<T$1 = any> = boolean | ((value: T$1) => boolean);
+//#endregion
+//#region src/cache.d.ts
+/**
+ * Creates a cache function
+ */
+declare function createCache<T$1 = unknown>(maxSize?: number): CacheApi<T$1>;
+type CacheApi<T$1 = unknown> = {
+  (deps: unknown[], cacheAction: DynamicValue<T$1>): T$1;
+  get(deps: unknown[]): Nullable<[unknown[], T$1]>;
+  set(deps: unknown[], value: T$1): void;
+  invalidate(item: any): void;
+};
+declare namespace bus_d_exports {
+  export { BusType, createBus };
+}
+declare const EVENT_WILDCARD = "*";
+type TEventsWildcard = typeof EVENT_WILDCARD;
+declare function createBus<TEvents extends Record<string, any> = Record<string, any>>(): BusType<TEvents>;
+type OnReturn = {
+  off: CB<void>;
+};
+type BusType<TEvents extends Record<string, any>> = {
+  on<T$1 extends keyof TEvents>(event: T$1, handler: (payload: TEvents[T$1]) => void): OnReturn;
+  on(event: TEventsWildcard, handler: (payload: any) => void): OnReturn;
+  emit<T$1 extends keyof TEvents>(event: T$1, ...args: TEvents[T$1] extends void ? [payload?: TEvents[T$1]] : [payload: TEvents[T$1]]): void;
+  emit(event: TEventsWildcard, payload?: any): void;
+};
+declare namespace tinyState_d_exports {
+  export { TinyState, createTinyState };
+}
+declare function createTinyState<S>(initialValue: SetValueInput<S>): TinyState<S>;
+type TinyState<S> = () => [value: S, setValue: (next: SetValueInput<S>) => void, resetValue: () => void];
+type SetValueInput<S> = DynamicValue<S, [prev: S]>;
+//#endregion
+//#region src/isNullish.d.ts
+declare function isNullish(value: any): value is Nullish;
+declare const isNotNullish: (value: any) => boolean;
+//#endregion
+//#region src/asArray.d.ts
+declare function asArray<T$1>(possibleArg: T$1 | T$1[]): T$1[];
+//#endregion
+//#region src/callEach.d.ts
+declare function callEach(arr: CB[]): void;
+//#endregion
+//#region src/hasOwnProperty.d.ts
+/**
+ * A safe hasOwnProperty access
+ */
+declare function hasOwnProperty<T$1>(obj: T$1, key: string | number | symbol): key is keyof T$1;
+//#endregion
+//#region src/isPromise.d.ts
+declare function isPromise(value: any): value is Promise<unknown>;
+//#endregion
+//#region src/dynamicValue.d.ts
+declare function dynamicValue<T$1>(value: DynamicValue<T$1>, ...args: unknown[]): T$1;
+//#endregion
+//#region src/assign.d.ts
+declare const _default: {
+  <T$1 extends {}, U$1>(target: T$1, source: U$1): T$1 & U$1;
+  <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+  <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+  (target: object, ...sources: any[]): any;
+};
+//#endregion
+//#region src/defaultTo.d.ts
+declare function defaultTo<T$1>(value: DynamicValue<Nullish<T$1>>, defaultValue: DynamicValue<T$1>): T$1;
+//#endregion
+//#region src/invariant.d.ts
+declare function invariant(condition: any, message?: String | Stringable): asserts condition;
+//#endregion
+//#region src/isStringValue.d.ts
+declare function isStringValue(v: unknown): v is string;
+//#endregion
+//#region src/isUnsafeKey.d.ts
+declare function isUnsafeKey(key: string): boolean;
+//#endregion
+//#region src/bindNot.d.ts
+declare function bindNot<T$1 extends (...args: any[]) => unknown>(fn: T$1): (...args: Parameters<T$1>) => boolean;
+//#endregion
+//#region src/either.d.ts
+declare function either(a: unknown, b: unknown): boolean;
+//#endregion
+//#region src/isBooleanValue.d.ts
+declare function isBoolean(value: unknown): value is boolean;
+//#endregion
+//#region src/deferThrow.d.ts
+declare function deferThrow(message?: string): void;
+//#endregion
+//#region src/seq.d.ts
+declare const seq: CB<string, any[]>;
+declare function genSeq(namespace?: string): CB<string>;
+//#endregion
+//#region src/isFunction.d.ts
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+//#endregion
+//#region src/mapFirst.d.ts
+declare function mapFirst<T$1>(array: T$1[], callback: (item: T$1, breakout: (conditional: boolean, value: unknown) => void, index: number) => unknown): any;
+//#endregion
+//#region src/greaterThan.d.ts
+declare function greaterThan(value: number | string, gt: number | string): boolean;
+//#endregion
+//#region src/longerThan.d.ts
+declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
+//#endregion
+//#region src/isNumeric.d.ts
+declare function isNumeric(value: string | number): boolean;
+declare const isNotNumeric: (value: string | number) => boolean;
+//#endregion
+//#region src/valueIsObject.d.ts
+declare function isObject(v: any): v is Record<any, any>;
+//#endregion
+//#region src/lengthEquals.d.ts
+declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
+declare const lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
+//#endregion
+//#region src/numberEquals.d.ts
+declare function numberEquals(value: string | number, eq: string | number): boolean;
+declare const numberNotEquals: (value: string | number, eq: string | number) => boolean;
+//#endregion
+//#region src/isNull.d.ts
+declare function isNull(value: unknown): value is null;
+declare const isNotNull: (value: unknown) => boolean;
+//#endregion
+//#region src/isUndefined.d.ts
+declare function isUndefined(value?: unknown): value is undefined;
+declare const isNotUndefined: (value?: unknown) => boolean;
+//#endregion
+//#region src/isArrayValue.d.ts
+declare function isArray(value: unknown): value is Array<unknown>;
+declare const isNotArray: (value: unknown) => boolean;
+//#endregion
+//#region src/isEmpty.d.ts
+declare function isEmpty(value: unknown): boolean;
+declare const isNotEmpty: (value: unknown) => boolean;
+//#endregion
+//#region src/isEmptySet.d.ts
+/**
+ * Checks if a given set is empty.
+ * @param value value to check
+ */
+declare function isEmptySet(value: Set<unknown>): boolean;
+/**
+ * Checks if a given set is NOT empty.
+ * @param value value to check
+ */
+declare function isNotEmptySet(value: Set<unknown>): boolean;
+//#endregion
+//#region src/isPositive.d.ts
+declare function isPositive(value: number | string): boolean;
+//#endregion
+//#region src/text.d.ts
+declare function text(str: string, ...substitutions: Array<unknown>): string;
+//#endregion
+//#region src/Result.d.ts
+type Result<T$1, E = unknown> = Success<T$1, E> | Failure<T$1, E>;
+type Success<T$1, E> = {
+  chain<U$1, E2 = E>(fn: (value: T$1) => Result<U$1, E2>): Result<U$1, E | E2>;
+  map<U$1>(fn: (value: T$1) => U$1): Result<U$1, E>;
+  mapError<E2>(fn: (error: E) => E2): Result<T$1, E2>;
+  match<U$1>(handlers: {
+    ok: (value: T$1) => U$1;
+    err: (error: E) => U$1;
+  }): U$1;
+  readonly type: 'ok';
+  unwrap(): T$1;
+  unwrapOr(defaultValue: T$1): T$1;
+  readonly value: T$1;
+};
+type Failure<T$1, E> = {
+  chain<U$1, E2 = E>(fn: (value: T$1) => Result<U$1, E2>): Result<U$1, E | E2>;
+  readonly error: E;
+  map<U$1>(fn: (value: T$1) => U$1): Result<U$1, E>;
+  mapError<E2>(fn: (error: E) => E2): Result<T$1, E2>;
+  match<U$1>(handlers: {
+    ok: (value: T$1) => U$1;
+    err: (error: E) => U$1;
+  }): U$1;
+  readonly type: 'err';
+  unwrap(): T$1;
+  unwrapOr(defaultValue: T$1): T$1;
+};
+declare function ok<T$1, E = unknown>(value: T$1): Success<T$1, E>;
+declare function err<T$1 = never, E = unknown>(error: E): Failure<T$1, E>;
+declare const makeResult: {
+  readonly Ok: typeof ok;
+  readonly Err: typeof err;
+};
+declare function isResult(value: unknown): value is Result<unknown, unknown>;
+declare function isSuccess<T$1, E>(value: Result<T$1, E>): value is Success<T$1, E>;
+declare function isFailure<T$1, E>(value: Result<T$1, E>): value is Failure<T$1, E>;
+/**
+ * Unwraps a Result.
+ * If the Result is Success, it returns the value.
+ * If the Result is Failure, it throws the error.
+ */
+declare function unwrap<T$1>(result: Result<T$1, any>): T$1;
+//#endregion
+//#region src/SimpleStateMachine.d.ts
+declare const STATE_WILD_CARD = "*";
+type TStateWildCard = typeof STATE_WILD_CARD;
+type TransitionTarget<S extends string> = S | [S, CB<boolean, [payload?: any]>];
+type StatesMap<S extends string = string, A extends string = string> = Record<S | TStateWildCard, Partial<Record<A, TransitionTarget<S>>>>;
+type TStateMachine<S extends string = string, A extends string = string> = {
+  initial: S;
+  states: Partial<StatesMap<S, A>>;
+};
+type TStateMachineApi<S extends string = string, A extends string = string> = {
+  getState: CB<S>;
+  initial: CB<S>;
+  staticTransition: (from: S, action: A, payload?: any) => S;
+  transition: (action: A, payload?: any) => Result<void, string>;
+};
+type TransitionValue<V> = V extends [infer T, any] ? T extends string ? T : never : V extends string ? V : never;
+type Values<T$1> = T$1[keyof T$1];
+type StateConfigs<M extends {
+  states: Record<string, any>;
+}> = Values<M['states']>;
+type ActionFromConfig<M extends {
+  states: Record<string, any>;
+}> = StateConfigs<M> extends infer SC ? SC extends any ? Extract<keyof SC, string> : never : never;
+type TargetStatesFromConfig<M extends {
+  states: Record<string, any>;
+}> = StateConfigs<M> extends infer SC ? SC extends any ? TransitionValue<Values<SC>> : never : never;
+type StateFromConfig<M extends {
+  initial: string;
+  states: Record<string, any>;
+}> = M['initial'] | Extract<keyof M['states'], string> | TargetStatesFromConfig<M>;
+declare function StateMachine<M extends {
+  initial: string;
+  states: Record<string, any>;
+}>(machine: M): TStateMachineApi<StateFromConfig<M>, ActionFromConfig<M>>;
+//#endregion
+//#region src/nonnullish.d.ts
+declare function nonnullish<T$1>(value: Nullish<T$1>, error?: string): T$1;
+//#endregion
+//#region src/StringObject.d.ts
+declare function StringObject(value?: Stringable): String;
+//#endregion
+//#region src/noop.d.ts
+declare function noop(): void;
+declare namespace Predicates_d_exports {
+  export { all, any };
+}
+declare function all<T$1 = any>(...p: Predicate<T$1>[]): (value: T$1) => boolean;
+declare function any<T$1 = any>(...p: Predicate<T$1>[]): (value: T$1) => boolean;
+//#endregion
+//#region src/freezeAssign.d.ts
+declare function freezeAssign<T$1 extends object>(...args: Partial<T$1>[]): T$1;
+//#endregion
+//#region src/withCatch.d.ts
+declare function withCatch<T$1>(cb: CB<T$1>): () => T$1 | unknown;
+//#endregion
+//#region src/Brand.d.ts
+type Brand<T$1, B> = T$1 & {
+  readonly __brand: B;
+};
+declare function makeBrand<T$1 extends Brand<any, any>>(value: unknown): T$1;
+//#endregion
+//#region src/toNumber.d.ts
+declare function toNumber(value: any): Result<number, string>;
+//#endregion
+//#region src/IO.d.ts
+type IO<T$1> = () => T$1;
+//#endregion
+export { type BlankValue, type Brand, type BusType, type CB, type CacheApi, type DropFirst, type DynamicValue, type Failure, type IO, type Maybe, type Nullable, type Nullish, type OneOrMoreOf, type Predicate, Predicates_d_exports as Predicates, type Result, StateMachine, StringObject, type Stringable, type TStateMachine, type TStateMachineApi, type TinyState, type ValueOf, asArray, _default as assign, bindNot, bus_d_exports as bus, createCache as cache, callEach, defaultTo, deferThrow, dynamicValue, either, freezeAssign, genSeq, greaterThan, hasOwnProperty, invariant, isArray, isBoolean, isEmpty, isEmptySet, isFailure, isFunction, isNotArray, isNotEmpty, isNotEmptySet, isNotNull, isNotNullish, isNotNumeric, isNotUndefined, isNull, isNullish, isNumeric, isObject, isPositive, isPromise, isResult, isStringValue, isSuccess, isUndefined, isUnsafeKey, lengthEquals, lengthNotEquals, longerThan, makeBrand, makeResult, mapFirst, nonnullish, noop, numberEquals, numberNotEquals, seq, text, tinyState_d_exports as tinyState, toNumber, unwrap, withCatch, withResolvers };
+//# sourceMappingURL=vest-utils.d.cts.map