@ripetchor/vivi 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ripetchor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# Vivi 
+
+WARNING: This package is primarily intended for personal use. It may contain bugs or unexpected behavior. Use at your own risk.
+
+## Primitive Validators
+
+- `v.string(options?)`
+- `v.number(options?)`
+- `v.boolean(options?)`
+- `v.bigint(options?)`
+- `v.null(options?)`
+- `v.undefined(options?)`
+
+## Other Validators
+
+- `v.nullable(validator)`
+- `v.optional(validator)`
+- `v.array(validator, options?)`
+- `v.object(shape, options?)`
+- `v.union([validators], options?)`
+- `v.literal(value, options?)`
+- `v.instance(Class, options?)`
+- `v.date(options?)`
+- `v.email(options?)`
+- `v.unknown()`
+- `v.fallback(validator, defaultValue)`
+- `v.refine(validator, refinements[], options?)`
+- `v.pipe(validator, ...transformFns)`
+
+## Usage Examples
+
+```ts
+import { v } from '@ripetchor/vivi'
+// or 
+import v from '@ripetchor/vivi'
+ // or 
+import { stringValidator, numberValidator, refine /* etc. */ } from '@ripetchor/vivi'
+```
+
+### Primitive validation
+```ts
+const name = v.string().parse('Alice');
+console.log(name); // Alice
+
+const age = v.number().parse(30);
+console.log(age); // 30
+
+const active = v.boolean().parse(true);
+console.log(active); // true
+```
+
+### Nullable and optional
+```ts
+const nullableName = v.nullable(v.string()).parse(null);
+console.log(nullableName); // null
+
+const optionalAge = v.optional(v.number()).parse(undefined);
+console.log(optionalAge); // undefined
+```
+
+### Array validation
+```ts
+const numbers = v.array(v.number()).parse([1, 2, 3]);
+console.log(numbers); // [1, 2, 3]
+
+const users = v.array(v.object({ name: v.string(), age: v.number() })).parse([
+  { name: "Lana", age: 28 },
+  { name: "Mikaela", age: 25, friends: ["Nicole"] },
+  { name: "Elsa", age: 28, job: "dev" },
+]);
+console.log(users); // [{ name: 'Lana', age: 28 }, { name: 'Mikaela', age: 25 }, { name: 'Elsa', age: 28 }]
+```
+
+### Object validation
+```ts
+const exactUser = v.object({ name: v.string(), age: v.number() }, { mode: 'exact' }).parse({ name: 'Alice', age: 25 });
+console.log(exactUser); // { name: 'Alice', age: 25 }
+
+const stripUser = v.object({ name: v.string() }, { mode: 'strip' }).parse({ name: 'Bob', age: 30 });
+console.log(stripUser); // { name: 'Bob' }
+
+const passthroughUser = v.object({ name: v.string() }, { mode: 'passthrough' }).parse({ name: 'Charlie', age: 40 });
+console.log(passthroughUser); // { name: 'Charlie', age: 40 }
+```
+
+### Union validation
+```ts
+const value = v.union([v.string(), v.number()]).parse('Hello');
+console.log(value); // 'Hello'
+```
+
+### Literal validation
+```ts
+const l1 = v.literal("yes").parse("yes");
+console.log(l1); // 'yes'
+
+v.literal("yes").parse("yeS");
+// error
+```
+
+### Refinements
+```ts
+const schema = refine(
+  v.string(),
+  [
+    (value) => value.length === 5 || "length must be 5",
+    (value) => /^\d+$/.test(value) || "contains only numbers",
+  ],
+  { abort: true },
+);
+
+const result = schema.safeParse("abc");
+
+if (!result.success) {
+  console.log(result.error.issues); // [ { path: [], message: 'length must be 5' } ]
+} else {
+  console.log(result.data);
+}
+```
+
+### Fallback
+```ts
+const fallbackValue = v.fallback(v.number(), 42).parse('invalid');
+console.log(fallbackValue); // 42
+```
+
+### Email validation
+```ts
+const email = v.email().parse('test@example.com');
+console.log(email); // 'test@example.com'
+```
+
+### Date validation
+```ts
+const birthday = v.date().parse(new Date('1990-01-01'));
+console.log(birthday); // 1990-01-01T00:00:00.000Z
+```
+
+### Pipe transformations
+```ts
+const transformed = v.pipe(
+  v.string(),
+  (s: string) => s.trim(),
+  (s: string) => s.toUpperCase(),
+).parse(' hello ');
+console.log(transformed); // 'HELLO'
+```
+
+### Safe parsing
+```ts
+const result1 = v.number().safeParse(123);
+console.log(result1); // { success: true, data: 123 }
+
+const result2 = v.number().safeParse('not a number');
+console.log(result2); // { success: false, error: ViviError }
+```
+
+### Abort on first issue
+```ts
+try {
+  v.array(v.number(), { abort: true }).parse([1, "x", 3, "y"]);
+} catch (err) {
+  if (err instanceof ViviError) {
+    console.log("Aborted on first error:", err.issues);
+  }
+}
+```
+
+### Pattern matching (`match`)
+
+`match` is a alternative to `if / else` for handling the result of `safeParse`.
+
+- enforces handling of all possible states
+
+- provides proper type narrowing
+
+- eliminates if (result.success) checks
+
+```ts
+const schema = v.string();
+
+const result = schema.safeParse("hello");
+
+v.match(
+  result,
+  (data) => {
+    console.log("Success:", data);
+  },
+  (error) => {
+    console.log("Validation failed:", error.issues);
+  },
+);
+
+// Еhe return type is inferred from the callbacks.
+const value = v.match(
+  result,
+  (data) => data.toUpperCase(),
+  () => "DEFAULT",
+);
+// value: string
+```
+
+### Type inference
+```ts
+const userValidator = v.object({ name: v.string(), age: v.number() });
+type User = v.infer<typeof userValidator>;
+
+const user: User = { name: 'Alice', age: 25 };
+console.log(user); // { name: 'Alice', age: 25 }
+```

package/dist/index.d.mts

@@ -0,0 +1,220 @@
+//#region src/error.d.ts
+declare class ViviError extends Error {
+  readonly issues: ReadonlyArray<ViviIssue>;
+  constructor(issues: ReadonlyArray<ViviIssue>);
+  static single(message: string, path: Path): ViviError;
+  merge(other: ViviError): ViviError;
+}
+//#endregion
+//#region src/types.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+interface SafeParseSuccess<T> {
+  success: true;
+  data: T;
+}
+interface SafeParseFailure {
+  success: false;
+  error: ViviError;
+}
+type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseFailure;
+interface ViviValidator<T> {
+  parse(input: unknown, path?: Path): T;
+  safeParse(input: unknown): SafeParseResult<T>;
+}
+type Infer<T> = T extends ViviValidator<infer U> ? U : never;
+type ErrorFn = (input: unknown) => string;
+type ParseFn<T> = (input: unknown, path: Path) => T;
+type RefineFn<T> = (value: T) => boolean | string;
+type TransformFn<T, U> = (value: T) => U;
+type ErrorMessage = string | ErrorFn;
+interface ValidatorOptions {
+  error?: ErrorMessage;
+}
+type Path = ReadonlyArray<string | number>;
+interface ViviIssue {
+  readonly path: Path;
+  readonly message: string;
+}
+type InferUnion<T extends readonly ViviValidator<unknown>[]> = T extends [infer First, ...infer Rest extends readonly ViviValidator<unknown>[]] ? (First extends ViviValidator<infer O> ? O : never) | InferUnion<Rest> : never;
+type OptionalKeys<T extends Record<string, ViviValidator<unknown>>> = { [K in keyof T]: undefined extends Infer<T[K]> ? K : never }[keyof T];
+type RequiredKeys<T extends Record<string, ViviValidator<unknown>>> = Exclude<keyof T, OptionalKeys<T>>;
+type ObjectShape<T extends Record<string, ViviValidator<unknown>>> = Prettify<{ [K in RequiredKeys<T>]: Infer<T[K]> } & { [K in OptionalKeys<T>]?: Exclude<Infer<T[K]>, undefined> }>;
+//#endregion
+//#region src/array-validator.d.ts
+interface ArrayValidatorOptions extends ValidatorOptions {
+  abort?: boolean;
+}
+declare function arrayValidator<T>(validator: ViviValidator<T>, options?: ArrayValidatorOptions): ViviValidator<T[]>;
+//#endregion
+//#region src/bigint-validator.d.ts
+declare function bigintValidator(options?: ValidatorOptions): ViviValidator<bigint>;
+//#endregion
+//#region src/boolean-validator.d.ts
+declare function booleanValidator(options?: ValidatorOptions): ViviValidator<boolean>;
+//#endregion
+//#region src/date-validator.d.ts
+declare function dateValidator(options?: ValidatorOptions): ViviValidator<Date>;
+//#endregion
+//#region src/email-validator.d.ts
+interface EmailValidatorOptions extends ValidatorOptions {
+  pattern?: RegExp;
+}
+declare function emailValidator(options?: EmailValidatorOptions): ViviValidator<string>;
+//#endregion
+//#region src/fallback.d.ts
+declare function fallback<T>(validator: ViviValidator<T>, defaultValue: T): ViviValidator<T>;
+//#endregion
+//#region src/instance-validator.d.ts
+declare function instanceValidator<T>(ctor: new (...args: any[]) => T, options?: ValidatorOptions): ViviValidator<T>;
+//#endregion
+//#region src/literal-validator.d.ts
+declare function literalValidator<T extends string | number | boolean>(value: T, options?: ValidatorOptions): ViviValidator<T>;
+//#endregion
+//#region src/null-validator.d.ts
+declare function nullValidator(options?: ValidatorOptions): ViviValidator<null>;
+//#endregion
+//#region src/nullable-validator.d.ts
+declare function nullableValidator<T>(validator: ViviValidator<T>): ViviValidator<T | null>;
+//#endregion
+//#region src/number-validator.d.ts
+declare function numberValidator(options?: ValidatorOptions): ViviValidator<number>;
+//#endregion
+//#region src/object-validator.d.ts
+type ObjectMode = "exact" | "passthrough" | "strip";
+interface ObjectValidatorOptions extends ValidatorOptions {
+  mode?: ObjectMode;
+  abort?: boolean;
+}
+declare function objectValidator<T extends Record<string, ViviValidator<unknown>>>(shape: T, options?: ObjectValidatorOptions): ViviValidator<ObjectShape<T>>;
+//#endregion
+//#region src/optional-validator.d.ts
+declare function optionalValidator<T>(validator: ViviValidator<T>): ViviValidator<T | undefined>;
+//#endregion
+//#region src/pipe.d.ts
+declare function pipe<A>(a: ViviValidator<A>): ViviValidator<A>;
+declare function pipe<A, B>(a: ViviValidator<A>, ab: TransformFn<A, B>): ViviValidator<B>;
+declare function pipe<A, B, C>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>): ViviValidator<C>;
+declare function pipe<A, B, C, D>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>): ViviValidator<D>;
+declare function pipe<A, B, C, D, E>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>): ViviValidator<E>;
+declare function pipe<A, B, C, D, E, F>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>): ViviValidator<F>;
+declare function pipe<A, B, C, D, E, F, G>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>): ViviValidator<G>;
+declare function pipe<A, B, C, D, E, F, G, H>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>): ViviValidator<H>;
+declare function pipe<A, B, C, D, E, F, G, H, I>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>): ViviValidator<I>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>): ViviValidator<J>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>): ViviValidator<K$1>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>): ViviValidator<L>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>): ViviValidator<M>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>): ViviValidator<N>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>): ViviValidator<O>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>): ViviValidator<P>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>): ViviValidator<Q>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>): ViviValidator<R>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>): ViviValidator<S>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>): ViviValidator<T>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T, U>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>, tu: TransformFn<T, U>): ViviValidator<U>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T, U, V>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>, tu: TransformFn<T, U>, uv: TransformFn<U, V>): ViviValidator<V>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T, U, V, W>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>, tu: TransformFn<T, U>, uv: TransformFn<U, V>, vw: TransformFn<V, W>): ViviValidator<W>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T, U, V, W, X>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>, tu: TransformFn<T, U>, uv: TransformFn<U, V>, vw: TransformFn<V, W>, wx: TransformFn<W, X>): ViviValidator<X>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>, tu: TransformFn<T, U>, uv: TransformFn<U, V>, vw: TransformFn<V, W>, wx: TransformFn<W, X>, xy: TransformFn<X, Y>): ViviValidator<Y>;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>(a: ViviValidator<A>, ab: TransformFn<A, B>, bc: TransformFn<B, C>, cd: TransformFn<C, D>, de: TransformFn<D, E>, ef: TransformFn<E, F>, fg: TransformFn<F, G>, gh: TransformFn<G, H>, hi: TransformFn<H, I>, ij: TransformFn<I, J>, jk: TransformFn<J, K$1>, kl: TransformFn<K$1, L>, lm: TransformFn<L, M>, mn: TransformFn<M, N>, no: TransformFn<N, O>, op: TransformFn<O, P>, pq: TransformFn<P, Q>, qr: TransformFn<Q, R>, rs: TransformFn<R, S>, st: TransformFn<S, T>, tu: TransformFn<T, U>, uv: TransformFn<U, V>, vw: TransformFn<V, W>, wx: TransformFn<W, X>, xy: TransformFn<X, Y>, yz: TransformFn<Y, Z>): ViviValidator<Z>;
+//#endregion
+//#region src/refine.d.ts
+interface RefineOptions {
+  abort?: boolean;
+}
+declare function refine<T>(validator: ViviValidator<T>, refinements: RefineFn<T>[], options?: RefineOptions): ViviValidator<T>;
+//#endregion
+//#region src/shared/create-validator.d.ts
+declare function createValidator<T>(parseFn: ParseFn<T>): ViviValidator<T>;
+//#endregion
+//#region src/shared/match.d.ts
+declare function match<T, R>(result: SafeParseResult<T>, onsuccess: (data: T) => R, onfailure: (error: ViviError) => R): R;
+//#endregion
+//#region src/string-validator.d.ts
+declare function stringValidator(options?: ValidatorOptions): ViviValidator<string>;
+//#endregion
+//#region src/undefined-validator.d.ts
+declare function undefinedValidator(options?: ValidatorOptions): ViviValidator<undefined>;
+//#endregion
+//#region src/union-validator.d.ts
+declare function unionValidator<T extends ReadonlyArray<ViviValidator<unknown>>>(validators: readonly [...T], options?: ValidatorOptions): ViviValidator<InferUnion<T>>;
+//#endregion
+//#region src/unknown-validator.d.ts
+declare function unknownValidator(): ViviValidator<unknown>;
+//#endregion
+//#region src/refinement-utils/number-refinements.d.ts
+declare function min(minValue: number, message?: string): (value: number) => string | true;
+declare function max(maxValue: number, message?: string): (value: number) => string | true;
+declare function gt(minValue: number, message?: string): (value: number) => string | true;
+declare function lt(maxValue: number, message?: string): (value: number) => string | true;
+declare function integer(message?: string): (value: number) => string | true;
+declare function finite(message?: string): (value: number) => string | true;
+declare function positive(message?: string): (value: number) => string | true;
+declare function negative(message?: string): (value: number) => string | true;
+declare function between(minValue: number, maxValue: number, message?: string): (value: number) => string | true;
+declare function even(message?: string): (value: number) => string | true;
+declare function odd(message?: string): (value: number) => string | true;
+//#endregion
+//#region src/refinement-utils/string-refinements.d.ts
+declare function minLength(min: number, message?: string): (value: string) => string | true;
+declare function maxLength(max: number, message?: string): (value: string) => string | true;
+declare function length(len: number, message?: string): (value: string) => string | true;
+declare function pattern(regex: RegExp, message?: string): (value: string) => string | true;
+declare function startsWith(prefix: string, message?: string): (value: string) => string | true;
+declare function endsWith(suffix: string, message?: string): (value: string) => string | true;
+declare function nonEmpty(message?: string): (value: string) => string | true;
+declare function includes(substring: string, message?: string): (value: string) => string | true;
+declare function notIncludes(substring: string, message?: string): (value: string) => string | true;
+declare function trimmed(message?: string): (value: string) => string | true;
+declare function lowercase(message?: string): (value: string) => string | true;
+declare function uppercase(message?: string): (value: string) => string | true;
+declare function uuid4(message?: string): (value: string) => string | true;
+//#endregion
+//#region src/transform-utils/number-transforms.d.ts
+declare function round(): (value: number) => number;
+declare function floor(): (value: number) => number;
+declare function ceil(): (value: number) => number;
+declare function clamp(minValue: number, maxValue: number): (value: number) => number;
+declare function abs(): (value: number) => number;
+//#endregion
+//#region src/transform-utils/string-transforms.d.ts
+declare function trim(): (value: string) => string;
+declare function toLowerCase(): (value: string) => string;
+declare function toUpperCase(): (value: string) => string;
+interface ReplaceOptions {
+  global?: boolean;
+  ignoreCase?: boolean;
+}
+declare function replace(searchValue: string | RegExp, replaceValue: string, options?: ReplaceOptions): (value: string) => string;
+declare function truncateEnd(maxLength: number, suffix?: string): (value: string) => string;
+declare function truncateStart(maxLength: number, suffix?: string): (value: string) => string;
+declare function normalizeSpaces(): (value: string) => string;
+//#endregion
+//#region src/index.d.ts
+declare const v: {
+  array: typeof arrayValidator;
+  bigint: typeof bigintValidator;
+  boolean: typeof booleanValidator;
+  date: typeof dateValidator;
+  email: typeof emailValidator;
+  fallback: typeof fallback;
+  instance: typeof instanceValidator;
+  literal: typeof literalValidator;
+  null: typeof nullValidator;
+  nullable: typeof nullableValidator;
+  number: typeof numberValidator;
+  object: typeof objectValidator;
+  optional: typeof optionalValidator;
+  string: typeof stringValidator;
+  undefined: typeof undefinedValidator;
+  union: typeof unionValidator;
+  unknown: typeof unknownValidator;
+  refine: typeof refine;
+  pipe: typeof pipe;
+  match: typeof match;
+};
+declare namespace v {
+  type infer<T extends ViviValidator<unknown>> = Infer<T>;
+}
+//#endregion
+export { ViviError, abs, arrayValidator, between, bigintValidator, booleanValidator, ceil, clamp, createValidator as customValidator, dateValidator, v as default, v, emailValidator, endsWith, even, fallback, finite, floor, gt, includes, instanceValidator, integer, length, literalValidator, lowercase, lt, match, max, maxLength, min, minLength, negative, nonEmpty, normalizeSpaces, notIncludes, nullValidator, nullableValidator, numberValidator, objectValidator, odd, optionalValidator, pattern, pipe, positive, refine, replace, round, startsWith, stringValidator, toLowerCase, toUpperCase, trim, trimmed, truncateEnd, truncateStart, undefinedValidator, unionValidator, unknownValidator, uppercase, uuid4 };

package/dist/index.mjs

@@ -0,0 +1 @@
+var e=class e extends Error{issues;constructor(t){super(`Vivi validation error`),this.name=e.name,this.issues=t}static single(t,n){return new e([{message:t,path:n}])}merge(t){return new e([...this.issues,...t.issues])}};function t(e,t,n){for(let r=0;r<t.length;r++){let i=t[r],a=[];for(let e=0;e<n.length;e++)a.push(n[e]);for(let e=0;e<i.path.length;e++)a.push(i.path[e]);e.push({message:i.message,path:a})}}function n(t){return{parse(e,n=[]){return t(e,n)},safeParse(n){try{return{success:!0,data:t(n,[])}}catch(t){if(t instanceof e)return{success:!1,error:t};let n=t instanceof Error?t.message:`Unknown validation error`;return{success:!1,error:e.single(n,[])}}}}}function r(e,t,n){return typeof e==`function`?e(n):e??t}function i(i,a){return n((n,o)=>{if(!Array.isArray(n))throw e.single(r(a?.error,`Expected array`,n),o);let s=[],c=[];for(let r=0;r<n.length;r++){let l=i.safeParse(n[r]);if(l.success)s[r]=l.data;else if(t(c,l.error.issues,o.concat(r)),a?.abort)throw new e(c)}if(c.length>0)throw new e(c);return s})}function a(t){return n((n,i)=>{if(typeof n!=`bigint`)throw e.single(r(t?.error,`Expected bigint`,n),i);return n})}function o(t){return n((n,i)=>{if(typeof n!=`boolean`)throw e.single(r(t?.error,`Expected boolean`,n),i);return n})}function s(t){return n((n,i)=>{if(!(n instanceof Date)||isNaN(n.getTime()))throw e.single(r(t?.error,`Expected Date`,n),i);return n})}const c=/^(?!\.)(?!.*\.\.)([a-z0-9_'+\-\.]*)[a-z0-9_+\-]@([a-z0-9][a-z0-9\-]*\.)+[a-z]{2,}$/i;function l(t){let i=t?.pattern??c;return n((n,a)=>{if(typeof n!=`string`)throw e.single(r(t?.error,`Expected string`,n),a);if(!i.test(n))throw e.single(r(t?.error,`Invalid email format`,n),a);return n})}function u(t,r){return n((n,i)=>{try{return t.parse(n,i)}catch(t){if(t instanceof e)return r;throw t}})}function d(t,i){return n((n,a)=>{if(!(n instanceof t))throw e.single(r(i?.error,`Expected instance of ${t.name}`,n),a);return n})}function f(t,i){return n((n,a)=>{if(n!==t)throw e.single(r(i?.error,`Expected literal ${String(t)}`,n),a);return t})}function p(t){return n((n,i)=>{if(n!==null)throw e.single(r(t?.error,`Expected null`,n),i);return null})}function m(e){return n((t,n)=>t===null?null:e.parse(t,n))}function h(t){return n((n,i)=>{if(typeof n!=`number`)throw e.single(r(t?.error,`Expected number`,n),i);return n})}function g(i,a){let o=a?.mode??`strip`;return n((n,s)=>{if(typeof n!=`object`||!n||Array.isArray(n))throw e.single(r(a?.error,`Expected object`,n),s);let c=n,l={},u=[],d=Object.keys(c);for(let n=0;n<d.length;n++){let f=d[n],p=c[f],m=i[f];if(m!==void 0){let n=m.safeParse(p);if(n.success)l[f]=n.data;else if(t(u,n.error.issues,s.concat(f)),a?.abort)throw new e(u)}else o===`exact`?u.push({message:r(void 0,`Unexpected property`,p),path:s.concat(f)}):o===`passthrough`&&(l[f]=p)}if(u.length>0)throw new e(u);return l})}function _(e){return n((t,n)=>{if(t!==void 0)return e.parse(t,n)})}function v(e,...t){return n((n,r)=>{let i=e.parse(n,r);for(let e=0;e<t.length;e++)i=t[e](i);return i})}function y(t,r,i){return n((n,a)=>{let o=t.parse(n,a),s=[];for(let e=0;e<r.length;e++){let t=r[e](o);if(t===!1){if(s.push({path:a,message:`Refinement failed`}),i?.abort)break}else if(typeof t==`string`&&(s.push({path:a,message:t}),i?.abort))break}if(s.length>0)throw new e(s);return o})}function b(e,t,n){return e.success?t(e.data):n(e.error)}function x(t){return n((n,i)=>{if(typeof n!=`string`)throw e.single(r(t?.error,`Expected string`,n),i);return n})}function S(t){return n((n,i)=>{if(n!==void 0)throw e.single(r(t?.error,`Expected undefined`,n),i)})}function C(i,a){return n((n,o)=>{let s=[];for(let e=0;e<i.length;e++){let r=i[e].safeParse(n);if(r.success)return r.data;t(s,r.error.issues,o)}throw s.length>0?new e(s):e.single(r(a?.error,`No union variant matched`,n),o)})}function w(){return n(e=>e)}function T(e,t){return function(n){return n>=e||t||`Must be >= ${e}`}}function ee(e,t){return function(n){return n<=e||t||`Must be <= ${e}`}}function E(e,t){return function(n){return n>e||t||`Must be > ${e}`}}function D(e,t){return function(n){return n<e||t||`Must be < ${e}`}}function O(e){return function(t){return Number.isInteger(t)||e||`Must be an integer`}}function k(e){return function(t){return Number.isFinite(t)||e||`Must be a finite number`}}function A(e){return function(t){return t>0||e||`Must be positive`}}function j(e){return function(t){return t<0||e||`Must be negative`}}function M(e,t,n){return function(r){return r>=e&&r<=t||n||`Must be between ${e} and ${t}`}}function N(e){return function(t){return t%2==0||e||`Must be an even number`}}function P(e){return function(t){return t%2!=0||e||`Must be an odd number`}}function F(e,t){return function(n){return n.length>=e||t||`Must have at least ${e} characters`}}function I(e,t){return function(n){return n.length<=e||t||`Must have at most ${e} characters`}}function L(e,t){return function(n){return n.length===e||t||`Must have exactly ${e} characters`}}function R(e,t){return function(n){return e.test(n)||t||`Invalid format`}}function z(e,t){return function(n){return n.startsWith(e)||t||`Must start with "${e}"`}}function B(e,t){return function(n){return n.endsWith(e)||t||`Must end with "${e}"`}}function V(e){return function(t){return t.length>0||e||`Must not be empty`}}function te(e,t){return function(n){return n.includes(e)||t||`Must include "${e}"`}}function H(e,t){return function(n){return!n.includes(e)||t||`Must not include "${e}"`}}function U(e){return function(t){return t.trim()===t||e||`Must not have leading or trailing spaces`}}function W(e){return function(t){return t===t.toLowerCase()||e||`Must be lowercase`}}function G(e){return function(t){return t===t.toUpperCase()||e||`Must be uppercase`}}function K(e){let t=/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;return function(n){return t.test(n)||e||`Must be a valid UUID v4`}}function q(){return function(e){return Math.round(e)}}function J(){return function(e){return Math.floor(e)}}function Y(){return function(e){return Math.ceil(e)}}function X(e,t){return function(n){return Math.min(Math.max(n,e),t)}}function Z(){return function(e){return Math.abs(e)}}function Q(){return function(e){return e.trim()}}function ne(){return function(e){return e.toLowerCase()}}function re(){return function(e){return e.toUpperCase()}}function ie(e,t,n){return function(r){if(typeof e==`string`){let i=``;return n?.global&&(i+=`g`),n?.ignoreCase&&(i+=`i`),r.replace(new RegExp(e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`),i),t)}else return r.replace(e,t)}}function ae(e,t=``){return function(n){return n.length>e?n.slice(0,e)+t:n}}function oe(e,t=``){return function(n){return n.length<=e?n:t+n.slice(n.length-e)}}function se(){return function(e){return e.replace(/\s+/g,` `).trim()}}const $={array:i,bigint:a,boolean:o,date:s,email:l,fallback:u,instance:d,literal:f,null:p,nullable:m,number:h,object:g,optional:_,string:x,undefined:S,union:C,unknown:w,refine:y,pipe:v,match:b};var ce=$;export{e as ViviError,Z as abs,i as arrayValidator,M as between,a as bigintValidator,o as booleanValidator,Y as ceil,X as clamp,n as customValidator,s as dateValidator,ce as default,l as emailValidator,B as endsWith,N as even,u as fallback,k as finite,J as floor,E as gt,te as includes,d as instanceValidator,O as integer,L as length,f as literalValidator,W as lowercase,D as lt,b as match,ee as max,I as maxLength,T as min,F as minLength,j as negative,V as nonEmpty,se as normalizeSpaces,H as notIncludes,p as nullValidator,m as nullableValidator,h as numberValidator,g as objectValidator,P as odd,_ as optionalValidator,R as pattern,v as pipe,A as positive,y as refine,ie as replace,q as round,z as startsWith,x as stringValidator,ne as toLowerCase,re as toUpperCase,Q as trim,U as trimmed,ae as truncateEnd,oe as truncateStart,S as undefinedValidator,C as unionValidator,w as unknownValidator,G as uppercase,K as uuid4,$ as v};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ripetchor/vivi",
+  "version": "0.0.1",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ripetchor/vivi.git"
+  },
+  "author": "ripetchor",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/ripetchor/vivi/issues"
+  },
+  "homepage": "https://github.com/ripetchor/vivi#readme",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "bumpp": "^10.3.1",
+    "tsdown": "^0.18.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.9"
+  }
+}