@foormjs/atscript 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 foormjs
+
+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,316 @@
+# @foormjs/atscript
+
+ATScript plugin for foormjs -- define forms declaratively with type-safe annotations.
+
+Writing form definitions in plain TypeScript means juggling objects, validator functions, and computed property boilerplate. ATScript lets you write all of that as annotations directly on your interface fields. The result is a `.as` file that reads like a specification: labels, placeholders, validators, computed properties, and options are all visible at a glance, right next to the fields they describe.
+
+The plugin provides primitives (`foorm.select`, `foorm.radio`, `foorm.checkbox`, `foorm.action`, `foorm.paragraph`), a full set of annotations for field metadata and computed behavior, and `createFoorm()` to convert annotated types into runtime `TFoormModel` objects.
+
+## Install
+
+```bash
+npm install @foormjs/atscript
+# or
+pnpm add @foormjs/atscript
+```
+
+Peer dependency: `@atscript/typescript` (for type generation).
+
+## Quick Start
+
+### 1. Configure the plugin
+
+```ts
+// atscript.config.ts
+import { defineConfig } from '@atscript/core'
+import ts from '@atscript/typescript'
+import { foormPlugin } from '@foormjs/atscript/plugin'
+
+export default defineConfig({
+  rootDir: 'src',
+  plugins: [ts(), foormPlugin()],
+})
+```
+
+### 2. Define a form
+
+```
+// login-form.as
+@foorm.title 'Sign In'
+@foorm.submit.text 'Log In'
+export interface LoginForm {
+    @meta.label 'Email'
+    @meta.placeholder 'you@example.com'
+    @foorm.autocomplete 'email'
+    @foorm.validate '(v) => !!v || "Email is required"'
+    @foorm.validate '(v) => v.includes("@") || "Invalid email"'
+    email: string
+
+    @meta.label 'Password'
+    @foorm.type 'password'
+    @foorm.validate '(v) => !!v || "Password is required"'
+    password: string
+
+    @meta.label 'Remember me'
+    rememberMe?: foorm.checkbox
+}
+```
+
+### 3. Use at runtime
+
+```ts
+import { createFoorm } from '@foormjs/atscript'
+import { createFormData, getFormValidator } from 'foorm'
+import { LoginForm } from './login-form.as'
+
+const form = createFoorm(LoginForm)
+const data = createFormData(form.fields)
+const validator = getFormValidator(form)
+```
+
+## Practical Examples
+
+### Static form with validation
+
+```
+@foorm.title 'Contact Us'
+@foorm.submit.text 'Send Message'
+export interface ContactForm {
+    @meta.label 'Your Name'
+    @meta.placeholder 'John Doe'
+    @foorm.validate '(v) => !!v || "Name is required"'
+    @foorm.order 1
+    name: string
+
+    @meta.label 'Email'
+    @foorm.autocomplete 'email'
+    @foorm.validate '(v) => !!v || "Email is required"'
+    @foorm.validate '(v) => v.includes("@") || "Enter a valid email"'
+    @foorm.order 2
+    email: string
+
+    @meta.label 'Message'
+    @foorm.validate '(v) => !!v || "Message is required"'
+    @foorm.validate '(v) => v.length >= 10 || "At least 10 characters"'
+    @foorm.order 3
+    message: string
+}
+```
+
+### Reactive form with computed properties
+
+Computed annotations (`@foorm.fn.*`) accept JavaScript function strings. Field-level functions receive `(value, data, context, entry)`, form-level functions receive `(data, context)`.
+
+```
+@foorm.fn.title '(data) => "Welcome, " + (data.firstName || "Guest")'
+@foorm.submit.text 'Register'
+@foorm.fn.submit.disabled '(data) => !data.firstName || !data.lastName'
+export interface SignupForm {
+    @meta.label 'First Name'
+    @meta.placeholder 'Alice'
+    @foorm.validate '(v) => !!v || "Required"'
+    @foorm.order 1
+    firstName: string
+
+    @meta.label 'Last Name'
+    @foorm.fn.placeholder '(v, data) => data.firstName ? "Same as " + data.firstName + "?" : "Doe"'
+    @foorm.validate '(v) => !!v || "Required"'
+    @foorm.order 2
+    lastName: string
+
+    @meta.label 'Password'
+    @foorm.type 'password'
+    @foorm.fn.disabled '(v, data) => !data.firstName || !data.lastName'
+    @foorm.validate '(v) => !!v || "Required"'
+    @foorm.validate '(v) => v.length >= 8 || "At least 8 characters"'
+    @foorm.order 3
+    password: string
+}
+```
+
+### Select, radio, and checkbox fields
+
+Use `foorm.select`, `foorm.radio`, and `foorm.checkbox` primitives with `@foorm.options` for static choices or `@foorm.fn.options` for dynamic choices from context:
+
+```
+export interface PreferencesForm {
+    // Static options
+    @meta.label 'Country'
+    @meta.placeholder 'Select a country'
+    @foorm.options 'United States', 'us'
+    @foorm.options 'Canada', 'ca'
+    @foorm.options 'United Kingdom', 'uk'
+    country?: foorm.select
+
+    // Options from context (backend-provided)
+    @meta.label 'City'
+    @meta.placeholder 'Select a city'
+    @foorm.fn.options '(v, data, context) => context.cityOptions || []'
+    city?: foorm.select
+
+    // Radio group
+    @meta.label 'Theme'
+    @foorm.options 'Light', 'light'
+    @foorm.options 'Dark', 'dark'
+    @foorm.options 'System', 'system'
+    theme?: foorm.radio
+
+    // Boolean checkbox
+    @meta.label 'I agree to the terms and conditions'
+    @foorm.validate '(v) => v === true || "You must agree"'
+    agreeToTerms: foorm.checkbox
+}
+```
+
+When using `@foorm.fn.options`, the backend passes option lists through the context object:
+
+```ts
+const context = {
+  cityOptions: [
+    { key: 'nyc', label: 'New York' },
+    { key: 'la', label: 'Los Angeles' },
+  ],
+}
+```
+
+### Non-data fields: paragraphs and actions
+
+```
+export interface WizardStep {
+    @meta.label 'Please review your information before submitting.'
+    info: foorm.paragraph
+
+    @meta.label 'First Name'
+    firstName: string
+
+    @meta.label 'Reset Form'
+    @foorm.altAction 'reset'
+    resetBtn: foorm.action
+}
+```
+
+Paragraphs render as static text. Actions render as buttons that emit events instead of submitting the form.
+
+## Annotations Reference
+
+### Form-Level Annotations
+
+| Annotation                                       | Description                                     |
+| ------------------------------------------------ | ----------------------------------------------- |
+| `@foorm.title 'text'`                            | Static form title                               |
+| `@foorm.submit.text 'text'`                      | Static submit button text (default: `"Submit"`) |
+| `@foorm.fn.title '(data, ctx) => ...'`           | Computed form title                             |
+| `@foorm.fn.submit.text '(data, ctx) => ...'`     | Computed submit button text                     |
+| `@foorm.fn.submit.disabled '(data, ctx) => ...'` | Computed submit disabled state                  |
+
+### Field-Level Static Annotations
+
+| Annotation                    | Description                                           |
+| ----------------------------- | ----------------------------------------------------- |
+| `@foorm.type 'text'`          | Field input type (text, password, number, date, etc.) |
+| `@foorm.component 'name'`     | Named component override for rendering                |
+| `@foorm.autocomplete 'value'` | HTML autocomplete attribute                           |
+| `@foorm.altAction 'name'`     | Alternate action name (for action fields)             |
+| `@foorm.value 'default'`      | Default field value                                   |
+| `@foorm.order N`              | Rendering order (lower = earlier)                     |
+| `@foorm.hidden`               | Mark field as statically hidden                       |
+| `@foorm.disabled`             | Mark field as statically disabled                     |
+
+### Options Annotation
+
+| Annotation                        | Description                                                                      |
+| --------------------------------- | -------------------------------------------------------------------------------- |
+| `@foorm.options 'Label', 'value'` | Add a static option. Repeat for each choice. Value defaults to label if omitted. |
+
+### Validation Annotation
+
+| Annotation                                | Description                                                                                   |
+| ----------------------------------------- | --------------------------------------------------------------------------------------------- |
+| `@foorm.validate '(v, data, ctx) => ...'` | Custom validator. Returns `true` to pass, or an error string. Repeat for multiple validators. |
+
+Validators run in declaration order and stop on first failure.
+
+### Computed (fn) Annotations
+
+All field-level computed functions receive `(value, data, context, entry)`:
+
+| Annotation              | Return type            | Description                     |
+| ----------------------- | ---------------------- | ------------------------------- |
+| `@foorm.fn.label`       | `string`               | Computed label                  |
+| `@foorm.fn.description` | `string`               | Computed description            |
+| `@foorm.fn.hint`        | `string`               | Computed hint text              |
+| `@foorm.fn.placeholder` | `string`               | Computed placeholder            |
+| `@foorm.fn.disabled`    | `boolean`              | Computed disabled state         |
+| `@foorm.fn.hidden`      | `boolean`              | Computed hidden state           |
+| `@foorm.fn.optional`    | `boolean`              | Computed optional state         |
+| `@foorm.fn.classes`     | `string \| Record`     | Computed CSS classes            |
+| `@foorm.fn.styles`      | `string \| Record`     | Computed inline styles          |
+| `@foorm.fn.options`     | `TFoormEntryOptions[]` | Computed options (select/radio) |
+
+### Metadata Annotations (from ATScript core)
+
+| Annotation                 | Description       |
+| -------------------------- | ----------------- |
+| `@meta.label 'text'`       | Field label       |
+| `@meta.description 'text'` | Field description |
+| `@meta.hint 'text'`        | Hint text         |
+| `@meta.placeholder 'text'` | Input placeholder |
+
+### Constraint Annotations (from ATScript core)
+
+| Annotation            | Description           |
+| --------------------- | --------------------- |
+| `@expect.maxLength N` | Maximum string length |
+| `@expect.minLength N` | Minimum string length |
+| `@expect.min N`       | Minimum numeric value |
+| `@expect.max N`       | Maximum numeric value |
+
+## Primitives
+
+| Primitive         | Underlying type | Description                       |
+| ----------------- | --------------- | --------------------------------- |
+| `foorm.select`    | `string`        | Dropdown select field             |
+| `foorm.radio`     | `string`        | Radio button group                |
+| `foorm.checkbox`  | `boolean`       | Single checkbox toggle            |
+| `foorm.action`    | phantom         | Button that emits an action event |
+| `foorm.paragraph` | phantom         | Static read-only text             |
+
+Phantom primitives are excluded from form data -- they exist only for UI rendering.
+
+## Plugin Options
+
+```ts
+foormPlugin({
+  // Extend allowed values for @foorm.type
+  extraTypes: ['tel', 'url', 'color'],
+
+  // Enable autocomplete for @foorm.component
+  components: ['CustomInput', 'DatePicker', 'RichTextEditor'],
+})
+```
+
+When `components` is provided, `@foorm.component` gets IDE autocomplete suggestions and compile-time validation against the list. When omitted, any string is accepted.
+
+When `extraTypes` is provided, the additional values are added to the built-in `@foorm.type` values (text, password, number, select, textarea, checkbox, radio, date, paragraph, action).
+
+## Field Type Resolution
+
+`createFoorm()` determines each field's type in this order:
+
+1. `@foorm.type` annotation (explicit override)
+2. Foorm primitive tag (`foorm.select`, `foorm.radio`, `foorm.checkbox`, `foorm.action`, `foorm.paragraph`)
+3. Default: `'text'`
+
+## Options Resolution
+
+For select and radio fields, options are resolved in this order:
+
+1. `@foorm.fn.options` (computed) -- if present, compiled as a function
+2. `@foorm.options` (static) -- parsed from annotation values
+3. `undefined` -- no options
+
+The computed path takes precedence, so you can define static fallbacks that are overridden when a `fn.options` annotation exists.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,233 @@
+'use strict';
+
+var deserializeFn = require('@prostojs/deserialize-fn');
+
+const pool = new deserializeFn.FNPool();
+/**
+ * Compiles a field-level function string from a @foorm.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 TFoormFnScope 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 @foorm.fn.title,
+ * @foorm.fn.submit.text, or @foorm.fn.submit.disabled annotation.
+ *
+ * The function string should be:
+ *   "(data, ctx) => someExpression"
+ *
+ * The compiled function receives a single TFoormFnScope object:
+ *   { data, context }
+ */
+function compileTopFn(fnStr) {
+    const code = `return (${fnStr})(data, context)`;
+    return pool.getFn(code);
+}
+/**
+ * Compiles a validator function string from a @foorm.validate annotation.
+ *
+ * The function string should be:
+ *   "(v, data, ctx) => boolean | string"
+ *
+ * The compiled function receives a single TFoormFnScope object:
+ *   { v, data, context }
+ */
+function compileValidatorFn(fnStr) {
+    const code = `return (${fnStr})(v, data, context)`;
+    return pool.getFn(code);
+}
+
+function foormValidatorPlugin(foormCtx) {
+    return (ctx, def, value) => {
+        var _a, _b, _c;
+        const validators = (_a = def.metadata) === null || _a === void 0 ? void 0 : _a.get('foorm.validate');
+        if (!validators) {
+            return undefined;
+        }
+        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 : {};
+        for (const fnStr of fns) {
+            if (typeof fnStr !== 'string') {
+                continue;
+            }
+            const fn = compileValidatorFn(fnStr);
+            const result = fn({ v: value, data, context });
+            if (result !== true) {
+                ctx.error(typeof result === 'string' ? result : 'Validation failed');
+                return false;
+            }
+        }
+        return undefined;
+    };
+}
+
+/** Known foorm primitive extension tags that map directly to field types. */
+const FOORM_TAGS = new Set(['action', 'paragraph', 'select', 'radio', 'checkbox']);
+/** Converts a static @foorm.options annotation value to TFoormEntryOptions[]. */
+function parseStaticOptions(raw) {
+    const items = Array.isArray(raw) ? raw : [raw];
+    return items.map(item => {
+        // Multi-arg annotations are stored as { label, value? }
+        if (typeof item === 'object' && item !== null && 'label' in item) {
+            const { label, value } = item;
+            return value !== undefined ? { key: value, label } : label;
+        }
+        // Plain string fallback (single-arg or raw value)
+        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) {
+    const fnStr = metadata.get(fnKey);
+    if (typeof fnStr === 'string') {
+        return compileFn(fnStr);
+    }
+    const staticVal = metadata.get(staticKey);
+    if (staticVal !== undefined) {
+        return staticVal;
+    }
+    return defaultValue;
+}
+/**
+ * Converts an ATScript annotated type into a TFoormModel.
+ *
+ * Reads @foorm.*, @meta.*, and @expect.* annotations from the type's
+ * metadata to build field definitions with static or computed properties.
+ *
+ * @example
+ * ```ts
+ * import { RegistrationForm } from './registration.as'
+ * import { createFoorm } from '@foormjs/atscript'
+ *
+ * const model = createFoorm(RegistrationForm)
+ * const data = createFormData(model.fields)
+ * const validator = getFormValidator(model)
+ * ```
+ */
+function createFoorm(type) {
+    var _a, _b;
+    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 submit = { text: submitText, disabled: submitDisabled };
+    // Build fields from props
+    const fields = [];
+    for (const [name, prop] of props.entries()) {
+        const pm = prop.metadata;
+        const tags = (_a = prop.type) === null || _a === void 0 ? void 0 : _a.tags;
+        // Determine field type from @foorm.type, foorm primitive tags, or default
+        const foormType = pm.get('foorm.type');
+        const foormTag = tags ? [...tags].find(t => FOORM_TAGS.has(t)) : undefined;
+        const fieldType = (_b = foormType !== null && foormType !== void 0 ? foormType : foormTag) !== null && _b !== void 0 ? _b : 'text';
+        // Build validators from @foorm.validate
+        const validators = [];
+        const validateAnnotation = pm.get('foorm.validate');
+        if (validateAnnotation) {
+            const fns = Array.isArray(validateAnnotation) ? validateAnnotation : [validateAnnotation];
+            for (const fnStr of fns) {
+                if (typeof fnStr === 'string') {
+                    validators.push(compileValidatorFn(fnStr));
+                }
+            }
+        }
+        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: (() => {
+                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);
+                }
+                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,
+            // ATScript @expect constraints
+            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
+    fields.sort((a, b) => { var _a, _b; return ((_a = a.order) !== null && _a !== void 0 ? _a : Infinity) - ((_b = b.order) !== null && _b !== void 0 ? _b : Infinity); });
+    return { title, submit, fields };
+}
+
+exports.compileFieldFn = compileFieldFn;
+exports.compileTopFn = compileTopFn;
+exports.compileValidatorFn = compileValidatorFn;
+exports.createFoorm = createFoorm;
+exports.foormValidatorPlugin = foormValidatorPlugin;

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+import { TFoormFnScope, TFoormModel } from 'foorm';
+import { TAtscriptAnnotatedType, TAtscriptTypeObject } from '@atscript/typescript/utils';
+
+/**
+ * ATScript validator plugin that processes @foorm.validate annotations.
+ *
+ * Reads the `foorm.validate` annotation value(s) from the metadata,
+ * compiles each function string, and executes it with the current value
+ * and form data/context from validator options.
+ *
+ * Usage:
+ *   import { foormValidatorPlugin } from '@foormjs/atscript'
+ *
+ *   const validator = MyForm.validator({
+ *     plugins: [foormValidatorPlugin()],
+ *   })
+ *
+ * Pass form data and context via validator options:
+ *   validator.validate(fieldValue, true) // safe mode
+ *
+ * For whole-form validation, iterate props and validate each field.
+ */
+interface TFoormValidatorContext {
+    data?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+type TValidatorPlugin = (ctx: any, def: any, value: unknown) => boolean | undefined;
+declare function foormValidatorPlugin(foormCtx?: TFoormValidatorContext): TValidatorPlugin;
+
+/**
+ * Compiles a field-level function string from a @foorm.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 TFoormFnScope object:
+ *   { v, data, context, entry }
+ */
+declare function compileFieldFn<R = unknown>(fnStr: string): (scope: TFoormFnScope) => R;
+/**
+ * Compiles a form-level function string from a @foorm.fn.title,
+ * @foorm.fn.submit.text, or @foorm.fn.submit.disabled annotation.
+ *
+ * The function string should be:
+ *   "(data, ctx) => someExpression"
+ *
+ * The compiled function receives a single TFoormFnScope object:
+ *   { data, context }
+ */
+declare function compileTopFn<R = unknown>(fnStr: string): (scope: TFoormFnScope) => R;
+/**
+ * Compiles a validator function string from a @foorm.validate annotation.
+ *
+ * The function string should be:
+ *   "(v, data, ctx) => boolean | string"
+ *
+ * The compiled function receives a single TFoormFnScope object:
+ *   { v, data, context }
+ */
+declare function compileValidatorFn(fnStr: string): (scope: TFoormFnScope) => boolean | string;
+
+/**
+ * Converts an ATScript annotated type into a TFoormModel.
+ *
+ * Reads @foorm.*, @meta.*, and @expect.* annotations from the type's
+ * metadata to build field definitions with static or computed properties.
+ *
+ * @example
+ * ```ts
+ * import { RegistrationForm } from './registration.as'
+ * import { createFoorm } from '@foormjs/atscript'
+ *
+ * const model = createFoorm(RegistrationForm)
+ * const data = createFormData(model.fields)
+ * const validator = getFormValidator(model)
+ * ```
+ */
+declare function createFoorm(type: TAtscriptAnnotatedType<TAtscriptTypeObject<any, any>>): TFoormModel;
+
+export { compileFieldFn, compileTopFn, compileValidatorFn, createFoorm, foormValidatorPlugin };
+export type { TFoormValidatorContext };