@seidor-cloud-produtos/tax-core 0.0.9-beta5 → 0.0.9-beta7

package/{lib/index.ts → dist/index.d.ts}

@@ -1,7 +1,7 @@
 import Block from "./taxReport/Block";
 import * as Decorators from "./taxReport/Decorators";
 import { Register } from "./taxReport/Register";
-import * as ReportGenerator from "./taxReport/ReportGenerator";
+import * as Generation from "./taxReport/ReportGenerator";
 import TaxReport from "./taxReport/TaxReport";
 import ConsoleOutput from "./taxReport/implementations/ConsoleOutput";
 import MemoryPersist from "./taxReport/implementations/MemoryPersist";
@@ -11,19 +11,4 @@ import RegisterEventNotifier from "./taxReport/interfaces/RegisterEventNotifier"
 import RegisterGenerator from "./taxReport/interfaces/RegisterGenerator";
 import RegisterPersist from "./taxReport/interfaces/RegisterPersist";
 import RegisterSubscriber from "./taxReport/interfaces/RegisterSubscriber";
-
-export {
-  Block,
-  Decorators,
-  Register,
-  ReportGenerator,
-  TaxReport,
-  ConsoleOutput,
-  MemoryPersist,
-  TaxRegisterGenerator,
-  OutputWriter,
-  RegisterEventNotifier,
-  RegisterGenerator,
-  RegisterPersist,
-  RegisterSubscriber,
-};
+export { Block, Decorators, Register, Generation, TaxReport, ConsoleOutput, MemoryPersist, TaxRegisterGenerator, OutputWriter, RegisterEventNotifier, RegisterGenerator, RegisterPersist, RegisterSubscriber, };

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaxRegisterGenerator = exports.MemoryPersist = exports.ConsoleOutput = exports.TaxReport = exports.Generation = exports.Register = exports.Decorators = exports.Block = void 0;
+const Block_1 = require("./taxReport/Block");
+exports.Block = Block_1.default;
+const Decorators = require("./taxReport/Decorators");
+exports.Decorators = Decorators;
+const Register_1 = require("./taxReport/Register");
+Object.defineProperty(exports, "Register", { enumerable: true, get: function () { return Register_1.Register; } });
+const Generation = require("./taxReport/ReportGenerator");
+exports.Generation = Generation;
+const TaxReport_1 = require("./taxReport/TaxReport");
+exports.TaxReport = TaxReport_1.default;
+const ConsoleOutput_1 = require("./taxReport/implementations/ConsoleOutput");
+exports.ConsoleOutput = ConsoleOutput_1.default;
+const MemoryPersist_1 = require("./taxReport/implementations/MemoryPersist");
+exports.MemoryPersist = MemoryPersist_1.default;
+const TaxRegisterGenerator_1 = require("./taxReport/implementations/TaxRegisterGenerator");
+exports.TaxRegisterGenerator = TaxRegisterGenerator_1.default;

package/dist/taxReport/Block.d.ts

@@ -0,0 +1,18 @@
+import RegisterPersist from "./interfaces/RegisterPersist";
+import { Register } from "./Register";
+import RegisterSubscriber from "./interfaces/RegisterSubscriber";
+import RegisterEventNotifier, { RegisterEventData } from "./interfaces/RegisterEventNotifier";
+export default abstract class Block implements RegisterEventNotifier, RegisterSubscriber {
+    private readonly _name;
+    private eventEmitter;
+    protected registersPersist: RegisterPersist;
+    protected constructor(name: string, regPersist: RegisterPersist);
+    abstract eventHandler(eventData: RegisterEventData): void;
+    notifyEvent(eventData: RegisterEventData): void;
+    get name(): string;
+    get registers(): Register[];
+    addSubscriber(subscriber: RegisterSubscriber): void;
+    addRegister<T extends Register>(register: T): void;
+    hasContent(): boolean;
+    getRegisterByKey(registerKey: string): Register;
+}

package/dist/taxReport/Block.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const RegisterEventNotifier_1 = require("./interfaces/RegisterEventNotifier");
+class Block {
+    constructor(name, regPersist) {
+        this._name = name;
+        this.eventEmitter = new node_events_1.EventEmitter();
+        this.registersPersist = regPersist;
+    }
+    notifyEvent(eventData) {
+        this.eventEmitter.emit(eventData.event, eventData);
+    }
+    get name() {
+        return this._name;
+    }
+    get registers() {
+        const sortApproach = (a, b) => a.reg.localeCompare(b.reg);
+        return this.registersPersist.all().sort(sortApproach);
+    }
+    addSubscriber(subscriber) {
+        this.eventEmitter.on(RegisterEventNotifier_1.Event.REGISTER_CREATED, function (data) {
+            return subscriber.eventHandler.call(subscriber, data);
+        });
+    }
+    addRegister(register) {
+        this.registersPersist.add(register);
+        this.notifyEvent((0, RegisterEventNotifier_1.newRegisterEventData)(register));
+    }
+    hasContent() {
+        return this.registersPersist.hasRegisters();
+    }
+    getRegisterByKey(registerKey) {
+        return this.registersPersist.getByKey(registerKey);
+    }
+}
+exports.default = Block;

package/dist/taxReport/CounterBlock.d.ts

@@ -0,0 +1,7 @@
+import Block from "./Block";
+import RegisterPersist from "./interfaces/RegisterPersist";
+import { RegisterEventData } from "./interfaces/RegisterEventNotifier";
+export default class CounterBlock extends Block {
+    constructor(regPersist: RegisterPersist, name?: string);
+    eventHandler(eventData: RegisterEventData): void;
+}

package/dist/taxReport/CounterBlock.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Block_1 = require("./Block");
+class CounterBlock extends Block_1.default {
+    constructor(regPersist, name = "9") {
+        super(name, regPersist);
+    }
+    eventHandler(eventData) {
+        // throw new Error("Method not implemented.");
+    }
+}
+exports.default = CounterBlock;

package/dist/taxReport/CounterRegister.d.ts

@@ -0,0 +1,6 @@
+import { Register } from "./Register";
+export default class CounterRegister extends Register {
+    reg_blc: string;
+    qtd_reg_blc: number;
+    constructor(qtd_reg_blc?: number, register?: string);
+}

package/dist/taxReport/CounterRegister.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Register_1 = require("./Register");
+const Decorators_1 = require("./Decorators");
+class CounterRegister extends Register_1.Register {
+    constructor(qtd_reg_blc = 0, register = "9900") {
+        super(register, {});
+        // @ts-ignore
+        this.reg_blc = "";
+        // @ts-ignore
+        this.qtd_reg_blc = 0;
+    }
+}
+exports.default = CounterRegister;
+__decorate([
+    (0, Decorators_1.Key)()
+    // @ts-ignore
+    ,
+    (0, Decorators_1.Alphanumeric)(),
+    __metadata("design:type", String)
+], CounterRegister.prototype, "reg_blc", void 0);
+__decorate([
+    (0, Decorators_1.Numeric)(),
+    __metadata("design:type", Number)
+], CounterRegister.prototype, "qtd_reg_blc", void 0);

package/dist/taxReport/Decorators.d.ts

@@ -0,0 +1,31 @@
+import "reflect-metadata";
+export declare const keyCompositionMetadata: unique symbol;
+export declare const maximumNumericLength = 19;
+export declare const defaultAlphanumericLength = 255;
+export declare enum FieldDataType {
+    alphanumeric = 0,
+    numeric = 1
+}
+export declare enum valueProviderType {
+    property = 0,
+    method = 1
+}
+export interface FieldFormat {
+    required: boolean;
+    dataType: FieldDataType;
+    maximumLength: number;
+    maximumDecimalsLength: number;
+    fillEntireLength: boolean;
+    valueProvider: valueProviderType;
+}
+export declare function Numeric(required?: boolean, fillEntireLength?: boolean, maximumLength?: number): (target: any, propertyKey: string, other?: any) => any;
+export declare function Decimal(required?: boolean, fillEntireLength?: boolean, maximumLength?: number, maximumDecimalsLength?: number): (target: any, propertyKey: string, other?: any) => any;
+export declare function Alphanumeric(required?: boolean, fillEntireLength?: boolean, maximumLength?: number): (target: any, propertyKey: string, other?: any) => any;
+export interface KeyComposition {
+    fields: KeyFieldDefinition[];
+}
+export interface KeyFieldDefinition {
+    fieldName: string;
+    valueProvider: valueProviderType;
+}
+export declare function Key(): (target: any, propertyKey: string, other?: any) => void;

package/dist/taxReport/Decorators.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueProviderType = exports.FieldDataType = exports.defaultAlphanumericLength = exports.maximumNumericLength = exports.keyCompositionMetadata = void 0;
+exports.Numeric = Numeric;
+exports.Decimal = Decimal;
+exports.Alphanumeric = Alphanumeric;
+exports.Key = Key;
+require("reflect-metadata");
+exports.keyCompositionMetadata = Symbol("key");
+exports.maximumNumericLength = 19;
+exports.defaultAlphanumericLength = 255;
+var FieldDataType;
+(function (FieldDataType) {
+    FieldDataType[FieldDataType["alphanumeric"] = 0] = "alphanumeric";
+    FieldDataType[FieldDataType["numeric"] = 1] = "numeric";
+})(FieldDataType || (exports.FieldDataType = FieldDataType = {}));
+var valueProviderType;
+(function (valueProviderType) {
+    valueProviderType[valueProviderType["property"] = 0] = "property";
+    valueProviderType[valueProviderType["method"] = 1] = "method";
+})(valueProviderType || (exports.valueProviderType = valueProviderType = {}));
+function numericField(required, maximumLength, valueProvider, fillEntireLength = false, maximumDecimalsLength = 0) {
+    return {
+        required: required,
+        dataType: FieldDataType.numeric,
+        maximumLength: maximumLength,
+        maximumDecimalsLength: maximumDecimalsLength,
+        fillEntireLength: fillEntireLength,
+        valueProvider: valueProvider,
+    };
+}
+function alphanumericField(required, maximumLength, valueProvider, fillEntireLength = false, maximumDecimalsLength = 0) {
+    return {
+        required: required,
+        dataType: FieldDataType.alphanumeric,
+        maximumLength: maximumLength,
+        maximumDecimalsLength: maximumDecimalsLength,
+        fillEntireLength: fillEntireLength,
+        valueProvider: valueProvider,
+    };
+}
+function Numeric(required = false, fillEntireLength = false, maximumLength = exports.maximumNumericLength) {
+    return function (target, propertyKey, other) {
+        Reflect.defineMetadata(propertyKey, numericField(required, maximumLength, other ? valueProviderType.method : valueProviderType.property, fillEntireLength), target);
+        return other;
+    };
+}
+//export function Numeric(
+//  required: boolean = false,
+//  fillEntireLength: boolean = false,
+//  maximumLength: number = maximumNumericLength,
+//): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other: any) {
+//    Reflect.defineMetadata(
+//      propertyKey,
+//      numericField(
+//        required,
+//        maximumLength,
+//        other ? valueProviderType.method : valueProviderType.property,
+//        fillEntireLength,
+//      ),
+//      target,
+//    );
+//  };
+//}
+function Decimal(required = false, fillEntireLength = false, maximumLength = exports.maximumNumericLength, maximumDecimalsLength = 2) {
+    return function (target, propertyKey, other) {
+        Reflect.defineMetadata(propertyKey, numericField(required, maximumLength, other ? valueProviderType.method : valueProviderType.property, fillEntireLength, maximumDecimalsLength), target);
+        return other;
+    };
+}
+//export function Decimal(
+//  required: boolean = false,
+//  fillEntireLength: boolean = false,
+//  maximumLength: number = maximumNumericLength,
+//  maximumDecimalsLength: number = 2,
+//): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other: any) {
+//    Reflect.defineMetadata(
+//      propertyKey,
+//      numericField(
+//        required,
+//        maximumLength,
+//        other ? valueProviderType.method : valueProviderType.property,
+//        fillEntireLength,
+//        maximumDecimalsLength,
+//      ),
+//      target,
+//    );
+//  };
+//}
+function Alphanumeric(required = false, fillEntireLength = false, maximumLength = exports.defaultAlphanumericLength) {
+    return function (target, propertyKey, other) {
+        Reflect.defineMetadata(propertyKey, alphanumericField(required, maximumLength, other ? valueProviderType.method : valueProviderType.property, fillEntireLength), target);
+        return other;
+    };
+}
+function key() {
+    return {
+        fields: [],
+    };
+}
+function keyFieldDefinition(fieldName, valueProvider) {
+    return {
+        fieldName: fieldName,
+        valueProvider: valueProvider,
+    };
+}
+function Key() {
+    return function (target, propertyKey, other) {
+        let keyComposition;
+        keyComposition = Reflect.getMetadata(exports.keyCompositionMetadata, target);
+        if (!keyComposition) {
+            keyComposition = key();
+        }
+        keyComposition.fields.push(keyFieldDefinition(propertyKey, other ? valueProviderType.method : valueProviderType.property));
+        Reflect.defineMetadata(exports.keyCompositionMetadata, keyComposition, target);
+        return other;
+    };
+}
+//export function Key(): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other?: any): void {
+//    let keyComposition: KeyComposition;
+//    keyComposition = Reflect.getMetadata(keyCompositionMetadata, target);
+//    if (!keyComposition) {
+//      keyComposition = key();
+//    }
+//    keyComposition.fields.push(
+//      keyFieldDefinition(
+//        propertyKey,
+//        other ? valueProviderType.method : valueProviderType.property,
+//      ),
+//    );
+//    Reflect.defineMetadata(keyCompositionMetadata, keyComposition, target);
+//  };
+//}
+//export {Numeric, Decimal, Alphanumeric, Key}

package/dist/taxReport/Register.d.ts

@@ -0,0 +1,11 @@
+import RegisterEventNotifier from "./interfaces/RegisterEventNotifier";
+export declare abstract class Register {
+    [key: string]: any;
+    private _registerNotifier;
+    private readonly _children;
+    reg: string;
+    constructor(registerTag: string, notifier: RegisterEventNotifier | null);
+    protected addChild(child: Register): void;
+    getChildren(): Register[];
+    getKeyValue(): string;
+}

package/dist/taxReport/Register.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Register = void 0;
+const Decorators_1 = require("./Decorators");
+const RegisterEventNotifier_1 = require("./interfaces/RegisterEventNotifier");
+class Register {
+    constructor(registerTag, notifier) {
+        // @ts-ignore
+        this.reg = "";
+        this._children = [];
+        this.reg = registerTag;
+        this._registerNotifier = notifier;
+    }
+    addChild(child) {
+        this._children.push(child);
+        this._registerNotifier.notifyEvent((0, RegisterEventNotifier_1.newRegisterEventData)(child));
+    }
+    getChildren() {
+        return this._children;
+    }
+    getKeyValue() {
+        const keyComposition = Reflect.getMetadata(Decorators_1.keyCompositionMetadata, this);
+        let result = "";
+        for (const keyFieldData of keyComposition.fields) {
+            result = result.concat(this[keyFieldData.fieldName]);
+        }
+        return result;
+    }
+}
+exports.Register = Register;
+__decorate([
+    (0, Decorators_1.Key)(),
+    __metadata("design:type", String)
+], Register.prototype, "reg", void 0);

package/dist/taxReport/ReportGenerator.d.ts

@@ -0,0 +1,43 @@
+import TaxReport from "./TaxReport";
+import Block from "./Block";
+import { Register } from "./Register";
+import TagCounter from "./TagCounter";
+import RegisterGenerator from "./interfaces/RegisterGenerator";
+export interface ReportGenerationOptions {
+    openSuffix: string;
+    closeSuffix: string;
+    openFileRegister: Register;
+    registerGenerator: RegisterGenerator;
+}
+export declare class CloseFile extends Register {
+    qtd_lin: number;
+    constructor();
+}
+export declare class OpenBlock extends Register {
+    constructor(tag: string);
+    ind_mov: number;
+}
+export declare class CloseBlock extends Register {
+    constructor(tag: string);
+    qtd_lin: number;
+}
+export declare class ReportGenerator {
+    protected _options: ReportGenerationOptions;
+    protected _counters: TagCounter;
+    private constructor();
+    static defaultOptions(openFileRegister: Register, registerGenerator: RegisterGenerator): ReportGenerationOptions;
+    static newWithDefaultOptions(openFileRegister: Register): ReportGenerator;
+    static newWithOptions(options: ReportGenerationOptions): ReportGenerator;
+    private beforeGeneration;
+    private generation;
+    private afterGeneration;
+    protected beforeBlockGeneration(block: Block): void;
+    protected blockGeneration(block: Block): void;
+    protected beforeRegisterGeneration(register: Register): void;
+    protected registerGeneration(register: Register): void;
+    protected afterRegisterGeneration(register: Register): void;
+    protected afterBlockGeneration(block: Block): void;
+    private addBlock;
+    private addRegister;
+    generateFile(taxReport: TaxReport): void;
+}

package/dist/taxReport/ReportGenerator.js

@@ -0,0 +1,152 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportGenerator = exports.CloseBlock = exports.OpenBlock = exports.CloseFile = void 0;
+const Register_1 = require("./Register");
+const Decorators_1 = require("./Decorators");
+const TagCounter_1 = require("./TagCounter");
+const CounterBlock_1 = require("./CounterBlock");
+const MemoryPersist_1 = require("./implementations/MemoryPersist");
+const CounterRegister_1 = require("./CounterRegister");
+const TaxRegisterGenerator_1 = require("./implementations/TaxRegisterGenerator");
+const tagCloseFileRegister = "9999";
+const openSuffix = "001";
+const closeSuffix = "990";
+var IndicatorBlockContent;
+(function (IndicatorBlockContent) {
+    IndicatorBlockContent[IndicatorBlockContent["hasContent"] = 0] = "hasContent";
+    IndicatorBlockContent[IndicatorBlockContent["hasNoContent"] = 1] = "hasNoContent";
+})(IndicatorBlockContent || (IndicatorBlockContent = {}));
+class CloseFile extends Register_1.Register {
+    constructor() {
+        super(tagCloseFileRegister, {});
+        // @ts-ignore
+        this.qtd_lin = 0;
+    }
+}
+exports.CloseFile = CloseFile;
+__decorate([
+    (0, Decorators_1.Numeric)(),
+    __metadata("design:type", Number)
+], CloseFile.prototype, "qtd_lin", void 0);
+class OpenBlock extends Register_1.Register {
+    constructor(tag) {
+        super(tag, {});
+        // @ts-ignore
+        this.ind_mov = IndicatorBlockContent.hasNoContent;
+    }
+}
+exports.OpenBlock = OpenBlock;
+__decorate([
+    (0, Decorators_1.Alphanumeric)(1),
+    __metadata("design:type", Number)
+], OpenBlock.prototype, "ind_mov", void 0);
+class CloseBlock extends Register_1.Register {
+    constructor(tag) {
+        super(tag, {});
+        this.qtd_lin = 0;
+    }
+}
+exports.CloseBlock = CloseBlock;
+class ReportGenerator {
+    constructor(options) {
+        this._options = options;
+        this._counters = new TagCounter_1.default();
+    }
+    static defaultOptions(openFileRegister, registerGenerator) {
+        return {
+            openSuffix: openSuffix,
+            closeSuffix: closeSuffix,
+            openFileRegister: openFileRegister,
+            registerGenerator: registerGenerator,
+        };
+    }
+    static newWithDefaultOptions(openFileRegister) {
+        return this.newWithOptions(this.defaultOptions(openFileRegister, TaxRegisterGenerator_1.default.newWithDefaultOptions()));
+    }
+    static newWithOptions(options) {
+        return new ReportGenerator(options);
+    }
+    beforeGeneration(taxReport) {
+        this.addRegister(this._options.openFileRegister);
+    }
+    generation(taxReport) {
+        const blocks = taxReport.Blocks;
+        for (const block of blocks) {
+            this.addBlock(block);
+        }
+    }
+    afterGeneration(taxReport) {
+        const tagCounters = this._counters.getAllTagsCounters();
+        const counterBlock = new CounterBlock_1.default(MemoryPersist_1.default.createInstance());
+        const closeFileRegister = new CloseFile();
+        tagCounters.forEach((amount, tag) => {
+            const counterRegister = new CounterRegister_1.default();
+            counterRegister.reg_blc = tag;
+            counterRegister.qtd_reg_blc = amount;
+            closeFileRegister.qtd_lin += amount;
+            counterBlock.addRegister(counterRegister);
+        });
+        this.addBlock(counterBlock);
+        //This should register all lines of the taxReport
+        // To calculate this, we need to sum:
+        // total lines = registers lines (qtd_reg_blc) +
+        //               lines of counters (tagCounters.size) +
+        //               counters open and close line (2) +
+        //               close file line (1)
+        closeFileRegister.qtd_lin += tagCounters.size + 3;
+        this._options.registerGenerator.generate(closeFileRegister);
+    }
+    beforeBlockGeneration(block) {
+        const openBlock = new OpenBlock(`${block.name}${this._options.openSuffix}`);
+        openBlock.ind_mov = block.hasContent()
+            ? IndicatorBlockContent.hasContent
+            : IndicatorBlockContent.hasNoContent;
+        this.addRegister(openBlock);
+    }
+    blockGeneration(block) {
+        for (const register of block.registers) {
+            this.addRegister(register);
+        }
+    }
+    beforeRegisterGeneration(register) { }
+    registerGeneration(register) {
+        this._options.registerGenerator.generate(register);
+        for (const child of register.getChildren()) {
+            this.addRegister(child);
+        }
+    }
+    afterRegisterGeneration(register) {
+        this._counters.countRegister(register);
+    }
+    afterBlockGeneration(block) {
+        const closeBlock = new CloseBlock(`${block.name}${this._options.closeSuffix}`);
+        closeBlock.qtd_lin = this._counters.getBlockRegistersTotal(block.name) + 1;
+        this.addRegister(closeBlock);
+    }
+    addBlock(block) {
+        this.beforeBlockGeneration(block);
+        this.blockGeneration(block);
+        this.afterBlockGeneration(block);
+    }
+    addRegister(register) {
+        this.beforeRegisterGeneration(register);
+        this.registerGeneration(register);
+        this.afterRegisterGeneration(register);
+    }
+    generateFile(taxReport) {
+        this.beforeGeneration(taxReport);
+        this.generation(taxReport);
+        this.afterGeneration(taxReport);
+        this._options.registerGenerator.save();
+    }
+}
+exports.ReportGenerator = ReportGenerator;

package/dist/taxReport/TagCounter.d.ts

@@ -0,0 +1,8 @@
+import { Register } from "./Register";
+export default class TagCounter {
+    private _blocksCounters;
+    constructor();
+    countRegister(register: Register): void;
+    getBlockRegistersTotal(blockLetter: string): number;
+    getAllTagsCounters(): Map<string, number>;
+}

package/dist/taxReport/TagCounter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TagCounter {
+    constructor() {
+        this._blocksCounters = new Map();
+    }
+    countRegister(register) {
+        const blockLetter = register.reg[0];
+        let counters;
+        counters = !this._blocksCounters.has(blockLetter) ? new Map() : this._blocksCounters.get(blockLetter);
+        !counters.has(register.reg) ? counters.set(register.reg, 1) : counters.set(register.reg, (counters.get(register.reg) + 1));
+        this._blocksCounters.set(blockLetter, counters);
+    }
+    getBlockRegistersTotal(blockLetter) {
+        let blockRegistersTotal = 0;
+        const blocksCounter = this._blocksCounters.get(blockLetter);
+        if (!blocksCounter) {
+            return blockRegistersTotal;
+        }
+        for (const value of blocksCounter.values()) {
+            blockRegistersTotal += value;
+        }
+        return blockRegistersTotal;
+    }
+    getAllTagsCounters() {
+        const all = new Map();
+        const blocksKeys = Array.from(this._blocksCounters.keys()).sort((a, b) => a.localeCompare(b));
+        blocksKeys.forEach((blockKey) => {
+            const block = this._blocksCounters.get(blockKey);
+            const registerKeys = Array.from(block.keys()).sort((a, b) => a.localeCompare(b));
+            registerKeys.forEach((tag) => {
+                all.set(tag, block.get(tag));
+            });
+        });
+        return all;
+    }
+}
+exports.default = TagCounter;

package/dist/taxReport/TaxReport.d.ts

@@ -0,0 +1,8 @@
+import Block from "./Block";
+export default abstract class TaxReport {
+    private readonly _blocks;
+    protected constructor();
+    protected registerBlock(block: Block): TaxReport;
+    protected getBlock(name: string): Block | undefined;
+    get Blocks(): Block[];
+}

package/dist/taxReport/TaxReport.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TaxReport {
+    constructor() {
+        this._blocks = new Map();
+    }
+    registerBlock(block) {
+        this._blocks.set(block.name, block);
+        return this;
+    }
+    getBlock(name) {
+        return this._blocks.get(name);
+    }
+    get Blocks() {
+        return Array.from(this._blocks.values());
+    }
+}
+exports.default = TaxReport;