@atscript/typescript 0.1.31 → 0.1.33

package/dist/utils.mjs

@@ -1,22 +1,4 @@
 
-//#region packages/typescript/src/traverse.ts
-function forAnnotatedType(def, handlers) {
-	switch (def.type.kind) {
-		case "": {
-			const typed = def;
-			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
-			return handlers.final(typed);
-		}
-		case "object": return handlers.object(def);
-		case "array": return handlers.array(def);
-		case "union": return handlers.union(def);
-		case "intersection": return handlers.intersection(def);
-		case "tuple": return handlers.tuple(def);
-		default: throw new Error(`Unknown type kind "${def.type.kind}"`);
-	}
-}
-
-//#endregion
 //#region packages/typescript/src/validator.ts
 function _define_property(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
@@ -31,28 +13,35 @@ else obj[key] = value;
 const regexCache = new Map();
 var Validator = class {
 	isLimitExceeded() {
-		if (this.stackErrors.length > 0) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		if (this.stackErrors.length > 0) {
+			const top = this.stackErrors[this.stackErrors.length - 1];
+			return top !== null && top.length >= this.opts.errorLimit;
+		}
 		return this.errors.length >= this.opts.errorLimit;
 	}
 	push(name) {
 		this.stackPath.push(name);
-		this.stackErrors.push([]);
+		this.stackErrors.push(null);
+		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
 	}
 	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);
-		});
+		if (saveErrors && popped !== null && popped !== undefined && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
+		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
 		return popped;
 	}
 	clear() {
-		this.stackErrors[this.stackErrors.length - 1] = [];
+		this.stackErrors[this.stackErrors.length - 1] = null;
 	}
 	error(message, path, details) {
-		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		let errors = this.stackErrors[this.stackErrors.length - 1];
+		if (!errors) if (this.stackErrors.length > 0) {
+			errors = [];
+			this.stackErrors[this.stackErrors.length - 1] = errors;
+		} else errors = this.errors;
 		const error = {
-			path: path || this.path,
+			path: path || this.cachedPath,
 			message
 		};
 		if (details?.length) error.details = details;
@@ -72,9 +61,10 @@ var Validator = class {
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
 	*/ validate(value, safe, context) {
-		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.stackPath = [""];
+		this.cachedPath = "";
 		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
@@ -88,7 +78,7 @@ var Validator = class {
 	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 (typeof this.opts.replace === "function") def = this.opts.replace(def, this.cachedPath);
 		if (def.optional && value === undefined) return true;
 		for (const plugin of this.opts.plugins) {
 			const result = plugin(this, def, value);
@@ -97,18 +87,21 @@ var Validator = class {
 		return this.validateAnnotatedType(def, value);
 	}
 	get path() {
-		return this.stackPath.slice(1).join(".");
+		return this.cachedPath;
 	}
 	validateAnnotatedType(def, value) {
-		return forAnnotatedType(def, {
-			final: (d) => this.validatePrimitive(d, value),
-			phantom: () => true,
-			object: (d) => this.validateObject(d, value),
-			array: (d) => this.validateArray(d, value),
-			union: (d) => this.validateUnion(d, value),
-			intersection: (d) => this.validateIntersection(d, value),
-			tuple: (d) => this.validateTuple(d, value)
-		});
+		switch (def.type.kind) {
+			case "": {
+				if (def.type.designType === "phantom") return true;
+				return this.validatePrimitive(def, value);
+			}
+			case "object": return this.validateObject(def, value);
+			case "array": return this.validateArray(def, value);
+			case "union": return this.validateUnion(def, value);
+			case "intersection": return this.validateIntersection(def, value);
+			case "tuple": return this.validateTuple(def, value);
+			default: throw new Error(`Unknown type kind "${def.type.kind}"`);
+		}
 	}
 	validateUnion(def, value) {
 		let i = 0;
@@ -172,6 +165,30 @@ var Validator = class {
 				return false;
 			}
 		}
+		const uniqueItems = def.metadata.get("expect.array.uniqueItems");
+		if (uniqueItems) {
+			const separator = "▼↩";
+			const seen = new Set();
+			const keyProps = new Set();
+			if (def.type.of.type.kind === "object") {
+				for (const [key, val] of def.type.of.type.props.entries()) if (val.metadata.get("expect.array.key")) keyProps.add(key);
+			}
+			for (let idx = 0; idx < value.length; idx++) {
+				const item = value[idx];
+				let key;
+				if (keyProps.size > 0) {
+					key = "";
+					for (const prop of keyProps) key += JSON.stringify(item[prop]) + separator;
+				} else key = JSON.stringify(item);
+				if (seen.has(key)) {
+					this.push(String(idx));
+					this.error(uniqueItems.message || "Duplicate items are not allowed");
+					this.pop(true);
+					return false;
+				}
+				seen.add(key);
+			}
+		}
 		let i = 0;
 		let passed = true;
 		for (const item of value) {
@@ -193,21 +210,20 @@ var Validator = class {
 		let passed = true;
 		const valueKeys = new Set(Object.keys(value));
 		const typeKeys = new Set();
-		const skipList = new Set();
+		let skipList;
 		if (this.opts.skipList) {
-			const path = this.stackPath.length > 1 ? `${this.path}.` : "";
-			this.opts.skipList.forEach((item) => {
-				if (item.startsWith(path)) {
-					const key = item.slice(path.length);
-					skipList.add(key);
-					valueKeys.delete(key);
-				}
-			});
+			const path = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
+			for (const item of this.opts.skipList) if (item.startsWith(path)) {
+				const key = item.slice(path.length);
+				if (!skipList) skipList = new Set();
+				skipList.add(key);
+				valueKeys.delete(key);
+			}
 		}
 		let partialFunctionMatched = false;
-		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.path);
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.cachedPath);
 		for (const [key, item] of def.type.props.entries()) {
-			if (skipList.has(key) || isPhantomType(item)) continue;
+			if (skipList && skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -228,19 +244,21 @@ else {
 				def: propDef
 			});
 			if (matched.length > 0) {
+				this.push(key);
 				let keyPassed = false;
-				for (const { def: def$1 } of matched) if (this.validateSafe(def$1, value[key])) {
-					this.pop(false);
-					keyPassed = true;
-					break;
+				for (const { def: propDef } of matched) {
+					if (this.validateSafe(propDef, value[key])) {
+						keyPassed = true;
+						break;
+					}
+					this.clear();
 				}
 				if (!keyPassed) {
-					this.push(key);
 					this.validateSafe(matched[0].def, value[key]);
 					this.pop(true);
 					passed = false;
 					if (this.isLimitExceeded()) return false;
-				}
+				} else this.pop(false);
 			} else if (this.opts.unknownProps !== "ignore") {
 				if (this.opts.unknownProps === "error") {
 					this.push(key);
@@ -393,11 +411,13 @@ else {
 		/** Validation errors collected during the last {@link validate} call. */ _define_property(this, "errors", void 0);
 		_define_property(this, "stackErrors", void 0);
 		_define_property(this, "stackPath", void 0);
+		_define_property(this, "cachedPath", void 0);
 		_define_property(this, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];
 		this.stackPath = [];
+		this.cachedPath = "";
 		this.opts = {
 			partial: false,
 			unknownProps: "error",
@@ -415,6 +435,25 @@ var ValidatorError = class extends Error {
 
 //#endregion
 //#region packages/typescript/src/annotated-type.ts
+const COMPLEX_KINDS = new Set([
+	"union",
+	"intersection",
+	"tuple"
+]);
+const NON_PRIMITIVE_KINDS = new Set(["array", "object"]);
+/** Shared validator method reused by all annotated type nodes. */ function validatorMethod(opts) {
+	return new Validator(this, opts);
+}
+function createAnnotatedTypeNode(type, metadata, opts) {
+	return {
+		__is_atscript_annotated_type: true,
+		type,
+		metadata,
+		validator: validatorMethod,
+		id: opts?.id,
+		optional: opts?.optional
+	};
+}
 function isAnnotatedType(type) {
 	return type && type.__is_atscript_annotated_type;
 }
@@ -433,32 +472,22 @@ function cloneRefProp(parentType, propName) {
 	const existing = objType.props.get(propName);
 	if (!existing) return;
 	const clonedType = cloneTypeDef(existing.type);
-	objType.props.set(propName, {
-		__is_atscript_annotated_type: true,
-		type: clonedType,
-		metadata: new Map(existing.metadata),
+	objType.props.set(propName, createAnnotatedTypeNode(clonedType, new Map(existing.metadata), {
 		id: existing.id,
-		optional: existing.optional,
-		validator(opts) {
-			return new Validator(this, opts);
-		}
-	});
+		optional: existing.optional
+	}));
 }
 function cloneTypeDef(type) {
 	if (type.kind === "object") {
 		const obj = type;
+		const props = new Map();
+		for (const [k, v] of obj.props) props.set(k, createAnnotatedTypeNode(v.type, new Map(v.metadata), {
+			id: v.id,
+			optional: v.optional
+		}));
 		return {
 			kind: "object",
-			props: new Map(Array.from(obj.props.entries()).map(([k, v]) => [k, {
-				__is_atscript_annotated_type: true,
-				type: v.type,
-				metadata: new Map(v.metadata),
-				id: v.id,
-				optional: v.optional,
-				validator(opts) {
-					return new Validator(this, opts);
-				}
-			}])),
+			props,
 			propsPatterns: [...obj.propsPatterns],
 			tags: new Set(obj.tags)
 		};
@@ -488,38 +517,24 @@ function defineAnnotatedType(_kind, base) {
 	const kind = _kind || "";
 	const type = base?.type || {};
 	type.kind = kind;
-	if ([
-		"union",
-		"intersection",
-		"tuple"
-	].includes(kind)) type.items = [];
+	if (COMPLEX_KINDS.has(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, {
+	const payload = {
 		__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);
-		}
+		validator: validatorMethod
 	};
+	base = base ? Object.assign(base, payload) : payload;
 	const handle = {
 		$type: base,
 		$def: type,
 		$metadata: metadata,
-		_existingObject: undefined,
 		tags(...tags) {
 			for (const tag of tags) this.$def.tags.add(tag);
 			return this;
@@ -560,27 +575,18 @@ else base = {
 			return this;
 		},
 		refTo(type$1, chain) {
+			if (!isAnnotatedType(type$1)) throw new Error(`${type$1} is not annotated type`);
 			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 (chain) for (let i = 0; i < chain.length; i++) {
+				const c = chain[i];
+				if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
+else {
+					const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
+					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,
-					id: newBase.id,
-					validator(opts) {
-						return new Validator(this, opts);
-					}
-				};
-			} else throw new Error(`${type$1} is not annotated type`);
+			}
+			this.$type = createAnnotatedTypeNode(newBase.type, metadata, { id: newBase.id });
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -598,19 +604,33 @@ function isPhantomType(def) {
 	return def.type.kind === "" && def.type.designType === "phantom";
 }
 function isAnnotatedTypeOfPrimitive(t) {
-	if (["array", "object"].includes(t.type.kind)) return false;
+	if (NON_PRIMITIVE_KINDS.has(t.type.kind)) return false;
 	if (!t.type.kind) return true;
-	if ([
-		"union",
-		"tuple",
-		"intersection"
-	].includes(t.type.kind)) {
+	if (COMPLEX_KINDS.has(t.type.kind)) {
 		for (const item of t.type.items) if (!isAnnotatedTypeOfPrimitive(item)) return false;
 		return true;
 	}
 	return false;
 }
 
+//#endregion
+//#region packages/typescript/src/traverse.ts
+function forAnnotatedType(def, handlers) {
+	switch (def.type.kind) {
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
+		case "object": return handlers.object(def);
+		case "array": return handlers.array(def);
+		case "union": return handlers.union(def);
+		case "intersection": return handlers.intersection(def);
+		case "tuple": return handlers.tuple(def);
+		default: throw new Error(`Unknown type kind "${def.type.kind}"`);
+	}
+}
+
 //#endregion
 //#region packages/typescript/src/json-schema.ts
 /**
@@ -625,10 +645,10 @@ function isAnnotatedTypeOfPrimitive(t) {
 	const firstObj = items[0].type;
 	const candidates = [];
 	for (const [propName, propType] of firstObj.props.entries()) if (propType.type.kind === "" && propType.type.value !== undefined) candidates.push(propName);
-	const validCandidates = [];
+	let result = null;
 	for (const candidate of candidates) {
 		const values = new Set();
-		const mapping = {};
+		const indexMapping = {};
 		let valid = true;
 		for (let i = 0; i < items.length; i++) {
 			const obj = items[i].type;
@@ -643,19 +663,21 @@ function isAnnotatedTypeOfPrimitive(t) {
 				break;
 			}
 			values.add(val);
-			mapping[String(val)] = `#/oneOf/${i}`;
+			indexMapping[String(val)] = i;
+		}
+		if (valid) {
+			if (result) return null;
+			result = {
+				propertyName: candidate,
+				indexMapping
+			};
 		}
-		if (valid) validCandidates.push({
-			propertyName: candidate,
-			mapping
-		});
 	}
-	if (validCandidates.length === 1) return validCandidates[0];
-	return null;
+	return result;
 }
 function buildJsonSchema(type) {
 	const defs = {};
-	let isRoot = true;
+	let hasDefs = false;
 	const buildObject = (d) => {
 		const properties = {};
 		const required = [];
@@ -672,15 +694,15 @@ function buildJsonSchema(type) {
 		return schema$1;
 	};
 	const build$1 = (def) => {
-		if (def.id && def.type.kind === "object" && !isRoot) {
+		if (def.id && def.type.kind === "object" && def !== type) {
 			const name = def.id;
 			if (!defs[name]) {
+				hasDefs = true;
 				defs[name] = {};
 				defs[name] = buildObject(def);
 			}
 			return { $ref: `#/$defs/${name}` };
 		}
-		isRoot = false;
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
 			phantom() {
@@ -705,11 +727,9 @@ function buildJsonSchema(type) {
 				if (disc) {
 					const oneOf = d.type.items.map(build$1);
 					const mapping = {};
-					for (const [val, origPath] of Object.entries(disc.mapping)) {
-						const idx = Number.parseInt(origPath.split("/").pop(), 10);
+					for (const [val, idx] of Object.entries(disc.indexMapping)) {
 						const item = d.type.items[idx];
-						if (item.id && defs[item.id]) mapping[val] = `#/$defs/${item.id}`;
-else mapping[val] = origPath;
+						mapping[val] = item.id && defs[item.id] ? `#/$defs/${item.id}` : `#/oneOf/${idx}`;
 					}
 					return {
 						oneOf,
@@ -759,7 +779,7 @@ else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ patte
 		});
 	};
 	const schema = build$1(type);
-	if (Object.keys(defs).length > 0) return {
+	if (hasDefs) return {
 		...schema,
 		$defs: defs
 	};
@@ -774,6 +794,8 @@ function fromJsonSchema(schema) {
 			const refName = s.$ref.replace(/^#\/(\$defs|definitions)\//, "");
 			if (resolved.has(refName)) return resolved.get(refName);
 			if (defsSource[refName]) {
+				const placeholder = defineAnnotatedType().designType("any").$type;
+				resolved.set(refName, placeholder);
 				const type = convert(defsSource[refName]);
 				resolved.set(refName, type);
 				return type;
@@ -1184,16 +1206,10 @@ function deserializeAnnotatedType(data) {
 function deserializeNode(data) {
 	const metadata = new Map(Object.entries(data.metadata));
 	const type = deserializeTypeDef(data.type);
-	const result = {
-		__is_atscript_annotated_type: true,
-		type,
-		metadata,
-		validator(opts) {
-			return new Validator(this, opts);
-		}
-	};
-	if (data.optional) result.optional = true;
-	if (data.id) result.id = data.id;
+	const result = createAnnotatedTypeNode(type, metadata, {
+		optional: data.optional || undefined,
+		id: data.id || undefined
+	});
 	return result;
 }
 function deserializeTypeDef(t) {
@@ -1239,4 +1255,4 @@ function deserializeTypeDef(t) {
 }
 
 //#endregion
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "Atscript: typescript-gen support.",
   "keywords": [
     "annotations",
@@ -64,7 +64,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.31"
+    "@atscript/core": "^0.1.33"
   },
   "build": [
     {},

package/skills/atscript-typescript/annotations.md

@@ -17,7 +17,7 @@
 | `@meta.required`      | `message?: string`         | Required field. Strings: non-whitespace. Booleans: must be `true`  |
 | `@meta.default`       | `value: string`            | Default value (strings as-is, others parsed as JSON)               |
 | `@meta.example`       | `value: string`            | Example value (strings as-is, others parsed as JSON)               |
-| `@expect.array.key`   | _(none)_                   | Mark field as key inside array (string/number types only)          |
+| `@expect.array.key`   | `message?: string`         | Mark field as key inside array (string/number only, non-optional). Multiple = composite key |
 
 ### `@expect.*` — Validation Constraints
 
@@ -29,6 +29,7 @@
 | `@expect.max`       | `maxValue: number`, `message?: string`                  | number        | Maximum value                                          |
 | `@expect.int`       | _(none)_                                                | number        | Must be integer                                        |
 | `@expect.pattern`   | `pattern: string`, `flags?: string`, `message?: string` | string        | Regex validation. **Multiple allowed** (all must pass) |
+| `@expect.array.uniqueItems` | `message?: string`                             | array         | No duplicate items (by key fields or deep equality)    |
 
 ### `@ui.*` — UI / Presentation Hints