@atscript/typescript 0.1.59 → 0.1.60

package/dist/utils.cjs

@@ -109,10 +109,32 @@ function throwFeatureDisabled(feature, option, annotation) {
 
 //#endregion
 //#region packages/typescript/src/runtime/flatten.ts
+/**
+* Flattens an annotated object type into a map of dot-separated paths to their annotated types.
+*
+* For an object like `{ address: { street: string, city: string } }`, the result contains:
+* - `''` → the root object type
+* - `'address'` → the address object type
+* - `'address.street'` → string type
+* - `'address.city'` → string type
+*
+* Arrays are recursed into (their element types are flattened with the same prefix).
+* Unions/intersections/tuples are recursed into (each branch contributes to the same path,
+* merging via synthetic union types when paths collide).
+*
+* @param type - The root annotated type (must be an object type).
+* @param options - Optional hooks for domain-specific processing.
+* @returns A map of dot-separated field paths to their annotated types.
+*/ const EMPTY_ANCESTORS = new Set();
+function extendAncestors(ancestors, id) {
+	if (!id || ancestors.has(id)) return ancestors;
+	const next = new Set(ancestors);
+	next.add(id);
+	return next;
+}
 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) {
@@ -125,62 +147,60 @@ else flatUnion.item(existing);
 			flatMap.set(name, flatUnion.$type);
 		} else flatMap.set(name, def);
 	}
-	function flattenArray(def, name) {
+	function flattenArray(def, name, ancestors) {
 		const resolvedId = def.id;
-		if (resolvedId) {
-			if (visitedIds.has(resolvedId)) return;
-			visitedIds.add(resolvedId);
-		}
+		if (resolvedId && ancestors.has(resolvedId)) return;
+		let childAncestors = extendAncestors(ancestors, resolvedId);
 		switch (def.type.kind) {
 			case "object": {
 				if (!resolvedId && def.id) {
-					if (visitedIds.has(def.id)) return;
-					visitedIds.add(def.id);
+					if (ancestors.has(def.id)) return;
+					childAncestors = extendAncestors(ancestors, def.id);
 				}
 				const items = Array.from(def.type.props.entries());
 				for (const [key, value] of items) {
 					if (skipPhantom && require_json_schema.isPhantomType(value)) continue;
-					flattenType(value, name ? `${name}.${key}` : key, true);
+					flattenType(value, name ? `${name}.${key}` : key, true, childAncestors);
 				}
 				break;
 			}
 			case "union":
 			case "intersection":
 			case "tuple": {
-				for (const item of def.type.items) flattenArray(item, name);
+				for (const item of def.type.items) flattenArray(item, name, childAncestors);
 				break;
 			}
 			case "array": {
-				flattenArray(def.type.of, name);
+				flattenArray(def.type.of, name, childAncestors);
 				break;
 			}
 			default:
 		}
 	}
-	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+	function flattenType(def, prefix = "", inComplexTypeOrArray = false, ancestors = EMPTY_ANCESTORS) {
 		let typeId = def.id;
-		if (typeId && visitedIds.has(typeId)) {
+		if (typeId && ancestors.has(typeId)) {
 			addFieldToFlatMap(prefix || "", def);
 			if (prefix) options?.onField?.(prefix, def, def.metadata);
 			return;
 		}
-		if (typeId) visitedIds.add(typeId);
+		let childAncestors = extendAncestors(ancestors, typeId);
 		const kind = def.type.kind;
 		if (!typeId && def.id) {
 			typeId = def.id;
-			if (visitedIds.has(typeId)) {
+			if (ancestors.has(typeId)) {
 				addFieldToFlatMap(prefix || "", def);
 				if (prefix) options?.onField?.(prefix, def, def.metadata);
 				return;
 			}
-			visitedIds.add(typeId);
+			childAncestors = extendAncestors(ancestors, typeId);
 		}
 		switch (kind) {
 			case "object": {
 				addFieldToFlatMap(prefix || "", def);
 				for (const [key, value] of def.type.props.entries()) {
 					if (skipPhantom && require_json_schema.isPhantomType(value)) continue;
-					flattenType(value, prefix ? `${prefix}.${key}` : key, inComplexTypeOrArray);
+					flattenType(value, prefix ? `${prefix}.${key}` : key, inComplexTypeOrArray, childAncestors);
 				}
 				break;
 			}
@@ -192,13 +212,13 @@ else flatUnion.item(existing);
 					if (options?.topLevelArrayTag) typeArray.metadata.set(options.topLevelArrayTag, true);
 				}
 				addFieldToFlatMap(prefix || "", typeArray);
-				if (!require_json_schema.isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix);
+				if (!require_json_schema.isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix, childAncestors);
 				break;
 			}
 			case "intersection":
 			case "tuple":
 			case "union": {
-				for (const item of def.type.items) flattenType(item, prefix, true);
+				for (const item of def.type.items) flattenType(item, prefix, true, childAncestors);
 				addFieldToFlatMap(prefix || "", def);
 				if (def.optional) {
 					const entry = flatMap.get(prefix || "");

package/dist/utils.d.ts

@@ -456,23 +456,6 @@ interface TFlattenOptions {
      */
     excludePhantomTypes?: boolean;
 }
-/**
- * Flattens an annotated object type into a map of dot-separated paths to their annotated types.
- *
- * For an object like `{ address: { street: string, city: string } }`, the result contains:
- * - `''` → the root object type
- * - `'address'` → the address object type
- * - `'address.street'` → string type
- * - `'address.city'` → string type
- *
- * Arrays are recursed into (their element types are flattened with the same prefix).
- * Unions/intersections/tuples are recursed into (each branch contributes to the same path,
- * merging via synthetic union types when paths collide).
- *
- * @param type - The root annotated type (must be an object type).
- * @param options - Optional hooks for domain-specific processing.
- * @returns A map of dot-separated field paths to their annotated types.
- */
 declare function flattenAnnotatedType(type: TAtscriptAnnotatedType<TAtscriptTypeObject>, options?: TFlattenOptions): Map<string, TAtscriptAnnotatedType>;
 
 /** Runtime shape of a ref annotation argument (lazy type reference with optional chain). */

package/dist/utils.mjs

@@ -108,10 +108,32 @@ function throwFeatureDisabled(feature, option, annotation) {
 
 //#endregion
 //#region packages/typescript/src/runtime/flatten.ts
+/**
+* Flattens an annotated object type into a map of dot-separated paths to their annotated types.
+*
+* For an object like `{ address: { street: string, city: string } }`, the result contains:
+* - `''` → the root object type
+* - `'address'` → the address object type
+* - `'address.street'` → string type
+* - `'address.city'` → string type
+*
+* Arrays are recursed into (their element types are flattened with the same prefix).
+* Unions/intersections/tuples are recursed into (each branch contributes to the same path,
+* merging via synthetic union types when paths collide).
+*
+* @param type - The root annotated type (must be an object type).
+* @param options - Optional hooks for domain-specific processing.
+* @returns A map of dot-separated field paths to their annotated types.
+*/ const EMPTY_ANCESTORS = new Set();
+function extendAncestors(ancestors, id) {
+	if (!id || ancestors.has(id)) return ancestors;
+	const next = new Set(ancestors);
+	next.add(id);
+	return next;
+}
 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) {
@@ -124,62 +146,60 @@ else flatUnion.item(existing);
 			flatMap.set(name, flatUnion.$type);
 		} else flatMap.set(name, def);
 	}
-	function flattenArray(def, name) {
+	function flattenArray(def, name, ancestors) {
 		const resolvedId = def.id;
-		if (resolvedId) {
-			if (visitedIds.has(resolvedId)) return;
-			visitedIds.add(resolvedId);
-		}
+		if (resolvedId && ancestors.has(resolvedId)) return;
+		let childAncestors = extendAncestors(ancestors, resolvedId);
 		switch (def.type.kind) {
 			case "object": {
 				if (!resolvedId && def.id) {
-					if (visitedIds.has(def.id)) return;
-					visitedIds.add(def.id);
+					if (ancestors.has(def.id)) return;
+					childAncestors = extendAncestors(ancestors, def.id);
 				}
 				const items = Array.from(def.type.props.entries());
 				for (const [key, value] of items) {
 					if (skipPhantom && isPhantomType(value)) continue;
-					flattenType(value, name ? `${name}.${key}` : key, true);
+					flattenType(value, name ? `${name}.${key}` : key, true, childAncestors);
 				}
 				break;
 			}
 			case "union":
 			case "intersection":
 			case "tuple": {
-				for (const item of def.type.items) flattenArray(item, name);
+				for (const item of def.type.items) flattenArray(item, name, childAncestors);
 				break;
 			}
 			case "array": {
-				flattenArray(def.type.of, name);
+				flattenArray(def.type.of, name, childAncestors);
 				break;
 			}
 			default:
 		}
 	}
-	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+	function flattenType(def, prefix = "", inComplexTypeOrArray = false, ancestors = EMPTY_ANCESTORS) {
 		let typeId = def.id;
-		if (typeId && visitedIds.has(typeId)) {
+		if (typeId && ancestors.has(typeId)) {
 			addFieldToFlatMap(prefix || "", def);
 			if (prefix) options?.onField?.(prefix, def, def.metadata);
 			return;
 		}
-		if (typeId) visitedIds.add(typeId);
+		let childAncestors = extendAncestors(ancestors, typeId);
 		const kind = def.type.kind;
 		if (!typeId && def.id) {
 			typeId = def.id;
-			if (visitedIds.has(typeId)) {
+			if (ancestors.has(typeId)) {
 				addFieldToFlatMap(prefix || "", def);
 				if (prefix) options?.onField?.(prefix, def, def.metadata);
 				return;
 			}
-			visitedIds.add(typeId);
+			childAncestors = extendAncestors(ancestors, typeId);
 		}
 		switch (kind) {
 			case "object": {
 				addFieldToFlatMap(prefix || "", def);
 				for (const [key, value] of def.type.props.entries()) {
 					if (skipPhantom && isPhantomType(value)) continue;
-					flattenType(value, prefix ? `${prefix}.${key}` : key, inComplexTypeOrArray);
+					flattenType(value, prefix ? `${prefix}.${key}` : key, inComplexTypeOrArray, childAncestors);
 				}
 				break;
 			}
@@ -191,13 +211,13 @@ else flatUnion.item(existing);
 					if (options?.topLevelArrayTag) typeArray.metadata.set(options.topLevelArrayTag, true);
 				}
 				addFieldToFlatMap(prefix || "", typeArray);
-				if (!isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix);
+				if (!isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix, childAncestors);
 				break;
 			}
 			case "intersection":
 			case "tuple":
 			case "union": {
-				for (const item of def.type.items) flattenType(item, prefix, true);
+				for (const item of def.type.items) flattenType(item, prefix, true, childAncestors);
 				addFieldToFlatMap(prefix || "", def);
 				if (def.optional) {
 					const entry = flatMap.get(prefix || "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "Atscript: typescript-gen support.",
   "keywords": [
     "annotations",
@@ -73,7 +73,7 @@
   },
   "peerDependencies": {
     "@atscript/db": "^0.1.74",
-    "@atscript/core": "^0.1.59"
+    "@atscript/core": "^0.1.60"
   },
   "peerDependenciesMeta": {
     "@atscript/db": {