zeed 1.3.0 → 1.4.0

package/dist/common/schema/schema.mjs

@@ -1,2 +1,405 @@
-import{isArray as e,isBoolean as t,isFunction as n,isInteger as r,isNumber as i,isObject as a,isString as o}from"../data/is.mjs";var s=class e{type;_default;_optional;_meta;_check;_object;_type;_union;_enumValues;_args;_ret;_info;constructor(e,t={}){this.type=e,Object.assign(this,t)}get"~standard"(){return{version:1,vendor:`zeed`,validate:e=>this.validate(e),types:{input:void 0,output:void 0}}}validate(e){if(e==null)return this._optional?{value:void 0}:this._default===void 0?{issues:[{message:`Required value is missing`,path:[]}]}:{value:n(this._default)?this._default(this):this._default};if(this.type===`literal`&&this._default!==e)return{issues:[{message:`Expected literal value ${this._default}, got ${e}`,path:[]}]};if(this._enumValues&&Array.isArray(this._enumValues)&&!this._enumValues.includes(e))return{issues:[{message:`Expected one of [${this._enumValues.join(`, `)}], got ${e}`,path:[]}]};if(this._union&&Array.isArray(this._union)){for(let t of this._union){let n=t.validate(e);if(!n.issues)return n}return{issues:[{message:`Value does not match any union variant`,path:[]}]}}if(this.type===`array`||this.type===`tuple`){if(!Array.isArray(e))return{issues:[{message:`Expected array, got ${typeof e}`,path:[]}]};if(this.type===`tuple`&&this._type){let t=this._type;if(e.length!==t.length)return{issues:[{message:`Expected tuple of length ${t.length}, got ${e.length}`,path:[]}]};let n=[];for(let r=0;r<t.length;r++){let i=t[r].validate(e[r]);if(i.issues)for(let e of i.issues)n.push({message:e.message,path:[r,...e.path||[]]})}if(n.length>0)return{issues:n}}else if(this._type){let t=this._type,n=[];for(let r=0;r<e.length;r++){let i=t.validate(e[r]);if(i.issues)for(let e of i.issues)n.push({message:e.message,path:[r,...e.path||[]]})}if(n.length>0)return{issues:n}}}if(this._object){if(!a(e))return{issues:[{message:`Expected object, got ${typeof e}`,path:[]}]};let t=[],n=e;for(let e in this._object){let r=this._object[e],i=n[e],a=r.validate(i);if(a.issues)for(let n of a.issues)t.push({message:n.message,path:[e,...n.path||[]]})}return t.length>0?{issues:t}:{value:e,issues:void 0}}if(this.type===`record`&&this._type){if(!a(e))return{issues:[{message:`Expected object, got ${typeof e}`,path:[]}]};let t=this._type,n=[],r=e;for(let e in r){let i=t.validate(r[e]);if(i.issues)for(let t of i.issues)n.push({message:t.message,path:[e,...t.path||[]]})}if(n.length>0)return{issues:n}}return this._check&&!this._check(e)?{issues:[{message:`Expected ${this.type}, got ${typeof e}`,path:[]}]}:{value:e}}_cloneWithProps(t={}){let n=new e(this.type);for(let e of[`_default`,`_optional`,`_meta`,`_check`,`_object`,`_type`,`_union`,`_enumValues`,`_args`,`_ret`,`_info`])this[e]!==void 0&&(n[e]=this[e]);return Object.assign(n,t),n}static _copyTypeProperties(e,t){for(let n of[`_check`,`_default`,`_meta`,`_object`,`_type`,`_enumValues`])e[n]!==void 0&&(t[n]=e[n])}optional(){return this._cloneWithProps({_optional:!0})}default(e){return this._cloneWithProps({_default:e})}meta(e){return this._cloneWithProps({_meta:e})}describe(e){let t=this._meta||{};return t.desc=e,this._cloneWithProps({_meta:t})}extend(e){if(!this._object)throw Error(`extend() can only be used on object schemas`);return _({...this._object,...e})}pick(e){if(!this._object)throw Error(`pick() can only be used on object schemas`);let t={};for(let n of Object.keys(e))n in this._object&&(t[n]=this._object[n]);return _(t)}omit(e){if(!this._object)throw Error(`omit() can only be used on object schemas`);let t={...this._object};for(let n of Object.keys(e))delete t[n];return _(t)}_transformObjectProperties(e,t){if(!this._object)throw Error(`This operation can only be used on object schemas`);let n={},r=this._object;for(let[i,a]of Object.entries(r))n[i]=e(i,a,!t||i in t);return _(n)}partial(t){if(!this._object)throw Error(`partial() can only be used on object schemas`);return this._transformObjectProperties((t,n,r)=>r?e._cloneTypeWithOptional(n,!0):n,t)}required(t){if(!this._object)throw Error(`required() can only be used on object schemas`);return this._transformObjectProperties((t,n,r)=>r?e._cloneTypeWithOptional(n,!1):n,t)}static _cloneTypeWithOptional(t,n){let r=new e(t.type);return e._copyTypeProperties(t,r),r._optional=n,r}};function c(){return new s(`string`,{_check:o})}function l(){return new s(`number`,{_check:i})}function u(){return new s(`int`,{_check:r})}function d(){return new s(`boolean`,{_check:t})}function f(){return new s(`none`,{_check:e=>e==null,_optional:!0})}function p(){return new s(`any`,{_check:e=>e!=null})}const m=l,h=l,g=l;function _(e){return new s(`object`,{_check:a,_object:e})}function v(e){return new s(`record`,{_check:a,_type:e})}function y(e){return new s(`union`,{_check:t=>e.some(e=>e._check?.(t)??!1),_union:e})}function b(e){return new s(`literal`,{_check:t=>t===e,_default:e})}function x(e){return new s(`string`,{_check:t=>typeof t==`string`&&e.includes(t),_enumValues:e})}function S(e){return new s(`tuple`,{_check:t=>Array.isArray(t)&&t.length===e.length&&e.every((e,n)=>e._check?.(t[n])??!1),_type:e})}function C(t){return new s(`array`,{_check:e,_type:t})}function w(e,t){return new s(`function`,{_check:n,_args:e,_ret:t})}function T(e,t){return new s(`rpc`,{_check:n,_info:e,_ret:t??f()})}export{s as Type,p as any,C as array,d as boolean,h as double,m as float,w as func,u as int,b as literal,f as none,l as number,_ as object,g as real,v as record,T as rpc,c as string,x as stringLiterals,S as tuple,y as union};
+import { isArray, isBoolean, isFunction, isInteger, isNumber, isObject, isString } from "../data/is.mjs";
+
+//#region src/common/schema/schema.ts
+/**
+* Core Type class for schema validation and type inference
+* Implements StandardSchemaV1 for cross-library compatibility
+*/
+var Type = class Type {
+	type;
+	_default;
+	_optional;
+	_meta;
+	_check;
+	_object;
+	_type;
+	_union;
+	_enumValues;
+	_args;
+	_ret;
+	_info;
+	constructor(name, options = {}) {
+		this.type = name;
+		Object.assign(this, options);
+	}
+	/**
+	* Standard Schema V1 compliance property
+	* Provides a standard interface for validation and type inference
+	*/
+	get "~standard"() {
+		return {
+			version: 1,
+			vendor: "zeed",
+			validate: (value) => {
+				return this.validate(value);
+			},
+			types: {
+				input: void 0,
+				output: void 0
+			}
+		};
+	}
+	/**
+	* Validation method for standard-schema compliance
+	*/
+	validate(value) {
+		if (value == null) {
+			if (this._optional) return { value: void 0 };
+			if (this._default !== void 0) return { value: isFunction(this._default) ? this._default(this) : this._default };
+			return { issues: [{
+				message: `Required value is missing`,
+				path: []
+			}] };
+		}
+		if (this.type === "literal" && this._default !== value) return { issues: [{
+			message: `Expected literal value ${this._default}, got ${value}`,
+			path: []
+		}] };
+		if (this._enumValues && Array.isArray(this._enumValues)) {
+			if (!this._enumValues.includes(value)) return { issues: [{
+				message: `Expected one of [${this._enumValues.join(", ")}], got ${value}`,
+				path: []
+			}] };
+		}
+		if (this._union && Array.isArray(this._union)) {
+			for (const option of this._union) {
+				const result = option.validate(value);
+				if (!result.issues) return result;
+			}
+			return { issues: [{
+				message: `Value does not match any union variant`,
+				path: []
+			}] };
+		}
+		if (this.type === "array" || this.type === "tuple") {
+			if (!Array.isArray(value)) return { issues: [{
+				message: `Expected array, got ${typeof value}`,
+				path: []
+			}] };
+			if (this.type === "tuple" && this._type) {
+				const items = this._type;
+				if (value.length !== items.length) return { issues: [{
+					message: `Expected tuple of length ${items.length}, got ${value.length}`,
+					path: []
+				}] };
+				const issues = [];
+				for (let i = 0; i < items.length; i++) {
+					const itemResult = items[i].validate(value[i]);
+					if (itemResult.issues) for (const issue of itemResult.issues) issues.push({
+						message: issue.message,
+						path: [i, ...issue.path || []]
+					});
+				}
+				if (issues.length > 0) return { issues };
+			} else if (this._type) {
+				const itemType = this._type;
+				const issues = [];
+				for (let i = 0; i < value.length; i++) {
+					const itemResult = itemType.validate(value[i]);
+					if (itemResult.issues) for (const issue of itemResult.issues) issues.push({
+						message: issue.message,
+						path: [i, ...issue.path || []]
+					});
+				}
+				if (issues.length > 0) return { issues };
+			}
+		}
+		if (this._object) {
+			if (!isObject(value)) return { issues: [{
+				message: `Expected object, got ${typeof value}`,
+				path: []
+			}] };
+			const issues = [];
+			const obj = value;
+			for (const key in this._object) {
+				const propSchema = this._object[key];
+				const propValue = obj[key];
+				const propResult = propSchema.validate(propValue);
+				if (propResult.issues) for (const issue of propResult.issues) issues.push({
+					message: issue.message,
+					path: [key, ...issue.path || []]
+				});
+			}
+			if (issues.length > 0) return { issues };
+			return {
+				value,
+				issues: void 0
+			};
+		}
+		if (this.type === "record" && this._type) {
+			if (!isObject(value)) return { issues: [{
+				message: `Expected object, got ${typeof value}`,
+				path: []
+			}] };
+			const valueType = this._type;
+			const issues = [];
+			const obj = value;
+			for (const key in obj) {
+				const propResult = valueType.validate(obj[key]);
+				if (propResult.issues) for (const issue of propResult.issues) issues.push({
+					message: issue.message,
+					path: [key, ...issue.path || []]
+				});
+			}
+			if (issues.length > 0) return { issues };
+		}
+		if (this._check && !this._check(value)) return { issues: [{
+			message: `Expected ${this.type}, got ${typeof value}`,
+			path: []
+		}] };
+		return { value };
+	}
+	/**
+	* Creates a copy of the type with new properties merged
+	*/
+	_cloneWithProps(newProps = {}) {
+		const cloned = new Type(this.type);
+		for (const prop of [
+			"_default",
+			"_optional",
+			"_meta",
+			"_check",
+			"_object",
+			"_type",
+			"_union",
+			"_enumValues",
+			"_args",
+			"_ret",
+			"_info"
+		]) if (this[prop] !== void 0) cloned[prop] = this[prop];
+		Object.assign(cloned, newProps);
+		return cloned;
+	}
+	/**
+	* Helper to copy type properties when creating new type instances
+	*/
+	static _copyTypeProperties(source, target) {
+		for (const prop of [
+			"_check",
+			"_default",
+			"_meta",
+			"_object",
+			"_type",
+			"_enumValues"
+		]) if (source[prop] !== void 0) target[prop] = source[prop];
+	}
+	/**
+	* Marks the type as optional, meaning it can be undefined
+	* This is useful for properties that are not required.
+	*/
+	optional() {
+		return this._cloneWithProps({ _optional: true });
+	}
+	/**
+	* Sets a default value for the type, which will be used if the value is not provided
+	* The default value can be a function that receives the schema as argument, or a static value.
+	*/
+	default(value) {
+		return this._cloneWithProps({ _default: value });
+	}
+	/**
+	* Props / Metadata for the type, like description or other properties
+	*/
+	meta(meta) {
+		return this._cloneWithProps({ _meta: meta });
+	}
+	/**
+	* Sets the `desc` property for the type, which is a human-readable description
+	*/
+	describe(msg) {
+		const meta = this._meta || {};
+		meta.desc = msg;
+		return this._cloneWithProps({ _meta: meta });
+	}
+	/**
+	* Extends the type with an object, merging the properties
+	*/
+	extend(obj) {
+		if (!this._object) throw new Error("extend() can only be used on object schemas");
+		return object({
+			...this._object,
+			...obj
+		});
+	}
+	/**
+	* Picks certain keys from an object schema
+	*/
+	pick(keys) {
+		if (!this._object) throw new Error("pick() can only be used on object schemas");
+		const pickedObj = {};
+		for (const key of Object.keys(keys)) if (key in this._object) pickedObj[key] = this._object[key];
+		return object(pickedObj);
+	}
+	/**
+	* Omits certain keys from an object schema
+	*/
+	omit(keys) {
+		if (!this._object) throw new Error("omit() can only be used on object schemas");
+		const omittedObj = { ...this._object };
+		for (const key of Object.keys(keys)) delete omittedObj[key];
+		return object(omittedObj);
+	}
+	/**
+	* Helper method to modify object properties with a transformation function
+	*/
+	_transformObjectProperties(transform, keys) {
+		if (!this._object) throw new Error("This operation can only be used on object schemas");
+		const transformedObj = {};
+		const originalObj = this._object;
+		for (const [key, typeInstance] of Object.entries(originalObj)) transformedObj[key] = transform(key, typeInstance, !keys || key in keys);
+		return object(transformedObj);
+	}
+	partial(keys) {
+		if (!this._object) throw new Error("partial() can only be used on object schemas");
+		return this._transformObjectProperties((key, type, shouldTransform) => {
+			if (!shouldTransform) return type;
+			return Type._cloneTypeWithOptional(type, true);
+		}, keys);
+	}
+	required(keys) {
+		if (!this._object) throw new Error("required() can only be used on object schemas");
+		return this._transformObjectProperties((key, type, shouldTransform) => {
+			if (!shouldTransform) return type;
+			return Type._cloneTypeWithOptional(type, false);
+		}, keys);
+	}
+	/**
+	* Helper method to clone a type with optional flag
+	*/
+	static _cloneTypeWithOptional(originalType, optional) {
+		const newType = new Type(originalType.type);
+		Type._copyTypeProperties(originalType, newType);
+		newType._optional = optional;
+		return newType;
+	}
+};
+/**
+* Creates a string type validator
+*/
+function string() {
+	return new Type("string", { _check: isString });
+}
+/**
+* Creates a number type validator
+*/
+function number() {
+	return new Type("number", { _check: isNumber });
+}
+/**
+* Creates an integer type validator
+*/
+function int() {
+	return new Type("int", { _check: isInteger });
+}
+/**
+* Creates a boolean type validator
+*/
+function boolean() {
+	return new Type("boolean", { _check: isBoolean });
+}
+/**
+* Creates a none type validator (undefined | null)
+* Like undefined | null in TS and nil in Swift
+*/
+function none() {
+	return new Type("none", {
+		_check: (v) => v == null,
+		_optional: true
+	});
+}
+/**
+* Creates an any type validator that accepts any non-null value
+*/
+function any() {
+	return new Type("any", { _check: (v) => v != null });
+}
+const float = number;
+const double = number;
+const real = number;
+/**
+* Creates an object type validator with specified properties
+*/
+function object(tobj) {
+	return new Type("object", {
+		_check: isObject,
+		_object: tobj
+	});
+}
+/**
+* Creates a record type validator (object with string keys and uniform value type)
+*/
+function record(valueType) {
+	return new Type("record", {
+		_check: isObject,
+		_type: valueType
+	});
+}
+/**
+* Creates a union type validator (like `string | number | boolean`)
+*/
+function union(options) {
+	return new Type("union", {
+		_check: (v) => options.some((option) => option._check?.(v) ?? false),
+		_union: options
+	});
+}
+/**
+* Creates a literal value validator
+*/
+function literal(value) {
+	return new Type("literal", {
+		_check: (v) => v === value,
+		_default: value
+	});
+}
+/**
+* Creates a string literal union validator (like `"a" | "b" | "c"`)
+*/
+function stringLiterals(values) {
+	return new Type("string", {
+		_check: (v) => typeof v === "string" && values.includes(v),
+		_enumValues: values
+	});
+}
+/**
+* Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]
+*/
+function tuple(items) {
+	return new Type("tuple", {
+		_check: (v) => Array.isArray(v) && v.length === items.length && items.every((item, i) => item._check?.(v[i]) ?? false),
+		_type: items
+	});
+}
+/**
+* Creates an array type validator for a specific item type
+*/
+function array(itemType) {
+	return new Type("array", {
+		_check: isArray,
+		_type: itemType
+	});
+}
+/**
+* Creates a regular function type validator
+*/
+function func(args, ret) {
+	return new Type("function", {
+		_check: isFunction,
+		_args: args,
+		_ret: ret
+	});
+}
+/**
+* Creates an RPC function type validator that takes one argument and returns a promise
+*/
+function rpc(info, ret) {
+	return new Type("rpc", {
+		_check: isFunction,
+		_info: info,
+		_ret: ret ?? none()
+	});
+}
+
+//#endregion
+export { Type, any, array, boolean, double, float, func, int, literal, none, number, object, real, record, rpc, string, stringLiterals, tuple, union };
 //# sourceMappingURL=schema.mjs.map

package/dist/common/schema/schema.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/common/schema/schema.ts"],"sourcesContent":["// With many, many inspiration from https://github.com/badrap/valita MIT License as of 2024-09-10\n\nimport type { StandardSchemaV1 } from './schema-standard'\nimport { isArray, isBoolean, isFunction, isInteger, isNumber, isObject, isString } from '../data/is'\n\n/**\n * Metadata interface for type descriptions and additional properties\n */\nexport interface TypeMeta {\n  desc?: string\n}\n\n/**\n * Core Type class for schema validation and type inference\n * Implements StandardSchemaV1 for cross-library compatibility\n */\nexport class Type<T = unknown> {\n  readonly type: string\n\n  _default?: any\n  _optional?: boolean\n  _meta?: TypeMeta\n  _check?: (obj: any) => boolean\n  _object?: any\n  _type?: any\n  _union?: any\n  _enumValues?: any\n  _args?: any\n  _ret?: any\n  _info?: any\n\n  // [key: `_${string}`]: any // Allow only optional dynamic properties starting with an underscore\n\n  constructor(name: string, options: Partial<Type<T>> = {}) {\n    this.type = name\n    Object.assign(this, options)\n  }\n\n  /**\n   * Standard Schema V1 compliance property\n   * Provides a standard interface for validation and type inference\n   */\n  get '~standard'(): any {\n    return {\n      version: 1,\n      vendor: 'zeed',\n      validate: (value: unknown): StandardSchemaV1.Result<T> => {\n        return this.validate(value)\n      },\n      types: {\n        input: undefined as any as T,\n        output: undefined as any as T,\n      },\n    }\n  }\n\n  /**\n   * Validation method for standard-schema compliance\n   */\n  validate(value: any): any {\n    // const messages: Array<{ path: string, message: string, type: string, valid: boolean }> = []\n\n    // Handle null/undefined cases\n    if (value == null) {\n      if (this._optional) {\n        return { value: undefined as any as T }\n      }\n      if (this._default !== undefined) {\n        const defaultValue = isFunction(this._default) ? this._default(this) : this._default\n        return { value: defaultValue }\n      }\n      return {\n        issues: [{\n          message: `Required value is missing`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle literal types\n    if (this.type === 'literal' && this._default !== value) {\n      return {\n        issues: [{\n          message: `Expected literal value ${this._default}, got ${value}`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle string literals (enums)\n    if (this._enumValues && Array.isArray(this._enumValues)) {\n      if (!this._enumValues.includes(value)) {\n        return {\n          issues: [{\n            message: `Expected one of [${this._enumValues.join(', ')}], got ${value}`,\n            path: [],\n          }],\n        }\n      }\n    }\n\n    // Handle union types\n    if (this._union && Array.isArray(this._union)) {\n      for (const option of this._union) {\n        const result = (option as Type<any>).validate(value)\n        if (!result.issues) {\n          return result\n        }\n      }\n      return {\n        issues: [{\n          message: `Value does not match any union variant`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle array types\n    if (this.type === 'array' || this.type === 'tuple') {\n      if (!Array.isArray(value)) {\n        return {\n          issues: [{\n            message: `Expected array, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      if (this.type === 'tuple' && this._type) {\n        const items = this._type as Type<any>[]\n        if (value.length !== items.length) {\n          return {\n            issues: [{\n              message: `Expected tuple of length ${items.length}, got ${value.length}`,\n              path: [],\n            }],\n          }\n        }\n\n        const issues: StandardSchemaV1.Issue[] = []\n        for (let i = 0; i < items.length; i++) {\n          const itemResult = items[i].validate(value[i])\n          if (itemResult.issues) {\n            for (const issue of itemResult.issues) {\n              issues.push({\n                message: issue.message,\n                path: [i, ...(issue.path || [])],\n              })\n            }\n          }\n        }\n\n        if (issues.length > 0) {\n          return { issues }\n        }\n      }\n      else if (this._type) {\n        // Regular array with item type\n        const itemType = this._type as Type<any>\n        const issues: StandardSchemaV1.Issue[] = []\n\n        for (let i = 0; i < value.length; i++) {\n          const itemResult = itemType.validate(value[i])\n          if (itemResult.issues) {\n            for (const issue of itemResult.issues) {\n              issues.push({\n                message: issue.message,\n                path: [i, ...(issue.path || [])],\n              })\n            }\n          }\n        }\n\n        if (issues.length > 0) {\n          return { issues }\n        }\n      }\n    }\n\n    // Handle object types\n    if (this._object) {\n      if (!isObject(value)) {\n        return {\n          issues: [{\n            message: `Expected object, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      const issues: StandardSchemaV1.Issue[] = []\n      const obj = value as Record<string, any>\n\n      for (const key in this._object) {\n        const propSchema = this._object[key] as Type<any>\n        const propValue = obj[key]\n        const propResult = propSchema.validate(propValue)\n\n        if (propResult.issues) {\n          for (const issue of propResult.issues) {\n            issues.push({\n              message: issue.message,\n              path: [key, ...(issue.path || [])],\n            })\n          }\n        }\n      }\n\n      if (issues.length > 0) {\n        return { issues }\n      }\n\n      return { value: value as T, issues: undefined }\n    }\n\n    // Handle record types\n    if (this.type === 'record' && this._type) {\n      if (!isObject(value)) {\n        return {\n          issues: [{\n            message: `Expected object, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      const valueType = this._type as Type<any>\n      const issues: StandardSchemaV1.Issue[] = []\n      const obj = value as Record<string, any>\n\n      for (const key in obj) {\n        const propResult = valueType.validate(obj[key])\n        if (propResult.issues) {\n          for (const issue of propResult.issues) {\n            issues.push({\n              message: issue.message,\n              path: [key, ...(issue.path || [])],\n            })\n          }\n        }\n      }\n\n      if (issues.length > 0) {\n        return { issues }\n      }\n    }\n\n    // Check primitive types\n    if (this._check && !this._check(value)) {\n      return {\n        issues: [{\n          message: `Expected ${this.type}, got ${typeof value}`,\n          path: [],\n        }],\n      }\n    }\n\n    // Success - return the value\n    return { value: value as T }\n  }\n\n  /**\n   * Creates a copy of the type with new properties merged\n   */\n  private _cloneWithProps<U = T>(newProps: Partial<Type<any>> = {}): Type<U> {\n    const cloned = new Type<U>(this.type)\n    // Copy all existing properties\n    const propertiesToCopy = ['_default', '_optional', '_meta', '_check', '_object', '_type', '_union', '_enumValues', '_args', '_ret', '_info']\n    for (const prop of propertiesToCopy) {\n      if ((this as any)[prop] !== undefined) {\n        (cloned as any)[prop] = (this as any)[prop]\n      }\n    }\n    // Apply new properties\n    Object.assign(cloned, newProps)\n    return cloned\n  }\n\n  /**\n   * Helper to copy type properties when creating new type instances\n   */\n  private static _copyTypeProperties(source: Type<any>, target: Type<any>): void {\n    const properties = ['_check', '_default', '_meta', '_object', '_type', '_enumValues']\n    for (const prop of properties) {\n      if ((source as any)[prop] !== undefined) {\n        (target as any)[prop] = (source as any)[prop]\n      }\n    }\n  }\n\n  /**\n   * Marks the type as optional, meaning it can be undefined\n   * This is useful for properties that are not required.\n   */\n  optional(): Type<T | undefined> {\n    return this._cloneWithProps<T | undefined>({ _optional: true })\n  }\n\n  /**\n   * Sets a default value for the type, which will be used if the value is not provided\n   * The default value can be a function that receives the schema as argument, or a static value.\n   */\n  default(value: T | ((schema?: this) => T)): Type<T> {\n    return this._cloneWithProps<T>({ _default: value })\n  }\n\n  /**\n   * Props / Metadata for the type, like description or other properties\n   */\n  meta(meta: TypeMeta): Type<T> {\n    return this._cloneWithProps<T>({ _meta: meta })\n  }\n\n  /**\n   * Sets the `desc` property for the type, which is a human-readable description\n   */\n  describe(msg: string): Type<T> {\n    const meta = this._meta || {}\n    meta.desc = msg\n    return this._cloneWithProps<T>({ _meta: meta })\n  }\n\n  /**\n   * Extends the type with an object, merging the properties\n   */\n  extend<O>(obj: O): Type<T & TypeObject<O>> {\n    if (!this._object) {\n      throw new Error('extend() can only be used on object schemas')\n    }\n    const newObj = { ...this._object, ...obj }\n    return object(newObj) as any\n  }\n\n  /**\n   * Picks certain keys from an object schema\n   */\n  pick<K extends keyof T>(keys: Record<K, true>): Type<Pick<T, K>> {\n    if (!this._object) {\n      throw new Error('pick() can only be used on object schemas')\n    }\n    const pickedObj: any = {}\n    for (const key of Object.keys(keys)) {\n      if (key in this._object) {\n        pickedObj[key] = (this._object as any)[key]\n      }\n    }\n    return object(pickedObj) as any\n  }\n\n  /**\n   * Omits certain keys from an object schema\n   */\n  omit<K extends keyof T>(keys: Record<K, true>): Type<Omit<T, K>> {\n    if (!this._object) {\n      throw new Error('omit() can only be used on object schemas')\n    }\n    const omittedObj: any = { ...this._object }\n    for (const key of Object.keys(keys)) {\n      delete omittedObj[key]\n    }\n    return object(omittedObj) as any\n  }\n\n  /**\n   * Helper method to modify object properties with a transformation function\n   */\n  private _transformObjectProperties(\n    transform: (key: string, type: Type<any>, shouldTransform: boolean) => Type<any>,\n    keys?: Record<string, true>,\n  ): any {\n    if (!this._object) {\n      throw new Error('This operation can only be used on object schemas')\n    }\n\n    const transformedObj: any = {}\n    const originalObj = this._object as any\n\n    for (const [key, typeInstance] of Object.entries(originalObj)) {\n      const shouldTransform = !keys || key in keys\n      transformedObj[key] = transform(key, typeInstance as Type<any>, shouldTransform)\n    }\n\n    return object(transformedObj)\n  }\n\n  /**\n   * Makes some or all properties of an object schema optional\n   */\n  partial(): Type<Partial<T>>\n  partial<K extends keyof T>(keys: Record<K, true>): Type<Partial<Pick<T, K>> & Omit<T, K>>\n  partial<K extends keyof T>(keys?: Record<K, true>): Type<Partial<T> | (Partial<Pick<T, K>> & Omit<T, K>)> {\n    if (!this._object) {\n      throw new Error('partial() can only be used on object schemas')\n    }\n    return this._transformObjectProperties((key, type, shouldTransform) => {\n      if (!shouldTransform)\n        return type\n      return Type._cloneTypeWithOptional(type, true)\n    }, keys)\n  }\n\n  /**\n   * Makes some or all properties of an object schema required\n   */\n  required(): Type<Required<T>>\n  required<K extends keyof T>(keys: Record<K, true>): Type<Required<Pick<T, K>> & Omit<T, K>>\n  required<K extends keyof T>(keys?: Record<K, true>): Type<Required<T> | (Required<Pick<T, K>> & Omit<T, K>)> {\n    if (!this._object) {\n      throw new Error('required() can only be used on object schemas')\n    }\n    return this._transformObjectProperties((key, type, shouldTransform) => {\n      if (!shouldTransform)\n        return type\n      return Type._cloneTypeWithOptional(type, false)\n    }, keys)\n  }\n\n  /**\n   * Helper method to clone a type with optional flag\n   */\n  private static _cloneTypeWithOptional(originalType: Type<any>, optional: boolean): Type<any> {\n    const newType = new Type(originalType.type)\n    Type._copyTypeProperties(originalType, newType)\n    newType._optional = optional\n    return newType\n  }\n}\n\n/**\n * Type inference utility for extracting the TypeScript type from a schema Type\n */\nexport type Infer<T> = T extends Type<infer TT> ? TT : never\n\n// =============================================================================\n// Primitive Types\n// =============================================================================\n\n/**\n * Creates a string type validator\n */\nexport function string(): Type<string> {\n  return new Type('string', {\n    _check: isString,\n  })\n}\n\n/**\n * Creates a number type validator\n */\nexport function number(): Type<number> {\n  return new Type('number', {\n    _check: isNumber,\n  })\n}\n\n/**\n * Creates an integer type validator\n */\nexport function int(): Type<number> {\n  return new Type('int', {\n    _check: isInteger,\n  })\n}\n\n/**\n * Creates a boolean type validator\n */\nexport function boolean(): Type<boolean> {\n  return new Type('boolean', {\n    _check: isBoolean,\n  })\n}\n\n/**\n * Creates a none type validator (undefined | null)\n * Like undefined | null in TS and nil in Swift\n */\nexport function none(): Type<undefined> {\n  return new Type('none', {\n    _check: (v: any) => v == null,\n    _optional: true,\n  })\n}\n\n/**\n * Creates an any type validator that accepts any non-null value\n */\nexport function any<T = any>(): Type<T> {\n  return new Type('any', {\n    _check: (v: any) => v != null,\n  })\n}\n\n// Aliases for number types\nexport const float = number\nexport const double = number\nexport const real = number\n\n// =============================================================================\n// Object Types\n// =============================================================================\n\n/**\n * Utility type to make object properties optional if their value type includes undefined.\n * @category Schema\n */\nexport type TypeObjectFixOptional<T> = {\n  [K in keyof T as undefined extends T[K] ? K : never]?: T[K] & {}\n} & {\n  [K in keyof T as undefined extends T[K] ? never : K]: T[K] & {}\n}\n\n/**\n * Utility type for pretty-printing object types\n */\ntype TypeObjectPretty<V> = Extract<{ [K in keyof V]: V[K] }, unknown>\n\n/**\n * Main object type utility\n */\ntype TypeObject<T> = TypeObjectPretty<TypeObjectFixOptional<{\n  [K in keyof T]: Infer<T[K]>\n}>>\n\n/**\n * Creates an object type validator with specified properties\n */\nexport function object<T>(tobj: T): Type<TypeObject<T>> {\n  return new Type('object', {\n    _check: isObject,\n    _object: tobj,\n  })\n}\n\n/**\n * Creates a record type validator (object with string keys and uniform value type)\n */\nexport function record<T extends Type>(valueType: T): Type<Record<string, Infer<T>>> {\n  return new Type('record', {\n    _check: isObject,\n    _type: valueType,\n  })\n}\n\n// =============================================================================\n// Union Types\n// =============================================================================\n\n/**\n * Utility type for union of types.\n * @category Schema\n */\nexport type TypeUnion<T extends Type<any>[]> = {\n  [K in keyof T]: T[K] extends Type<infer U> ? U : never\n}[number]\n\n/**\n * Creates a union type validator (like `string | number | boolean`)\n */\nexport function union<T extends Type<any>[]>(options: T): Type<TypeUnion<T>> {\n  return new Type('union', {\n    _check: (v: any) => options.some(option => option._check?.(v) ?? false),\n    _union: options,\n  })\n}\n\n// =============================================================================\n// Literal Types\n// =============================================================================\n\n/**\n * Utility type for literal types.\n * @category Schema\n */\nexport type TypeLiterals = string | number | bigint | boolean\n\n/**\n * Creates a literal value validator\n */\nexport function literal<T extends TypeLiterals>(value: T): Type<T> {\n  return new Type('literal', {\n    _check: (v: any) => v === value,\n    _default: value,\n  })\n}\n\n/**\n * Creates a string literal union validator (like `\"a\" | \"b\" | \"c\"`)\n */\nexport function stringLiterals<const T extends readonly string[]>(values: T): Type<T[number]> {\n  return new Type('string', {\n    _check: (v: any) => typeof v === 'string' && (values as readonly string[]).includes(v),\n    _enumValues: values,\n  })\n}\n\n// =============================================================================\n// Collection Types\n// =============================================================================\n\n/**\n * Utility type for tuple types.\n * @category Schema\n */\nexport type TypeTuple<T extends readonly Type[]> = {\n  -readonly [K in keyof T]: T[K] extends Type<infer U> ? U : never\n}\n\n/**\n * Output type for TypeArray.\n * @category Schema\n */\nexport type TypeArrayOutput<Head extends Type[], Rest extends Type | undefined> = [\n  ...TypeTuple<Head>,\n  ...(Rest extends Type ? Infer<Rest>[] : []),\n]\n\n/**\n * Utility type for array types.\n * @category Schema\n */\nexport type TypeArray<Head extends Type[] = Type[], Rest extends Type | undefined = Type | undefined> = Type<TypeArrayOutput<Head, Rest>>\n\n/**\n * Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]\n */\nexport function tuple<const T extends readonly Type[]>(items: T): Type<TypeTuple<T>> {\n  return new Type('tuple', {\n    _check: (v: any) => Array.isArray(v) && v.length === items.length && items.every((item, i) => (item as Type)._check?.(v[i]) ?? false),\n    _type: items,\n  })\n}\n\n/**\n * Creates an array type validator for a specific item type\n */\nexport function array<T>(itemType: Type<T>): Type<T[]> {\n  return new Type('array', {\n    _check: isArray,\n    _type: itemType,\n  })\n}\n\n// =============================================================================\n// Function Types\n// =============================================================================\n\n/**\n * Creates a regular function type validator\n */\nexport function func<\n  TypeFuncArgs extends [Type<unknown>, ...Type<any>[]] | [],\n  TypeFuncRet = Type,\n  T = (...args: TypeTuple<TypeFuncArgs>) => Infer<TypeFuncRet>,\n>(args: TypeFuncArgs, ret: TypeFuncRet): Type<T> {\n  return new Type('function', {\n    _check: isFunction,\n    _args: args,\n    _ret: ret,\n  })\n}\n\n/**\n * Creates an RPC function type validator that takes one argument and returns a promise\n */\nexport function rpc<\n  TypeRpcInfo extends Type<unknown> | undefined = undefined,\n  TypeRpcRet extends Type<unknown> = Type<void>,\n  T = TypeRpcInfo extends undefined\n    ? () => Infer<TypeRpcRet>\n    : (info: Infer<TypeRpcInfo>) => Infer<TypeRpcRet> | Promise<Infer<TypeRpcRet>>,\n>(info?: TypeRpcInfo, ret?: TypeRpcRet): Type<T> {\n  return new Type('rpc', {\n    _check: isFunction,\n    _info: info,\n    _ret: ret ?? none(),\n  })\n}\n"],"mappings":"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"}
+{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/common/schema/schema.ts"],"sourcesContent":["// With many, many inspiration from https://github.com/badrap/valita MIT License as of 2024-09-10\n\nimport type { StandardSchemaV1 } from './schema-standard'\nimport { isArray, isBoolean, isFunction, isInteger, isNumber, isObject, isString } from '../data/is'\n\n/**\n * Metadata interface for type descriptions and additional properties\n */\nexport interface TypeMeta {\n  desc?: string\n}\n\n/**\n * Core Type class for schema validation and type inference\n * Implements StandardSchemaV1 for cross-library compatibility\n */\nexport class Type<T = unknown> {\n  readonly type: string\n\n  _default?: any\n  _optional?: boolean\n  _meta?: TypeMeta\n  _check?: (obj: any) => boolean\n  _object?: any\n  _type?: any\n  _union?: any\n  _enumValues?: any\n  _args?: any\n  _ret?: any\n  _info?: any\n\n  // [key: `_${string}`]: any // Allow only optional dynamic properties starting with an underscore\n\n  constructor(name: string, options: Partial<Type<T>> = {}) {\n    this.type = name\n    Object.assign(this, options)\n  }\n\n  /**\n   * Standard Schema V1 compliance property\n   * Provides a standard interface for validation and type inference\n   */\n  get '~standard'(): any {\n    return {\n      version: 1,\n      vendor: 'zeed',\n      validate: (value: unknown): StandardSchemaV1.Result<T> => {\n        return this.validate(value)\n      },\n      types: {\n        input: undefined as any as T,\n        output: undefined as any as T,\n      },\n    }\n  }\n\n  /**\n   * Validation method for standard-schema compliance\n   */\n  validate(value: any): any {\n    // const messages: Array<{ path: string, message: string, type: string, valid: boolean }> = []\n\n    // Handle null/undefined cases\n    if (value == null) {\n      if (this._optional) {\n        return { value: undefined as any as T }\n      }\n      if (this._default !== undefined) {\n        const defaultValue = isFunction(this._default) ? this._default(this) : this._default\n        return { value: defaultValue }\n      }\n      return {\n        issues: [{\n          message: `Required value is missing`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle literal types\n    if (this.type === 'literal' && this._default !== value) {\n      return {\n        issues: [{\n          message: `Expected literal value ${this._default}, got ${value}`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle string literals (enums)\n    if (this._enumValues && Array.isArray(this._enumValues)) {\n      if (!this._enumValues.includes(value)) {\n        return {\n          issues: [{\n            message: `Expected one of [${this._enumValues.join(', ')}], got ${value}`,\n            path: [],\n          }],\n        }\n      }\n    }\n\n    // Handle union types\n    if (this._union && Array.isArray(this._union)) {\n      for (const option of this._union) {\n        const result = (option as Type<any>).validate(value)\n        if (!result.issues) {\n          return result\n        }\n      }\n      return {\n        issues: [{\n          message: `Value does not match any union variant`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle array types\n    if (this.type === 'array' || this.type === 'tuple') {\n      if (!Array.isArray(value)) {\n        return {\n          issues: [{\n            message: `Expected array, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      if (this.type === 'tuple' && this._type) {\n        const items = this._type as Type<any>[]\n        if (value.length !== items.length) {\n          return {\n            issues: [{\n              message: `Expected tuple of length ${items.length}, got ${value.length}`,\n              path: [],\n            }],\n          }\n        }\n\n        const issues: StandardSchemaV1.Issue[] = []\n        for (let i = 0; i < items.length; i++) {\n          const itemResult = items[i].validate(value[i])\n          if (itemResult.issues) {\n            for (const issue of itemResult.issues) {\n              issues.push({\n                message: issue.message,\n                path: [i, ...(issue.path || [])],\n              })\n            }\n          }\n        }\n\n        if (issues.length > 0) {\n          return { issues }\n        }\n      }\n      else if (this._type) {\n        // Regular array with item type\n        const itemType = this._type as Type<any>\n        const issues: StandardSchemaV1.Issue[] = []\n\n        for (let i = 0; i < value.length; i++) {\n          const itemResult = itemType.validate(value[i])\n          if (itemResult.issues) {\n            for (const issue of itemResult.issues) {\n              issues.push({\n                message: issue.message,\n                path: [i, ...(issue.path || [])],\n              })\n            }\n          }\n        }\n\n        if (issues.length > 0) {\n          return { issues }\n        }\n      }\n    }\n\n    // Handle object types\n    if (this._object) {\n      if (!isObject(value)) {\n        return {\n          issues: [{\n            message: `Expected object, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      const issues: StandardSchemaV1.Issue[] = []\n      const obj = value as Record<string, any>\n\n      for (const key in this._object) {\n        const propSchema = this._object[key] as Type<any>\n        const propValue = obj[key]\n        const propResult = propSchema.validate(propValue)\n\n        if (propResult.issues) {\n          for (const issue of propResult.issues) {\n            issues.push({\n              message: issue.message,\n              path: [key, ...(issue.path || [])],\n            })\n          }\n        }\n      }\n\n      if (issues.length > 0) {\n        return { issues }\n      }\n\n      return { value: value as T, issues: undefined }\n    }\n\n    // Handle record types\n    if (this.type === 'record' && this._type) {\n      if (!isObject(value)) {\n        return {\n          issues: [{\n            message: `Expected object, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      const valueType = this._type as Type<any>\n      const issues: StandardSchemaV1.Issue[] = []\n      const obj = value as Record<string, any>\n\n      for (const key in obj) {\n        const propResult = valueType.validate(obj[key])\n        if (propResult.issues) {\n          for (const issue of propResult.issues) {\n            issues.push({\n              message: issue.message,\n              path: [key, ...(issue.path || [])],\n            })\n          }\n        }\n      }\n\n      if (issues.length > 0) {\n        return { issues }\n      }\n    }\n\n    // Check primitive types\n    if (this._check && !this._check(value)) {\n      return {\n        issues: [{\n          message: `Expected ${this.type}, got ${typeof value}`,\n          path: [],\n        }],\n      }\n    }\n\n    // Success - return the value\n    return { value: value as T }\n  }\n\n  /**\n   * Creates a copy of the type with new properties merged\n   */\n  private _cloneWithProps<U = T>(newProps: Partial<Type<any>> = {}): Type<U> {\n    const cloned = new Type<U>(this.type)\n    // Copy all existing properties\n    const propertiesToCopy = ['_default', '_optional', '_meta', '_check', '_object', '_type', '_union', '_enumValues', '_args', '_ret', '_info']\n    for (const prop of propertiesToCopy) {\n      if ((this as any)[prop] !== undefined) {\n        (cloned as any)[prop] = (this as any)[prop]\n      }\n    }\n    // Apply new properties\n    Object.assign(cloned, newProps)\n    return cloned\n  }\n\n  /**\n   * Helper to copy type properties when creating new type instances\n   */\n  private static _copyTypeProperties(source: Type<any>, target: Type<any>): void {\n    const properties = ['_check', '_default', '_meta', '_object', '_type', '_enumValues']\n    for (const prop of properties) {\n      if ((source as any)[prop] !== undefined) {\n        (target as any)[prop] = (source as any)[prop]\n      }\n    }\n  }\n\n  /**\n   * Marks the type as optional, meaning it can be undefined\n   * This is useful for properties that are not required.\n   */\n  optional(): Type<T | undefined> {\n    return this._cloneWithProps<T | undefined>({ _optional: true })\n  }\n\n  /**\n   * Sets a default value for the type, which will be used if the value is not provided\n   * The default value can be a function that receives the schema as argument, or a static value.\n   */\n  default(value: T | ((schema?: this) => T)): Type<T> {\n    return this._cloneWithProps<T>({ _default: value })\n  }\n\n  /**\n   * Props / Metadata for the type, like description or other properties\n   */\n  meta(meta: TypeMeta): Type<T> {\n    return this._cloneWithProps<T>({ _meta: meta })\n  }\n\n  /**\n   * Sets the `desc` property for the type, which is a human-readable description\n   */\n  describe(msg: string): Type<T> {\n    const meta = this._meta || {}\n    meta.desc = msg\n    return this._cloneWithProps<T>({ _meta: meta })\n  }\n\n  /**\n   * Extends the type with an object, merging the properties\n   */\n  extend<O>(obj: O): Type<T & TypeObject<O>> {\n    if (!this._object) {\n      throw new Error('extend() can only be used on object schemas')\n    }\n    const newObj = { ...this._object, ...obj }\n    return object(newObj) as any\n  }\n\n  /**\n   * Picks certain keys from an object schema\n   */\n  pick<K extends keyof T>(keys: Record<K, true>): Type<Pick<T, K>> {\n    if (!this._object) {\n      throw new Error('pick() can only be used on object schemas')\n    }\n    const pickedObj: any = {}\n    for (const key of Object.keys(keys)) {\n      if (key in this._object) {\n        pickedObj[key] = (this._object as any)[key]\n      }\n    }\n    return object(pickedObj) as any\n  }\n\n  /**\n   * Omits certain keys from an object schema\n   */\n  omit<K extends keyof T>(keys: Record<K, true>): Type<Omit<T, K>> {\n    if (!this._object) {\n      throw new Error('omit() can only be used on object schemas')\n    }\n    const omittedObj: any = { ...this._object }\n    for (const key of Object.keys(keys)) {\n      delete omittedObj[key]\n    }\n    return object(omittedObj) as any\n  }\n\n  /**\n   * Helper method to modify object properties with a transformation function\n   */\n  private _transformObjectProperties(\n    transform: (key: string, type: Type<any>, shouldTransform: boolean) => Type<any>,\n    keys?: Record<string, true>,\n  ): any {\n    if (!this._object) {\n      throw new Error('This operation can only be used on object schemas')\n    }\n\n    const transformedObj: any = {}\n    const originalObj = this._object as any\n\n    for (const [key, typeInstance] of Object.entries(originalObj)) {\n      const shouldTransform = !keys || key in keys\n      transformedObj[key] = transform(key, typeInstance as Type<any>, shouldTransform)\n    }\n\n    return object(transformedObj)\n  }\n\n  /**\n   * Makes some or all properties of an object schema optional\n   */\n  partial(): Type<Partial<T>>\n  partial<K extends keyof T>(keys: Record<K, true>): Type<Partial<Pick<T, K>> & Omit<T, K>>\n  partial<K extends keyof T>(keys?: Record<K, true>): Type<Partial<T> | (Partial<Pick<T, K>> & Omit<T, K>)> {\n    if (!this._object) {\n      throw new Error('partial() can only be used on object schemas')\n    }\n    return this._transformObjectProperties((key, type, shouldTransform) => {\n      if (!shouldTransform)\n        return type\n      return Type._cloneTypeWithOptional(type, true)\n    }, keys)\n  }\n\n  /**\n   * Makes some or all properties of an object schema required\n   */\n  required(): Type<Required<T>>\n  required<K extends keyof T>(keys: Record<K, true>): Type<Required<Pick<T, K>> & Omit<T, K>>\n  required<K extends keyof T>(keys?: Record<K, true>): Type<Required<T> | (Required<Pick<T, K>> & Omit<T, K>)> {\n    if (!this._object) {\n      throw new Error('required() can only be used on object schemas')\n    }\n    return this._transformObjectProperties((key, type, shouldTransform) => {\n      if (!shouldTransform)\n        return type\n      return Type._cloneTypeWithOptional(type, false)\n    }, keys)\n  }\n\n  /**\n   * Helper method to clone a type with optional flag\n   */\n  private static _cloneTypeWithOptional(originalType: Type<any>, optional: boolean): Type<any> {\n    const newType = new Type(originalType.type)\n    Type._copyTypeProperties(originalType, newType)\n    newType._optional = optional\n    return newType\n  }\n}\n\n/**\n * Type inference utility for extracting the TypeScript type from a schema Type\n */\nexport type Infer<T> = T extends Type<infer TT> ? TT : never\n\n// =============================================================================\n// Primitive Types\n// =============================================================================\n\n/**\n * Creates a string type validator\n */\nexport function string(): Type<string> {\n  return new Type('string', {\n    _check: isString,\n  })\n}\n\n/**\n * Creates a number type validator\n */\nexport function number(): Type<number> {\n  return new Type('number', {\n    _check: isNumber,\n  })\n}\n\n/**\n * Creates an integer type validator\n */\nexport function int(): Type<number> {\n  return new Type('int', {\n    _check: isInteger,\n  })\n}\n\n/**\n * Creates a boolean type validator\n */\nexport function boolean(): Type<boolean> {\n  return new Type('boolean', {\n    _check: isBoolean,\n  })\n}\n\n/**\n * Creates a none type validator (undefined | null)\n * Like undefined | null in TS and nil in Swift\n */\nexport function none(): Type<undefined> {\n  return new Type('none', {\n    _check: (v: any) => v == null,\n    _optional: true,\n  })\n}\n\n/**\n * Creates an any type validator that accepts any non-null value\n */\nexport function any<T = any>(): Type<T> {\n  return new Type('any', {\n    _check: (v: any) => v != null,\n  })\n}\n\n// Aliases for number types\nexport const float = number\nexport const double = number\nexport const real = number\n\n// =============================================================================\n// Object Types\n// =============================================================================\n\n/**\n * Utility type to make object properties optional if their value type includes undefined.\n * @category Schema\n */\nexport type TypeObjectFixOptional<T> = {\n  [K in keyof T as undefined extends T[K] ? K : never]?: T[K] & {}\n} & {\n  [K in keyof T as undefined extends T[K] ? never : K]: T[K] & {}\n}\n\n/**\n * Utility type for pretty-printing object types\n */\ntype TypeObjectPretty<V> = Extract<{ [K in keyof V]: V[K] }, unknown>\n\n/**\n * Main object type utility\n */\ntype TypeObject<T> = TypeObjectPretty<TypeObjectFixOptional<{\n  [K in keyof T]: Infer<T[K]>\n}>>\n\n/**\n * Creates an object type validator with specified properties\n */\nexport function object<T>(tobj: T): Type<TypeObject<T>> {\n  return new Type('object', {\n    _check: isObject,\n    _object: tobj,\n  })\n}\n\n/**\n * Creates a record type validator (object with string keys and uniform value type)\n */\nexport function record<T extends Type>(valueType: T): Type<Record<string, Infer<T>>> {\n  return new Type('record', {\n    _check: isObject,\n    _type: valueType,\n  })\n}\n\n// =============================================================================\n// Union Types\n// =============================================================================\n\n/**\n * Utility type for union of types.\n * @category Schema\n */\nexport type TypeUnion<T extends Type<any>[]> = {\n  [K in keyof T]: T[K] extends Type<infer U> ? U : never\n}[number]\n\n/**\n * Creates a union type validator (like `string | number | boolean`)\n */\nexport function union<T extends Type<any>[]>(options: T): Type<TypeUnion<T>> {\n  return new Type('union', {\n    _check: (v: any) => options.some(option => option._check?.(v) ?? false),\n    _union: options,\n  })\n}\n\n// =============================================================================\n// Literal Types\n// =============================================================================\n\n/**\n * Utility type for literal types.\n * @category Schema\n */\nexport type TypeLiterals = string | number | bigint | boolean\n\n/**\n * Creates a literal value validator\n */\nexport function literal<T extends TypeLiterals>(value: T): Type<T> {\n  return new Type('literal', {\n    _check: (v: any) => v === value,\n    _default: value,\n  })\n}\n\n/**\n * Creates a string literal union validator (like `\"a\" | \"b\" | \"c\"`)\n */\nexport function stringLiterals<const T extends readonly string[]>(values: T): Type<T[number]> {\n  return new Type('string', {\n    _check: (v: any) => typeof v === 'string' && (values as readonly string[]).includes(v),\n    _enumValues: values,\n  })\n}\n\n// =============================================================================\n// Collection Types\n// =============================================================================\n\n/**\n * Utility type for tuple types.\n * @category Schema\n */\nexport type TypeTuple<T extends readonly Type[]> = {\n  -readonly [K in keyof T]: T[K] extends Type<infer U> ? U : never\n}\n\n/**\n * Output type for TypeArray.\n * @category Schema\n */\nexport type TypeArrayOutput<Head extends Type[], Rest extends Type | undefined> = [\n  ...TypeTuple<Head>,\n  ...(Rest extends Type ? Infer<Rest>[] : []),\n]\n\n/**\n * Utility type for array types.\n * @category Schema\n */\nexport type TypeArray<Head extends Type[] = Type[], Rest extends Type | undefined = Type | undefined> = Type<TypeArrayOutput<Head, Rest>>\n\n/**\n * Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]\n */\nexport function tuple<const T extends readonly Type[]>(items: T): Type<TypeTuple<T>> {\n  return new Type('tuple', {\n    _check: (v: any) => Array.isArray(v) && v.length === items.length && items.every((item, i) => (item as Type)._check?.(v[i]) ?? false),\n    _type: items,\n  })\n}\n\n/**\n * Creates an array type validator for a specific item type\n */\nexport function array<T>(itemType: Type<T>): Type<T[]> {\n  return new Type('array', {\n    _check: isArray,\n    _type: itemType,\n  })\n}\n\n// =============================================================================\n// Function Types\n// =============================================================================\n\n/**\n * Creates a regular function type validator\n */\nexport function func<\n  TypeFuncArgs extends [Type<unknown>, ...Type<any>[]] | [],\n  TypeFuncRet = Type,\n  T = (...args: TypeTuple<TypeFuncArgs>) => Infer<TypeFuncRet>,\n>(args: TypeFuncArgs, ret: TypeFuncRet): Type<T> {\n  return new Type('function', {\n    _check: isFunction,\n    _args: args,\n    _ret: ret,\n  })\n}\n\n/**\n * Creates an RPC function type validator that takes one argument and returns a promise\n */\nexport function rpc<\n  TypeRpcInfo extends Type<unknown> | undefined = undefined,\n  TypeRpcRet extends Type<unknown> = Type<void>,\n  T = TypeRpcInfo extends undefined\n    ? () => Infer<TypeRpcRet>\n    : (info: Infer<TypeRpcInfo>) => Infer<TypeRpcRet> | Promise<Infer<TypeRpcRet>>,\n>(info?: TypeRpcInfo, ret?: TypeRpcRet): Type<T> {\n  return new Type('rpc', {\n    _check: isFunction,\n    _info: info,\n    _ret: ret ?? none(),\n  })\n}\n"],"mappings":"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"}

package/dist/common/schema/serialize.cjs

@@ -1,2 +1,110 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../data/is.cjs`),t=require(`./schema.cjs`);function n(t){let r={type:t.type};if(t._optional!==void 0&&(r.optional=t._optional),t._meta!==void 0&&(r.meta=t._meta),t._default!==void 0&&!e.isFunction(t._default)&&(r.default=t._default),t._object!==void 0){r.object={};for(let[e,i]of Object.entries(t._object))r.object[e]=n(i)}return t._type!==void 0&&(e.isArray(t._type)?r.tupleTypes=t._type.map(e=>n(e)):r.itemType=n(t._type)),t._union!==void 0&&(r.union=t._union.map(e=>n(e))),t._enumValues!==void 0&&(r.enumValues=t._enumValues),t._args!==void 0&&(r.args=t._args.map(e=>n(e))),t._ret!==void 0&&(r.ret=n(t._ret)),t._info!==void 0&&(r.info=n(t._info)),t.type===`literal`&&t._default!==void 0&&(r.literalValue=t._default),r}function r(e){let n;switch(e.type){case`string`:n=e.enumValues?t.stringLiterals(e.enumValues):t.string();break;case`number`:n=t.number();break;case`int`:n=t.int();break;case`boolean`:n=t.boolean();break;case`none`:n=t.none();break;case`any`:n=t.any();break;case`object`:if(e.object){let i={};for(let[t,n]of Object.entries(e.object))i[t]=r(n);n=t.object(i)}else n=t.object({});break;case`record`:n=e.itemType?t.record(r(e.itemType)):t.record(t.any());break;case`array`:n=e.itemType?t.array(r(e.itemType)):t.array(t.any());break;case`tuple`:n=e.tupleTypes?t.tuple(e.tupleTypes.map(e=>r(e))):t.tuple([]);break;case`union`:n=e.union?t.union(e.union.map(e=>r(e))):t.union([]);break;case`literal`:n=e.literalValue===void 0?t.any():t.literal(e.literalValue);break;case`function`:n=e.args&&e.ret?t.func(e.args.map(e=>r(e)),r(e.ret)):t.func([],t.any());break;case`rpc`:n=e.info&&e.ret?t.rpc(r(e.info),r(e.ret)):e.ret?t.rpc(void 0,r(e.ret)):t.rpc();break;default:n=t.any();break}return e.optional&&(n=n.optional()),e.default!==void 0&&(n=n.default(e.default)),e.meta&&(n=n.meta(e.meta)),n}exports.deserializeSchema=r,exports.serializeSchema=n;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_data_is = require('../data/is.cjs');
+const require_common_schema_schema = require('./schema.cjs');
+
+//#region src/common/schema/serialize.ts
+/**
+* Serializes a schema Type to a plain JSON object.
+* Functions in _check and _default will not be serialized.
+*
+* @param schema - The schema Type to serialize
+* @returns A plain JSON object representing the schema
+*/
+function serializeSchema(schema) {
+	const result = { type: schema.type };
+	if (schema._optional !== void 0) result.optional = schema._optional;
+	if (schema._meta !== void 0) result.meta = schema._meta;
+	if (schema._default !== void 0 && !require_common_data_is.isFunction(schema._default)) result.default = schema._default;
+	if (schema._object !== void 0) {
+		result.object = {};
+		for (const [key, value] of Object.entries(schema._object)) result.object[key] = serializeSchema(value);
+	}
+	if (schema._type !== void 0) if (require_common_data_is.isArray(schema._type)) result.tupleTypes = schema._type.map((t) => serializeSchema(t));
+	else result.itemType = serializeSchema(schema._type);
+	if (schema._union !== void 0) result.union = schema._union.map((t) => serializeSchema(t));
+	if (schema._enumValues !== void 0) result.enumValues = schema._enumValues;
+	if (schema._args !== void 0) result.args = schema._args.map((t) => serializeSchema(t));
+	if (schema._ret !== void 0) result.ret = serializeSchema(schema._ret);
+	if (schema._info !== void 0) result.info = serializeSchema(schema._info);
+	if (schema.type === "literal" && schema._default !== void 0) result.literalValue = schema._default;
+	return result;
+}
+/**
+* Deserializes a plain JSON object back to a schema Type.
+* Note: Custom _check functions cannot be restored and will use default validators.
+*
+* @param serialized - The serialized schema object
+* @returns A reconstructed Type instance
+*/
+function deserializeSchema(serialized) {
+	let schema;
+	switch (serialized.type) {
+		case "string":
+			if (serialized.enumValues) schema = require_common_schema_schema.stringLiterals(serialized.enumValues);
+			else schema = require_common_schema_schema.string();
+			break;
+		case "number":
+			schema = require_common_schema_schema.number();
+			break;
+		case "int":
+			schema = require_common_schema_schema.int();
+			break;
+		case "boolean":
+			schema = require_common_schema_schema.boolean();
+			break;
+		case "none":
+			schema = require_common_schema_schema.none();
+			break;
+		case "any":
+			schema = require_common_schema_schema.any();
+			break;
+		case "object":
+			if (serialized.object) {
+				const obj = {};
+				for (const [key, value] of Object.entries(serialized.object)) obj[key] = deserializeSchema(value);
+				schema = require_common_schema_schema.object(obj);
+			} else schema = require_common_schema_schema.object({});
+			break;
+		case "record":
+			if (serialized.itemType) schema = require_common_schema_schema.record(deserializeSchema(serialized.itemType));
+			else schema = require_common_schema_schema.record(require_common_schema_schema.any());
+			break;
+		case "array":
+			if (serialized.itemType) schema = require_common_schema_schema.array(deserializeSchema(serialized.itemType));
+			else schema = require_common_schema_schema.array(require_common_schema_schema.any());
+			break;
+		case "tuple":
+			if (serialized.tupleTypes) schema = require_common_schema_schema.tuple(serialized.tupleTypes.map((t) => deserializeSchema(t)));
+			else schema = require_common_schema_schema.tuple([]);
+			break;
+		case "union":
+			if (serialized.union) schema = require_common_schema_schema.union(serialized.union.map((t) => deserializeSchema(t)));
+			else schema = require_common_schema_schema.union([]);
+			break;
+		case "literal":
+			if (serialized.literalValue !== void 0) schema = require_common_schema_schema.literal(serialized.literalValue);
+			else schema = require_common_schema_schema.any();
+			break;
+		case "function":
+			if (serialized.args && serialized.ret) schema = require_common_schema_schema.func(serialized.args.map((t) => deserializeSchema(t)), deserializeSchema(serialized.ret));
+			else schema = require_common_schema_schema.func([], require_common_schema_schema.any());
+			break;
+		case "rpc":
+			if (serialized.info && serialized.ret) schema = require_common_schema_schema.rpc(deserializeSchema(serialized.info), deserializeSchema(serialized.ret));
+			else if (serialized.ret) schema = require_common_schema_schema.rpc(void 0, deserializeSchema(serialized.ret));
+			else schema = require_common_schema_schema.rpc();
+			break;
+		default:
+			schema = require_common_schema_schema.any();
+			break;
+	}
+	if (serialized.optional) schema = schema.optional();
+	if (serialized.default !== void 0) schema = schema.default(serialized.default);
+	if (serialized.meta) schema = schema.meta(serialized.meta);
+	return schema;
+}
+
+//#endregion
+exports.deserializeSchema = deserializeSchema;
+exports.serializeSchema = serializeSchema;
 //# sourceMappingURL=serialize.cjs.map