@atscript/typescript 0.0.27 → 0.0.28

package/dist/cli.cjs

@@ -29,7 +29,7 @@ const __atscript_core = __toESM(require("@atscript/core"));
 const fs = __toESM(require("fs"));
 
 //#region packages/typescript/src/codegen/code-printer.ts
-function _define_property$3(obj, key, value) {
+function _define_property$5(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -122,17 +122,17 @@ else this.write(closing);
 		return " ".repeat(this.indentLevel * this.indentSize);
 	}
 	constructor() {
-		_define_property$3(this, "lines", []);
-		_define_property$3(this, "currentLine", "");
-		_define_property$3(this, "indentLevel", 0);
-		_define_property$3(this, "indentSize", 2);
-		_define_property$3(this, "blockStack", []);
+		_define_property$5(this, "lines", []);
+		_define_property$5(this, "currentLine", "");
+		_define_property$5(this, "indentLevel", 0);
+		_define_property$5(this, "indentSize", 2);
+		_define_property$5(this, "blockStack", []);
 	}
 };
 
 //#endregion
 //#region packages/typescript/src/codegen/base-renderer.ts
-function _define_property$2(obj, key, value) {
+function _define_property$4(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -191,7 +191,7 @@ var BaseRenderer = class extends CodePrinter {
 		}
 	}
 	constructor(doc) {
-		super(), _define_property$2(this, "doc", void 0), _define_property$2(this, "unused", void 0), this.doc = doc;
+		super(), _define_property$4(this, "doc", void 0), _define_property$4(this, "unused", void 0), this.doc = doc;
 		this.unused = new Set(this.doc.getUnusedTokens().map((t) => t.text));
 	}
 };
@@ -209,6 +209,16 @@ function escapeQuotes(str) {
 
 //#endregion
 //#region packages/typescript/src/codegen/type-renderer.ts
+function _define_property$3(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
 var TypeRenderer = class extends BaseRenderer {
 	pre() {
 		this.writeln("// prettier-ignore-start");
@@ -306,6 +316,7 @@ else if (patterns.length === 1) {
 			this.writeln(`static type: TAtscriptTypeObject<keyof ${asClass}>`);
 			this.writeln(`static metadata: TMetadataMap<AtscriptMetadata>`);
 			this.writeln(`static validator: <TT extends TAtscriptAnnotatedTypeConstructor = ${asClass}>(opts?: Partial<TValidatorOptions>) => Validator<TT>`);
+			this.writeln("static toJsonSchema: () => any");
 		}
 		this.pop();
 	}
@@ -348,6 +359,7 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = "TAtscriptTypeFina
 		this.writeln(`const type: ${typeDef}`);
 		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
 		this.writeln(`const validator: <TT extends TAtscriptAnnotatedTypeConstructor = ${node.id}>(opts?: Partial<TValidatorOptions>) => Validator<TT>`);
+		if (this.opts?.jsonSchema) this.writeln("const toJsonSchema: () => any");
 		this.popln();
 	}
 	renderJsDoc(node) {
@@ -358,6 +370,9 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = "TAtscriptTypeFina
 		this.writeln(` * @see {@link ./${this.doc.name}${rangeStr}}`);
 		this.writeln(` */`);
 	}
+	constructor(doc, opts) {
+		super(doc), _define_property$3(this, "opts", void 0), this.opts = opts;
+	}
 };
 function renderPrimitiveTypeDef(def) {
 	if (!def) return "unknown";
@@ -376,6 +391,537 @@ function renderPrimitiveTypeDef(def) {
 	}
 }
 
+//#endregion
+//#region packages/typescript/src/validator.ts
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const regexCache = new Map();
+var Validator = class {
+	isLimitExceeded() {
+		if (this.stackErrors.length > 0) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		return this.errors.length >= this.opts.errorLimit;
+	}
+	push(name) {
+		this.stackPath.push(name);
+		this.stackErrors.push([]);
+	}
+	pop(saveErrors) {
+		this.stackPath.pop();
+		const popped = this.stackErrors.pop();
+		if (saveErrors && popped?.length) popped.forEach((error) => {
+			this.error(error.message, error.path, error.details);
+		});
+		return popped;
+	}
+	clear() {
+		this.stackErrors[this.stackErrors.length - 1] = [];
+	}
+	error(message, path$3, details) {
+		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		const error = {
+			path: path$3 || this.path,
+			message
+		};
+		if (details?.length) error.details = details;
+		errors.push(error);
+	}
+	throw() {
+		throw new ValidatorError(this.errors);
+	}
+	validate(value, safe) {
+		this.push("");
+		this.errors = [];
+		this.stackErrors = [];
+		const passed = this.validateSafe(this.def, value);
+		this.pop(!passed);
+		if (!passed) {
+			if (safe) return false;
+			this.throw();
+		}
+		return true;
+	}
+	validateSafe(def, value) {
+		if (this.isLimitExceeded()) return false;
+		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
+		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.path);
+		if (def.optional && value === undefined) return true;
+		for (const plugin of this.opts.plugins) {
+			const result = plugin(this, def, value);
+			if (result === false || result === true) return result;
+		}
+		return this.validateAnnotatedType(def, value);
+	}
+	get path() {
+		return this.stackPath.slice(1).join(".");
+	}
+	validateAnnotatedType(def, value) {
+		switch (def.type.kind) {
+			case "object": return this.validateObject(def, value);
+			case "union": return this.validateUnion(def, value);
+			case "intersection": return this.validateIntersection(def, value);
+			case "tuple": return this.validateTuple(def, value);
+			case "array": return this.validateArray(def, value);
+			case "": return this.validatePrimitive(def, value);
+			default: throw new Error(`Unknown type "${def.type.kind}"`);
+		}
+	}
+	validateUnion(def, value) {
+		let i = 0;
+		const popped = [];
+		for (const item of def.type.items) {
+			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
+			if (this.validateSafe(item, value)) {
+				this.pop(false);
+				return true;
+			}
+			const errors = this.pop(false);
+			if (errors) popped.push(...errors);
+			i++;
+		}
+		this.clear();
+		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
+		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
+		return false;
+	}
+	validateIntersection(def, value) {
+		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
+		return true;
+	}
+	validateTuple(def, value) {
+		if (!Array.isArray(value) || value.length !== def.type.items.length) {
+			this.error("Expected array of length " + def.type.items.length);
+			return false;
+		}
+		let i = 0;
+		for (const item of def.type.items) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(item, value[i])) {
+				this.pop(true);
+				return false;
+			}
+			this.pop(false);
+			i++;
+		}
+		return true;
+	}
+	validateArray(def, value) {
+		if (!Array.isArray(value)) {
+			this.error("Expected array");
+			return false;
+		}
+		const minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} items, got ${value.length} items`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} items, got ${value.length} items`);
+			return false;
+		}
+		let i = 0;
+		let passed = true;
+		for (const item of value) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(def.type.of, item)) {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			} else this.pop(false);
+			i++;
+		}
+		return passed;
+	}
+	validateObject(def, value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			this.error("Expected object");
+			return false;
+		}
+		let passed = true;
+		const valueKeys = new Set(Object.keys(value));
+		const typeKeys = new Set();
+		const skipList = new Set();
+		if (this.opts.skipList) {
+			const path$3 = this.stackPath.length > 1 ? this.path + "." : "";
+			this.opts.skipList.forEach((item) => {
+				if (item.startsWith(path$3)) {
+					const key = item.slice(path$3.length);
+					skipList.add(key);
+					valueKeys.delete(key);
+				}
+			});
+		}
+		let partialFunctionMatched = false;
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.path);
+		for (const [key, item] of def.type.props.entries()) {
+			if (skipList.has(key)) continue;
+			typeKeys.add(key);
+			if (value[key] === undefined) {
+				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
+			}
+			this.push(key);
+			if (this.validateSafe(item, value[key])) this.pop(false);
+else {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			}
+		}
+		for (const key of valueKeys)
+ /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
+			const matched = [];
+			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
+				pattern,
+				def: propDef
+			});
+			if (matched.length) {
+				let keyPassed = false;
+				for (const { def: def$1 } of matched) if (this.validateSafe(def$1, value[key])) {
+					this.pop(false);
+					keyPassed = true;
+					break;
+				}
+				if (!keyPassed) {
+					this.push(key);
+					this.validateSafe(matched[0].def, value[key]);
+					this.pop(true);
+					passed = false;
+					if (this.isLimitExceeded()) return false;
+				}
+			} else if (this.opts.unknwonProps !== "ignore") {
+				if (this.opts.unknwonProps === "error") {
+					this.push(key);
+					this.error(`Unexpected property`);
+					this.pop(true);
+					if (this.isLimitExceeded()) return false;
+					passed = false;
+				} else if (this.opts.unknwonProps === "strip") delete value[key];
+			}
+		}
+		return passed;
+	}
+	validatePrimitive(def, value) {
+		if (typeof def.type.value !== "undefined") {
+			if (value !== def.type.value) {
+				this.error(`Expected ${def.type.value}, got ${value}`);
+				return false;
+			}
+			return true;
+		}
+		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
+		switch (def.type.designType) {
+			case "never":
+				this.error(`This type is impossible, must be an internal problem`);
+				return false;
+			case "any": return true;
+			case "string":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateString(def, value);
+			case "number":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateNumber(def, value);
+			case "boolean":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "undefined":
+				if (value !== undefined) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "null":
+				if (value !== null) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			default: throw new Error(`Unknown type "${def.type.designType}"`);
+		}
+	}
+	validateString(def, value) {
+		const minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const patterns = def.metadata.get("expect.pattern");
+		for (const { pattern, flags, message } of patterns || []) {
+			if (!pattern) continue;
+			const cacheKey = `${pattern}//${flags || ""}`;
+			let regex = regexCache.get(cacheKey);
+			if (!regex) {
+				regex = new RegExp(pattern, flags);
+				regexCache.set(cacheKey, regex);
+			}
+			if (!regex.test(value)) {
+				this.error(message || `Value is expected to match pattern "${pattern}"`);
+				return false;
+			}
+		}
+		return true;
+	}
+	validateNumber(def, value) {
+		const int = def.metadata.get("expect.int");
+		if (typeof int === "boolean" && int && value % 1 !== 0) {
+			this.error(`Expected integer, got ${value}`);
+			return false;
+		}
+		const min = def.metadata.get("expect.min");
+		if (typeof min === "number" && value < min) {
+			this.error(`Expected minimum ${min}, got ${value}`);
+			return false;
+		}
+		const max = def.metadata.get("expect.max");
+		if (typeof max === "number" && value > max) {
+			this.error(`Expected maximum ${max}, got ${value}`);
+			return false;
+		}
+		return true;
+	}
+	constructor(def, opts) {
+		_define_property$2(this, "def", void 0);
+		_define_property$2(this, "opts", void 0);
+		_define_property$2(this, "errors", void 0);
+		_define_property$2(this, "stackErrors", void 0);
+		_define_property$2(this, "stackPath", void 0);
+		this.def = def;
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [];
+		this.opts = {
+			partial: false,
+			unknwonProps: "error",
+			errorLimit: 10,
+			...opts,
+			plugins: opts?.plugins || []
+		};
+	}
+};
+var ValidatorError = class extends Error {
+	constructor(errors) {
+		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property$2(this, "errors", void 0), _define_property$2(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/annotated-type.ts
+function isAnnotatedType(type) {
+	return type && type.__is_atscript_annotated_type;
+}
+function defineAnnotatedType(_kind, base) {
+	const kind = _kind || "";
+	const type = base?.type || {};
+	type.kind = kind;
+	if ([
+		"union",
+		"intersection",
+		"tuple"
+	].includes(kind)) type.items = [];
+	if (kind === "object") {
+		type.props = new Map();
+		type.propsPatterns = [];
+	}
+	type.tags = new Set();
+	const metadata = base?.metadata || new Map();
+	if (base) Object.assign(base, {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	});
+else base = {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	};
+	const handle = {
+		$type: base,
+		$def: type,
+		$metadata: metadata,
+		_existingObject: undefined,
+		tags(...tags) {
+			for (const tag of tags) this.$def.tags.add(tag);
+			return this;
+		},
+		designType(value) {
+			this.$def.designType = value;
+			return this;
+		},
+		value(value) {
+			this.$def.value = value;
+			return this;
+		},
+		of(value) {
+			this.$def.of = value;
+			return this;
+		},
+		item(value) {
+			this.$def.items.push(value);
+			return this;
+		},
+		prop(name, value) {
+			this.$def.props.set(name, value);
+			return this;
+		},
+		propPattern(pattern, def) {
+			this.$def.propsPatterns.push({
+				pattern,
+				def
+			});
+			return this;
+		},
+		optional(value = true) {
+			this.$type.optional = value;
+			return this;
+		},
+		copyMetadata(fromMetadata, ignore) {
+			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
+			return this;
+		},
+		refTo(type$1, chain) {
+			let newBase = type$1;
+			const typeName = type$1.name || "Unknown";
+			if (isAnnotatedType(newBase)) {
+				let keys = "";
+				for (const c of chain || []) {
+					keys += `["${c}"]`;
+					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
+else throw new Error(`Can't find prop ${typeName}${keys}`);
+				}
+				if (!newBase && keys) throw new Error(`Can't find prop ${typeName}${keys}`);
+else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
+				this.$type = {
+					__is_atscript_annotated_type: true,
+					type: newBase.type,
+					metadata,
+					validator(opts) {
+						return new Validator(this, opts);
+					}
+				};
+			} else throw new Error(`${type$1} is not annotated type`);
+			return this;
+		},
+		annotate(key, value, asArray) {
+			if (asArray) if (this.$metadata.has(key)) {
+				const a = this.$metadata.get(key);
+				if (Array.isArray(a)) a.push(value);
+else this.$metadata.set(key, [a, value]);
+			} else this.$metadata.set(key, [value]);
+else this.$metadata.set(key, value);
+			return this;
+		}
+	};
+	return handle;
+}
+
+//#endregion
+//#region packages/typescript/src/json-schema.ts
+function buildJsonSchema(type) {
+	const build$1 = (def) => {
+		const t = def.type;
+		const meta = def.metadata;
+		switch (t.kind) {
+			case "object": {
+				const obj = t;
+				const properties = {};
+				const required = [];
+				for (const [key, val] of obj.props.entries()) {
+					properties[key] = build$1(val);
+					if (!val.optional) required.push(key);
+				}
+				const schema = {
+					type: "object",
+					properties
+				};
+				if (required.length) schema.required = required;
+				return schema;
+			}
+			case "array": {
+				const arr = t;
+				const schema = {
+					type: "array",
+					items: build$1(arr.of)
+				};
+				const minLength = meta.get("expect.minLength");
+				if (typeof minLength === "number") schema.minItems = minLength;
+				const maxLength = meta.get("expect.maxLength");
+				if (typeof maxLength === "number") schema.maxItems = maxLength;
+				return schema;
+			}
+			case "union": {
+				const grp = t;
+				return { anyOf: grp.items.map(build$1) };
+			}
+			case "intersection": {
+				const grp = t;
+				return { allOf: grp.items.map(build$1) };
+			}
+			case "tuple": {
+				const grp = t;
+				return {
+					type: "array",
+					items: grp.items.map(build$1),
+					additionalItems: false
+				};
+			}
+			case "": {
+				const fin = t;
+				const schema = {};
+				if (fin.value !== undefined) schema.const = fin.value;
+				if (fin.designType && fin.designType !== "any") {
+					schema.type = fin.designType === "undefined" ? "null" : fin.designType;
+					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
+				}
+				if (schema.type === "string") {
+					const minLength = meta.get("expect.minLength");
+					if (typeof minLength === "number") schema.minLength = minLength;
+					const maxLength = meta.get("expect.maxLength");
+					if (typeof maxLength === "number") schema.maxLength = maxLength;
+					const patterns = meta.get("expect.pattern");
+					if (patterns?.length) if (patterns.length === 1) schema.pattern = patterns[0].pattern;
+else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
+				}
+				if (schema.type === "number" || schema.type === "integer") {
+					const min = meta.get("expect.min");
+					if (typeof min === "number") schema.minimum = min;
+					const max = meta.get("expect.max");
+					if (typeof max === "number") schema.maximum = max;
+				}
+				return schema;
+			}
+			default: return {};
+		}
+	};
+	return build$1(type);
+}
+
 //#endregion
 //#region packages/typescript/src/codegen/js-renderer.ts
 function _define_property$1(obj, key, value) {
@@ -392,7 +938,9 @@ var JsRenderer = class extends BaseRenderer {
 	pre() {
 		this.writeln("// prettier-ignore-start");
 		this.writeln("/* eslint-disable */");
-		this.writeln("import { defineAnnotatedType as $ } from \"@atscript/typescript\"");
+		const imports = ["defineAnnotatedType as $"];
+		if (!this.opts?.preRenderJsonSchema) imports.push("buildJsonSchema as $$");
+		this.writeln(`import { ${imports.join(", ")} } from "@atscript/typescript"`);
 	}
 	post() {
 		for (const node of this.postAnnotate) {
@@ -412,6 +960,18 @@ var JsRenderer = class extends BaseRenderer {
 		this.writeln("static __is_atscript_annotated_type = true");
 		this.writeln("static type = {}");
 		this.writeln("static metadata = new Map()");
+		if (this.opts?.preRenderJsonSchema) {
+			const schema = JSON.stringify(buildJsonSchema(this.toAnnotatedType(node)));
+			this.writeln(`static _jsonSchema = ${schema}`);
+			this.writeln("static toJsonSchema() {");
+			this.indent().writeln("return this._jsonSchema").unindent();
+			this.writeln("}");
+		} else {
+			this.writeln("static _jsonSchema");
+			this.writeln("static toJsonSchema() {");
+			this.indent().writeln("return this._jsonSchema ?? (this._jsonSchema = $$(this))").unindent();
+			this.writeln("}");
+		}
 		this.popln();
 		this.postAnnotate.push(node);
 		this.writeln();
@@ -425,10 +985,125 @@ var JsRenderer = class extends BaseRenderer {
 		this.writeln("static __is_atscript_annotated_type = true");
 		this.writeln("static type = {}");
 		this.writeln("static metadata = new Map()");
+		if (this.opts?.jsonSchema) if (typeof this.opts.jsonSchema === "object" && this.opts.jsonSchema.preRender) {
+			const schema = JSON.stringify(buildJsonSchema(this.toAnnotatedType(node)));
+			this.writeln(`static _jsonSchema = ${schema}`);
+			this.writeln("static toJsonSchema() {");
+			this.indent().writeln("return this._jsonSchema").unindent();
+			this.writeln("}");
+		} else {
+			this.writeln("static _jsonSchema");
+			this.writeln("static toJsonSchema() {");
+			this.indent().writeln("return this._jsonSchema ?? (this._jsonSchema = $$(this))").unindent();
+			this.writeln("}");
+		}
 		this.popln();
 		this.postAnnotate.push(node);
 		this.writeln();
 	}
+	toAnnotatedType(node) {
+		return this.toAnnotatedHandle(node).$type;
+	}
+	toAnnotatedHandle(node, skipAnnotations = false) {
+		if (!node) return defineAnnotatedType();
+		switch (node.entity) {
+			case "interface":
+			case "type": {
+				const def = node.getDefinition();
+				const handle = this.toAnnotatedHandle(def, true);
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			case "prop": {
+				const prop = node;
+				const def = prop.getDefinition();
+				const handle = this.toAnnotatedHandle(def, true);
+				if (!skipAnnotations) {
+					this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(prop));
+					if (prop.token("optional")) handle.optional();
+				}
+				return handle;
+			}
+			case "ref": {
+				const ref = node;
+				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
+				const handle = this.toAnnotatedHandle(decl, true);
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			case "primitive": {
+				const prim = node;
+				const handle = defineAnnotatedType();
+				handle.designType(prim.id === "never" ? "never" : prim.config.type);
+				if (!skipAnnotations) this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+				return handle;
+			}
+			case "const": {
+				const c = node;
+				const handle = defineAnnotatedType();
+				const t = c.token("identifier")?.type;
+				handle.designType(t === "number" ? "number" : "string");
+				handle.value(t === "number" ? Number(c.id) : c.id);
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			case "structure": {
+				const struct = node;
+				const handle = defineAnnotatedType("object");
+				for (const prop of Array.from(struct.props.values())) {
+					const propHandle = this.toAnnotatedHandle(prop);
+					const pattern = prop.token("identifier")?.pattern;
+					if (pattern) handle.propPattern(pattern, propHandle.$type);
+else handle.prop(prop.id, propHandle.$type);
+				}
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			case "group": {
+				const group = node;
+				const kind = group.op === "|" ? "union" : "intersection";
+				const handle = defineAnnotatedType(kind);
+				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			case "tuple": {
+				const group = node;
+				const handle = defineAnnotatedType("tuple");
+				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			case "array": {
+				const arr = node;
+				const handle = defineAnnotatedType("array");
+				handle.of(this.toAnnotatedHandle(arr.getDefinition()).$type);
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+			default: {
+				const handle = defineAnnotatedType();
+				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
+			}
+		}
+	}
+	applyExpectAnnotations(handle, annotations) {
+		annotations?.forEach((a) => {
+			switch (a.name) {
+				case "expect.minLength":
+				case "expect.maxLength":
+				case "expect.min":
+				case "expect.max":
+					if (a.args[0]) handle.annotate(a.name, Number(a.args[0].text));
+					break;
+				case "expect.pattern":
+					handle.annotate(a.name, {
+						pattern: a.args[0]?.text || "",
+						flags: a.args[1]?.text,
+						message: a.args[2]?.text
+					}, true);
+					break;
+				case "expect.int":
+					handle.annotate(a.name, true);
+					break;
+				default:
+			}
+		});
+		return handle;
+	}
 	annotateType(_node, name) {
 		if (!_node) return this;
 		const node = this.doc.mergeIntersection(_node);
@@ -479,7 +1154,6 @@ var JsRenderer = class extends BaseRenderer {
 	defineConst(node) {
 		const t = node.token("identifier")?.type;
 		const designType = t === "text" ? "string" : t === "number" ? "number" : "unknown";
-		const type = t === "text" ? "String" : t === "number" ? "Number" : "undefined";
 		this.writeln(`.designType("${escapeQuotes(designType)}")`);
 		this.writeln(`.value(${t === "text" ? `"${escapeQuotes(node.id)}"` : node.id})`);
 		return this;
@@ -619,24 +1293,24 @@ else targetValue = "true";
 		if (multiple) this.writeln(`.annotate("${escapeQuotes(an.name)}", ${targetValue}, true)`);
 else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${targetValue})`);
 	}
-	constructor(...args) {
-		super(...args), _define_property$1(this, "postAnnotate", []);
+	constructor(doc, opts) {
+		super(doc), _define_property$1(this, "opts", void 0), _define_property$1(this, "postAnnotate", void 0), this.opts = opts, this.postAnnotate = [];
 	}
 };
 
 //#endregion
 //#region packages/typescript/src/plugin.ts
-const tsPlugin = () => {
+const tsPlugin = (opts) => {
 	return {
 		name: "typesccript",
 		render(doc, format) {
 			if (format === "dts") return [{
 				fileName: `${doc.name}.d.ts`,
-				content: new TypeRenderer(doc).render()
+				content: new TypeRenderer(doc, opts).render()
 			}];
 			if (format === "js") return [{
 				fileName: `${doc.name}.js`,
-				content: new JsRenderer(doc).render()
+				content: new JsRenderer(doc, opts).render()
 			}];
 		},
 		async buildEnd(output, format, repo) {