@atscript/ui-fns 0.1.58

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artem Maltsev <artem@maltsev.nl>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @atscript/ui-fns
+
+Opt-in plugin for [`@atscript/ui`](../ui) that adds **dynamic** field properties driven by `@ui.fn.*` annotations.
+
+Part of the [atscript-ui](https://github.com/moostjs/atscript-ui) monorepo.
+
+## Why it's a separate package
+
+`@ui.fn.*` annotations let `.as` schemas declare computed UI behaviour (e.g. `@ui.fn.disabled (form) => form.value.kind !== 'admin'`). Evaluating them requires `new Function` at runtime, which is incompatible with strict CSPs. Splitting the dynamic resolver into its own package keeps `@atscript/ui` CSP-safe by default — consumers opt in only when they need expressions.
+
+## Install
+
+```sh
+pnpm add @atscript/ui-fns
+```
+
+## Entry points
+
+| Subpath                   | What it exports                                                         |
+| ------------------------- | ----------------------------------------------------------------------- |
+| `@atscript/ui-fns`        | `FnFieldResolver` — drop-in replacement for the default `FieldResolver` |
+| `@atscript/ui-fns/plugin` | atscript build-time plugin that compiles `@ui.fn.*` bodies              |
+
+## License
+
+MIT © Artem Maltsev

package/dist/index.cjs

@@ -0,0 +1,169 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _atscript_ui = require("@atscript/ui");
+//#region src/runtime/fn-compiler.ts
+const pool = new (require("@prostojs/deserialize-fn")).FNPool();
+/**
+* Compiles a field-level function string from a `@ui.form.fn.*` / `@ui.table.fn.*` annotation
+* into a callable function. Uses FNPool for caching.
+*
+* The function string should be an arrow or regular function expression:
+*   `"(v, data, ctx, entry) => !data.firstName"`
+*
+* The compiled function receives a single TFnScope object:
+*   `{ v, data, context, entry }`
+*/
+function compileFieldFn(fnStr) {
+	const code = `return (${fnStr})(v, data, context, entry)`;
+	return pool.getFn(code);
+}
+/**
+* Compiles a form-level function string from a `@ui.form.fn.title` or similar annotation.
+*
+* The function string should be:
+*   `"(data, ctx) => someExpression"`
+*
+* The compiled function receives a single TFnScope object:
+*   `{ data, context }`
+*/
+function compileTopFn(fnStr) {
+	const code = `return (${fnStr})(data, context)`;
+	return pool.getFn(code);
+}
+/**
+* Compiles a validator function string.
+* Delegates to `compileFieldFn` with a narrowed return type.
+*
+* Returns `true` for valid, or a string error message for invalid.
+*/
+function compileValidatorFn(fnStr) {
+	return compileFieldFn(fnStr);
+}
+//#endregion
+//#region src/runtime/dynamic-resolver.ts
+/** Fn keys that store `[{ name, fn }]` arrays rather than a single fn string. */
+const ATTR_FN_KEYS = new Set([_atscript_ui.UI_FORM_FN_ATTR, _atscript_ui.UI_TABLE_FN_ATTR]);
+/**
+* Dynamic field resolver — extends static resolution with `new Function` compilation
+* for `ui.fn.*` annotation keys.
+*
+* Install via `installDynamicResolver()` from the package index.
+*/
+var DynamicFieldResolver = class {
+	resolveFieldProp(prop, fnKey, staticKey, scope, opts) {
+		if (ATTR_FN_KEYS.has(fnKey)) return this.resolveAttrFns(prop, fnKey, scope);
+		return resolveAnnotatedProp(prop.metadata, fnKey, staticKey, scope, compileFieldFn, opts);
+	}
+	resolveFormProp(type, fnKey, staticKey, scope, opts) {
+		return resolveAnnotatedProp(type.metadata, fnKey, staticKey, scope, compileTopFn, opts);
+	}
+	hasComputedAnnotations(prop) {
+		for (const key of prop.metadata.keys()) {
+			const k = key;
+			if (k.startsWith(_atscript_ui.UI_FORM_FN_PREFIX) || k.startsWith(_atscript_ui.UI_TABLE_FN_PREFIX)) return true;
+		}
+		return false;
+	}
+	resolveAttrFns(prop, fnKey, scope) {
+		const fnAttrs = prop.metadata.get(fnKey);
+		if (!fnAttrs) return void 0;
+		const result = {};
+		let hasAttrs = false;
+		for (const item of (0, _atscript_ui.asArray)(fnAttrs)) if (typeof item === "object" && item !== null && "name" in item && "fn" in item) {
+			const { name, fn } = item;
+			result[name] = compileFieldFn(fn)(scope);
+			hasAttrs = true;
+		}
+		return hasAttrs ? result : void 0;
+	}
+};
+function resolveAnnotatedProp(metadata, fnKey, staticKey, scope, compileFn, opts) {
+	const fnStr = metadata.get(fnKey);
+	if (typeof fnStr === "string") return compileFn(fnStr)(scope);
+	return (0, _atscript_ui.resolveStatic)(metadata, staticKey, opts);
+}
+/**
+* Builds a `TFieldEvaluated` entry and returns a full scope containing it.
+*
+* Implements the dual-scope pattern:
+* 1. Resolve constraints (disabled/hidden/readonly) from `baseScope`
+* 2. Assemble the entry object
+* 3. Build full scope (`{ ...baseScope, entry }`)
+* 4. Resolve options into the entry using the full scope
+*/
+function buildFieldEntry(prop, baseScope, path, opts) {
+	const boolOpts = { staticAsBoolean: true };
+	const scopeAsRecord = baseScope;
+	const entry = {
+		field: path,
+		type: opts?.type ?? (0, _atscript_ui.getFieldMeta)(prop, _atscript_ui.UI_FORM_TYPE) ?? (0, _atscript_ui.getFieldMeta)(prop, _atscript_ui.UI_TYPE) ?? "text",
+		component: opts?.component ?? (0, _atscript_ui.getFieldMeta)(prop, _atscript_ui.UI_FORM_COMPONENT),
+		name: opts?.name ?? path.slice(path.lastIndexOf(".") + 1),
+		optional: opts?.optional ?? prop.optional,
+		disabled: opts?.disabled ?? (0, _atscript_ui.resolveFieldProp)(prop, _atscript_ui.UI_FORM_FN_DISABLED, _atscript_ui.UI_FORM_DISABLED, scopeAsRecord, boolOpts),
+		hidden: opts?.hidden ?? (0, _atscript_ui.resolveFieldProp)(prop, _atscript_ui.UI_FORM_FN_HIDDEN, _atscript_ui.UI_FORM_HIDDEN, scopeAsRecord, boolOpts),
+		readonly: opts?.readonly ?? (0, _atscript_ui.resolveFieldProp)(prop, _atscript_ui.UI_FORM_FN_READONLY, _atscript_ui.META_READONLY, scopeAsRecord, boolOpts)
+	};
+	const scope = {
+		...baseScope,
+		entry
+	};
+	entry.options = (0, _atscript_ui.resolveOptions)(prop, scope);
+	return scope;
+}
+//#endregion
+//#region src/runtime/validator-plugin.ts
+/**
+* Creates an ATScript validator plugin that processes `@ui.form.validate` annotations
+* using compiled function strings.
+*
+* Usage:
+*   const plugin = uiFnsValidatorPlugin()
+*   const validator = new Validator(field.prop, { plugins: [plugin] })
+*   validator.validate(value, true, { data: formData, context })
+*/
+function uiFnsValidatorPlugin() {
+	return (ctx, def, value) => {
+		const hasValidators = (0, _atscript_ui.getFieldMeta)(def, _atscript_ui.UI_FORM_VALIDATE);
+		if (!hasValidators) return void 0;
+		const fnsCtx = ctx.context;
+		const scope = buildFieldEntry(def, {
+			v: value,
+			data: fnsCtx?.data ?? {},
+			context: fnsCtx?.context ?? {},
+			entry: void 0
+		}, ctx.path);
+		const fns = (0, _atscript_ui.asArray)(hasValidators);
+		for (const fnStr of fns) {
+			if (typeof fnStr !== "string") continue;
+			const result = compileValidatorFn(fnStr)(scope);
+			if (result !== true) {
+				ctx.error(typeof result === "string" ? result : "Validation failed");
+				return false;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* Installs the dynamic field resolver into @atscript/ui.
+* Call this once at app startup to enable `ui.fn.*` annotation resolution
+* and `@ui.form.validate` custom validator strings.
+*
+* ```ts
+* import { installDynamicResolver } from '@atscript/ui-fns'
+* installDynamicResolver()
+* ```
+*/
+function installDynamicResolver() {
+	(0, _atscript_ui.setResolver)(new DynamicFieldResolver());
+	(0, _atscript_ui.setDefaultValidatorPlugins)([uiFnsValidatorPlugin()]);
+}
+//#endregion
+exports.DynamicFieldResolver = DynamicFieldResolver;
+exports.buildFieldEntry = buildFieldEntry;
+exports.compileFieldFn = compileFieldFn;
+exports.compileTopFn = compileTopFn;
+exports.compileValidatorFn = compileValidatorFn;
+exports.installDynamicResolver = installDynamicResolver;
+exports.uiFnsValidatorPlugin = uiFnsValidatorPlugin;

package/dist/index.d.cts

@@ -0,0 +1,123 @@
+import { FieldResolver, TFormEntryOptions, TResolveOptions } from "@atscript/ui";
+import { TAtscriptAnnotatedType, TValidatorPlugin } from "@atscript/typescript/utils";
+
+//#region src/runtime/types.d.ts
+/**
+ * Scope object passed to compiled functions.
+ * Properties become variables inside compiled function strings:
+ *   v, data, context, entry
+ */
+interface TFnScope<V = unknown, D = Record<string, unknown>, C = Record<string, unknown>> {
+  v?: V;
+  data: D;
+  context: C;
+  entry?: TFieldEvaluated;
+  action?: string;
+}
+/**
+ * A value that is either static or a function of the fn scope.
+ */
+type TComputed<T> = T | ((scope: TFnScope) => T);
+/**
+ * Minimal evaluated snapshot of a field — passed to validators and
+ * computed functions as `entry`.
+ */
+interface TFieldEvaluated {
+  field: string;
+  type: string;
+  component?: string;
+  name: string;
+  disabled?: boolean;
+  optional?: boolean;
+  hidden?: boolean;
+  readonly?: boolean;
+  options?: TFormEntryOptions[];
+}
+//#endregion
+//#region src/runtime/fn-compiler.d.ts
+/**
+ * Compiles a field-level function string from a `@ui.form.fn.*` / `@ui.table.fn.*` annotation
+ * into a callable function. Uses FNPool for caching.
+ *
+ * The function string should be an arrow or regular function expression:
+ *   `"(v, data, ctx, entry) => !data.firstName"`
+ *
+ * The compiled function receives a single TFnScope object:
+ *   `{ v, data, context, entry }`
+ */
+declare function compileFieldFn<R = unknown>(fnStr: string): (scope: TFnScope) => R;
+/**
+ * Compiles a form-level function string from a `@ui.form.fn.title` or similar annotation.
+ *
+ * The function string should be:
+ *   `"(data, ctx) => someExpression"`
+ *
+ * The compiled function receives a single TFnScope object:
+ *   `{ data, context }`
+ */
+declare function compileTopFn<R = unknown>(fnStr: string): (scope: TFnScope) => R;
+/**
+ * Compiles a validator function string.
+ * Delegates to `compileFieldFn` with a narrowed return type.
+ *
+ * Returns `true` for valid, or a string error message for invalid.
+ */
+declare function compileValidatorFn(fnStr: string): (scope: TFnScope) => string | boolean;
+//#endregion
+//#region src/runtime/dynamic-resolver.d.ts
+/** Options for buildFieldEntry — allows pre-resolved overrides. */
+type TBuildFieldEntryOpts = Partial<Pick<TFieldEvaluated, "name" | "type" | "component" | "optional" | "disabled" | "hidden" | "readonly">>;
+/**
+ * Dynamic field resolver — extends static resolution with `new Function` compilation
+ * for `ui.fn.*` annotation keys.
+ *
+ * Install via `installDynamicResolver()` from the package index.
+ */
+declare class DynamicFieldResolver implements FieldResolver {
+  resolveFieldProp<T>(prop: TAtscriptAnnotatedType, fnKey: string, staticKey: string | undefined, scope: Record<string, unknown>, opts?: TResolveOptions<T>): T | undefined;
+  resolveFormProp<T>(type: TAtscriptAnnotatedType, fnKey: string, staticKey: string | undefined, scope: Record<string, unknown>, opts?: TResolveOptions<T>): T | undefined;
+  hasComputedAnnotations(prop: TAtscriptAnnotatedType): boolean;
+  private resolveAttrFns;
+}
+/**
+ * Builds a `TFieldEvaluated` entry and returns a full scope containing it.
+ *
+ * Implements the dual-scope pattern:
+ * 1. Resolve constraints (disabled/hidden/readonly) from `baseScope`
+ * 2. Assemble the entry object
+ * 3. Build full scope (`{ ...baseScope, entry }`)
+ * 4. Resolve options into the entry using the full scope
+ */
+declare function buildFieldEntry(prop: TAtscriptAnnotatedType, baseScope: TFnScope, path: string, opts?: TBuildFieldEntryOpts): TFnScope;
+//#endregion
+//#region src/runtime/validator-plugin.d.ts
+/** Per-call context passed via `validator.validate(value, safe, context)`. */
+interface TValidatorContext {
+  data: Record<string, unknown>;
+  context: Record<string, unknown>;
+}
+/**
+ * Creates an ATScript validator plugin that processes `@ui.form.validate` annotations
+ * using compiled function strings.
+ *
+ * Usage:
+ *   const plugin = uiFnsValidatorPlugin()
+ *   const validator = new Validator(field.prop, { plugins: [plugin] })
+ *   validator.validate(value, true, { data: formData, context })
+ */
+declare function uiFnsValidatorPlugin(): TValidatorPlugin;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Installs the dynamic field resolver into @atscript/ui.
+ * Call this once at app startup to enable `ui.fn.*` annotation resolution
+ * and `@ui.form.validate` custom validator strings.
+ *
+ * ```ts
+ * import { installDynamicResolver } from '@atscript/ui-fns'
+ * installDynamicResolver()
+ * ```
+ */
+declare function installDynamicResolver(): void;
+//#endregion
+export { DynamicFieldResolver, type TBuildFieldEntryOpts, type TComputed, type TFieldEvaluated, type TFnScope, type TValidatorContext, buildFieldEntry, compileFieldFn, compileTopFn, compileValidatorFn, installDynamicResolver, uiFnsValidatorPlugin };

package/dist/index.d.mts

@@ -0,0 +1,123 @@
+import { FieldResolver, TFormEntryOptions, TResolveOptions } from "@atscript/ui";
+import { TAtscriptAnnotatedType, TValidatorPlugin } from "@atscript/typescript/utils";
+
+//#region src/runtime/types.d.ts
+/**
+ * Scope object passed to compiled functions.
+ * Properties become variables inside compiled function strings:
+ *   v, data, context, entry
+ */
+interface TFnScope<V = unknown, D = Record<string, unknown>, C = Record<string, unknown>> {
+  v?: V;
+  data: D;
+  context: C;
+  entry?: TFieldEvaluated;
+  action?: string;
+}
+/**
+ * A value that is either static or a function of the fn scope.
+ */
+type TComputed<T> = T | ((scope: TFnScope) => T);
+/**
+ * Minimal evaluated snapshot of a field — passed to validators and
+ * computed functions as `entry`.
+ */
+interface TFieldEvaluated {
+  field: string;
+  type: string;
+  component?: string;
+  name: string;
+  disabled?: boolean;
+  optional?: boolean;
+  hidden?: boolean;
+  readonly?: boolean;
+  options?: TFormEntryOptions[];
+}
+//#endregion
+//#region src/runtime/fn-compiler.d.ts
+/**
+ * Compiles a field-level function string from a `@ui.form.fn.*` / `@ui.table.fn.*` annotation
+ * into a callable function. Uses FNPool for caching.
+ *
+ * The function string should be an arrow or regular function expression:
+ *   `"(v, data, ctx, entry) => !data.firstName"`
+ *
+ * The compiled function receives a single TFnScope object:
+ *   `{ v, data, context, entry }`
+ */
+declare function compileFieldFn<R = unknown>(fnStr: string): (scope: TFnScope) => R;
+/**
+ * Compiles a form-level function string from a `@ui.form.fn.title` or similar annotation.
+ *
+ * The function string should be:
+ *   `"(data, ctx) => someExpression"`
+ *
+ * The compiled function receives a single TFnScope object:
+ *   `{ data, context }`
+ */
+declare function compileTopFn<R = unknown>(fnStr: string): (scope: TFnScope) => R;
+/**
+ * Compiles a validator function string.
+ * Delegates to `compileFieldFn` with a narrowed return type.
+ *
+ * Returns `true` for valid, or a string error message for invalid.
+ */
+declare function compileValidatorFn(fnStr: string): (scope: TFnScope) => string | boolean;
+//#endregion
+//#region src/runtime/dynamic-resolver.d.ts
+/** Options for buildFieldEntry — allows pre-resolved overrides. */
+type TBuildFieldEntryOpts = Partial<Pick<TFieldEvaluated, "name" | "type" | "component" | "optional" | "disabled" | "hidden" | "readonly">>;
+/**
+ * Dynamic field resolver — extends static resolution with `new Function` compilation
+ * for `ui.fn.*` annotation keys.
+ *
+ * Install via `installDynamicResolver()` from the package index.
+ */
+declare class DynamicFieldResolver implements FieldResolver {
+  resolveFieldProp<T>(prop: TAtscriptAnnotatedType, fnKey: string, staticKey: string | undefined, scope: Record<string, unknown>, opts?: TResolveOptions<T>): T | undefined;
+  resolveFormProp<T>(type: TAtscriptAnnotatedType, fnKey: string, staticKey: string | undefined, scope: Record<string, unknown>, opts?: TResolveOptions<T>): T | undefined;
+  hasComputedAnnotations(prop: TAtscriptAnnotatedType): boolean;
+  private resolveAttrFns;
+}
+/**
+ * Builds a `TFieldEvaluated` entry and returns a full scope containing it.
+ *
+ * Implements the dual-scope pattern:
+ * 1. Resolve constraints (disabled/hidden/readonly) from `baseScope`
+ * 2. Assemble the entry object
+ * 3. Build full scope (`{ ...baseScope, entry }`)
+ * 4. Resolve options into the entry using the full scope
+ */
+declare function buildFieldEntry(prop: TAtscriptAnnotatedType, baseScope: TFnScope, path: string, opts?: TBuildFieldEntryOpts): TFnScope;
+//#endregion
+//#region src/runtime/validator-plugin.d.ts
+/** Per-call context passed via `validator.validate(value, safe, context)`. */
+interface TValidatorContext {
+  data: Record<string, unknown>;
+  context: Record<string, unknown>;
+}
+/**
+ * Creates an ATScript validator plugin that processes `@ui.form.validate` annotations
+ * using compiled function strings.
+ *
+ * Usage:
+ *   const plugin = uiFnsValidatorPlugin()
+ *   const validator = new Validator(field.prop, { plugins: [plugin] })
+ *   validator.validate(value, true, { data: formData, context })
+ */
+declare function uiFnsValidatorPlugin(): TValidatorPlugin;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Installs the dynamic field resolver into @atscript/ui.
+ * Call this once at app startup to enable `ui.fn.*` annotation resolution
+ * and `@ui.form.validate` custom validator strings.
+ *
+ * ```ts
+ * import { installDynamicResolver } from '@atscript/ui-fns'
+ * installDynamicResolver()
+ * ```
+ */
+declare function installDynamicResolver(): void;
+//#endregion
+export { DynamicFieldResolver, type TBuildFieldEntryOpts, type TComputed, type TFieldEvaluated, type TFnScope, type TValidatorContext, buildFieldEntry, compileFieldFn, compileTopFn, compileValidatorFn, installDynamicResolver, uiFnsValidatorPlugin };

package/dist/index.mjs

@@ -0,0 +1,163 @@
+import { META_READONLY, UI_FORM_COMPONENT, UI_FORM_DISABLED, UI_FORM_FN_ATTR, UI_FORM_FN_DISABLED, UI_FORM_FN_HIDDEN, UI_FORM_FN_PREFIX, UI_FORM_FN_READONLY, UI_FORM_HIDDEN, UI_FORM_TYPE, UI_FORM_VALIDATE, UI_TABLE_FN_ATTR, UI_TABLE_FN_PREFIX, UI_TYPE, asArray, getFieldMeta, resolveFieldProp, resolveOptions, resolveStatic, setDefaultValidatorPlugins, setResolver } from "@atscript/ui";
+import { FNPool } from "@prostojs/deserialize-fn";
+//#region src/runtime/fn-compiler.ts
+const pool = new FNPool();
+/**
+* Compiles a field-level function string from a `@ui.form.fn.*` / `@ui.table.fn.*` annotation
+* into a callable function. Uses FNPool for caching.
+*
+* The function string should be an arrow or regular function expression:
+*   `"(v, data, ctx, entry) => !data.firstName"`
+*
+* The compiled function receives a single TFnScope object:
+*   `{ v, data, context, entry }`
+*/
+function compileFieldFn(fnStr) {
+	const code = `return (${fnStr})(v, data, context, entry)`;
+	return pool.getFn(code);
+}
+/**
+* Compiles a form-level function string from a `@ui.form.fn.title` or similar annotation.
+*
+* The function string should be:
+*   `"(data, ctx) => someExpression"`
+*
+* The compiled function receives a single TFnScope object:
+*   `{ data, context }`
+*/
+function compileTopFn(fnStr) {
+	const code = `return (${fnStr})(data, context)`;
+	return pool.getFn(code);
+}
+/**
+* Compiles a validator function string.
+* Delegates to `compileFieldFn` with a narrowed return type.
+*
+* Returns `true` for valid, or a string error message for invalid.
+*/
+function compileValidatorFn(fnStr) {
+	return compileFieldFn(fnStr);
+}
+//#endregion
+//#region src/runtime/dynamic-resolver.ts
+/** Fn keys that store `[{ name, fn }]` arrays rather than a single fn string. */
+const ATTR_FN_KEYS = new Set([UI_FORM_FN_ATTR, UI_TABLE_FN_ATTR]);
+/**
+* Dynamic field resolver — extends static resolution with `new Function` compilation
+* for `ui.fn.*` annotation keys.
+*
+* Install via `installDynamicResolver()` from the package index.
+*/
+var DynamicFieldResolver = class {
+	resolveFieldProp(prop, fnKey, staticKey, scope, opts) {
+		if (ATTR_FN_KEYS.has(fnKey)) return this.resolveAttrFns(prop, fnKey, scope);
+		return resolveAnnotatedProp(prop.metadata, fnKey, staticKey, scope, compileFieldFn, opts);
+	}
+	resolveFormProp(type, fnKey, staticKey, scope, opts) {
+		return resolveAnnotatedProp(type.metadata, fnKey, staticKey, scope, compileTopFn, opts);
+	}
+	hasComputedAnnotations(prop) {
+		for (const key of prop.metadata.keys()) {
+			const k = key;
+			if (k.startsWith(UI_FORM_FN_PREFIX) || k.startsWith(UI_TABLE_FN_PREFIX)) return true;
+		}
+		return false;
+	}
+	resolveAttrFns(prop, fnKey, scope) {
+		const fnAttrs = prop.metadata.get(fnKey);
+		if (!fnAttrs) return void 0;
+		const result = {};
+		let hasAttrs = false;
+		for (const item of asArray(fnAttrs)) if (typeof item === "object" && item !== null && "name" in item && "fn" in item) {
+			const { name, fn } = item;
+			result[name] = compileFieldFn(fn)(scope);
+			hasAttrs = true;
+		}
+		return hasAttrs ? result : void 0;
+	}
+};
+function resolveAnnotatedProp(metadata, fnKey, staticKey, scope, compileFn, opts) {
+	const fnStr = metadata.get(fnKey);
+	if (typeof fnStr === "string") return compileFn(fnStr)(scope);
+	return resolveStatic(metadata, staticKey, opts);
+}
+/**
+* Builds a `TFieldEvaluated` entry and returns a full scope containing it.
+*
+* Implements the dual-scope pattern:
+* 1. Resolve constraints (disabled/hidden/readonly) from `baseScope`
+* 2. Assemble the entry object
+* 3. Build full scope (`{ ...baseScope, entry }`)
+* 4. Resolve options into the entry using the full scope
+*/
+function buildFieldEntry(prop, baseScope, path, opts) {
+	const boolOpts = { staticAsBoolean: true };
+	const scopeAsRecord = baseScope;
+	const entry = {
+		field: path,
+		type: opts?.type ?? getFieldMeta(prop, UI_FORM_TYPE) ?? getFieldMeta(prop, UI_TYPE) ?? "text",
+		component: opts?.component ?? getFieldMeta(prop, UI_FORM_COMPONENT),
+		name: opts?.name ?? path.slice(path.lastIndexOf(".") + 1),
+		optional: opts?.optional ?? prop.optional,
+		disabled: opts?.disabled ?? resolveFieldProp(prop, UI_FORM_FN_DISABLED, UI_FORM_DISABLED, scopeAsRecord, boolOpts),
+		hidden: opts?.hidden ?? resolveFieldProp(prop, UI_FORM_FN_HIDDEN, UI_FORM_HIDDEN, scopeAsRecord, boolOpts),
+		readonly: opts?.readonly ?? resolveFieldProp(prop, UI_FORM_FN_READONLY, META_READONLY, scopeAsRecord, boolOpts)
+	};
+	const scope = {
+		...baseScope,
+		entry
+	};
+	entry.options = resolveOptions(prop, scope);
+	return scope;
+}
+//#endregion
+//#region src/runtime/validator-plugin.ts
+/**
+* Creates an ATScript validator plugin that processes `@ui.form.validate` annotations
+* using compiled function strings.
+*
+* Usage:
+*   const plugin = uiFnsValidatorPlugin()
+*   const validator = new Validator(field.prop, { plugins: [plugin] })
+*   validator.validate(value, true, { data: formData, context })
+*/
+function uiFnsValidatorPlugin() {
+	return (ctx, def, value) => {
+		const hasValidators = getFieldMeta(def, UI_FORM_VALIDATE);
+		if (!hasValidators) return void 0;
+		const fnsCtx = ctx.context;
+		const scope = buildFieldEntry(def, {
+			v: value,
+			data: fnsCtx?.data ?? {},
+			context: fnsCtx?.context ?? {},
+			entry: void 0
+		}, ctx.path);
+		const fns = asArray(hasValidators);
+		for (const fnStr of fns) {
+			if (typeof fnStr !== "string") continue;
+			const result = compileValidatorFn(fnStr)(scope);
+			if (result !== true) {
+				ctx.error(typeof result === "string" ? result : "Validation failed");
+				return false;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* Installs the dynamic field resolver into @atscript/ui.
+* Call this once at app startup to enable `ui.fn.*` annotation resolution
+* and `@ui.form.validate` custom validator strings.
+*
+* ```ts
+* import { installDynamicResolver } from '@atscript/ui-fns'
+* installDynamicResolver()
+* ```
+*/
+function installDynamicResolver() {
+	setResolver(new DynamicFieldResolver());
+	setDefaultValidatorPlugins([uiFnsValidatorPlugin()]);
+}
+//#endregion
+export { DynamicFieldResolver, buildFieldEntry, compileFieldFn, compileTopFn, compileValidatorFn, installDynamicResolver, uiFnsValidatorPlugin };

package/dist/plugin.cjs

@@ -0,0 +1,156 @@
+let _atscript_core = require("@atscript/core");
+//#region src/plugin/annotations.ts
+/**
+* Validates a function string by attempting to compile it with `new Function`.
+* Used by `ui.form.fn.*` / `ui.table.fn.*` and `ui.form.validate` annotation validate hooks.
+*/
+function validateFnString(fnStr, range) {
+	try {
+		new Function("v", "data", "context", "entry", `return (${fnStr})(v, data, context, entry)`);
+	} catch (error) {
+		return [{
+			severity: 1,
+			message: `Invalid function string: ${error.message}`,
+			range
+		}];
+	}
+}
+function makeFnAnnotation(description, mode) {
+	return new _atscript_core.AnnotationSpec({
+		description,
+		nodeType: mode === "field" ? ["prop", "type"] : ["interface", "type"],
+		argument: {
+			name: "fn",
+			type: "string",
+			description: mode === "field" ? "JS function string: (value, data, context, entry) => result" : "JS function string: (data, context) => result"
+		},
+		validate: validateFirstArg
+	});
+}
+/** Shared validate hook: validates the fn string at args[0]. */
+function validateFirstArg(_token, args) {
+	if (args[0]) return validateFnString(args[0].text, args[0].range);
+}
+const fnAnnotation = (description) => makeFnAnnotation(description, "field");
+const fnTopAnnotation = (description) => makeFnAnnotation(description, "top");
+const TABLE_ROW_SCOPE_DOC = "Receives `{ row, ctx }` where `row` is the current row's data object and `ctx` carries table-level context (minimum keys: `searchTerm`, `filters`, `sorters`, `rowIndex`). Per-row+cell scope only — every expression must be meaningful when applied to a single cell.";
+function tableFnAnnotation(description) {
+	return new _atscript_core.AnnotationSpec({
+		description: `${description}\n\n${TABLE_ROW_SCOPE_DOC}`,
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "fn",
+			type: "string",
+			description: "JS function string evaluated against the per-row scope `{ row, ctx }`."
+		},
+		validate: validateFirstArg
+	});
+}
+const fnAttrSpec = new _atscript_core.AnnotationSpec({
+	description: "Computed custom attribute/prop. Name is the attribute/prop name, fn returns the value.",
+	nodeType: ["prop", "type"],
+	multiple: true,
+	mergeStrategy: "replace",
+	argument: [{
+		name: "name",
+		type: "string",
+		description: "Attribute/prop name (e.g., \"data-testid\", \"variant\", \"size\")"
+	}, {
+		name: "fn",
+		type: "string",
+		description: "JS function string: (value, data, context, entry) => any"
+	}],
+	validate(_token, args) {
+		if (args[1]) return validateFnString(args[1].text, args[1].range);
+	}
+});
+const tableFnAttrSpec = new _atscript_core.AnnotationSpec({
+	description: "Per-row computed attribute/prop applied to the rendered `<td>`. Name is the attribute/prop name, fn returns the value.\n\n" + TABLE_ROW_SCOPE_DOC,
+	nodeType: ["prop", "type"],
+	multiple: true,
+	mergeStrategy: "replace",
+	argument: [{
+		name: "name",
+		type: "string",
+		description: "Attribute/prop name (e.g., \"title\", \"data-row\", \"aria-label\")"
+	}, {
+		name: "fn",
+		type: "string",
+		description: "JS function string evaluated against the per-row scope `{ row, ctx }`."
+	}],
+	validate(_token, args) {
+		if (args[1]) return validateFnString(args[1].text, args[1].range);
+	}
+});
+/**
+* Annotation specs for dynamic computed annotations and `ui.form.validate`.
+*
+* Registered as atscript annotations via the `uiFnsPlugin()`.
+* Static `@ui.*` annotations and primitives are provided by `@atscript/ui/plugin`.
+*/
+const uiFnsAnnotations = { ui: {
+	form: {
+		validate: new _atscript_core.AnnotationSpec({
+			description: "Custom JS validator function string. Returns true for pass, or an error message string.",
+			nodeType: ["prop", "type"],
+			multiple: true,
+			mergeStrategy: "append",
+			argument: {
+				name: "fn",
+				type: "string",
+				description: "JS function string: (value, data, context, entry) => boolean | string"
+			},
+			validate: validateFirstArg
+		}),
+		fn: {
+			title: fnTopAnnotation("Computed form title: (data, context) => string"),
+			submit: {
+				text: fnTopAnnotation("Computed submit button text: (data, context) => string"),
+				disabled: fnTopAnnotation("Computed submit disabled state: (data, context) => boolean")
+			},
+			label: fnAnnotation("Computed label: (value, data, context, entry) => string"),
+			description: fnAnnotation("Computed description: (value, data, context, entry) => string"),
+			hint: fnAnnotation("Computed hint: (value, data, context, entry) => string"),
+			placeholder: fnAnnotation("Computed placeholder: (value, data, context, entry) => string"),
+			disabled: fnAnnotation("Computed disabled state: (value, data, context, entry) => boolean"),
+			hidden: fnAnnotation("Computed hidden state: (value, data, context, entry) => boolean"),
+			readonly: fnAnnotation("Computed readonly state: (value, data, context, entry) => boolean"),
+			value: fnAnnotation("Computed default value: (value, data, context, entry) => any"),
+			classes: fnAnnotation("Computed CSS classes: (value, data, context, entry) => string | Record<string, boolean>"),
+			styles: fnAnnotation("Computed inline styles: (value, data, context, entry) => string | Record<string, string>"),
+			options: fnAnnotation("Computed select/radio options: (value, data, context, entry) => Array"),
+			attr: fnAttrSpec
+		}
+	},
+	table: { fn: {
+		attr: tableFnAttrSpec,
+		classes: tableFnAnnotation("Per-row computed CSS classes for the cell `<td>`: `(row, ctx) => string | Record<string, boolean>`"),
+		styles: tableFnAnnotation("Per-row computed inline styles for the cell `<td>`: `(row, ctx) => string | Record<string, string>`")
+	} }
+} };
+//#endregion
+//#region src/plugin.ts
+/**
+* ATScript plugin that registers `ui.form.fn.*` / `ui.table.fn.*` computed annotations and `ui.form.validate`.
+*
+* Static `@ui.*` annotations and UI primitives are provided by `@atscript/ui/plugin`.
+*
+* Install in your `atscript.config.ts`:
+* ```ts
+* import uiFnsPlugin from '@atscript/ui-fns/plugin'
+*
+* export default {
+*   plugins: [uiFnsPlugin()],
+* }
+* ```
+*/
+function uiFnsPlugin() {
+	return {
+		name: "ui-fns",
+		config() {
+			return { annotations: uiFnsAnnotations };
+		}
+	};
+}
+//#endregion
+module.exports = uiFnsPlugin;

package/dist/plugin.d.cts

@@ -0,0 +1,19 @@
+import { TAtscriptPlugin } from "@atscript/core";
+
+//#region src/plugin.d.ts
+/**
+ * ATScript plugin that registers `ui.form.fn.*` / `ui.table.fn.*` computed annotations and `ui.form.validate`.
+ *
+ * Static `@ui.*` annotations and UI primitives are provided by `@atscript/ui/plugin`.
+ *
+ * Install in your `atscript.config.ts`:
+ * ```ts
+ * import uiFnsPlugin from '@atscript/ui-fns/plugin'
+ *
+ * export default {
+ *   plugins: [uiFnsPlugin()],
+ * }
+ * ```
+ */
+declare function uiFnsPlugin(): TAtscriptPlugin;
+export = uiFnsPlugin;

package/dist/plugin.d.mts

@@ -0,0 +1,20 @@
+import { TAtscriptPlugin } from "@atscript/core";
+
+//#region src/plugin.d.ts
+/**
+ * ATScript plugin that registers `ui.form.fn.*` / `ui.table.fn.*` computed annotations and `ui.form.validate`.
+ *
+ * Static `@ui.*` annotations and UI primitives are provided by `@atscript/ui/plugin`.
+ *
+ * Install in your `atscript.config.ts`:
+ * ```ts
+ * import uiFnsPlugin from '@atscript/ui-fns/plugin'
+ *
+ * export default {
+ *   plugins: [uiFnsPlugin()],
+ * }
+ * ```
+ */
+declare function uiFnsPlugin(): TAtscriptPlugin;
+//#endregion
+export { uiFnsPlugin as default };

package/dist/plugin.mjs

@@ -0,0 +1,156 @@
+import { AnnotationSpec } from "@atscript/core";
+//#region src/plugin/annotations.ts
+/**
+* Validates a function string by attempting to compile it with `new Function`.
+* Used by `ui.form.fn.*` / `ui.table.fn.*` and `ui.form.validate` annotation validate hooks.
+*/
+function validateFnString(fnStr, range) {
+	try {
+		new Function("v", "data", "context", "entry", `return (${fnStr})(v, data, context, entry)`);
+	} catch (error) {
+		return [{
+			severity: 1,
+			message: `Invalid function string: ${error.message}`,
+			range
+		}];
+	}
+}
+function makeFnAnnotation(description, mode) {
+	return new AnnotationSpec({
+		description,
+		nodeType: mode === "field" ? ["prop", "type"] : ["interface", "type"],
+		argument: {
+			name: "fn",
+			type: "string",
+			description: mode === "field" ? "JS function string: (value, data, context, entry) => result" : "JS function string: (data, context) => result"
+		},
+		validate: validateFirstArg
+	});
+}
+/** Shared validate hook: validates the fn string at args[0]. */
+function validateFirstArg(_token, args) {
+	if (args[0]) return validateFnString(args[0].text, args[0].range);
+}
+const fnAnnotation = (description) => makeFnAnnotation(description, "field");
+const fnTopAnnotation = (description) => makeFnAnnotation(description, "top");
+const TABLE_ROW_SCOPE_DOC = "Receives `{ row, ctx }` where `row` is the current row's data object and `ctx` carries table-level context (minimum keys: `searchTerm`, `filters`, `sorters`, `rowIndex`). Per-row+cell scope only — every expression must be meaningful when applied to a single cell.";
+function tableFnAnnotation(description) {
+	return new AnnotationSpec({
+		description: `${description}\n\n${TABLE_ROW_SCOPE_DOC}`,
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "fn",
+			type: "string",
+			description: "JS function string evaluated against the per-row scope `{ row, ctx }`."
+		},
+		validate: validateFirstArg
+	});
+}
+const fnAttrSpec = new AnnotationSpec({
+	description: "Computed custom attribute/prop. Name is the attribute/prop name, fn returns the value.",
+	nodeType: ["prop", "type"],
+	multiple: true,
+	mergeStrategy: "replace",
+	argument: [{
+		name: "name",
+		type: "string",
+		description: "Attribute/prop name (e.g., \"data-testid\", \"variant\", \"size\")"
+	}, {
+		name: "fn",
+		type: "string",
+		description: "JS function string: (value, data, context, entry) => any"
+	}],
+	validate(_token, args) {
+		if (args[1]) return validateFnString(args[1].text, args[1].range);
+	}
+});
+const tableFnAttrSpec = new AnnotationSpec({
+	description: "Per-row computed attribute/prop applied to the rendered `<td>`. Name is the attribute/prop name, fn returns the value.\n\n" + TABLE_ROW_SCOPE_DOC,
+	nodeType: ["prop", "type"],
+	multiple: true,
+	mergeStrategy: "replace",
+	argument: [{
+		name: "name",
+		type: "string",
+		description: "Attribute/prop name (e.g., \"title\", \"data-row\", \"aria-label\")"
+	}, {
+		name: "fn",
+		type: "string",
+		description: "JS function string evaluated against the per-row scope `{ row, ctx }`."
+	}],
+	validate(_token, args) {
+		if (args[1]) return validateFnString(args[1].text, args[1].range);
+	}
+});
+/**
+* Annotation specs for dynamic computed annotations and `ui.form.validate`.
+*
+* Registered as atscript annotations via the `uiFnsPlugin()`.
+* Static `@ui.*` annotations and primitives are provided by `@atscript/ui/plugin`.
+*/
+const uiFnsAnnotations = { ui: {
+	form: {
+		validate: new AnnotationSpec({
+			description: "Custom JS validator function string. Returns true for pass, or an error message string.",
+			nodeType: ["prop", "type"],
+			multiple: true,
+			mergeStrategy: "append",
+			argument: {
+				name: "fn",
+				type: "string",
+				description: "JS function string: (value, data, context, entry) => boolean | string"
+			},
+			validate: validateFirstArg
+		}),
+		fn: {
+			title: fnTopAnnotation("Computed form title: (data, context) => string"),
+			submit: {
+				text: fnTopAnnotation("Computed submit button text: (data, context) => string"),
+				disabled: fnTopAnnotation("Computed submit disabled state: (data, context) => boolean")
+			},
+			label: fnAnnotation("Computed label: (value, data, context, entry) => string"),
+			description: fnAnnotation("Computed description: (value, data, context, entry) => string"),
+			hint: fnAnnotation("Computed hint: (value, data, context, entry) => string"),
+			placeholder: fnAnnotation("Computed placeholder: (value, data, context, entry) => string"),
+			disabled: fnAnnotation("Computed disabled state: (value, data, context, entry) => boolean"),
+			hidden: fnAnnotation("Computed hidden state: (value, data, context, entry) => boolean"),
+			readonly: fnAnnotation("Computed readonly state: (value, data, context, entry) => boolean"),
+			value: fnAnnotation("Computed default value: (value, data, context, entry) => any"),
+			classes: fnAnnotation("Computed CSS classes: (value, data, context, entry) => string | Record<string, boolean>"),
+			styles: fnAnnotation("Computed inline styles: (value, data, context, entry) => string | Record<string, string>"),
+			options: fnAnnotation("Computed select/radio options: (value, data, context, entry) => Array"),
+			attr: fnAttrSpec
+		}
+	},
+	table: { fn: {
+		attr: tableFnAttrSpec,
+		classes: tableFnAnnotation("Per-row computed CSS classes for the cell `<td>`: `(row, ctx) => string | Record<string, boolean>`"),
+		styles: tableFnAnnotation("Per-row computed inline styles for the cell `<td>`: `(row, ctx) => string | Record<string, string>`")
+	} }
+} };
+//#endregion
+//#region src/plugin.ts
+/**
+* ATScript plugin that registers `ui.form.fn.*` / `ui.table.fn.*` computed annotations and `ui.form.validate`.
+*
+* Static `@ui.*` annotations and UI primitives are provided by `@atscript/ui/plugin`.
+*
+* Install in your `atscript.config.ts`:
+* ```ts
+* import uiFnsPlugin from '@atscript/ui-fns/plugin'
+*
+* export default {
+*   plugins: [uiFnsPlugin()],
+* }
+* ```
+*/
+function uiFnsPlugin() {
+	return {
+		name: "ui-fns",
+		config() {
+			return { annotations: uiFnsAnnotations };
+		}
+	};
+}
+//#endregion
+export { uiFnsPlugin as default };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@atscript/ui-fns",
+  "version": "0.1.58",
+  "description": "Dynamic fn-compiled field properties for @atscript/ui (opt-in, uses new Function)",
+  "keywords": [
+    "annotations",
+    "atscript",
+    "dynamic",
+    "expressions",
+    "form",
+    "metadata",
+    "type-driven",
+    "typescript"
+  ],
+  "homepage": "https://github.com/moostjs/atscript-ui/tree/main/packages/ui-fns#readme",
+  "bugs": {
+    "url": "https://github.com/moostjs/atscript-ui/issues"
+  },
+  "license": "MIT",
+  "author": "Artem Maltsev <artem@maltsev.nl>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/atscript-ui.git",
+    "directory": "packages/ui-fns"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.mts",
+      "import": "./dist/plugin.mjs",
+      "require": "./dist/plugin.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@prostojs/deserialize-fn": "^0.0.5",
+    "@atscript/ui": "^0.1.58"
+  },
+  "devDependencies": {
+    "@atscript/core": "^0.1.54",
+    "@atscript/typescript": "^0.1.54",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+  },
+  "peerDependencies": {
+    "@atscript/core": "^0.1.54",
+    "@atscript/typescript": "^0.1.54"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}