@bgroup/wise-form 1.0.1

package/src/formulas/variants/comparison.ts

@@ -0,0 +1,156 @@
+import type { FormulaManager } from "..";
+import { EvaluationsManager } from "../helpers/evaluations";
+
+import { Token } from "../helpers/token";
+import { FormulaObserver, IComplexCondition, IConditionalField } from "../types/formulas";
+import { number, parse } from "mathjs";
+
+export class FormulaComparison {
+	#plugin: any;
+	#specs: FormulaObserver;
+	#emptyValue: undefined;
+	#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;
+	}
+
+	#variables: string[] = [];
+	get variables() {
+		return this.#variables;
+	};
+
+	#observers: string[];
+	get observers() {
+		return this.#observers;
+	}
+
+	#isNotListenToChanges = false
+
+	#parent: FormulaManager;
+	constructor(parent, plugin, specs) {
+		this.#parent = parent;
+		this.#plugin = plugin;
+		this.#specs = specs;
+		this.#isNotListenToChanges = specs.isNotListenToChanges;
+		this.#observers = specs.formula.observers;
+	}
+
+	initialize() {
+		if (!Array.isArray(this.#specs.fields)) {
+			throw new Error("The fields property must be an array");
+		}
+		if (!this.#isNotListenToChanges && this.#observers && Array.isArray(this.#observers) && !!this.#observers.length) {
+			const fields = this.#parent.getModels(this.#observers);
+			fields.forEach(field => {
+				if (!field) return;
+				field.on('change', this.calculate.bind(this));
+			});
+		}
+		const models = this.#parent.getModels(this.#specs.fields);
+		if (!this.#isNotListenToChanges) models.forEach(model => model.on("change", this.calculate.bind(this)));
+	}
+
+
+	start() { }
+
+	evaluate() {
+		const formula = <IComplexCondition>this.#specs.formula;
+
+		if (typeof formula === "string" || !formula.conditions) {
+			console.error("Invalid formula configuration");
+			return null;
+		}
+		const models = this.#parent.getModels(this.#specs.fields);
+		let fieldValues = models.map(fieldModel => {
+			if (!fieldModel) return;
+			return { name: fieldModel.name, value: fieldModel ? fieldModel.value : null };
+		});
+
+		// Utilizar reduce para comparar cada par de valores consecutivos y determinar cuál cumple la condición
+		const resultField = fieldValues.reduce((prevField, currentField) => {
+			if (!prevField) return currentField;
+
+			// Si el campo previo cumple la condición con respecto al actual, se mantiene como el campo elegido
+			if (EvaluationsManager.validate(formula.condition, prevField.value, currentField.value)) {
+				return prevField;
+			}
+			// De lo contrario, el campo actual se convierte en el nuevo campo elegido
+			return currentField;
+		}, null);
+
+		if (resultField) {
+			// Ajustar según la lógica específica deseada, como devolver una fórmula particular basada en el resultado
+			return resultField;
+		} else {
+			// Manejar el caso de que ninguno cumpla la condición
+			return null;
+		}
+	}
+
+	async calculate() {
+		let applied = this.evaluate();
+
+		if (!applied || !applied?.value) {
+			// any formula apply, so we need to reset the value
+			this.#value = 0;
+			return;
+		}
+		/**
+		 * Get the formula analyzer
+		 */
+
+		const specsFormula = this.#specs.formula as IComplexCondition;
+		const formulaString = specsFormula.conditions[applied.name];
+		const formula = this.#parent.getParser({ formula: formulaString });
+		const variables = formula.tokens.filter(token => token.type === "variable").map(item => item.value);
+		const params = await this.#parent.getParams(variables);
+
+		try {
+			const keys = Object.keys(params);
+			const result = keys.length === 1 ? params[keys[0]] : parse(this.formula as string).evaluate(params);
+
+			this.#value = [-Infinity, Infinity, undefined, null, NaN].includes(result)
+				? this.#emptyValue
+				: Number(result.toFixed(2));
+			this.#parent.trigger("change");
+			return this.#value;
+		} catch (e) {
+			console.log("formula", this.name, this.formula, params);
+			throw new Error("Error calculating the formula");
+		}
+	}
+
+	calculateUpper(models) {
+		let glue;
+		models.forEach(item => {
+			if (Number(item.value) > Number(glue?.value ?? 0)) glue = item;
+		});
+
+		return glue;
+	}
+}
+

package/src/formulas/variants/conditional.ts

@@ -0,0 +1,208 @@
+import type { FormulaManager } from '..';
+import { conditionsTypes } from '../helpers/condition-types';
+import { EvaluationsManager } from '../helpers/evaluations';
+import {
+    EvaluatedFormula,
+    FormulaObserver,
+    IComplexCondition,
+    IConditionalField,
+} from '../types/formulas';
+import { parse } from 'mathjs';
+
+export class FormulaConditional {
+    #plugin: any;
+    #specs: FormulaObserver;
+    #emptyValue: undefined;
+    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;
+    }
+
+    /**
+     * FormField type
+     */
+    #fields: any;
+
+    #parent: FormulaManager;
+    #ceil: boolean;
+    #round: boolean;
+    #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;
+
+        if (specs.isNotListenToChanges)
+            this.#isNotListenToChanges = specs.isNotListenToChanges;
+    }
+
+    initialize() {
+        try {
+            const { form } = this.#plugin;
+
+            if (!this.fields) {
+                throw new Error(`Fields not found in formula ${this.name}`);
+            }
+            const fields = this.fields.map((name) => {
+                const formula = this.#plugin.formulas.get(name);
+                if (formula) return formula;
+                const field = form.getField(name);
+                return field;
+            });
+            this.#fields = fields;
+            if (this.name === 'costoTotalGrafico') {
+                console.log('fields', fields);
+            }
+            if (!this.#isNotListenToChanges)
+                fields.forEach((field) => {
+                    if (!field) {
+                        throw new Error(
+                            `Field ${this.name} not found in form ${form.name}`
+                        );
+                    }
+                    field.on('change', this.calculate.bind(this));
+                });
+        } catch (e) {}
+    }
+
+    evaluate() {
+        const formula = <IComplexCondition>this.#specs.formula;
+        let evaluatedFormula: any = { formula: formula.base }; // Use the base formula by default
+        if (formula.conditions) {
+            const conditionsArray = Array.isArray(formula.conditions) ? formula.conditions : [formula.conditions];
+            for (const condition of conditionsArray) {
+                let conditionMet = false;
+                if (condition.conditions) {
+                    // If there are nested conditions, all must be met
+                    conditionMet = condition.conditions.every(
+                        (subCondition) => {
+                            const fieldValues = subCondition.fields.map(
+                                (fieldName) => {
+                                    const field = this.#fields.find(
+                                        (f) => f.name === fieldName
+                                    );
+                                    return field
+                                        ? field.value
+                                        : this.#emptyValue;
+                                }
+                            );
+                            return EvaluationsManager.validateAll(
+                                subCondition.condition,
+                                fieldValues,
+                                subCondition.value
+                            );
+                        }
+                    );
+                } else {
+                    const fieldValues = condition.fields.map((fieldName) => {
+                        const field = this.#fields.find(
+                            (f) => f.name === fieldName
+                        );
+                        return field ? field.value : this.#emptyValue;
+                    });
+                    const conditionType =
+                        !!condition.type && conditionsTypes[condition.type]
+                            ? conditionsTypes[condition.type]
+                            : conditionsTypes.some;
+                    // Check if any of the specified fields meet the condition
+                    conditionMet = EvaluationsManager[conditionType](
+                        condition.condition,
+                        fieldValues,
+                        condition.value
+                    );
+                }
+
+                if (conditionMet) {
+                    evaluatedFormula.formula = condition.formula;
+                    evaluatedFormula.fi = condition;
+                    break;
+                }
+            }
+        }
+        return evaluatedFormula;
+    }
+
+    async calculate() {
+        /**
+         * the formula is taken from the evaluate method since the conditions are evaluated there and
+         * can change the formula to be applied
+         */
+        const model = this.#plugin.form.getField(this.name);
+        const formula = this.evaluate();
+
+        if (!formula.formula) {
+            this.#value =
+                this.#emptyValue !== undefined ? this.#emptyValue : '';
+            model && model.set({ value: this.#value });
+            this.#parent.trigger('change');
+            return this.#value;
+        }
+        // todo: Review if this section can be replaced by formulaManager.variables property.
+        const { tokens } = this.#parent.getParser(formula);
+        const variables = tokens
+            .filter((token) => token.type === 'variable')
+            .map((item) => item.value);
+
+        const params = await this.#parent.getParams(variables);
+
+        try {
+            const keys = Object.keys(params);
+            let result =
+                keys.length === 1
+                    ? params[keys[0]]
+                    : parse(formula.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 || typeof result === 'object'
+                    ? this.#emptyValue
+                    : Number(result.toFixed(2));
+
+            this.#parent.trigger('change');
+
+            model && model.set({ value: this.#value });
+            return this.#value;
+        } catch (e) {
+            console.log('formula', this.name, formula.formula, params);
+            console.error(e);
+            throw new Error('Error calculating the formula');
+        }
+    }
+}
+

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

@@ -0,0 +1,152 @@
+import type { FormulaManager } from '..';
+import { EvaluationsManager } from '../helpers/evaluations';
+import { Token } from '../helpers/token';
+import { FormulaObserver, IComplexCondition } from '../types/formulas';
+import { parse } from 'mathjs';
+
+export class IterativeArrayFormula {
+	#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 = this.#specs.emptyValue;
+		this.#isNotListenToChanges = specs.isNotListenToChanges
+	}
+
+	initialize() {
+		const fieldArray = this.#plugin.form.getField(this.#specs.arrayFieldName);
+		if (!fieldArray) {
+			console.error(`Field ${this.#specs.arrayFieldName} does NOT exist.`);
+			return;
+		}
+		fieldArray.on('change', this.calculate.bind(this));
+	}
+
+	async calculate() {
+
+		const formulaField = this.#plugin.form.getField(this.name);
+
+		const fieldArray = this.#plugin.form.getField(this.#specs.arrayFieldName);
+
+		if (!fieldArray) {
+			console.error(`Field ${this.#specs.arrayFieldName} does NOT exist.`);
+			return;
+		}
+
+		const entries = fieldArray[this.#specs.arrayFieldProperty];
+
+		if (!Array.isArray(entries)) {
+			console.error(`Property ${this.#specs.arrayFieldProperty} is not an array.`);
+			return;
+		}
+
+		const empty = !entries.length;
+		const formula: any = this.#specs.formula;
+		let formulaEvaluate = formula?.formula || formula
+		if (empty) {
+			// If all models are empty, set the input to empty if exists.
+			if (formulaField) formulaField.set({ value: this.#emptyValue !== undefined ? this.#emptyValue : '' });
+			this.#value = undefined;
+			this.#parent.trigger('change');
+			return;
+		}
+
+		try {
+			let totalResult: string | number = 0;
+			for (let item of entries) {
+				if (formula.conditions) {
+					for (const condition of formula.conditions) {
+						const comparisonValue = item[condition.property]
+						let conditionMet = EvaluationsManager.validate(condition.condition, comparisonValue, condition.value);
+						if (conditionMet) {
+							formulaEvaluate = condition.formula;
+							break
+						} else {
+							formulaEvaluate = formula.base
+						}
+					}
+				}
+				const attrs = this.sanitizeData(item);
+				let result = parse(formulaEvaluate as string).evaluate(attrs);
+				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);
+				totalResult = isInvalidResult ? totalResult : Number(totalResult) + Number(result.toFixed(2))
+			}
+			const isInvalidResult = [-Infinity, Infinity, undefined, null, NaN, ''].includes(totalResult);
+			this.#value = isInvalidResult ? this.#emptyValue : totalResult
+			if (formulaField) formulaField.set({ value: this.#value });
+			this.#parent.trigger('change');
+		} catch (e) {
+			console.log('formula', this.name, this.formula);
+			console.trace(e);
+			throw new Error(`Error calculating the formula: ${e.message} ${this.name}`);
+		}
+	};
+
+	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/per-value.ts

@@ -0,0 +1,152 @@
+import type { FormulaManager } from '../';
+import { EvaluationsManager } from '../helpers/evaluations';
+import { Parser } from '../helpers/parser';
+import { FormulaObserver, IComplexCondition, ParserData } from '../types/formulas';
+import { filter, parse } from 'mathjs';
+
+export class FormulaPerValue {
+	#plugin: any;
+	#emptyValue: undefined;
+	#specs: FormulaObserver;
+	get formula() {
+		return this.#specs.formula;
+	}
+	#value: string | number | undefined | 0;
+	get value() {
+		return this.#value;
+	}
+	get name() {
+		return this.#specs.name;
+	}
+
+	#observers: string[];
+	get observers() {
+		return this.#observers;
+	}
+	/**
+	 *  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;
+	}
+
+	#parent: FormulaManager;
+	#parsers: ParserData[];
+	#mainFields: any[];
+	#isNotListenToChanges = false
+	constructor(parent, plugin, specs) {
+		this.#parent = parent;
+		this.#plugin = plugin;
+		this.#specs = specs;
+		this.#observers = specs.formula.observers;
+		this.#isNotListenToChanges = specs.isNotListenToChanges
+	}
+
+	initialize() {
+		const { form } = this.#plugin;
+		const fields = new Set<string>();
+
+		this.#mainFields = this.#parent.getModels(this.fields);
+
+		/**
+		 * The method will iterate over the conditions to get the parser for each value
+		 * and get access to the fields that are part of the formula and be able to evaluate it
+		 * changes.
+		 */
+		const conditionsArray = Array.isArray(this.conditions) ? this.conditions : [];
+		conditionsArray.forEach(condition => {
+			if (!condition.condition) {
+				throw new Error('the formula per value must contain a condition property in the condition`s item');
+			}
+			if (!condition.values) {
+				throw new Error('the formula per value must contain a values property in the condition`s item');
+			}
+
+			const parsers = condition.values.map(item => this.#parent.getParser(item));
+			this.#parsers = parsers;
+			parsers.forEach(parser => {
+				parser.tokens.filter(token => token.type === 'variable').forEach(token => fields.add(token.value));
+			});
+		});
+
+		fields.forEach(field => {
+			const model = form.getField(field);
+			if (model) model.on('change', this.listenConditionals.bind(this));
+		});
+
+		this.listenConditionals();
+		if (!this.#isNotListenToChanges) this.#mainFields.forEach(item => item.on('change', this.calculate.bind(this)));
+		if (!this.#isNotListenToChanges) if (this.#observers && Array.isArray(this.#observers) && !!this.#observers.length) {
+			const fields = this.#parent.getModels(this.#observers);
+			fields.forEach(field => {
+				if (!field) return;
+				field.on('change', this.calculateAll.bind(this));
+			});
+		}
+	}
+
+	calculateAll() {
+		this.#mainFields.forEach(field => this.calculate(field));
+	}
+	listenConditionals() {
+		this.#mainFields.forEach(field => {
+			if (!field) return;
+			field.on('change', this.calculate.bind(this));
+		});
+	}
+
+	async calculate(field) {
+		if (!field) return;
+		const { form } = this.#plugin;
+		const formula = this.evaluate(field.value);
+
+		if (!formula) return;
+
+		const variables = formula.tokens.filter(token => token.type === 'variable').map(item => item.value);
+		const params = await this.#parent.getParams(variables);
+		const formulaField = form.getField(this.name);
+
+		try {
+			const keys = Object.keys(params);
+			const result = keys.length === 1 ? params[keys[0]] : parse(formula.formula as string).evaluate(params);
+			this.#value = [-Infinity, Infinity, undefined, null, NaN].includes(result)
+				? this.#emptyValue
+				: Number(result.toFixed(2));
+			formulaField && formulaField.set({ value: this.#value });
+			this.#parent.trigger('change');
+		} catch (e) {
+			console.log(e);
+			throw new Error('Error calculating the formula');
+		}
+	}
+
+	evaluate(value) {
+		let formula = undefined;
+		if ([null, undefined].includes(value)) {
+			return;
+		}
+		const conditionsArray = Array.isArray(this.conditions) ? this.conditions : [];
+		conditionsArray.forEach(item => {
+			const { condition, values } = item;
+			if (!condition) {
+				throw new Error('the formula per value must contain a condition property in the condition`s item');
+			}
+			if (!values) {
+				throw new Error('the formula per value must contain a values property in the condition`s item');
+			}
+			const index = values.findIndex(item => EvaluationsManager.validate(condition, value, item.value));
+
+			if (index > -1) formula = this.#parent.getParser(values[index]);
+		});
+
+		return formula;
+	}
+}
+

package/src/index.ts

@@ -0,0 +1,6 @@
+// Main entry point - export all modules
+export * from './form';
+export * from './formulas';
+export * from './models';
+export * from './settings';
+