foorm 0.1.0 → 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,246 +1,101 @@
 'use strict';
 
-var deserializeFn = require('@prostojs/deserialize-fn');
-var serializeFn = require('@prostojs/serialize-fn');
-
-function evalParameter(fn, scope, forField) {
-    if (typeof fn === 'function') {
-        if (fn.__deserialized) {
-            return fn(scope);
-        }
-        else {
-            const args = (forField
-                ? [scope.v, scope.data, scope.context, scope.entry]
-                : [scope.data, scope.context, scope.entry]);
-            return fn(...args);
-        }
+function evalComputed(value, scope) {
+    if (typeof value === 'function') {
+        return value(scope);
     }
-    return fn;
+    return value;
 }
 
-/* eslint-disable no-inner-declarations */
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-class Foorm {
-    // private fns!: FNPool<string | boolean, TFoormFnScope>
-    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;
-    }
-    getDefinition() {
-        return {
-            title: this.title,
-            submit: this.submit || { text: 'Submit' },
-            context: this.context,
-            entries: this.entries,
-        };
-    }
-    normalizeEntry(e) {
-        return Object.assign(Object.assign({}, e), { name: e.name || e.field, label: (e.label || e.field), type: e.type || 'text' });
-    }
-    executable() {
-        return {
-            title: this.title || '',
-            submit: this.submit || { text: 'Submit' },
-            context: this.context,
-            entries: this.entries.map(e => this.normalizeEntry(e)),
-        };
-    }
-    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 || [];
-        validators.unshift((v, _d, _c, entry) => entry.optional || !!v || 'Required');
-        return validators;
-    }
-    supportsAltAction(altAction) {
-        return !!this.entries.some(e => e.altAction === altAction);
-    }
-    getFormValidator() {
-        const entries = this.executable().entries;
-        const fields = {};
-        for (const entry of entries) {
-            if (entry.field) {
-                const validators = this.prepareValidators(entry.validators);
-                fields[entry.field] = {
-                    entry,
-                    validators,
-                };
-                fields[entry.field].validators = validators;
-            }
-        }
-        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: data,
-                };
-                if (scope.entry) {
-                    scope.entry.disabled = evalParameter(evalEntry.disabled, scope, true);
-                    scope.entry.optional = evalParameter(evalEntry.optional, scope, true);
-                    scope.entry.hidden = evalParameter(evalEntry.hidden, scope, true);
-                }
-                // 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: data,
-                });
-                if (!result.passed) {
-                    passed = false;
-                    if (!errors[key]) {
-                        errors[key] = result.error || 'Wrong value';
-                    }
-                }
-            }
-            return {
-                passed,
-                errors,
-            };
-        };
-    }
-}
-function validate(opts) {
-    for (const validator of opts.validators || []) {
-        const result = evalParameter(validator, {
-            v: opts.v,
-            context: opts.context,
-            data: opts.data,
-            entry: opts.entry,
-        }, true);
+/**
+ * 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 };
 }
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const pool = new deserializeFn.FNPool();
-function deserializeForm(form) {
-    return new Foorm({
-        title: deserializeComputedFn(form.title),
-        context: form.context,
-        submit: deserializeComputedFn(form.submit, true),
-        entries: form.entries.map(e => (Object.assign(Object.assign({}, e), { 
-            // strings
-            label: deserializeComputedFn(e.label), description: deserializeComputedFn(e.description), hint: deserializeComputedFn(e.hint), placeholder: deserializeComputedFn(e.placeholder), 
-            // strings || objects
-            classes: deserializeComputedFn(e.classes, true), styles: deserializeComputedFn(e.styles, true), 
-            // booleans
-            optional: deserializeComputedFn(e.optional), disabled: deserializeComputedFn(e.disabled), hidden: deserializeComputedFn(e.hidden), 
-            // options
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-            options: deserializeComputedFn(e.options), 
-            // attrs
-            attrs: deserializeComputedFn(e.attrs, true), 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            value: e.value, validators: (e.validators || []).map(fn => deserializeComputedFn(fn)) }))),
-    });
-}
-function deserializeComputedFn(v, asObj) {
-    if (typeof v === 'object' && typeof v.__fn__ === 'string') {
-        const fn = pool.getFn(v.__fn__);
-        fn.__deserialized = true;
-        return fn;
-    }
-    if (typeof v === 'object' && asObj) {
-        const o = {};
-        for (const [key, val] of Object.entries(v)) {
-            o[key] = deserializeComputedFn(val);
+/** 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 o;
     }
-    return v;
+    return data;
 }
-
-/* eslint-disable @typescript-eslint/naming-convention */
-function serializeForm(form, opts) {
-    const def = form.getDefinition();
-    return {
-        title: serializeComputedFn(def.title),
-        submit: {
-            text: serializeComputedFn(def.submit.text || 'Submit'),
-            disabled: serializeComputedFn(def.submit.disabled),
-        },
-        context: (opts === null || opts === void 0 ? void 0 : opts.replaceContext) || def.context,
-        entries: def.entries.map(e => (Object.assign(Object.assign({}, e), { 
-            // strings
-            label: serializeComputedFnWithVal(e.label), description: serializeComputedFnWithVal(e.description), hint: serializeComputedFnWithVal(e.hint), placeholder: serializeComputedFnWithVal(e.placeholder), 
-            // strings || objects
-            classes: serializeComputedFnWithVal(e.classes, true), styles: serializeComputedFnWithVal(e.styles, true), 
-            // booleans
-            optional: serializeComputedFnWithVal(e.optional), disabled: serializeComputedFnWithVal(e.disabled), hidden: serializeComputedFnWithVal(e.hidden), 
-            // options
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-            options: serializeComputedFnWithVal(e.options), 
-            // attrs
-            attrs: serializeComputedFnWithVal(e.attrs, true), 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            value: (opts === null || opts === void 0 ? void 0 : opts.replaceValues) ? opts.replaceValues[e.field] : e.value, validators: (e.validators || [])
-                .filter(v => serializeFn.isCleanFn(v))
-                .map(fn => serializeComputedFnWithVal(fn)) }))),
+/**
+ * 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 { passed, errors };
     };
 }
-function serializeComputedFn(fn) {
-    if (typeof fn === 'function') {
-        return { __fn__: serializeFn.serializeFn(fn, 'data', 'context') };
-    }
-    return fn;
-}
-function serializeComputedFnWithVal(fn, inObj) {
-    if (inObj && typeof fn === 'object') {
-        const o = {};
-        for (const [key, val] of Object.entries(fn)) {
-            o[key] = serializeComputedFnWithVal(val);
-        }
-        return o;
-    }
-    if (typeof fn === 'function') {
-        return { __fn__: serializeFn.serializeFn(fn, 'v', 'data', 'context', 'entry') };
-    }
-    return fn;
+/**
+ * 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.deserializeForm = deserializeForm;
-exports.evalParameter = evalParameter;
-exports.serializeForm = serializeForm;
+exports.createFormData = createFormData;
+exports.evalComputed = evalComputed;
+exports.getFormValidator = getFormValidator;
+exports.supportsAltAction = supportsAltAction;
 exports.validate = validate;

package/dist/index.d.ts

@@ -1,158 +1,115 @@
-type TFoormFnTop<OF, D, C> = (data: D, ctx: C) => OF;
-type TFoormFnField<OF, V, D, C> = (v: V, data: D, ctx: C, entry: TFoormEntryEvaluated) => OF;
-interface TFoormFnSerializedTop<OF, D, C> {
-    (ctx: TFoormFnScope<undefined, D, C>): OF;
-    __deserialized?: boolean;
-}
-interface TFoormFnSerializedField<OF, V, D, C> {
-    (ctx: TFoormFnScope<V, D, C>): OF;
-    __deserialized?: boolean;
-}
-type TComputed<OF, D, C> = OF | TFoormFnTop<OF, D, C> | TFoormFnSerializedTop<OF, D, C>;
-type TComputedWithVal<OF, V, D, C> = OF | TFoormFnField<OF, V, D, C> | TFoormFnSerializedField<OF, V, D, C>;
-interface TFoormFnScope<V = string, D = Record<string, unknown>, C = Record<string, unknown>> {
+/**
+ * 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?: TFoormEntryEvaluated;
+    entry?: TFoormFieldEvaluated;
     action?: string;
 }
-type TFoormValidatorFn<V, D, C> = Exclude<Exclude<TComputedWithVal<boolean | string, V, D, C>, boolean>, string>;
+/**
+ * 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<V, D, C, O extends TFoormEntryOptions> {
+/**
+ * A single form field definition with static or computed properties.
+ */
+interface TFoormField {
     field: string;
-    altAction?: string;
-    label?: TComputedWithVal<string, V, D, C>;
-    description?: TComputedWithVal<string, V, D, C>;
-    hint?: TComputedWithVal<string, V, D, C>;
-    placeholder?: TComputedWithVal<string, V, D, C>;
-    classes?: TComputedWithVal<string, V, D, C> | Record<string, TComputedWithVal<boolean, V, D, C>>;
-    styles?: TComputedWithVal<string, V, D, C> | Record<string, TComputedWithVal<string, V, D, C>>;
-    type?: string;
+    type: string;
     component?: string;
     autocomplete?: string;
+    altAction?: string;
+    order?: number;
     name?: string;
-    value?: V;
-    options?: O[] | TComputedWithVal<O[], V, D, C>;
-    attrs?: Record<string, TComputedWithVal<any, V, D, C>>;
-    optional?: TComputedWithVal<boolean, V, D, C>;
-    disabled?: TComputedWithVal<boolean, V, D, C>;
-    hidden?: TComputedWithVal<boolean, V, D, C>;
-    length?: number;
-    validators?: Array<TFoormValidatorFn<V, D, C>>;
-}
-interface TFoormMetaExecutable<D, C> {
-    title: TComputed<string, D, C>;
-    submit: {
-        text: TComputed<string, D, C>;
-        disabled?: TComputed<boolean, D, C>;
-    };
-    context: C;
-    entries: Array<TFoormEntry<any, D, C, TFoormEntryOptions>>;
+    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 TSerializedFn {
-    __fn__: string;
+/**
+ * Submit button configuration.
+ */
+interface TFoormSubmit {
+    text: TComputed<string>;
+    disabled?: TComputed<boolean>;
 }
-interface TFoormSerialized<V = any, O = any> {
-    title?: string | TSerializedFn;
-    submit: {
-        text: string | TSerializedFn;
-        disabled: boolean | TSerializedFn;
-    };
-    context: any;
-    entries: Array<{
-        field: string;
-        altAction?: string;
-        label?: string | TSerializedFn;
-        description?: string | TSerializedFn;
-        hint?: string | TSerializedFn;
-        placeholder?: string | TSerializedFn;
-        classes?: string | TSerializedFn | Record<string, TSerializedFn>;
-        styles?: string | TSerializedFn | Record<string, string | TSerializedFn>;
-        type?: string;
-        component?: string;
-        autocomplete?: string;
-        name?: string;
-        value?: V;
-        options?: O[] | TSerializedFn;
-        attrs?: Record<string, string | TSerializedFn>;
-        optional?: TSerializedFn;
-        disabled?: TSerializedFn;
-        hidden?: TSerializedFn;
-        length?: number;
-        validators?: TSerializedFn[];
-    }>;
-}
-interface TFoormEntryEvaluated {
-    field: string;
-    type: string;
-    component?: string;
-    name: string;
-    length?: number;
-    disabled?: boolean;
-    optional?: boolean;
-    hidden?: boolean;
+/**
+ * Complete form model — produced by createFoorm() in @foormjs/atscript.
+ */
+interface TFoormModel {
+    title?: TComputed<string>;
+    submit: TFoormSubmit;
+    fields: TFoormField[];
 }
 
-interface TFoormOptions<D, C> {
-    title?: TComputed<string, D, C>;
-    entries: Array<TFoormEntry<any, D, C, TFoormEntryOptions>>;
-    submit?: TFoormMetaExecutable<D, C>['submit'];
-    context?: C;
-}
-declare class Foorm<D = any, C = any> {
-    protected entries: Array<TFoormEntry<any, D, C, TFoormEntryOptions>>;
-    protected submit?: TFoormMetaExecutable<D, C>['submit'];
-    protected title?: TComputed<string, D, C>;
-    protected context: C;
-    constructor(opts?: TFoormOptions<D, C>);
-    addEntry<V>(entry: TFoormEntry<V, D, C, TFoormEntryOptions>): void;
-    setTitle(title: string): void;
-    setSubmit(submit: TFoormMetaExecutable<D, C>['submit']): void;
-    setContext(context: C): void;
-    getDefinition(): {
-        title: TComputed<string, D, C> | undefined;
-        submit: {
-            text: TComputed<string, D, C>;
-            disabled?: TComputed<boolean, D, C> | undefined;
-        };
-        context: C;
-        entries: TFoormEntry<any, D, C, TFoormEntryOptions>[];
-    };
-    protected normalizeEntry<V, O extends TFoormEntryOptions>(e: TFoormEntry<V, D, C, O>): TFoormEntry<V, D, C, O> & {
-        name: string;
-        label: TComputed<string, D, C>;
-        type: string;
-    };
-    executable(): TFoormMetaExecutable<D, C>;
-    createFormData<T extends Record<string, unknown>>(): T;
-    prepareValidators(_validators: TFoormEntry<any, D, C, TFoormEntryOptions>['validators']): TFoormValidatorFn<any, D, C>[];
-    supportsAltAction(altAction: string): boolean;
-    getFormValidator(): (inputs: Record<string, unknown>) => {
-        passed: boolean;
-        errors: Record<string, string>;
-    };
-}
-declare function validate<V, D, C>(opts: TFoormFnScope<V, D, C> & {
-    validators: TFoormEntry<any, D, C, TFoormEntryOptions>['validators'];
-}): {
-    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 deserializeForm<D = unknown, C = unknown>(form: TFoormSerialized): Foorm<D, C>;
-
-declare function serializeForm<D, C>(form: Foorm<D, C>, opts?: {
-    replaceContext?: C;
-    replaceValues?: Record<string, unknown>;
-}): TFoormSerialized;
-
-declare function evalParameter<OF>(fn: TComputed<OF, any, any> | TComputedWithVal<OF, any, any, any>, scope: TFoormFnScope<any, any, any>, forField?: boolean): OF | undefined;
+/**
+ * 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 TComputed, type TComputedWithVal, type TFoormEntry, type TFoormEntryEvaluated, type TFoormEntryOptions, type TFoormFnField, type TFoormFnScope, type TFoormFnSerializedField, type TFoormFnSerializedTop, type TFoormFnTop, type TFoormMetaExecutable, type TFoormOptions, type TFoormSerialized, type TFoormValidatorFn, type TSerializedFn, deserializeForm, evalParameter, serializeForm, validate };
+export { createFormData, evalComputed, getFormValidator, supportsAltAction, validate };
+export type { TComputed, TFoormEntryOptions, TFoormField, TFoormFieldEvaluated, TFoormFnScope, TFoormModel, TFoormSubmit };

package/dist/index.mjs

@@ -1,240 +1,95 @@
-import { FNPool } from '@prostojs/deserialize-fn';
-import { isCleanFn, serializeFn } from '@prostojs/serialize-fn';
-
-function evalParameter(fn, scope, forField) {
-    if (typeof fn === 'function') {
-        if (fn.__deserialized) {
-            return fn(scope);
-        }
-        else {
-            const args = (forField
-                ? [scope.v, scope.data, scope.context, scope.entry]
-                : [scope.data, scope.context, scope.entry]);
-            return fn(...args);
-        }
+function evalComputed(value, scope) {
+    if (typeof value === 'function') {
+        return value(scope);
     }
-    return fn;
+    return value;
 }
 
-/* eslint-disable no-inner-declarations */
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-class Foorm {
-    // private fns!: FNPool<string | boolean, TFoormFnScope>
-    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;
-    }
-    getDefinition() {
-        return {
-            title: this.title,
-            submit: this.submit || { text: 'Submit' },
-            context: this.context,
-            entries: this.entries,
-        };
-    }
-    normalizeEntry(e) {
-        return Object.assign(Object.assign({}, e), { name: e.name || e.field, label: (e.label || e.field), type: e.type || 'text' });
-    }
-    executable() {
-        return {
-            title: this.title || '',
-            submit: this.submit || { text: 'Submit' },
-            context: this.context,
-            entries: this.entries.map(e => this.normalizeEntry(e)),
-        };
-    }
-    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 || [];
-        validators.unshift((v, _d, _c, entry) => entry.optional || !!v || 'Required');
-        return validators;
-    }
-    supportsAltAction(altAction) {
-        return !!this.entries.some(e => e.altAction === altAction);
-    }
-    getFormValidator() {
-        const entries = this.executable().entries;
-        const fields = {};
-        for (const entry of entries) {
-            if (entry.field) {
-                const validators = this.prepareValidators(entry.validators);
-                fields[entry.field] = {
-                    entry,
-                    validators,
-                };
-                fields[entry.field].validators = validators;
-            }
-        }
-        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: data,
-                };
-                if (scope.entry) {
-                    scope.entry.disabled = evalParameter(evalEntry.disabled, scope, true);
-                    scope.entry.optional = evalParameter(evalEntry.optional, scope, true);
-                    scope.entry.hidden = evalParameter(evalEntry.hidden, scope, true);
-                }
-                // 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: data,
-                });
-                if (!result.passed) {
-                    passed = false;
-                    if (!errors[key]) {
-                        errors[key] = result.error || 'Wrong value';
-                    }
-                }
-            }
-            return {
-                passed,
-                errors,
-            };
-        };
-    }
-}
-function validate(opts) {
-    for (const validator of opts.validators || []) {
-        const result = evalParameter(validator, {
-            v: opts.v,
-            context: opts.context,
-            data: opts.data,
-            entry: opts.entry,
-        }, true);
+/**
+ * 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 };
 }
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const pool = new FNPool();
-function deserializeForm(form) {
-    return new Foorm({
-        title: deserializeComputedFn(form.title),
-        context: form.context,
-        submit: deserializeComputedFn(form.submit, true),
-        entries: form.entries.map(e => (Object.assign(Object.assign({}, e), { 
-            // strings
-            label: deserializeComputedFn(e.label), description: deserializeComputedFn(e.description), hint: deserializeComputedFn(e.hint), placeholder: deserializeComputedFn(e.placeholder), 
-            // strings || objects
-            classes: deserializeComputedFn(e.classes, true), styles: deserializeComputedFn(e.styles, true), 
-            // booleans
-            optional: deserializeComputedFn(e.optional), disabled: deserializeComputedFn(e.disabled), hidden: deserializeComputedFn(e.hidden), 
-            // options
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-            options: deserializeComputedFn(e.options), 
-            // attrs
-            attrs: deserializeComputedFn(e.attrs, true), 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            value: e.value, validators: (e.validators || []).map(fn => deserializeComputedFn(fn)) }))),
-    });
-}
-function deserializeComputedFn(v, asObj) {
-    if (typeof v === 'object' && typeof v.__fn__ === 'string') {
-        const fn = pool.getFn(v.__fn__);
-        fn.__deserialized = true;
-        return fn;
-    }
-    if (typeof v === 'object' && asObj) {
-        const o = {};
-        for (const [key, val] of Object.entries(v)) {
-            o[key] = deserializeComputedFn(val);
+/** 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 o;
     }
-    return v;
+    return data;
 }
-
-/* eslint-disable @typescript-eslint/naming-convention */
-function serializeForm(form, opts) {
-    const def = form.getDefinition();
-    return {
-        title: serializeComputedFn(def.title),
-        submit: {
-            text: serializeComputedFn(def.submit.text || 'Submit'),
-            disabled: serializeComputedFn(def.submit.disabled),
-        },
-        context: (opts === null || opts === void 0 ? void 0 : opts.replaceContext) || def.context,
-        entries: def.entries.map(e => (Object.assign(Object.assign({}, e), { 
-            // strings
-            label: serializeComputedFnWithVal(e.label), description: serializeComputedFnWithVal(e.description), hint: serializeComputedFnWithVal(e.hint), placeholder: serializeComputedFnWithVal(e.placeholder), 
-            // strings || objects
-            classes: serializeComputedFnWithVal(e.classes, true), styles: serializeComputedFnWithVal(e.styles, true), 
-            // booleans
-            optional: serializeComputedFnWithVal(e.optional), disabled: serializeComputedFnWithVal(e.disabled), hidden: serializeComputedFnWithVal(e.hidden), 
-            // options
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-            options: serializeComputedFnWithVal(e.options), 
-            // attrs
-            attrs: serializeComputedFnWithVal(e.attrs, true), 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            value: (opts === null || opts === void 0 ? void 0 : opts.replaceValues) ? opts.replaceValues[e.field] : e.value, validators: (e.validators || [])
-                .filter(v => isCleanFn(v))
-                .map(fn => serializeComputedFnWithVal(fn)) }))),
+/**
+ * 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 { passed, errors };
     };
 }
-function serializeComputedFn(fn) {
-    if (typeof fn === 'function') {
-        return { __fn__: serializeFn(fn, 'data', 'context') };
-    }
-    return fn;
-}
-function serializeComputedFnWithVal(fn, inObj) {
-    if (inObj && typeof fn === 'object') {
-        const o = {};
-        for (const [key, val] of Object.entries(fn)) {
-            o[key] = serializeComputedFnWithVal(val);
-        }
-        return o;
-    }
-    if (typeof fn === 'function') {
-        return { __fn__: serializeFn(fn, 'v', 'data', 'context', 'entry') };
-    }
-    return fn;
+/**
+ * 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, deserializeForm, evalParameter, serializeForm, validate };
+export { createFormData, evalComputed, getFormValidator, supportsAltAction, validate };

package/package.json

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