@nerd-bible/valio 0.0.1

package/dist/pipe.js

@@ -0,0 +1,149 @@
+import enFormat from "./locales/en";
+function clone(obj) {
+    return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+export class HalfPipe {
+    name;
+    typeCheck;
+    transform;
+    constructor(
+    /** The type name */
+    name, 
+    /** The first check to run */
+    typeCheck, 
+    /** Optional transform for pipe to run at end. Useful for containers */
+    transform) {
+        this.name = name;
+        this.typeCheck = typeCheck;
+        this.transform = transform;
+    }
+    /** The second checks to run */
+    checks = [];
+    clone() {
+        const res = clone(this);
+        res.checks = res.checks.slice();
+        return res;
+    }
+}
+/** During encoding, decoding, or validation. */
+export class Context {
+    jsonPath = [];
+    errors = {};
+    errorFmt(name, props) {
+        return enFormat(name, props);
+    }
+    clone() {
+        const res = clone(this);
+        res.jsonPath = res.jsonPath.slice();
+        res.errors = { ...res.errors };
+        return res;
+    }
+    pushError(error) {
+        const key = "." + this.jsonPath.join(".");
+        this.errors[key] ??= [];
+        this.errors[key].push(error);
+    }
+    pushErrorFmt(name, input, props) {
+        const message = this.errorFmt(name, props);
+        this.pushError({ input, message });
+    }
+    run(input, halfPipe) {
+        if (!halfPipe.typeCheck(input)) {
+            this.pushErrorFmt("type", input, { expected: halfPipe.name });
+            return { success: false, errors: this.errors };
+        }
+        let success = true;
+        for (const c of halfPipe.checks ?? []) {
+            if (!c.valid(input, this)) {
+                this.pushErrorFmt(c.name, input, c.props);
+                success = false;
+            }
+        }
+        if (!success)
+            return { success, errors: this.errors };
+        return { success, output: input };
+    }
+}
+export class Pipe {
+    i;
+    o;
+    constructor(i, o) {
+        this.i = i;
+        this.o = o;
+    }
+    pipes = [];
+    registry = {};
+    clone() {
+        const res = clone(this);
+        res.i = res.i.clone();
+        res.o = res.o.clone();
+        res.pipes = res.pipes.slice();
+        res.registry = { ...res.registry };
+        return res;
+    }
+    refine(valid, name, props) {
+        const res = this.clone();
+        res.o.checks.push({ valid, name, props });
+        return res;
+    }
+    pipe(pipe) {
+        const res = this.clone();
+        res.pipes.push(pipe);
+        return res;
+    }
+    decodeAny(input, ctx = new Context()) {
+        // 1. Verify input
+        let res = ctx.run(input, this.i);
+        if (!res.success)
+            return res;
+        // 2. Transform input to output
+        if (this.i.transform) {
+            res = this.i.transform(res.output, ctx);
+            if (!res.success)
+                return res;
+        }
+        // 3. Verify output
+        res = ctx.run(res.output, this.o);
+        if (!res.success)
+            return res;
+        // 4. Next
+        for (const p of this.pipes) {
+            res = p.decode(res.output, ctx);
+            if (!res.success)
+                return res;
+        }
+        return res;
+    }
+    decode(input, ctx = new Context()) {
+        return this.decodeAny(input, ctx);
+    }
+    encodeAny(output, ctx = new Context()) {
+        // 1. Next
+        let res = { success: true, output };
+        for (let i = this.pipes.length - 1; i >= 0; i--) {
+            res = this.pipes[i].encodeAny(res.output, ctx);
+            if (!res.success)
+                return res;
+        }
+        // 2. Verify output
+        res = ctx.run(res.output, this.o);
+        if (!res.success)
+            return res;
+        // 3. Transform output to input
+        if (this.o.transform) {
+            res = this.o.transform(res.output, ctx);
+            if (!res.success)
+                return res;
+        }
+        // 4. Verify input
+        return ctx.run(res.output, this.i);
+    }
+    encode(output, ctx = new Context()) {
+        return this.encodeAny(output, ctx);
+    }
+    register(key, value) {
+        const res = this.clone();
+        res.registry[key] = value;
+        return res;
+    }
+}

package/dist/primitives.d.ts

@@ -0,0 +1,41 @@
+import { Pipe } from "./pipe";
+export declare function boolean(): Pipe<boolean, boolean>;
+export declare function undefined(): Pipe<undefined, undefined>;
+export declare function any(): Pipe<any, any>;
+declare function null_(): Pipe<null, null>;
+export { null_ as null };
+export declare class Comparable<I, O> extends Pipe<I, O> {
+    gt(n: O): this;
+    gte(n: O): this;
+    lt(n: O): this;
+    lte(n: O): this;
+    eq(n: O): this;
+}
+declare class ValioNumber extends Comparable<number, number> {
+    constructor();
+}
+export declare function number(): ValioNumber;
+export declare class Arrayish<I, O extends {
+    length: number;
+}> extends Pipe<I, O> {
+    minLength(n: number): this;
+    maxLength(n: number): this;
+}
+declare class ValioString extends Pipe<string, string> {
+    constructor();
+    regex(re: RegExp): this;
+}
+export declare function string(): ValioString;
+export type Lit = string | number | bigint | boolean | null | undefined;
+declare class ValioLiteral<T extends Lit> extends Pipe<T, T> {
+    literal: T;
+    constructor(literal: T);
+}
+export declare function literal<T extends Lit>(literal: T): ValioLiteral<T>;
+declare class ValioEnum<T extends Lit> extends Pipe<T, T> {
+    literals: T[];
+    constructor(literals: T[]);
+}
+declare function enum_<T extends Lit>(literals: T[]): ValioEnum<T>;
+export { enum_ as enum };
+//# sourceMappingURL=primitives.d.ts.map

package/dist/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../src/primitives.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,IAAI,EAAE,MAAM,QAAQ,CAAC;AAOxC,wBAAgB,OAAO,2BAKtB;AAED,wBAAgB,SAAS,+BAKxB;AAED,wBAAgB,GAAG,mBAElB;AAED,iBAAS,KAAK,qBAEb;AACD,OAAO,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC;AAEzB,qBAAa,UAAU,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/C,EAAE,CAAC,CAAC,EAAE,CAAC;IAGP,GAAG,CAAC,CAAC,EAAE,CAAC;IAGR,EAAE,CAAC,CAAC,EAAE,CAAC;IAGP,GAAG,CAAC,CAAC,EAAE,CAAC;IAGR,EAAE,CAAC,CAAC,EAAE,CAAC;CAGP;AAED,cAAM,WAAY,SAAQ,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC;;CAKnD;AACD,wBAAgB,MAAM,gBAErB;AAED,qBAAa,QAAQ,CACpB,CAAC,EACD,CAAC,SAAS;IACT,MAAM,EAAE,MAAM,CAAC;CACf,CACA,SAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IACnB,SAAS,CAAC,CAAC,EAAE,MAAM;IAGnB,SAAS,CAAC,CAAC,EAAE,MAAM;CAGnB;AAED,cAAM,WAAY,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;;IAM7C,KAAK,CAAC,EAAE,EAAE,MAAM;CAGhB;AACD,wBAAgB,MAAM,IAAI,WAAW,CAEpC;AAED,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAExE,cAAM,YAAY,CAAC,CAAC,SAAS,GAAG,CAAE,SAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC,OAAO,EAAE,CAAC;gBAAV,OAAO,EAAE,CAAC;CAI7B;AACD,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,CAAC,mBAEhD;AAED,cAAM,SAAS,CAAC,CAAC,SAAS,GAAG,CAAE,SAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAC7B,QAAQ,EAAE,CAAC,EAAE;gBAAb,QAAQ,EAAE,CAAC,EAAE;CAMhC;AACD,iBAAS,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAEzD;AACD,OAAO,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC"}

package/dist/primitives.js

@@ -0,0 +1,87 @@
+import { HalfPipe, Pipe } from "./pipe";
+function primitive(name, typeCheck) {
+    const half = new HalfPipe(name, typeCheck);
+    return new Pipe(half, half);
+}
+export function boolean() {
+    return primitive("boolean", (v) => typeof v == "boolean");
+}
+export function undefined() {
+    return primitive("undefined", (v) => typeof v == "undefined");
+}
+export function any() {
+    return primitive("any", (v) => true);
+}
+function null_() {
+    return primitive("null", (v) => v === null);
+}
+export { null_ as null };
+export class Comparable extends Pipe {
+    gt(n) {
+        return this.refine((v) => v > n, "gt", { n });
+    }
+    gte(n) {
+        return this.refine((v) => v >= n, "gte", { n });
+    }
+    lt(n) {
+        return this.refine((v) => v < n, "lt", { n });
+    }
+    lte(n) {
+        return this.refine((v) => v <= n, "lte", { n });
+    }
+    eq(n) {
+        return this.refine((v) => v == n, "eq", { n });
+    }
+}
+class ValioNumber extends Comparable {
+    constructor() {
+        const half = new HalfPipe("number", (v) => typeof v == "number");
+        super(half, half);
+    }
+}
+export function number() {
+    return new ValioNumber();
+}
+export class Arrayish extends Pipe {
+    minLength(n) {
+        return this.refine((v) => v.length >= n, "minLength", { n });
+    }
+    maxLength(n) {
+        return this.refine((v) => v.length <= n, "maxLength", { n });
+    }
+}
+class ValioString extends Pipe {
+    constructor() {
+        const half = new HalfPipe("string", (v) => typeof v == "string");
+        super(half, half);
+    }
+    regex(re) {
+        return this.refine((v) => !!v.match(re), "regex", { regex: re.source });
+    }
+}
+export function string() {
+    return new ValioString();
+}
+class ValioLiteral extends Pipe {
+    literal;
+    constructor(literal) {
+        const half = new HalfPipe(`${literal}`, (v) => v == literal);
+        super(half, half);
+        this.literal = literal;
+    }
+}
+export function literal(literal) {
+    return new ValioLiteral(literal);
+}
+class ValioEnum extends Pipe {
+    literals;
+    constructor(literals) {
+        const half = new HalfPipe(`${literals.join(",")}`, (v) => literals.includes(v));
+        super(half, half);
+        this.literals = literals;
+    }
+}
+function enum_(literals) {
+    return new ValioEnum(literals);
+}
+export { enum_ as enum };

package/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@nerd-bible/valio",
+	"version": "0.0.1",
+	"module": "index.ts",
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.0",
+		"@types/bun": "latest"
+	},
+	"scripts": {
+		"build": "tsc",
+		"fmt": "biome check",
+		"fmt-fix": "biome check --write --unsafe"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"type": "module"
+}

package/src/codecs.test.ts

@@ -0,0 +1,88 @@
+import { expect, test } from "bun:test";
+import * as v from "./index";
+
+test("number codec", () => {
+	const schema = v.codecs.number();
+
+	expect(schema.decode("13")).toEqual({ success: true, output: 13 });
+	expect(schema.lt(12).decode("13")).toEqual({
+		success: false,
+		errors: { ".": [{ input: 13, message: "must be < 12" }] },
+	});
+	expect(schema.decode("-1.3")).toEqual({ success: true, output: -1.3 });
+	expect(schema.decode("asdf")).toEqual({
+		success: false,
+		errors: {
+			".": [{ input: "asdf", message: "could not coerce to number" }],
+		},
+	});
+	expect(schema.decode("Infinity")).toEqual({
+		success: true,
+		output: Number.POSITIVE_INFINITY,
+	});
+	expect(schema.decode("-Infinity")).toEqual({
+		success: true,
+		output: Number.NEGATIVE_INFINITY,
+	});
+	expect(schema.encode(1.3)).toEqual({ success: true, output: 1.3 });
+});
+
+test("2 pipes", () => {
+	const schema = v.codecs.number();
+	const next = schema.pipe(v.number().gt(5));
+
+	expect(next.decode("3")).toEqual({
+		success: false,
+		errors: {
+			".": [{ input: 3, message: "must be > 5" }],
+		},
+	});
+	expect(schema.decode(undefined)).toEqual({
+		success: true,
+		output: Number.NaN,
+	});
+	expect(schema.decode(null)).toEqual({ success: true, output: Number.NaN });
+});
+
+test("array number codec", () => {
+	const schema = v.array(v.codecs.number().gt(4).gt(5));
+
+	expect(schema.decode(["10a", "11b"])).toEqual({
+		success: true,
+		output: [10, 11],
+	});
+	expect(schema.decode(["NaN", "5", 5])).toEqual({
+		errors: {
+			".0": [
+				{ input: Number.NaN, message: "must be > 4" },
+				{ input: Number.NaN, message: "must be > 5" },
+			],
+			".1": [{ input: 5, message: "must be > 5" }],
+			".2": [{ input: 5, message: "must be > 5" }],
+		},
+		success: false,
+	});
+});
+
+test("boolean codec", () => {
+	const schema = v.codecs.boolean({ true: ["yes"], false: ["no"] });
+
+	expect(schema.decode("yes")).toEqual({ success: true, output: true });
+	expect(schema.decode("no")).toEqual({ success: true, output: false });
+	expect(schema.decode("")).toEqual({ success: true, output: false });
+	expect(schema.decode("1")).toEqual({ success: true, output: true });
+	expect(schema.decode(false)).toEqual({ success: true, output: false });
+	expect(schema.decode(0)).toEqual({ success: true, output: false });
+});
+
+// test("string codec", () => {
+// 	const schema = v.codecs.string();
+//
+// 	expect(schema.decode(13)).toEqual({ success: true, output: "13" });
+// 	expect(schema.decode(null)).toEqual({ success: true, output: "null" });
+// 	expect(schema.encode(null as any)).toEqual({
+// 		success: false,
+// 		errors: { ".": [ { input: null, message: "not type string" } ] },
+// 	});
+// 	expect(schema.encode("asdf")).toEqual({ success: true, output: "asdf" });
+// });

package/src/codecs.ts

@@ -0,0 +1,56 @@
+import * as c from "./containers";
+import type { Context, Pipe, Result } from "./pipe";
+import * as p from "./primitives";
+
+export function custom<I, O>(
+	input: Pipe<I, any>,
+	output: Pipe<any, O>,
+	codec: {
+		encode?(input: O, ctx: Context): Result<I>;
+		decode?(output: I, ctx: Context): Result<O>;
+	},
+): Pipe<I, O> {
+	const res = output.clone() as any;
+	res.i = input.i.clone();
+	res.i.transform = codec.decode;
+	res.o.transform = codec.encode;
+	return res;
+}
+
+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 };
+
+				const output = parser(input);
+				if (!Number.isNaN(output)) return { success: true, output };
+
+				ctx.pushErrorFmt("coerce", input, { expected: "number" });
+				return { success: false, errors: ctx.errors };
+			},
+		},
+	) as ReturnType<typeof number>;
+}
+
+export function boolean(opts: {
+	true?: string[];
+	false?: string[];
+}): Pipe<any, boolean> {
+	return custom(p.any(), p.boolean(), {
+		decode(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 };
+			}
+			return { success: true, output: Boolean(input) };
+		},
+	});
+}

package/src/containers.test.ts

@@ -0,0 +1,203 @@
+import { expect, test } from "bun:test";
+import * as v from "./index";
+
+test("array", () => {
+	const schema = v.array(v.number());
+
+	expect(schema.decode([54])).toEqual({ success: true, output: [54] });
+	expect(schema.decode(["54"])).toEqual({
+		success: false,
+		errors: { ".0": [{ input: "54", message: "not type number" }] },
+	});
+	expect(schema.decodeAny(54)).toEqual({
+		success: false,
+		errors: { ".": [{ input: 54, message: "not type array" }] },
+	});
+});
+
+test("array failed element", () => {
+	const schema = v.array(v.number().gt(4).gt(5));
+
+	expect(schema.decode(["5", 5])).toEqual({
+		success: false,
+		errors: {
+			".0": [{ input: "5", message: "not type number" }],
+			".1": [{ input: 5, message: "must be > 5" }],
+		},
+	});
+});
+
+test("object", () => {
+	const o = v.object({ foo: v.number().gt(4) });
+	type O = v.Output<typeof o>;
+
+	expect(o.decode({ foo: 10 })).toEqual({
+		success: true,
+		output: { foo: 10 } as O,
+	});
+	expect(o.decode({ foo: 10, bar: 10 })).toEqual({
+		success: true,
+		output: { foo: 10 } as O,
+	});
+	expect(o.decode({ bar: 10 })).toEqual({
+		success: false,
+		errors: {
+			".foo": [
+				{
+					input: undefined,
+					message: "not type number",
+				},
+			],
+		},
+	});
+});
+
+test("loose object", () => {
+	const o = v.object({ foo: v.number().gt(4) }).loose<number>();
+	type O = v.Output<typeof o>;
+
+	expect(o.isLoose).toBe(true);
+	expect(o.decode({ foo: 10, bar: 10 })).toEqual({
+		success: true,
+		output: { foo: 10, bar: 10 } as O,
+	});
+});
+
+test("nested object", () => {
+	const o = v.object({
+		foo: v.object({ bar: v.number().gt(4) }),
+	});
+
+	expect(o.decode({ foo: { bar: 10 } })).toEqual({
+		success: true,
+		output: { foo: { bar: 10 } },
+	});
+	expect(o.decode({ bar: 10 })).toEqual({
+		success: false,
+		errors: {
+			".foo": [
+				{
+					input: undefined,
+					message: "not type object",
+				},
+			],
+		},
+	});
+});
+
+test("partial object", () => {
+	const o = v.object({ foo: v.number().gt(4) }).partial({ foo: true });
+	type O = v.Output<typeof o>;
+
+	expect(o.decode({ foo: 10 })).toEqual({
+		success: true,
+		output: { foo: 10 } as O,
+	});
+	expect(o.decode({ foo: undefined })).toEqual({
+		success: true,
+		output: { foo: undefined } as O,
+	});
+	expect(o.decode({})).toEqual({
+		success: true,
+		output: {} as O,
+	});
+});
+
+test("pick object", () => {
+	const o = v
+		.object({ foo: v.number().gt(4), bar: v.number() })
+		.pick({ foo: true });
+	type O = v.Output<typeof o>;
+
+	expect(o.decode({ bar: 10 })).toEqual({
+		success: false,
+		errors: {
+			".foo": [
+				{
+					input: undefined,
+					message: "not type number",
+				},
+			],
+		},
+	});
+	expect(o.decode({ foo: 10, bar: 10 } as O)).toEqual({
+		success: true,
+		output: { foo: 10 },
+	});
+	expect(o.decode({})).toEqual({
+		success: false,
+		errors: { ".foo": [{ input: undefined, message: "not type number" }] },
+	});
+});
+
+test("omit object", () => {
+	const o = v
+		.object({ foo: v.number().gt(4), bar: v.number() })
+		.omit({ foo: true });
+	type O = v.Output<typeof o>;
+
+	expect(o.decode({ bar: 10 })).toEqual({
+		success: true,
+		output: { bar: 10 } as O,
+	});
+	expect(o.decode({ foo: undefined, bar: 10 })).toEqual({
+		success: true,
+		output: { bar: 10 },
+	});
+	expect(o.decode({})).toEqual({
+		success: false,
+		errors: { ".bar": [{ input: undefined, message: "not type number" }] },
+	});
+});
+
+test("record", () => {
+	const o = v.record(v.string(), v.number());
+
+	expect(o.decode({ bar: 10 })).toEqual({
+		success: true,
+		output: { bar: 10 },
+	});
+	expect(o.decode({ foo: { bar: 10 } })).toEqual({
+		success: false,
+		errors: { ".foo": [{ input: { bar: 10 }, message: "not type number" }] },
+	});
+});
+
+test("extend object", () => {
+	const o = v.object({ foo: v.number().gt(4) }).extend({ bar: v.number() });
+	type O = v.Output<typeof o>;
+
+	expect(o.decode({ foo: 10, bar: 5 })).toEqual({
+		success: true,
+		output: { foo: 10, bar: 5 } as O,
+	});
+	expect(o.decode({})).toEqual({
+		success: false,
+		errors: {
+			".bar": [
+				{
+					input: undefined,
+					message: "not type number",
+				},
+			],
+			".foo": [
+				{
+					input: undefined,
+					message: "not type number",
+				},
+			],
+		},
+	});
+});
+
+test("union", () => {
+	const schema = v.union([v.string(), v.number()]);
+	type O = v.Output<typeof schema>;
+
+	expect(schema.decode(42 as O)).toEqual({ success: true, output: 42 });
+	expect(schema.decode("asdf")).toEqual({ success: true, output: "asdf" });
+	expect(schema.decodeAny({})).toEqual({
+		success: false,
+		errors: { ".": [{ input: {}, message: "not type string|number" }] },
+	});
+});