foorm 0.0.2-alpha.0 → 0.0.2-alpha.10

package/dist/index.cjs

@@ -20,6 +20,7 @@ class Foorm {
         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);
@@ -30,17 +31,33 @@ class Foorm {
     setSubmit(submit) {
         this.submit = submit;
     }
-    transportable() {
+    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) {
         var _a, _b;
         return {
             title: (_a = this.title) !== null && _a !== void 0 ? _a : '',
             submit: (_b = this.submit) !== null && _b !== void 0 ? _b : { text: 'Submit' },
-            entries: this.entries.map((e) => (Object.assign(Object.assign({}, this.normalizeEntry(e)), { validators: (e.validators || []).filter((v) => isFtring(v)) }))),
+            context: replaceContext || this.context,
+            entries: this.entries.map((e) => (Object.assign(Object.assign({}, e), { 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)
@@ -51,6 +68,7 @@ class Foorm {
                 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), { 
@@ -59,10 +77,28 @@ class Foorm {
                 // 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) }))),
+                optional: transformFtrings(e.optional, this.fns), disabled: transformFtrings(e.disabled, this.fns), hidden: transformFtrings(e.hidden, this.fns), validators: this.prepareValidators(e.validators) }))),
         };
     }
-    getValidator() {
+    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.find((e) => e.altAction === altAction);
+    }
+    getFormValidator() {
         if (!this.fns)
             this.fns = new ftring$1.FtringsPool();
         const entries = this.executable().entries;
@@ -71,7 +107,7 @@ class Foorm {
             if (entry.field) {
                 fields[entry.field] = {
                     entry,
-                    validators: (entry.validators || []).map((v) => isFtring(v) ? this.fns.getFn(v.v) : v),
+                    validators: this.prepareValidators(entry.validators),
                 };
             }
             fields[entry.field].validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
@@ -80,25 +116,48 @@ class Foorm {
             let passed = true;
             const errors = {};
             for (const [key, value] of Object.entries(fields)) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const evalEntry = Object.assign({}, value.entry);
-                const ctx = {
+                const scope = {
                     v: data[key],
-                    validators: value.validators,
-                    entry: value.entry,
+                    context: this.context,
+                    entry: {
+                        field: evalEntry.field,
+                        type: evalEntry.type,
+                        component: evalEntry.component,
+                        name: evalEntry.name,
+                        length: evalEntry.length,
+                    },
                     data,
                 };
-                if (typeof evalEntry.optional === 'function') {
-                    evalEntry.optional = evalEntry.optional(ctx);
-                }
-                if (typeof evalEntry.disabled === 'function') {
-                    evalEntry.disabled = evalEntry.disabled(ctx);
+                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: evalEntry,
+                    entry: scope.entry,
                     data,
                 });
                 if (!result.passed) {
@@ -119,6 +178,7 @@ function validate(opts) {
     for (const validator of opts.validators || []) {
         const result = validator({
             v: opts.v,
+            context: opts.context,
             data: opts.data,
             entry: opts.entry,
         });

package/dist/index.d.ts

@@ -1,3 +1,122 @@
-export * from './foorm';
-export * from './utils';
-export * from './types';
+type TFtring = {
+    __is_ftring__: true;
+    v: string;
+    __type__?: 'boolean' | 'string' | 'number';
+};
+type StringOrFtring = string | TFtring;
+type ObjSOF = Record<string, StringOrFtring>;
+type 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;
+    };
+    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';
+interface TFoormEntry<T = string, O = string, SFTR = TFtring, BFTR = TFtring, FNFTR = TFtring> {
+    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;
+    component?: string;
+    autocomplete?: string;
+    name?: string;
+    value?: T;
+    options?: O[];
+    attrs?: Record<string, unknown>;
+    optional?: boolean | BFTR;
+    disabled?: boolean | BFTR;
+    hidden?: boolean | BFTR;
+    length?: number;
+    validators?: (FNFTR | TFoormValidatorFn<T>)[];
+}
+type TFoormEntryExecutable<T = unknown, O = string> = TFoormEntry<T, O, TFoormFn<T, string>, TFoormFn<T, boolean>, TFoormValidatorFn<T>> & {
+    name: string;
+    label: string | TFoormFn<T, string>;
+    type: string;
+};
+type 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;
+}
+interface TFoormOptions {
+    title?: StringOrFtring;
+    entries: TFoormEntry[];
+    submit?: TFoormSubmit;
+    context?: Record<string, unknown>;
+}
+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): 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>;
+    };
+}
+declare function validate<T = string>(opts: TFoormFnScope<T> & {
+    validators: TFoormValidatorFn<T>[];
+}): {
+    passed: boolean;
+    error: string;
+} | {
+    passed: boolean;
+    error?: undefined;
+};
+
+declare function isFtring(input: unknown): input is TFtring;
+declare function ftring(strings: TemplateStringsArray, __type__?: TFtring['__type__']): TFtring;
+
+export { Foorm, type ObjSOF, type StringOrFtring, type TFoormEntry, type TFoormEntryExecutable, type TFoormFn, type TFoormFnScope, type TFoormMetaExecutable, type TFoormOptions, type TFoormSubmit, type TFoormValidatorFn, type TFtring, ftring, isFtring, validate };

package/dist/index.mjs

@@ -18,6 +18,7 @@ class Foorm {
         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);
@@ -28,17 +29,33 @@ class Foorm {
     setSubmit(submit) {
         this.submit = submit;
     }
-    transportable() {
+    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) {
         var _a, _b;
         return {
             title: (_a = this.title) !== null && _a !== void 0 ? _a : '',
             submit: (_b = this.submit) !== null && _b !== void 0 ? _b : { text: 'Submit' },
-            entries: this.entries.map((e) => (Object.assign(Object.assign({}, this.normalizeEntry(e)), { validators: (e.validators || []).filter((v) => isFtring(v)) }))),
+            context: replaceContext || this.context,
+            entries: this.entries.map((e) => (Object.assign(Object.assign({}, e), { 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)
@@ -49,6 +66,7 @@ class Foorm {
                 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), { 
@@ -57,10 +75,28 @@ class Foorm {
                 // 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) }))),
+                optional: transformFtrings(e.optional, this.fns), disabled: transformFtrings(e.disabled, this.fns), hidden: transformFtrings(e.hidden, this.fns), validators: this.prepareValidators(e.validators) }))),
         };
     }
-    getValidator() {
+    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.find((e) => e.altAction === altAction);
+    }
+    getFormValidator() {
         if (!this.fns)
             this.fns = new FtringsPool();
         const entries = this.executable().entries;
@@ -69,7 +105,7 @@ class Foorm {
             if (entry.field) {
                 fields[entry.field] = {
                     entry,
-                    validators: (entry.validators || []).map((v) => isFtring(v) ? this.fns.getFn(v.v) : v),
+                    validators: this.prepareValidators(entry.validators),
                 };
             }
             fields[entry.field].validators.unshift(this.fns.getFn('entry.optional || !!v || "Required"'));
@@ -78,25 +114,48 @@ class Foorm {
             let passed = true;
             const errors = {};
             for (const [key, value] of Object.entries(fields)) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const evalEntry = Object.assign({}, value.entry);
-                const ctx = {
+                const scope = {
                     v: data[key],
-                    validators: value.validators,
-                    entry: value.entry,
+                    context: this.context,
+                    entry: {
+                        field: evalEntry.field,
+                        type: evalEntry.type,
+                        component: evalEntry.component,
+                        name: evalEntry.name,
+                        length: evalEntry.length,
+                    },
                     data,
                 };
-                if (typeof evalEntry.optional === 'function') {
-                    evalEntry.optional = evalEntry.optional(ctx);
-                }
-                if (typeof evalEntry.disabled === 'function') {
-                    evalEntry.disabled = evalEntry.disabled(ctx);
+                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: evalEntry,
+                    entry: scope.entry,
                     data,
                 });
                 if (!result.passed) {
@@ -117,6 +176,7 @@ function validate(opts) {
     for (const validator of opts.validators || []) {
         const result = validator({
             v: opts.v,
+            context: opts.context,
             data: opts.data,
             entry: opts.entry,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foorm",
-  "version": "0.0.2-alpha.0",
+  "version": "0.0.2-alpha.10",
   "description": "foorm",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",

package/dist/foorm.d.ts

@@ -1,85 +0,0 @@
-import { StringOrFtring, TFoormEntry, TFoormValidatorFn, TFoormFn, TFtring } from './types';
-export interface TFoormSubmit<S = TFtring, B = TFtring> {
-    text: string | S;
-    disabled?: boolean | B;
-}
-export interface TFoormOptions {
-    title?: StringOrFtring;
-    entries: TFoormEntry[];
-    submit?: TFoormSubmit;
-}
-export declare class Foorm {
-    protected entries: TFoormEntry[];
-    protected submit?: TFoormSubmit;
-    protected title?: StringOrFtring;
-    private fns;
-    constructor(opts?: TFoormOptions);
-    addEntry(entry: TFoormEntry): void;
-    setTitle(title: string): void;
-    setSubmit(submit: TFoormSubmit): void;
-    transportable(): Required<TFoormOptions>;
-    protected normalizeEntry(e: TFoormEntry): {
-        name: string;
-        label: string | TFtring;
-        type: string;
-        description?: string | TFtring | undefined;
-        hint?: string | TFtring | undefined;
-        placeholder?: string | TFtring | undefined;
-        classes?: string | TFtring | Record<string, boolean | TFtring> | undefined;
-        styles?: string | TFtring | Record<string, string | TFtring> | undefined;
-        component?: string | undefined;
-        field: string;
-        value?: string | undefined;
-        options?: string[] | undefined;
-        attrs?: Record<string, unknown> | undefined;
-        optional?: boolean | TFtring | undefined;
-        disabled?: boolean | TFtring | undefined;
-        hidden?: boolean | TFtring | undefined;
-        length?: number | undefined;
-        validators?: (TFtring | TFoormValidatorFn<string>)[] | undefined;
-    };
-    executable(): {
-        title: string | TFoormFn<undefined, string>;
-        submit: {
-            text: string | TFoormFn<undefined, string>;
-            disabled: boolean | TFoormFn<undefined, boolean>;
-        };
-        entries: {
-            label: string | TFoormFn<unknown, string>;
-            description: string | TFoormFn<unknown, string>;
-            hint: unknown;
-            placeholder: string | TFoormFn<unknown, string>;
-            classes: string | TFoormFn<unknown, string> | Record<string, boolean | TFoormFn<unknown, boolean>>;
-            styles: string | TFoormFn<unknown, string> | Record<string, string | TFoormFn<unknown, string>>;
-            optional: boolean | TFoormFn<unknown, boolean>;
-            disabled: boolean | TFoormFn<unknown, boolean>;
-            hidden: boolean | TFoormFn<unknown, boolean>;
-            name: string;
-            type: string;
-            component?: string | undefined;
-            field: string;
-            value?: string | undefined;
-            options?: string[] | undefined;
-            attrs?: Record<string, unknown> | undefined;
-            length?: number | undefined;
-            validators?: (TFtring | TFoormValidatorFn<string>)[] | undefined;
-        }[];
-    };
-    getValidator(): (inputs: Record<string, unknown>) => {
-        passed: boolean;
-        errors: Record<string, string>;
-    };
-}
-export type TFoormExecutableMeta = ReturnType<Foorm['executable']>;
-export declare function validate<T = string>(opts: {
-    v: T;
-    data: Record<string, unknown>;
-    entry?: TFoormEntry<T>;
-    validators: TFoormValidatorFn<T>[];
-}): {
-    passed: boolean;
-    error: string;
-} | {
-    passed: boolean;
-    error?: undefined;
-};

package/dist/foorm.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types.d.ts

@@ -1,35 +0,0 @@
-export type TFtring = {
-    __is_ftring__: true;
-    v: string;
-    __type__?: 'boolean' | 'string' | 'number';
-};
-export type StringOrFtring = string | TFtring;
-export type ObjSOF = Record<string, StringOrFtring>;
-export type TFoormFnCtx<T = string> = {
-    v?: T;
-    data: Record<string, unknown>;
-    entry?: TFoormEntry<T>;
-    action?: string;
-};
-export type TFoormValidatorFn<T = string> = (ctx: TFoormFnCtx<T>) => string | boolean;
-export type TFoormFn<T = string, R = string | boolean> = (ctx: TFoormFnCtx<T>) => R;
-export interface TFoormEntry<T = string, O = string, SFTR = TFtring, BFTR = TFtring, FNFTR = TFtring> {
-    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;
-    component?: string;
-    name?: string;
-    field: string;
-    value?: T;
-    options?: O[];
-    attrs?: Record<string, unknown>;
-    optional?: boolean | BFTR;
-    disabled?: boolean | BFTR;
-    hidden?: boolean | BFTR;
-    length?: number;
-    validators?: (FNFTR | TFoormValidatorFn<T>)[];
-}

package/dist/utils.d.ts

@@ -1,3 +0,0 @@
-import { TFtring } from './types';
-export declare function isFtring(input: unknown): input is TFtring;
-export declare function ftring(strings: TemplateStringsArray, __type__?: TFtring['__type__']): TFtring;

package/dist/utils.spec.d.ts

@@ -1 +0,0 @@
-export {};