@temelj/standard-schema 0.1.0 → 0.2.0

package/README.md

@@ -43,3 +43,9 @@ import { ss } from "@temelj/standard-schema";
 const schema = ss.string();
 const result = schema["~standard"].validate("hello");
 ```
+
+`SchemaFields` names an object's field schemas. `object` validates those fields and strips other keys; `strictObject` rejects extra keys. `looseObject` preserves extra keys at runtime, but its output type exposes only the validated fields.
+
+`array()` checks the container and returns `unknown[]`. Pass an element schema, such as `array(string())`, to validate its elements. `fn()` checks that a value is callable; it does not validate the function's parameters or result.
+
+`defaulted(schema, value)` uses the supplied value, including function values. Use `defaultedWith(schema, () => value)` to create a default only when the input is `undefined`.

package/dist/mod.d.mts

@@ -1,54 +1,130 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/mod.d.ts
-type Schema<TInput = unknown, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
-type SchemaOutput<TSchema extends Schema> = StandardSchemaV1.InferOutput<TSchema>;
-type SchemaResult<TOutput> = StandardSchemaV1.Result<TOutput>;
-type SchemaIssue = StandardSchemaV1.Issue;
-type SchemaValidator<TOutput> = (value: unknown) => SchemaResult<TOutput>;
-type SchemaShape = Record<string, Schema>;
-type ObjectOutput<TShape extends SchemaShape> = { readonly [TKey in keyof TShape]: SchemaOutput<TShape[TKey]> };
-declare function schema<TInput, TOutput>(validate: SchemaValidator<TOutput>): Schema<TInput, TOutput>;
-declare function success<T>(value: T): StandardSchemaV1.SuccessResult<T>;
-declare function failure(message: string, path?: ReadonlyArray<PropertyKey>): StandardSchemaV1.FailureResult;
-declare class StandardSchemaValidationError extends Error {
+export type Schema<TInput = unknown, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
+export type SchemaInput<TSchema extends Schema> = StandardSchemaV1.InferInput<TSchema>;
+export type SchemaOutput<TSchema extends Schema> = StandardSchemaV1.InferOutput<TSchema>;
+export type SchemaResult<TOutput> = StandardSchemaV1.Result<TOutput>;
+export type SchemaIssue = StandardSchemaV1.Issue;
+export type SchemaValidator<TOutput> = (value: unknown) => SchemaResult<TOutput>;
+export type SchemaFields = Record<string, Schema>;
+export type ObjectOutput<TFields extends SchemaFields> = { readonly [TKey in keyof TFields]: SchemaOutput<TFields[TKey]>; };
+export type ObjectInput<TFields extends SchemaFields> = { readonly [TKey in keyof TFields]: SchemaInput<TFields[TKey]>; };
+export type SafeParseResult<T> = {
+  readonly success: true;
+  readonly value: T;
+} | {
+  readonly success: false;
   readonly issues: ReadonlyArray<SchemaIssue>;
-  constructor(message: string, issues: ReadonlyArray<SchemaIssue>);
+};
+export interface ObjectOptions {
+  readonly unknownKeys?: "strip" | "passthrough" | "strict";
+}
+interface Constructor<T> extends Function {
+  readonly prototype: T;
+  readonly name: string;
+}
+export declare function schema<TInput, TOutput>(validate: SchemaValidator<TOutput>): Schema<TInput, TOutput>;
+export declare function success<T>(value: T): StandardSchemaV1.SuccessResult<T>;
+export declare function failure(message: string, path?: ReadonlyArray<PropertyKey>): StandardSchemaV1.FailureResult;
+export declare class StandardSchemaValidationError extends Error {
+  readonly issues: ReadonlyArray<SchemaIssue>;
+  constructor(message: string, issues: ReadonlyArray<SchemaIssue>, context?: Function);
+  static failed(this: void, message: string, issues: ReadonlyArray<SchemaIssue>): never;
+}
+export declare class StandardSchemaAsyncValidationError extends Error {
+  constructor(message: string, context?: Function);
+  static unsupported(this: void): never;
 }
-declare function validateStandardSchema<TSchema extends Schema>(inputSchema: TSchema, value: unknown, message?: string): Promise<SchemaOutput<TSchema>>;
-declare function validateStandardSchemaSync<TSchema extends Schema>(inputSchema: TSchema, value: unknown, message?: string): SchemaOutput<TSchema>;
-declare function unknown(): Schema<unknown>;
-declare function string(message?: string): Schema<unknown, string>;
-declare function number(message?: string): Schema<unknown, number>;
-declare function boolean(message?: string): Schema<unknown, boolean>;
-declare function literal<const TValue extends string | number | boolean | null | undefined>(expected: TValue, message?: string): Schema<unknown, TValue>;
-declare function picklist<const TValues extends readonly [unknown, ...unknown[]]>(values: TValues, message?: string): Schema<unknown, TValues[number]>;
-declare function union<const TSchemas extends readonly [Schema, ...Schema[]]>(schemas: TSchemas, message?: string): Schema<unknown, SchemaOutput<TSchemas[number]>>;
-declare function array<TItem extends Schema = Schema<unknown>>(itemSchema?: TItem, message?: string): Schema<unknown, SchemaOutput<TItem>[]>;
-declare function object<TShape extends SchemaShape>(shape: TShape, message?: string): Schema<unknown, ObjectOutput<TShape>>;
-declare function record<TValue extends Schema>(valueSchema: TValue, message?: string): Schema<unknown, Record<string, SchemaOutput<TValue>>>;
-declare function optional<TSchema extends Schema>(inner: TSchema): Schema<unknown, SchemaOutput<TSchema> | undefined>;
-declare function defaulted<TSchema extends Schema>(inner: TSchema, defaultValue: SchemaOutput<TSchema> | (() => SchemaOutput<TSchema>)): Schema<unknown, SchemaOutput<TSchema>>;
-declare const ss: {
+export declare function validateStandardSchema<TSchema extends Schema>(inputSchema: TSchema, value: unknown, message?: string): Promise<SchemaOutput<TSchema>>;
+export declare function validateStandardSchemaSync<TSchema extends Schema>(inputSchema: TSchema, value: unknown, message?: string): SchemaOutput<TSchema>;
+export declare function safeParse<TSchema extends Schema>(inputSchema: TSchema, value: SchemaInput<TSchema>): Promise<SafeParseResult<SchemaOutput<TSchema>>>;
+export declare function safeParseSync<TSchema extends Schema>(inputSchema: TSchema, value: SchemaInput<TSchema>): SafeParseResult<SchemaOutput<TSchema>>;
+export declare function parse<TSchema extends Schema>(inputSchema: TSchema, value: SchemaInput<TSchema>, message?: string): Promise<SchemaOutput<TSchema>>;
+export declare function parseSync<TSchema extends Schema>(inputSchema: TSchema, value: SchemaInput<TSchema>, message?: string): SchemaOutput<TSchema>;
+export declare function unknown(): Schema<unknown>;
+export declare function string(message?: string): Schema<unknown, string>;
+export declare function number(message?: string): Schema<unknown, number>;
+export declare function finite(message?: string): Schema<unknown, number>;
+export declare function integer(message?: string): Schema<unknown, number>;
+export declare function safeInteger(message?: string): Schema<unknown, number>;
+export declare function positiveNumber(message?: string): Schema<unknown, number>;
+export declare function nonNegativeNumber(message?: string): Schema<unknown, number>;
+export declare function positiveSafeInteger(message?: string): Schema<unknown, number>;
+export declare function nonNegativeSafeInteger(message?: string): Schema<unknown, number>;
+export declare function min(inner: Schema<unknown, number>, minimum: number, message?: string): Schema<unknown, number>;
+export declare function max(inner: Schema<unknown, number>, maximum: number, message?: string): Schema<unknown, number>;
+export declare function nonEmptyString(message?: string): Schema<unknown, string>;
+export declare function nonBlankString(message?: string): Schema<unknown, string>;
+export declare function boolean(message?: string): Schema<unknown, boolean>;
+export declare function fn(message?: string): Schema<unknown, Function>;
+export declare function instanceOf<T>(constructor: Constructor<T>, message?: string): Schema<unknown, T>;
+export declare function literal<const TValue extends string | number | boolean | null | undefined>(expected: TValue, message?: string): Schema<unknown, TValue>;
+export declare function picklist<const TValues extends readonly [unknown, ...unknown[]]>(values: TValues, message?: string): Schema<unknown, TValues[number]>;
+export declare function union<const TSchemas extends readonly [Schema, ...Schema[]]>(schemas: TSchemas, message?: string): Schema<unknown, SchemaOutput<TSchemas[number]>>;
+export declare function array(): Schema<unknown, unknown[]>;
+export declare function array<TItem extends Schema>(itemSchema: TItem, message?: string): Schema<unknown, SchemaOutput<TItem>[]>;
+export declare function object<TFields extends SchemaFields>(fields: TFields, message?: string, options?: ObjectOptions): Schema<unknown, ObjectOutput<TFields>>;
+export declare function strictObject<TFields extends SchemaFields>(fields: TFields, message?: string): Schema<unknown, ObjectOutput<TFields>>;
+export declare function looseObject<TFields extends SchemaFields>(fields: TFields, message?: string): Schema<unknown, ObjectOutput<TFields>>;
+export declare function record<TValue extends Schema>(valueSchema: TValue, message?: string): Schema<unknown, Record<string, SchemaOutput<TValue>>>;
+export declare function optional<TSchema extends Schema>(inner: TSchema): Schema<unknown, SchemaOutput<TSchema> | undefined>;
+export declare function defaulted<TSchema extends Schema>(inner: TSchema, defaultValue: SchemaOutput<TSchema>): Schema<unknown, SchemaOutput<TSchema>>;
+export declare function defaultedWith<TSchema extends Schema>(inner: TSchema, createDefault: () => SchemaOutput<TSchema>): Schema<unknown, SchemaOutput<TSchema>>;
+export declare function refine<TSchema extends Schema, TOutput extends SchemaOutput<TSchema>>(inner: TSchema, predicate: (value: SchemaOutput<TSchema>) => value is TOutput, message?: string): Schema<SchemaInput<TSchema>, TOutput>;
+export declare function refine<TSchema extends Schema>(inner: TSchema, predicate: (value: SchemaOutput<TSchema>) => boolean, message?: string): Schema<SchemaInput<TSchema>, SchemaOutput<TSchema>>;
+export declare function transform<TSchema extends Schema, TOutput>(inner: TSchema, mapper: (value: SchemaOutput<TSchema>) => TOutput): Schema<SchemaInput<TSchema>, TOutput>;
+export declare function pipe<TLeft extends Schema, TRight extends Schema>(left: TLeft, right: TRight): Schema<SchemaInput<TLeft>, SchemaOutput<TRight>>;
+export declare function extend<TBase extends SchemaFields, TExtension extends SchemaFields>(base: TBase, extension: TExtension): Omit<TBase, keyof TExtension> & TExtension;
+export declare function pick<TFields extends SchemaFields, const TKeys extends readonly (keyof TFields)[]>(fields: TFields, keys: TKeys): Pick<TFields, TKeys[number]>;
+export declare function omit<TFields extends SchemaFields, const TKeys extends readonly (keyof TFields)[]>(fields: TFields, keys: TKeys): Omit<TFields, TKeys[number]>;
+export declare function partial<TFields extends SchemaFields>(fields: TFields): { readonly [TKey in keyof TFields]: Schema<unknown, SchemaOutput<TFields[TKey]> | undefined>; };
+export declare const ss: {
   schema: typeof schema;
   success: typeof success;
   failure: typeof failure;
   StandardSchemaValidationError: typeof StandardSchemaValidationError;
   validateStandardSchema: typeof validateStandardSchema;
   validateStandardSchemaSync: typeof validateStandardSchemaSync;
+  safeParse: typeof safeParse;
+  safeParseSync: typeof safeParseSync;
+  parse: typeof parse;
+  parseSync: typeof parseSync;
   unknown: typeof unknown;
   string: typeof string;
   number: typeof number;
+  finite: typeof finite;
+  integer: typeof integer;
+  safeInteger: typeof safeInteger;
+  positiveNumber: typeof positiveNumber;
+  nonNegativeNumber: typeof nonNegativeNumber;
+  positiveSafeInteger: typeof positiveSafeInteger;
+  nonNegativeSafeInteger: typeof nonNegativeSafeInteger;
+  min: typeof min;
+  max: typeof max;
+  nonEmptyString: typeof nonEmptyString;
+  nonBlankString: typeof nonBlankString;
   boolean: typeof boolean;
+  fn: typeof fn;
+  instanceOf: typeof instanceOf;
   literal: typeof literal;
   picklist: typeof picklist;
   union: typeof union;
   array: typeof array;
   object: typeof object;
+  strictObject: typeof strictObject;
+  looseObject: typeof looseObject;
   record: typeof record;
   optional: typeof optional;
   defaulted: typeof defaulted;
+  defaultedWith: typeof defaultedWith;
+  refine: typeof refine;
+  transform: typeof transform;
+  pipe: typeof pipe;
+  extend: typeof extend;
+  pick: typeof pick;
+  omit: typeof omit;
+  partial: typeof partial;
 };
 //#endregion
-export { ObjectOutput, Schema, SchemaIssue, SchemaOutput, SchemaResult, SchemaShape, SchemaValidator, StandardSchemaValidationError, array, boolean, defaulted, failure, literal, number, object, optional, picklist, record, schema, ss, string, success, union, unknown, validateStandardSchema, validateStandardSchemaSync };
+export {};
 //# sourceMappingURL=mod.d.mts.map

package/dist/mod.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.mts","names":[],"sources":["../src/mod.ts"],"mappings":";;;KAEY,MAAA,6BAAmC,MAAA,IAAU,gBAAA,CAAiB,MAAA,EAAQ,OAAA;AAAA,KAEtE,YAAA,iBAA6B,MAAA,IAAU,gBAAA,CAAiB,WAAA,CAAY,OAAA;AAAA,KAEpE,YAAA,YAAwB,gBAAA,CAAiB,MAAM,CAAC,OAAA;AAAA,KAEhD,WAAA,GAAc,gBAAA,CAAiB,KAAK;AAAA,KAEpC,eAAA,aAA4B,KAAA,cAAmB,YAAY,CAAC,OAAA;AAAA,KAE5D,WAAA,GAAc,MAAM,SAAS,MAAA;AAAA,KAE7B,YAAA,gBAA4B,WAAA,8BACd,MAAA,GAAS,YAAA,CAAa,MAAA,CAAO,IAAA;AAAA,iBAGvC,MAAA,kBACd,QAAA,EAAU,eAAA,CAAgB,OAAA,IACzB,MAAA,CAAO,MAAA,EAAQ,OAAA;AAAA,iBAUF,OAAA,IAAW,KAAA,EAAO,CAAA,GAAI,gBAAA,CAAiB,aAAA,CAAc,CAAA;AAAA,iBAIrD,OAAA,CACd,OAAA,UACA,IAAA,GAAO,aAAA,CAAc,WAAA,IACpB,gBAAA,CAAiB,aAAA;AAAA,cAWP,6BAAA,SAAsC,KAAA;EAAA,SACjC,MAAA,EAAQ,aAAA,CAAc,WAAA;cAE1B,OAAA,UAAiB,MAAA,EAAQ,aAAA,CAAc,WAAA;AAAA;AAAA,iBAO/B,sBAAA,iBAAuC,MAAA,EAC3D,WAAA,EAAa,OAAA,EACb,KAAA,WACA,OAAA,YACC,OAAA,CAAQ,YAAA,CAAa,OAAA;AAAA,iBAQR,0BAAA,iBAA2C,MAAA,EACzD,WAAA,EAAa,OAAA,EACb,KAAA,WACA,OAAA,YACC,YAAA,CAAa,OAAA;AAAA,iBASA,OAAA,IAAW,MAAM;AAAA,iBAIjB,MAAA,CAAO,OAAA,YAAgC,MAAM;AAAA,iBAI7C,MAAA,CAAO,OAAA,YAAgC,MAAM;AAAA,iBAI7C,OAAA,CAAQ,OAAA,YAAiC,MAAM;AAAA,iBAI/C,OAAA,oEACd,QAAA,EAAU,MAAA,EACV,OAAA,YACC,MAAA,UAAgB,MAAA;AAAA,iBAIH,QAAA,yDACd,MAAA,EAAQ,OAAA,EACR,OAAA,YACC,MAAA,UAAgB,OAAA;AAAA,iBAQH,KAAA,kCAAuC,MAAA,KAAW,MAAA,KAChE,OAAA,EAAS,QAAA,EACT,OAAA,YACC,MAAA,UAAgB,YAAA,CAAa,QAAA;AAAA,iBAoBhB,KAAA,eAAoB,MAAA,GAAS,MAAA,WAC3C,UAAA,GAAa,KAAA,EACb,OAAA,YACC,MAAA,UAAgB,YAAA,CAAa,KAAA;AAAA,iBA2BhB,MAAA,gBAAsB,WAAA,EACpC,KAAA,EAAO,MAAA,EACP,OAAA,YACC,MAAA,UAAgB,YAAA,CAAa,MAAA;AAAA,iBA4BhB,MAAA,gBAAsB,MAAA,EACpC,WAAA,EAAa,MAAA,EACb,OAAA,YACC,MAAA,UAAgB,MAAA,SAAe,YAAA,CAAa,MAAA;AAAA,iBAwB/B,QAAA,iBAAyB,MAAA,EACvC,KAAA,EAAO,OAAA,GACN,MAAA,UAAgB,YAAA,CAAa,OAAA;AAAA,iBAYhB,SAAA,iBAA0B,MAAA,EACxC,KAAA,EAAO,OAAA,EACP,YAAA,EAAc,YAAA,CAAa,OAAA,WAAkB,YAAA,CAAa,OAAA,KACzD,MAAA,UAAgB,YAAA,CAAa,OAAA;AAAA,cA6BnB,EAAA"}
+{"version":3,"file":"mod.d.mts","names":[],"sources":["../src/mod.ts"],"mappings":"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"}

package/dist/mod.mjs

@@ -1,3 +1,4 @@
+import { isBoolean, isFunction, isNumber, isObject, isString } from "@temelj/value";
 //#region src/mod.ts
 function schema(validate) {
 	return { "~standard": {
@@ -12,56 +13,134 @@ function success(value) {
 function failure(message, path) {
 	return { issues: [{
 		message,
-		...path === void 0 ? {} : { path }
+		path
 	}] };
 }
-var StandardSchemaValidationError = class extends Error {
+var StandardSchemaValidationError = class StandardSchemaValidationError extends Error {
 	issues;
-	constructor(message, issues) {
+	constructor(message, issues, context) {
 		super(message);
 		this.name = "StandardSchemaValidationError";
 		this.issues = issues;
+		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
+	}
+	static failed(message, issues) {
+		throw new StandardSchemaValidationError(message, issues, StandardSchemaValidationError.failed);
+	}
+};
+var StandardSchemaAsyncValidationError = class StandardSchemaAsyncValidationError extends Error {
+	constructor(message, context) {
+		super(message);
+		this.name = "StandardSchemaAsyncValidationError";
+		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
+	}
+	static unsupported() {
+		throw new StandardSchemaAsyncValidationError("Async schema validation is not supported", StandardSchemaAsyncValidationError.unsupported);
 	}
 };
 async function validateStandardSchema(inputSchema, value, message = "Schema validation failed") {
 	const result = await inputSchema["~standard"].validate(value);
 	if (!result.issues) return result.value;
-	throw new StandardSchemaValidationError(message, result.issues);
+	StandardSchemaValidationError.failed(message, result.issues);
 }
 function validateStandardSchemaSync(inputSchema, value, message = "Schema validation failed") {
-	const result = inputSchema["~standard"].validate(value);
-	ensureSynchronous(result);
+	const result = evaluate(inputSchema, value);
 	if (!result.issues) return result.value;
-	throw new StandardSchemaValidationError(message, result.issues);
+	StandardSchemaValidationError.failed(message, result.issues);
+}
+async function safeParse(inputSchema, value) {
+	const result = await inputSchema["~standard"].validate(value);
+	return result.issues ? {
+		success: false,
+		issues: result.issues
+	} : {
+		success: true,
+		value: result.value
+	};
+}
+function safeParseSync(inputSchema, value) {
+	const result = evaluate(inputSchema, value);
+	return result.issues ? {
+		success: false,
+		issues: result.issues
+	} : {
+		success: true,
+		value: result.value
+	};
+}
+async function parse(inputSchema, value, message) {
+	return await validateStandardSchema(inputSchema, value, message);
+}
+function parseSync(inputSchema, value, message) {
+	return validateStandardSchemaSync(inputSchema, value, message);
 }
 function unknown() {
 	return schema((value) => success(value));
 }
 function string(message = "Expected a string") {
-	return schema((value) => typeof value === "string" ? success(value) : failure(message));
+	return schema((value) => isString(value) ? success(value) : failure(message));
 }
 function number(message = "Expected a number") {
-	return schema((value) => typeof value === "number" ? success(value) : failure(message));
+	return schema((value) => isNumber(value) ? success(value) : failure(message));
+}
+function finite(message = "Expected a finite number") {
+	return refine(number(), Number.isFinite, message);
+}
+function integer(message = "Expected an integer") {
+	return refine(number(), Number.isInteger, message);
+}
+function safeInteger(message = "Expected a safe integer") {
+	return refine(number(), Number.isSafeInteger, message);
+}
+function positiveNumber(message = "Expected a positive number") {
+	return refine(number(), (value) => Number.isFinite(value) && value > 0, message);
+}
+function nonNegativeNumber(message = "Expected a non-negative number") {
+	return refine(number(), (value) => Number.isFinite(value) && value >= 0, message);
+}
+function positiveSafeInteger(message = "Expected a positive safe integer") {
+	return refine(number(), (value) => Number.isSafeInteger(value) && value > 0, message);
+}
+function nonNegativeSafeInteger(message = "Expected a non-negative safe integer") {
+	return refine(number(), (value) => Number.isSafeInteger(value) && value >= 0, message);
+}
+function min(inner, minimum, message = `Expected a number greater than or equal to ${minimum}`) {
+	return refine(inner, (value) => value >= minimum, message);
+}
+function max(inner, maximum, message = `Expected a number less than or equal to ${maximum}`) {
+	return refine(inner, (value) => value <= maximum, message);
+}
+function nonEmptyString(message = "Expected a non-empty string") {
+	return refine(string(), (value) => value.length > 0, message);
+}
+function nonBlankString(message = "Expected a non-blank string") {
+	return refine(string(), (value) => value.trim().length > 0, message);
 }
 function boolean(message = "Expected a boolean") {
-	return schema((value) => typeof value === "boolean" ? success(value) : failure(message));
+	return schema((value) => isBoolean(value) ? success(value) : failure(message));
+}
+function fn(message = "Expected a function") {
+	return schema((value) => isFunction(value) ? success(value) : failure(message));
+}
+function instanceOf(constructor, message = `Expected ${constructor.name}`) {
+	return schema((value) => value instanceof constructor ? success(value) : failure(message));
 }
 function literal(expected, message = `Expected ${String(expected)}`) {
 	return schema((value) => Object.is(value, expected) ? success(expected) : failure(message));
 }
 function picklist(values, message = `Expected one of ${values.map(String).join(", ")}`) {
-	return schema((value) => values.some((item) => Object.is(item, value)) ? success(value) : failure(message));
+	return schema((value) => {
+		const match = values.findIndex((item) => Object.is(item, value));
+		return match === -1 ? failure(message) : success(values[match]);
+	});
 }
 function union(schemas, message = "Expected a union match") {
 	return schema((value) => {
-		const issues = [];
 		for (const itemSchema of schemas) {
-			const result = itemSchema["~standard"].validate(value);
-			ensureSynchronous(result);
+			const result = evaluate(itemSchema, value);
 			if (!result.issues) return success(result.value);
-			issues.push(...result.issues);
 		}
-		return issues.length > 0 ? failure(message) : failure(message);
+		return failure(message);
 	});
 }
 function array(itemSchema, message = "Expected an array") {
@@ -71,37 +150,62 @@ function array(itemSchema, message = "Expected an array") {
 		const output = [];
 		const issues = [];
 		for (let index = 0; index < value.length; index++) {
-			const result = itemSchema["~standard"].validate(value[index]);
-			ensureSynchronous(result);
+			const result = evaluate(itemSchema, value[index]);
 			if (result.issues) issues.push(...result.issues.map((issue) => withPath(index, issue)));
 			else output.push(result.value);
 		}
 		return issues.length > 0 ? { issues } : success(output);
 	});
 }
-function object(shape, message = "Expected an object") {
+function object(fields, message = "Expected an object", options = {}) {
 	return schema((value) => {
-		if (value === null || typeof value !== "object" || Array.isArray(value)) return failure(message);
+		if (!isObject(value) || Array.isArray(value)) return failure(message);
 		const input = value;
 		const output = {};
+		if (options.unknownKeys === "passthrough") for (const key of Reflect.ownKeys(input)) {
+			if (!Object.prototype.propertyIsEnumerable.call(input, key)) continue;
+			Object.defineProperty(output, key, {
+				value: input[key],
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		}
 		const issues = [];
-		for (const key of Object.keys(shape)) {
-			const result = shape[key]["~standard"].validate(input[key]);
-			ensureSynchronous(result);
+		const fieldKeys = Object.keys(fields);
+		if (options.unknownKeys === "strict") {
+			for (const key of Object.keys(input)) if (!fieldKeys.includes(key)) issues.push({
+				message: "Unexpected key",
+				path: [key]
+			});
+		}
+		for (const key of fieldKeys) {
+			const hasOwnField = Object.prototype.hasOwnProperty.call(input, key);
+			const result = evaluate(fields[key], hasOwnField ? input[key] : void 0);
 			if (result.issues) issues.push(...result.issues.map((issue) => withPath(key, issue)));
-			else output[key] = result.value;
+			else if (hasOwnField || result.value !== void 0) Object.defineProperty(output, key, {
+				value: result.value,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
 		}
 		return issues.length > 0 ? { issues } : success(output);
 	});
 }
+function strictObject(fields, message = "Expected an object") {
+	return object(fields, message, { unknownKeys: "strict" });
+}
+function looseObject(fields, message = "Expected an object") {
+	return object(fields, message, { unknownKeys: "passthrough" });
+}
 function record(valueSchema, message = "Expected an object") {
 	return schema((value) => {
-		if (value === null || typeof value !== "object" || Array.isArray(value)) return failure(message);
+		if (!isObject(value) || Array.isArray(value)) return failure(message);
 		const output = {};
 		const issues = [];
 		for (const [key, item] of Object.entries(value)) {
-			const result = valueSchema["~standard"].validate(item);
-			ensureSynchronous(result);
+			const result = evaluate(valueSchema, item);
 			if (result.issues) issues.push(...result.issues.map((issue) => withPath(key, issue)));
 			else output[key] = result.value;
 		}
@@ -111,21 +215,66 @@ function record(valueSchema, message = "Expected an object") {
 function optional(inner) {
 	return schema((value) => {
 		if (value === void 0) return success(void 0);
-		const result = inner["~standard"].validate(value);
-		ensureSynchronous(result);
-		return result;
+		return evaluate(inner, value);
 	});
 }
 function defaulted(inner, defaultValue) {
 	return schema((value) => {
-		if (value === void 0) return success(typeof defaultValue === "function" ? defaultValue() : defaultValue);
-		const result = inner["~standard"].validate(value);
-		ensureSynchronous(result);
-		return result;
+		if (value === void 0) return success(defaultValue);
+		return evaluate(inner, value);
+	});
+}
+function defaultedWith(inner, createDefault) {
+	return schema((value) => value === void 0 ? success(createDefault()) : evaluate(inner, value));
+}
+function refine(inner, predicate, message = "Invalid value") {
+	return schema((value) => {
+		const result = evaluate(inner, value);
+		if (result.issues) return result;
+		return predicate(result.value) ? result : failure(message);
+	});
+}
+function transform(inner, mapper) {
+	return schema((value) => {
+		const result = evaluate(inner, value);
+		if (result.issues) return result;
+		return success(mapper(result.value));
 	});
 }
+function pipe(left, right) {
+	return schema((value) => {
+		const leftResult = evaluate(left, value);
+		if (leftResult.issues) return leftResult;
+		return evaluate(right, leftResult.value);
+	});
+}
+function extend(base, extension) {
+	return {
+		...base,
+		...extension
+	};
+}
+function pick(fields, keys) {
+	return Object.fromEntries(keys.map((key) => [key, fields[key]]));
+}
+function omit(fields, keys) {
+	const result = { ...fields };
+	for (const key of keys) delete result[key];
+	return result;
+}
+function partial(fields) {
+	const entries = Reflect.ownKeys(fields).map((key) => {
+		return [key, optional(fields[key])];
+	});
+	return Object.fromEntries(entries);
+}
+function evaluate(inputSchema, value) {
+	const result = inputSchema["~standard"].validate(value);
+	ensureSynchronous(result);
+	return result;
+}
 function ensureSynchronous(value) {
-	if (value instanceof Promise) throw new Error("Async schema validation is not supported");
+	if (value instanceof Promise) StandardSchemaAsyncValidationError.unsupported();
 }
 function withPath(key, issue) {
 	return {
@@ -140,20 +289,47 @@ const ss = {
 	StandardSchemaValidationError,
 	validateStandardSchema,
 	validateStandardSchemaSync,
+	safeParse,
+	safeParseSync,
+	parse,
+	parseSync,
 	unknown,
 	string,
 	number,
+	finite,
+	integer,
+	safeInteger,
+	positiveNumber,
+	nonNegativeNumber,
+	positiveSafeInteger,
+	nonNegativeSafeInteger,
+	min,
+	max,
+	nonEmptyString,
+	nonBlankString,
 	boolean,
+	fn,
+	instanceOf,
 	literal,
 	picklist,
 	union,
 	array,
 	object,
+	strictObject,
+	looseObject,
 	record,
 	optional,
-	defaulted
+	defaulted,
+	defaultedWith,
+	refine,
+	transform,
+	pipe,
+	extend,
+	pick,
+	omit,
+	partial
 };
 //#endregion
-export { StandardSchemaValidationError, array, boolean, defaulted, failure, literal, number, object, optional, picklist, record, schema, ss, string, success, union, unknown, validateStandardSchema, validateStandardSchemaSync };
+export { StandardSchemaAsyncValidationError, StandardSchemaValidationError, array, boolean, defaulted, defaultedWith, extend, failure, finite, fn, instanceOf, integer, literal, looseObject, max, min, nonBlankString, nonEmptyString, nonNegativeNumber, nonNegativeSafeInteger, number, object, omit, optional, parse, parseSync, partial, pick, picklist, pipe, positiveNumber, positiveSafeInteger, record, refine, safeInteger, safeParse, safeParseSync, schema, ss, strictObject, string, success, transform, union, unknown, validateStandardSchema, validateStandardSchemaSync };
 
 //# sourceMappingURL=mod.mjs.map

package/dist/mod.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mod.mjs","names":[],"sources":["../src/mod.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nexport type Schema<TInput = unknown, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;\n\nexport type SchemaOutput<TSchema extends Schema> = StandardSchemaV1.InferOutput<TSchema>;\n\nexport type SchemaResult<TOutput> = StandardSchemaV1.Result<TOutput>;\n\nexport type SchemaIssue = StandardSchemaV1.Issue;\n\nexport type SchemaValidator<TOutput> = (value: unknown) => SchemaResult<TOutput>;\n\nexport type SchemaShape = Record<string, Schema>;\n\nexport type ObjectOutput<TShape extends SchemaShape> = {\n  readonly [TKey in keyof TShape]: SchemaOutput<TShape[TKey]>;\n};\n\nexport function schema<TInput, TOutput>(\n  validate: SchemaValidator<TOutput>,\n): Schema<TInput, TOutput> {\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: \"@temelj/standard-schema\",\n      validate,\n    },\n  };\n}\n\nexport function success<T>(value: T): StandardSchemaV1.SuccessResult<T> {\n  return { value };\n}\n\nexport function failure(\n  message: string,\n  path?: ReadonlyArray<PropertyKey>,\n): StandardSchemaV1.FailureResult {\n  return {\n    issues: [\n      {\n        message,\n        ...(path === undefined ? {} : { path }),\n      },\n    ],\n  };\n}\n\nexport class StandardSchemaValidationError extends Error {\n  public readonly issues: ReadonlyArray<SchemaIssue>;\n\n  constructor(message: string, issues: ReadonlyArray<SchemaIssue>) {\n    super(message);\n    this.name = \"StandardSchemaValidationError\";\n    this.issues = issues;\n  }\n}\n\nexport async function validateStandardSchema<TSchema extends Schema>(\n  inputSchema: TSchema,\n  value: unknown,\n  message = \"Schema validation failed\",\n): Promise<SchemaOutput<TSchema>> {\n  const result = await inputSchema[\"~standard\"].validate(value);\n  if (!result.issues) {\n    return result.value as SchemaOutput<TSchema>;\n  }\n  throw new StandardSchemaValidationError(message, result.issues);\n}\n\nexport function validateStandardSchemaSync<TSchema extends Schema>(\n  inputSchema: TSchema,\n  value: unknown,\n  message = \"Schema validation failed\",\n): SchemaOutput<TSchema> {\n  const result = inputSchema[\"~standard\"].validate(value);\n  ensureSynchronous(result);\n  if (!result.issues) {\n    return result.value as SchemaOutput<TSchema>;\n  }\n  throw new StandardSchemaValidationError(message, result.issues);\n}\n\nexport function unknown(): Schema<unknown> {\n  return schema((value) => success(value));\n}\n\nexport function string(message = \"Expected a string\"): Schema<unknown, string> {\n  return schema((value) => (typeof value === \"string\" ? success(value) : failure(message)));\n}\n\nexport function number(message = \"Expected a number\"): Schema<unknown, number> {\n  return schema((value) => (typeof value === \"number\" ? success(value) : failure(message)));\n}\n\nexport function boolean(message = \"Expected a boolean\"): Schema<unknown, boolean> {\n  return schema((value) => (typeof value === \"boolean\" ? success(value) : failure(message)));\n}\n\nexport function literal<const TValue extends string | number | boolean | null | undefined>(\n  expected: TValue,\n  message = `Expected ${String(expected)}`,\n): Schema<unknown, TValue> {\n  return schema((value) => (Object.is(value, expected) ? success(expected) : failure(message)));\n}\n\nexport function picklist<const TValues extends readonly [unknown, ...unknown[]]>(\n  values: TValues,\n  message = `Expected one of ${values.map(String).join(\", \")}`,\n): Schema<unknown, TValues[number]> {\n  return schema((value) =>\n    values.some((item) => Object.is(item, value))\n      ? success(value as TValues[number])\n      : failure(message),\n  );\n}\n\nexport function union<const TSchemas extends readonly [Schema, ...Schema[]]>(\n  schemas: TSchemas,\n  message = \"Expected a union match\",\n): Schema<unknown, SchemaOutput<TSchemas[number]>> {\n  return schema((value) => {\n    const issues: SchemaIssue[] = [];\n\n    for (const itemSchema of schemas) {\n      const result:\n        | SchemaResult<SchemaOutput<TSchemas[number]>>\n        | Promise<SchemaResult<SchemaOutput<TSchemas[number]>>> =\n        itemSchema[\"~standard\"].validate(value);\n      ensureSynchronous(result);\n      if (!result.issues) {\n        return success(result.value as SchemaOutput<TSchemas[number]>);\n      }\n      issues.push(...result.issues);\n    }\n\n    return issues.length > 0 ? failure(message) : failure(message);\n  });\n}\n\nexport function array<TItem extends Schema = Schema<unknown>>(\n  itemSchema?: TItem,\n  message = \"Expected an array\",\n): Schema<unknown, SchemaOutput<TItem>[]> {\n  return schema((value) => {\n    if (!Array.isArray(value)) {\n      return failure(message);\n    }\n\n    if (itemSchema === undefined) {\n      return success(value as SchemaOutput<TItem>[]);\n    }\n\n    const output: SchemaOutput<TItem>[] = [];\n    const issues: SchemaIssue[] = [];\n    for (let index = 0; index < value.length; index++) {\n      const result: SchemaResult<SchemaOutput<TItem>> | Promise<SchemaResult<SchemaOutput<TItem>>> =\n        itemSchema[\"~standard\"].validate(value[index]);\n      ensureSynchronous(result);\n      if (result.issues) {\n        issues.push(...result.issues.map((issue: SchemaIssue) => withPath(index, issue)));\n      } else {\n        output.push(result.value as SchemaOutput<TItem>);\n      }\n    }\n\n    return issues.length > 0 ? { issues } : success(output);\n  });\n}\n\nexport function object<TShape extends SchemaShape>(\n  shape: TShape,\n  message = \"Expected an object\",\n): Schema<unknown, ObjectOutput<TShape>> {\n  return schema((value) => {\n    if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n      return failure(message);\n    }\n\n    const input = value as Record<string, unknown>;\n    const output: Partial<ObjectOutput<TShape>> = {};\n    const issues: SchemaIssue[] = [];\n\n    for (const key of Object.keys(shape) as Array<keyof TShape & string>) {\n      const result:\n        | SchemaResult<SchemaOutput<TShape[typeof key]>>\n        | Promise<SchemaResult<SchemaOutput<TShape[typeof key]>>> = shape[key][\n        \"~standard\"\n      ].validate(input[key]);\n      ensureSynchronous(result);\n      if (result.issues) {\n        issues.push(...result.issues.map((issue: SchemaIssue) => withPath(key, issue)));\n      } else {\n        output[key] = result.value as ObjectOutput<TShape>[typeof key];\n      }\n    }\n\n    return issues.length > 0 ? { issues } : success(output as ObjectOutput<TShape>);\n  });\n}\n\nexport function record<TValue extends Schema>(\n  valueSchema: TValue,\n  message = \"Expected an object\",\n): Schema<unknown, Record<string, SchemaOutput<TValue>>> {\n  return schema((value) => {\n    if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n      return failure(message);\n    }\n\n    const output: Record<string, SchemaOutput<TValue>> = {};\n    const issues: SchemaIssue[] = [];\n    for (const [key, item] of Object.entries(value)) {\n      const result:\n        | SchemaResult<SchemaOutput<TValue>>\n        | Promise<SchemaResult<SchemaOutput<TValue>>> = valueSchema[\"~standard\"].validate(item);\n      ensureSynchronous(result);\n      if (result.issues) {\n        issues.push(...result.issues.map((issue: SchemaIssue) => withPath(key, issue)));\n      } else {\n        output[key] = result.value as SchemaOutput<TValue>;\n      }\n    }\n\n    return issues.length > 0 ? { issues } : success(output);\n  });\n}\n\nexport function optional<TSchema extends Schema>(\n  inner: TSchema,\n): Schema<unknown, SchemaOutput<TSchema> | undefined> {\n  return schema((value) => {\n    if (value === undefined) {\n      return success(undefined);\n    }\n\n    const result = inner[\"~standard\"].validate(value);\n    ensureSynchronous(result);\n    return result;\n  });\n}\n\nexport function defaulted<TSchema extends Schema>(\n  inner: TSchema,\n  defaultValue: SchemaOutput<TSchema> | (() => SchemaOutput<TSchema>),\n): Schema<unknown, SchemaOutput<TSchema>> {\n  return schema((value) => {\n    if (value === undefined) {\n      return success(\n        typeof defaultValue === \"function\"\n          ? (defaultValue as () => SchemaOutput<TSchema>)()\n          : defaultValue,\n      );\n    }\n\n    const result = inner[\"~standard\"].validate(value);\n    ensureSynchronous(result);\n    return result;\n  });\n}\n\nfunction ensureSynchronous<T>(value: T | Promise<T>): asserts value is T {\n  if (value instanceof Promise) {\n    throw new Error(\"Async schema validation is not supported\");\n  }\n}\n\nfunction withPath(key: PropertyKey, issue: SchemaIssue): SchemaIssue {\n  return {\n    ...issue,\n    path: [key, ...(issue.path ?? [])],\n  };\n}\n\nexport const ss = {\n  schema,\n  success,\n  failure,\n  StandardSchemaValidationError,\n  validateStandardSchema,\n  validateStandardSchemaSync,\n  unknown,\n  string,\n  number,\n  boolean,\n  literal,\n  picklist,\n  union,\n  array,\n  object,\n  record,\n  optional,\n  defaulted,\n};\n"],"mappings":"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"}
+{"version":3,"file":"mod.mjs","names":[],"sources":["../src/mod.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nimport { isString, isNumber, isBoolean, isFunction, isObject } from \"@temelj/value\";\n\nexport type Schema<TInput = unknown, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;\n\nexport type SchemaInput<TSchema extends Schema> = StandardSchemaV1.InferInput<TSchema>;\n\nexport type SchemaOutput<TSchema extends Schema> = StandardSchemaV1.InferOutput<TSchema>;\n\nexport type SchemaResult<TOutput> = StandardSchemaV1.Result<TOutput>;\n\nexport type SchemaIssue = StandardSchemaV1.Issue;\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Standard Schema validators receive untrusted input before validating it.\nexport type SchemaValidator<TOutput> = (value: unknown) => SchemaResult<TOutput>;\n\nexport type SchemaFields = Record<string, Schema>;\n\nexport type ObjectOutput<TFields extends SchemaFields> = {\n  readonly [TKey in keyof TFields]: SchemaOutput<TFields[TKey]>;\n};\n\nexport type ObjectInput<TFields extends SchemaFields> = {\n  readonly [TKey in keyof TFields]: SchemaInput<TFields[TKey]>;\n};\n\nexport type SafeParseResult<T> =\n  | { readonly success: true; readonly value: T }\n  | { readonly success: false; readonly issues: ReadonlyArray<SchemaIssue> };\n\nexport interface ObjectOptions {\n  readonly unknownKeys?: \"strip\" | \"passthrough\" | \"strict\";\n}\n\ninterface Constructor<T> extends Function {\n  readonly prototype: T;\n  readonly name: string;\n}\n\nexport function schema<TInput, TOutput>(\n  validate: SchemaValidator<TOutput>,\n): Schema<TInput, TOutput> {\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: \"@temelj/standard-schema\",\n      validate,\n    },\n  };\n}\n\nexport function success<T>(value: T): StandardSchemaV1.SuccessResult<T> {\n  return { value };\n}\n\nexport function failure(\n  message: string,\n  path?: ReadonlyArray<PropertyKey>,\n): StandardSchemaV1.FailureResult {\n  return {\n    issues: [\n      {\n        message,\n        path,\n      },\n    ],\n  };\n}\n\nexport class StandardSchemaValidationError extends Error {\n  public readonly issues: ReadonlyArray<SchemaIssue>;\n\n  constructor(message: string, issues: ReadonlyArray<SchemaIssue>, context?: Function) {\n    super(message);\n    this.name = \"StandardSchemaValidationError\";\n    this.issues = issues;\n\n    if (Error.captureStackTrace !== undefined) {\n      Error.captureStackTrace(this, context ?? this.constructor);\n    }\n  }\n\n  static failed(this: void, message: string, issues: ReadonlyArray<SchemaIssue>): never {\n    throw new StandardSchemaValidationError(message, issues, StandardSchemaValidationError.failed);\n  }\n}\n\nexport class StandardSchemaAsyncValidationError extends Error {\n  constructor(message: string, context?: Function) {\n    super(message);\n    this.name = \"StandardSchemaAsyncValidationError\";\n\n    if (Error.captureStackTrace !== undefined) {\n      Error.captureStackTrace(this, context ?? this.constructor);\n    }\n  }\n\n  static unsupported(this: void): never {\n    throw new StandardSchemaAsyncValidationError(\n      \"Async schema validation is not supported\",\n      StandardSchemaAsyncValidationError.unsupported,\n    );\n  }\n}\n\nexport async function validateStandardSchema<TSchema extends Schema>(\n  inputSchema: TSchema,\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Schema validation is the boundary that converts untrusted input to its declared output.\n  value: unknown,\n  message: string = \"Schema validation failed\",\n): Promise<SchemaOutput<TSchema>> {\n  const result = await inputSchema[\"~standard\"].validate(value);\n\n  if (!result.issues) {\n    // SAFETY: this success result was returned by the supplied TSchema validator.\n    return result.value as SchemaOutput<TSchema>;\n  }\n\n  StandardSchemaValidationError.failed(message, result.issues);\n}\n\nexport function validateStandardSchemaSync<TSchema extends Schema>(\n  inputSchema: TSchema,\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Schema validation is the boundary that converts untrusted input to its declared output.\n  value: unknown,\n  message: string = \"Schema validation failed\",\n): SchemaOutput<TSchema> {\n  const result = evaluate(inputSchema, value);\n\n  if (!result.issues) {\n    return result.value;\n  }\n\n  StandardSchemaValidationError.failed(message, result.issues);\n}\n\nexport async function safeParse<TSchema extends Schema>(\n  inputSchema: TSchema,\n  value: SchemaInput<TSchema>,\n): Promise<SafeParseResult<SchemaOutput<TSchema>>> {\n  const result = await inputSchema[\"~standard\"].validate(value);\n\n  // SAFETY: the success value was returned by the supplied TSchema validator.\n  return result.issues\n    ? { success: false, issues: result.issues }\n    : { success: true, value: result.value as SchemaOutput<TSchema> };\n}\n\nexport function safeParseSync<TSchema extends Schema>(\n  inputSchema: TSchema,\n  value: SchemaInput<TSchema>,\n): SafeParseResult<SchemaOutput<TSchema>> {\n  const result = evaluate(inputSchema, value);\n\n  return result.issues\n    ? { success: false, issues: result.issues }\n    : { success: true, value: result.value };\n}\n\nexport async function parse<TSchema extends Schema>(\n  inputSchema: TSchema,\n  value: SchemaInput<TSchema>,\n  message?: string,\n): Promise<SchemaOutput<TSchema>> {\n  return await validateStandardSchema(inputSchema, value, message);\n}\n\nexport function parseSync<TSchema extends Schema>(\n  inputSchema: TSchema,\n  value: SchemaInput<TSchema>,\n  message?: string,\n): SchemaOutput<TSchema> {\n  return validateStandardSchemaSync(inputSchema, value, message);\n}\n\nexport function unknown(): Schema<unknown> {\n  return schema((value) => success(value));\n}\n\nexport function string(message: string = \"Expected a string\"): Schema<unknown, string> {\n  return schema((value) => (isString(value) ? success(value) : failure(message)));\n}\n\nexport function number(message: string = \"Expected a number\"): Schema<unknown, number> {\n  return schema((value) => (isNumber(value) ? success(value) : failure(message)));\n}\n\nexport function finite(message: string = \"Expected a finite number\"): Schema<unknown, number> {\n  return refine(number(), Number.isFinite, message);\n}\n\nexport function integer(message: string = \"Expected an integer\"): Schema<unknown, number> {\n  return refine(number(), Number.isInteger, message);\n}\n\nexport function safeInteger(message: string = \"Expected a safe integer\"): Schema<unknown, number> {\n  return refine(number(), Number.isSafeInteger, message);\n}\n\nexport function positiveNumber(\n  message: string = \"Expected a positive number\",\n): Schema<unknown, number> {\n  return refine(number(), (value) => Number.isFinite(value) && value > 0, message);\n}\n\nexport function nonNegativeNumber(\n  message: string = \"Expected a non-negative number\",\n): Schema<unknown, number> {\n  return refine(number(), (value) => Number.isFinite(value) && value >= 0, message);\n}\n\nexport function positiveSafeInteger(\n  message: string = \"Expected a positive safe integer\",\n): Schema<unknown, number> {\n  return refine(number(), (value) => Number.isSafeInteger(value) && value > 0, message);\n}\n\nexport function nonNegativeSafeInteger(\n  message: string = \"Expected a non-negative safe integer\",\n): Schema<unknown, number> {\n  return refine(number(), (value) => Number.isSafeInteger(value) && value >= 0, message);\n}\n\nexport function min(\n  inner: Schema<unknown, number>,\n  minimum: number,\n  message: string = `Expected a number greater than or equal to ${minimum}`,\n): Schema<unknown, number> {\n  return refine(inner, (value) => value >= minimum, message);\n}\n\nexport function max(\n  inner: Schema<unknown, number>,\n  maximum: number,\n  message: string = `Expected a number less than or equal to ${maximum}`,\n): Schema<unknown, number> {\n  return refine(inner, (value) => value <= maximum, message);\n}\n\nexport function nonEmptyString(\n  message: string = \"Expected a non-empty string\",\n): Schema<unknown, string> {\n  return refine(string(), (value) => value.length > 0, message);\n}\n\nexport function nonBlankString(\n  message: string = \"Expected a non-blank string\",\n): Schema<unknown, string> {\n  return refine(string(), (value) => value.trim().length > 0, message);\n}\n\nexport function boolean(message: string = \"Expected a boolean\"): Schema<unknown, boolean> {\n  return schema((value) => (isBoolean(value) ? success(value) : failure(message)));\n}\n\nexport function fn(message: string = \"Expected a function\"): Schema<unknown, Function> {\n  return schema((value) => (isFunction(value) ? success(value) : failure(message)));\n}\n\nexport function instanceOf<T>(\n  constructor: Constructor<T>,\n  message: string = `Expected ${constructor.name}`,\n): Schema<unknown, T> {\n  return schema((value) => (value instanceof constructor ? success(value) : failure(message)));\n}\n\nexport function literal<const TValue extends string | number | boolean | null | undefined>(\n  expected: TValue,\n  message: string = `Expected ${String(expected)}`,\n): Schema<unknown, TValue> {\n  return schema((value) => (Object.is(value, expected) ? success(expected) : failure(message)));\n}\n\nexport function picklist<const TValues extends readonly [unknown, ...unknown[]]>(\n  values: TValues,\n  message: string = `Expected one of ${values.map(String).join(\", \")}`,\n): Schema<unknown, TValues[number]> {\n  return schema((value) => {\n    const match = values.findIndex((item) => Object.is(item, value));\n\n    return match === -1 ? failure(message) : success(values[match]);\n  });\n}\n\nexport function union<const TSchemas extends readonly [Schema, ...Schema[]]>(\n  schemas: TSchemas,\n  message: string = \"Expected a union match\",\n): Schema<unknown, SchemaOutput<TSchemas[number]>> {\n  return schema((value) => {\n    for (const itemSchema of schemas) {\n      const result = evaluate<TSchemas[number]>(itemSchema, value);\n\n      if (!result.issues) {\n        return success(result.value);\n      }\n    }\n\n    return failure(message);\n  });\n}\n\nexport function array(): Schema<unknown, unknown[]>;\nexport function array<TItem extends Schema>(\n  itemSchema: TItem,\n  message?: string,\n): Schema<unknown, SchemaOutput<TItem>[]>;\nexport function array<TItem extends Schema>(\n  itemSchema?: TItem,\n  message: string = \"Expected an array\",\n): Schema<unknown, unknown[]> {\n  return schema((value) => {\n    if (!Array.isArray(value)) {\n      return failure(message);\n    }\n\n    if (itemSchema === undefined) {\n      return success(value);\n    }\n\n    const output: SchemaOutput<TItem>[] = [];\n    const issues: SchemaIssue[] = [];\n\n    for (let index = 0; index < value.length; index++) {\n      const result: SchemaResult<SchemaOutput<TItem>> = evaluate(itemSchema, value[index]);\n\n      if (result.issues) {\n        issues.push(...result.issues.map((issue: SchemaIssue) => withPath(index, issue)));\n      } else {\n        output.push(result.value);\n      }\n    }\n\n    return issues.length > 0 ? { issues } : success(output);\n  });\n}\n\nexport function object<TFields extends SchemaFields>(\n  fields: TFields,\n  message: string = \"Expected an object\",\n  options: ObjectOptions = {},\n): Schema<unknown, ObjectOutput<TFields>> {\n  return schema((value) => {\n    if (!isObject(value) || Array.isArray(value)) {\n      return failure(message);\n    }\n\n    // SAFETY: the object check above establishes key lookup; each field remains unknown until its schema validates it.\n    // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Temporary untrusted object at the schema parsing boundary.\n    const input = value as Record<PropertyKey, unknown>;\n\n    const output: Partial<{ -readonly [K in keyof TFields]: SchemaOutput<TFields[K]> }> = {};\n\n    if (options.unknownKeys === \"passthrough\") {\n      for (const key of Reflect.ownKeys(input)) {\n        if (!Object.prototype.propertyIsEnumerable.call(input, key)) {\n          continue;\n        }\n\n        Object.defineProperty(output, key, {\n          value: input[key],\n          enumerable: true,\n          writable: true,\n          configurable: true,\n        });\n      }\n    }\n\n    const issues: SchemaIssue[] = [];\n    const fieldKeys = Object.keys(fields);\n\n    if (options.unknownKeys === \"strict\") {\n      for (const key of Object.keys(input)) {\n        if (!fieldKeys.includes(key)) {\n          issues.push({ message: \"Unexpected key\", path: [key] });\n        }\n      }\n    }\n\n    // SAFETY: these are the enumerable keys of the supplied field schema object.\n    for (const key of fieldKeys as Array<keyof TFields & string>) {\n      const hasOwnField = Object.prototype.hasOwnProperty.call(input, key);\n      const result = evaluate(fields[key], hasOwnField ? input[key] : undefined);\n\n      if (result.issues) {\n        issues.push(...result.issues.map((issue: SchemaIssue) => withPath(key, issue)));\n      } else if (hasOwnField || result.value !== undefined) {\n        Object.defineProperty(output, key, {\n          value: result.value,\n          enumerable: true,\n          writable: true,\n          configurable: true,\n        });\n      }\n    }\n\n    // SAFETY: all schema fields have succeeded; absent optional fields are represented by undefined in ObjectOutput.\n    return issues.length > 0 ? { issues } : success(output as ObjectOutput<TFields>);\n  });\n}\n\nexport function strictObject<TFields extends SchemaFields>(\n  fields: TFields,\n  message: string = \"Expected an object\",\n): Schema<unknown, ObjectOutput<TFields>> {\n  return object(fields, message, { unknownKeys: \"strict\" });\n}\n\nexport function looseObject<TFields extends SchemaFields>(\n  fields: TFields,\n  message: string = \"Expected an object\",\n): Schema<unknown, ObjectOutput<TFields>> {\n  return object(fields, message, { unknownKeys: \"passthrough\" });\n}\n\nexport function record<TValue extends Schema>(\n  valueSchema: TValue,\n  message: string = \"Expected an object\",\n): Schema<unknown, Record<string, SchemaOutput<TValue>>> {\n  return schema((value) => {\n    if (!isObject(value) || Array.isArray(value)) {\n      return failure(message);\n    }\n\n    const output: Record<string, SchemaOutput<TValue>> = {};\n    const issues: SchemaIssue[] = [];\n\n    for (const [key, item] of Object.entries(value)) {\n      const result = evaluate(valueSchema, item);\n\n      if (result.issues) {\n        issues.push(...result.issues.map((issue: SchemaIssue) => withPath(key, issue)));\n      } else {\n        output[key] = result.value;\n      }\n    }\n\n    return issues.length > 0 ? { issues } : success(output);\n  });\n}\n\nexport function optional<TSchema extends Schema>(\n  inner: TSchema,\n): Schema<unknown, SchemaOutput<TSchema> | undefined> {\n  return schema((value) => {\n    if (value === undefined) {\n      return success(undefined);\n    }\n\n    const result = evaluate(inner, value);\n\n    return result;\n  });\n}\n\nexport function defaulted<TSchema extends Schema>(\n  inner: TSchema,\n  defaultValue: SchemaOutput<TSchema>,\n): Schema<unknown, SchemaOutput<TSchema>> {\n  return schema((value) => {\n    if (value === undefined) {\n      return success(defaultValue);\n    }\n\n    const result = evaluate(inner, value);\n\n    return result;\n  });\n}\n\nexport function defaultedWith<TSchema extends Schema>(\n  inner: TSchema,\n  createDefault: () => SchemaOutput<TSchema>,\n): Schema<unknown, SchemaOutput<TSchema>> {\n  return schema((value) =>\n    value === undefined ? success(createDefault()) : evaluate(inner, value),\n  );\n}\n\nexport function refine<TSchema extends Schema, TOutput extends SchemaOutput<TSchema>>(\n  inner: TSchema,\n  predicate: (value: SchemaOutput<TSchema>) => value is TOutput,\n  message?: string,\n): Schema<SchemaInput<TSchema>, TOutput>;\nexport function refine<TSchema extends Schema>(\n  inner: TSchema,\n  predicate: (value: SchemaOutput<TSchema>) => boolean,\n  message?: string,\n): Schema<SchemaInput<TSchema>, SchemaOutput<TSchema>>;\nexport function refine<TSchema extends Schema>(\n  inner: TSchema,\n  predicate: (value: SchemaOutput<TSchema>) => boolean,\n  message: string = \"Invalid value\",\n): Schema<SchemaInput<TSchema>, SchemaOutput<TSchema>> {\n  return schema((value) => {\n    const result = evaluate(inner, value);\n\n    if (result.issues) {\n      return result;\n    }\n\n    return predicate(result.value) ? result : failure(message);\n  });\n}\n\nexport function transform<TSchema extends Schema, TOutput>(\n  inner: TSchema,\n  mapper: (value: SchemaOutput<TSchema>) => TOutput,\n): Schema<SchemaInput<TSchema>, TOutput> {\n  return schema((value) => {\n    const result = evaluate(inner, value);\n\n    if (result.issues) {\n      return result;\n    }\n\n    return success(mapper(result.value));\n  });\n}\n\nexport function pipe<TLeft extends Schema, TRight extends Schema>(\n  left: TLeft,\n  right: TRight,\n): Schema<SchemaInput<TLeft>, SchemaOutput<TRight>> {\n  return schema((value) => {\n    const leftResult = evaluate(left, value);\n\n    if (leftResult.issues) {\n      return leftResult;\n    }\n\n    const rightResult = evaluate(right, leftResult.value);\n\n    return rightResult;\n  });\n}\n\nexport function extend<TBase extends SchemaFields, TExtension extends SchemaFields>(\n  base: TBase,\n  extension: TExtension,\n): Omit<TBase, keyof TExtension> & TExtension {\n  return { ...base, ...extension };\n}\n\nexport function pick<TFields extends SchemaFields, const TKeys extends readonly (keyof TFields)[]>(\n  fields: TFields,\n  keys: TKeys,\n): Pick<TFields, TKeys[number]> {\n  // SAFETY: each requested key is constrained to TFields and is copied with its corresponding schema.\n  return Object.fromEntries(keys.map((key) => [key, fields[key]])) as Pick<TFields, TKeys[number]>;\n}\n\nexport function omit<TFields extends SchemaFields, const TKeys extends readonly (keyof TFields)[]>(\n  fields: TFields,\n  keys: TKeys,\n): Omit<TFields, TKeys[number]> {\n  const result = { ...fields };\n\n  for (const key of keys) {\n    delete result[key];\n  }\n\n  return result;\n}\n\nexport function partial<TFields extends SchemaFields>(\n  fields: TFields,\n): { readonly [TKey in keyof TFields]: Schema<unknown, SchemaOutput<TFields[TKey]> | undefined> } {\n  const entries = Reflect.ownKeys(fields).map((key) => {\n    // SAFETY: key is an own key of the supplied field schema object.\n    return [key, optional(fields[key as keyof TFields])];\n  });\n\n  // SAFETY: each own field is preserved under its key and optional retains its output type while adding undefined.\n  return Object.fromEntries(entries) as {\n    readonly [TKey in keyof TFields]: Schema<unknown, SchemaOutput<TFields[TKey]> | undefined>;\n  };\n}\n\nfunction evaluate<TSchema extends Schema>(\n  inputSchema: TSchema,\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- This helper invokes the schema validator on untrusted input.\n  value: unknown,\n): SchemaResult<SchemaOutput<TSchema>> {\n  const result = inputSchema[\"~standard\"].validate(value);\n  ensureSynchronous(result);\n\n  // SAFETY: StandardSchemaV1 ties the validator success type to TSchema's declared output.\n  return result as SchemaResult<SchemaOutput<TSchema>>;\n}\n\nfunction ensureSynchronous<T>(value: T | Promise<T>): asserts value is T {\n  if (value instanceof Promise) {\n    StandardSchemaAsyncValidationError.unsupported();\n  }\n}\n\nfunction withPath(key: PropertyKey, issue: SchemaIssue): SchemaIssue {\n  return {\n    ...issue,\n    path: [key, ...(issue.path ?? [])],\n  };\n}\n\nexport const ss = {\n  schema,\n  success,\n  failure,\n  StandardSchemaValidationError,\n  validateStandardSchema,\n  validateStandardSchemaSync,\n  safeParse,\n  safeParseSync,\n  parse,\n  parseSync,\n  unknown,\n  string,\n  number,\n  finite,\n  integer,\n  safeInteger,\n  positiveNumber,\n  nonNegativeNumber,\n  positiveSafeInteger,\n  nonNegativeSafeInteger,\n  min,\n  max,\n  nonEmptyString,\n  nonBlankString,\n  boolean,\n  fn,\n  instanceOf,\n  literal,\n  picklist,\n  union,\n  array,\n  object,\n  strictObject,\n  looseObject,\n  record,\n  optional,\n  defaulted,\n  defaultedWith,\n  refine,\n  transform,\n  pipe,\n  extend,\n  pick,\n  omit,\n  partial,\n};\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temelj/standard-schema",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Standard Schema construction utilities.",
   "license": "MIT",
   "repository": {
@@ -19,14 +19,15 @@
     }
   },
   "dependencies": {
-    "@standard-schema/spec": "^1.1.0"
+    "@standard-schema/spec": "^1.1.0",
+    "@temelj/value": "0.15.0"
   },
   "devDependencies": {
-    "@types/node": "25.9.2",
+    "@types/node": "26.6.5",
     "shx": "^0.4.0",
-    "tsdown": "^0.22.2",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
   },
   "scripts": {
     "build": "tsdown",