@atscript/typescript 0.1.8 → 0.1.10

package/dist/cli.cjs

@@ -519,12 +519,14 @@ var Validator = class {
 	* @param safe - If `true`, returns `false` on failure instead of throwing.
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe) {
+	*/ validate(value, safe, context) {
 		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
+		this.context = undefined;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -814,6 +816,7 @@ else {
 		/** Validation errors collected during the last {@link validate} call. */ _define_property$2(this, "errors", void 0);
 		_define_property$2(this, "stackErrors", void 0);
 		_define_property$2(this, "stackPath", void 0);
+		_define_property$2(this, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];

package/dist/index.cjs

@@ -516,12 +516,14 @@ var Validator = class {
 	* @param safe - If `true`, returns `false` on failure instead of throwing.
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe) {
+	*/ validate(value, safe, context) {
 		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
+		this.context = undefined;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -811,6 +813,7 @@ else {
 		/** Validation errors collected during the last {@link validate} call. */ _define_property$1(this, "errors", void 0);
 		_define_property$1(this, "stackErrors", void 0);
 		_define_property$1(this, "stackPath", void 0);
+		_define_property$1(this, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];

package/dist/index.mjs

@@ -492,12 +492,14 @@ var Validator = class {
 	* @param safe - If `true`, returns `false` on failure instead of throwing.
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe) {
+	*/ validate(value, safe, context) {
 		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
+		this.context = undefined;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -787,6 +789,7 @@ else {
 		/** Validation errors collected during the last {@link validate} call. */ _define_property$1(this, "errors", void 0);
 		_define_property$1(this, "stackErrors", void 0);
 		_define_property$1(this, "stackPath", void 0);
+		_define_property$1(this, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];

package/dist/utils.cjs

@@ -72,12 +72,14 @@ var Validator = class {
 	* @param safe - If `true`, returns `false` on failure instead of throwing.
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe) {
+	*/ validate(value, safe, context) {
 		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
+		this.context = undefined;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -367,6 +369,7 @@ 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, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];
@@ -690,6 +693,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 +932,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

@@ -25,6 +25,7 @@ interface TValidatorPluginContext {
     validateAnnotatedType: Validator<any>['validateAnnotatedType'];
     error: Validator<any>['error'];
     path: Validator<any>['path'];
+    context: unknown;
 }
 /**
  * Validates values against an {@link TAtscriptAnnotatedType} definition.
@@ -59,6 +60,7 @@ declare class Validator<T extends TAtscriptAnnotatedType = TAtscriptAnnotatedTyp
     errors: TError[];
     protected stackErrors: TError[][];
     protected stackPath: string[];
+    protected context: unknown;
     protected isLimitExceeded(): boolean;
     protected push(name: string): void;
     protected pop(saveErrors: boolean): TError[] | undefined;
@@ -76,7 +78,7 @@ declare class Validator<T extends TAtscriptAnnotatedType = TAtscriptAnnotatedTyp
      * @returns `true` if the value matches the type definition.
      * @throws {ValidatorError} When validation fails and `safe` is not `true`.
      */
-    validate<TT = DataType>(value: any, safe?: boolean): value is TT;
+    validate<TT = DataType>(value: any, safe?: boolean, context?: unknown): value is TT;
     protected validateSafe(def: TAtscriptAnnotatedType, value: any): boolean;
     protected get path(): string;
     protected validateAnnotatedType(def: TAtscriptAnnotatedType, value: any): boolean;
@@ -302,6 +304,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 +451,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

@@ -71,12 +71,14 @@ var Validator = class {
 	* @param safe - If `true`, returns `false` on failure instead of throwing.
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe) {
+	*/ validate(value, safe, context) {
 		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
+		this.context = undefined;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -366,6 +368,7 @@ 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, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];
@@ -689,6 +692,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 +924,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.10",
   "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.10"
   },
   "dependencies": {
     "@moostjs/event-cli": "^0.5.32",