@atscript/typescript 0.1.32 → 0.1.34

package/dist/utils.cjs

@@ -436,6 +436,26 @@ 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,
+		ref: opts?.ref
+	};
+}
 function isAnnotatedType(type) {
 	return type && type.__is_atscript_annotated_type;
 }
@@ -454,32 +474,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)
 		};
@@ -509,38 +519,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, {
-		__is_atscript_annotated_type: true,
-		metadata,
-		type,
-		validator(opts) {
-			return new Validator(this, opts);
-		}
-	});
-else base = {
+	const payload = {
 		__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;
@@ -581,26 +577,56 @@ else base = {
 			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 (isAnnotatedType(type$1)) {
+				let newBase = type$1;
+				const typeName = type$1.name || "Unknown";
+				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 throw new Error(`Can't find prop ${typeName}${keys}`);
+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,
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
 					id: newBase.id,
-					validator(opts) {
-						return new Validator(this, opts);
-					}
-				};
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						let target = t;
+						if (chain) for (const c of chain) if (target.type.kind === "object" && target.type.props.has(c)) target = target.type.props.get(c);
+else return t.type;
+						node.id = target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
 			} else throw new Error(`${type$1} is not annotated type`);
 			return this;
 		},
@@ -619,13 +645,9 @@ 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;
 	}
@@ -664,10 +686,10 @@ function forAnnotatedType(def, handlers) {
 	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;
@@ -682,19 +704,21 @@ function forAnnotatedType(def, handlers) {
 				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 = [];
@@ -711,15 +735,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() {
@@ -744,11 +768,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,
@@ -798,7 +820,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
 	};
@@ -813,6 +835,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;
@@ -1036,6 +1060,7 @@ function throwFeatureDisabled(feature, option, annotation) {
 function flattenAnnotatedType(type, options) {
 	const flatMap = new Map();
 	const skipPhantom = !!options?.excludePhantomTypes;
+	const visitedIds = new Set();
 	function addFieldToFlatMap(name, def) {
 		const existing = flatMap.get(name);
 		if (existing) {
@@ -1072,6 +1097,13 @@ else flatUnion.item(existing);
 		}
 	}
 	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+		const typeId = def.id;
+		if (typeId && visitedIds.has(typeId)) {
+			addFieldToFlatMap(prefix || "", def);
+			if (prefix) options?.onField?.(prefix, def, def.metadata);
+			return;
+		}
+		if (typeId) visitedIds.add(typeId);
 		switch (def.type.kind) {
 			case "object": {
 				addFieldToFlatMap(prefix || "", def);
@@ -1118,20 +1150,31 @@ else flatUnion.item(existing);
 //#region packages/typescript/src/serialize.ts
 const SERIALIZE_VERSION = 1;
 function serializeAnnotatedType(type, options) {
-	const result = serializeNode(type, [], options);
+	const visited = new Set();
+	const result = serializeNode(type, [], options, visited);
 	result.$v = SERIALIZE_VERSION;
 	return result;
 }
-function serializeNode(def, path, options) {
+function serializeNode(def, path, options, visited) {
+	if (def.id && visited.has(def.id)) return {
+		type: {
+			kind: "$ref",
+			id: def.id
+		},
+		metadata: {},
+		...def.optional ? { optional: true } : {},
+		id: def.id
+	};
+	if (def.id) visited.add(def.id);
 	const result = {
-		type: serializeTypeDef(def, path, options),
+		type: serializeTypeDef(def, path, options, visited),
 		metadata: serializeMetadata(def.metadata, path, def.type.kind, options)
 	};
 	if (def.optional) result.optional = true;
 	if (def.id) result.id = def.id;
 	return result;
 }
-function serializeTypeDef(def, path, options) {
+function serializeTypeDef(def, path, options, visited) {
 	return forAnnotatedType(def, {
 		phantom(d) {
 			return {
@@ -1151,13 +1194,13 @@ function serializeTypeDef(def, path, options) {
 		},
 		object(d) {
 			const props = {};
-			for (const [key, val] of d.type.props.entries()) props[key] = serializeNode(val, [...path, key], options);
+			for (const [key, val] of d.type.props.entries()) props[key] = serializeNode(val, [...path, key], options, visited);
 			const propsPatterns = d.type.propsPatterns.map((pp) => ({
 				pattern: {
 					source: pp.pattern.source,
 					flags: pp.pattern.flags
 				},
-				def: serializeNode(pp.def, path, options)
+				def: serializeNode(pp.def, path, options, visited)
 			}));
 			return {
 				kind: "object",
@@ -1169,28 +1212,28 @@ function serializeTypeDef(def, path, options) {
 		array(d) {
 			return {
 				kind: "array",
-				of: serializeNode(d.type.of, path, options),
+				of: serializeNode(d.type.of, path, options, visited),
 				tags: Array.from(d.type.tags)
 			};
 		},
 		union(d) {
 			return {
 				kind: "union",
-				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				items: d.type.items.map((item) => serializeNode(item, path, options, visited)),
 				tags: Array.from(d.type.tags)
 			};
 		},
 		intersection(d) {
 			return {
 				kind: "intersection",
-				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				items: d.type.items.map((item) => serializeNode(item, path, options, visited)),
 				tags: Array.from(d.type.tags)
 			};
 		},
 		tuple(d) {
 			return {
 				kind: "tuple",
-				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				items: d.type.items.map((item) => serializeNode(item, path, options, visited)),
 				tags: Array.from(d.type.tags)
 			};
 		}
@@ -1223,16 +1266,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) {
@@ -1273,6 +1310,12 @@ function deserializeTypeDef(t) {
 			items: t.items.map((item) => deserializeNode(item)),
 			tags
 		};
+		case "$ref": return {
+			kind: "object",
+			props: new Map(),
+			propsPatterns: [],
+			tags
+		};
 		default: throw new Error(`Unknown serialized type kind "${t.kind}"`);
 	}
 }
@@ -1284,6 +1327,7 @@ exports.ValidatorError = ValidatorError
 exports.annotate = annotate
 exports.buildJsonSchema = buildJsonSchema
 exports.cloneRefProp = cloneRefProp
+exports.createAnnotatedTypeNode = createAnnotatedTypeNode
 exports.createDataFromAnnotatedType = createDataFromAnnotatedType
 exports.defineAnnotatedType = defineAnnotatedType
 exports.deserializeAnnotatedType = deserializeAnnotatedType

package/dist/utils.d.ts

@@ -96,6 +96,18 @@ declare class ValidatorError extends Error {
     constructor(errors: TError[]);
 }
 
+/**
+ * Creates a minimal annotated type node from a type def and metadata map.
+ * Centralises the shape so callers never duplicate the boilerplate.
+ */
+declare function createAnnotatedTypeNode(type: TAtscriptTypeDef, metadata: TMetadataMap<AtscriptMetadata>, opts?: {
+    id?: string;
+    optional?: boolean;
+    ref?: {
+        type: () => TAtscriptAnnotatedType;
+        field: string;
+    };
+}): TAtscriptAnnotatedType;
 /** Type definition for union, intersection, or tuple types. */
 interface TAtscriptTypeComplex<DataType = unknown> {
     kind: 'union' | 'intersection' | 'tuple';
@@ -183,6 +195,10 @@ interface TAtscriptAnnotatedType<T extends TAtscriptTypeDef = TAtscriptTypeDef,
     metadata: TMetadataMap<AtscriptMetadata>;
     optional?: boolean;
     id?: string;
+    ref?: {
+        type: () => TAtscriptAnnotatedType;
+        field: string;
+    };
 }
 /** An annotated type that is also a class constructor (i.e. a generated interface class). */
 type TAtscriptAnnotatedTypeConstructor = TAtscriptAnnotatedType & (new (...args: any[]) => any);
@@ -235,7 +251,6 @@ interface TAnnotatedTypeHandle {
         kind: TKind;
     } & Omit<TAtscriptTypeComplex, 'kind'> & Omit<TAtscriptTypeFinal, 'kind'> & Omit<TAtscriptTypeArray, 'kind'> & Omit<TAtscriptTypeObject<string>, 'kind'>;
     $metadata: TMetadataMap<AtscriptMetadata>;
-    _existingObject: TAtscriptAnnotatedType | undefined;
     tags(...tags: string[]): TAnnotatedTypeHandle;
     designType(value: TAtscriptTypeFinal['designType']): TAnnotatedTypeHandle;
     value(value: string | number | boolean): TAnnotatedTypeHandle;
@@ -245,9 +260,11 @@ interface TAnnotatedTypeHandle {
     propPattern(pattern: RegExp, value: TAtscriptAnnotatedType): TAnnotatedTypeHandle;
     optional(value?: boolean): TAnnotatedTypeHandle;
     copyMetadata(fromMetadata: TMetadataMap<AtscriptMetadata>): TAnnotatedTypeHandle;
-    refTo(type: TAtscriptAnnotatedType & {
+    refTo(type: (TAtscriptAnnotatedType & {
         name?: string;
-    }, chain?: string[]): TAnnotatedTypeHandle;
+    }) | (() => TAtscriptAnnotatedType & {
+        name?: string;
+    }), chain?: string[]): TAnnotatedTypeHandle;
     annotate(key: keyof AtscriptMetadata, value: any, asArray?: boolean): TAnnotatedTypeHandle;
     id(value: string): TAnnotatedTypeHandle;
 }
@@ -471,7 +488,11 @@ interface TSerializedTypeComplex {
     items: TSerializedAnnotatedTypeInner[];
     tags: string[];
 }
-type TSerializedTypeDef = TSerializedTypeFinal | TSerializedTypeObject | TSerializedTypeArray | TSerializedTypeComplex;
+interface TSerializedTypeRef {
+    kind: '$ref';
+    id: string;
+}
+type TSerializedTypeDef = TSerializedTypeFinal | TSerializedTypeObject | TSerializedTypeArray | TSerializedTypeComplex | TSerializedTypeRef;
 /** Context passed to {@link TSerializeOptions.processAnnotation} for each annotation entry. */
 interface TProcessAnnotationContext {
     /** Annotation key, e.g. "meta.label" */
@@ -559,5 +580,5 @@ type PrimaryKeyOf<T> = T extends {
     __pk: infer PK;
 } ? PK : unknown;
 
-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 };
 export type { FlatOf, InferDataType, PrimaryKeyOf, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptDataType, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TCreateDataOptions, TFlattenOptions, TJsonSchema, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext, TValueResolver };