@oh-my-pi/omptype 17.2.6 → 17.2.7

package/src/typebox.ts

@@ -149,7 +149,7 @@ function applyMeta<T>(schema: RuntimeType<T>, opts?: Meta): CompatRuntime<T> {
 }
 
 function withJsonSchemaKeywords<T>(schema: CompatRuntime<T>, keywords: Record<string, unknown>): CompatRuntime<T> {
-	const emitBase = schema.toJsonSchema;
+	const emitBase = schema.toJsonSchema.bind(schema);
 	schema.toJsonSchema = options => ({ ...emitBase(options), ...keywords });
 	return schema;
 }

package/src/zod.ts

@@ -1,6 +1,6 @@
-import { OmpTypeError } from "./errors";
+import { type OmpErrors, OmpTypeError } from "./errors";
 import { type EmbeddableSchema, embed, type IR, IR_BRAND, type PropIR } from "./ir";
-import { type FluentType, type NarrowContext, type Type, type } from "./type";
+import { type NarrowContext, type Type, type } from "./type";
 
 interface OptionalSchemaMarker {
 	readonly _optional: true;
@@ -11,6 +11,15 @@ interface RefineOptions {
 	error?: string;
 }
 
+interface Decoratable<out Out> extends EmbeddableSchema {
+	(value: unknown): Out | OmpErrors;
+	narrow(predicate: (value: Out, context: NarrowContext) => unknown): Decoratable<Out>;
+	pipe<Next>(transform: (value: Out, context: NarrowContext) => Next): Decoratable<Exclude<Next, OmpErrors>>;
+	or(def: unknown): Decoratable<unknown>;
+	describe(description: string): Decoratable<Out>;
+	default(value: Out | (() => Out)): Decoratable<Out>;
+}
+
 export interface ZodLikeIssue {
 	path: PropertyKey[];
 	message: string;
@@ -21,7 +30,7 @@ export type ZodLikeSafeParseResult<Out> =
 	| { success: false; error: { message: string; issues: ZodLikeIssue[] } };
 
 /** A callable omptype schema carrying the Zod-v4-style fluent surface. */
-export interface ZodLikeSchema<out Out> extends Type<Out> {
+export interface ZodLikeSchema<out Out> extends Type<Out, unknown> {
 	readonly _output: Out;
 	/** @internal Used while composing object property IR. */
 	readonly isOptional: boolean;
@@ -47,7 +56,7 @@ export interface ZodLikeSchema<out Out> extends Type<Out> {
 	partial(): Out extends object ? ZodLikeSchema<Partial<Out>> : ZodLikeSchema<Out>;
 }
 
-function schemaFromIR<Out>(ir: IR): FluentType<Out> {
+function schemaFromIR<Out>(ir: IR): Decoratable<Out> {
 	const embedded: EmbeddableSchema = {
 		[IR_BRAND]: true,
 		ir,
@@ -55,23 +64,19 @@ function schemaFromIR<Out>(ir: IR): FluentType<Out> {
 		hasDefault: false,
 		run: value => value,
 	};
-	return type.raw(embedded) as FluentType<Out>;
+	return type.raw(embedded) as unknown as Decoratable<Out>;
 }
 
-function withMeta<Out>(source: FluentType<Out>, target: FluentType<Out>): FluentType<Out> {
-	let next = target;
+function restrictBase<Out>(source: Decoratable<Out>, ir: IR): Decoratable<Out> {
+	let next = source.hasSteps
+		? schemaFromIR<Out>({ k: "morph", input: ir, fn: value => source(value) })
+		: schemaFromIR<Out>(ir);
 	if (source.description !== undefined) next = next.describe(source.description);
 	if (source.hasDefault) next = next.default(source.defaultValue as Out | (() => Out));
 	return next;
 }
 
-function restrictBase<Out>(source: FluentType<Out>, ir: IR): FluentType<Out> {
-	let next = schemaFromIR<Out>(ir);
-	if (source.hasSteps) next = next.pipe(value => source(value)) as FluentType<Out>;
-	return withMeta(source, next);
-}
-
-function lengthBound(kind: "min" | "max", schema: FluentType<unknown>, bound: number): void {
+function lengthBound(kind: "min" | "max", schema: Decoratable<unknown>, bound: number): void {
 	if (schema.ir.k !== "string" && schema.ir.k !== "array") return;
 	if (!Number.isSafeInteger(bound) || bound < 0) {
 		throw new OmpTypeError(`${kind} length must be a nonnegative safe integer`);
@@ -98,8 +103,8 @@ function isStringKeyIR(ir: IR): boolean {
 	}
 }
 
-function decorate<Out>(schema: FluentType<Out>, optional = false): ZodLikeSchema<Out> {
-	const next = (inner: FluentType<Out>, nextOptional = optional): ZodLikeSchema<Out> => decorate(inner, nextOptional);
+function decorate<Out>(schema: Decoratable<Out>, optional = false): ZodLikeSchema<Out> {
+	const next = (inner: Decoratable<Out>, nextOptional = optional): ZodLikeSchema<Out> => decorate(inner, nextOptional);
 	const withObjectExtras = (extras: "keep" | "reject" | "delete"): ZodLikeSchema<Out> => {
 		if (schema.ir.k !== "object") throw new OmpTypeError("object mode requires an object schema");
 		return next(restrictBase(schema, { ...schema.ir, extras }));
@@ -181,21 +186,21 @@ function decorate<Out>(schema: FluentType<Out>, optional = false): ZodLikeSchema
 			return next(restrictBase(schema, { ...schema.ir, url: true }));
 		},
 		optional(): ZodLikeSchema<Out | undefined> & OptionalSchemaMarker {
-			const widened = schema.or(type.raw("undefined")) as FluentType<Out | undefined>;
+			const widened = schema.or(type.raw("undefined")) as Decoratable<Out | undefined>;
 			return decorate(widened, true) as ZodLikeSchema<Out | undefined> & OptionalSchemaMarker;
 		},
 		nullable(): ZodLikeSchema<Out | null> {
-			return decorate(schema.or(type.raw("null")) as FluentType<Out | null>, optional);
+			return decorate(schema.or(type.raw("null")) as Decoratable<Out | null>, optional);
 		},
 		default(
 			value: Exclude<Out, undefined> | (() => Exclude<Out, undefined>),
 		): ZodLikeSchema<Exclude<Out, undefined>> {
 			type DefaultOut = Exclude<Out, undefined>;
-			const widened = schema.or(type.raw("undefined")) as FluentType<Out | undefined>;
+			const widened = schema.or(type.raw("undefined")) as Decoratable<Out | undefined>;
 			const piped = widened.pipe(output => {
 				if (output !== undefined) return output as DefaultOut;
 				return typeof value === "function" ? (value as () => DefaultOut)() : value;
-			}) as FluentType<DefaultOut>;
+			}) as Decoratable<DefaultOut>;
 			return decorate(piped.default(value as DefaultOut | (() => DefaultOut)));
 		},
 		describe(description: string): ZodLikeSchema<Out> {
@@ -221,7 +226,7 @@ function decorate<Out>(schema: FluentType<Out>, optional = false): ZodLikeSchema
 				}
 				return typeof fallback === "function" ? (fallback as () => Out)() : fallback;
 			});
-			return decorate(caught as FluentType<Out>, optional);
+			return decorate(caught as Decoratable<Out>, optional);
 		},
 		strict(): ZodLikeSchema<Out> {
 			return withObjectExtras("reject");
@@ -242,6 +247,10 @@ function decorate<Out>(schema: FluentType<Out>, optional = false): ZodLikeSchema
 	}) as unknown as ZodLikeSchema<Out>;
 }
 
+function decorateUnknown(schema: Decoratable<unknown>): ZodLikeSchema<unknown> {
+	return decorate(schema);
+}
+
 export type infer<T> = T extends { readonly _output: infer Out } ? Out : never;
 
 type SchemaOutput<Schema> = Schema extends { readonly _output: infer Out } ? Out : never;
@@ -254,7 +263,7 @@ type ObjectOutput<S extends Shape> = {
 type Simplify<T> = { [K in keyof T]: T[K] };
 type UnionOutput<Schemas extends readonly ZodLikeSchema<unknown>[]> = SchemaOutput<Schemas[number]>;
 
-function objectSchema<const S extends Shape>(shape: S): ZodLikeSchema<Simplify<ObjectOutput<S>>> {
+function objectSchema<const S extends Shape>(shape: S): ZodLikeSchema<ObjectOutput<S>> {
 	const props: PropIR[] = [];
 	for (const key in shape) {
 		const member = shape[key];
@@ -266,18 +275,21 @@ function objectSchema<const S extends Shape>(shape: S): ZodLikeSchema<Simplify<O
 		}
 		props.push(prop);
 	}
-	return decorate(schemaFromIR({ k: "object", props, extras: "delete" }));
+	return decorateUnknown(schemaFromIR<unknown>({ k: "object", props, extras: "delete" })) as unknown as ZodLikeSchema<
+		ObjectOutput<S>
+	>;
 }
 
 export const string = (): ZodLikeSchema<string> => decorate(schemaFromIR(type.string.ir));
 export const number = (): ZodLikeSchema<number> => decorate(schemaFromIR(type.number.ir));
 export const boolean = (): ZodLikeSchema<boolean> => decorate(schemaFromIR(type.boolean.ir));
-export const literal = <const Value>(value: Value): ZodLikeSchema<Value> => decorate(type.enumerated(value));
+export const literal = <const Value>(value: Value): ZodLikeSchema<Value> =>
+	decorate(schemaFromIR<Value>(type.enumerated(value).ir));
 const enumSchema = <const Values extends readonly [string, ...string[]]>(
 	values: Values,
 ): ZodLikeSchema<Values[number]> => {
 	if (values.length === 0) throw new OmpTypeError("enum requires at least one value");
-	return decorate(type.enumerated(...values));
+	return decorate(schemaFromIR<Values[number]>(type.enumerated(...values).ir));
 };
 
 export { enumSchema as enum };
@@ -312,8 +324,9 @@ export const record = <Key extends string, Value>(
 };
 export const unknown = (): ZodLikeSchema<unknown> => decorate(schemaFromIR(type.unknown.ir));
 export const any = (): ZodLikeSchema<unknown> => decorate(schemaFromIR(type.unknown.ir));
-const nullSchema = (): ZodLikeSchema<null> => decorate(type.raw("null") as FluentType<null>);
-const undefinedSchema = (): ZodLikeSchema<undefined> => decorate(type.raw("undefined") as FluentType<undefined>);
+const nullSchema = (): ZodLikeSchema<null> => decorate(type.raw("null") as unknown as Decoratable<null>);
+const undefinedSchema = (): ZodLikeSchema<undefined> =>
+	decorate(type.raw("undefined") as unknown as Decoratable<undefined>);
 
 export { nullSchema as null, undefinedSchema as undefined };