@senior-gestao-empresarial/erpx-components 4.3.0 → 4.5.0

package/components/tributos/calculators/gross-amount-calculator.d.ts

@@ -1,5 +1,10 @@
 import BigNumber from 'bignumber.js';
+import { TaxRoundingService } from '../services/tax-rounding.service';
+import { TaxStore } from '../stores/tax.store';
 export declare class GrossAmountCalculator {
+    private readonly taxRoundingService;
+    private readonly taxStore;
+    constructor(taxRoundingService: TaxRoundingService, taxStore: TaxStore);
     /**
      * Calculates the gross amount based on the provided taxable base and tax rate.
      *

package/components/tributos/calculators/tax-amount-calculator.d.ts

@@ -1,8 +1,12 @@
 import BigNumber from 'bignumber.js';
 import { EffectiveTaxRateCalculator } from './effective-tax-rate-calculator';
+import { TaxRoundingService } from '../services/tax-rounding.service';
+import { TaxStore } from '../stores/tax.store';
 export declare class TaxAmountCalculator {
     private readonly effectiveTaxRateCalculator;
-    constructor(effectiveTaxRateCalculator: EffectiveTaxRateCalculator);
+    private readonly taxRoundingService;
+    private readonly taxStore;
+    constructor(effectiveTaxRateCalculator: EffectiveTaxRateCalculator, taxRoundingService: TaxRoundingService, taxStore: TaxStore);
     /**
      * Calculates the tax amount based on a taxable base and a tax rate.
      *

package/components/tributos/erp-tributos.component.d.ts

@@ -3,15 +3,21 @@ import { FormBuilder, FormGroup } from '@angular/forms';
 import { TranslateService } from '@ngx-translate/core';
 import { BeneficioFiscalLookup, ClassificacaoTributariaLookup, CplTriNotaSaidaNaturezaReceitaPisCofinsLookup, E027EqiLookup, E027StrLookup, LookupValidationUtils } from '@senior-gestao-empresarial/angular-components';
 import { BadgeColors, ButtonAnimation, ButtonPriority, ButtonSize, FormField, LocaleService } from '@seniorsistemas/angular-components';
+import { FeatureToggleService } from '@seniorsistemas/platform-components';
 import { GTagService } from '@seniorsistemas/platform-utils';
 import { MenuItem, MessageService } from 'primeng/api';
+import { LoadingContext } from '../utils/loading-context';
+import { TaxAmountCalculator } from './calculators/tax-amount-calculator';
 import { ErpTributosService } from './erp-tributos.service';
 import { Item, Sugestao, TaxCalculationMemory } from './erp-tributos.types';
 import { RulesService } from './rules/rules.service';
+import { TaxRoundingService } from './services/tax-rounding.service';
+import { TaxStore } from './stores/tax.store';
 import { Context } from './types/context';
 import { Group } from './types/group';
 import { Tax } from './types/tax';
 export declare class ErpTributosComponent implements OnInit, OnChanges, OnDestroy {
+    readonly loadingContext: LoadingContext;
     private readonly messageService;
     private readonly formBuilder;
     private readonly changeDetector;
@@ -26,6 +32,10 @@ export declare class ErpTributosComponent implements OnInit, OnChanges, OnDestro
     private readonly gtag;
     private readonly rulesService;
     private readonly localeService;
+    private readonly taxRoundingService;
+    private readonly taxAmountCalculator;
+    private readonly featureToggleService;
+    private readonly taxStore;
     context: Context;
     sugestoes: Sugestao[];
     camposBloqueados: boolean;
@@ -46,7 +56,6 @@ export declare class ErpTributosComponent implements OnInit, OnChanges, OnDestro
     reload: boolean;
     indexAccordion: number[];
     prefixLabel: string;
-    isLoading: boolean;
     private menuItemPis;
     private menuItemCofins;
     private menuItemIpi;
@@ -115,7 +124,7 @@ export declare class ErpTributosComponent implements OnInit, OnChanges, OnDestro
     private requiredFcpStReditoAnt;
     private percentageLocaleOptions?;
     private readonly unsubscribe$;
-    constructor(messageService: MessageService, formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, translate: TranslateService, e027StrLookup: E027StrLookup, beneficioFiscalLookup: BeneficioFiscalLookup, e027eqiLookup: E027EqiLookup, naturezaReceitaLookup: CplTriNotaSaidaNaturezaReceitaPisCofinsLookup, classificacaoTributariaLookup: ClassificacaoTributariaLookup, lookupUtils: LookupValidationUtils, erpTributosService: ErpTributosService, gtag: GTagService, rulesService: RulesService, localeService: LocaleService);
+    constructor(loadingContext: LoadingContext, messageService: MessageService, formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, translate: TranslateService, e027StrLookup: E027StrLookup, beneficioFiscalLookup: BeneficioFiscalLookup, e027eqiLookup: E027EqiLookup, naturezaReceitaLookup: CplTriNotaSaidaNaturezaReceitaPisCofinsLookup, classificacaoTributariaLookup: ClassificacaoTributariaLookup, lookupUtils: LookupValidationUtils, erpTributosService: ErpTributosService, gtag: GTagService, rulesService: RulesService, localeService: LocaleService, taxRoundingService: TaxRoundingService, taxAmountCalculator: TaxAmountCalculator, featureToggleService: FeatureToggleService, taxStore: TaxStore);
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
@@ -174,7 +183,6 @@ export declare class ErpTributosComponent implements OnInit, OnChanges, OnDestro
     private setVariableRequired;
     private setRequired;
     private impostoCalculado;
-    private roundImposto;
     private addMessageErrorBaseDiferente;
     private calcularValor;
     private calcularImpostosTotal;
@@ -199,4 +207,6 @@ export declare class ErpTributosComponent implements OnInit, OnChanges, OnDestro
     };
     private isInvoiceDocument;
     private isFieldRequired;
+    private markICMSSimplesAsManual;
+    private getArredondamentoAbnt;
 }

package/components/tributos/services/tax-rounding.service.d.ts

@@ -0,0 +1,5 @@
+import BigNumber from 'bignumber.js';
+export declare class TaxRoundingService {
+    halfEven(value: BigNumber.Value, decimalPlaces?: number): BigNumber;
+    halfUp(value: number, decimalPlaces?: number): BigNumber;
+}

package/components/tributos/stores/tax.store.d.ts

@@ -0,0 +1,10 @@
+import { ComponentStore } from '@ngrx/component-store';
+export declare class TaxStore extends ComponentStore<Store> {
+    constructor();
+    readonly getArredondamentoAbnt: () => boolean;
+    readonly setArredondamentoAbnt: (arredondamentoAbnt: boolean) => void;
+}
+declare type Store = {
+    arredondamentoAbnt: boolean;
+};
+export {};

package/components/utils/loading-context.d.ts

@@ -0,0 +1,7 @@
+export declare class LoadingContext {
+    private contexts;
+    push(context?: string): void;
+    pop(): void;
+    isLoading(): boolean;
+    getContext(): string[];
+}

package/esm2015/components/tributos/calculators/gross-amount-calculator.js

@@ -1,7 +1,15 @@
 import { __decorate } from "tslib";
 import { Injectable } from '@angular/core';
+import { TaxRoundingService } from '../services/tax-rounding.service';
+import { TaxStore } from '../stores/tax.store';
 import * as i0 from "@angular/core";
+import * as i1 from "../services/tax-rounding.service";
+import * as i2 from "../stores/tax.store";
 let GrossAmountCalculator = class GrossAmountCalculator {
+    constructor(taxRoundingService, taxStore) {
+        this.taxRoundingService = taxRoundingService;
+        this.taxStore = taxStore;
+    }
     /**
      * Calculates the gross amount based on the provided taxable base and tax rate.
      *
@@ -11,12 +19,19 @@ let GrossAmountCalculator = class GrossAmountCalculator {
      * @returns The calculated gross amount as a BigNumber.
      */
     calculateGrossAmount({ taxableBase, taxRate }) {
-        return taxableBase.multipliedBy(taxRate).dividedBy(100);
+        const taxAmount = taxableBase.multipliedBy(taxRate).dividedBy(100);
+        return this.taxStore.getArredondamentoAbnt()
+            ? this.taxRoundingService.halfEven(taxAmount)
+            : this.taxRoundingService.halfUp(taxAmount.toNumber());
     }
 };
-GrossAmountCalculator.ɵprov = i0.ɵɵdefineInjectable({ factory: function GrossAmountCalculator_Factory() { return new GrossAmountCalculator(); }, token: GrossAmountCalculator, providedIn: "root" });
+GrossAmountCalculator.ctorParameters = () => [
+    { type: TaxRoundingService },
+    { type: TaxStore }
+];
+GrossAmountCalculator.ɵprov = i0.ɵɵdefineInjectable({ factory: function GrossAmountCalculator_Factory() { return new GrossAmountCalculator(i0.ɵɵinject(i1.TaxRoundingService), i0.ɵɵinject(i2.TaxStore)); }, token: GrossAmountCalculator, providedIn: "root" });
 GrossAmountCalculator = __decorate([
     Injectable({ providedIn: 'root' })
 ], GrossAmountCalculator);
 export { GrossAmountCalculator };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3Jvc3MtYW1vdW50LWNhbGN1bGF0b3IuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1lbXByZXNhcmlhbC9lcnB4LWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJjb21wb25lbnRzL3RyaWJ1dG9zL2NhbGN1bGF0b3JzL2dyb3NzLWFtb3VudC1jYWxjdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUkzQyxJQUFhLHFCQUFxQixHQUFsQyxNQUFhLHFCQUFxQjtJQUM5Qjs7Ozs7OztPQU9HO0lBQ0gsb0JBQW9CLENBQUMsRUFDakIsV0FBVyxFQUNYLE9BQU8sRUFJVjtRQUNHLE9BQU8sV0FBVyxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDNUQsQ0FBQztDQUNKLENBQUE7O0FBbEJZLHFCQUFxQjtJQURqQyxVQUFVLENBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLENBQUM7R0FDdEIscUJBQXFCLENBa0JqQztTQWxCWSxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCBCaWdOdW1iZXIgZnJvbSAnYmlnbnVtYmVyLmpzJztcclxuXHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBHcm9zc0Ftb3VudENhbGN1bGF0b3Ige1xyXG4gICAgLyoqXHJcbiAgICAgKiBDYWxjdWxhdGVzIHRoZSBncm9zcyBhbW91bnQgYmFzZWQgb24gdGhlIHByb3ZpZGVkIHRheGFibGUgYmFzZSBhbmQgdGF4IHJhdGUuXHJcbiAgICAgKlxyXG4gICAgICogQHBhcmFtIHBhcmFtcyAtIEFuIG9iamVjdCBjb250YWluaW5nOlxyXG4gICAgICogICAtIHRheGFibGVCYXNlOiBUaGUgYmFzZSBhbW91bnQgdG8gYmUgdGF4ZWQgYXMgYSBCaWdOdW1iZXIuXHJcbiAgICAgKiAgIC0gdGF4UmF0ZTogVGhlIHRheCByYXRlIHRvIGFwcGx5IGFzIGEgQmlnTnVtYmVyIChwZXJjZW50YWdlKS5cclxuICAgICAqIEByZXR1cm5zIFRoZSBjYWxjdWxhdGVkIGdyb3NzIGFtb3VudCBhcyBhIEJpZ051bWJlci5cclxuICAgICAqL1xyXG4gICAgY2FsY3VsYXRlR3Jvc3NBbW91bnQoe1xyXG4gICAgICAgIHRheGFibGVCYXNlLFxyXG4gICAgICAgIHRheFJhdGVcclxuICAgIH06IHtcclxuICAgICAgICB0YXhhYmxlQmFzZTogQmlnTnVtYmVyO1xyXG4gICAgICAgIHRheFJhdGU6IEJpZ051bWJlcjtcclxuICAgIH0pOiBCaWdOdW1iZXIge1xyXG4gICAgICAgIHJldHVybiB0YXhhYmxlQmFzZS5tdWx0aXBsaWVkQnkodGF4UmF0ZSkuZGl2aWRlZEJ5KDEwMCk7XHJcbiAgICB9XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/tributos/calculators/tax-amount-calculator.js

@@ -2,11 +2,17 @@ import { __decorate } from "tslib";
 import { Injectable } from '@angular/core';
 import BigNumber from 'bignumber.js';
 import { EffectiveTaxRateCalculator } from './effective-tax-rate-calculator';
+import { TaxRoundingService } from '../services/tax-rounding.service';
+import { TaxStore } from '../stores/tax.store';
 import * as i0 from "@angular/core";
 import * as i1 from "./effective-tax-rate-calculator";
+import * as i2 from "../services/tax-rounding.service";
+import * as i3 from "../stores/tax.store";
 let TaxAmountCalculator = class TaxAmountCalculator {
-    constructor(effectiveTaxRateCalculator) {
+    constructor(effectiveTaxRateCalculator, taxRoundingService, taxStore) {
         this.effectiveTaxRateCalculator = effectiveTaxRateCalculator;
+        this.taxRoundingService = taxRoundingService;
+        this.taxStore = taxStore;
     }
     /**
      * Calculates the tax amount based on a taxable base and a tax rate.
@@ -17,7 +23,12 @@ let TaxAmountCalculator = class TaxAmountCalculator {
      * @returns The calculated tax amount as a BigNumber.
      */
     calculateTaxAmount({ taxableBase, taxRate }) {
-        return new BigNumber(taxableBase).multipliedBy(taxRate).dividedBy(100);
+        const taxAmount = new BigNumber(taxableBase)
+            .multipliedBy(taxRate)
+            .dividedBy(100);
+        return this.taxStore.getArredondamentoAbnt()
+            ? this.taxRoundingService.halfEven(taxAmount)
+            : this.taxRoundingService.halfUp(taxAmount.toNumber());
     }
     /**
      * Calculates the tax amount considering a deferred tax value.
@@ -29,10 +40,13 @@ let TaxAmountCalculator = class TaxAmountCalculator {
      * @returns The calculated tax amount after subtracting the deferred tax.
      */
     calculateTaxAmountWithDeferredTax({ taxableBase, taxRate, deferredTaxAmount }) {
-        return new BigNumber(taxableBase)
+        const taxAmount = new BigNumber(taxableBase)
             .multipliedBy(taxRate)
             .dividedBy(100)
             .minus(deferredTaxAmount);
+        return this.taxStore.getArredondamentoAbnt()
+            ? this.taxRoundingService.halfEven(taxAmount)
+            : this.taxRoundingService.halfUp(taxAmount.toNumber());
     }
     /**
      * Calculates the tax amount based on the provided tax base, tax rate, and tax rate reduction,
@@ -52,17 +66,22 @@ let TaxAmountCalculator = class TaxAmountCalculator {
             taxRate,
             taxRateReduction
         });
-        return new BigNumber(taxBase)
+        const taxAmount = new BigNumber(taxBase)
             .multipliedBy(effectiveTaxRate)
             .dividedBy(100);
+        return this.taxStore.getArredondamentoAbnt()
+            ? this.taxRoundingService.halfEven(taxAmount)
+            : this.taxRoundingService.halfUp(taxAmount.toNumber());
     }
 };
 TaxAmountCalculator.ctorParameters = () => [
-    { type: EffectiveTaxRateCalculator }
+    { type: EffectiveTaxRateCalculator },
+    { type: TaxRoundingService },
+    { type: TaxStore }
 ];
-TaxAmountCalculator.ɵprov = i0.ɵɵdefineInjectable({ factory: function TaxAmountCalculator_Factory() { return new TaxAmountCalculator(i0.ɵɵinject(i1.EffectiveTaxRateCalculator)); }, token: TaxAmountCalculator, providedIn: "root" });
+TaxAmountCalculator.ɵprov = i0.ɵɵdefineInjectable({ factory: function TaxAmountCalculator_Factory() { return new TaxAmountCalculator(i0.ɵɵinject(i1.EffectiveTaxRateCalculator), i0.ɵɵinject(i2.TaxRoundingService), i0.ɵɵinject(i3.TaxStore)); }, token: TaxAmountCalculator, providedIn: "root" });
 TaxAmountCalculator = __decorate([
     Injectable({ providedIn: 'root' })
 ], TaxAmountCalculator);
 export { TaxAmountCalculator };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tax-amount-calculator.js","sourceRoot":"ng://@senior-gestao-empresarial/erpx-components/","sources":["components/tributos/calculators/tax-amount-calculator.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;;;;;AAG/C,IAAa,mBAAmB,GAAhC,MAAa,mBAAmB;IAC5B,YACqB,0BAAsD,EACtD,kBAAsC,EACtC,QAAkB;QAFlB,+BAA0B,GAA1B,0BAA0B,CAA4B;QACtD,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,aAAQ,GAAR,QAAQ,CAAU;IACpC,CAAC;IAEJ;;;;;;;OAOG;IACH,kBAAkB,CAAC,EACf,WAAW,EACX,OAAO,EAIV;QACG,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,WAAW,CAAC;aACvC,YAAY,CAAC,OAAO,CAAC;aACrB,SAAS,CAAC,GAAG,CAAC,CAAC;QAEpB,OAAO,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE;YACxC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC7C,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;;;OAQG;IACH,iCAAiC,CAAC,EAC9B,WAAW,EACX,OAAO,EACP,iBAAiB,EAKpB;QACG,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,WAAW,CAAC;aACvC,YAAY,CAAC,OAAO,CAAC;aACrB,SAAS,CAAC,GAAG,CAAC;aACd,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAE9B,OAAO,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE;YACxC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC7C,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,kEAAkE,CAAC,EAC/D,OAAO,EACP,OAAO,EACP,gBAAgB,EAKnB;QACG,MAAM,gBAAgB,GAClB,IAAI,CAAC,0BAA0B,CAAC,6DAA6D,CACzF;YACI,OAAO;YACP,gBAAgB;SACnB,CACJ,CAAC;QAEN,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,OAAO,CAAC;aACnC,YAAY,CAAC,gBAAgB,CAAC;aAC9B,SAAS,CAAC,GAAG,CAAC,CAAC;QAEpB,OAAO,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE;YACxC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC7C,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC/D,CAAC;CACJ,CAAA;;YA/FoD,0BAA0B;YAClC,kBAAkB;YAC5B,QAAQ;;;AAJ9B,mBAAmB;IAD/B,UAAU,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;GACtB,mBAAmB,CAiG/B;SAjGY,mBAAmB","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport BigNumber from 'bignumber.js';\r\nimport { EffectiveTaxRateCalculator } from './effective-tax-rate-calculator';\r\nimport { TaxRoundingService } from '../services/tax-rounding.service';\r\nimport { TaxStore } from '../stores/tax.store';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TaxAmountCalculator {\r\n    constructor(\r\n        private readonly effectiveTaxRateCalculator: EffectiveTaxRateCalculator,\r\n        private readonly taxRoundingService: TaxRoundingService,\r\n        private readonly taxStore: TaxStore\r\n    ) {}\r\n\r\n    /**\r\n     * Calculates the tax amount based on a taxable base and a tax rate.\r\n     *\r\n     * @param params - An object containing:\r\n     *   @param params.taxableBase - The base amount on which the tax is calculated (as a BigNumber).\r\n     *   @param params.taxRate - The tax rate to apply (as a BigNumber, representing a percentage).\r\n     * @returns The calculated tax amount as a BigNumber.\r\n     */\r\n    calculateTaxAmount({\r\n        taxableBase,\r\n        taxRate\r\n    }: {\r\n        taxableBase: BigNumber;\r\n        taxRate: BigNumber;\r\n    }): BigNumber {\r\n        const taxAmount = new BigNumber(taxableBase)\r\n            .multipliedBy(taxRate)\r\n            .dividedBy(100);\r\n\r\n        return this.taxStore.getArredondamentoAbnt()\r\n            ? this.taxRoundingService.halfEven(taxAmount)\r\n            : this.taxRoundingService.halfUp(taxAmount.toNumber());\r\n    }\r\n\r\n    /**\r\n     * Calculates the tax amount considering a deferred tax value.\r\n     *\r\n     * @param params - The parameters for the calculation.\r\n     * @param params.taxableBase - The base amount on which tax is calculated.\r\n     * @param params.taxRate - The tax rate as a percentage.\r\n     * @param params.deferredTaxAmount - The amount of tax that is deferred and should be subtracted from the result.\r\n     * @returns The calculated tax amount after subtracting the deferred tax.\r\n     */\r\n    calculateTaxAmountWithDeferredTax({\r\n        taxableBase,\r\n        taxRate,\r\n        deferredTaxAmount\r\n    }: {\r\n        taxableBase: BigNumber;\r\n        taxRate: BigNumber;\r\n        deferredTaxAmount: BigNumber;\r\n    }): BigNumber {\r\n        const taxAmount = new BigNumber(taxableBase)\r\n            .multipliedBy(taxRate)\r\n            .dividedBy(100)\r\n            .minus(deferredTaxAmount);\r\n\r\n        return this.taxStore.getArredondamentoAbnt()\r\n            ? this.taxRoundingService.halfEven(taxAmount)\r\n            : this.taxRoundingService.halfUp(taxAmount.toNumber());\r\n    }\r\n\r\n    /**\r\n     * Calculates the tax amount based on the provided tax base, tax rate, and tax rate reduction,\r\n     * excluding deferred tax and governamental tax rate reductions.\r\n     *\r\n     * This method uses the effective tax rate calculated without considering governamental tax rate reductions,\r\n     * and applies it to the tax base to determine the final tax amount.\r\n     *\r\n     * @param params - The parameters for tax calculation.\r\n     * @param params.taxBase - The base amount on which the tax is calculated.\r\n     * @param params.taxRate - The initial tax rate before any reductions.\r\n     * @param params.taxRateReduction - The reduction applied to the tax rate.\r\n     * @returns The calculated tax amount as a BigNumber.\r\n     */\r\n    calculateTaxAmountWithoutDeferredTaxAndWithoutGovernamentalTaxRate({\r\n        taxBase,\r\n        taxRate,\r\n        taxRateReduction\r\n    }: {\r\n        taxBase: BigNumber;\r\n        taxRate: BigNumber;\r\n        taxRateReduction: BigNumber;\r\n    }): BigNumber {\r\n        const effectiveTaxRate =\r\n            this.effectiveTaxRateCalculator.calculateEffectiveTaxRateWithoutGovernamentalTaxRateReduction(\r\n                {\r\n                    taxRate,\r\n                    taxRateReduction\r\n                }\r\n            );\r\n\r\n        const taxAmount = new BigNumber(taxBase)\r\n            .multipliedBy(effectiveTaxRate)\r\n            .dividedBy(100);\r\n\r\n        return this.taxStore.getArredondamentoAbnt()\r\n            ? this.taxRoundingService.halfEven(taxAmount)\r\n            : this.taxRoundingService.halfUp(taxAmount.toNumber());\r\n    }\r\n}\r\n"]}