foorm 0.0.2 → 0.1.0

package/dist/index.cjs

@@ -1,21 +1,28 @@
 'use strict';
 
-var ftring$1 = require('@prostojs/ftring');
+var deserializeFn = require('@prostojs/deserialize-fn');
+var serializeFn = require('@prostojs/serialize-fn');
 
-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__,
-    };
+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);
+        }
+    }
+    return fn;
 }
 
+/* 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;
@@ -34,55 +41,23 @@ class Foorm {
     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;
+    getDefinition() {
         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)) }))),
+            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' });
+        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),
-            },
+            title: this.title || '',
+            submit: this.submit || { text: 'Submit' },
             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) }))),
+            entries: this.entries.map(e => this.normalizeEntry(e)),
         };
     }
     createFormData() {
@@ -95,27 +70,25 @@ class Foorm {
         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"'));
+        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() {
-        if (!this.fns) {
-            this.fns = new ftring$1.FtringsPool();
-        }
         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: this.prepareValidators(entry.validators),
+                    validators,
                 };
+                fields[entry.field].validators = validators;
             }
-            fields[entry.field].validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
         }
         return (data) => {
             let passed = true;
@@ -132,27 +105,12 @@ class Foorm {
                         name: evalEntry.name,
                         length: evalEntry.length,
                     },
-                    data,
+                    data: 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;
-                    }
+                    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({
@@ -160,7 +118,7 @@ class Foorm {
                     context: this.context,
                     validators: value.validators,
                     entry: scope.entry,
-                    data,
+                    data: data,
                 });
                 if (!result.passed) {
                     passed = false;
@@ -178,12 +136,12 @@ class Foorm {
 }
 function validate(opts) {
     for (const validator of opts.validators || []) {
-        const result = validator({
+        const result = evalParameter(validator, {
             v: opts.v,
             context: opts.context,
             data: opts.data,
             entry: opts.entry,
-        });
+        }, true);
         if (result !== true) {
             return {
                 passed: false,
@@ -193,30 +151,96 @@ function validate(opts) {
     }
     return { passed: true };
 }
-function transformFtrings(value, fns) {
-    if (value === undefined) {
-        return value;
-    }
-    return isFtring(value) ? fns.getFn(value.v) : value;
+
+/* 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 transformFtringsInObj(value, fns) {
-    if (isFtring(value)) {
-        return transformFtrings(value, fns);
+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);
+        }
+        return o;
     }
-    if (typeof value === 'function') {
-        return value;
+    return v;
+}
+
+/* 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)) }))),
+    };
+}
+function serializeComputedFn(fn) {
+    if (typeof fn === 'function') {
+        return { __fn__: serializeFn.serializeFn(fn, 'data', 'context') };
     }
-    if (typeof value === 'object' && value !== null) {
-        const obj = {};
-        for (const [key, val] of Object.entries(value)) {
-            obj[key] = transformFtrings(val, fns);
+    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 obj;
+        return o;
+    }
+    if (typeof fn === 'function') {
+        return { __fn__: serializeFn.serializeFn(fn, 'v', 'data', 'context', 'entry') };
     }
-    return value;
+    return fn;
 }
 
 exports.Foorm = Foorm;
-exports.ftring = ftring;
-exports.isFtring = isFtring;
+exports.deserializeForm = deserializeForm;
+exports.evalParameter = evalParameter;
+exports.serializeForm = serializeForm;
 exports.validate = validate;

package/dist/index.d.ts

@@ -1,117 +1,143 @@
-interface TFtring {
-    __is_ftring__: true;
-    v: string;
-    __type__?: 'boolean' | 'string' | 'number';
+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;
 }
-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;
-    };
+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>> {
+    v?: V;
+    data: D;
+    context: C;
+    entry?: TFoormEntryEvaluated;
     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';
+type TFoormValidatorFn<V, D, C> = Exclude<Exclude<TComputedWithVal<boolean | string, V, D, C>, boolean>, string>;
 type TFoormEntryOptions = {
     key: string;
     label: string;
 } | string;
-interface TFoormEntry<T = string, O = TFoormEntryOptions, SFTR = TFtring, BFTR = TFtring, FNFTR = TFtring, OFTR = TFtring> {
+interface TFoormEntry<V, D, C, O extends TFoormEntryOptions> {
     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>;
+    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;
     component?: string;
     autocomplete?: string;
     name?: string;
-    value?: T;
-    options?: O[] | OFTR;
-    attrs?: Record<string, string | SFTR>;
-    optional?: boolean | BFTR;
-    disabled?: boolean | BFTR;
-    hidden?: boolean | BFTR;
+    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<FNFTR | TFoormValidatorFn<T>>;
+    validators?: Array<TFoormValidatorFn<V, D, C>>;
 }
-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>;
+interface TFoormMetaExecutable<D, C> {
+    title: TComputed<string, D, C>;
     submit: {
-        text: string | TFoormFn<undefined, string>;
-        disabled: boolean | TFoormFn<undefined, boolean>;
+        text: TComputed<string, D, C>;
+        disabled?: TComputed<boolean, D, C>;
     };
-    context: Record<string, unknown>;
-    entries: TFoormEntryExecutable[];
+    context: C;
+    entries: Array<TFoormEntry<any, D, C, TFoormEntryOptions>>;
 }
-
-interface TFoormSubmit<S = TFtring, B = TFtring> {
-    text: string | S;
-    disabled?: boolean | B;
+interface TSerializedFn {
+    __fn__: string;
+}
+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 TFoormOptions {
-    title?: StringOrFtring;
-    entries: TFoormEntry[];
-    submit?: TFoormSubmit;
-    context?: Record<string, unknown>;
+interface TFoormEntryEvaluated {
+    field: string;
+    type: string;
+    component?: string;
+    name: string;
+    length?: number;
+    disabled?: boolean;
+    optional?: boolean;
+    hidden?: 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;
+
+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: 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>;
+    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<T, O>(e: TFoormEntry<T, O>): TFoormEntry<T, O> & {
+    protected normalizeEntry<V, O extends TFoormEntryOptions>(e: TFoormEntry<V, D, C, O>): TFoormEntry<V, D, C, O> & {
         name: string;
-        label: string | TFtring;
+        label: TComputed<string, D, C>;
         type: string;
     };
-    /**
-     * Evaluates all the ftrings into functions, makes it ready for execution
-     *
-     * @returns form metadata with functions
-     */
-    executable(): TFoormMetaExecutable;
+    executable(): TFoormMetaExecutable<D, C>;
     createFormData<T extends Record<string, unknown>>(): T;
-    prepareValidators(_validators: TFoormEntry['validators']): TFoormValidatorFn<string>[];
+    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<T = string>(opts: TFoormFnScope<T> & {
-    validators: Array<TFoormValidatorFn<T>>;
+declare function validate<V, D, C>(opts: TFoormFnScope<V, D, C> & {
+    validators: TFoormEntry<any, D, C, TFoormEntryOptions>['validators'];
 }): {
     passed: boolean;
     error: string;
@@ -120,7 +146,13 @@ declare function validate<T = string>(opts: TFoormFnScope<T> & {
     error?: undefined;
 };
 
-declare function isFtring(input: unknown): input is TFtring;
-declare function ftring(strings: TemplateStringsArray, __type__?: TFtring['__type__']): TFtring;
+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;
 
-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 { 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 };

package/dist/index.mjs

@@ -1,19 +1,26 @@
-import { FtringsPool } from '@prostojs/ftring';
+import { FNPool } from '@prostojs/deserialize-fn';
+import { isCleanFn, serializeFn } from '@prostojs/serialize-fn';
 
-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__,
-    };
+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);
+        }
+    }
+    return fn;
 }
 
+/* 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;
@@ -32,55 +39,23 @@ class Foorm {
     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;
+    getDefinition() {
         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)) }))),
+            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' });
+        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),
-            },
+            title: this.title || '',
+            submit: this.submit || { text: 'Submit' },
             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) }))),
+            entries: this.entries.map(e => this.normalizeEntry(e)),
         };
     }
     createFormData() {
@@ -93,27 +68,25 @@ class Foorm {
         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"'));
+        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() {
-        if (!this.fns) {
-            this.fns = new FtringsPool();
-        }
         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: this.prepareValidators(entry.validators),
+                    validators,
                 };
+                fields[entry.field].validators = validators;
             }
-            fields[entry.field].validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
         }
         return (data) => {
             let passed = true;
@@ -130,27 +103,12 @@ class Foorm {
                         name: evalEntry.name,
                         length: evalEntry.length,
                     },
-                    data,
+                    data: 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;
-                    }
+                    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({
@@ -158,7 +116,7 @@ class Foorm {
                     context: this.context,
                     validators: value.validators,
                     entry: scope.entry,
-                    data,
+                    data: data,
                 });
                 if (!result.passed) {
                     passed = false;
@@ -176,12 +134,12 @@ class Foorm {
 }
 function validate(opts) {
     for (const validator of opts.validators || []) {
-        const result = validator({
+        const result = evalParameter(validator, {
             v: opts.v,
             context: opts.context,
             data: opts.data,
             entry: opts.entry,
-        });
+        }, true);
         if (result !== true) {
             return {
                 passed: false,
@@ -191,27 +149,92 @@ function validate(opts) {
     }
     return { passed: true };
 }
-function transformFtrings(value, fns) {
-    if (value === undefined) {
-        return value;
-    }
-    return isFtring(value) ? fns.getFn(value.v) : value;
+
+/* 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 transformFtringsInObj(value, fns) {
-    if (isFtring(value)) {
-        return transformFtrings(value, fns);
+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);
+        }
+        return o;
     }
-    if (typeof value === 'function') {
-        return value;
+    return v;
+}
+
+/* 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)) }))),
+    };
+}
+function serializeComputedFn(fn) {
+    if (typeof fn === 'function') {
+        return { __fn__: serializeFn(fn, 'data', 'context') };
     }
-    if (typeof value === 'object' && value !== null) {
-        const obj = {};
-        for (const [key, val] of Object.entries(value)) {
-            obj[key] = transformFtrings(val, fns);
+    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 obj;
+        return o;
+    }
+    if (typeof fn === 'function') {
+        return { __fn__: serializeFn(fn, 'v', 'data', 'context', 'entry') };
     }
-    return value;
+    return fn;
 }
 
-export { Foorm, ftring, isFtring, validate };
+export { Foorm, deserializeForm, evalParameter, serializeForm, validate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foorm",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "foorm",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -35,6 +35,7 @@
   },
   "homepage": "https://github.com/foormjs/foormjs/tree/main/packages/foorm#readme",
   "dependencies": {
-    "@prostojs/ftring": "^0.0.4"
+    "@prostojs/serialize-fn": "^0.0.5",
+    "@prostojs/deserialize-fn": "^0.0.5"
   }
 }