vest-utils 1.5.0 → 2.0.1

package/dist/vest-utils.mjs

@@ -0,0 +1,421 @@
+import { t as __export } from "./chunk-CLMFDpHK.mjs";
+import { S as isFunction, _ as numberEquals, a as isObject, b as isNumeric, c as hasOwnProperty, d as isNotUndefined, f as isUndefined, g as lengthNotEquals, h as lengthEquals, i as isNotArray, l as isNotNullish, m as isNull, n as isNotEmpty, o as isUnsafeKey, p as isNotNull, r as isArray, s as isStringValue, t as isEmpty, u as isNullish, v as numberNotEquals, x as bindNot, y as isNotNumeric } from "./isEmpty-BBxAFjjm.mjs";
+
+//#region src/noop.ts
+function noop() {}
+
+//#endregion
+//#region src/withResolvers.ts
+function withResolvers() {
+	if (isFunction(Promise.withResolvers)) return Promise.withResolvers();
+	let resolve = noop, reject = noop;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+
+//#endregion
+//#region src/greaterThan.ts
+function greaterThan(value, gt) {
+	return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+}
+
+//#endregion
+//#region src/longerThan.ts
+function longerThan(value, arg1) {
+	return greaterThan(value.length, arg1);
+}
+
+//#endregion
+//#region src/cache.ts
+/**
+* Creates a cache function
+*/
+function createCache(maxSize = 1) {
+	const cacheStorage = [];
+	const cache = (deps, cacheAction) => {
+		const cacheHit = cache.get(deps);
+		if (cacheHit) return cacheHit[1];
+		const result = dynamicValue(cacheAction);
+		cacheStorage.unshift([deps.concat(), result]);
+		trimToSize();
+		return result;
+	};
+	cache.invalidate = (deps) => {
+		const index = findIndex(deps);
+		if (index > -1) cacheStorage.splice(index, 1);
+	};
+	cache.get = (deps) => cacheStorage[findIndex(deps)] || null;
+	cache.set = (deps, value) => {
+		const index = findIndex(deps);
+		if (index > -1) cacheStorage[index] = [deps, value];
+		else cacheStorage.unshift([deps, value]);
+		trimToSize();
+	};
+	return cache;
+	function trimToSize() {
+		if (longerThan(cacheStorage, maxSize)) cacheStorage.length = maxSize;
+	}
+	function findIndex(deps) {
+		return cacheStorage.findIndex(([cachedDeps]) => lengthEquals(deps, cachedDeps.length) && deps.every((dep, i) => dep === cachedDeps[i]));
+	}
+}
+
+//#endregion
+//#region src/asArray.ts
+function asArray(possibleArg) {
+	return [].concat(possibleArg);
+}
+
+//#endregion
+//#region src/callEach.ts
+function callEach(arr) {
+	return arr.forEach((fn) => fn());
+}
+
+//#endregion
+//#region src/isPromise.ts
+function isPromise(value) {
+	return !!value && isFunction(value.then);
+}
+
+//#endregion
+//#region src/dynamicValue.ts
+function dynamicValue(value, ...args) {
+	return isFunction(value) ? value(...args) : value;
+}
+
+//#endregion
+//#region src/assign.ts
+var assign_default = Object.assign;
+
+//#endregion
+//#region src/defaultTo.ts
+function defaultTo(value, defaultValue) {
+	return dynamicValue(value) ?? dynamicValue(defaultValue);
+}
+
+//#endregion
+//#region src/invariant.ts
+function invariant(condition, message) {
+	if (condition) return;
+	throw message instanceof String ? message.valueOf() : new Error(message ? dynamicValue(message) : message);
+}
+
+//#endregion
+//#region src/either.ts
+function either(a, b) {
+	return !!a !== !!b;
+}
+
+//#endregion
+//#region src/isBooleanValue.ts
+function isBoolean(value) {
+	return !!value === value;
+}
+
+//#endregion
+//#region src/deferThrow.ts
+function deferThrow(message) {
+	setTimeout(() => {
+		throw new Error(message);
+	}, 0);
+}
+
+//#endregion
+//#region src/bus.ts
+var bus_exports = /* @__PURE__ */ __export({ createBus: () => createBus });
+const EVENT_WILDCARD = "*";
+function createBus() {
+	const listeners = {};
+	return {
+		emit(event, payload) {
+			getListeners(event).concat(getListeners(EVENT_WILDCARD)).forEach((handler) => {
+				handler(payload);
+			});
+		},
+		on(event, handler) {
+			listeners[event] = getListeners(event).concat(handler);
+			return { off() {
+				listeners[event] = getListeners(event).filter((h) => h !== handler);
+			} };
+		}
+	};
+	function getListeners(event) {
+		return listeners[event] || [];
+	}
+}
+
+//#endregion
+//#region src/seq.ts
+const seq = genSeq();
+var seq_default = seq;
+function genSeq(namespace) {
+	return ((n) => () => `${namespace ? namespace + "_" : ""}${n++}`)(0);
+}
+
+//#endregion
+//#region src/mapFirst.ts
+function mapFirst(array, callback) {
+	let broke = false;
+	let breakoutValue = null;
+	for (let i = 0; i < array.length; i++) {
+		callback(array[i], breakout, i);
+		if (broke) return breakoutValue;
+	}
+	function breakout(conditional, value) {
+		if (conditional) {
+			broke = true;
+			breakoutValue = value;
+		}
+	}
+}
+
+//#endregion
+//#region src/isEmptySet.ts
+/**
+* Checks if a given set is empty.
+* @param value value to check
+*/
+function isEmptySet(value) {
+	return value.size === 0;
+}
+/**
+* Checks if a given set is NOT empty.
+* @param value value to check
+*/
+function isNotEmptySet(value) {
+	return value.size > 0;
+}
+
+//#endregion
+//#region src/isPositive.ts
+function isPositive(value) {
+	return greaterThan(value, 0);
+}
+
+//#endregion
+//#region src/text.ts
+const regexp = /{([^}]*)}/g;
+function text(str, ...substitutions) {
+	const first = substitutions[0];
+	if (isObject(first)) return str.replace(regexp, (placeholder, key) => {
+		return `${first[key] ?? placeholder}`;
+	});
+	const subs = [...substitutions];
+	return str.replace(regexp, (placeholder) => {
+		return `${isEmpty(subs) ? placeholder : subs.shift()}`;
+	});
+}
+
+//#endregion
+//#region src/Result.ts
+function ok(value) {
+	return {
+		chain(fn) {
+			return fn(value);
+		},
+		map(fn) {
+			return ok(fn(value));
+		},
+		mapError(_fn) {
+			return this;
+		},
+		match(handlers) {
+			return handlers.ok(value);
+		},
+		type: "ok",
+		unwrap() {
+			return value;
+		},
+		unwrapOr(_defaultValue) {
+			return value;
+		},
+		value
+	};
+}
+function err(error) {
+	return {
+		chain(_fn) {
+			return this;
+		},
+		error,
+		map(_fn) {
+			return this;
+		},
+		mapError(fn) {
+			return err(fn(error));
+		},
+		match(handlers) {
+			return handlers.err(error);
+		},
+		type: "err",
+		unwrap() {
+			throw error instanceof Error ? error : new Error(String(error));
+		},
+		unwrapOr(defaultValue) {
+			return defaultValue;
+		}
+	};
+}
+const makeResult = {
+	Ok: ok,
+	Err: err
+};
+const hasResultType = (candidate) => candidate.type === "ok" || candidate.type === "err";
+const hasResultShape = (candidate) => "value" in candidate || "error" in candidate;
+function isResult(value) {
+	if (!isObject(value)) return false;
+	const candidate = value;
+	if (!hasResultShape(candidate)) return false;
+	return hasResultType(candidate);
+}
+function isSuccess(value) {
+	return value.type === "ok";
+}
+function isFailure(value) {
+	return value.type === "err";
+}
+/**
+* Unwraps a Result.
+* If the Result is Success, it returns the value.
+* If the Result is Failure, it throws the error.
+*/
+function unwrap(result) {
+	if (isFailure(result)) throw result.error instanceof Error ? result.error : new Error(String(result.error));
+	return result.value;
+}
+
+//#endregion
+//#region src/SimpleStateMachine.ts
+const STATE_WILD_CARD = "*";
+function StateMachine(machine) {
+	const typedMachine = machine;
+	let state = typedMachine.initial;
+	return {
+		getState,
+		initial,
+		staticTransition,
+		transition
+	};
+	function getState() {
+		return state;
+	}
+	function initial() {
+		return machine.initial;
+	}
+	function transition(action, payload) {
+		const result = calculateNextState(typedMachine, state, action, payload);
+		if (isFailure(result)) return makeResult.Err(result.error);
+		state = result.value;
+		return makeResult.Ok(void 0);
+	}
+	function staticTransition(from, action, payload) {
+		const transitionTo = getTransitionTarget(typedMachine, from, action);
+		const target = Array.isArray(transitionTo) ? evaluateConditionalTarget(transitionTo, from, payload) : transitionTo;
+		return !target || target === from ? from : target;
+	}
+}
+function getTransitionTarget(machine, from, action) {
+	return machine.states[from]?.[action] ?? machine.states[STATE_WILD_CARD]?.[action];
+}
+function evaluateConditionalTarget(target, from, payload) {
+	const [nextState, conditional] = target;
+	return conditional(payload) ? nextState : from;
+}
+function calculateNextState(machine, from, action, payload) {
+	const transitionTo = getTransitionTarget(machine, from, action);
+	if (!transitionTo) return makeResult.Err(`Invalid transition: "${action}" from state "${from}"`);
+	if (Array.isArray(transitionTo)) {
+		const [candidateState, conditional] = transitionTo;
+		if (!conditional(payload)) return makeResult.Err(`Invalid transition: "${action}" from state "${from}" (conditional failed)`);
+		return makeResult.Ok(candidateState);
+	}
+	return makeResult.Ok(transitionTo);
+}
+
+//#endregion
+//#region src/nonnullish.ts
+function nonnullish(value, error) {
+	invariant(!isNullish(value), error);
+	return value;
+}
+
+//#endregion
+//#region src/tinyState.ts
+var tinyState_exports = /* @__PURE__ */ __export({ createTinyState: () => createTinyState });
+function createTinyState(initialValue) {
+	let value;
+	resetValue();
+	return () => [
+		value,
+		setValue,
+		resetValue
+	];
+	function setValue(nextValue) {
+		value = dynamicValue(nextValue, value);
+	}
+	function resetValue() {
+		setValue(dynamicValue(initialValue));
+	}
+}
+
+//#endregion
+//#region src/StringObject.ts
+function StringObject(value) {
+	return new String(dynamicValue(value));
+}
+
+//#endregion
+//#region src/Predicates.ts
+var Predicates_exports = /* @__PURE__ */ __export({
+	all: () => all,
+	any: () => any
+});
+function all(...p) {
+	return (value) => isEmpty(p) ? false : p.every((predicate) => dynamicValue(predicate, value));
+}
+function any(...p) {
+	return (value) => isEmpty(p) ? false : p.some((predicate) => dynamicValue(predicate, value));
+}
+
+//#endregion
+//#region src/freezeAssign.ts
+function freezeAssign(...args) {
+	return Object.freeze(assign_default(...args));
+}
+
+//#endregion
+//#region src/withCatch.ts
+function withCatch(cb) {
+	return () => {
+		try {
+			return cb();
+		} catch (error) {
+			return error;
+		}
+	};
+}
+
+//#endregion
+//#region src/Brand.ts
+function makeBrand(value) {
+	return value;
+}
+
+//#endregion
+//#region src/toNumber.ts
+function toNumber(value) {
+	const num = Number(value);
+	if (Number.isNaN(num)) return makeResult.Err(`Value "${value}" is not a number`);
+	return makeResult.Ok(num);
+}
+
+//#endregion
+export { Predicates_exports as Predicates, StateMachine, StringObject, asArray, assign_default as assign, bindNot, bus_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_default as seq, text, tinyState_exports as tinyState, toNumber, unwrap, withCatch, withResolvers };
+//# sourceMappingURL=vest-utils.mjs.map

package/dist/vest-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vest-utils.mjs","names":["resolve: (value: T | PromiseLike<T>) => void","reject: (reason?: any) => void","cacheStorage: Array<[unknown[], T]>","value: S","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 } from './vest-utils';\n\n/**\n * Creates a cache function\n */\nexport default function createCache<T = unknown>(maxSize = 1): CacheApi<T> {\n  const cacheStorage: Array<[unknown[], T]> = [];\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]);\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    cacheStorage[findIndex(deps)] || null;\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];\n    } else {\n      cacheStorage.unshift([deps, value]);\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","export default function asArray<T>(possibleArg: T | 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":";;;;AAAA,SAAgB,OAAO;;;;ACcvB,SAAgB,gBAAmB;AACjC,KAAI,WAAW,QAAQ,cAAc,CACnC,QAAO,QAAQ,eAAkB;CAGnC,IAAIA,UAA+C,MACjDC,SAAiC;AAOnC,QAAO;EACL,SANc,IAAI,SAAY,KAAK,QAAQ;AAC3C,aAAU;AACV,YAAS;IACT;EAIA;EACA;EACD;;;;;AC7BH,SAAgB,YACd,OACA,IACS;AACT,QAAO,UAAU,MAAM,IAAI,UAAU,GAAG,IAAI,OAAO,MAAM,GAAG,OAAO,GAAG;;;;;ACJxE,SAAgB,WACd,OACA,MACS;AACT,QAAO,YAAY,MAAM,QAAQ,KAAK;;;;;;;;ACExC,SAAwB,YAAyB,UAAU,GAAgB;CACzE,MAAMC,eAAsC,EAAE;CAE9C,MAAM,SAAS,MAAiB,gBAAoC;EAClE,MAAM,WAAW,MAAM,IAAI,KAAK;AAEhC,MAAI,SAAU,QAAO,SAAS;EAE9B,MAAM,SAAS,aAAa,YAAY;AACxC,eAAa,QAAQ,CAAC,KAAK,QAAQ,EAAE,OAAO,CAAC;AAE7C,cAAY;AAEZ,SAAO;;AAIT,OAAM,cAAc,SAAsB;EACxC,MAAM,QAAQ,UAAU,KAAK;AAC7B,MAAI,QAAQ,GAAI,cAAa,OAAO,OAAO,EAAE;;AAI/C,OAAM,OAAO,SACX,aAAa,UAAU,KAAK,KAAK;AAGnC,OAAM,OAAO,MAAiB,UAAmB;EAC/C,MAAM,QAAQ,UAAU,KAAK;AAC7B,MAAI,QAAQ,GACV,cAAa,SAAS,CAAC,MAAM,MAAM;MAEnC,cAAa,QAAQ,CAAC,MAAM,MAAM,CAAC;AAErC,cAAY;;AAGd,QAAO;CAEP,SAAS,aAAa;AACpB,MAAI,WAAW,cAAc,QAAQ,CACnC,cAAa,SAAS;;CAI1B,SAAS,UAAU,MAAyB;AAC1C,SAAO,aAAa,WACjB,CAAC,gBACA,aAAa,MAAM,WAAW,OAAO,IACrC,KAAK,OAAO,KAAK,MAAM,QAAQ,WAAW,GAAG,CAChD;;;;;;AC1DL,SAAwB,QAAW,aAA2B;AAC5D,QAAQ,EAAE,CAAS,OAAO,YAAY;;;;;ACCxC,SAAwB,SAAS,KAAiB;AAChD,QAAO,IAAI,SAAQ,OAAM,IAAI,CAAC;;;;;ACDhC,SAAwB,UAAU,OAAuC;AACvE,QAAO,CAAC,CAAC,SAAS,WAAW,MAAM,KAAK;;;;;ACA1C,SAAwB,aACtB,OACA,GAAG,MACA;AACH,QAAO,WAAW,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG;;;;;ACP9C,qBAAe,OAAO;;;;ACGtB,SAAwB,UACtB,OACA,cACG;AACH,QAAO,aAAa,MAAM,IAAI,aAAa,aAAa;;;;;ACJ1D,SAAwB,UACtB,WAEA,SACmB;AACnB,KAAI,UACF;AAMF,OAAM,mBAAmB,SACrB,QAAQ,SAAS,GACjB,IAAI,MAAM,UAAU,aAAa,QAAQ,GAAG,QAAQ;;;;;ACjB1D,SAAwB,OAAO,GAAY,GAAqB;AAC9D,QAAO,CAAC,CAAC,MAAM,CAAC,CAAC;;;;;ACDnB,SAAwB,UAAU,OAAkC;AAClE,QAAO,CAAC,CAAC,UAAU;;;;;ACDrB,SAAwB,WAAW,SAAwB;AACzD,kBAAiB;AACf,QAAM,IAAI,MAAM,QAAQ;IACvB,EAAE;;;;;;ACDP,MAAM,iBAAiB;AAGvB,SAAgB,YAEM;CACpB,MAAM,YAAY,EAAE;AAEpB,QAAO;EACL,KAAK,OAAwC,SAAe;AAC1D,gBAAa,MAAM,CAChB,OAAO,aAAa,eAAe,CAAC,CACpC,SAAQ,YAAW;AAClB,YAAQ,QAAQ;KAChB;;EAGN,GAAG,OAAwC,SAAuB;AAChE,aAAU,SAAS,aAAa,MAAM,CAAC,OAAO,QAAQ;AAEtD,UAAO,EACL,MAAM;AACJ,cAAU,SAAS,aAAa,MAAM,CAAC,QAAO,MAAK,MAAM,QAAQ;MAEpE;;EAEJ;CAED,SAAS,aAAa,OAA8C;AAClE,SAAO,UAAU,UAAU,EAAE;;;;;;ACzBjC,MAAM,MAAM,QAAQ;AAEpB,kBAAe;AAEf,SAAgB,OAAO,WAAgC;AACrD,UACG,YACC,GAAG,YAAY,YAAY,MAAM,KAAK,OACxC,EAAE;;;;;ACdN,SAAwB,SACtB,OACA,UAKK;CACL,IAAI,QAAQ;CACZ,IAAI,gBAAgB;AACpB,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,WAAS,MAAM,IAAI,UAAU,EAAE;AAE/B,MAAI,MACF,QAAO;;CAIX,SAAS,SAAS,aAAsB,OAAgB;AACtD,MAAI,aAAa;AACf,WAAQ;AACR,mBAAgB;;;;;;;;;;;ACjBtB,SAAgB,WAAW,OAA8B;AACvD,QAAO,MAAM,SAAS;;;;;;AAOxB,SAAgB,cAAc,OAA8B;AAC1D,QAAO,MAAM,OAAO;;;;;ACXtB,SAAgB,WAAW,OAAiC;AAC1D,QAAO,YAAY,OAAO,EAAE;;;;;ACA9B,MAAM,SAAS;AAEf,SAAgB,KAAK,KAAa,GAAG,eAAuC;CAC1E,MAAM,QAAQ,cAAc;AAE5B,KAAI,SAAS,MAAM,CACjB,QAAO,IAAI,QAAQ,SAAS,aAAa,QAAgB;AACvD,SAAO,GAAG,MAAM,QAAQ;GACxB;CAGJ,MAAM,OAAO,CAAC,GAAG,cAAc;AAE/B,QAAO,IAAI,QAAQ,SAAQ,gBAAe;AACxC,SAAO,GAAG,QAAQ,KAAK,GAAG,cAAc,KAAK,OAAO;GACpD;;;;;ACQJ,SAAS,GAAmB,OAAyB;AACnD,QAAO;EACL,MAAiB,IAAiC;AAChD,UAAO,GAAG,MAAM;;EAElB,IAAO,IAAqB;AAC1B,UAAO,GAAS,GAAG,MAAM,CAAC;;EAE5B,SAAa,KAAuB;AAClC,UAAO;;EAET,MAAS,UAAqD;AAC5D,UAAO,SAAS,GAAG,MAAM;;EAE3B,MAAM;EACN,SAAS;AACP,UAAO;;EAET,SAAS,eAAkB;AACzB,UAAO;;EAET;EACD;;AAGH,SAAS,IAA4B,OAAyB;AAC5D,QAAO;EACL,MAAiB,KAAkC;AACjD,UAAO;;EAET;EACA,IAAO,KAAsB;AAC3B,UAAO;;EAET,SAAa,IAAsB;AACjC,UAAO,IAAW,GAAG,MAAM,CAAC;;EAE9B,MAAS,UAAqD;AAC5D,UAAO,SAAS,IAAI,MAAM;;EAE5B,MAAM;EACN,SAAS;AACP,SAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;;EAEjE,SAAS,cAAiB;AACxB,UAAO;;EAEV;;AAGH,MAAa,aAAa;CAAE,IAAI;CAAI,KAAK;CAAK;AAE9C,MAAM,iBAAiB,cACrB,UAAU,SAAS,QAAQ,UAAU,SAAS;AAEhD,MAAM,kBAAkB,cACtB,WAAW,aAAa,WAAW;AAErC,SAAgB,SAAS,OAAmD;AAC1E,KAAI,CAAC,SAAS,MAAM,CAClB,QAAO;CAGT,MAAM,YAAY;AAElB,KAAI,CAAC,eAAe,UAAU,CAC5B,QAAO;AAGT,QAAO,cAAc,UAAU;;AAGjC,SAAgB,UAAgB,OAA6C;AAC3E,QAAO,MAAM,SAAS;;AAGxB,SAAgB,UAAgB,OAA6C;AAC3E,QAAO,MAAM,SAAS;;;;;;;AAQxB,SAAgB,OAAU,QAA2B;AACnD,KAAI,UAAU,OAAO,CAEnB,OAAM,OAAO,iBAAiB,QAC1B,OAAO,QACP,IAAI,MAAM,OAAO,OAAO,MAAM,CAAC;AAGrC,QAAO,OAAO;;;;;ACpHhB,MAAM,kBAAkB;AA8DxB,SAAgB,aAEd,SAAuE;CAIvE,MAAM,eAAe;CAErB,IAAI,QAAQ,aAAa;AAIzB,QAFY;EAAE;EAAU;EAAS;EAAkB;EAAY;CAI/D,SAAS,WAAoB;AAC3B,SAAO;;CAGT,SAAS,UAAmB;AAC1B,SAAO,QAAQ;;CAGjB,SAAS,WAAW,QAAkB,SAAqC;EACzE,MAAM,SAAS,mBAAmB,cAAc,OAAO,QAAQ,QAAQ;AAEvE,MAAI,UAAU,OAAO,CACnB,QAAO,WAAW,IAAI,OAAO,MAAM;AAGrC,UAAQ,OAAO;AACf,SAAO,WAAW,GAAG,OAAU;;CAGjC,SAAS,iBACP,MACA,QACA,SACS;EACT,MAAM,eAAe,oBAAoB,cAAc,MAAM,OAAO;EACpE,MAAM,SAAS,MAAM,QAAQ,aAAa,GACtC,0BAA0B,cAAc,MAAM,QAAQ,GACtD;AAEJ,SAAO,CAAC,UAAU,WAAW,OAAO,OAAQ;;;AAIhD,SAAS,oBACP,SACA,MACA,QACiC;AACjC,QACE,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,mBAAmB;;AAIxE,SAAS,0BACP,QACA,MACA,SACG;CACH,MAAM,CAAC,WAAW,eAAe;AACjC,QAAO,YAAY,QAAQ,GAAG,YAAY;;AAG5C,SAAS,mBACP,SACA,MACA,QACA,SACmB;CACnB,MAAM,eAAe,oBAAoB,SAAS,MAAM,OAAO;AAE/D,KAAI,CAAC,aACH,QAAO,WAAW,IAChB,wBAAwB,OAAO,gBAAgB,KAAK,GACrD;AAGH,KAAI,MAAM,QAAQ,aAAa,EAAE;EAC/B,MAAM,CAAC,gBAAgB,eAAe;AACtC,MAAI,CAAC,YAAY,QAAQ,CACvB,QAAO,WAAW,IAChB,wBAAwB,OAAO,gBAAgB,KAAK,wBACrD;AAEH,SAAO,WAAW,GAAG,eAAe;;AAGtC,QAAO,WAAW,GAAG,aAAkB;;;;;ACvJzC,SAAgB,WAAc,OAAmB,OAAmB;AAClE,WAAU,CAAC,UAAU,MAAM,EAAE,MAAM;AAEnC,QAAO;;;;;;ACJT,SAAgB,gBACd,cACc;CACd,IAAIC;AAEJ,aAAY;AAEZ,cAAa;EAAC;EAAO;EAAU;EAAW;CAE1C,SAAS,SAAS,WAA6B;AAC7C,UAAQ,aAAa,WAAW,MAAM;;CAGxC,SAAS,aAAa;AACpB,WAAS,aAAa,aAAa,CAAC;;;;;;ACdxC,SAAgB,aAAa,OAA4B;AACvD,QAAO,IAAI,OAAO,aAAa,MAAM,CAAC;;;;;;;;;ACAxC,SAAgB,IAAa,GAAG,GAA0C;AACxE,SAAQ,UACN,QAAQ,EAAE,GAAG,QAAQ,EAAE,OAAM,cAAa,aAAa,WAAW,MAAM,CAAC;;AAG7E,SAAgB,IAAa,GAAG,GAA0C;AACxE,SAAQ,UACN,QAAQ,EAAE,GAAG,QAAQ,EAAE,MAAK,cAAa,aAAa,WAAW,MAAM,CAAC;;;;;ACT5E,SAAgB,aAA+B,GAAG,MAAuB;AACvE,QAAO,OAAO,OAAOC,eAAO,GAAI,KAAsB,CAAC;;;;;ACDzD,SAAgB,UAAa,IAA8B;AACzD,cAAa;AACX,MAAI;AACF,UAAO,IAAI;WACJ,OAAO;AACd,UAAO;;;;;;;ACDb,SAAgB,UAAqC,OAAmB;AACtE,QAAO;;;;;ACLT,SAAgB,SAAS,OAAoC;CAC3D,MAAM,MAAM,OAAO,MAAM;AAEzB,KAAI,OAAO,MAAM,IAAI,CACnB,QAAO,WAAW,IAAI,UAAU,MAAM,mBAAmB;AAG3D,QAAO,WAAW,GAAG,IAAI"}

package/minifyObject/package.json

@@ -1,10 +1,14 @@
 {
-  "main": "../dist/cjs/minifyObject.js",
-  "module": "../dist/es/minifyObject.production.js",
-  "unpkg": "../dist/umd/minifyObject.production.js",
-  "jsdelivr": "../dist/umd/minifyObject.production.js",
-  "name": "minifyObject",
-  "types": "../types/minifyObject.d.ts",
-  "license": "MIT",
-  "private": true
+  "exports": {
+    ".": {
+      "default": "../dist/exports/minifyObject.mjs",
+      "import": "../dist/exports/minifyObject.mjs",
+      "require": "../dist/exports/minifyObject.cjs",
+      "types": "../types/exports/minifyObject.d.mts"
+    }
+  },
+  "main": "../dist/exports/minifyObject.cjs",
+  "module": "../dist/exports/minifyObject.mjs",
+  "type": "module",
+  "types": "../types/exports/minifyObject.d.mts"
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.0",
+  "version": "2.0.1",
   "name": "vest-utils",
   "author": "ealush",
   "scripts": {
@@ -7,73 +7,58 @@
     "build": "vx build",
     "release": "vx release"
   },
-  "main": "./dist/cjs/vest-utils.js",
-  "module": "./dist/es/vest-utils.production.js",
-  "unpkg": "./dist/umd/vest-utils.production.js",
-  "jsdelivr": "./dist/umd/vest-utils.production.js",
-  "types": "./types/vest-utils.d.ts",
+  "main": "./dist/vest-utils.cjs",
+  "module": "./dist/vest-utils.mjs",
+  "unpkg": "./dist/vest-utils.mjs",
+  "jsdelivr": "./dist/vest-utils.mjs",
+  "types": "./types/vest-utils.d.cts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ealush/vest.git",
+    "url": "git+https://github.com/ealush/vest.git",
     "directory": "packages/vest-utils"
   },
   "bugs": {
     "url": "https://github.com/ealush/vest.git/issues"
   },
+  "license": "MIT",
   "exports": {
-    "./minifyObject": {
-      "production": {
-        "types": "./types/minifyObject.d.ts",
-        "browser": "./dist/es/minifyObject.production.js",
-        "umd": "./dist/umd/minifyObject.production.js",
-        "import": "./dist/es/minifyObject.production.js",
-        "require": "./dist/cjs/minifyObject.production.js",
-        "node": "./dist/cjs/minifyObject.production.js",
-        "module": "./dist/es/minifyObject.production.js",
-        "default": "./dist/cjs/minifyObject.production.js"
-      },
-      "development": {
-        "types": "./types/minifyObject.d.ts",
-        "browser": "./dist/es/minifyObject.development.js",
-        "umd": "./dist/umd/minifyObject.development.js",
-        "import": "./dist/es/minifyObject.development.js",
-        "require": "./dist/cjs/minifyObject.development.js",
-        "node": "./dist/cjs/minifyObject.development.js",
-        "module": "./dist/es/minifyObject.development.js",
-        "default": "./dist/cjs/minifyObject.development.js"
-      },
-      "types": "./types/minifyObject.d.ts",
-      "browser": "./dist/es/minifyObject.production.js",
-      "umd": "./dist/umd/minifyObject.production.js",
-      "import": "./dist/es/minifyObject.production.js",
-      "require": "./dist/cjs/minifyObject.production.js",
-      "node": "./dist/cjs/minifyObject.production.js",
-      "module": "./dist/es/minifyObject.production.js",
-      "default": "./dist/cjs/minifyObject.production.js"
+    "./exports/minifyObject": {
+      "types": "./types/exports/minifyObject.d.cts",
+      "require": "./dist/exports/minifyObject.cjs",
+      "import": "./dist/exports/minifyObject.mjs"
+    },
+    "./exports/standardSchemaSpec": {
+      "types": "./types/exports/standardSchemaSpec.d.cts",
+      "require": "./dist/exports/standardSchemaSpec.cjs",
+      "import": "./dist/exports/standardSchemaSpec.mjs"
+    },
+    "./vest-utils": {
+      "types": "./types/vest-utils.d.cts",
+      "require": "./dist/vest-utils.cjs",
+      "import": "./dist/vest-utils.mjs"
+    },
+    "./*": {
+      "types": "./types/vest-utils.d.cts",
+      "default": "./*"
     },
     ".": {
-      "development": {
-        "types": "./types/vest-utils.d.ts",
-        "browser": "./dist/es/vest-utils.development.js",
-        "umd": "./dist/umd/vest-utils.development.js",
-        "import": "./dist/es/vest-utils.development.js",
-        "require": "./dist/cjs/vest-utils.development.js",
-        "node": "./dist/cjs/vest-utils.development.js",
-        "module": "./dist/es/vest-utils.development.js",
-        "default": "./dist/cjs/vest-utils.development.js"
-      },
-      "types": "./types/vest-utils.d.ts",
-      "browser": "./dist/es/vest-utils.production.js",
-      "umd": "./dist/umd/vest-utils.production.js",
-      "import": "./dist/es/vest-utils.production.js",
-      "require": "./dist/cjs/vest-utils.production.js",
-      "node": "./dist/cjs/vest-utils.production.js",
-      "module": "./dist/es/vest-utils.production.js",
-      "default": "./dist/cjs/vest-utils.production.js"
+      "types": "./types/vest-utils.d.cts",
+      "require": "./dist/vest-utils.cjs",
+      "import": "./dist/vest-utils.mjs"
     },
     "./package.json": "./package.json",
-    "./*": "./*"
-  },
-  "vxAllowResolve": [],
-  "license": "MIT"
+    "./minifyObject": {
+      "types": "./types/exports/minifyObject.d.cts",
+      "require": "./dist/exports/minifyObject.cjs",
+      "import": "./dist/exports/minifyObject.mjs"
+    },
+    "./standardSchemaSpec": {
+      "types": "./types/exports/standardSchemaSpec.d.cts",
+      "require": "./dist/exports/standardSchemaSpec.cjs",
+      "import": "./dist/exports/standardSchemaSpec.mjs"
+    },
+    "./vest-utils.d.ts": "./types/vest-utils.d.ts",
+    "./types/*": "./types/*",
+    "./dist/*": "./dist/*"
+  }
 }

package/src/Brand.ts

@@ -0,0 +1,9 @@
+// Utility for creating opaque branded types to avoid primitive mixing
+// Brand is represented as an intersection type with a unique symbol index
+// This pattern prevents accidental assignment between different domain primitives
+
+export type Brand<T, B> = T & { readonly __brand: B };
+
+export function makeBrand<T extends Brand<any, any>>(value: unknown): T {
+  return value as T;
+}

package/src/IO.ts

@@ -0,0 +1,2 @@
+// IO represents a deferred computation. Executing the function performs the effect.
+export type IO<T> = () => T;

package/src/Predicates.ts

@@ -0,0 +1,13 @@
+import dynamicValue from './dynamicValue';
+import { isEmpty } from './isEmpty';
+import { Predicate } from './utilityTypes';
+
+export function all<T = any>(...p: Predicate<T>[]): (value: T) => boolean {
+  return (value: T) =>
+    isEmpty(p) ? false : p.every(predicate => dynamicValue(predicate, value));
+}
+
+export function any<T = any>(...p: Predicate<T>[]): (value: T) => boolean {
+  return (value: T) =>
+    isEmpty(p) ? false : p.some(predicate => dynamicValue(predicate, value));
+}