foorm 0.0.3 → 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

@@ -1 +1,263 @@
-# @foormjs/foorm
+# foorm
+
+Core form model for building validatable, reactive forms in any JavaScript environment.
+
+Forms are more than just inputs on a screen. They have conditional logic, validation rules that depend on other fields, labels that change based on context, and fields that appear or disappear based on user input. `foorm` captures all of this in a single, portable model where every property can be either a static value or a computed function. The same model works on the server for validation and on the client for rendering, with zero framework dependencies.
+
+## Install
+
+```bash
+npm install foorm
+# or
+pnpm add foorm
+```
+
+## Quick Start
+
+Define a form model and validate it:
+
+```ts
+import { createFormData, getFormValidator } from 'foorm'
+import type { TFoormModel } from 'foorm'
+
+const form: TFoormModel = {
+  title: 'Registration',
+  submit: { text: 'Create Account' },
+  fields: [
+    {
+      field: 'email',
+      type: 'text',
+      label: 'Email',
+      optional: false,
+      disabled: false,
+      hidden: false,
+      validators: [
+        s => !!s.v || 'Email is required',
+        s => String(s.v).includes('@') || 'Must be a valid email',
+      ],
+    },
+    {
+      field: 'age',
+      type: 'number',
+      label: 'Age',
+      optional: false,
+      disabled: false,
+      hidden: false,
+      validators: [
+        s => !!s.v || 'Age is required',
+        s => Number(s.v) >= 18 || 'Must be 18 or older',
+      ],
+    },
+  ],
+}
+
+// Create initial data from field defaults
+const data = createFormData(form.fields)
+// => { email: undefined, age: undefined }
+
+// Validate the entire form
+const validator = getFormValidator(form)
+const result = validator({ email: 'alice@example.com', age: 25 })
+// => { passed: true, errors: {} }
+```
+
+## Computed Properties
+
+The core idea behind foorm is `TComputed<T>` -- any field property can be either a static value or a function that reacts to form state:
+
+```ts
+import type { TFoormField } from 'foorm'
+
+const passwordField: TFoormField = {
+  field: 'password',
+  type: 'password',
+  label: 'Password',
+  optional: false,
+  hidden: false,
+
+  // Static placeholder
+  placeholder: 'Enter a strong password',
+
+  // Computed: disabled until name is filled
+  disabled: scope => !scope.data.name,
+
+  // Computed: hint changes based on value
+  hint: scope =>
+    scope.v ? `${8 - String(scope.v).length} more characters needed` : 'At least 8 characters',
+
+  validators: [
+    s => !!s.v || 'Password is required',
+    s => String(s.v).length >= 8 || 'At least 8 characters',
+  ],
+}
+```
+
+Every computed function receives a `TFoormFnScope` object:
+
+```ts
+interface TFoormFnScope {
+  v?: unknown // Current field value
+  data: Record<string, unknown> // All form data
+  context: Record<string, unknown> // External context (user info, locale, etc.)
+  entry?: TFoormFieldEvaluated // Evaluated field metadata
+}
+```
+
+The `context` object is your escape hatch for passing in external data -- user roles, locale strings, API-fetched options -- anything the form needs but doesn't own.
+
+## Using with ATScript
+
+While you can build `TFoormModel` objects by hand, the recommended approach is to use `@foormjs/atscript` to define forms declaratively in `.as` files:
+
+```
+@foorm.fn.title '(data) => "Hello, " + (data.name || "stranger")'
+@foorm.submit.text 'Register'
+export interface RegistrationForm {
+    @meta.label 'Name'
+    @foorm.validate '(v) => !!v || "Name is required"'
+    name: string
+
+    @meta.label 'Country'
+    @foorm.options 'United States', 'us'
+    @foorm.options 'Canada', 'ca'
+    country?: foorm.select
+}
+```
+
+Then convert it to a runtime model:
+
+```ts
+import { createFoorm } from '@foormjs/atscript'
+import { RegistrationForm } from './registration.as'
+
+const form = createFoorm(RegistrationForm)
+```
+
+See [`@foormjs/atscript`](../atscript) for the full annotation reference.
+
+## API Reference
+
+### `createFormData(fields)`
+
+Creates an initial data object from field definitions. Each field's `value` property becomes the default. Non-data fields (`action`, `paragraph`) are excluded.
+
+```ts
+const data = createFormData(form.fields)
+// => { email: undefined, name: 'Default Name', ... }
+```
+
+### `getFormValidator(model, context?)`
+
+Returns a reusable validator function for the entire form. The validator evaluates computed constraints per field, skips disabled/hidden fields, enforces required checks, then runs custom validators.
+
+```ts
+const validate = getFormValidator(form, { locale: 'en' })
+
+const result = validate(formData)
+// => { passed: false, errors: { email: 'Email is required' } }
+```
+
+Validation order per field:
+
+1. Skip if field type is `action` or `paragraph`
+2. Evaluate `disabled`, `optional`, `hidden` (may be computed)
+3. Skip if disabled or hidden
+4. If not optional and value is falsy, return `"Required"` error
+5. Run custom validators in order, stop on first failure
+
+### `validate(validators, scope)`
+
+Validates a single field by running its validators in sequence. Returns on first failure.
+
+```ts
+import { validate } from 'foorm'
+
+const result = validate(field.validators, { v: 'test', data, context: {} })
+if (!result.passed) {
+  console.log(result.error) // "Too short"
+}
+```
+
+### `evalComputed(value, scope)`
+
+Resolves a `TComputed<T>` value. If it's a function, calls it with the scope. Otherwise returns the static value.
+
+```ts
+import { evalComputed } from 'foorm'
+
+evalComputed('Hello', scope) // => 'Hello'
+evalComputed(s => `Hi ${s.data.name}`, scope) // => 'Hi Alice'
+```
+
+### `supportsAltAction(model, actionName)`
+
+Checks if any field in the model declares the given alternate action name.
+
+```ts
+if (supportsAltAction(form, 'save-draft')) {
+  // Show "Save Draft" button
+}
+```
+
+## Types
+
+### `TFoormModel`
+
+The complete form model:
+
+```ts
+interface TFoormModel {
+  title?: TComputed<string>
+  submit: TFoormSubmit
+  fields: TFoormField[]
+}
+```
+
+### `TFoormField`
+
+A single field definition. All description and constraint properties support `TComputed<T>`:
+
+| Property       | Type                                           | Description                                                       |
+| -------------- | ---------------------------------------------- | ----------------------------------------------------------------- |
+| `field`        | `string`                                       | Field identifier (required)                                       |
+| `type`         | `string`                                       | Input type: text, password, number, select, radio, checkbox, etc. |
+| `label`        | `TComputed<string>`                            | Field label                                                       |
+| `description`  | `TComputed<string>`                            | Descriptive text below the label                                  |
+| `hint`         | `TComputed<string>`                            | Hint text (shown when no error)                                   |
+| `placeholder`  | `TComputed<string>`                            | Input placeholder                                                 |
+| `optional`     | `TComputed<boolean>`                           | Whether the field is optional                                     |
+| `disabled`     | `TComputed<boolean>`                           | Whether the field is disabled                                     |
+| `hidden`       | `TComputed<boolean>`                           | Whether the field is hidden                                       |
+| `classes`      | `TComputed<string \| Record<string, boolean>>` | CSS classes                                                       |
+| `styles`       | `TComputed<string \| Record<string, string>>`  | Inline styles                                                     |
+| `options`      | `TComputed<TFoormEntryOptions[]>`              | Options for select/radio fields                                   |
+| `validators`   | `Array<(scope) => boolean \| string>`          | Validation functions                                              |
+| `component`    | `string`                                       | Named component override                                          |
+| `autocomplete` | `string`                                       | HTML autocomplete attribute                                       |
+| `altAction`    | `string`                                       | Alternate submit action name                                      |
+| `order`        | `number`                                       | Rendering order                                                   |
+| `value`        | `unknown`                                      | Default value                                                     |
+| `maxLength`    | `number`                                       | HTML maxlength constraint                                         |
+| `minLength`    | `number`                                       | HTML minlength constraint                                         |
+| `min`          | `number`                                       | HTML min constraint                                               |
+| `max`          | `number`                                       | HTML max constraint                                               |
+
+### `TFoormEntryOptions`
+
+Options for select and radio fields. Can be a simple string (used as both key and display label) or an object:
+
+```ts
+type TFoormEntryOptions = string | { key: string; label: string }
+```
+
+### `TComputed<T>`
+
+The union type that powers reactive properties:
+
+```ts
+type TComputed<T> = T | ((scope: TFoormFnScope) => T)
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -1,222 +1,101 @@
 'use strict';
 
-var ftring$1 = require('@prostojs/ftring');
-
-function isFtring(input) {
-    return (typeof input === 'object' &&
-        input.__is_ftring__ &&
-        typeof input.v === 'string');
-}
-function ftring(strings, __type__) {
-    return {
-        __is_ftring__: true,
-        v: strings.join(''),
-        __type__,
-    };
-}
-
-class Foorm {
-    constructor(opts) {
-        this.entries = (opts === null || opts === void 0 ? void 0 : opts.entries) || [];
-        this.submit = opts === null || opts === void 0 ? void 0 : opts.submit;
-        this.title = (opts === null || opts === void 0 ? void 0 : opts.title) || '';
-        this.context = (opts === null || opts === void 0 ? void 0 : opts.context) || {};
-    }
-    addEntry(entry) {
-        this.entries.push(entry);
-    }
-    setTitle(title) {
-        this.title = title;
-    }
-    setSubmit(submit) {
-        this.submit = submit;
-    }
-    setContext(context) {
-        this.context = context;
-    }
-    /**
-     * Normalizes form metadata and removes all the functions
-     * from validators.
-     *
-     * @param replaceContext a context to be transported along with metadata
-     * @returns form metadata without functions
-     */
-    transportable(replaceContext, replaceValues) {
-        var _a, _b;
-        return {
-            title: (_a = this.title) !== null && _a !== void 0 ? _a : '',
-            submit: (_b = this.submit) !== null && _b !== void 0 ? _b : { text: 'Submit' },
-            context: replaceContext || this.context,
-            entries: this.entries.map(e => (Object.assign(Object.assign({}, e), { value: replaceValues ? replaceValues[e.field] : e.value, validators: (e.validators || []).filter(v => isFtring(v)) }))),
-        };
-    }
-    normalizeEntry(e) {
-        return Object.assign(Object.assign({}, e), { name: e.name || e.field, label: e.label || e.field, type: e.type || 'text' });
-    }
-    /**
-     * Evaluates all the ftrings into functions, makes it ready for execution
-     *
-     * @returns form metadata with functions
-     */
-    executable() {
-        var _a, _b;
-        if (!this.fns) {
-            this.fns = new ftring$1.FtringsPool();
-        }
-        return {
-            title: transformFtrings(this.title || '', this.fns),
-            submit: {
-                text: transformFtrings(((_a = this.submit) === null || _a === void 0 ? void 0 : _a.text) || 'Submit', this.fns),
-                disabled: transformFtrings((_b = this.submit) === null || _b === void 0 ? void 0 : _b.disabled, this.fns),
-            },
-            context: this.context,
-            entries: this.entries
-                .map(e => this.normalizeEntry(e))
-                .map(e => (Object.assign(Object.assign({}, e), { 
-                // strings
-                label: transformFtrings(e.label, this.fns), description: transformFtrings(e.description, this.fns), hint: transformFtrings(e.hint, this.fns), placeholder: transformFtrings(e.placeholder, this.fns), 
-                // strings || objects
-                classes: transformFtringsInObj(e.classes, this.fns), styles: transformFtringsInObj(e.styles, this.fns), 
-                // booleans
-                optional: transformFtrings(e.optional, this.fns), disabled: transformFtrings(e.disabled, this.fns), hidden: transformFtrings(e.hidden, this.fns), validators: this.prepareValidators(e.validators), 
-                // options
-                options: transformFtrings(e.options, this.fns), 
-                // attrs
-                attrs: transformFtringsInObj(e.attrs, this.fns) }))),
-        };
-    }
-    createFormData() {
-        const data = {};
-        for (const entry of this.entries) {
-            if (entry.type !== 'action') {
-                data[entry.field] = (entry.value || undefined);
-            }
-        }
-        return data;
-    }
-    prepareValidators(_validators) {
-        const validators = (_validators || []).map(v => (isFtring(v) ? this.fns.getFn(v.v) : v));
-        validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
-        return validators;
-    }
-    supportsAltAction(altAction) {
-        return !!this.entries.some(e => e.altAction === altAction);
-    }
-    getFormValidator() {
-        if (!this.fns) {
-            this.fns = new ftring$1.FtringsPool();
-        }
-        const entries = this.executable().entries;
-        const fields = {};
-        for (const entry of entries) {
-            if (entry.field) {
-                fields[entry.field] = {
-                    entry,
-                    validators: this.prepareValidators(entry.validators),
-                };
-            }
-            fields[entry.field].validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
-        }
-        return (data) => {
-            let passed = true;
-            const errors = {};
-            for (const [key, value] of Object.entries(fields)) {
-                const evalEntry = Object.assign({}, value.entry);
-                const scope = {
-                    v: data[key],
-                    context: this.context,
-                    entry: {
-                        field: evalEntry.field,
-                        type: evalEntry.type,
-                        component: evalEntry.component,
-                        name: evalEntry.name,
-                        length: evalEntry.length,
-                    },
-                    data,
-                };
-                if (scope.entry) {
-                    if (typeof evalEntry.disabled === 'function') {
-                        scope.entry.disabled = evalEntry.disabled = evalEntry.disabled(scope);
-                    }
-                    else {
-                        scope.entry.disabled = evalEntry.disabled;
-                    }
-                    if (typeof evalEntry.optional === 'function') {
-                        scope.entry.optional = evalEntry.optional = evalEntry.optional(scope);
-                    }
-                    else {
-                        scope.entry.optional = evalEntry.optional;
-                    }
-                    if (typeof evalEntry.hidden === 'function') {
-                        scope.entry.hidden = evalEntry.hidden = evalEntry.hidden(scope);
-                    }
-                    else {
-                        scope.entry.hidden = evalEntry.hidden;
-                    }
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const result = validate({
-                    v: data[key],
-                    context: this.context,
-                    validators: value.validators,
-                    entry: scope.entry,
-                    data,
-                });
-                if (!result.passed) {
-                    passed = false;
-                    if (!errors[key]) {
-                        errors[key] = result.error || 'Wrong value';
-                    }
-                }
-            }
-            return {
-                passed,
-                errors,
-            };
-        };
+function evalComputed(value, scope) {
+    if (typeof value === 'function') {
+        return value(scope);
     }
+    return value;
 }
-function validate(opts) {
-    for (const validator of opts.validators || []) {
-        const result = validator({
-            v: opts.v,
-            context: opts.context,
-            data: opts.data,
-            entry: opts.entry,
-        });
+
+/**
+ * Runs validators for a single field. Returns on first failure.
+ */
+function validate(validators, scope) {
+    for (const validator of validators) {
+        const result = validator(scope);
         if (result !== true) {
             return {
                 passed: false,
-                error: result || 'Wrong value',
+                error: typeof result === 'string' ? result : 'Invalid value',
             };
         }
     }
     return { passed: true };
 }
-function transformFtrings(value, fns) {
-    if (value === undefined) {
-        return value;
+/** Field types that are UI-only elements, excluded from form data and validation. */
+const NON_DATA_TYPES = new Set(['action', 'paragraph']);
+/**
+ * Creates initial form data from field default values.
+ * Skips non-data field types (action, paragraph).
+ */
+function createFormData(fields) {
+    var _a;
+    const data = {};
+    for (const f of fields) {
+        if (!NON_DATA_TYPES.has(f.type)) {
+            data[f.field] = (_a = f.value) !== null && _a !== void 0 ? _a : undefined;
+        }
     }
-    return isFtring(value) ? fns.getFn(value.v) : value;
+    return data;
 }
-function transformFtringsInObj(value, fns) {
-    if (isFtring(value)) {
-        return transformFtrings(value, fns);
-    }
-    if (typeof value === 'function') {
-        return value;
-    }
-    if (typeof value === 'object' && value !== null) {
-        const obj = {};
-        for (const [key, val] of Object.entries(value)) {
-            obj[key] = transformFtrings(val, fns);
+/**
+ * Returns a validator function for the whole form.
+ * Evaluates disabled/hidden/optional per field, skips disabled/hidden,
+ * enforces required, then runs custom validators.
+ */
+function getFormValidator(model, context) {
+    return (data) => {
+        let passed = true;
+        const errors = {};
+        for (const f of model.fields) {
+            if (NON_DATA_TYPES.has(f.type)) {
+                continue;
+            }
+            const entry = {
+                field: f.field,
+                type: f.type,
+                component: f.component,
+                name: f.name || f.field,
+            };
+            const scope = {
+                v: data[f.field],
+                data,
+                context: (context !== null && context !== void 0 ? context : {}),
+                entry,
+            };
+            // Resolve computed constraints
+            entry.disabled = evalComputed(f.disabled, scope);
+            entry.optional = evalComputed(f.optional, scope);
+            entry.hidden = evalComputed(f.hidden, scope);
+            // Skip disabled and hidden fields
+            if (entry.disabled || entry.hidden) {
+                continue;
+            }
+            // Required check
+            if (!entry.optional && !data[f.field]) {
+                errors[f.field] = 'Required';
+                passed = false;
+                continue;
+            }
+            // Custom validators
+            const result = validate(f.validators, scope);
+            if (!result.passed) {
+                errors[f.field] = result.error;
+                passed = false;
+            }
         }
-        return obj;
-    }
-    return value;
+        return { passed, errors };
+    };
+}
+/**
+ * Checks if any field in the model declares the given altAction.
+ */
+function supportsAltAction(model, altAction) {
+    return model.fields.some(f => f.altAction === altAction);
 }
 
-exports.Foorm = Foorm;
-exports.ftring = ftring;
-exports.isFtring = isFtring;
+exports.createFormData = createFormData;
+exports.evalComputed = evalComputed;
+exports.getFormValidator = getFormValidator;
+exports.supportsAltAction = supportsAltAction;
 exports.validate = validate;

package/dist/index.d.ts

@@ -1,126 +1,115 @@
-interface TFtring {
-    __is_ftring__: true;
-    v: string;
-    __type__?: 'boolean' | 'string' | 'number';
-}
-type StringOrFtring = string | TFtring;
-type ObjSOF = Record<string, StringOrFtring>;
-interface TFoormFnScope<T = string> {
-    v?: T;
-    data: Record<string, unknown>;
-    context: Record<string, unknown>;
-    entry?: Pick<TFoormEntry<T, unknown, string, boolean>, TRelevantFields> & {
-        optional?: boolean;
-        disabled?: boolean;
-        hidden?: boolean;
-    };
+/**
+ * Scope object passed to computed functions.
+ * Properties become variables inside compiled function strings:
+ *   v, data, context, entry
+ */
+interface TFoormFnScope<V = unknown, D = Record<string, unknown>, C = Record<string, unknown>> {
+    v?: V;
+    data: D;
+    context: C;
+    entry?: TFoormFieldEvaluated;
     action?: string;
 }
-type TFoormValidatorFn<T = string> = (ctx: TFoormFnScope<T>) => string | boolean;
-type TFoormFn<T = string, R = string | boolean> = (ctx: TFoormFnScope<T>) => R;
-type TRelevantFields = 'field' | 'type' | 'component' | 'name' | 'attrs' | 'length';
+/**
+ * A value that is either static or a function of the form scope.
+ */
+type TComputed<T> = T | ((scope: TFoormFnScope) => T);
+/**
+ * Minimal evaluated snapshot of a field — passed to validators and
+ * computed functions as `entry`.
+ */
+interface TFoormFieldEvaluated {
+    field: string;
+    type: string;
+    component?: string;
+    name: string;
+    disabled?: boolean;
+    optional?: boolean;
+    hidden?: boolean;
+}
 type TFoormEntryOptions = {
     key: string;
     label: string;
 } | string;
-interface TFoormEntry<T = string, O = TFoormEntryOptions, SFTR = TFtring, BFTR = TFtring, FNFTR = TFtring, OFTR = TFtring> {
+/**
+ * A single form field definition with static or computed properties.
+ */
+interface TFoormField {
     field: string;
-    altAction?: string;
-    label?: string | SFTR;
-    description?: string | SFTR;
-    hint?: string | SFTR;
-    placeholder?: string | SFTR;
-    classes?: (string | SFTR) | Record<string, boolean | BFTR>;
-    styles?: (string | SFTR) | Record<string, string | SFTR>;
-    type?: string;
+    type: string;
     component?: string;
     autocomplete?: string;
+    altAction?: string;
+    order?: number;
     name?: string;
-    value?: T;
-    options?: O[] | OFTR;
-    attrs?: Record<string, string | SFTR>;
-    optional?: boolean | BFTR;
-    disabled?: boolean | BFTR;
-    hidden?: boolean | BFTR;
-    length?: number;
-    validators?: Array<FNFTR | TFoormValidatorFn<T>>;
-}
-type TFoormEntryExecutable<T = unknown, O = TFoormEntryOptions> = TFoormEntry<T, O, TFoormFn<T, string>, TFoormFn<T, boolean>, TFoormValidatorFn<T>, TFoormFn<T, O[]>> & {
-    name: string;
-    label: string | TFoormFn<T, string>;
-    type: string;
-};
-interface TFoormMetaExecutable {
-    title: string | TFoormFn<undefined, string>;
-    submit: {
-        text: string | TFoormFn<undefined, string>;
-        disabled: boolean | TFoormFn<undefined, boolean>;
-    };
-    context: Record<string, unknown>;
-    entries: TFoormEntryExecutable[];
-}
-
-interface TFoormSubmit<S = TFtring, B = TFtring> {
-    text: string | S;
-    disabled?: boolean | B;
+    label: TComputed<string>;
+    description?: TComputed<string>;
+    hint?: TComputed<string>;
+    placeholder?: TComputed<string>;
+    optional: TComputed<boolean>;
+    disabled: TComputed<boolean>;
+    hidden: TComputed<boolean>;
+    classes?: TComputed<string | Record<string, boolean>>;
+    styles?: TComputed<string | Record<string, string>>;
+    options?: TComputed<TFoormEntryOptions[]>;
+    attrs?: Record<string, TComputed<unknown>>;
+    value?: unknown;
+    validators: Array<(scope: TFoormFnScope) => boolean | string>;
+    maxLength?: number;
+    minLength?: number;
+    min?: number;
+    max?: number;
 }
-interface TFoormOptions {
-    title?: StringOrFtring;
-    entries: TFoormEntry[];
-    submit?: TFoormSubmit;
-    context?: Record<string, unknown>;
+/**
+ * Submit button configuration.
+ */
+interface TFoormSubmit {
+    text: TComputed<string>;
+    disabled?: TComputed<boolean>;
 }
-declare class Foorm {
-    protected entries: TFoormEntry[];
-    protected submit?: TFoormSubmit;
-    protected title?: StringOrFtring;
-    protected context: Record<string, unknown>;
-    private fns;
-    constructor(opts?: TFoormOptions);
-    addEntry(entry: TFoormEntry): void;
-    setTitle(title: string): void;
-    setSubmit(submit: TFoormSubmit): void;
-    setContext<T extends Record<string, unknown>>(context: T): void;
-    /**
-     * Normalizes form metadata and removes all the functions
-     * from validators.
-     *
-     * @param replaceContext a context to be transported along with metadata
-     * @returns form metadata without functions
-     */
-    transportable<T extends Record<string, unknown>>(replaceContext?: T, replaceValues?: Record<string, unknown>): Required<TFoormOptions> & {
-        context?: Record<string, unknown>;
-    };
-    protected normalizeEntry<T, O>(e: TFoormEntry<T, O>): TFoormEntry<T, O> & {
-        name: string;
-        label: string | TFtring;
-        type: string;
-    };
-    /**
-     * Evaluates all the ftrings into functions, makes it ready for execution
-     *
-     * @returns form metadata with functions
-     */
-    executable(): TFoormMetaExecutable;
-    createFormData<T extends Record<string, unknown>>(): T;
-    prepareValidators(_validators: TFoormEntry['validators']): TFoormValidatorFn<string>[];
-    supportsAltAction(altAction: string): boolean;
-    getFormValidator(): (inputs: Record<string, unknown>) => {
-        passed: boolean;
-        errors: Record<string, string>;
-    };
+/**
+ * Complete form model — produced by createFoorm() in @foormjs/atscript.
+ */
+interface TFoormModel {
+    title?: TComputed<string>;
+    submit: TFoormSubmit;
+    fields: TFoormField[];
 }
-declare function validate<T = string>(opts: TFoormFnScope<T> & {
-    validators: Array<TFoormValidatorFn<T>>;
-}): {
-    passed: boolean;
-    error: string;
+
+/**
+ * Runs validators for a single field. Returns on first failure.
+ */
+declare function validate(validators: TFoormField['validators'], scope: TFoormFnScope): {
+    passed: true;
 } | {
+    passed: false;
+    error: string;
+};
+/**
+ * Creates initial form data from field default values.
+ * Skips non-data field types (action, paragraph).
+ */
+declare function createFormData<T = Record<string, unknown>>(fields: TFoormField[]): T;
+/**
+ * Returns a validator function for the whole form.
+ * Evaluates disabled/hidden/optional per field, skips disabled/hidden,
+ * enforces required, then runs custom validators.
+ */
+declare function getFormValidator(model: TFoormModel, context?: unknown): (data: Record<string, unknown>) => {
     passed: boolean;
-    error?: undefined;
+    errors: Record<string, string>;
 };
+/**
+ * Checks if any field in the model declares the given altAction.
+ */
+declare function supportsAltAction(model: TFoormModel, altAction: string): boolean;
 
-declare function isFtring(input: unknown): input is TFtring;
-declare function ftring(strings: TemplateStringsArray, __type__?: TFtring['__type__']): TFtring;
+/**
+ * Resolves a TComputed value: if it's a function, calls it with
+ * the scope. Otherwise returns the static value as-is.
+ */
+declare function evalComputed<T>(value: TComputed<T>, scope: TFoormFnScope): T;
+declare function evalComputed<T>(value: TComputed<T> | undefined, scope: TFoormFnScope): T | undefined;
 
-export { Foorm, type ObjSOF, type StringOrFtring, type TFoormEntry, type TFoormEntryExecutable, type TFoormEntryOptions, type TFoormFn, type TFoormFnScope, type TFoormMetaExecutable, type TFoormOptions, type TFoormSubmit, type TFoormValidatorFn, type TFtring, ftring, isFtring, validate };
+export { createFormData, evalComputed, getFormValidator, supportsAltAction, validate };
+export type { TComputed, TFoormEntryOptions, TFoormField, TFoormFieldEvaluated, TFoormFnScope, TFoormModel, TFoormSubmit };

package/dist/index.mjs

@@ -1,217 +1,95 @@
-import { FtringsPool } from '@prostojs/ftring';
-
-function isFtring(input) {
-    return (typeof input === 'object' &&
-        input.__is_ftring__ &&
-        typeof input.v === 'string');
-}
-function ftring(strings, __type__) {
-    return {
-        __is_ftring__: true,
-        v: strings.join(''),
-        __type__,
-    };
-}
-
-class Foorm {
-    constructor(opts) {
-        this.entries = (opts === null || opts === void 0 ? void 0 : opts.entries) || [];
-        this.submit = opts === null || opts === void 0 ? void 0 : opts.submit;
-        this.title = (opts === null || opts === void 0 ? void 0 : opts.title) || '';
-        this.context = (opts === null || opts === void 0 ? void 0 : opts.context) || {};
-    }
-    addEntry(entry) {
-        this.entries.push(entry);
-    }
-    setTitle(title) {
-        this.title = title;
-    }
-    setSubmit(submit) {
-        this.submit = submit;
-    }
-    setContext(context) {
-        this.context = context;
-    }
-    /**
-     * Normalizes form metadata and removes all the functions
-     * from validators.
-     *
-     * @param replaceContext a context to be transported along with metadata
-     * @returns form metadata without functions
-     */
-    transportable(replaceContext, replaceValues) {
-        var _a, _b;
-        return {
-            title: (_a = this.title) !== null && _a !== void 0 ? _a : '',
-            submit: (_b = this.submit) !== null && _b !== void 0 ? _b : { text: 'Submit' },
-            context: replaceContext || this.context,
-            entries: this.entries.map(e => (Object.assign(Object.assign({}, e), { value: replaceValues ? replaceValues[e.field] : e.value, validators: (e.validators || []).filter(v => isFtring(v)) }))),
-        };
-    }
-    normalizeEntry(e) {
-        return Object.assign(Object.assign({}, e), { name: e.name || e.field, label: e.label || e.field, type: e.type || 'text' });
-    }
-    /**
-     * Evaluates all the ftrings into functions, makes it ready for execution
-     *
-     * @returns form metadata with functions
-     */
-    executable() {
-        var _a, _b;
-        if (!this.fns) {
-            this.fns = new FtringsPool();
-        }
-        return {
-            title: transformFtrings(this.title || '', this.fns),
-            submit: {
-                text: transformFtrings(((_a = this.submit) === null || _a === void 0 ? void 0 : _a.text) || 'Submit', this.fns),
-                disabled: transformFtrings((_b = this.submit) === null || _b === void 0 ? void 0 : _b.disabled, this.fns),
-            },
-            context: this.context,
-            entries: this.entries
-                .map(e => this.normalizeEntry(e))
-                .map(e => (Object.assign(Object.assign({}, e), { 
-                // strings
-                label: transformFtrings(e.label, this.fns), description: transformFtrings(e.description, this.fns), hint: transformFtrings(e.hint, this.fns), placeholder: transformFtrings(e.placeholder, this.fns), 
-                // strings || objects
-                classes: transformFtringsInObj(e.classes, this.fns), styles: transformFtringsInObj(e.styles, this.fns), 
-                // booleans
-                optional: transformFtrings(e.optional, this.fns), disabled: transformFtrings(e.disabled, this.fns), hidden: transformFtrings(e.hidden, this.fns), validators: this.prepareValidators(e.validators), 
-                // options
-                options: transformFtrings(e.options, this.fns), 
-                // attrs
-                attrs: transformFtringsInObj(e.attrs, this.fns) }))),
-        };
-    }
-    createFormData() {
-        const data = {};
-        for (const entry of this.entries) {
-            if (entry.type !== 'action') {
-                data[entry.field] = (entry.value || undefined);
-            }
-        }
-        return data;
-    }
-    prepareValidators(_validators) {
-        const validators = (_validators || []).map(v => (isFtring(v) ? this.fns.getFn(v.v) : v));
-        validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
-        return validators;
-    }
-    supportsAltAction(altAction) {
-        return !!this.entries.some(e => e.altAction === altAction);
-    }
-    getFormValidator() {
-        if (!this.fns) {
-            this.fns = new FtringsPool();
-        }
-        const entries = this.executable().entries;
-        const fields = {};
-        for (const entry of entries) {
-            if (entry.field) {
-                fields[entry.field] = {
-                    entry,
-                    validators: this.prepareValidators(entry.validators),
-                };
-            }
-            fields[entry.field].validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
-        }
-        return (data) => {
-            let passed = true;
-            const errors = {};
-            for (const [key, value] of Object.entries(fields)) {
-                const evalEntry = Object.assign({}, value.entry);
-                const scope = {
-                    v: data[key],
-                    context: this.context,
-                    entry: {
-                        field: evalEntry.field,
-                        type: evalEntry.type,
-                        component: evalEntry.component,
-                        name: evalEntry.name,
-                        length: evalEntry.length,
-                    },
-                    data,
-                };
-                if (scope.entry) {
-                    if (typeof evalEntry.disabled === 'function') {
-                        scope.entry.disabled = evalEntry.disabled = evalEntry.disabled(scope);
-                    }
-                    else {
-                        scope.entry.disabled = evalEntry.disabled;
-                    }
-                    if (typeof evalEntry.optional === 'function') {
-                        scope.entry.optional = evalEntry.optional = evalEntry.optional(scope);
-                    }
-                    else {
-                        scope.entry.optional = evalEntry.optional;
-                    }
-                    if (typeof evalEntry.hidden === 'function') {
-                        scope.entry.hidden = evalEntry.hidden = evalEntry.hidden(scope);
-                    }
-                    else {
-                        scope.entry.hidden = evalEntry.hidden;
-                    }
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const result = validate({
-                    v: data[key],
-                    context: this.context,
-                    validators: value.validators,
-                    entry: scope.entry,
-                    data,
-                });
-                if (!result.passed) {
-                    passed = false;
-                    if (!errors[key]) {
-                        errors[key] = result.error || 'Wrong value';
-                    }
-                }
-            }
-            return {
-                passed,
-                errors,
-            };
-        };
+function evalComputed(value, scope) {
+    if (typeof value === 'function') {
+        return value(scope);
     }
+    return value;
 }
-function validate(opts) {
-    for (const validator of opts.validators || []) {
-        const result = validator({
-            v: opts.v,
-            context: opts.context,
-            data: opts.data,
-            entry: opts.entry,
-        });
+
+/**
+ * Runs validators for a single field. Returns on first failure.
+ */
+function validate(validators, scope) {
+    for (const validator of validators) {
+        const result = validator(scope);
         if (result !== true) {
             return {
                 passed: false,
-                error: result || 'Wrong value',
+                error: typeof result === 'string' ? result : 'Invalid value',
             };
         }
     }
     return { passed: true };
 }
-function transformFtrings(value, fns) {
-    if (value === undefined) {
-        return value;
+/** Field types that are UI-only elements, excluded from form data and validation. */
+const NON_DATA_TYPES = new Set(['action', 'paragraph']);
+/**
+ * Creates initial form data from field default values.
+ * Skips non-data field types (action, paragraph).
+ */
+function createFormData(fields) {
+    var _a;
+    const data = {};
+    for (const f of fields) {
+        if (!NON_DATA_TYPES.has(f.type)) {
+            data[f.field] = (_a = f.value) !== null && _a !== void 0 ? _a : undefined;
+        }
     }
-    return isFtring(value) ? fns.getFn(value.v) : value;
+    return data;
 }
-function transformFtringsInObj(value, fns) {
-    if (isFtring(value)) {
-        return transformFtrings(value, fns);
-    }
-    if (typeof value === 'function') {
-        return value;
-    }
-    if (typeof value === 'object' && value !== null) {
-        const obj = {};
-        for (const [key, val] of Object.entries(value)) {
-            obj[key] = transformFtrings(val, fns);
+/**
+ * Returns a validator function for the whole form.
+ * Evaluates disabled/hidden/optional per field, skips disabled/hidden,
+ * enforces required, then runs custom validators.
+ */
+function getFormValidator(model, context) {
+    return (data) => {
+        let passed = true;
+        const errors = {};
+        for (const f of model.fields) {
+            if (NON_DATA_TYPES.has(f.type)) {
+                continue;
+            }
+            const entry = {
+                field: f.field,
+                type: f.type,
+                component: f.component,
+                name: f.name || f.field,
+            };
+            const scope = {
+                v: data[f.field],
+                data,
+                context: (context !== null && context !== void 0 ? context : {}),
+                entry,
+            };
+            // Resolve computed constraints
+            entry.disabled = evalComputed(f.disabled, scope);
+            entry.optional = evalComputed(f.optional, scope);
+            entry.hidden = evalComputed(f.hidden, scope);
+            // Skip disabled and hidden fields
+            if (entry.disabled || entry.hidden) {
+                continue;
+            }
+            // Required check
+            if (!entry.optional && !data[f.field]) {
+                errors[f.field] = 'Required';
+                passed = false;
+                continue;
+            }
+            // Custom validators
+            const result = validate(f.validators, scope);
+            if (!result.passed) {
+                errors[f.field] = result.error;
+                passed = false;
+            }
         }
-        return obj;
-    }
-    return value;
+        return { passed, errors };
+    };
+}
+/**
+ * Checks if any field in the model declares the given altAction.
+ */
+function supportsAltAction(model, altAction) {
+    return model.fields.some(f => f.altAction === altAction);
 }
 
-export { Foorm, ftring, isFtring, validate };
+export { createFormData, evalComputed, getFormValidator, supportsAltAction, validate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foorm",
-  "version": "0.0.3",
+  "version": "0.2.0",
   "description": "foorm",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -34,7 +34,7 @@
     "url": "https://github.com/foormjs/foormjs/issues"
   },
   "homepage": "https://github.com/foormjs/foormjs/tree/main/packages/foorm#readme",
-  "dependencies": {
-    "@prostojs/ftring": "^0.0.4"
+  "scripts": {
+    "pub": "pnpm publish --access public --no-git-checks"
   }
-}
+}