@bgroup/wise-form 1.0.1

package/src/formulas/index.ts

@@ -0,0 +1,198 @@
+import { parse } from 'mathjs';
+import { EvaluationsManager } from './helpers/evaluations';
+import { ReactiveModel } from '@beyond-js/reactive/model';
+import { Lexer } from './helpers/lexer';
+import { Parser } from './helpers/parser';
+import { Token } from './helpers/token';
+import { IComplexCondition, IConditionalFormula, FormulaObserver, FormulaType, FormulaFields } from './types/formulas';
+import { FormulaBasic } from './variants/basic';
+import { FormulaConditional } from './variants/conditional';
+import { FormulaPerValue } from './variants/per-value';
+import { FormulaComparison } from './variants/comparison';
+import { FormulaArray } from './variants/array-formula';
+import { IterativeArrayFormula } from './variants/iterative-array';
+type ParserData = {
+	parser: Parser;
+	tokens: Token[];
+	[key: string]: any;
+};
+export class FormulaManager extends ReactiveModel<FormulaManager> {
+	#lexer = new Lexer(true);
+
+	#tokens: Token[];
+	get tokens() {
+		return this.#tokens;
+	}
+	#parser: Parser;
+	get parser() {
+		return this.#parser;
+	}
+
+	#specs: FormulaObserver;
+	get formula() {
+		return this.#specs.formula;
+	}
+	get name() {
+		return this.#specs.name;
+	}
+
+	get conditional() {
+		return typeof this.#specs.formula === 'object';
+	}
+
+	get conditions() {
+		if (typeof this.#specs.formula === 'string') return;
+		const formula = this.#specs.formula as IComplexCondition;
+		return formula.conditions;
+	}
+
+	/**
+	 *  Represents the fields defined in the plugin settings
+	 */
+	get fields() {
+		const formula = <IComplexCondition>this.formula;
+		return typeof formula?.fields === 'string' ? [formula?.fields] : formula?.fields;
+	}
+
+	#parsedBase;
+	get parsedBase() {
+		return this.#parsedBase;
+	}
+	#type: string;
+	get type() {
+		return this.#type;
+	}
+
+	get base() {
+		const formula = <IComplexCondition>this.#specs.formula;
+		return formula.base;
+	}
+
+	#variables: string[] = [];
+	get variables() {
+		return this.#variables;
+	}
+
+	get value() {
+		return this.#instance.value;
+	}
+
+	#parsers: Map<string, ParserData> = new Map();
+	#plugin: any;
+	#instance: any;
+
+	constructor(plugin, specs) {
+		super();
+		this.#plugin = plugin;
+		this.#specs = specs;
+		this.#initialize();
+	}
+
+	#initialize() {
+		this.#type = this.getType();
+
+		const objects = {
+			basic: FormulaBasic,
+			'base-conditional': FormulaConditional,
+			'value-conditions': FormulaPerValue,
+			comparison: FormulaComparison,
+			array: FormulaArray,
+			'iterative-array': IterativeArrayFormula,
+		};
+
+		if (!objects[this.type]) {
+			throw new Error(`this type ${this.type} not found`);
+		}
+
+		this.#instance = new objects[this.type](this, this.#plugin, this.#specs);
+	}
+
+	initialize() {
+		this.#instance.initialize();
+	}
+	/**
+	 * Returns the models that are part of the formula
+	 * The models could be fields or formulas
+	 * @param variables
+	 * @returns
+	 */
+	getModels(variables: FormulaFields) {
+		const varsArray = Array.isArray(variables) ? variables : [variables];
+		return varsArray.map(name => {
+			if (this.#plugin.formulas.has(name)) return this.#plugin.formulas.get(name);
+			return this.#plugin.form.getField(name);
+		});
+	}
+
+	private getType(): FormulaType {
+		const { type, formula } = this.#specs;
+		if (type) return type;
+		if (typeof formula === 'string') return 'basic';
+		if (formula.conditions) return formula.base ? 'base-conditional' : 'value-conditions';
+	}
+
+	processConditional() {
+		const formula = <IComplexCondition>this.formula;
+		if (this.base) {
+			this.#parsedBase = this.getParser({ formula: this.base });
+		}
+	}
+	calculate() {
+		if (!this.#instance || this.#instance.calculate) {
+		}
+		this.#instance.calculate();
+
+		this.trigger('change');
+		return;
+	}
+
+	/**
+	 * Returns the parser for the formula, if the parser is already created it will return the memoized parser
+	 *
+	 *
+	 * The formula is tokenized and parsed to create a parser instance
+	 * the object returned contains the tokens, the parser and the formula
+	 * @param data Receives the formula to be parsed
+	 * @returns
+	 */
+	getParser(data): ParserData {
+		if (!data.formula) throw new Error('To get a parser you must provide a formula');
+		if (this.#parsers.has(data.formula)) return this.#parsers.get(data.formula);
+		const tokens = this.#lexer.tokenize(data.formula);
+		const parser = new Parser(tokens);
+		const result = { tokens, parser, ...data };
+
+		this.#parsers.set(data.formula, result);
+		return result;
+	}
+
+	async getParams(variables: string[]) {
+		const params = {};
+		const { form, formulas } = this.#plugin;
+		const build = async value => {
+			/**
+			 * the value could be a formula or a field
+			 */
+			const element = formulas.has(value) ? formulas.get(value) : form.getField(value);
+			if (!element)
+				throw new Error(`Field ${value} used in formula ${this.name}, not found in form ${form.name}, `);
+			await element.isReady;
+			params[value] = [undefined, '', null, NaN].includes(element.value) ? 0 : element.value;
+		};
+		variables.forEach(build);
+
+		return params;
+	}
+
+	/**
+	 * A form can have multiple formulas, this method will create an instance of the formula manager
+	 * and memoize it to avoid creating multiple instances of the same formula.
+	 * @param specs
+	 * @returns
+	 */
+	static async create(plugin, specs) {
+		const instance = new FormulaManager(plugin, specs);
+		// FormulaManager.instances.set(plugin.form.name, instance);
+		return instance;
+	}
+}

package/src/formulas/types/formulas.ts

@@ -0,0 +1,72 @@
+import type { Parser } from "../helpers/parser";
+import type { Token } from "../helpers/token";
+
+export interface ISimpleFormula {
+	name: string;
+	formula: string;
+	type?: FormulaType;
+	emptyValue?: string | number;
+	fields?: FormulaFields;
+	propertyValue?: string;
+	propertyToSet?: string;
+	formulas?: any[];
+	arrayFieldProperty?: string;
+	arrayFieldName?: string
+}
+
+export interface IFormulaCondition {
+	condition: "hasValue" | "upper" | "lower" | "equal" | "different" | "between" | "lessOrEqual" | "greaterOrEqual";
+	value?: string | number | [number, number];
+	formula: string;
+	conditions?: IConditionalField[];
+	fields?: string[];
+}
+
+export type FormulaFields = string | string[];
+export type EvaluatedFormula = { value?: string | number; formula: string; condition?: string };
+export interface IConditionalFormula { }
+
+export interface IConditionalField {
+	field?: string | string[];
+	condition?: string;
+	values?: [EvaluatedFormula];
+	conditions?: IFormulaCondition[];
+	fields?: string[];
+	formula?: string;
+	type?: string;
+	value: string | number;
+}
+
+export interface IComplexCondition {
+	fields: FormulaFields;
+	base?: string;
+	conditions: IConditionalField | IConditionalField[];
+	condition?: string;
+	arrayFieldName?: string,
+	arrayFieldProperty?: string;
+}
+
+export interface IConditionalFormula {
+	name: string;
+	type?: FormulaType;
+	fields?: FormulaFields;
+	formula: IComplexCondition | string;
+	conditions?: IConditionalField[];
+	emptyValue?: string | number;
+	propertyValue?: string;
+	propertyToSet?: string;
+	formulas?: any[];
+	arrayFieldName?: string,
+	arrayFieldProperty?: string;
+}
+
+export type ParserData = {
+	parser: Parser;
+	tokens: Token[];
+	[key: string]: any;
+};
+
+export type FormulaType = "basic" | "base-conditional" | "value-conditions" | "comparison" | "array" | "iterative-array" | undefined;
+
+export type FormulaObserver = ISimpleFormula | IConditionalFormula;
+

package/src/formulas/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Defines the type of token based on the part of the expression it represents.
+ */
+export type TokenType = 'variable' | 'number' | 'operator' | 'parenthesis';
+

package/src/formulas/variants/array-formula.ts

@@ -0,0 +1,138 @@
+import type { FormulaManager } from '..';
+import { EvaluationsManager } from '../helpers/evaluations';
+import { FormulaObserver, IComplexCondition } from '../types/formulas';
+import { parse } from 'mathjs';
+
+export class FormulaArray {
+    #plugin: any;
+    #specs: FormulaObserver;
+    get formula() {
+        return this.#specs.formula;
+    }
+    get base() {
+        const formula = <IComplexCondition>this.#specs.formula;
+        return formula.base;
+    }
+    #value: any[] = [];
+    get value() {
+        return this.#value;
+    }
+    get name() {
+        return this.#specs.name;
+    }
+    /**
+     *  Represents the fields defined in the plugin settings
+     */
+    get fields() {
+        const formula = <IComplexCondition>this.formula;
+        return typeof formula?.fields === 'string' ? [formula?.fields] : formula?.fields;
+    }
+
+    get conditions() {
+        if (typeof this.#specs.formula === 'string') return;
+        const formula = this.#specs.formula as IComplexCondition;
+        return formula.conditions;
+    }
+
+    #emptyValue: string | number;
+    #variables: string[] = [];
+    get variables() {
+        return this.#variables;
+    }
+
+    #round: boolean;
+    #ceil: boolean
+
+    #parent: FormulaManager;
+
+    #formulaField
+    constructor(parent, plugin, specs) {
+        this.#parent = parent;
+        this.#plugin = plugin;
+        this.#specs = specs;
+        this.#round = specs.round;
+        this.#ceil = specs.ceil;
+        this.#specs.emptyValue = specs.emptyValue;
+
+        this.#formulaField = this.#plugin.form.getField(this.name);
+    }
+
+    initialize() {
+        this.#formulaField.on('change', this.calculate.bind(this));
+    };
+
+    evaluate = (data: { formulas: any[], values: any }) => {
+        const values = {};
+        for (const formula of data.formulas) {
+
+            let result;
+            let formulaEvaluate = formula.formula
+            try {
+                if (formula.conditions) {
+                    for (const condition of formula.conditions) {
+                        const comparisonValue = { ...data.values, ...values }[condition.property]
+                        let conditionMet = EvaluationsManager.validate(condition.condition, comparisonValue, condition.value);
+                        if (conditionMet) {
+                            formulaEvaluate = condition.formula;
+                            break
+                        }
+                    }
+                }
+                const attrs = this.sanitizeData({ ...data.values, ...values });
+
+                result = parse(formulaEvaluate as string).evaluate(attrs);
+
+            } catch (error) {
+                console.log("Error evaluating formula:", formula.formula, "Error:", error);
+            }
+            const isInvalidResult = [-Infinity, Infinity, undefined, null, NaN].includes(result);
+
+            if (formula.round && !isInvalidResult) result = Math.round(result);
+            if (formula.ceil && !isInvalidResult) result = Math.ceil(result);
+            result = isInvalidResult ? formula.emptyValue : Number(result.toFixed(2));
+            values[formula.propertyToSet] = result;
+        }
+        return values;
+    };
+
+    async calculate() {
+        const formulaField = this.#plugin.form.getField(this.name);
+        if (!formulaField) return;
+        const value = formulaField[this.#specs.propertyValue || 'entries']
+        if (!value || !Array.isArray(value) || !value.length) {
+            formulaField.set({ [this.#specs.propertyValue]: [] });
+            return
+        };
+        const newValue = value.map(item => {
+            let results = this.evaluate({ formulas: this.#specs.formulas, values: item })
+            return {
+                ...item,
+                ...results
+            }
+        });
+        this.#value = newValue
+        formulaField.set({ [this.#specs.propertyValue]: newValue })
+    };
+
+
+    private sanitizeData(data: any): any {
+        if (Array.isArray(data)) {
+            return data.map(item => this.sanitizeData(item));
+        } else if (typeof data === 'object' && data !== null) {
+            const sanitizedData: any = {};
+            for (const key in data) {
+                if (data.hasOwnProperty(key)) {
+                    sanitizedData[key] = this.sanitizeData(data[key]);
+                }
+            }
+            return sanitizedData;
+        } else {
+            return this.sanitizeValue(data);
+        }
+    }
+
+    private sanitizeValue(value: any, defaultValue: number = 0): number {
+        return (value === null || value === undefined || isNaN(value)) ? defaultValue : Number(value);
+    }
+}
+

package/src/formulas/variants/base.ts

@@ -0,0 +1,6 @@
+export abstract class WiseFormFormulaPlugin {
+	abstract initialize(): void;
+	abstract validate(): void;
+	abstract calculate(): void;
+}
+

package/src/formulas/variants/basic.ts

@@ -0,0 +1,141 @@
+import type { FormulaManager } from '..';
+import { EvaluationsManager } from '../helpers/evaluations';
+import { Token } from '../helpers/token';
+import {
+    EvaluatedFormula,
+    FormulaObserver,
+    IComplexCondition,
+    IConditionalField,
+} from '../types/formulas';
+import { parse } from 'mathjs';
+
+export class FormulaBasic {
+    #plugin: any;
+    #specs: FormulaObserver;
+    #tokens: Token[];
+    get formula() {
+        return this.#specs.formula;
+    }
+    get base() {
+        const formula = <IComplexCondition>this.#specs.formula;
+        return formula.base;
+    }
+    #value: string | number | undefined | 0;
+    get value() {
+        return this.#value;
+    }
+    get name() {
+        return this.#specs.name;
+    }
+    /**
+     *  Represents the fields defined in the plugin settings
+     */
+    get fields() {
+        const formula = <IComplexCondition>this.formula;
+        return typeof formula?.fields === 'string'
+            ? [formula?.fields]
+            : formula?.fields;
+    }
+
+    get conditions() {
+        if (typeof this.#specs.formula === 'string') return;
+        const formula = this.#specs.formula as IComplexCondition;
+        return formula.conditions;
+    }
+
+    #emptyValue: string | number;
+    #variables: string[] = [];
+    get variables() {
+        return this.#variables;
+    }
+
+    #round: boolean;
+    #ceil: boolean;
+
+    #parent: FormulaManager;
+
+    #isNotListenToChanges = false;
+    constructor(parent, plugin, specs) {
+        this.#parent = parent;
+        this.#plugin = plugin;
+        this.#specs = specs;
+        this.#round = specs.round;
+        this.#ceil = specs.ceil;
+        this.#emptyValue = specs.emptyValue;
+
+        this.#isNotListenToChanges = specs.isNotListenToChanges;
+    }
+
+    initialize() {
+        const { tokens } = this.#parent.getParser(this.#specs);
+        this.#tokens = tokens;
+        const variables = this.#tokens
+            .filter((token) => token.type === 'variable')
+            .map((item) => item.value);
+        this.#variables = variables;
+        const models = this.#parent.getModels(variables);
+        if (!this.#isNotListenToChanges)
+            models.forEach((model) => {
+                if ([undefined].includes(model)) {
+                    return;
+                }
+
+                model.on('change', this.calculate.bind(this));
+            });
+        if (!Array.isArray(this.#variables) || !this.#variables.length) {
+            this.#value = parse(this.formula as string).evaluate();
+        }
+    }
+
+    async calculate() {
+        const variables = this.#variables;
+
+        const formulaField = this.#plugin.form.getField(this.name);
+        let params = await this.#parent.getParams(variables);
+        const models = this.#parent.getModels(variables);
+
+        const empty = (models as any[]).every((model) =>
+            [null, undefined, ''].includes(model.value)
+        );
+
+        if (empty) {
+            // If all models are empty, set the input to empty if exists.
+            if (formulaField)
+                formulaField.set({ value: this.#emptyValue || '' });
+            this.#value = undefined;
+            return;
+        }
+
+        try {
+            let result =
+                models.length === 1 &&
+                !['+', '-', '*', '/'].some((item) =>
+                    this.formula.toString().includes(item)
+                )
+                    ? models[0].value
+                    : parse(this.formula as string).evaluate(params);
+            const isInvalidResult = [
+                -Infinity,
+                Infinity,
+                undefined,
+                null,
+                NaN,
+            ].includes(result);
+            if (this.#round && !isInvalidResult) result = Math.round(result);
+            if (this.#ceil && !isInvalidResult) result = Math.ceil(result);
+            this.#value = isInvalidResult
+                ? this.#emptyValue
+                : Number(result.toFixed(2));
+            if (formulaField) formulaField.set({ value: this.#value });
+
+            this.#parent.trigger('change');
+        } catch (e) {
+            console.log('formula', this.name, this.formula, params);
+            console.trace(e);
+            throw new Error(
+                `Error calculating the formula: ${e.message} ${this.name}`
+            );
+        }
+    }
+}
+