@foormjs/atscript 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -35,19 +35,19 @@ function compileTopFn(fnStr) {
  * Compiles a validator function string from a @foorm.validate annotation.
  *
  * The function string should be:
- *   "(v, data, ctx) => boolean | string"
+ *   "(v, data, ctx, entry) => boolean | string"
  *
  * The compiled function receives a single TFoormFnScope object:
- *   { v, data, context }
+ *   { v, data, context, entry }
  */
 function compileValidatorFn(fnStr) {
-    const code = `return (${fnStr})(v, data, context)`;
+    const code = `return (${fnStr})(v, data, context, entry)`;
     return pool.getFn(code);
 }
 
 function foormValidatorPlugin(foormCtx) {
     return (ctx, def, value) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const validators = (_a = def.metadata) === null || _a === void 0 ? void 0 : _a.get('foorm.validate');
         if (!validators) {
             return undefined;
@@ -55,12 +55,31 @@ function foormValidatorPlugin(foormCtx) {
         const fns = Array.isArray(validators) ? validators : [validators];
         const data = (_b = foormCtx === null || foormCtx === void 0 ? void 0 : foormCtx.data) !== null && _b !== void 0 ? _b : {};
         const context = (_c = foormCtx === null || foormCtx === void 0 ? void 0 : foormCtx.context) !== null && _c !== void 0 ? _c : {};
+        // Build entry object with field metadata
+        const entry = {
+            field: def.name,
+            type: ((_d = def.metadata) === null || _d === void 0 ? void 0 : _d.get('foorm.type')) || 'text',
+            component: (_e = def.metadata) === null || _e === void 0 ? void 0 : _e.get('foorm.component'),
+            name: def.name,
+        };
+        // Base scope for evaluating constraints
+        const baseScope = { v: value, data, context, entry: undefined };
+        // Evaluate computed constraints
+        entry.disabled = evalConstraint(def.metadata, 'foorm.disabled', 'foorm.fn.disabled', baseScope);
+        entry.optional = evalConstraint(def.metadata, 'foorm.optional', 'foorm.fn.optional', baseScope);
+        entry.hidden = evalConstraint(def.metadata, 'foorm.hidden', 'foorm.fn.hidden', baseScope);
+        entry.readonly = evalConstraint(def.metadata, 'foorm.readonly', 'foorm.fn.readonly', baseScope);
+        // Full scope with evaluated entry
+        const scope = { v: value, data, context, entry };
+        // Evaluate options (static or computed)
+        entry.options = evalOptions(def.metadata, scope);
+        // Run custom validators with full scope
         for (const fnStr of fns) {
             if (typeof fnStr !== 'string') {
                 continue;
             }
             const fn = compileValidatorFn(fnStr);
-            const result = fn({ v: value, data, context });
+            const result = fn(scope);
             if (result !== true) {
                 ctx.error(typeof result === 'string' ? result : 'Validation failed');
                 return false;
@@ -69,6 +88,429 @@ function foormValidatorPlugin(foormCtx) {
         return undefined;
     };
 }
+/** Helper to evaluate a boolean constraint (static or computed) */
+function evalConstraint(metadata, staticKey, fnKey, scope) {
+    const fnStr = metadata === null || metadata === void 0 ? void 0 : metadata.get(fnKey);
+    if (typeof fnStr === 'string') {
+        return compileFieldFn(fnStr)(scope);
+    }
+    const staticVal = metadata === null || metadata === void 0 ? void 0 : metadata.get(staticKey);
+    return staticVal !== undefined ? true : undefined;
+}
+/** Helper to evaluate options (static or computed) */
+function evalOptions(metadata, scope) {
+    const fnStr = metadata === null || metadata === void 0 ? void 0 : metadata.get('foorm.fn.options');
+    if (typeof fnStr === 'string') {
+        return compileFieldFn(fnStr)(scope);
+    }
+    const staticOpts = metadata === null || metadata === void 0 ? void 0 : metadata.get('foorm.options');
+    if (staticOpts) {
+        const items = Array.isArray(staticOpts) ? staticOpts : [staticOpts];
+        return items.map(item => {
+            if (typeof item === 'object' && item !== null && 'label' in item) {
+                const { label, value } = item;
+                return value !== undefined ? { key: value, label } : label;
+            }
+            return String(item);
+        });
+    }
+    return undefined;
+}
+
+//#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, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const regexCache = new Map();
+var Validator = class {
+	isLimitExceeded() {
+		if (this.stackErrors.length > 0) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		return this.errors.length >= this.opts.errorLimit;
+	}
+	push(name) {
+		this.stackPath.push(name);
+		this.stackErrors.push([]);
+	}
+	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);
+		});
+		return popped;
+	}
+	clear() {
+		this.stackErrors[this.stackErrors.length - 1] = [];
+	}
+	error(message, path, details) {
+		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		const error = {
+			path: path || this.path,
+			message
+		};
+		if (details?.length) error.details = details;
+		errors.push(error);
+	}
+	throw() {
+		throw new ValidatorError(this.errors);
+	}
+	/**
+	* Validates a value against the type definition.
+	*
+	* Acts as a TypeScript type guard — when it returns `true`, the value
+	* is narrowed to `DataType`.
+	*
+	* @param value - The value to validate.
+	* @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) {
+		this.push("");
+		this.errors = [];
+		this.stackErrors = [];
+		const passed = this.validateSafe(this.def, value);
+		this.pop(!passed);
+		if (!passed) {
+			if (safe) return false;
+			this.throw();
+		}
+		return true;
+	}
+	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 (def.optional && value === undefined) return true;
+		for (const plugin of this.opts.plugins) {
+			const result = plugin(this, def, value);
+			if (result === false || result === true) return result;
+		}
+		return this.validateAnnotatedType(def, value);
+	}
+	get path() {
+		return this.stackPath.slice(1).join(".");
+	}
+	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)
+		});
+	}
+	validateUnion(def, value) {
+		let i = 0;
+		const popped = [];
+		for (const item of def.type.items) {
+			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
+			if (this.validateSafe(item, value)) {
+				this.pop(false);
+				return true;
+			}
+			const errors = this.pop(false);
+			if (errors) popped.push(...errors);
+			i++;
+		}
+		this.clear();
+		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
+		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
+		return false;
+	}
+	validateIntersection(def, value) {
+		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
+		return true;
+	}
+	validateTuple(def, value) {
+		if (!Array.isArray(value) || value.length !== def.type.items.length) {
+			this.error(`Expected array of length ${def.type.items.length}`);
+			return false;
+		}
+		let i = 0;
+		for (const item of def.type.items) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(item, value[i])) {
+				this.pop(true);
+				return false;
+			}
+			this.pop(false);
+			i++;
+		}
+		return true;
+	}
+	validateArray(def, value) {
+		if (!Array.isArray(value)) {
+			this.error("Expected array");
+			return false;
+		}
+		const minLength = def.metadata.get("expect.minLength");
+		if (minLength) {
+			const length = typeof minLength === "number" ? minLength : minLength.length;
+			if (value.length < length) {
+				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} items, got ${value.length} items`;
+				this.error(message);
+				return false;
+			}
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (maxLength) {
+			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
+			if (value.length > length) {
+				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} items, got ${value.length} items`;
+				this.error(message);
+				return false;
+			}
+		}
+		let i = 0;
+		let passed = true;
+		for (const item of value) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(def.type.of, item)) {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			} else this.pop(false);
+			i++;
+		}
+		return passed;
+	}
+	validateObject(def, value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			this.error("Expected object");
+			return false;
+		}
+		let passed = true;
+		const valueKeys = new Set(Object.keys(value));
+		const typeKeys = new Set();
+		const skipList = new Set();
+		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);
+				}
+			});
+		}
+		let partialFunctionMatched = false;
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.path);
+		for (const [key, item] of def.type.props.entries()) {
+			if (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;
+			}
+			this.push(key);
+			if (this.validateSafe(item, value[key])) this.pop(false);
+else {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			}
+		}
+		for (const key of valueKeys)
+ /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
+			const matched = [];
+			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
+				pattern,
+				def: propDef
+			});
+			if (matched.length) {
+				let keyPassed = false;
+				for (const { def: def$1 } of matched) if (this.validateSafe(def$1, value[key])) {
+					this.pop(false);
+					keyPassed = true;
+					break;
+				}
+				if (!keyPassed) {
+					this.push(key);
+					this.validateSafe(matched[0].def, value[key]);
+					this.pop(true);
+					passed = false;
+					if (this.isLimitExceeded()) return false;
+				}
+			} else if (this.opts.unknwonProps !== "ignore") {
+				if (this.opts.unknwonProps === "error") {
+					this.push(key);
+					this.error(`Unexpected property`);
+					this.pop(true);
+					if (this.isLimitExceeded()) return false;
+					passed = false;
+				} else if (this.opts.unknwonProps === "strip") delete value[key];
+			}
+		}
+		return passed;
+	}
+	validatePrimitive(def, value) {
+		if (typeof def.type.value !== "undefined") {
+			if (value !== def.type.value) {
+				this.error(`Expected ${def.type.value}, got ${value}`);
+				return false;
+			}
+			return true;
+		}
+		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
+		switch (def.type.designType) {
+			case "never":
+				this.error(`This type is impossible, must be an internal problem`);
+				return false;
+			case "any": return true;
+			case "string":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateString(def, value);
+			case "number":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateNumber(def, value);
+			case "boolean":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "undefined":
+				if (value !== undefined) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "null":
+				if (value !== null) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			default: throw new Error(`Unknown type "${def.type.designType}"`);
+		}
+	}
+	validateString(def, value) {
+		const minLength = def.metadata.get("expect.minLength");
+		if (minLength) {
+			const length = typeof minLength === "number" ? minLength : minLength.length;
+			if (value.length < length) {
+				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} characters, got ${value.length} characters`;
+				this.error(message);
+				return false;
+			}
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (maxLength) {
+			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
+			if (value.length > length) {
+				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} characters, got ${value.length} characters`;
+				this.error(message);
+				return false;
+			}
+		}
+		const patterns = def.metadata.get("expect.pattern");
+		for (const { pattern, flags, message } of patterns || []) {
+			if (!pattern) continue;
+			const cacheKey = `${pattern}//${flags || ""}`;
+			let regex = regexCache.get(cacheKey);
+			if (!regex) {
+				regex = new RegExp(pattern, flags);
+				regexCache.set(cacheKey, regex);
+			}
+			if (!regex.test(value)) {
+				this.error(message || `Value is expected to match pattern "${pattern}"`);
+				return false;
+			}
+		}
+		return true;
+	}
+	validateNumber(def, value) {
+		const int = def.metadata.get("expect.int");
+		if (int && value % 1 !== 0) {
+			const message = typeof int === "object" && int.message ? int.message : `Expected integer, got ${value}`;
+			this.error(message);
+			return false;
+		}
+		const min = def.metadata.get("expect.min");
+		if (min) {
+			const minValue = typeof min === "number" ? min : min.minValue;
+			if (value < minValue) {
+				const message = typeof min === "object" && min.message ? min.message : `Expected minimum ${minValue}, got ${value}`;
+				this.error(message);
+				return false;
+			}
+		}
+		const max = def.metadata.get("expect.max");
+		if (max) {
+			const maxValue = typeof max === "number" ? max : max.maxValue;
+			if (value > maxValue) {
+				const message = typeof max === "object" && max.message ? max.message : `Expected maximum ${maxValue}, got ${value}`;
+				this.error(message);
+				return false;
+			}
+		}
+		return true;
+	}
+	constructor(def, opts) {
+		_define_property(this, "def", void 0);
+		_define_property(this, "opts", void 0);
+		/** 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);
+		this.def = def;
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [];
+		this.opts = {
+			partial: false,
+			unknwonProps: "error",
+			errorLimit: 10,
+			...opts,
+			plugins: opts?.plugins || []
+		};
+	}
+};
+var ValidatorError = class extends Error {
+	constructor(errors) {
+		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property(this, "errors", void 0), _define_property(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/annotated-type.ts
+function isAnnotatedType(type) {
+	return type && type.__is_atscript_annotated_type;
+}
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 
 /** Known foorm primitive extension tags that map directly to field types. */
 const FOORM_TAGS = new Set(['action', 'paragraph', 'select', 'radio', 'checkbox']);
@@ -85,22 +527,96 @@ function parseStaticOptions(raw) {
         return String(item);
     });
 }
-/**
- * Resolves a static annotation or a @foorm.fn.* computed annotation.
- * If the fn annotation exists, compiles it. Otherwise falls back to the
- * static annotation or the default value.
- */
-function resolveComputed(staticKey, fnKey, metadata, compileFn, defaultValue) {
+// Implementation
+function resolveProperty(fnKey, staticKey, metadata, options) {
+    const { transform, defaultValue, staticAsBoolean = false, compiler = compileFieldFn, } = options !== null && options !== void 0 ? options : {};
+    // Check for computed annotation first
     const fnStr = metadata.get(fnKey);
     if (typeof fnStr === 'string') {
-        return compileFn(fnStr);
+        return compiler(fnStr);
     }
-    const staticVal = metadata.get(staticKey);
-    if (staticVal !== undefined) {
-        return staticVal;
+    // Check for static annotation
+    if (staticKey !== undefined) {
+        const staticVal = metadata.get(staticKey);
+        if (staticVal !== undefined) {
+            if (staticAsBoolean) {
+                return true;
+            }
+            if (transform) {
+                return transform(staticVal);
+            }
+            return staticVal;
+        }
     }
+    // Return default or undefined
     return defaultValue;
 }
+/**
+ * Batch resolves multiple boolean constraints at once to reduce overhead.
+ * Returns an object with all constraint values (functions or booleans).
+ */
+function resolveConstraints(metadata, propOptional) {
+    var _a, _b, _c, _d;
+    return {
+        optional: (_a = resolveProperty('foorm.fn.optional', undefined, metadata)) !== null && _a !== void 0 ? _a : (propOptional !== null && propOptional !== void 0 ? propOptional : false),
+        disabled: (_b = resolveProperty('foorm.fn.disabled', 'foorm.disabled', metadata, {
+            staticAsBoolean: true,
+        })) !== null && _b !== void 0 ? _b : false,
+        hidden: (_c = resolveProperty('foorm.fn.hidden', 'foorm.hidden', metadata, {
+            staticAsBoolean: true,
+        })) !== null && _c !== void 0 ? _c : false,
+        readonly: (_d = resolveProperty('foorm.fn.readonly', 'foorm.readonly', metadata, {
+            staticAsBoolean: true,
+        })) !== null && _d !== void 0 ? _d : false,
+    };
+}
+/**
+ * Batch resolves multiple text properties at once.
+ * Empty strings are replaced with undefined to enable Vue optimization.
+ */
+function resolveTextProperties(metadata, fieldName) {
+    return {
+        label: resolveProperty('foorm.fn.label', 'meta.label', metadata, {
+            defaultValue: fieldName,
+        }),
+        description: resolveProperty('foorm.fn.description', 'meta.description', metadata),
+        hint: resolveProperty('foorm.fn.hint', 'meta.hint', metadata),
+        placeholder: resolveProperty('foorm.fn.placeholder', 'meta.placeholder', metadata),
+    };
+}
+/**
+ * Parses @foorm.attr and @foorm.fn.attr annotations into a Record<string, TComputed<unknown>>.
+ * Static attrs are direct key-value pairs, computed attrs are compiled functions.
+ */
+function parseAttrs(metadata) {
+    const staticAttrs = metadata.get('foorm.attr');
+    const fnAttrs = metadata.get('foorm.fn.attr');
+    if (!staticAttrs && !fnAttrs) {
+        return undefined;
+    }
+    const result = {};
+    // Process static @foorm.attr annotations
+    if (staticAttrs) {
+        const items = Array.isArray(staticAttrs) ? staticAttrs : [staticAttrs];
+        for (const item of items) {
+            if (typeof item === 'object' && item !== null && 'name' in item && 'value' in item) {
+                const { name, value } = item;
+                result[name] = value;
+            }
+        }
+    }
+    // Process computed @foorm.fn.attr annotations (override static if same name)
+    if (fnAttrs) {
+        const items = Array.isArray(fnAttrs) ? fnAttrs : [fnAttrs];
+        for (const item of items) {
+            if (typeof item === 'object' && item !== null && 'name' in item && 'fn' in item) {
+                const { name, fn } = item;
+                result[name] = compileFieldFn(fn);
+            }
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
 /**
  * Converts an ATScript annotated type into a TFoormModel.
  *
@@ -122,15 +638,18 @@ function createFoorm(type) {
     const metadata = type.metadata;
     const props = type.type.props;
     // Form-level metadata
-    const title = resolveComputed('foorm.title', 'foorm.fn.title', metadata, compileTopFn, '');
-    const submitText = resolveComputed('foorm.submit.text', 'foorm.fn.submit.text', metadata, compileTopFn, 'Submit');
-    const submitDisabled = (() => {
-        const fnStr = metadata.get('foorm.fn.submit.disabled');
-        if (typeof fnStr === 'string') {
-            return compileTopFn(fnStr);
-        }
-        return false;
-    })();
+    const title = resolveProperty('foorm.fn.title', 'foorm.title', metadata, {
+        compiler: compileTopFn,
+        defaultValue: '',
+    });
+    const submitText = resolveProperty('foorm.fn.submit.text', 'foorm.submit.text', metadata, {
+        compiler: compileTopFn,
+        defaultValue: 'Submit',
+    });
+    const submitDisabled = resolveProperty('foorm.fn.submit.disabled', 'foorm.submit.disabled', metadata, {
+        compiler: compileTopFn,
+        defaultValue: false,
+    });
     const submit = { text: submitText, disabled: submitDisabled };
     // Build fields from props
     const fields = [];
@@ -152,73 +671,42 @@ function createFoorm(type) {
                 }
             }
         }
-        const field = {
-            field: name,
-            type: fieldType,
-            component: pm.get('foorm.component'),
-            autocomplete: pm.get('foorm.autocomplete'),
-            altAction: pm.get('foorm.altAction'),
-            order: pm.get('foorm.order'),
-            name: name,
-            label: resolveComputed('meta.label', 'foorm.fn.label', pm, compileFieldFn, name),
-            description: resolveComputed('meta.description', 'foorm.fn.description', pm, compileFieldFn, ''),
-            hint: resolveComputed('meta.hint', 'foorm.fn.hint', pm, compileFieldFn, ''),
-            placeholder: resolveComputed('meta.placeholder', 'foorm.fn.placeholder', pm, compileFieldFn, ''),
-            optional: (() => {
+        // Add ATScript built-in validation (for @expect.* and semantic primitives like string.email)
+        // Check if field has ATScript validation requirements
+        const hasExpectConstraints = pm.get('expect.pattern') !== undefined ||
+            pm.get('expect.min') !== undefined ||
+            pm.get('expect.max') !== undefined ||
+            pm.get('expect.minLength') !== undefined ||
+            pm.get('expect.maxLength') !== undefined ||
+            pm.get('expect.int') !== undefined;
+        const hasTags = tags && tags.size > 0;
+        if (hasExpectConstraints || hasTags) {
+            // Create ATScript validator for this property
+            const propValidator = new Validator(prop);
+            validators.push((scope) => {
                 var _a;
-                const fnStr = pm.get('foorm.fn.optional');
-                if (typeof fnStr === 'string') {
-                    return compileFieldFn(fnStr);
-                }
-                return (_a = prop.optional) !== null && _a !== void 0 ? _a : false;
-            })(),
-            disabled: (() => {
-                const fnStr = pm.get('foorm.fn.disabled');
-                if (typeof fnStr === 'string') {
-                    return compileFieldFn(fnStr);
-                }
-                return pm.get('foorm.disabled') !== undefined;
-            })(),
-            hidden: (() => {
-                const fnStr = pm.get('foorm.fn.hidden');
-                if (typeof fnStr === 'string') {
-                    return compileFieldFn(fnStr);
-                }
-                return pm.get('foorm.hidden') !== undefined;
-            })(),
-            classes: (() => {
-                const fnStr = pm.get('foorm.fn.classes');
-                if (typeof fnStr === 'string') {
-                    return compileFieldFn(fnStr);
+                // ATScript validator in safe mode: returns true (pass) or false (fail)
+                // On failure, propValidator.errors contains error details
+                const isValid = propValidator.validate(scope.v, true);
+                if (isValid) {
+                    return true;
                 }
-                return undefined;
-            })(),
-            styles: (() => {
-                const fnStr = pm.get('foorm.fn.styles');
-                if (typeof fnStr === 'string') {
-                    return compileFieldFn(fnStr);
-                }
-                return undefined;
-            })(),
-            options: (() => {
-                const fnStr = pm.get('foorm.fn.options');
-                if (typeof fnStr === 'string') {
-                    return compileFieldFn(fnStr);
-                }
-                const staticOpts = pm.get('foorm.options');
-                if (staticOpts) {
-                    return parseStaticOptions(staticOpts);
-                }
-                return undefined;
-            })(),
-            value: pm.get('foorm.value'),
-            validators,
+                // Extract first error message from validator.errors
+                const firstError = (_a = propValidator.errors) === null || _a === void 0 ? void 0 : _a[0];
+                return (firstError === null || firstError === void 0 ? void 0 : firstError.message) || 'Validation failed';
+            });
+        }
+        const field = Object.assign(Object.assign(Object.assign({ field: name, type: fieldType, component: pm.get('foorm.component'), autocomplete: pm.get('foorm.autocomplete'), altAction: pm.get('foorm.altAction'), order: pm.get('foorm.order'), name: name }, resolveTextProperties(pm, name)), resolveConstraints(pm, prop.optional)), { 
+            // Appearance - truly optional
+            classes: resolveProperty('foorm.fn.classes', undefined, pm), styles: resolveProperty('foorm.fn.styles', undefined, pm), 
+            // Data properties - truly optional
+            options: resolveProperty('foorm.fn.options', 'foorm.options', pm, {
+                transform: parseStaticOptions,
+            }), value: resolveProperty('foorm.fn.value', 'foorm.value', pm), validators, 
+            // Custom attributes/props
+            attrs: parseAttrs(pm), 
             // ATScript @expect constraints
-            maxLength: pm.get('expect.maxLength'),
-            minLength: pm.get('expect.minLength'),
-            min: pm.get('expect.min'),
-            max: pm.get('expect.max'),
-        };
+            maxLength: pm.get('expect.maxLength'), minLength: pm.get('expect.minLength'), min: pm.get('expect.min'), max: pm.get('expect.max') });
         fields.push(field);
     }
     // Sort by explicit order, preserving original order for unordered fields