nana 1.2.0 → 2.0.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## v2.0.0 / 2026-02-25
+
+- add validateAll to collect all validation errors
+- add InferOutput to get schema type
+- refactor: use tsdown instead of tsup
+- chore(deps): update deps
+
 ## v1.2.0 / 2025-12-16
 
 - fix: rename __skipNext to __abortPipe

package/README.md

@@ -6,7 +6,7 @@
 
 A minimal validator for any JavaScript environment.
 
-- ~200 lines of code, 0 dependencies
+- ~360 lines of code, 0 dependencies
 - Only 3 concepts: `pipe`, `transform`, `check`
 - Rich error context: `expected/actual/path/key/parent/root`
 
@@ -48,6 +48,7 @@ console.log(
     actual: 'God',
     path: '$.job.title',
     key: 'title',
+    message: 'You cannot be God',
     parent: { title: 'God' },
     root: { name: 'nana', job: [Object] }
   },
@@ -173,6 +174,47 @@ console.log(
 */
 ```
 
+## validateAll (collect all errors)
+
+Unlike `validate` which stops at the first error, `validateAll` collects all validation errors:
+
+```js
+import { string, number, object, validateAll } from 'nana'
+
+const userSchema = object({
+  name: string(),
+  age: number()
+})
+
+const result = validateAll(userSchema, { name: 2, age: 'nana' })
+
+/*
+{
+  valid: false,
+  errors: [
+    Error: ($.name: 2) ✖ string,
+    Error: ($.age: nana) ✖ number
+  ],
+  result: { name: 2, age: 'nana' }
+}
+*/
+
+## TypeScript
+
+Use `InferOutput` to extract the output type from a schema:
+
+```ts
+import { string, number, object, InferOutput } from 'nana'
+
+const userSchema = object({
+  name: string(),
+  age: number()
+})
+
+type User = InferOutput<typeof userSchema>
+// type User = { name: string; age: number }
+```
+
 ## With third party validator
 
 ```js

package/dist/cjs/index.cjs

@@ -1,217 +1,227 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_exports = {};
-__export(index_exports, {
-  array: () => array,
-  bigint: () => bigint,
-  boolean: () => boolean,
-  check: () => check,
-  createValidator: () => createValidator,
-  formatValue: () => formatValue,
-  makeCtx: () => makeCtx,
-  number: () => number,
-  object: () => object,
-  optional: () => optional,
-  pipe: () => pipe,
-  required: () => required,
-  string: () => string,
-  symbol: () => symbol,
-  transform: () => transform,
-  validate: () => validate
-});
-module.exports = __toCommonJS(index_exports);
-function makeCtx(parentCtx, key, value) {
-  let path;
-  if (!parentCtx) path = "$";
-  else if (typeof key === "number") path = `${parentCtx.path}[${key}]`;
-  else path = `${parentCtx.path}.${key}`;
-  return {
-    path,
-    key,
-    parent: parentCtx ? parentCtx.value : null,
-    root: parentCtx ? parentCtx.root : value,
-    value
-  };
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region index.ts
+const DEFAULT_ROOT_PATH = "$";
+function collectError(ctx, error) {
+	if (!ctx.__errors) ctx.__errors = [];
+	ctx.__errors.push(error);
+}
+function attachCollector(parentCtx, childCtx) {
+	if (!parentCtx.__collectErrors) return;
+	childCtx.__collectErrors = true;
+	childCtx.__errors = parentCtx.__errors;
+}
+function makeCtx(parentCtx, key, value, root) {
+	let path;
+	if (!parentCtx) path = DEFAULT_ROOT_PATH;
+	else if (typeof key === "number") path = `${parentCtx.path}[${key}]`;
+	else path = `${parentCtx.path}.${key}`;
+	return {
+		path,
+		key,
+		parent: parentCtx ? parentCtx.value : null,
+		root: parentCtx ? parentCtx.root : value,
+		value
+	};
 }
 function formatValue(value) {
-  if (value === null || value === void 0) return String(value);
-  const type = typeof value;
-  if (type === "string") return value;
-  if (type === "number" || type === "boolean" || type === "bigint") return String(value);
-  if (type === "symbol") return value.toString();
-  if (type === "function") {
-    const name = value.name ? `: ${value.name}` : "";
-    return `[Function${name}]`;
-  }
-  if (value instanceof RegExp) return value.toString();
-  if (value instanceof Date) return value.toISOString();
-  if (Array.isArray(value) || value && Object.getPrototypeOf(value) === Object.prototype) {
-    return JSON.stringify(value);
-  }
-  return Object.prototype.toString.call(value);
+	if (value === null || value === void 0) return String(value);
+	const type = typeof value;
+	if (type === "string") return value;
+	if (type === "number" || type === "boolean" || type === "bigint") return String(value);
+	if (type === "symbol") return value.toString();
+	if (type === "function") return `[Function${value.name ? `: ${value.name}` : ""}]`;
+	if (value instanceof RegExp) return value.toString();
+	if (value instanceof Date) return value.toISOString();
+	if (Array.isArray(value) || value && Object.getPrototypeOf(value) === Object.prototype) return JSON.stringify(value);
+	return Object.prototype.toString.call(value);
 }
 function createValidator(name, handler) {
-  return function validatorFactory(...args) {
-    return function validatorFn(value, ctx) {
-      try {
-        return handler(value, ctx, args);
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        if (!error.expected) {
-          error.expected = name;
-          error.actual = value;
-          error.path = ctx.path;
-          error.key = ctx.key;
-          error.parent = ctx.parent;
-          error.root = ctx.root;
-        }
-        throw error;
-      }
-    };
-  };
+	return function validatorFactory(...args) {
+		return function validatorFn(value, ctx) {
+			try {
+				return handler(value, ctx, args);
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				if (!error.expected) {
+					error.expected = name;
+					error.actual = value;
+					error.path = ctx.path;
+					error.key = ctx.key;
+					error.parent = ctx.parent;
+					error.root = ctx.root;
+				}
+				if (ctx.__collectErrors) {
+					collectError(ctx, error);
+					ctx.__abortPipe = true;
+					return value;
+				}
+				throw error;
+			}
+		};
+	};
 }
 function pipe(...validators) {
-  return createValidator("pipe", (value, ctx) => {
-    for (const validator of validators) {
-      if (ctx.__abortPipe) break;
-      value = validator(value, ctx);
-    }
-    delete ctx.__abortPipe;
-    return value;
-  })();
+	return createValidator("pipe", (value, ctx) => {
+		for (const validator of validators) {
+			if (ctx.__abortPipe) break;
+			value = validator(value, ctx);
+		}
+		delete ctx.__abortPipe;
+		return value;
+	})();
 }
 function transform(fn) {
-  return createValidator("transform", (value, ctx) => fn(value, ctx))();
+	return createValidator("transform", (value, ctx) => fn(value, ctx))();
 }
 function check(fn, msg) {
-  const expected = fn.name || "check";
-  return createValidator(expected, (value, ctx) => {
-    const result = fn(value, ctx);
-    if (result === true) return value;
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 ${expected}`);
-  })();
+	const expected = fn.name || "check";
+	return createValidator(expected, (value, ctx) => {
+		if (fn(value, ctx) === true) return value;
+		throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ ${expected}`);
+	})();
 }
-function validate(schema, value, rootPath = "$") {
-  const ctx = {
-    path: rootPath,
-    key: null,
-    parent: null,
-    root: value,
-    value
-  };
-  try {
-    const result = schema(value, ctx);
-    return { valid: true, result };
-  } catch (error) {
-    return {
-      valid: false,
-      error,
-      result: value
-    };
-  }
+function validate(schema, value, rootPath = DEFAULT_ROOT_PATH) {
+	const ctx = {
+		path: rootPath,
+		key: null,
+		parent: null,
+		root: value,
+		value
+	};
+	try {
+		return {
+			valid: true,
+			result: schema(value, ctx)
+		};
+	} catch (error) {
+		return {
+			valid: false,
+			error,
+			result: value
+		};
+	}
+}
+function validateAll(schema, value, rootPath = DEFAULT_ROOT_PATH) {
+	const ctx = {
+		path: rootPath,
+		key: null,
+		parent: null,
+		root: value,
+		value,
+		__collectErrors: true,
+		__errors: []
+	};
+	let result = value;
+	try {
+		result = schema(value, ctx);
+	} catch (error) {
+		collectError(ctx, error);
+	}
+	const errors = ctx.__errors ?? [];
+	if (errors.length > 0) return {
+		valid: false,
+		errors,
+		result: value
+	};
+	return {
+		valid: true,
+		result,
+		errors: []
+	};
 }
 const required = createValidator("required", (value, ctx, args) => {
-  const [msg] = args;
-  if (value == null) {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 required`);
-  }
-  return value;
+	const [msg] = args;
+	if (value == null) throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ required`);
+	return value;
 });
-const optional = createValidator("optional", (value, ctx, args) => {
-  if (value == null) {
-    ctx.__abortPipe = true;
-    return value;
-  }
-  return value;
+const optional = createValidator("optional", (value, ctx) => {
+	if (value == null) {
+		ctx.__abortPipe = true;
+		return value;
+	}
+	return value;
 });
 const string = createValidator("string", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "string") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 string`);
-  }
-  return value;
+	const [msg] = args;
+	if (typeof value !== "string") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ string`);
+	return value;
 });
 const number = createValidator("number", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "number") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 number`);
-  }
-  return value;
+	const [msg] = args;
+	if (typeof value !== "number") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ number`);
+	return value;
 });
 const bigint = createValidator("bigint", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "bigint") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 bigint`);
-  }
-  return value;
+	const [msg] = args;
+	if (typeof value !== "bigint") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ bigint`);
+	return value;
 });
 const boolean = createValidator("boolean", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "boolean") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 boolean`);
-  }
-  return value;
+	const [msg] = args;
+	if (typeof value !== "boolean") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ boolean`);
+	return value;
 });
 const symbol = createValidator("symbol", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "symbol") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 symbol`);
-  }
-  return value;
-});
-const object = createValidator("object", (value, ctx, args) => {
-  const [obj, msg] = args;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 object`);
-  }
-  const result = {};
-  for (const key in obj) {
-    const childCtx = makeCtx(ctx, key, value[key]);
-    result[key] = obj[key](value[key], childCtx);
-  }
-  return result;
-});
-const array = createValidator("array", (value, ctx, args) => {
-  const [validator, msg] = args;
-  if (!Array.isArray(value)) {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 array`);
-  }
-  return value.map((item, i) => {
-    const childCtx = makeCtx(ctx, i, item);
-    return validator(item, childCtx);
-  });
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  array,
-  bigint,
-  boolean,
-  check,
-  createValidator,
-  formatValue,
-  makeCtx,
-  number,
-  object,
-  optional,
-  pipe,
-  required,
-  string,
-  symbol,
-  transform,
-  validate
+	const [msg] = args;
+	if (typeof value !== "symbol") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ symbol`);
+	return value;
 });
+function object(shape, msg) {
+	return createValidator("object", (value, ctx) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ object`);
+		const result = {};
+		for (const key in shape) {
+			const childCtx = makeCtx(ctx, key, value[key]);
+			attachCollector(ctx, childCtx);
+			try {
+				result[key] = shape[key](value[key], childCtx);
+			} catch (error) {
+				if (ctx.__collectErrors) {
+					collectError(ctx, error);
+					result[key] = value[key];
+					continue;
+				}
+				throw error;
+			}
+		}
+		return result;
+	})();
+}
+function array(validator, msg) {
+	return createValidator("array", (value, ctx) => {
+		if (!Array.isArray(value)) throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ array`);
+		return value.map((item, i) => {
+			const childCtx = makeCtx(ctx, i, item);
+			attachCollector(ctx, childCtx);
+			try {
+				return validator(item, childCtx);
+			} catch (error) {
+				if (ctx.__collectErrors) {
+					collectError(ctx, error);
+					return item;
+				}
+				throw error;
+			}
+		});
+	})();
+}
+
+//#endregion
+exports.array = array;
+exports.bigint = bigint;
+exports.boolean = boolean;
+exports.check = check;
+exports.createValidator = createValidator;
+exports.formatValue = formatValue;
+exports.makeCtx = makeCtx;
+exports.number = number;
+exports.object = object;
+exports.optional = optional;
+exports.pipe = pipe;
+exports.required = required;
+exports.string = string;
+exports.symbol = symbol;
+exports.transform = transform;
+exports.validate = validate;
+exports.validateAll = validateAll;

package/dist/cjs/index.d.cts

@@ -0,0 +1,70 @@
+//#region index.d.ts
+interface Ctx {
+  path: string;
+  key: string | number | null;
+  parent: any;
+  root: any;
+  __abortPipe?: boolean;
+  __collectErrors?: boolean;
+  __errors?: ValidationError[];
+  [key: string]: any;
+}
+type Validator<Input = any, Output = Input> = (value: Input, ctx: Ctx) => Output;
+interface ValidationError extends Error {
+  expected?: string;
+  actual?: any;
+  path?: string;
+  key?: string | number | null;
+  parent?: any;
+  root?: any;
+}
+type ValidatorFactory<Input = any, Output = Input, Args extends any[] = any[]> = (...args: Args) => Validator<Input, Output>;
+declare function makeCtx(parentCtx: Ctx | null, key: string | number | null, value: any, root?: any): Ctx;
+declare function formatValue(value: any): string;
+declare function createValidator<I = unknown, O = I, Args extends any[] = any[]>(name: string, handler: (value: I, ctx: Ctx, args: Args) => O): (...args: Args) => Validator<I, O>;
+interface ControlValidator {
+  __control?: true;
+}
+type IsControl<V> = V extends ControlValidator ? true : false;
+type InputOf<V> = V extends ((value: infer I, ctx: Ctx) => any) ? I : never;
+type OutputOf<V> = V extends ((value: any, ctx: Ctx) => infer O) ? O : never;
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type DeepSimplify<T> = T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends Function ? T : T extends (infer U)[] ? Array<DeepSimplify<U>> : T extends object ? Simplify<{ [K in keyof T]: DeepSimplify<T[K]> }> : T;
+type InferOutput<V> = V extends ((value: any, ctx: Ctx) => infer O) ? DeepSimplify<O> : never;
+type Last<T extends unknown[]> = T extends [...any[], infer L] ? L : never;
+type ValidateChain<Vs extends unknown[]> = Vs extends [infer V1, infer V2, ...infer Rest] ? IsControl<V1> extends true ? [V1, ...ValidateChain<[V2, ...Rest]>] : OutputOf<V1> extends InputOf<V2> ? [V1, ...ValidateChain<[V2, ...Rest]>] : never : Vs;
+declare function pipe<Vs extends [Validator<any, any>, ...(Validator<any, any>)[]]>(...validators: ValidateChain<Vs>): Validator<InputOf<Vs[0]>, OutputOf<Last<Vs>>>;
+declare function transform<I = any, O = any>(fn: (value: I, ctx: Ctx) => O): Validator<I, O>;
+declare function check<I = any>(fn: (value: I, ctx: Ctx) => boolean, msg?: string): Validator<I, I>;
+type ValidateResult<O> = {
+  valid: true;
+  result: O;
+  error?: undefined;
+} | {
+  valid: false;
+  error: ValidationError;
+  result: any;
+};
+declare function validate<I, O>(schema: Validator<I, O>, value: I, rootPath?: string): ValidateResult<O>;
+type ValidateAllResult<O> = {
+  valid: true;
+  result: O;
+  errors: [];
+} | {
+  valid: false;
+  result: any;
+  errors: ValidationError[];
+};
+declare function validateAll<I, O>(schema: Validator<I, O>, value: I, rootPath?: string): ValidateAllResult<O>;
+declare const required: (args_0?: string | undefined) => Validator<any, any>;
+declare const optional: () => (Validator<any, any> & ControlValidator);
+declare const string: (args_0?: string | undefined) => Validator<string, string>;
+declare const number: (args_0?: string | undefined) => Validator<number, number>;
+declare const bigint: (args_0?: string | undefined) => Validator<bigint, bigint>;
+declare const boolean: (args_0?: string | undefined) => Validator<boolean, boolean>;
+declare const symbol: (args_0?: string | undefined) => Validator<symbol, symbol>;
+type InferShape<S> = { [K in keyof S]: S[K] extends Validator<any, infer O> ? O : never };
+declare function object<S extends Record<string, Validator<any, any>>>(shape: S, msg?: string): Validator<unknown, InferShape<S>>;
+declare function array<T>(validator: Validator<any, T>, msg?: string): Validator<T[], T[]>;
+//#endregion
+export { Ctx, InferOutput, InferShape, ValidateAllResult, ValidateResult, ValidationError, Validator, ValidatorFactory, array, bigint, boolean, check, createValidator, formatValue, makeCtx, number, object, optional, pipe, required, string, symbol, transform, validate, validateAll };

package/dist/esm/index.d.mts

@@ -0,0 +1,70 @@
+//#region index.d.ts
+interface Ctx {
+  path: string;
+  key: string | number | null;
+  parent: any;
+  root: any;
+  __abortPipe?: boolean;
+  __collectErrors?: boolean;
+  __errors?: ValidationError[];
+  [key: string]: any;
+}
+type Validator<Input = any, Output = Input> = (value: Input, ctx: Ctx) => Output;
+interface ValidationError extends Error {
+  expected?: string;
+  actual?: any;
+  path?: string;
+  key?: string | number | null;
+  parent?: any;
+  root?: any;
+}
+type ValidatorFactory<Input = any, Output = Input, Args extends any[] = any[]> = (...args: Args) => Validator<Input, Output>;
+declare function makeCtx(parentCtx: Ctx | null, key: string | number | null, value: any, root?: any): Ctx;
+declare function formatValue(value: any): string;
+declare function createValidator<I = unknown, O = I, Args extends any[] = any[]>(name: string, handler: (value: I, ctx: Ctx, args: Args) => O): (...args: Args) => Validator<I, O>;
+interface ControlValidator {
+  __control?: true;
+}
+type IsControl<V> = V extends ControlValidator ? true : false;
+type InputOf<V> = V extends ((value: infer I, ctx: Ctx) => any) ? I : never;
+type OutputOf<V> = V extends ((value: any, ctx: Ctx) => infer O) ? O : never;
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type DeepSimplify<T> = T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends Function ? T : T extends (infer U)[] ? Array<DeepSimplify<U>> : T extends object ? Simplify<{ [K in keyof T]: DeepSimplify<T[K]> }> : T;
+type InferOutput<V> = V extends ((value: any, ctx: Ctx) => infer O) ? DeepSimplify<O> : never;
+type Last<T extends unknown[]> = T extends [...any[], infer L] ? L : never;
+type ValidateChain<Vs extends unknown[]> = Vs extends [infer V1, infer V2, ...infer Rest] ? IsControl<V1> extends true ? [V1, ...ValidateChain<[V2, ...Rest]>] : OutputOf<V1> extends InputOf<V2> ? [V1, ...ValidateChain<[V2, ...Rest]>] : never : Vs;
+declare function pipe<Vs extends [Validator<any, any>, ...(Validator<any, any>)[]]>(...validators: ValidateChain<Vs>): Validator<InputOf<Vs[0]>, OutputOf<Last<Vs>>>;
+declare function transform<I = any, O = any>(fn: (value: I, ctx: Ctx) => O): Validator<I, O>;
+declare function check<I = any>(fn: (value: I, ctx: Ctx) => boolean, msg?: string): Validator<I, I>;
+type ValidateResult<O> = {
+  valid: true;
+  result: O;
+  error?: undefined;
+} | {
+  valid: false;
+  error: ValidationError;
+  result: any;
+};
+declare function validate<I, O>(schema: Validator<I, O>, value: I, rootPath?: string): ValidateResult<O>;
+type ValidateAllResult<O> = {
+  valid: true;
+  result: O;
+  errors: [];
+} | {
+  valid: false;
+  result: any;
+  errors: ValidationError[];
+};
+declare function validateAll<I, O>(schema: Validator<I, O>, value: I, rootPath?: string): ValidateAllResult<O>;
+declare const required: (args_0?: string | undefined) => Validator<any, any>;
+declare const optional: () => (Validator<any, any> & ControlValidator);
+declare const string: (args_0?: string | undefined) => Validator<string, string>;
+declare const number: (args_0?: string | undefined) => Validator<number, number>;
+declare const bigint: (args_0?: string | undefined) => Validator<bigint, bigint>;
+declare const boolean: (args_0?: string | undefined) => Validator<boolean, boolean>;
+declare const symbol: (args_0?: string | undefined) => Validator<symbol, symbol>;
+type InferShape<S> = { [K in keyof S]: S[K] extends Validator<any, infer O> ? O : never };
+declare function object<S extends Record<string, Validator<any, any>>>(shape: S, msg?: string): Validator<unknown, InferShape<S>>;
+declare function array<T>(validator: Validator<any, T>, msg?: string): Validator<T[], T[]>;
+//#endregion
+export { Ctx, InferOutput, InferShape, ValidateAllResult, ValidateResult, ValidationError, Validator, ValidatorFactory, array, bigint, boolean, check, createValidator, formatValue, makeCtx, number, object, optional, pipe, required, string, symbol, transform, validate, validateAll };

package/dist/esm/index.mjs

@@ -0,0 +1,209 @@
+//#region index.ts
+const DEFAULT_ROOT_PATH = "$";
+function collectError(ctx, error) {
+	if (!ctx.__errors) ctx.__errors = [];
+	ctx.__errors.push(error);
+}
+function attachCollector(parentCtx, childCtx) {
+	if (!parentCtx.__collectErrors) return;
+	childCtx.__collectErrors = true;
+	childCtx.__errors = parentCtx.__errors;
+}
+function makeCtx(parentCtx, key, value, root) {
+	let path;
+	if (!parentCtx) path = DEFAULT_ROOT_PATH;
+	else if (typeof key === "number") path = `${parentCtx.path}[${key}]`;
+	else path = `${parentCtx.path}.${key}`;
+	return {
+		path,
+		key,
+		parent: parentCtx ? parentCtx.value : null,
+		root: parentCtx ? parentCtx.root : value,
+		value
+	};
+}
+function formatValue(value) {
+	if (value === null || value === void 0) return String(value);
+	const type = typeof value;
+	if (type === "string") return value;
+	if (type === "number" || type === "boolean" || type === "bigint") return String(value);
+	if (type === "symbol") return value.toString();
+	if (type === "function") return `[Function${value.name ? `: ${value.name}` : ""}]`;
+	if (value instanceof RegExp) return value.toString();
+	if (value instanceof Date) return value.toISOString();
+	if (Array.isArray(value) || value && Object.getPrototypeOf(value) === Object.prototype) return JSON.stringify(value);
+	return Object.prototype.toString.call(value);
+}
+function createValidator(name, handler) {
+	return function validatorFactory(...args) {
+		return function validatorFn(value, ctx) {
+			try {
+				return handler(value, ctx, args);
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				if (!error.expected) {
+					error.expected = name;
+					error.actual = value;
+					error.path = ctx.path;
+					error.key = ctx.key;
+					error.parent = ctx.parent;
+					error.root = ctx.root;
+				}
+				if (ctx.__collectErrors) {
+					collectError(ctx, error);
+					ctx.__abortPipe = true;
+					return value;
+				}
+				throw error;
+			}
+		};
+	};
+}
+function pipe(...validators) {
+	return createValidator("pipe", (value, ctx) => {
+		for (const validator of validators) {
+			if (ctx.__abortPipe) break;
+			value = validator(value, ctx);
+		}
+		delete ctx.__abortPipe;
+		return value;
+	})();
+}
+function transform(fn) {
+	return createValidator("transform", (value, ctx) => fn(value, ctx))();
+}
+function check(fn, msg) {
+	const expected = fn.name || "check";
+	return createValidator(expected, (value, ctx) => {
+		if (fn(value, ctx) === true) return value;
+		throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ ${expected}`);
+	})();
+}
+function validate(schema, value, rootPath = DEFAULT_ROOT_PATH) {
+	const ctx = {
+		path: rootPath,
+		key: null,
+		parent: null,
+		root: value,
+		value
+	};
+	try {
+		return {
+			valid: true,
+			result: schema(value, ctx)
+		};
+	} catch (error) {
+		return {
+			valid: false,
+			error,
+			result: value
+		};
+	}
+}
+function validateAll(schema, value, rootPath = DEFAULT_ROOT_PATH) {
+	const ctx = {
+		path: rootPath,
+		key: null,
+		parent: null,
+		root: value,
+		value,
+		__collectErrors: true,
+		__errors: []
+	};
+	let result = value;
+	try {
+		result = schema(value, ctx);
+	} catch (error) {
+		collectError(ctx, error);
+	}
+	const errors = ctx.__errors ?? [];
+	if (errors.length > 0) return {
+		valid: false,
+		errors,
+		result: value
+	};
+	return {
+		valid: true,
+		result,
+		errors: []
+	};
+}
+const required = createValidator("required", (value, ctx, args) => {
+	const [msg] = args;
+	if (value == null) throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ required`);
+	return value;
+});
+const optional = createValidator("optional", (value, ctx) => {
+	if (value == null) {
+		ctx.__abortPipe = true;
+		return value;
+	}
+	return value;
+});
+const string = createValidator("string", (value, ctx, args) => {
+	const [msg] = args;
+	if (typeof value !== "string") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ string`);
+	return value;
+});
+const number = createValidator("number", (value, ctx, args) => {
+	const [msg] = args;
+	if (typeof value !== "number") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ number`);
+	return value;
+});
+const bigint = createValidator("bigint", (value, ctx, args) => {
+	const [msg] = args;
+	if (typeof value !== "bigint") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ bigint`);
+	return value;
+});
+const boolean = createValidator("boolean", (value, ctx, args) => {
+	const [msg] = args;
+	if (typeof value !== "boolean") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ boolean`);
+	return value;
+});
+const symbol = createValidator("symbol", (value, ctx, args) => {
+	const [msg] = args;
+	if (typeof value !== "symbol") throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ symbol`);
+	return value;
+});
+function object(shape, msg) {
+	return createValidator("object", (value, ctx) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ object`);
+		const result = {};
+		for (const key in shape) {
+			const childCtx = makeCtx(ctx, key, value[key]);
+			attachCollector(ctx, childCtx);
+			try {
+				result[key] = shape[key](value[key], childCtx);
+			} catch (error) {
+				if (ctx.__collectErrors) {
+					collectError(ctx, error);
+					result[key] = value[key];
+					continue;
+				}
+				throw error;
+			}
+		}
+		return result;
+	})();
+}
+function array(validator, msg) {
+	return createValidator("array", (value, ctx) => {
+		if (!Array.isArray(value)) throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) ✖ array`);
+		return value.map((item, i) => {
+			const childCtx = makeCtx(ctx, i, item);
+			attachCollector(ctx, childCtx);
+			try {
+				return validator(item, childCtx);
+			} catch (error) {
+				if (ctx.__collectErrors) {
+					collectError(ctx, error);
+					return item;
+				}
+				throw error;
+			}
+		});
+	})();
+}
+
+//#endregion
+export { array, bigint, boolean, check, createValidator, formatValue, makeCtx, number, object, optional, pipe, required, string, symbol, transform, validate, validateAll };

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "nana",
   "description": "A minimal validator for any JavaScript environment.",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "type": "module",
   "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "types": "types/index.d.ts",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/esm/index.d.mts",
   "exports": {
     ".": {
-      "types": "./types/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.cjs",
-      "default": "./dist/esm/index.js"
+      "import": {
+        "types": "./dist/esm/index.d.mts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
     }
   },
   "files": [
@@ -23,9 +27,10 @@
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "build": "tsup",
+    "build": "tsdown",
+    "type-check": "tsc --noEmit",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "prepublishOnly": "npm run lint && npm run test && npm run build",
+    "prepublishOnly": "npm run type-check && npm run lint && npm run test && npm run build",
     "prepare": "husky"
   },
   "author": "nswbmw",
@@ -40,16 +45,20 @@
     "schema",
     "json-schema",
     "zod",
-    "valibot"
+    "valibot",
+    "typescript"
   ],
   "devDependencies": {
-    "@commitlint/cli": "20.2.0",
-    "@commitlint/config-conventional": "20.2.0",
+    "@commitlint/cli": "20.4.1",
+    "@commitlint/config-conventional": "20.4.1",
+    "@jest/globals": "^30.2.0",
     "eslint": "9.39.2",
-    "globals": "16.5.0",
+    "globals": "17.3.0",
     "husky": "9.1.7",
     "jest": "30.2.0",
     "neostandard": "0.12.2",
-    "tsup": "8.5.1"
+    "ts-jest": "^29.4.6",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
   }
 }

package/dist/esm/index.js

@@ -1,179 +0,0 @@
-function makeCtx(parentCtx, key, value) {
-  let path;
-  if (!parentCtx) path = "$";
-  else if (typeof key === "number") path = `${parentCtx.path}[${key}]`;
-  else path = `${parentCtx.path}.${key}`;
-  return {
-    path,
-    key,
-    parent: parentCtx ? parentCtx.value : null,
-    root: parentCtx ? parentCtx.root : value,
-    value
-  };
-}
-function formatValue(value) {
-  if (value === null || value === void 0) return String(value);
-  const type = typeof value;
-  if (type === "string") return value;
-  if (type === "number" || type === "boolean" || type === "bigint") return String(value);
-  if (type === "symbol") return value.toString();
-  if (type === "function") {
-    const name = value.name ? `: ${value.name}` : "";
-    return `[Function${name}]`;
-  }
-  if (value instanceof RegExp) return value.toString();
-  if (value instanceof Date) return value.toISOString();
-  if (Array.isArray(value) || value && Object.getPrototypeOf(value) === Object.prototype) {
-    return JSON.stringify(value);
-  }
-  return Object.prototype.toString.call(value);
-}
-function createValidator(name, handler) {
-  return function validatorFactory(...args) {
-    return function validatorFn(value, ctx) {
-      try {
-        return handler(value, ctx, args);
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        if (!error.expected) {
-          error.expected = name;
-          error.actual = value;
-          error.path = ctx.path;
-          error.key = ctx.key;
-          error.parent = ctx.parent;
-          error.root = ctx.root;
-        }
-        throw error;
-      }
-    };
-  };
-}
-function pipe(...validators) {
-  return createValidator("pipe", (value, ctx) => {
-    for (const validator of validators) {
-      if (ctx.__abortPipe) break;
-      value = validator(value, ctx);
-    }
-    delete ctx.__abortPipe;
-    return value;
-  })();
-}
-function transform(fn) {
-  return createValidator("transform", (value, ctx) => fn(value, ctx))();
-}
-function check(fn, msg) {
-  const expected = fn.name || "check";
-  return createValidator(expected, (value, ctx) => {
-    const result = fn(value, ctx);
-    if (result === true) return value;
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 ${expected}`);
-  })();
-}
-function validate(schema, value, rootPath = "$") {
-  const ctx = {
-    path: rootPath,
-    key: null,
-    parent: null,
-    root: value,
-    value
-  };
-  try {
-    const result = schema(value, ctx);
-    return { valid: true, result };
-  } catch (error) {
-    return {
-      valid: false,
-      error,
-      result: value
-    };
-  }
-}
-const required = createValidator("required", (value, ctx, args) => {
-  const [msg] = args;
-  if (value == null) {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 required`);
-  }
-  return value;
-});
-const optional = createValidator("optional", (value, ctx, args) => {
-  if (value == null) {
-    ctx.__abortPipe = true;
-    return value;
-  }
-  return value;
-});
-const string = createValidator("string", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "string") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 string`);
-  }
-  return value;
-});
-const number = createValidator("number", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "number") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 number`);
-  }
-  return value;
-});
-const bigint = createValidator("bigint", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "bigint") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 bigint`);
-  }
-  return value;
-});
-const boolean = createValidator("boolean", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "boolean") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 boolean`);
-  }
-  return value;
-});
-const symbol = createValidator("symbol", (value, ctx, args) => {
-  const [msg] = args;
-  if (typeof value !== "symbol") {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 symbol`);
-  }
-  return value;
-});
-const object = createValidator("object", (value, ctx, args) => {
-  const [obj, msg] = args;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 object`);
-  }
-  const result = {};
-  for (const key in obj) {
-    const childCtx = makeCtx(ctx, key, value[key]);
-    result[key] = obj[key](value[key], childCtx);
-  }
-  return result;
-});
-const array = createValidator("array", (value, ctx, args) => {
-  const [validator, msg] = args;
-  if (!Array.isArray(value)) {
-    throw new Error(msg || `(${ctx.path}: ${formatValue(value)}) \u2716 array`);
-  }
-  return value.map((item, i) => {
-    const childCtx = makeCtx(ctx, i, item);
-    return validator(item, childCtx);
-  });
-});
-export {
-  array,
-  bigint,
-  boolean,
-  check,
-  createValidator,
-  formatValue,
-  makeCtx,
-  number,
-  object,
-  optional,
-  pipe,
-  required,
-  string,
-  symbol,
-  transform,
-  validate
-};

package/types/index.d.ts

@@ -1,69 +0,0 @@
-export interface Ctx {
-  path: string
-  key: string | number | null
-  parent: any
-  root: any
-  value: any
-}
-
-export type Validator<T = any> = (value: T, ctx: Ctx) => T
-
-export type ValidatorFactory<Args extends any[] = any[], T = any> = (
-  ...args: Args
-) => Validator<T>
-
-export function makeCtx (parentCtx: Ctx | null, key: string | number | null, value: any): Ctx
-
-export function formatValue (value: any): string
-
-export function createValidator<Args extends any[] = any[], T = any> (
-  name: string,
-  handler: (value: any, ctx: Ctx, args: Args) => T
-): ValidatorFactory<Args, T>
-
-export function pipe<T = any> (...validators: Validator[]): Validator<T>
-
-export function transform<TIn = any, TOut = any> (
-  fn: (value: TIn, ctx: Ctx) => TOut
-): Validator<TOut>
-
-export function check<T = any> (
-  fn: (value: T, ctx: Ctx) => boolean,
-  msg?: string
-): Validator<T>
-
-export interface ValidateResult<T = any> {
-  valid: boolean
-  result: T
-  error?: Error
-}
-
-export function validate<T = any> (
-  schema: Validator<T>,
-  value: any,
-  rootPath?: string
-): ValidateResult<T>
-
-export const required: (msg?: string) => Validator<any>
-
-export const optional: () => Validator<any>
-
-export const string: (msg?: string) => Validator<string>
-
-export const number: (msg?: string) => Validator<number>
-
-export const bigint: (msg?: string) => Validator<bigint>
-
-export const boolean: (msg?: string) => Validator<boolean>
-
-export const symbol: (msg?: string) => Validator<symbol>
-
-export const object: (
-  obj: { [key: string]: Validator<any> },
-  msg?: string
-) => Validator<any>
-
-export const array: (
-  validator: Validator<any>,
-  msg?: string
-) => Validator<any[]>