@atscript/typescript 0.1.8 → 0.1.9

package/dist/utils.cjs

@@ -690,6 +690,76 @@ function fromJsonSchema(schema) {
 	return convert(schema);
 }
 
+//#endregion
+//#region packages/typescript/src/flatten.ts
+function flattenAnnotatedType(type, options) {
+	const flatMap = new Map();
+	const skipPhantom = !!options?.excludePhantomTypes;
+	function addFieldToFlatMap(name, def) {
+		const existing = flatMap.get(name);
+		if (existing) {
+			const flatUnion = defineAnnotatedType("union").copyMetadata(existing.metadata).copyMetadata(def.metadata);
+			if (existing.__flat_union) existing.type.items.forEach((item) => flatUnion.item(item));
+else flatUnion.item(existing);
+			flatUnion.item(def);
+			const unionType = flatUnion.$type;
+			unionType.__flat_union = true;
+			flatMap.set(name, flatUnion.$type);
+		} else flatMap.set(name, def);
+	}
+	function flattenArray(def, name) {
+		switch (def.type.kind) {
+			case "object": {
+				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);
+				}
+				break;
+			}
+			case "union":
+			case "intersection":
+			case "tuple":
+				for (const item of def.type.items) flattenArray(item, name);
+				break;
+			case "array":
+				flattenArray(def.type.of, name);
+				break;
+			default:
+		}
+	}
+	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+		switch (def.type.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);
+				}
+				break;
+			case "array": {
+				let typeArray = def;
+				if (!inComplexTypeOrArray) {
+					typeArray = defineAnnotatedType().refTo(def).copyMetadata(def.metadata).$type;
+					if (options?.topLevelArrayTag) typeArray.metadata.set(options.topLevelArrayTag, true);
+				}
+				addFieldToFlatMap(prefix || "", typeArray);
+				if (!isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix);
+				break;
+			}
+			case "intersection":
+			case "tuple":
+			case "union": for (const item of def.type.items) flattenType(item, prefix, true);
+			default:
+				addFieldToFlatMap(prefix || "", def);
+				break;
+		}
+		if (prefix) options?.onField?.(prefix, def, def.metadata);
+	}
+	flattenType(type);
+	return flatMap;
+}
+
 //#endregion
 //#region packages/typescript/src/serialize.ts
 const SERIALIZE_VERSION = 1;
@@ -859,6 +929,7 @@ exports.annotate = annotate
 exports.buildJsonSchema = buildJsonSchema
 exports.defineAnnotatedType = defineAnnotatedType
 exports.deserializeAnnotatedType = deserializeAnnotatedType
+exports.flattenAnnotatedType = flattenAnnotatedType
 exports.forAnnotatedType = forAnnotatedType
 exports.fromJsonSchema = fromJsonSchema
 exports.isAnnotatedType = isAnnotatedType

package/dist/utils.d.ts

@@ -302,6 +302,47 @@ declare function forAnnotatedType<R>(def: TAtscriptAnnotatedType, handlers: {
     phantom?: (def: TAtscriptAnnotatedType<TAtscriptTypeFinal>) => R;
 }): R;
 
+/**
+ * Options for controlling the flattening process.
+ */
+interface TFlattenOptions {
+    /**
+     * Called for each field (with a non-empty path prefix) after it has been added to the flat map.
+     * Use this to inspect field type and metadata for domain-specific logic (e.g. index extraction).
+     */
+    onField?: (path: string, type: TAtscriptAnnotatedType, metadata: TMetadataMap<AtscriptMetadata>) => void;
+    /**
+     * When set, top-level array fields get this metadata key set to `true`.
+     * For example, `'mongo.__topLevelArray'` marks arrays that are direct collection fields.
+     * Omit to skip tagging.
+     */
+    topLevelArrayTag?: string;
+    /**
+     * Whether to exclude phantom types from the flat map.
+     * When `true`, phantom-typed properties are skipped during traversal.
+     * By default phantom types are included.
+     */
+    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>;
+
 /** Current serialization format version. Bumped on breaking changes to the serialized shape. */
 declare const SERIALIZE_VERSION = 1;
 /** Top-level serialized annotated type. JSON-safe representation of a {@link TAtscriptAnnotatedType}. */
@@ -408,5 +449,5 @@ declare function serializeAnnotatedType(type: TAtscriptAnnotatedType, options?:
  */
 declare function deserializeAnnotatedType(data: TSerializedAnnotatedType): TAtscriptAnnotatedType;
 
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType };
-export type { InferDataType, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType };
+export type { InferDataType, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TFlattenOptions, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext };

package/dist/utils.mjs

@@ -689,6 +689,76 @@ function fromJsonSchema(schema) {
 	return convert(schema);
 }
 
+//#endregion
+//#region packages/typescript/src/flatten.ts
+function flattenAnnotatedType(type, options) {
+	const flatMap = new Map();
+	const skipPhantom = !!options?.excludePhantomTypes;
+	function addFieldToFlatMap(name, def) {
+		const existing = flatMap.get(name);
+		if (existing) {
+			const flatUnion = defineAnnotatedType("union").copyMetadata(existing.metadata).copyMetadata(def.metadata);
+			if (existing.__flat_union) existing.type.items.forEach((item) => flatUnion.item(item));
+else flatUnion.item(existing);
+			flatUnion.item(def);
+			const unionType = flatUnion.$type;
+			unionType.__flat_union = true;
+			flatMap.set(name, flatUnion.$type);
+		} else flatMap.set(name, def);
+	}
+	function flattenArray(def, name) {
+		switch (def.type.kind) {
+			case "object": {
+				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);
+				}
+				break;
+			}
+			case "union":
+			case "intersection":
+			case "tuple":
+				for (const item of def.type.items) flattenArray(item, name);
+				break;
+			case "array":
+				flattenArray(def.type.of, name);
+				break;
+			default:
+		}
+	}
+	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+		switch (def.type.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);
+				}
+				break;
+			case "array": {
+				let typeArray = def;
+				if (!inComplexTypeOrArray) {
+					typeArray = defineAnnotatedType().refTo(def).copyMetadata(def.metadata).$type;
+					if (options?.topLevelArrayTag) typeArray.metadata.set(options.topLevelArrayTag, true);
+				}
+				addFieldToFlatMap(prefix || "", typeArray);
+				if (!isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix);
+				break;
+			}
+			case "intersection":
+			case "tuple":
+			case "union": for (const item of def.type.items) flattenType(item, prefix, true);
+			default:
+				addFieldToFlatMap(prefix || "", def);
+				break;
+		}
+		if (prefix) options?.onField?.(prefix, def, def.metadata);
+	}
+	flattenType(type);
+	return flatMap;
+}
+
 //#endregion
 //#region packages/typescript/src/serialize.ts
 const SERIALIZE_VERSION = 1;
@@ -851,4 +921,4 @@ function deserializeTypeDef(t) {
 }
 
 //#endregion
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Atscript: typescript-gen support.",
   "type": "module",
   "main": "dist/index.mjs",
@@ -70,7 +70,7 @@
   "homepage": "https://github.com/moostjs/atscript/tree/main/packages/typescript#readme",
   "license": "ISC",
   "peerDependencies": {
-    "@atscript/core": "^0.1.8"
+    "@atscript/core": "^0.1.9"
   },
   "dependencies": {
     "@moostjs/event-cli": "^0.5.32",