@nerd-bible/valio 0.1.13 → 0.1.15

package/src/containers.ts

@@ -1,44 +1,52 @@
 import type { Input, Output, Result } from "./pipe.ts";
-import { Context, HalfPipe, Pipe } from "./pipe.ts";
+import { Context, Pipe } from "./pipe.ts";
 import * as p from "./primitives.ts";
 
 export class ValioArray<T> extends p.Arrayish<any[], T[]> {
 	element: Pipe<any, T>;
 
+	constructor(element: Pipe<any, T>) {
+		super();
+		this.element = element;
+	}
+
+	get inputName() {
+		return "array";
+	}
+
 	static typeCheck(v: any): v is any[] {
 		return Array.isArray(v);
 	}
 
-	constructor(element: Pipe<any, T>) {
-		super(
-			new HalfPipe("array", ValioArray.typeCheck, function parseAnyArr(
-				input: any[],
-				ctx: Context,
-			): Result<T[]> {
-				const output = new Array<T>(input.length);
-				let success = true;
-
-				const length = ctx.jsonPath.length;
-				for (let i = 0; i < input.length; i++) {
-					ctx.jsonPath[length] = i.toString();
-					const decoded = element.decode(input[i], ctx);
-					if (decoded.success) output[i] = decoded.output;
-					else success = false;
-				}
-				ctx.jsonPath.length = length;
-
-				if (!success) return { success, errors: ctx.errors };
-				return { success, output };
-			}),
-			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;
+	inputTypeCheck(v: any): v is any[] {
+		return ValioArray.typeCheck(v);
+	}
+
+	inputTransform(input: any[], ctx: Context): Result<T[]> {
+		const output = new Array<T>(input.length);
+		let success = true;
+
+		const length = ctx.jsonPath.length;
+		for (let i = 0; i < input.length; i++) {
+			ctx.jsonPath[length] = i.toString();
+			const decoded = this.element.decode(input[i], ctx);
+			if (decoded.success) output[i] = decoded.output;
+			else success = false;
+		}
+		ctx.jsonPath.length = length;
+
+		if (!success) return { success, errors: ctx.errors };
+		return { success, output };
+	}
+
+	get outputName() {
+		return `array<${this.element.outputName}>`;
+	}
+
+	outputTypeCheck(v: any): v is T[] {
+		if (!ValioArray.typeCheck(v)) return false;
+		for (const e of v) if (!this.element.outputTypeCheck(e)) return false;
+		return true;
 	}
 }
 export function array<T>(element: Pipe<any, T>): ValioArray<T> {
@@ -52,54 +60,61 @@ export class ValioRecord<K extends PropertyKey, V> extends Pipe<
 	keyPipe: Pipe<any, K>;
 	valPipe: Pipe<any, V>;
 
+	constructor(keyPipe: Pipe<any, K>, valPipe: Pipe<any, V>) {
+		super();
+		this.keyPipe = keyPipe;
+		this.valPipe = valPipe;
+	}
+
+	get inputName() {
+		return "object";
+	}
+
 	static typeCheck(v: any): v is Record<any, any> {
-		return Object.prototype.toString.call(v) === "[object Object]";
+		return v && typeof v === "object";
 	}
 
-	constructor(keyPipe: Pipe<any, K>, valPipe: Pipe<any, V>) {
-		super(
-			new HalfPipe("object", ValioRecord.typeCheck, function anyToRecordKV(
-				input: Record<any, any>,
-				ctx: Context,
-			): Result<Record<K, V>> {
-				const output = {} as Record<K, V>;
-
-				let success = true;
-				const length = ctx.jsonPath.length;
-				for (const key in input) {
-					ctx.jsonPath[length] = key;
-					const decodedKey = keyPipe.decode(key, ctx);
-					if (decodedKey.success) {
-						const decodedVal = valPipe.decode((input as any)[key], ctx);
-						if (decodedVal.success) {
-							output[decodedKey.output] = decodedVal.output;
-						} else {
-							success = false;
-						}
-					} else {
-						success = false;
-					}
+	inputTypeCheck(v: any): v is Record<any, any> {
+		return ValioRecord.typeCheck(v);
+	}
+
+	inputTransform(input: Record<any, any>, ctx: Context): Result<Record<K, V>> {
+		const output = {} as Record<K, V>;
+
+		let success = true;
+		const length = ctx.jsonPath.length;
+		for (const key in input) {
+			ctx.jsonPath[length] = key;
+			const decodedKey = this.keyPipe.decode(key, ctx);
+			if (decodedKey.success) {
+				const decodedVal = this.valPipe.decode((input as any)[key], ctx);
+				if (decodedVal.success) {
+					output[decodedKey.output] = decodedVal.output;
+				} else {
+					success = false;
 				}
-				ctx.jsonPath.length = length;
-
-				if (!success) return { success, errors: ctx.errors };
-				return { success, output };
-			}),
-			new HalfPipe(
-				`record<${keyPipe.o.name},${valPipe.o.name}>`,
-				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;
-						if (!valPipe.o.typeCheck(v[k])) return false;
-					}
-					return true;
-				},
-			),
-		);
-		this.keyPipe = keyPipe;
-		this.valPipe = valPipe;
+			} else {
+				success = false;
+			}
+		}
+		ctx.jsonPath.length = length;
+
+		if (!success) return { success, errors: ctx.errors };
+		return { success, output };
+	}
+
+	get outputName() {
+		return `record<${this.keyPipe.inputName},${this.valPipe.outputName}>`;
+	}
+
+	outputTypeCheck(v: any): 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;
+			if (!this.valPipe.outputTypeCheck(v[k])) return false;
+		}
+		return true;
 	}
 }
 export function record<K extends PropertyKey, V>(
@@ -116,37 +131,45 @@ export class Union<T extends Readonly<Pipe[]>> extends Pipe<
 	options: T;
 
 	constructor(options: T) {
-		const name = options.map((o) => o.o.name).join("|");
-		type O = Output<T[number]>;
-		super(
-			new HalfPipe(
-				name,
-				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> => {
-					// 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;
-					}
-
-					// 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, function isUnionType2(v: any): v is O {
-				for (const f of options) if (f.o.typeCheck(v)) return true;
-				return false;
-			}),
-		);
+		super();
 		this.options = options;
 	}
+
+	get inputName() {
+		return this.options.map((o) => o.outputName).join("|");
+	}
+
+	inputTypeCheck(v: any): v is Output<T[number]> {
+		for (const f of this.options) if (f.inputTypeCheck(v)) return true;
+		return false;
+	}
+
+	inputTransform(
+		data: Output<T[number]>,
+		ctx: Context,
+	): Result<Output<T[number]>> {
+		// Throw away errors since we expect them.
+		const newCtx = new Context();
+		newCtx.pushErrorFmt = () => {};
+		newCtx.pushError = () => {};
+		for (const f of this.options) {
+			const decoded = f.decode(data, newCtx);
+			if (decoded.success) return decoded;
+		}
+
+		// Sad path -- do again with real ctx to gather errors.
+		for (const f of this.options) f.decode(data, ctx);
+		return { success: false, errors: ctx.errors };
+	}
+
+	get outputName() {
+		return this.inputName;
+	}
+
+	outputTypeCheck(v: any): v is Output<T[number]> {
+		for (const f of this.options) if (f.outputTypeCheck(v)) return true;
+		return false;
+	}
 }
 export function union<T extends Readonly<Pipe[]>>(options: T): Union<T> {
 	return new Union(options);
@@ -188,30 +211,26 @@ export class ValioObject<
 	}
 
 	constructor(shape: Shape, isLoose: boolean) {
-		super(
-			new HalfPipe("object", ValioObject.typeCheck, (data, ctx) =>
-				this.transformInput(data, ctx),
-			),
-			new HalfPipe(
-				`{${Object.entries(shape)
-					.map(([k, v]) => `${k}: ${v.o.name}`)
-					.join(",")}}`,
-				(v) => this.typeCheckOutput(v),
-			),
-		);
-
+		super();
 		this.shape = shape;
 		this.isLoose = isLoose;
 	}
 
-	clone(): this {
-		return new ValioObject(this.shape, this.isLoose) as any;
+	get inputName() {
+		return "object";
 	}
 
-	protected transformInput(
-		data: object,
-		ctx: Context,
-	): Result<ObjectOutput<Shape>> {
+	get outputName() {
+		return `{${Object.entries(this.shape)
+			.map(([k, v]) => `${k}: ${v.outputName}`)
+			.join(",")}}`;
+	}
+
+	inputTypeCheck(v: any): v is Record<any, any> {
+		return ValioObject.typeCheck(v);
+	}
+
+	inputTransform(data: object, ctx: Context): Result<ObjectOutput<Shape>> {
 		const output: Record<PropertyKey, any> = this.isLoose ? data : {};
 		let success = true;
 
@@ -232,10 +251,10 @@ export class ValioObject<
 		return { success, output: output as ObjectOutput<Shape> };
 	}
 
-	protected typeCheckOutput(v: any): v is ObjectOutput<Shape> {
+	outputTypeCheck(v: any): v is ObjectOutput<Shape> {
 		if (!ValioObject.typeCheck(v)) return false;
 		for (const s in this.shape)
-			if (!this.shape[s]!.o.typeCheck(v[s])) return false;
+			if (!this.shape[s]!.outputTypeCheck(v[s])) return false;
 		return true;
 	}
 

package/src/pipe.ts

@@ -5,49 +5,12 @@ export type Errors = { [inputPath: string]: Error[] };
 export type Result<T> =
 	| { success: true; output: T }
 	| { success: false; errors: any };
-
-function clone<T>(obj: T): T {
-	return Object.create(
-		Object.getPrototypeOf(obj),
-		Object.getOwnPropertyDescriptors(obj),
-	);
-}
-
-interface Check<T> {
+export interface Check<T> {
 	valid(data: T, ctx: Context): boolean;
 	name: string;
 	props: Record<any, any>;
 }
 
-export class HalfPipe<I, O = never> {
-	name: string;
-	typeCheck: (v: any) => v is I;
-	transform?: (v: I, ctx: Context) => Result<O>;
-	/** Checks to run after type check */
-	checks: Check<I>[] = [];
-
-	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(),
-		);
-	}
-}
-
 /** During encoding, decoding, or validation. */
 export class Context {
 	jsonPath: (string | number)[] = [];
@@ -75,13 +38,18 @@ export class Context {
 		this.pushError({ input, message });
 	}
 
-	run<I, O>(input: any, halfPipe: HalfPipe<I, O>): Result<I> {
-		if (!halfPipe.typeCheck(input)) {
-			this.pushErrorFmt("type", input, { expected: halfPipe.name });
+	run<I>(
+		input: any,
+		name: () => string,
+		typeCheck: (v: any) => v is I,
+		checks?: Check<I>[],
+	): Result<I> {
+		if (!typeCheck(input)) {
+			this.pushErrorFmt("type", input, { expected: name() });
 			return { success: false, errors: this.errors };
 		}
 		let success = true;
-		for (const c of halfPipe.checks ?? []) {
+		for (const c of checks ?? []) {
 			if (!c.valid(input, this)) {
 				this.pushErrorFmt(c.name, input, c.props);
 				success = false;
@@ -92,35 +60,47 @@ export class Context {
 	}
 }
 
-export class Pipe<I = any, O = any> {
-	i: HalfPipe<I, O>;
-	o: HalfPipe<O, I>;
-
-	constructor(i: HalfPipe<I, O>, o: HalfPipe<O, I>) {
-		this.i = i;
-		this.o = o;
-	}
+export function cloneObject(obj: any) {
+	const res =
+		Object.getPrototypeOf(obj) == Object.prototype ? {} : Object.create(obj);
+	for (const p in obj) {
+		const v = obj[p];
+		if (Array.isArray(v)) res[p] = v.slice();
+		else if (v && v.clone) res[p] = v.clone();
+		else if (v && typeof v === "object") res[p] = cloneObject(v);
+		else res[p] = v;
+	}
+	return res;
+}
 
+export abstract class Pipe<I = any, O = any> {
 	pipes: Pipe<any, any>[] = [];
 	registry: Record<PropertyKey, any> = {};
-	debug = false;
+
+	abstract inputName: string;
+	abstract inputTypeCheck(v: any): v is I;
+	/** Checks to run after type check */
+	inputChecks?: Check<I>[];
+	inputTransform?(v: I, ctx: Context): Result<O>;
+
+	abstract outputName: string;
+	abstract outputTypeCheck(v: any): v is O;
+	/** Checks to run after type check */
+	outputChecks?: Check<O>[];
+	outputTransform?(v: O, ctx: Context): Result<I>;
 
 	clone(): this {
-		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;
+		return cloneObject(this);
 	}
 
 	refine(
 		valid: (data: O, ctx: Context) => boolean,
 		name: string,
 		props: Record<any, any> = {},
-	): this {
+	) {
 		const res = this.clone();
-		res.o.checks.push({ valid, name, props });
+		res.outputChecks ??= [];
+		res.outputChecks.push({ valid, name, props });
 		return res;
 	}
 
@@ -132,15 +112,25 @@ export class Pipe<I = any, O = any> {
 
 	decodeAny(input: any, ctx = new Context()): Result<O> {
 		// 1. Verify input
-		let res: Result<any> = ctx.run(input, this.i);
+		let res: Result<any> = ctx.run(
+			input,
+			() => this.inputName,
+			this.inputTypeCheck.bind(this),
+			this.inputChecks,
+		);
 		if (!res.success) return res;
 		// 2. Transform input to output
-		if (this.i.transform) {
-			res = this.i.transform(res.output, ctx);
+		if (this.inputTransform) {
+			res = this.inputTransform(res.output, ctx);
 			if (!res.success) return res;
 		}
 		// 3. Verify output
-		res = ctx.run(res.output, this.o);
+		res = ctx.run(
+			res.output,
+			() => this.outputName,
+			this.outputTypeCheck.bind(this),
+			this.outputChecks,
+		);
 		if (!res.success) return res;
 		// 4. Next
 		for (const p of this.pipes) {
@@ -161,21 +151,31 @@ export class Pipe<I = any, O = any> {
 			if (!res.success) return res;
 		}
 		// 2. Verify output
-		res = ctx.run(res.output, this.o);
+		res = ctx.run(
+			res.output,
+			() => this.outputName,
+			this.outputTypeCheck.bind(this),
+			this.outputChecks,
+		);
 		if (!res.success) return res;
 		// 3. Transform output to input
-		if (this.o.transform) {
-			res = this.o.transform(res.output, ctx);
+		if (this.outputTransform) {
+			res = this.outputTransform(res.output, ctx);
 			if (!res.success) return res;
 		}
 		// 4. Verify input
-		return ctx.run(res.output, this.i);
+		return ctx.run(
+			res.output,
+			() => this.inputName,
+			this.inputTypeCheck.bind(this),
+			this.inputChecks,
+		);
 	}
 	encode(output: O, ctx = new Context()): Result<I> {
 		return this.encodeAny(output, ctx);
 	}
 
-	register(key: PropertyKey, value: any): this {
+	register(key: PropertyKey, value: any): Pipe<I, O> {
 		const res = this.clone();
 		res.registry[key] = value;
 		return res;