elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/type/validator/default-precompute.mjs

@@ -0,0 +1,465 @@
+import { dangerousKeys } from "../../constants.mjs";
+import { nullObject } from "../../utils.mjs";
+import { Default } from "typebox/value";
+
+//#region src/type/validator/default-precompute.ts
+function isPrecomputeSafe(schema, depth = 0) {
+	if (!schema || typeof schema !== "object") return true;
+	const kind = schema["~kind"];
+	if (kind === "Union" || kind === "Intersect" || kind === "Ref" || kind === "This" || kind === "Cyclic") return false;
+	if (schema["~codec"] || schema["~refine"]) return false;
+	if (depth > 0 && (kind === "Object" || schema.type === "object")) {
+		if (schema.default === void 0 || nestedOwnDefaultDiverges(schema)) return false;
+	}
+	if (schema.properties) {
+		for (const key in schema.properties) if (Object.hasOwn(schema.properties, key) && !isPrecomputeSafe(schema.properties[key], depth + 1)) return false;
+	}
+	if (schema.items) {
+		if (Array.isArray(schema.items)) {
+			for (const v of schema.items) if (!isPrecomputeSafe(v, depth + 1)) return false;
+		} else if (!isPrecomputeSafe(schema.items, depth + 1)) return false;
+	}
+	if (typeof schema.additionalProperties === "object" && !isPrecomputeSafe(schema.additionalProperties, depth + 1)) return false;
+	if (schema.patternProperties) {
+		for (const key in schema.patternProperties) if (Object.hasOwn(schema.patternProperties, key) && !isPrecomputeSafe(schema.patternProperties[key], depth + 1)) return false;
+	}
+	return true;
+}
+function nestedOwnDefaultDiverges(objectSchema) {
+	const own = objectSchema.default;
+	if (own === null || typeof own !== "object" || Array.isArray(own)) return false;
+	const props = objectSchema.properties;
+	if (!props) return false;
+	for (const key in props) {
+		const child = props[key];
+		if (!child || typeof child !== "object") continue;
+		if ("default" in child) {
+			if (!(key in own) || canonical(own[key]) !== canonical(child.default)) return true;
+		} else if (child["~kind"] === "Object" || child.type === "object") {
+			if (key in own) {
+				if (nestedOwnDefaultDiverges({
+					...child,
+					default: own[key]
+				})) return true;
+			} else if (hasDefaultBelow(child)) return true;
+		}
+	}
+	return false;
+}
+function applyPrecomputed(defaults, value) {
+	const out = nullObject();
+	for (const k in defaults) {
+		const d = defaults[k];
+		const v = value[k];
+		if (v === void 0) out[k] = d !== null && typeof d === "object" ? structuredClone(d) : d;
+		else if (!Object.hasOwn(value, k)) out[k] = v;
+		else out[k] = d;
+	}
+	for (const k in value) {
+		const v = value[k];
+		if (v === void 0) continue;
+		const d = out[k];
+		if (v && typeof v === "object" && !Array.isArray(v) && d && typeof d === "object" && !Array.isArray(d)) out[k] = applyPrecomputed(d, v);
+		else out[k] = v;
+	}
+	return out;
+}
+const subtreeHasDefault = (n) => !!n && typeof n === "object" && ("default" in n || childSchemaSome(n, subtreeHasDefault));
+function childSchemaSome(n, f) {
+	if (!n || typeof n !== "object") return false;
+	if (n.properties) {
+		for (const k in n.properties) if (f(n.properties[k])) return true;
+	}
+	const items = n.items;
+	if (Array.isArray(items)) {
+		for (const it of items) if (f(it)) return true;
+	} else if (items && f(items)) return true;
+	for (const key of [
+		"anyOf",
+		"allOf",
+		"oneOf"
+	]) {
+		const arr = n[key];
+		if (Array.isArray(arr)) {
+			for (const s of arr) if (f(s)) return true;
+		}
+	}
+	if (typeof n.additionalProperties === "object" && f(n.additionalProperties)) return true;
+	if (n.patternProperties) {
+		for (const k in n.patternProperties) if (f(n.patternProperties[k])) return true;
+	}
+	for (const key of [
+		"not",
+		"if",
+		"then",
+		"else"
+	]) if (n[key] && f(n[key])) return true;
+	return false;
+}
+const hasDefaultBelow = (node) => childSchemaSome(node, subtreeHasDefault);
+function hasUnemittableDefaultValue(node) {
+	if (!node || typeof node !== "object") return false;
+	if ("default" in node && !isEmittable(node.default, /* @__PURE__ */ new Set(), true)) return true;
+	return childSchemaSome(node, hasUnemittableDefaultValue);
+}
+function containsRefLike(node, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!node || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	if (node.$ref !== void 0 || node["~kind"] === "Ref" || node["~kind"] === "This" || node["~kind"] === "Cyclic") return true;
+	return childSchemaSome(node, (child) => containsRefLike(child, seen));
+}
+function hasDivergentDefaultBelow(node) {
+	const ownKey = "default" in node ? canonical(node.default) : void 0;
+	let bad = false;
+	const visit = (n) => {
+		if (!n || typeof n !== "object") return false;
+		if ("default" in n && (ownKey === void 0 || canonical(n.default) !== ownKey)) return bad = true;
+		return childSchemaSome(n, visit);
+	};
+	childSchemaSome(node, visit);
+	return bad;
+}
+function structuralPreallocatable(schema, depth = 0) {
+	if (!schema || typeof schema !== "object") return true;
+	if (!((schema["~kind"] === "Object" || schema.type === "object") && !schema["~codec"] && !schema["~refine"] && !Array.isArray(schema.anyOf) && !Array.isArray(schema.allOf) && !Array.isArray(schema.oneOf) && schema.$ref === void 0 && schema.if === void 0 && schema.not === void 0)) return !hasDivergentDefaultBelow(schema);
+	if (depth > 0 && schema.default === void 0 && hasDefaultBelow(schema)) return false;
+	if (typeof schema.additionalProperties === "object" && subtreeHasDefault(schema.additionalProperties)) return false;
+	if (schema.patternProperties) {
+		for (const k in schema.patternProperties) if (subtreeHasDefault(schema.patternProperties[k])) return false;
+	}
+	if (schema.properties) {
+		for (const k in schema.properties) if (!structuralPreallocatable(schema.properties[k], depth + 1)) return false;
+	}
+	return true;
+}
+function emittableObjectKeys(v) {
+	if (Object.getOwnPropertySymbols(v).length) return;
+	const keys = Object.keys(v);
+	if (Object.getOwnPropertyNames(v).length !== keys.length) return;
+	for (const k of keys) {
+		const descriptor = Object.getOwnPropertyDescriptor(v, k);
+		if (!descriptor || descriptor.get || descriptor.set || !descriptor.enumerable) return;
+	}
+	return keys;
+}
+function isEmittable(v, seen, top = false) {
+	if (v === void 0) return top;
+	if (v === null) return true;
+	const t = typeof v;
+	if (t === "number") return Number.isFinite(v) && !Object.is(v, -0);
+	if (t === "string" || t === "boolean") return true;
+	if (t !== "object") return false;
+	if (seen.has(v)) return false;
+	seen.add(v);
+	let ok = true;
+	if (Array.isArray(v)) {
+		if (Object.getOwnPropertySymbols(v).length) ok = false;
+		for (const x of v) if (!isEmittable(x, seen)) {
+			ok = false;
+			break;
+		}
+	} else {
+		const proto = Object.getPrototypeOf(v);
+		if (proto !== Object.prototype && proto !== null) ok = false;
+		else {
+			const keys = emittableObjectKeys(v);
+			if (!keys) ok = false;
+			else for (const k of keys) {
+				if (dangerousKeys.has(k)) {
+					ok = false;
+					break;
+				}
+				if (!isEmittable(v[k], seen)) {
+					ok = false;
+					break;
+				}
+			}
+		}
+	}
+	seen.delete(v);
+	return ok;
+}
+function cloneExpression(v) {
+	if (v === void 0) return "undefined";
+	if (v === null) return "null";
+	const t = typeof v;
+	if (t === "number" || t === "string" || t === "boolean") return JSON.stringify(v);
+	if (t !== "object") return;
+	if (Array.isArray(v)) {
+		if (Object.getOwnPropertySymbols(v).length) return;
+		const values = [];
+		for (const x of v) {
+			const value = cloneExpression(x);
+			if (value === void 0) return;
+			values.push(value);
+		}
+		return "[" + values.join(",") + "]";
+	}
+	const proto = Object.getPrototypeOf(v);
+	if (proto !== Object.prototype && proto !== null) return;
+	const keys = emittableObjectKeys(v);
+	if (!keys) return;
+	const entries = [];
+	for (const k of keys) {
+		if (dangerousKeys.has(k)) return;
+		const value = cloneExpression(v[k]);
+		if (value === void 0) return;
+		entries.push(JSON.stringify(k) + ":" + value);
+	}
+	return "{" + entries.join(",") + "}";
+}
+function buildDefaultClonerSource(value) {
+	if (!isEmittable(value, /* @__PURE__ */ new Set(), true)) return;
+	const expression = cloneExpression(value);
+	if (expression === void 0) return;
+	return `function(){return ${expression}}`;
+}
+function buildObjectMergeFunction(defaults, helpers) {
+	const name = `_m${helpers.length}`;
+	helpers.push("");
+	const keys = Object.keys(defaults);
+	let body = "if(v===null||typeof v!=='object'||Array.isArray(v))return v;const out=Object.create(null);let x;";
+	for (const key of keys) {
+		const access = `v[${JSON.stringify(key)}]`;
+		const write = `out[${JSON.stringify(key)}]`;
+		const d = defaults[key];
+		const value = cloneExpression(d);
+		if (value === void 0) return;
+		body += `x=${access};`;
+		if (d !== null && typeof d === "object") {
+			if (Array.isArray(d)) {
+				body += `if(x===undefined)${write}=${value};else ${write}=x;`;
+				continue;
+			}
+			const nested = buildObjectMergeFunction(d, helpers);
+			if (!nested) return;
+			body += `if(x===undefined)${write}=${value};else if(x&&typeof x==='object'&&!Array.isArray(x))${write}=${nested}(x);else ${write}=x;`;
+		} else body += `${write}=x===undefined?${value}:x;`;
+	}
+	body += "for(const k in v){x=v[k];if(x!==undefined";
+	for (const key of keys) body += `&&k!==${JSON.stringify(key)}`;
+	body += ")out[k]=x}return out";
+	helpers[+name.slice(2)] = `function ${name}(v){${body}}`;
+	return name;
+}
+function buildObjectDefaultMergeSource(defaults) {
+	if (!isEmittable(defaults, /* @__PURE__ */ new Set(), true)) return;
+	const helpers = [];
+	const root = buildObjectMergeFunction(defaults, helpers);
+	if (!root) return;
+	return `(function(){${helpers.join(";")};return ${root}})()`;
+}
+function fromSource(source) {
+	try {
+		return Function(`return ${source}`)();
+	} catch {
+		return;
+	}
+}
+function createDefaultCloner(value) {
+	const source = buildDefaultClonerSource(value);
+	return source ? fromSource(source) : void 0;
+}
+function createObjectDefaultMerger(defaults) {
+	const source = buildObjectDefaultMergeSource(defaults);
+	return source ? fromSource(source) : void 0;
+}
+function createMergerFromSource(source) {
+	return fromSource(source);
+}
+function mergeCategory(node) {
+	if (!node || typeof node !== "object") return "identity";
+	if (!subtreeHasDefault(node)) return "identity";
+	if (node["~codec"] || node["~refine"]) return "bail";
+	const kind = node["~kind"];
+	if (kind === "Union" || kind === "Intersect" || kind === "Ref" || kind === "This" || kind === "Cyclic") return "bail";
+	if (kind === "Object" || node.type === "object") return "object";
+	if ((kind === "Array" || node.type === "array") && node.items) return !Array.isArray(node.items) && subtreeHasDefault(node.items) ? "array" : "identity";
+	return "identity";
+}
+function mergeExpression(schema, varName, helpers) {
+	const full = Default(schema, void 0);
+	const child = emitMerger(schema, helpers);
+	if (child === void 0) return;
+	const absent = full === void 0 ? void 0 : cloneExpression(full);
+	if (full !== void 0 && absent === void 0) return;
+	let present;
+	if (child === "") present = varName;
+	else present = mergeCategory(schema) === "object" ? `(${varName}!==null&&typeof ${varName}==='object'&&!Array.isArray(${varName})?${child}(${varName}):${varName})` : `(Array.isArray(${varName})?${child}(${varName}):${varName})`;
+	return {
+		absent,
+		present
+	};
+}
+function emitMerger(node, helpers) {
+	const category = mergeCategory(node);
+	if (category === "identity") return "";
+	if (category === "bail") return;
+	const name = `_d${helpers.length}`;
+	helpers.push("");
+	if (category === "object") {
+		const props = node.properties ?? {};
+		const handled = [];
+		let body = "if(v===null||typeof v!=='object'||Array.isArray(v))return v;const out=Object.create(null);let x;";
+		for (const key in props) {
+			if (!Object.hasOwn(props, key)) continue;
+			const ps = props[key];
+			if (!subtreeHasDefault(ps)) continue;
+			if (dangerousKeys.has(key)) return;
+			const expr = mergeExpression(ps, "x", helpers);
+			if (!expr) return;
+			handled.push(key);
+			const access = JSON.stringify(key);
+			body += `x=v[${access}];`;
+			body += expr.absent === void 0 ? `if(x!==undefined)out[${access}]=${expr.present};` : `out[${access}]=x===undefined?${expr.absent}:${expr.present};`;
+		}
+		if (!handled.length) {
+			helpers.pop();
+			return "";
+		}
+		body += "for(const k in v){x=v[k];if(x!==undefined";
+		for (const key of handled) body += `&&k!==${JSON.stringify(key)}`;
+		body += ")out[k]=x}return out";
+		helpers[+name.slice(2)] = `function ${name}(v){${body}}`;
+		return name;
+	}
+	const expr = mergeExpression(node.items, "e", helpers);
+	if (!expr) return;
+	if (expr.absent === void 0 && expr.present === "e") {
+		helpers.pop();
+		return "";
+	}
+	const assign = expr.absent === void 0 ? `e===undefined?undefined:${expr.present}` : `e===undefined?${expr.absent}:${expr.present}`;
+	helpers[+name.slice(2)] = `function ${name}(v){if(!Array.isArray(v))return v;const o=new Array(v.length);let e;for(let i=0;i<v.length;i++){e=v[i];o[i]=${assign}}return o}`;
+	return name;
+}
+function buildMergeSource(schema) {
+	const category = mergeCategory(schema);
+	if (category !== "object" && category !== "array") return;
+	const helpers = [];
+	const root = emitMerger(schema, helpers);
+	if (!root) return;
+	return `(function(){${helpers.join(";")};return ${root}})()`;
+}
+function emptyContainers(node, depth) {
+	if (depth <= 0 || !node || typeof node !== "object") return;
+	const kind = node["~kind"];
+	if (kind === "Object" || node.type === "object") {
+		const out = nullObject();
+		const props = node.properties ?? {};
+		for (const key in props) if (Object.hasOwn(props, key)) {
+			const child = emptyContainers(props[key], depth - 1);
+			if (child !== void 0) out[key] = child;
+		}
+		return out;
+	}
+	if ((kind === "Array" || node.type === "array") && node.items && !Array.isArray(node.items)) {
+		const element = emptyContainers(node.items, depth - 1);
+		return element === void 0 ? [] : [element];
+	}
+}
+function* mergeProbes(schema) {
+	yield {};
+	yield [];
+	const filled = emptyContainers(schema, 6);
+	if (filled !== void 0) yield filled;
+	const kind = schema["~kind"];
+	if (kind === "Object" || schema.type === "object") {
+		const props = schema.properties ?? {};
+		for (const key in props) if (Object.hasOwn(props, key)) {
+			yield { [key]: PROBE_SENTINEL };
+			const child = emptyContainers(props[key], 6);
+			if (child !== void 0) yield { [key]: child };
+		}
+	} else if ((kind === "Array" || schema.type === "array") && schema.items && !Array.isArray(schema.items)) {
+		yield [PROBE_SENTINEL];
+		const element = emptyContainers(schema.items, 6);
+		if (element !== void 0) yield [element, element];
+	}
+}
+function validateMergeSource(schema, source) {
+	const merger = fromSource(source);
+	if (!merger) return false;
+	for (const probe of mergeProbes(schema)) {
+		if (probe === null || typeof probe !== "object") continue;
+		let expected;
+		try {
+			expected = Default(schema, structuredClone(probe));
+		} catch {
+			return false;
+		}
+		let actual;
+		try {
+			actual = merger(structuredClone(probe));
+		} catch {
+			return false;
+		}
+		if (canonical(expected) !== canonical(actual)) return false;
+	}
+	return true;
+}
+const PROBE_SENTINEL = "__elysia_default_probe__";
+function* defaultProbes(pod) {
+	if (!pod) return;
+	yield {};
+	for (const k in pod) {
+		yield { [k]: PROBE_SENTINEL };
+		const d = pod[k];
+		if (d && typeof d === "object" && !Array.isArray(d)) {
+			yield { [k]: {} };
+			for (const k2 in d) {
+				yield { [k]: { [k2]: PROBE_SENTINEL } };
+				break;
+			}
+		}
+	}
+}
+function canonical(v) {
+	if (v === void 0) return "\0u";
+	if (Object.is(v, -0)) return "-0";
+	if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "\0u";
+	if (Array.isArray(v)) return "[" + v.map(canonical).join(",") + "]";
+	return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + canonical(v[k])).join(",") + "}";
+}
+function verifyPreallocatableDefault(schema, validate = true) {
+	if (hasUnemittableDefaultValue(schema)) return;
+	let pd;
+	let podRaw;
+	try {
+		pd = Default(schema, void 0);
+		podRaw = Default(schema, nullObject());
+	} catch {
+		return;
+	}
+	const s = schema;
+	const rootIsObject = s.type === "object" || s["~kind"] === "Object";
+	const pod = rootIsObject && podRaw && typeof podRaw === "object" && !Array.isArray(podRaw) ? podRaw : void 0;
+	if (containsRefLike(schema)) return;
+	if (!isEmittable(pd, /* @__PURE__ */ new Set(), true) || pod !== void 0 && !isEmittable(pod, /* @__PURE__ */ new Set(), true)) return;
+	const nullDefault = isPrecomputeSafe(schema);
+	let ms = buildMergeSource(schema);
+	if (ms !== void 0 && validate && !validateMergeSource(schema, ms)) ms = void 0;
+	if (!nullDefault && ms === void 0) {
+		if (!rootIsObject) return;
+		if (!structuralPreallocatable(schema)) return;
+		if (validate) for (const probe of defaultProbes(pod)) {
+			let expected;
+			try {
+				expected = Default(schema, structuredClone(probe));
+			} catch {
+				return;
+			}
+			const actual = applyPrecomputed(pod, structuredClone(probe));
+			if (canonical(expected) !== canonical(actual)) return;
+		}
+	}
+	return {
+		pd,
+		pn: nullDefault,
+		pod,
+		ms
+	};
+}
+
+//#endregion
+export { applyPrecomputed, buildDefaultClonerSource, buildMergeSource, buildObjectDefaultMergeSource, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, isEmittable, isPrecomputeSafe, verifyPreallocatableDefault };

package/dist/type/validator/frozen-check.d.ts

@@ -0,0 +1,11 @@
+import { CheckBuildResult } from "../../compile/aot.js";
+
+//#region src/type/validator/frozen-check.d.ts
+declare function buildFrozenCheck(build: CheckBuildResult | undefined, node: any): {
+  identifier: string;
+  checkDefs: string;
+  checkValue: string;
+  external: boolean;
+} | undefined;
+//#endregion
+export { buildFrozenCheck };

package/dist/type/validator/frozen-check.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_compile_aot = require('../../compile/aot.js');
+
+//#region src/type/validator/frozen-check.ts
+function buildFrozenCheck(build, node) {
+	if (!build?.functions?.length || !build.entry) return;
+	const vars = build.external.variables;
+	if (!require_compile_aot.externalsMatch(require_compile_aot.collectExternals(node), vars)) return;
+	const cr = require_compile_aot.reconstructCheck(build);
+	return {
+		identifier: build.external.identifier,
+		checkDefs: cr.defs,
+		checkValue: cr.value,
+		external: vars.length > 0
+	};
+}
+
+//#endregion
+exports.buildFrozenCheck = buildFrozenCheck;

package/dist/type/validator/frozen-check.mjs

@@ -0,0 +1,18 @@
+import { collectExternals, externalsMatch, reconstructCheck } from "../../compile/aot.mjs";
+
+//#region src/type/validator/frozen-check.ts
+function buildFrozenCheck(build, node) {
+	if (!build?.functions?.length || !build.entry) return;
+	const vars = build.external.variables;
+	if (!externalsMatch(collectExternals(node), vars)) return;
+	const cr = reconstructCheck(build);
+	return {
+		identifier: build.external.identifier,
+		checkDefs: cr.defs,
+		checkValue: cr.value,
+		external: vars.length > 0
+	};
+}
+
+//#endregion
+export { buildFrozenCheck };

package/dist/type/{validator.d.ts → validator/index.d.ts}

@@ -1,12 +1,12 @@
-import { MaybePromise } from "../types.js";
-import { CoerceOption } from "./coerce.js";
-import { Validator as Validator$1, ValidatorOptions } from "../validator/index.js";
+import { MaybePromise } from "../../types.js";
+import { Validator as Validator$1, ValidatorOptions } from "../../validator/index.js";
+import { TypeBoxValidatorCache } from "./validator-cache.js";
 import { Static, StaticDecode, StaticEncode, TAny, TSchema } from "typebox/type";
-import * as _$typebox_schema0 from "typebox/schema";
-import { Validator } from "typebox/schema";
 import { TLocalizedValidationError } from "typebox/error";
+import { Validator } from "typebox/schema";
 
-//#region src/type/validator.d.ts
+//#region src/type/validator/index.d.ts
+declare function shallowMergeObjects(members: any[]): TSchema | null;
 declare class TypeBoxValidator<const in out T extends TSchema = TAny> extends Validator$1 {
   #private;
   tb?: Validator;
@@ -27,18 +27,5 @@ declare class TypeBoxValidator<const in out T extends TSchema = TAny> extends Va
   FromAsync(value: Static<T>, type?: string): Promise<Static<T>>;
   FromSync(value: Static<T>, type?: string): Static<T>;
 }
-declare class TypeBoxValidatorCache {
-  #private;
-  private static EMPTY;
-  private static ignoreKeys;
-  private static fnIds;
-  private static nextFnId;
-  private static fnKey;
-  static ignoreMeta(k: string, v: unknown): any;
-  constructor(gcTime: number);
-  get(schema: TSchema, coercions?: CoerceOption[] | typeof TypeBoxValidatorCache.EMPTY, normalize?: string): Validator<_$typebox_schema0.XSchema, unknown> | undefined;
-  set(schema: TSchema, coercions?: CoerceOption[] | typeof TypeBoxValidatorCache.EMPTY, validator?: Validator, normalize?: string): void;
-  clear(): void;
-}
 //#endregion
-export { TypeBoxValidator, TypeBoxValidatorCache };
+export { TypeBoxValidator, TypeBoxValidatorCache, shallowMergeObjects };