@flusys/nestjs-form-builder 7.1.0 → 8.0.0

package/cjs/services/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./form-builder-config.service"), exports);
-_export_star(require("./form-builder-datasource.provider"), exports);
-_export_star(require("./form.service"), exports);
-_export_star(require("./form-result.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/utils/computed-field.utils.js

@@ -1,199 +0,0 @@
-/**
- * Computed Field Calculation Utilities
- *
- * This module provides functions to calculate computed field values
- * based on form submission data and computed field definitions.
- *
- * NOTE: Interface definitions here mirror @flusys/ng-form-builder interfaces
- * but are defined separately to avoid cross-package dependencies.
- * Both use compatible JSON structures for form schema serialization.
- *
- * @see FLUSYS_NG/projects/ng-form-builder/interfaces/computed-field.interface.ts
- */ // ============================================================================
-// Type Definitions
-// ============================================================================
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "calculateComputedFields", {
-    enumerable: true,
-    get: function() {
-        return calculateComputedFields;
-    }
-});
-// ============================================================================
-// Type Guards & Helpers
-// ============================================================================
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-function isDirectValueConfig(config) {
-    return isObject(config) && config.type === 'direct' && 'value' in config;
-}
-function isFieldReferenceConfig(config) {
-    return isObject(config) && config.type === 'field_reference' && 'fieldId' in config;
-}
-function isArithmeticConfig(config) {
-    return isObject(config) && config.type === 'arithmetic' && 'operation' in config && 'operands' in config && Array.isArray(config.operands);
-}
-function isEmptyValue(value) {
-    return value === null || value === undefined || value === '' || Array.isArray(value) && value.length === 0;
-}
-/**
- * Normalize operator to uppercase string (handles both enum and string values)
- */ function normalizeOperator(op) {
-    const strOp = String(op).toUpperCase();
-    return strOp === 'OR' ? 'OR' : 'AND';
-}
-function calculateComputedFields(formData, computedFields) {
-    if (!computedFields || computedFields.length === 0) {
-        return {};
-    }
-    const result = {};
-    for (const field of computedFields){
-        try {
-            const value = calculateComputedField(formData, field);
-            result[field.key] = value;
-        } catch (error) {
-            // If calculation fails, use default value or null
-            result[field.key] = field.defaultValue ?? null;
-        }
-    }
-    return result;
-}
-/**
- * Calculate a single computed field value
- */ function calculateComputedField(formData, field) {
-    // Evaluate rules in order, first matching rule wins
-    for (const rule of field.rules){
-        if (evaluateCondition(formData, rule.condition)) {
-            return executeComputation(formData, rule.computation, field.valueType);
-        }
-    }
-    // No rule matched, return default
-    return field.defaultValue ?? null;
-}
-/**
- * Evaluate a condition group
- */ function evaluateCondition(formData, conditionGroup) {
-    // No condition = always true
-    if (!conditionGroup || !conditionGroup.conditions || conditionGroup.conditions.length === 0) {
-        return true;
-    }
-    const results = conditionGroup.conditions.map((condition)=>evaluateSingleCondition(formData, condition));
-    // Normalize operator to handle both string and enum values
-    const operator = normalizeOperator(conditionGroup.operator);
-    if (operator === 'AND') {
-        return results.every((r)=>r);
-    } else {
-        return results.some((r)=>r);
-    }
-}
-/**
- * Evaluate a single condition
- */ function evaluateSingleCondition(formData, condition) {
-    const fieldValue = formData[condition.fieldId];
-    const compareValue = condition.value;
-    switch(condition.comparison){
-        case 'equals':
-            return fieldValue === compareValue || String(fieldValue) === String(compareValue);
-        case 'not_equals':
-            return fieldValue !== compareValue && String(fieldValue) !== String(compareValue);
-        case 'is_empty':
-            return isEmptyValue(fieldValue);
-        case 'is_not_empty':
-            return !isEmptyValue(fieldValue);
-        case 'contains':
-            return String(fieldValue).includes(String(compareValue));
-        case 'not_contains':
-            return !String(fieldValue).includes(String(compareValue));
-        case 'starts_with':
-            return String(fieldValue).startsWith(String(compareValue));
-        case 'ends_with':
-            return String(fieldValue).endsWith(String(compareValue));
-        case 'greater_than':
-            return Number(fieldValue) > Number(compareValue);
-        case 'less_than':
-            return Number(fieldValue) < Number(compareValue);
-        case 'greater_or_equal':
-            return Number(fieldValue) >= Number(compareValue);
-        case 'less_or_equal':
-            return Number(fieldValue) <= Number(compareValue);
-        case 'is_before':
-            return new Date(String(fieldValue)) < new Date(String(compareValue));
-        case 'is_after':
-            return new Date(String(fieldValue)) > new Date(String(compareValue));
-        case 'is_checked':
-            return fieldValue === true || fieldValue === 'true' || fieldValue === 1;
-        case 'is_not_checked':
-            return fieldValue === false || fieldValue === 'false' || fieldValue === 0 || !fieldValue;
-        case 'is_any_of':
-        case 'in':
-            return Array.isArray(compareValue) && compareValue.includes(fieldValue);
-        case 'is_none_of':
-        case 'not_in':
-            return !Array.isArray(compareValue) || !compareValue.includes(fieldValue);
-        default:
-            return false;
-    }
-}
-/**
- * Execute a computation and return the result
- */ function executeComputation(formData, computation, valueType) {
-    const { config } = computation;
-    // Use type guards for safe access
-    if (computation.type === 'direct' && isDirectValueConfig(config)) {
-        return valueType === 'number' ? Number(config.value) : String(config.value);
-    }
-    if (computation.type === 'field_reference' && isFieldReferenceConfig(config)) {
-        const value = formData[config.fieldId];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        return valueType === 'number' ? Number(value) : String(value);
-    }
-    if (computation.type === 'arithmetic' && isArithmeticConfig(config)) {
-        return calculateArithmetic(formData, config);
-    }
-    // Unknown computation type
-    return null;
-}
-/**
- * Perform arithmetic calculation
- */ function calculateArithmetic(formData, config) {
-    const values = config.operands.map((operand)=>{
-        if (operand.type === 'constant') {
-            return operand.value ?? 0;
-        } else {
-            const fieldValue = formData[operand.fieldId ?? ''];
-            return fieldValue !== null && fieldValue !== undefined ? Number(fieldValue) : 0;
-        }
-    });
-    if (values.length === 0) {
-        return null;
-    }
-    switch(config.operation){
-        case 'sum':
-        case 'increment':
-            return values.reduce((acc, val)=>acc + val, 0);
-        case 'subtract':
-        case 'decrement':
-            return values.reduce((acc, val, idx)=>idx === 0 ? val : acc - val, 0);
-        case 'multiply':
-            return values.reduce((acc, val)=>acc * val, 1);
-        case 'divide':
-            {
-                const [first, ...rest] = values;
-                return rest.reduce((acc, val)=>val !== 0 ? acc / val : acc, first);
-            }
-        case 'average':
-            return values.reduce((acc, val)=>acc + val, 0) / values.length;
-        case 'min':
-            return Math.min(...values);
-        case 'max':
-            return Math.max(...values);
-        default:
-            return null;
-    }
-}