@nerd-bible/valio 0.0.12 → 0.1.1

package/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Publish
+on:
+  push:
+    tags:
+      - v[0-9]+.[0-9]+.[0-9]+
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm install
+      - run: npm test
+      - run: node ./publish.ts "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY"
+      - run: npm publish --verbose

package/.github/workflows/test.yml

@@ -0,0 +1,14 @@
+name: Test
+on:
+  push:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v6
+        with:
+          node-version: lts/*
+      - run: npm install
+      - run: npm test

package/README.md

@@ -35,8 +35,8 @@ const schema = v.number(); // Pipe<number, number>
 
 expect(schema.decode(5)).toEqual({ success: true, output: 5 });
 expect(schema.decodeAny("5")).toEqual({
-success: false,
-errors: { ".": [{ input: "5", message: "not type number" }] },
+    success: false,
+    errors: { ".": [{ input: "5", message: "not type number" }] },
 });
 ```
 

package/package.json

@@ -1,27 +1,26 @@
 {
   "name": "@nerd-bible/valio",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "devDependencies": {
-    "@biomejs/biome": "^2.3.1",
-    "@types/bun": "latest"
+  "exports": {
+    ".": {
+      "import": {
+        "nbsource": "./src/index.ts",
+        "node": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsc",
-    "fmt": "biome check",
-    "fmt-fix": "biome check --write --unsafe"
+    "build": "tsc -p ./tsconfig.build.json",
+    "test": "node --test"
   },
-  "peerDependencies": {
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "expect": "^30.2.0",
     "typescript": "^5.9.3"
   },
-  "files": [
-    "README.md",
-    "src",
-    "dist"
-  ],
-  "version": "0.0.12",
+  "version": "0.1.1",
   "repository": {
-    "url": "git+https://github.com/nerd-bible/valio"
+    "url": "https://github.com/nerd-bible/valio"
   }
-}
+}

package/publish.ts

@@ -0,0 +1,49 @@
+// This script allows using Git tags as the source of truth for versions rather
+// than package.json.
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+
+const repoUrl = process.argv.slice(2).find((a) => !a.startsWith("--"));
+if (!repoUrl) throw Error("Required arg: repo URL");
+const dry = process.argv.includes("--dry");
+
+function execGit(args: string, allowFailure = false) {
+	try {
+		return execSync(`git ${args}`, {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+	} catch (err) {
+		if (!allowFailure) throw err;
+	}
+}
+
+execGit("fetch --tags");
+const tagCmd = "describe --tags --abbrev=0 --match='v[0-9]*.[0-9]*.[0-9]*'";
+let version = execGit(`${tagCmd} --exact-match`, true);
+
+if (!version) {
+	const lastVersion = execGit(tagCmd, true) ?? "v0.0.0";
+	console.log("No manual tag, bumping", lastVersion);
+
+	const split = lastVersion.split(".");
+	// Tags should only be missing for minor bumps.
+	const last = parseInt(split.pop()!) + 1;
+	version = [...split, last].join(".");
+
+	if (!dry) {
+		console.log("Tagging + pushing", version);
+		execGit(`tag ${version}`);
+		execGit("push --tags origin master");
+	}
+} else {
+	console.log("Using manual tag", version);
+}
+
+if (!dry) {
+	console.log("Writing temporary package.json");
+	const pkg = JSON.parse(readFileSync("package.json", "utf8"));
+	pkg.version = version.substring(1);
+	pkg.repository = { url: repoUrl };
+	writeFileSync("package.json", JSON.stringify(pkg, null, 2));
+}

package/src/codecs.test.ts

@@ -1,5 +1,6 @@
-import { expect, test } from "bun:test";
-import * as v from "./index";
+import { test } from "node:test";
+import expect from "expect";
+import * as v from "./index.ts";
 
 test("number codec", () => {
 	const schema = v.codecs.number();
@@ -65,7 +66,7 @@ test("array number codec", () => {
 });
 
 test("boolean codec", () => {
-	const schema = v.codecs.boolean({ true: ["yes"], false: ["no"] });
+	const schema = v.codecs.boolean({ true: /yes|^[1-9]/, false: /no|^0?$/ });
 
 	expect(schema.decode("yes")).toEqual({ success: true, output: true });
 	expect(schema.decode("no")).toEqual({ success: true, output: false });

package/src/codecs.ts

@@ -1,6 +1,5 @@
-import * as c from "./containers";
-import type { Context, Pipe, Result } from "./pipe";
-import * as p from "./primitives";
+import type { Context, Pipe, Result } from "./pipe.ts";
+import * as p from "./primitives.ts";
 
 export function custom<I, O>(
 	input: Pipe<I, any>,
@@ -20,37 +19,37 @@ export function custom<I, O>(
 export function number(
 	parser = Number.parseFloat,
 ): p.Comparable<string | number | null | undefined, number> {
-	return custom(
-		c.union([p.string(), p.number(), p.null(), p.undefined()]),
-		p.number(),
-		{
-			decode(input, ctx) {
-				if (typeof input == "number") return { success: true, output: input };
-				if (input == null || input.toLowerCase() == "nan")
-					return { success: true, output: Number.NaN };
+	return custom(p.any(), p.number(), {
+		decode(input, ctx) {
+			if (typeof input === "number") return { success: true, output: input };
+			if (!input || input.toLowerCase() === "nan")
+				return { success: true, output: Number.NaN };
 
-				const output = parser(input);
-				if (!Number.isNaN(output)) return { success: true, output };
+			const output = parser(input);
+			if (!Number.isNaN(output)) return { success: true, output };
 
-				ctx.pushErrorFmt("coerce", input, { expected: "number" });
-				return { success: false, errors: ctx.errors };
-			},
+			ctx.pushErrorFmt("coerce", input, { expected: "number" });
+			return { success: false, errors: ctx.errors };
 		},
-	) as ReturnType<typeof number>;
+	}) as ReturnType<typeof number>;
 }
 
 export function boolean(opts: {
-	true?: string[];
-	false?: string[];
+	true?: RegExp;
+	false?: RegExp;
 }): Pipe<any, boolean> {
 	return custom(p.any(), p.boolean(), {
-		decode(input) {
+		decode(input, ctx) {
+			if (typeof input === "boolean") return { success: true, output: input };
 			if (typeof input === "string") {
-				if (opts.true?.includes(input)) return { success: true, output: true };
-				if (opts.false?.includes(input))
-					return { success: true, output: false };
+				if (opts.true?.test(input)) return { success: true, output: true };
+				if (opts.false?.test(input)) return { success: true, output: false };
 			}
-			return { success: true, output: Boolean(input) };
+			if (typeof input === "number")
+				return { success: true, output: Boolean(input) };
+
+			ctx.pushErrorFmt("coerce", input, { expected: "boolean" });
+			return { success: false, errors: ctx.errors };
 		},
 	});
 }

package/src/containers.test.ts

@@ -1,5 +1,6 @@
-import { expect, test } from "bun:test";
-import * as v from "./index";
+import { test } from "node:test";
+import expect from "expect";
+import * as v from "./index.ts";
 
 test("array", () => {
 	const schema = v.array(v.number());

package/src/containers.ts

@@ -1,14 +1,20 @@
-import type { Input, Output, Result } from "./pipe";
-import { type Context, HalfPipe, Pipe } from "./pipe";
-import * as p from "./primitives";
+import type { Input, Output, Result } from "./pipe.ts";
+import { Context, HalfPipe, Pipe } from "./pipe.ts";
+import * as p from "./primitives.ts";
 
 class ValioArray<T> extends p.Arrayish<any[], T[]> {
-	constructor(public element: Pipe<any, T>) {
+	element: Pipe<any, T>;
+
+	static typeCheck(v: any): v is any[] {
+		return Array.isArray(v);
+	}
+
+	constructor(element: Pipe<any, T>) {
 		super(
 			new HalfPipe(
 				"array",
-				(v: any): v is any[] => Array.isArray(v),
-				(input: any[], ctx: Context): Result<T[]> => {
+				ValioArray.typeCheck,
+				function parseAnyArr(input: any[], ctx: Context): Result<T[]> {
 					const output = new Array<T>(input.length);
 					let success = true;
 
@@ -25,12 +31,16 @@ class ValioArray<T> extends p.Arrayish<any[], T[]> {
 					return { success, output };
 				},
 			),
-			new HalfPipe(`array<${element.o.name}>`, (v: any): v is T[] => {
-				if (!Array.isArray(v)) return false;
-				for (const e of v) if (!element.o.typeCheck(e)) return false;
-				return true;
-			}),
+			new HalfPipe(
+				`array<${element.o.name}>`,
+				function isArrT(v: any): v is T[] {
+					if (!ValioArray.typeCheck(v)) return false;
+					for (const e of v) if (!element.o.typeCheck(e)) return false;
+					return true;
+				},
+			),
 		);
+		this.element = element;
 	}
 }
 export function array<T>(element: Pipe<any, T>): ValioArray<T> {
@@ -41,16 +51,22 @@ class ValioRecord<K extends PropertyKey, V> extends Pipe<
 	Record<any, any>,
 	Record<K, V>
 > {
-	constructor(
-		public keyPipe: Pipe<any, K>,
-		public valPipe: Pipe<any, V>,
-	) {
+	keyPipe: Pipe<any, K>;
+	valPipe: Pipe<any, V>;
+
+	static typeCheck(v: any): v is Record<any, any> {
+		return Object.prototype.toString.call(v) === "[object Object]";
+	}
+
+	constructor(keyPipe: Pipe<any, K>, valPipe: Pipe<any, V>) {
 		super(
 			new HalfPipe(
 				"object",
-				(v): v is Record<any, any> =>
-					Object.prototype.toString.call(v) == "[object Object]",
-				(input: Record<any, any>, ctx: Context): Result<Record<K, V>> => {
+				ValioRecord.typeCheck,
+				function anyToRecordKV(
+					input: Record<any, any>,
+					ctx: Context,
+				): Result<Record<K, V>> {
 					const output = {} as Record<K, V>;
 
 					let success = true;
@@ -77,9 +93,8 @@ class ValioRecord<K extends PropertyKey, V> extends Pipe<
 			),
 			new HalfPipe(
 				`record<${keyPipe.o.name},${valPipe.o.name}>`,
-				(v): v is Record<K, V> => {
-					if (Object.prototype.toString.call(v) != "[object Object]")
-						return false;
+				function recordCheckV(v): v is Record<K, V> {
+					if (!ValioRecord.typeCheck(v)) return false;
 					for (const k in v) {
 						// Keys will always be strings.
 						// if (!keyPipe.o.typeCheck(k)) return false;
@@ -89,6 +104,8 @@ class ValioRecord<K extends PropertyKey, V> extends Pipe<
 				},
 			),
 		);
+		this.keyPipe = keyPipe;
+		this.valPipe = valPipe;
 	}
 }
 export function record<K extends PropertyKey, V>(
@@ -102,32 +119,39 @@ class Union<T extends Readonly<Pipe[]>> extends Pipe<
 	Output<T[number]>,
 	Output<T[number]>
 > {
-	constructor(public options: T) {
+	options: T;
+
+	constructor(options: T) {
 		const name = options.map((o) => o.o.name).join("|");
 		type O = Output<T[number]>;
 		super(
 			new HalfPipe(
 				name,
-				(v: any): v is O => {
+				function isUnionType(v: any): v is O {
 					for (const f of options) if (f.i.typeCheck(v)) return true;
 					return false;
 				},
 				(data: O, ctx: Context): Result<O> => {
-					const newCtx = ctx.clone();
-					for (const s in options) {
-						const decoded = options[s]!.decode(data, newCtx);
+					// Throw away errors since we expect them.
+					const newCtx = new Context();
+					newCtx.pushErrorFmt = () => {};
+					newCtx.pushError = () => {};
+					for (const f of options) {
+						const decoded = f.decode(data, newCtx);
 						if (decoded.success) return decoded;
 					}
 
-					Object.assign(ctx.errors, newCtx.errors);
+					// Sad path -- do again with real ctx to gather errors.
+					for (const f of options) f.decode(data, ctx);
 					return { success: false, errors: ctx.errors };
 				},
 			),
-			new HalfPipe(name, (v: any): v is O => {
+			new HalfPipe(name, function isUnionType2(v: any): v is O {
 				for (const f of options) if (f.o.typeCheck(v)) return true;
 				return false;
 			}),
 		);
+		this.options = options;
 	}
 }
 export function union<T extends Readonly<Pipe[]>>(options: T): Union<T> {
@@ -151,19 +175,21 @@ type Extend<A extends Record<any, any>, B extends Record<any, any>> = Flatten<
 			}
 >;
 
-class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
-	Record<any, any>,
-	ObjectOutput<Shape>
-> {
-	constructor(
-		public shape: Shape,
-		public isLoose: boolean,
-	) {
+export class ValioObject<
+	Shape extends Record<any, Pipe<any, any>>,
+> extends Pipe<Record<any, any>, ObjectOutput<Shape>> {
+	shape: Shape;
+	isLoose: boolean;
+
+	static typeCheck(v: any): v is Record<any, any> {
+		return typeof v === "object";
+	}
+
+	constructor(shape: Shape, isLoose: boolean) {
 		super(
 			new HalfPipe(
 				"object",
-				(v): v is Record<any, any> =>
-					Object.prototype.toString.call(v) == "[object Object]",
+				ValioObject.typeCheck,
 				(data, ctx) => this.transformInput(data, ctx),
 			),
 			new HalfPipe(
@@ -173,6 +199,9 @@ class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
 				(v) => this.typeCheckOutput(v),
 			),
 		);
+
+		this.shape = shape;
+		this.isLoose = isLoose;
 	}
 
 	clone(): this {
@@ -204,7 +233,7 @@ class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
 	}
 
 	protected typeCheckOutput(v: any): v is ObjectOutput<Shape> {
-		if (Object.prototype.toString.call(v) != "[object Object]") return false;
+		if (!ValioObject.typeCheck(v)) return false;
 		for (const s in this.shape)
 			if (!this.shape[s]!.o.typeCheck(v[s])) return false;
 		return true;

package/src/index.ts

@@ -1,4 +1,4 @@
-export * as codecs from "./codecs";
-export * from "./containers";
-export * from "./pipe";
-export * from "./primitives";
+export * as codecs from "./codecs.ts";
+export * from "./containers.ts";
+export * from "./pipe.ts";
+export * from "./primitives.ts";

package/src/pipe.ts

@@ -1,4 +1,4 @@
-import enFormat from "./locales/en";
+import enFormat from "./locales/en.ts";
 
 export type Error = { input: any; message: string };
 export type Errors = { [inputPath: string]: Error[] };
@@ -20,21 +20,31 @@ interface Check<T> {
 }
 
 export class HalfPipe<I, O = never> {
-	constructor(
-		/** The type name */
-		public name: string,
-		/** The first check to run */
-		public typeCheck: (v: any) => v is I,
-		/** Optional transform for pipe to run at end. Useful for containers */
-		public transform?: (v: I, ctx: Context) => Result<O>,
-	) {}
-	/** The second checks to run */
+	name: string;
+	typeCheck: (v: any) => v is I;
+	transform?: (v: I, ctx: Context) => Result<O>;
+	/** Checks to run after type check */
 	checks: Check<I>[] = [];
 
-	clone(): this {
-		const res = clone(this);
-		res.checks = res.checks.slice();
-		return res;
+	constructor(
+		name: string,
+		typeCheck: (v: any) => v is I,
+		transform?: (v: I, ctx: Context) => Result<O>,
+		checks: Check<I>[] = [],
+	) {
+		this.name = name;
+		this.typeCheck = typeCheck;
+		this.transform = transform;
+		this.checks = checks;
+	}
+
+	clone(): HalfPipe<I, O> {
+		return new HalfPipe(
+			this.name,
+			this.typeCheck,
+			this.transform,
+			this.checks.slice(),
+		);
 	}
 }
 
@@ -48,9 +58,9 @@ export class Context {
 	}
 
 	clone(): Context {
-		const res = clone(this);
-		res.jsonPath = res.jsonPath.slice();
-		res.errors = { ...res.errors };
+		const res = new Context();
+		res.jsonPath = this.jsonPath.slice();
+		res.errors = { ...this.errors };
 		return res;
 	}
 
@@ -83,13 +93,17 @@ export class Context {
 }
 
 export class Pipe<I = any, O = any> {
-	constructor(
-		public i: HalfPipe<I, O>,
-		public o: HalfPipe<O, I>,
-	) {}
+	i: HalfPipe<I, O>;
+	o: HalfPipe<O, I>;
+
+	constructor(i: HalfPipe<I, O>, o: HalfPipe<O, I>) {
+		this.i = i;
+		this.o = o;
+	}
 
 	pipes: Pipe<any, any>[] = [];
 	registry: Record<PropertyKey, any> = {};
+	debug = false;
 
 	clone(): this {
 		const res = clone(this);
@@ -103,7 +117,7 @@ export class Pipe<I = any, O = any> {
 	refine(
 		valid: (data: O, ctx: Context) => boolean,
 		name: string,
-		props: Record<any, any>,
+		props: Record<any, any> = {},
 	): this {
 		const res = this.clone();
 		res.o.checks.push({ valid, name, props });

package/src/primitives.test.ts

@@ -1,5 +1,6 @@
-import { expect, test } from "bun:test";
-import * as v from "./index";
+import { test } from "node:test";
+import expect from "expect";
+import * as v from "./index.ts";
 
 test("number", () => {
 	const schema = v.number();
@@ -12,7 +13,7 @@ test("number", () => {
 });
 
 test("custom validator", () => {
-	const schema = v.number().refine((n) => n == 5, "eq", { n: 5 });
+	const schema = v.number().refine((n) => n === 5, "eq", { n: 5 });
 
 	expect(schema.decode(5)).toEqual({ success: true, output: 5 });
 	expect(schema.encode(3)).toEqual({
@@ -22,7 +23,7 @@ test("custom validator", () => {
 });
 
 test("custom context", () => {
-	const schema = v.number().refine((n) => n == 5, "eq", { n: 5 });
+	const schema = v.number().refine((n) => n === 5, "eq", { n: 5 });
 	class MyContext extends v.Context {
 		errorFmt() {
 			return "You done messed up";

package/src/primitives.ts

@@ -1,4 +1,4 @@
-import { HalfPipe, Pipe } from "./pipe";
+import { HalfPipe, Pipe } from "./pipe.ts";
 
 function primitive<T>(name: string, typeCheck: (v: T) => v is T) {
 	const half = new HalfPipe(name, typeCheck);
@@ -8,7 +8,7 @@ function primitive<T>(name: string, typeCheck: (v: T) => v is T) {
 export function boolean() {
 	return primitive<boolean>(
 		"boolean",
-		(v): v is boolean => typeof v == "boolean",
+		(v): v is boolean => typeof v === "boolean",
 	);
 }
 
@@ -16,12 +16,12 @@ export function boolean() {
 export function undefined() {
 	return primitive<undefined>(
 		"undefined",
-		(v): v is undefined => typeof v == "undefined",
+		(v): v is undefined => typeof v === "undefined",
 	);
 }
 
 export function any() {
-	return primitive<any>("any", (v): v is any => true);
+	return primitive<any>("any", (_v): _v is any => true);
 }
 
 function null_() {
@@ -43,13 +43,13 @@ export class Comparable<I, O> extends Pipe<I, O> {
 		return this.refine((v) => v <= n, "lte", { n });
 	}
 	eq(n: O) {
-		return this.refine((v) => v == n, "eq", { n });
+		return this.refine((v) => v === n, "eq", { n });
 	}
 }
 
 class ValioNumber extends Comparable<number, number> {
 	constructor() {
-		const half = new HalfPipe("number", (v) => typeof v == "number");
+		const half = new HalfPipe("number", (v) => typeof v === "number");
 		super(half, half);
 	}
 }
@@ -71,9 +71,9 @@ export class Arrayish<
 	}
 }
 
-class ValioString extends Pipe<string, string> {
+class ValioString extends Arrayish<string, string> {
 	constructor() {
-		const half = new HalfPipe("string", (v) => typeof v == "string");
+		const half = new HalfPipe("string", (v) => typeof v === "string");
 		super(half, half);
 	}
 
@@ -88,9 +88,12 @@ export function string(): ValioString {
 export type Lit = string | number | bigint | boolean | null | undefined;
 
 class ValioLiteral<T extends Lit> extends Pipe<T, T> {
-	constructor(public literal: T) {
-		const half = new HalfPipe(`${literal}`, (v): v is T => v == literal);
+	literal: T;
+
+	constructor(literal: T) {
+		const half = new HalfPipe(`${literal}`, (v): v is T => v === literal);
 		super(half, half);
+		this.literal = literal;
 	}
 }
 export function literal<T extends Lit>(literal: T) {
@@ -98,14 +101,17 @@ export function literal<T extends Lit>(literal: T) {
 }
 
 class ValioEnum<T extends Lit> extends Pipe<T, T> {
-	constructor(public literals: T[]) {
+	literals: readonly T[];
+
+	constructor(literals: readonly T[]) {
 		const half = new HalfPipe(`${literals.join(",")}`, (v: any): v is T =>
 			literals.includes(v),
 		);
 		super(half, half);
+		this.literals = literals;
 	}
 }
-function enum_<T extends Lit>(literals: T[]): ValioEnum<T> {
+function enum_<T extends Lit>(literals: readonly T[]): ValioEnum<T> {
 	return new ValioEnum(literals);
 }
 export { enum_ as enum };