@senior-gestao-empresarial/erpx-components 0.0.0-develop-3bab051d

package/esm2015/components/rateio-editor/erp-rateio-editor.converter.js

@@ -0,0 +1,52 @@
+/**
+ * Converte entre o modelo plano (recDistribuicaoRateioManual — output de sugerirRateio)
+ * e o modelo hierárquico (recRateioConta + recRateioCCusto — usado pelo form e pela gravação).
+ */
+export class ErpRateioEditorConverter {
+    /**
+     * Agrupa itens planos por conta financeira (e091plf_id), gerando a estrutura
+     * hierárquica esperada pelo form e pela API gravarRateioManual.
+     *
+     * Regras:
+     * - Itens com mesmo e091plf_id são agrupados em uma única RateioConta.
+     * - Se e044ccu_id estiver preenchido, gera um RateioCCusto dentro da conta.
+     * - Percentual e valor da conta são a soma dos itens agrupados.
+     * - Labels (contaFinanceira, descCCusto) ficam vazios — devem ser resolvidos via lookup pelo componente.
+     */
+    static sugestaoPlanaParaHierarquica(planas) {
+        if (!planas || planas.length === 0) {
+            return [];
+        }
+        const porConta = new Map();
+        for (const item of planas) {
+            let conta = porConta.get(item.e091plf_id);
+            if (!conta) {
+                conta = {
+                    idContaFinanceira: item.e091plf_id,
+                    contaFinanceira: '',
+                    idContaContabil: item.e045pla_id || null,
+                    contaContabil: null,
+                    idProjeto: item.e615prj_id || null,
+                    projeto: null,
+                    idFaseProjeto: item.e615fpj_id || null,
+                    faseProjeto: null,
+                    percentual: 0,
+                    valorRateadoConta: 0,
+                    rateiosCCusto: []
+                };
+                porConta.set(item.e091plf_id, conta);
+            }
+            conta.percentual += item.percentual;
+            conta.valorRateadoConta += item.valor;
+            if (item.e044ccu_id) {
+                conta.rateiosCCusto.push({
+                    idCentroCusto: item.e044ccu_id,
+                    percentual: item.percentual,
+                    valor: item.valor
+                });
+            }
+        }
+        return Array.from(porConta.values());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/rateio-editor/erp-rateio-editor.module.js

@@ -0,0 +1,40 @@
+import { __decorate } from "tslib";
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TranslateModule } from '@ngx-translate/core';
+import { ErpLookupsModule } from '@senior-gestao-empresarial/angular-components';
+import { ButtonModule, DynamicFormModule, EmptyStateModule, LoadingStateModule, LocaleModule, StatsCardModule, TableModule as STableModule } from '@seniorsistemas/angular-components';
+import { TableModule } from 'primeng/table';
+import { PanelModule } from 'primeng/panel';
+import { DialogModule } from 'primeng/dialog';
+import { ErpRateioEditorComponent } from './erp-rateio-editor.component';
+import { ErpRateioEditorService } from './erp-rateio-editor.service';
+let ErpRateioEditorModule = class ErpRateioEditorModule {
+};
+ErpRateioEditorModule = __decorate([
+    NgModule({
+        declarations: [ErpRateioEditorComponent],
+        imports: [
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslateModule,
+            ButtonModule,
+            DynamicFormModule,
+            EmptyStateModule,
+            LoadingStateModule,
+            LocaleModule,
+            ErpLookupsModule,
+            StatsCardModule,
+            TableModule,
+            STableModule,
+            PanelModule,
+            DialogModule
+        ],
+        providers: [ErpRateioEditorService],
+        exports: [ErpRateioEditorComponent]
+    })
+], ErpRateioEditorModule);
+export { ErpRateioEditorModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/rateio-editor/erp-rateio-editor.service.js

@@ -0,0 +1,49 @@
+import { __decorate } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { MessageService } from 'primeng/api';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+let ErpRateioEditorService = class ErpRateioEditorService {
+    constructor(http, messageService) {
+        this.http = http;
+        this.messageService = messageService;
+        this.baseQueries = 'erpx_fin_rat/rateio/queries';
+        this.baseActions = 'erpx_fin_rat/rateio/actions';
+    }
+    retornarRateio(input) {
+        return this.http
+            .post(`${this.baseQueries}/retornarRateio`, input)
+            .pipe(this.defaultCatch());
+    }
+    sugerirRateio(input) {
+        return this.http
+            .post(`${this.baseQueries}/sugerirRateio`, input)
+            .pipe(this.defaultCatch());
+    }
+    gravarRateioManual(input) {
+        return this.http
+            .post(`${this.baseActions}/gravarRateioManual`, input)
+            .pipe(this.defaultCatch());
+    }
+    defaultCatch() {
+        return catchError((err) => {
+            var _a;
+            if (err) {
+                const summary = (err === null || err === void 0 ? void 0 : err.status) ? String(err.status) : 'Error';
+                const detail = ((_a = err === null || err === void 0 ? void 0 : err.error) === null || _a === void 0 ? void 0 : _a.message) || (err === null || err === void 0 ? void 0 : err.statusText) || (err === null || err === void 0 ? void 0 : err.message) || 'Error';
+                this.messageService.add({ severity: 'error', summary, detail });
+            }
+            return throwError(err);
+        });
+    }
+};
+ErpRateioEditorService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: MessageService }
+];
+ErpRateioEditorService = __decorate([
+    Injectable()
+], ErpRateioEditorService);
+export { ErpRateioEditorService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/rateio-editor/erp-rateio-editor.types.js

@@ -0,0 +1,5 @@
+/**
+ * Tipos do componente erp-rateio-editor.
+ * Espelham os records e enums do SDL erpx_fin_rat/rateio (ERPMAD-17682).
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erp-rateio-editor.types.js","sourceRoot":"ng://@senior-gestao-empresarial/erpx-components/","sources":["components/rateio-editor/erp-rateio-editor.types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * Tipos do componente erp-rateio-editor.\n * Espelham os records e enums do SDL erpx_fin_rat/rateio (ERPMAD-17682).\n */\n\n// === ENUMS ===\n\n/** Espelho de enumTipoMovimento (SDL — PascalCase) */\nexport type TipoMovimento =\n    | 'PedidoProduto'\n    | 'PedidoServico'\n    | 'NotaFiscalSaidaProduto'\n    | 'NotaFiscalSaidaServico'\n    | 'ContratoVendaProduto'\n    | 'ContratoVendaServico'\n    | 'Requisicao'\n    | 'MovimentoEstoque'\n    | 'ContasReceber'\n    | 'SolicitacaoCompra'\n    | 'OrdemCompraProduto'\n    | 'OrdemCompraServico'\n    | 'NotaFiscalEntradaProduto'\n    | 'NotaFiscalEntradaServico'\n    | 'ContasPagar'\n    | 'Comissoes'\n    | 'Tesouraria'\n    | 'PreparacaoTesouraria'\n    | 'ContratoCompraProduto'\n    | 'ContratoCompraServico'\n    | 'NotaFiscalEntrada'\n    | 'NotaFiscalSaida'\n    | 'ContratoCompra'\n    | 'ContratoVenda'\n    | 'Pedidos';\n\n/**\n * Espelho de enumCriRat (SDL).\n * V1 = Receitas — Conta X C. Custos\n * V2 = Receitas — C. Custos X Conta\n * V3 = Despesas — Conta X C. Custos\n * V4 = Despesas — C. Custos X Conta\n * V5 = Nenhum\n */\nexport type CriterioRateio = 'V1' | 'V2' | 'V3' | 'V4' | 'V5';\n\n// === MODELO HIERÁRQUICO (recRateioConta + recRateioCCusto) ===\n\nexport interface RateioConta {\n    id?: string;\n    idContaFinanceira: string;\n    contaFinanceira: string;\n    idContaContabil?: string;\n    contaContabil?: string;\n    idProjeto?: string;\n    projeto?: string;\n    idFaseProjeto?: string;\n    faseProjeto?: string;\n    percentual: number;\n    valorRateadoConta: number;\n    rateiosCCusto: RateioCCusto[];\n}\n\nexport interface RateioCCusto {\n    idCentroCusto: string;\n    descCCusto?: string;\n    percentual: number;\n    valor: number;\n    observacao?: string;\n}\n\n// === RECORDS AUXILIARES ===\n\nexport interface Empresa {\n    id: string;\n    codEmp: number;\n    nomEmp: string;\n}\n\nexport interface Filial {\n    id: string;\n    e070emp: Empresa;\n    codFil: number;\n    nomFil: string;\n}\n\nexport interface InformacaoMovimento {\n    id: string;\n    codigo: string;\n    descricao: string;\n    labelInformacao: string;\n}\n\nexport interface IntegracaoControladoria {\n    contabilidade?: boolean;\n    tributos?: boolean;\n    patrimonio?: boolean;\n}\n\n// === PAYLOADS DE API ===\n\nexport interface RetornarRateioInput {\n    idMovimento: string;\n    tipoMovimento: TipoMovimento;\n}\n\nexport interface RetornarRateioOutput {\n    rateio: RateioConta[];\n    e070fil: Filial;\n    oriRat: string;\n    criRat: CriterioRateio;\n    valorBase: number;\n    dataBase: string;\n    dataMovimento?: string;\n    informacoesMovimento?: InformacaoMovimento[];\n    agrupadorId: string;\n    integracaoControladoria?: IntegracaoControladoria;\n    usuGer: string;\n    dthGer: string;\n}\n\nexport interface GravarRateioManualInput {\n    idMovimento: string;\n    agrupadorId?: string;\n    tipoMovimento: TipoMovimento;\n    e070fil_id: string;\n    criterioRateio: CriterioRateio;\n    dataBase?: string;\n    dataMovimento?: string;\n    rateios: RateioConta[];\n}\n\n/** Modelo plano — usado APENAS pelo output de sugerirRateio */\nexport interface DistribuicaoRateioManualPlana {\n    e091plf_id: string;\n    e044ccu_id?: string;\n    e045pla_id?: string;\n    e615prj_id?: string;\n    e615fpj_id?: string;\n    percentual: number;\n    valor: number;\n}\n\nexport interface SugestaoRateio {\n    idMovimento?: string;\n    rateio: RateioConta[];\n}\n\nexport interface SugerirRateioInput {\n    parametros: SugerirRateioParametro[];\n    tipo: TipoMovimento;\n}\n\nexport interface SugerirRateioParametro {\n    idMovimento?: string;\n    e070fil_id: string;\n    valorBase: number;\n    movimentos?: string;\n    e091plf_id?: string;\n    e045pla_id?: string;\n    e044ccu_id?: string;\n    e615prj_id?: string;\n    e615fpj_id?: string;\n    criRat: CriterioRateio;\n    idTransacao?: string;\n    idFamilia?: string;\n    idDerivacao?: string;\n    idServico?: string;\n    dataBase?: string;\n    dataMovimento?: string;\n    valorExcedente?: number;\n}\n\n// === VALORES SELECIONADOS NOS LOOKUPS (uso transitório para validação) ===\n\n/**\n * Valor selecionado no lookup de conta financeira (E091Plf) com os displayfields\n * usados na validação analítica. Não é persistido em RateioConta.\n */\nexport interface ContaFinanceiraLookup {\n    id: string;\n    label: string;\n    /** 'VS' = sintética; demais valores = analítica. */\n    anaSin?: string;\n}\n\n/**\n * Valor selecionado no lookup de centro de custo (E044Ccu) com os displayfields\n * usados na validação analítica. Não é persistido em RateioCCusto.\n */\nexport interface CentroCustoLookup {\n    id: string;\n    label: string;\n    /** 'VS' = sintético; demais valores = analítico. */\n    anaSin?: string;\n    /** true = aceita rateio; false = não aceita. */\n    aceRat?: boolean;\n}\n\n// === CONFIGURAÇÃO DO COMPONENTE ===\n\nexport interface RateioEditorConfig {\n    /** Casas decimais para valores monetários (default: 2) */\n    currencyScale?: number;\n    /** Casas decimais para percentuais (default: 4) */\n    percentageScale?: number;\n    /** Permitir valores negativos (default: false) */\n    allowNegativeValues?: boolean;\n    /** Máximo de contas financeiras (default: sem limite) */\n    maxAccounts?: number;\n}\n\n// === EVENTOS ===\n\nexport interface RateioSaveEvent {\n    idMovimento: string;\n    tipoMovimento: TipoMovimento;\n    rateios: RateioConta[];\n}\n\nexport interface RateioChangeEvent {\n    isDirty: boolean;\n    isValid: boolean;\n    rateios: RateioConta[];\n}\n\nexport interface RateioErrorEvent {\n    operacao: 'load' | 'save' | 'suggest';\n    message: string;\n    code?: string;\n    originalError?: unknown;\n}\n"]}

package/esm2015/components/rateio-editor/index.js

@@ -0,0 +1,4 @@
+export { ErpRateioEditorModule } from './erp-rateio-editor.module';
+export { ErpRateioEditorComponent } from './erp-rateio-editor.component';
+export { ErpRateioEditorConverter } from './erp-rateio-editor.converter';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1lbXByZXNhcmlhbC9lcnB4LWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJjb21wb25lbnRzL3JhdGVpby1lZGl0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDbkUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUF3QnpFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRXJwUmF0ZWlvRWRpdG9yTW9kdWxlIH0gZnJvbSAnLi9lcnAtcmF0ZWlvLWVkaXRvci5tb2R1bGUnO1xuZXhwb3J0IHsgRXJwUmF0ZWlvRWRpdG9yQ29tcG9uZW50IH0gZnJvbSAnLi9lcnAtcmF0ZWlvLWVkaXRvci5jb21wb25lbnQnO1xuZXhwb3J0IHtcbiAgICBUaXBvTW92aW1lbnRvLFxuICAgIENyaXRlcmlvUmF0ZWlvLFxuICAgIFJhdGVpb0NvbnRhLFxuICAgIFJhdGVpb0NDdXN0byxcbiAgICBDb250YUZpbmFuY2VpcmFMb29rdXAsXG4gICAgQ2VudHJvQ3VzdG9Mb29rdXAsXG4gICAgRW1wcmVzYSxcbiAgICBGaWxpYWwsXG4gICAgSW5mb3JtYWNhb01vdmltZW50byxcbiAgICBJbnRlZ3JhY2FvQ29udHJvbGFkb3JpYSxcbiAgICBSZXRvcm5hclJhdGVpb0lucHV0LFxuICAgIFJldG9ybmFyUmF0ZWlvT3V0cHV0LFxuICAgIEdyYXZhclJhdGVpb01hbnVhbElucHV0LFxuICAgIERpc3RyaWJ1aWNhb1JhdGVpb01hbnVhbFBsYW5hLFxuICAgIFN1Z2VzdGFvUmF0ZWlvLFxuICAgIFN1Z2VyaXJSYXRlaW9JbnB1dCxcbiAgICBTdWdlcmlyUmF0ZWlvUGFyYW1ldHJvLFxuICAgIFJhdGVpb0VkaXRvckNvbmZpZyxcbiAgICBSYXRlaW9TYXZlRXZlbnQsXG4gICAgUmF0ZWlvQ2hhbmdlRXZlbnQsXG4gICAgUmF0ZWlvRXJyb3JFdmVudFxufSBmcm9tICcuL2VycC1yYXRlaW8tZWRpdG9yLnR5cGVzJztcbmV4cG9ydCB7IEVycFJhdGVpb0VkaXRvckNvbnZlcnRlciB9IGZyb20gJy4vZXJwLXJhdGVpby1lZGl0b3IuY29udmVydGVyJztcbiJdfQ==

package/esm2015/components/resumo/erp-resumo.component.js

@@ -0,0 +1,19 @@
+import { __decorate } from "tslib";
+import { Component, Input } from '@angular/core';
+let ErpResumoComponent = class ErpResumoComponent {
+    getProp(obj, path) {
+        return path.split('.').reduce((result, prop) => (result[prop] === undefined ? ' ' : result[prop]), obj);
+    }
+};
+__decorate([
+    Input()
+], ErpResumoComponent.prototype, "summary", void 0);
+ErpResumoComponent = __decorate([
+    Component({
+        selector: 'erp-resumo[summary]',
+        template: "<div *ngFor=\"let section of summary.sections\" class=\"ui-g-12 block\">\n  <div *ngIf=\"section.title\" class=\"ui-g-12 title-item\">\n    {{section?.title}}\n  </div>\n  <div *ngFor=\"let item of section.items\" class=\"ui-g-12 item border-bottom\">\n    <div *ngFor=\"let subItem of item; index as key\">\n      <div class=\"ui-g-6 left\" [ngClass]=\"{'sub': key > 0}\" [innerHTML]=\"getProp(subItem, 'label')\"></div>\n      <div class=\"ui-g-6 right\" [ngClass]=\"{'sub': key > 0}\" [innerHTML]=\"getProp(subItem, 'value')\"></div>\n    </div>\n  </div>\n  <div class=\"ui-g-12 item subtotal\" *ngIf=\"section.subtotal\">\n    <div class=\"ui-g-6 left\" [innerHTML]=\"getProp(section, 'subtotal.label')\"></div>\n    <div class=\"ui-g-6 right\" [innerHTML]=\"getProp(section, 'subtotal.value')\"></div>\n  </div>\n</div>\n<div class=\"ui-g-12 total\" *ngIf=\"summary.total\">\n  <div class=\"ui-g-12 item\">\n    <div class=\"ui-g-6 left\" [innerHTML]=\"getProp(summary, 'total.label')\"></div>\n    <div class=\"ui-g-6 right\" [innerHTML]=\"getProp(summary, 'total.value')\"></div>\n  </div>\n</div>",
+        styles: [".block .title-item{font-weight:700;padding-left:0;padding-bottom:0}.block .border-bottom{border-bottom:1px solid #d8d8d8}.total div{padding-top:0;font-weight:700;color:#8d8d8d}.subtotal{font-weight:700;color:#8d8d8d}.item{padding-left:0;padding-right:0;padding-bottom:0}.item .right{text-align:right!important;padding-right:0}.item .left{padding-left:0}.item .sub{color:#8d8d8d;padding-top:2px}"]
+    })
+], ErpResumoComponent);
+export { ErpResumoComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJwLXJlc3Vtby5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1lbXByZXNhcmlhbC9lcnB4LWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJjb21wb25lbnRzL3Jlc3Vtby9lcnAtcmVzdW1vLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFPakQsSUFBYSxrQkFBa0IsR0FBL0IsTUFBYSxrQkFBa0I7SUFJdEIsT0FBTyxDQUFDLEdBQVEsRUFBRSxJQUFTO1FBQ2hDLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxNQUFXLEVBQUUsSUFBUyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDekgsQ0FBQztDQUVGLENBQUE7QUFOVTtJQUFSLEtBQUssRUFBRTttREFBa0I7QUFGZixrQkFBa0I7SUFMOUIsU0FBUyxDQUFDO1FBQ1QsUUFBUSxFQUFFLHFCQUFxQjtRQUMvQiw2bENBQTBDOztLQUUzQyxDQUFDO0dBQ1csa0JBQWtCLENBUTlCO1NBUlksa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdlcnAtcmVzdW1vW3N1bW1hcnldJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2VycC1yZXN1bW8uY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9lcnAtcmVzdW1vLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgRXJwUmVzdW1vQ29tcG9uZW50IHtcblxuICBASW5wdXQoKSBzdW1tYXJ5OiBTdW1tYXJ5O1xuXG4gIHB1YmxpYyBnZXRQcm9wKG9iajogYW55LCBwYXRoOiBhbnkpIHtcbiAgICByZXR1cm4gcGF0aC5zcGxpdCgnLicpLnJlZHVjZSgocmVzdWx0OiBhbnksIHByb3A6IGFueSkgPT4gKHJlc3VsdFtwcm9wXSA9PT0gdW5kZWZpbmVkID8gJyZuYnNwOycgOiByZXN1bHRbcHJvcF0pLCBvYmopO1xuICB9XG5cbn1cblxuZXhwb3J0IGludGVyZmFjZSBTdW1tYXJ5IHtcbiAgdG90YWw/OiBTdW1tYXJ5SXRlbTtcbiAgc2VjdGlvbnM6IEFycmF5PFN1bW1hcnlTZWN0aW9uSXRlbT47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3VtbWFyeVNlY3Rpb25JdGVtIHtcbiAgdGl0bGU/OiBzdHJpbmc7XG4gIGl0ZW1zOiBBcnJheTxBcnJheTxTdW1tYXJ5SXRlbT4+O1xuICBzdWJ0b3RhbD86IFN1bW1hcnlJdGVtO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFN1bW1hcnlJdGVtIHtcbiAgbGFiZWw/OiBzdHJpbmc7XG4gIHZhbHVlPzogc3RyaW5nIHwgbnVtYmVyO1xufVxuIl19

package/esm2015/components/resumo/erp-resumo.module.js

@@ -0,0 +1,25 @@
+import { __decorate } from "tslib";
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ErpResumoService } from './erp-resumo.service';
+import { ErpResumoComponent } from './erp-resumo.component';
+let ErpResumoModule = class ErpResumoModule {
+};
+ErpResumoModule = __decorate([
+    NgModule({
+        declarations: [
+            ErpResumoComponent
+        ],
+        imports: [
+            CommonModule
+        ],
+        providers: [
+            ErpResumoService
+        ],
+        exports: [
+            ErpResumoComponent
+        ]
+    })
+], ErpResumoModule);
+export { ErpResumoModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJwLXJlc3Vtby5tb2R1bGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1lbXByZXNhcmlhbC9lcnB4LWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJjb21wb25lbnRzL3Jlc3Vtby9lcnAtcmVzdW1vLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFnQjVELElBQWEsZUFBZSxHQUE1QixNQUFhLGVBQWU7Q0FBSSxDQUFBO0FBQW5CLGVBQWU7SUFkM0IsUUFBUSxDQUFDO1FBQ1IsWUFBWSxFQUFFO1lBQ1osa0JBQWtCO1NBQ25CO1FBQ0QsT0FBTyxFQUFFO1lBQ1AsWUFBWTtTQUNiO1FBQ0QsU0FBUyxFQUFFO1lBQ1QsZ0JBQWdCO1NBQ2pCO1FBQ0QsT0FBTyxFQUFFO1lBQ1Asa0JBQWtCO1NBQ25CO0tBQ0YsQ0FBQztHQUNXLGVBQWUsQ0FBSTtTQUFuQixlQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBFcnBSZXN1bW9TZXJ2aWNlIH0gZnJvbSAnLi9lcnAtcmVzdW1vLnNlcnZpY2UnO1xuaW1wb3J0IHsgRXJwUmVzdW1vQ29tcG9uZW50IH0gZnJvbSAnLi9lcnAtcmVzdW1vLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIEVycFJlc3Vtb0NvbXBvbmVudFxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlXG4gIF0sXG4gIHByb3ZpZGVyczogW1xuICAgIEVycFJlc3Vtb1NlcnZpY2VcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIEVycFJlc3Vtb0NvbXBvbmVudFxuICBdXG59KVxuZXhwb3J0IGNsYXNzIEVycFJlc3Vtb01vZHVsZSB7IH1cbiJdfQ==

package/esm2015/components/resumo/erp-resumo.service.js

@@ -0,0 +1,13 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+let ErpResumoService = class ErpResumoService {
+};
+ErpResumoService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ErpResumoService_Factory() { return new ErpResumoService(); }, token: ErpResumoService, providedIn: "root" });
+ErpResumoService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], ErpResumoService);
+export { ErpResumoService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJwLXJlc3Vtby5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvci1nZXN0YW8tZW1wcmVzYXJpYWwvZXJweC1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9yZXN1bW8vZXJwLXJlc3Vtby5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxJQUFhLGdCQUFnQixHQUE3QixNQUFhLGdCQUFnQjtDQUU1QixDQUFBOztBQUZZLGdCQUFnQjtJQUg1QixVQUFVLENBQUM7UUFDVixVQUFVLEVBQUUsTUFBTTtLQUNuQixDQUFDO0dBQ1csZ0JBQWdCLENBRTVCO1NBRlksZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBFcnBSZXN1bW9TZXJ2aWNlIHtcblxufVxuIl19

package/esm2015/components/resumo/index.js

@@ -0,0 +1,2 @@
+export * from './erp-resumo.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1lbXByZXNhcmlhbC9lcnB4LWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJjb21wb25lbnRzL3Jlc3Vtby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lcnAtcmVzdW1vLm1vZHVsZSc7XG5leHBvcnQgeyBTdW1tYXJ5LCBTdW1tYXJ5SXRlbSwgU3VtbWFyeVNlY3Rpb25JdGVtIH0gZnJvbSAnLi9lcnAtcmVzdW1vLmNvbXBvbmVudCc7XG4iXX0=

package/esm2015/components/tributos/calculators/effective-tax-rate-calculator.js

@@ -0,0 +1,53 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import BigNumber from 'bignumber.js';
+import * as i0 from "@angular/core";
+let EffectiveTaxRateCalculator = class EffectiveTaxRateCalculator {
+    /**
+     * Calculates the effective tax rate by applying both the tax rate reduction and the governmental tax rate reduction factors.
+     *
+     * @param params - An object containing the following properties:
+     * @param params.taxRate - The base tax rate as a BigNumber.
+     * @param params.taxRateReduction - The tax rate reduction percentage as a BigNumber.
+     * @param params.governamentalTaxRateReduction - The governmental tax rate reduction percentage as a BigNumber.
+     * @returns The effective tax rate as a BigNumber after applying the reduction factors.
+     */
+    calculateEffectiveTaxRate({ taxRate, taxRateReduction, governamentalTaxRateReduction }) {
+        const taxRateReductionFactor = taxRateReduction.isGreaterThan(0)
+            ? new BigNumber(1).minus(new BigNumber(taxRateReduction).dividedBy(100))
+            : new BigNumber(1);
+        const governamentalTaxRateReductionFactor = governamentalTaxRateReduction.isGreaterThan(0)
+            ? new BigNumber(1).minus(new BigNumber(governamentalTaxRateReduction).dividedBy(100))
+            : new BigNumber(1);
+        return taxRateReductionFactor
+            .multipliedBy(taxRate)
+            .multipliedBy(governamentalTaxRateReductionFactor);
+    }
+    /**
+     * Calculates the effective tax rate by applying a reduction factor to the given tax rate,
+     * excluding any governmental tax rate reductions.
+     *
+     * If the `taxRateReduction` is not a valid number, it defaults to zero.
+     * The reduction factor is computed as (1 - taxRateReduction / 100) if `taxRateReduction` is greater than zero,
+     * otherwise it is 1 (no reduction).
+     *
+     * @param params - An object containing:
+     *   - taxRate: The original tax rate as a BigNumber.
+     *   - taxRateReduction: The tax rate reduction percentage as a BigNumber.
+     * @returns The effective tax rate as a BigNumber after applying the reduction factor.
+     */
+    calculateEffectiveTaxRateWithoutGovernamentalTaxRateReduction({ taxRate, taxRateReduction }) {
+        if (taxRateReduction.isNaN())
+            taxRateReduction = new BigNumber(0);
+        const taxRateReductionFactor = taxRateReduction.isGreaterThan(0)
+            ? new BigNumber(1).minus(new BigNumber(taxRateReduction).dividedBy(100))
+            : new BigNumber(1);
+        return taxRateReductionFactor.multipliedBy(taxRate);
+    }
+};
+EffectiveTaxRateCalculator.ɵprov = i0.ɵɵdefineInjectable({ factory: function EffectiveTaxRateCalculator_Factory() { return new EffectiveTaxRateCalculator(); }, token: EffectiveTaxRateCalculator, providedIn: "root" });
+EffectiveTaxRateCalculator = __decorate([
+    Injectable({ providedIn: 'root' })
+], EffectiveTaxRateCalculator);
+export { EffectiveTaxRateCalculator };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,37 @@
+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.
+     *
+     * @param params - An object containing:
+     *   - taxableBase: The base amount to be taxed as a BigNumber.
+     *   - taxRate: The tax rate to apply as a BigNumber (percentage).
+     * @returns The calculated gross amount as a BigNumber.
+     */
+    calculateGrossAmount({ taxableBase, taxRate }) {
+        const taxAmount = taxableBase.multipliedBy(taxRate).dividedBy(100);
+        return this.taxStore.getArredondamentoAbnt()
+            ? this.taxRoundingService.halfEven(taxAmount)
+            : this.taxRoundingService.halfUp(taxAmount.toNumber());
+    }
+};
+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,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

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

@@ -0,0 +1,87 @@
+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, taxRoundingService, taxStore) {
+        this.effectiveTaxRateCalculator = effectiveTaxRateCalculator;
+        this.taxRoundingService = taxRoundingService;
+        this.taxStore = taxStore;
+    }
+    /**
+     * Calculates the tax amount based on a taxable base and a tax rate.
+     *
+     * @param params - An object containing:
+     *   @param params.taxableBase - The base amount on which the tax is calculated (as a BigNumber).
+     *   @param params.taxRate - The tax rate to apply (as a BigNumber, representing a percentage).
+     * @returns The calculated tax amount as a BigNumber.
+     */
+    calculateTaxAmount({ taxableBase, taxRate }) {
+        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.
+     *
+     * @param params - The parameters for the calculation.
+     * @param params.taxableBase - The base amount on which tax is calculated.
+     * @param params.taxRate - The tax rate as a percentage.
+     * @param params.deferredTaxAmount - The amount of tax that is deferred and should be subtracted from the result.
+     * @returns The calculated tax amount after subtracting the deferred tax.
+     */
+    calculateTaxAmountWithDeferredTax({ taxableBase, taxRate, deferredTaxAmount }) {
+        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,
+     * excluding deferred tax and governamental tax rate reductions.
+     *
+     * This method uses the effective tax rate calculated without considering governamental tax rate reductions,
+     * and applies it to the tax base to determine the final tax amount.
+     *
+     * @param params - The parameters for tax calculation.
+     * @param params.taxBase - The base amount on which the tax is calculated.
+     * @param params.taxRate - The initial tax rate before any reductions.
+     * @param params.taxRateReduction - The reduction applied to the tax rate.
+     * @returns The calculated tax amount as a BigNumber.
+     */
+    calculateTaxAmountWithoutDeferredTaxAndWithoutGovernamentalTaxRate({ taxBase, taxRate, taxRateReduction }) {
+        const effectiveTaxRate = this.effectiveTaxRateCalculator.calculateEffectiveTaxRateWithoutGovernamentalTaxRateReduction({
+            taxRate,
+            taxRateReduction
+        });
+        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: TaxRoundingService },
+    { type: TaxStore }
+];
+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,{"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"]}