b2m-utils 0.0.311 → 0.0.313

package/build/functions/buildFeeExclusionsMap/index.d.ts

@@ -1,7 +1,7 @@
-import { RatecardLaneFee } from "../../types";
+import { Ratecard } from "../../types";
 /**
  * Constrói um Map de exclusões de fees baseado nas configurações do tarifário
- * @param fees - Array de fees do tarifário
+ * @param ratecard - Tarifário contendo as configurações de fees
  * @returns Map onde a chave é o feeId e o valor é um Set de feeIds excluídos da base de cálculo
  */
-export declare const buildFeeExclusionsMap: (fees: RatecardLaneFee[]) => Map<number, Set<number>>;
+export declare const buildFeeExclusionsMap: (ratecard?: Ratecard) => Map<number, Set<number>>;

package/build/functions/calculateFeesCacheWithDetails/index.d.ts

@@ -1,4 +1,4 @@
-import { Cte, RatecardLaneFee } from "../../types";
+import { Cte, RatecardLaneFee, Ratecard } from "../../types";
 export interface FeeCalculationResult {
     totalFee: number;
     totalToCalc: number;
@@ -17,6 +17,8 @@ export interface CalculateFeesCacheOptions {
     preCalculatedValues?: Map<number, number>;
     /** IDs de fees que foram editadas manualmente e não devem ser recalculadas */
     manuallyEditedFeeIds?: Set<number>;
+    /** Tarifário (opcional, será extraído do CTE se não fornecido) */
+    ratecard?: Ratecard;
 }
 /**
  * Calcula todas as fees em 3 passadas (normais, TOTAL_PERCENTAGE, ICMS) e retorna um cache detalhado

package/build/functions/calculateFeesTotal/index.d.ts

@@ -1,9 +1,10 @@
-import { Cte, RatecardLaneFee } from "../../types";
+import { Cte, RatecardLaneFee, Ratecard } from "../../types";
 /**
  * Calcula o total de fees de forma consistente, usando cálculo iterativo para TOTAL_PERCENTAGE
  * @param fees - Array de fees a calcular
  * @param cte - CTE para cálculo
  * @param allFeesForCalc - Todas as fees disponíveis para cálculo
+ * @param ratecard - Tarifário (opcional, será extraído do CTE se não fornecido)
  * @returns Total calculado
  */
-export declare const calculateFeesTotal: (fees: RatecardLaneFee[], cte: Cte, allFeesForCalc?: RatecardLaneFee[]) => number;
+export declare const calculateFeesTotal: (fees: RatecardLaneFee[], cte: Cte, allFeesForCalc?: RatecardLaneFee[], ratecard?: Ratecard) => number;

package/build/index.esm.js

@@ -418,28 +418,57 @@ var applyRedeliveryMultiplier = function (total, cte) {
 
 /**
  * Constrói um Map de exclusões de fees baseado nas configurações do tarifário
- * @param fees - Array de fees do tarifário
+ * @param ratecard - Tarifário contendo as configurações de fees
  * @returns Map onde a chave é o feeId e o valor é um Set de feeIds excluídos da base de cálculo
  */
-var buildFeeExclusionsMap = function (fees) {
+var buildFeeExclusionsMap = function (ratecard) {
+    var _a;
     var exclusionsMap = new Map();
-    fees.forEach(function (fee) {
-        var _a;
-        if (!((_a = fee.fee) === null || _a === void 0 ? void 0 : _a.id) || !fee.fee.RatecardFeeConfig)
-            return;
-        // Procurar pela configuração de exclusão
-        var excludeConfig = fee.fee.RatecardFeeConfig.find(function (config) { var _a; return ((_a = config.feeConfig) === null || _a === void 0 ? void 0 : _a.configKey) === RatecardFeeConfigKeyEnum.EXCLUDE_FROM_TOTAL_PERCENTAGE; });
-        if (excludeConfig === null || excludeConfig === void 0 ? void 0 : excludeConfig.configValue) {
+    console.log('[buildFeeExclusionsMap] Iniciando construção do mapa de exclusões', {
+        ratecardId: ratecard === null || ratecard === void 0 ? void 0 : ratecard.id,
+        hasConfigs: !!(ratecard === null || ratecard === void 0 ? void 0 : ratecard.RatecardFeeConfig),
+        configsCount: ((_a = ratecard === null || ratecard === void 0 ? void 0 : ratecard.RatecardFeeConfig) === null || _a === void 0 ? void 0 : _a.length) || 0
+    });
+    if (!(ratecard === null || ratecard === void 0 ? void 0 : ratecard.RatecardFeeConfig)) {
+        console.log('[buildFeeExclusionsMap] Nenhuma configuração encontrada, retornando mapa vazio');
+        return exclusionsMap;
+    }
+    // Iterar sobre todas as configurações de fees do ratecard
+    ratecard.RatecardFeeConfig.forEach(function (config) {
+        var _a, _b;
+        // Verificar se é uma configuração de exclusão
+        if (((_a = config.feeConfig) === null || _a === void 0 ? void 0 : _a.configKey) === RatecardFeeConfigKeyEnum.EXCLUDE_FROM_TOTAL_PERCENTAGE &&
+            config.configValue &&
+            config.feeId) {
+            console.log('[buildFeeExclusionsMap] Configuração de exclusão encontrada', {
+                feeId: config.feeId,
+                feeName: (_b = config.fee) === null || _b === void 0 ? void 0 : _b.name,
+                configValue: config.configValue
+            });
             // Parse dos IDs separados por vírgula
-            var excludedIds = excludeConfig.configValue
+            var excludedIds = config.configValue
                 .split(',')
                 .map(function (id) { return parseInt(id.trim(), 10); })
                 .filter(function (id) { return !isNaN(id); });
             if (excludedIds.length > 0) {
-                exclusionsMap.set(fee.fee.id, new Set(excludedIds));
+                exclusionsMap.set(config.feeId, new Set(excludedIds));
+                console.log('[buildFeeExclusionsMap] Exclusões adicionadas ao mapa', {
+                    feeId: config.feeId,
+                    excludedIds: Array.from(excludedIds)
+                });
             }
         }
     });
+    console.log('[buildFeeExclusionsMap] Mapa de exclusões construído', {
+        totalExclusions: exclusionsMap.size,
+        exclusionsMap: Array.from(exclusionsMap.entries()).map(function (_a) {
+            var feeId = _a[0], excludedIds = _a[1];
+            return ({
+                feeId: feeId,
+                excludedIds: Array.from(excludedIds)
+            });
+        })
+    });
     return exclusionsMap;
 };
 
@@ -1042,17 +1071,31 @@ var calculateTotalPercentageFees = function (allFees, cte, allFeesForCalc, curre
     // Calcular base das fees não-percentuais
     // Se temos currentValues, usar eles; senão calcular normalmente
     var baseNonPercentage = 0;
+    var nonPercentageDetails = [];
     if (currentValues) {
         // Usar valores atuais das fees não-percentuais
         baseNonPercentage = nonPercentageFees.reduce(function (sum, fee) {
             var _a;
             var value = ((_a = fee.fee) === null || _a === void 0 ? void 0 : _a.id) ? currentValues.get(fee.fee.id) : undefined;
             if (value !== undefined) {
+                nonPercentageDetails.push({
+                    feeId: fee.fee.id,
+                    feeName: fee.fee.name || 'Unknown',
+                    value: value
+                });
                 return sum + value;
             }
             // Se não tem valor atual, calcular
             var calculated = calculateFee(fee, cte, allFees, false, allFeesForCalc);
-            return sum + ((calculated === null || calculated === void 0 ? void 0 : calculated.totalToCalc) || 0);
+            var calcValue = (calculated === null || calculated === void 0 ? void 0 : calculated.totalToCalc) || 0;
+            if (calcValue > 0) {
+                nonPercentageDetails.push({
+                    feeId: fee.fee.id,
+                    feeName: fee.fee.name || 'Unknown',
+                    value: calcValue
+                });
+            }
+            return sum + calcValue;
         }, 0);
     }
     else {
@@ -1060,8 +1103,24 @@ var calculateTotalPercentageFees = function (allFees, cte, allFeesForCalc, curre
         var nonPercentageResults = filterSiblingFees(nonPercentageFees.map(function (it) {
             return calculateFee(it, cte, allFees, false, allFeesForCalc);
         }));
-        baseNonPercentage = nonPercentageResults.reduce(function (sum, r) { return sum + (r.totalToCalc || 0); }, 0);
+        baseNonPercentage = nonPercentageResults.reduce(function (sum, r) {
+            var _a;
+            var value = r.totalToCalc || 0;
+            if (value > 0 && ((_a = r.fee) === null || _a === void 0 ? void 0 : _a.id)) {
+                nonPercentageDetails.push({
+                    feeId: r.fee.id,
+                    feeName: r.fee.name || 'Unknown',
+                    value: value
+                });
+            }
+            return sum + value;
+        }, 0);
     }
+    console.log('[calculateTotalPercentageFees] Base não-percentual calculada', {
+        baseNonPercentage: baseNonPercentage,
+        nonPercentageFeesCount: nonPercentageFees.length,
+        nonPercentageDetails: nonPercentageDetails
+    });
     // Calcular fees percentuais iterativamente até convergir
     var maxIterations = 10;
     var tolerance = 0.01; // Tolerância de 1 centavo
@@ -1084,6 +1143,14 @@ var calculateTotalPercentageFees = function (allFees, cte, allFeesForCalc, curre
             }
             // Calcular base: fees não-percentuais + outras fees percentuais (exceto ela mesma e excluídas)
             var excludedFeeIds = (feeExclusions === null || feeExclusions === void 0 ? void 0 : feeExclusions.get(pf.fee.id)) || new Set();
+            console.log('[calculateTotalPercentageFees] Calculando fee TOTAL_PERCENTAGE', {
+                feeId: pf.fee.id,
+                feeName: pf.fee.name,
+                percentValue: pf.value,
+                hasExclusions: excludedFeeIds.size > 0,
+                excludedFeeIds: Array.from(excludedFeeIds),
+                iteration: iteration
+            });
             var basePercentage = Array.from(previousValues.entries())
                 .filter(function (_a) {
                 var feeId = _a[0];
@@ -1096,6 +1163,23 @@ var calculateTotalPercentageFees = function (allFees, cte, allFeesForCalc, curre
             var baseValue = baseNonPercentage + basePercentage;
             var percentValue = (+pf.value / 100);
             var calculatedValue = baseValue * percentValue;
+            console.log('[calculateTotalPercentageFees] Base calculada', {
+                feeId: pf.fee.id,
+                feeName: pf.fee.name,
+                baseNonPercentage: baseNonPercentage,
+                basePercentage: basePercentage,
+                baseValue: baseValue,
+                percentValue: "".concat(pf.value, "%"),
+                calculatedValue: calculatedValue,
+                allPreviousValues: Array.from(previousValues.entries()).map(function (_a) {
+                    var id = _a[0], val = _a[1];
+                    return ({
+                        feeId: id,
+                        value: val,
+                        excluded: excludedFeeIds.has(id)
+                    });
+                })
+            });
             previousValues.set(pf.fee.id, calculatedValue);
             // Armazenar resultado
             results.set(pf.fee.id, __assign(__assign({}, pf), { totalFee: calculatedValue, totalToCalc: calculatedValue, resultFee: "".concat(convertNumberToCurrency(baseValue, 'pt-br'), " x ").concat(+pf.value, "% = ").concat(convertNumberToCurrency(calculatedValue, 'pt-br')) }));
@@ -1171,12 +1255,14 @@ var calculateIcms = function (totalFromAllFees, icmsRate) {
  * Esta função centraliza a lógica de cálculo que estava duplicada em vários lugares do ModalCte.
  */
 var calculateFeesCacheWithDetails = function (options) {
-    var fees = options.fees, cte = options.cte, allFeesForCalc = options.allFeesForCalc, _a = options.excludedIndexes, excludedIndexes = _a === void 0 ? new Set() : _a, preCalculatedValues = options.preCalculatedValues, manuallyEditedFeeIds = options.manuallyEditedFeeIds;
+    var fees = options.fees, cte = options.cte, allFeesForCalc = options.allFeesForCalc, _a = options.excludedIndexes, excludedIndexes = _a === void 0 ? new Set() : _a, preCalculatedValues = options.preCalculatedValues, manuallyEditedFeeIds = options.manuallyEditedFeeIds, ratecard = options.ratecard;
     var cache = {};
     // Filtrar fees não excluídas
     var nonExcludedFees = fees.filter(function (_, idx) { return !excludedIndexes.has(idx); });
-    // Construir mapa de exclusões a partir das configurações
-    var feeExclusions = buildFeeExclusionsMap(fees);
+    // Obter ratecard se não foi fornecido
+    var ratecardToUse = ratecard || getRatecardFromCte(cte) || undefined;
+    // Construir mapa de exclusões a partir das configurações do ratecard
+    var feeExclusions = buildFeeExclusionsMap(ratecardToUse);
     // PASSADA 1: Calcular fees normais (não TOTAL_PERCENTAGE, não ICMS)
     fees.forEach(function (fee, idx) {
         var _a, _b;
@@ -1261,14 +1347,17 @@ var calculateFeesTotalFromCache = function (options) {
  * @param fees - Array de fees a calcular
  * @param cte - CTE para cálculo
  * @param allFeesForCalc - Todas as fees disponíveis para cálculo
+ * @param ratecard - Tarifário (opcional, será extraído do CTE se não fornecido)
  * @returns Total calculado
  */
-var calculateFeesTotal = function (fees, cte, allFeesForCalc) {
+var calculateFeesTotal = function (fees, cte, allFeesForCalc, ratecard) {
     if (!fees || fees.length === 0)
         return 0;
     var cache = {};
-    // Construir mapa de exclusões a partir das configurações
-    var feeExclusions = buildFeeExclusionsMap(fees);
+    // Obter ratecard se não foi fornecido
+    var ratecardToUse = ratecard || getRatecardFromCte(cte) || undefined;
+    // Construir mapa de exclusões a partir das configurações do ratecard
+    var feeExclusions = buildFeeExclusionsMap(ratecardToUse);
     // PASSADA 1: Calcular fees normais (não TOTAL_PERCENTAGE, não ICMS)
     fees.forEach(function (fee, idx) {
         var _a, _b;