@projetoacbr/acbrlib-base-node 1.0.0 → 1.0.1

package/dist/src/ACBrBuffer/index.d.ts

@@ -0,0 +1,16 @@
+export declare const TAMANHO_PADRAO = 1024;
+/**
+ * ACBrBuffer é uma classe que representa um buffer
+ * Implementa auto-cleanup com 'using' declaration
+ */
+export default class ACBrBuffer {
+    private bufferSize;
+    private bufferData;
+    private disposed;
+    constructor(size: number);
+    getRefTamanhoBuffer(): any;
+    getBuffer(): Buffer<ArrayBufferLike>;
+    toString(): string;
+    destroy(): void;
+    [Symbol.dispose](): void;
+}

package/dist/src/ACBrBuffer/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAMANHO_PADRAO = void 0;
+const koffi = __importStar(require("koffi"));
+exports.TAMANHO_PADRAO = 1024;
+function deref(pointer, pointerType) {
+    return koffi.decode(pointer, pointerType);
+}
+/**
+ * ACBrBuffer é uma classe que representa um buffer
+ * Implementa auto-cleanup com 'using' declaration
+ */
+class ACBrBuffer {
+    bufferSize;
+    bufferData;
+    disposed = false;
+    constructor(size) {
+        this.bufferSize = koffi.alloc("int", 1);
+        this.bufferData = Buffer.alloc(size);
+        koffi.encode(this.bufferSize, 'int', size);
+    }
+    getRefTamanhoBuffer() {
+        return this.bufferSize;
+    }
+    getBuffer() {
+        return this.bufferData;
+    }
+    toString() {
+        let size = deref(this.bufferSize, 'int');
+        let strBuffer = this.bufferData.toString('utf8', 0, (Math.min(size, this.bufferData.length)));
+        return strBuffer;
+    }
+    destroy() {
+        if (!this.disposed) {
+            koffi.free(this.bufferSize);
+            this.bufferSize = null;
+            this.disposed = true;
+        }
+    }
+    // Implementação do auto-cleanup com 'using' declaration
+    [Symbol.dispose]() {
+        this.destroy();
+    }
+}
+exports.default = ACBrBuffer;

package/dist/src/exception/ACBrLibResultCodes.d.ts

@@ -0,0 +1,19 @@
+export declare enum ACBrLibResultCodes {
+    OK = 0,
+    ErrLibNaoInicializada = -1,
+    ErrLibNaoFinalizada = -2,
+    ErrConfigLer = -3,
+    ErrConfigGravar = -4,
+    ErrArquivoNaoExiste = -5,
+    ErrDiretorioNaoExiste = -6,
+    ErrHttp = -7,
+    ErrParametroInvalido = -8,
+    ErrExecutandoMetodo = -10,
+    ErrCNPJInvalido = -11,
+    ErrCPFInvalido = -12,
+    ErrIndex = -13,
+    ErrGerarXml = -14,
+    ErrNaoDisponivelEmModoConsole = -15,
+    ErrTimeOut = -19,
+    ErrDemoExpirado = -999
+}

package/dist/src/exception/ACBrLibResultCodes.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACBrLibResultCodes = void 0;
+var ACBrLibResultCodes;
+(function (ACBrLibResultCodes) {
+    ACBrLibResultCodes[ACBrLibResultCodes["OK"] = 0] = "OK";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrLibNaoInicializada"] = -1] = "ErrLibNaoInicializada";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrLibNaoFinalizada"] = -2] = "ErrLibNaoFinalizada";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrConfigLer"] = -3] = "ErrConfigLer";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrConfigGravar"] = -4] = "ErrConfigGravar";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrArquivoNaoExiste"] = -5] = "ErrArquivoNaoExiste";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrDiretorioNaoExiste"] = -6] = "ErrDiretorioNaoExiste";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrHttp"] = -7] = "ErrHttp";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrParametroInvalido"] = -8] = "ErrParametroInvalido";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrExecutandoMetodo"] = -10] = "ErrExecutandoMetodo";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrCNPJInvalido"] = -11] = "ErrCNPJInvalido";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrCPFInvalido"] = -12] = "ErrCPFInvalido";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrIndex"] = -13] = "ErrIndex";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrGerarXml"] = -14] = "ErrGerarXml";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrNaoDisponivelEmModoConsole"] = -15] = "ErrNaoDisponivelEmModoConsole";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrTimeOut"] = -19] = "ErrTimeOut";
+    ACBrLibResultCodes[ACBrLibResultCodes["ErrDemoExpirado"] = -999] = "ErrDemoExpirado";
+})(ACBrLibResultCodes || (exports.ACBrLibResultCodes = ACBrLibResultCodes = {}));

package/dist/src/exception/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ACBrLibError  é uma classe de Exception para lançar Exceçoes da ACBr
+ *
+ */
+export default class ACBrLibError extends Error {
+    constructor(msg: string);
+}
+export declare class ACBrLibLibNaoInicializadaError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibLibNaoFinalizadaError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibConfigLerError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibConfigGravarError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibArquivoNaoExisteError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibDiretorioNaoExisteError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibHttpError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibParametroInvalidoError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibExecutandoMetodoError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibNaoDisponivelEmModoConsoleError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibTimeOutError extends ACBrLibError {
+    constructor(msg: string);
+}
+export declare class ACBrLibDemoExpiradoError extends ACBrLibError {
+    constructor(msg: string);
+}

package/dist/src/exception/index.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACBrLibDemoExpiradoError = exports.ACBrLibTimeOutError = exports.ACBrLibNaoDisponivelEmModoConsoleError = exports.ACBrLibExecutandoMetodoError = exports.ACBrLibParametroInvalidoError = exports.ACBrLibHttpError = exports.ACBrLibDiretorioNaoExisteError = exports.ACBrLibArquivoNaoExisteError = exports.ACBrLibConfigGravarError = exports.ACBrLibConfigLerError = exports.ACBrLibLibNaoFinalizadaError = exports.ACBrLibLibNaoInicializadaError = void 0;
+/**
+ * ACBrLibError  é uma classe de Exception para lançar Exceçoes da ACBr
+ *
+ */
+class ACBrLibError extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.default = ACBrLibError;
+class ACBrLibLibNaoInicializadaError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibLibNaoInicializadaError = ACBrLibLibNaoInicializadaError;
+class ACBrLibLibNaoFinalizadaError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibLibNaoFinalizadaError = ACBrLibLibNaoFinalizadaError;
+class ACBrLibConfigLerError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibConfigLerError = ACBrLibConfigLerError;
+class ACBrLibConfigGravarError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibConfigGravarError = ACBrLibConfigGravarError;
+class ACBrLibArquivoNaoExisteError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibArquivoNaoExisteError = ACBrLibArquivoNaoExisteError;
+class ACBrLibDiretorioNaoExisteError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibDiretorioNaoExisteError = ACBrLibDiretorioNaoExisteError;
+class ACBrLibHttpError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibHttpError = ACBrLibHttpError;
+class ACBrLibParametroInvalidoError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibParametroInvalidoError = ACBrLibParametroInvalidoError;
+class ACBrLibExecutandoMetodoError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibExecutandoMetodoError = ACBrLibExecutandoMetodoError;
+class ACBrLibNaoDisponivelEmModoConsoleError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibNaoDisponivelEmModoConsoleError = ACBrLibNaoDisponivelEmModoConsoleError;
+class ACBrLibTimeOutError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibTimeOutError = ACBrLibTimeOutError;
+class ACBrLibDemoExpiradoError extends ACBrLibError {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.ACBrLibDemoExpiradoError = ACBrLibDemoExpiradoError;

package/dist/src/index.d.ts

@@ -0,0 +1,136 @@
+import ACBrBuffer from './ACBrBuffer';
+/**
+ * ACBrLibBaseMT é uma  classe de alto nível que implementa os métodos da ACBrLibComum Multi-Thread
+ * Implementa Disposable para auto-cleanup do handle
+ */
+export default abstract class ACBrLibBaseMT {
+    #private;
+    private handle;
+    private isHandleInitialized;
+    private acbrlib;
+    private arquivoConfig;
+    private chaveCrypt;
+    private disposed;
+    constructor(acbrlib: any, arquivoConfig: string, chaveCrypt: string);
+    getAcbrlib(): any;
+    getHandle(): any;
+    /**
+     * Libera recursos alocados
+     */
+    destroy(): void;
+    /**
+     * Implementação do Disposable interface para using declaration
+     */
+    [Symbol.dispose](): void;
+    /**
+     * Implementação do AsyncDisposable interface para using await
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+       * @description Método usado para inicializar o componente para uso da biblioteca
+     */
+    inicializar(): number;
+    /**
+       * @description Método usado para inicializar o componente para uso da biblioteca
+       * @param arquivoConfig Localização do arquivo INI, pode ser em branco neste caso o ACBrLib vai criar um novo arquivo INI.
+       * @param chaveCrypt Chave de segurança para criptografar as informações confidencias, pode ser em branco neste caso será usado a senha padrão.
+       * @returns 0 se sucesso ou o código de erro
+  */
+    inicializar(arquivoConfig: string, chaveCrypt: string): number;
+    /**
+     * Método usado para remover ACBrLib  e suas classes da memoria
+     * @returns 0 ou código de erro
+     */
+    finalizar(): number;
+    /**
+     * @description Método que retornar o nome da biblioteca.
+     * @returns Uma string com o nome da biblioteca
+     */
+    nome(): string;
+    /**
+     * @description Método que retornar a versão da biblioteca.
+     * @returns  Uma string com o versão da biblioteca
+     */
+    versao(): string;
+    /**
+     * @description Método usado retornar o ultimo retorno processado pela biblioteca
+     * @returns Retorna uma string com o último retorno processado pela biblioteca.
+     */
+    ultimoRetorno(): string;
+    configLer(): number;
+    configLer(arquivoConfig: string): number;
+    /**
+     * @description Método usado para gravar a configuração da biblioteca no arquivo INI informado.
+     * @param arquivoConfig Arquivo INI para ler, se informado vazio será usado o valor padrão.
+     * @returns 0 ou código de erro
+     */
+    /**
+    * @description Método usado para gravar a configuração da biblioteca no arquivo INI informado.
+    */
+    configGravar(): number;
+    /**
+   * @description Método usado para gravar a configuração da biblioteca no arquivo INI informado.
+   * @param arquivoConfig Arquivo INI para ler, se informado vazio será usado o valor padrão.
+   * @returns 0 ou código de erro
+   */
+    configGravar(arquivoConfig: string): number;
+    /**
+     * @description Método usado para ler uma determinado item da configuração.
+     * @param sessao Nome da sessão de configuração.
+     * @param chave Nome da chave da sessão.
+     * @returns 0 ou código de erro
+     */
+    configLerValor(sessao: string, chave: string): string;
+    /**
+     * @description Método usado para gravar um determinado item  da configuração.
+     * @param sessao Nome da sessão de configuração.
+     * @param chave Nome da chave da sessão.
+     * @param valor  Valor para ser gravado na configuração
+     * @returns 0 ou código de erro
+     */
+    configGravarValor(sessao: string, chave: string, valor: string): number;
+    /**
+     * @description Método usado para exportar a configuração da biblioteca do arquivo INI informado.
+     * @returns Uma string com a configuração exportada.
+     */
+    configExportar(): string;
+    /**
+     *
+     * @description Método usado para importar a configuração da biblioteca do arquivo INI informado
+     * @param arquivoConfig  Arquivo INI para ler, se informado vazio será usado o valor padrão.
+     * @returns 0 ou código de erro
+     */
+    configImportar(arquivoConfig: string): number;
+    /**
+      * @description Método que retorna informações da biblioteca OpenSsl
+      * @returns
+      */
+    openSslInfo(): string;
+    _isRequiredReallocBuffer(requiredLen: number): boolean;
+    _processaResult(buffer: ACBrBuffer): string;
+    /**
+     * Verifica se o resultado é um código de erro
+     * @param result
+     * @returns
+     */
+    _isResultErrorCode(result: number): boolean;
+    /**
+     * Checa o resultado da operação e propaga a exceção se result < 0
+     * @param result
+     */
+    _checkResult(result: number): void;
+    _ultimoRetorno(size: number): string;
+    /** Metodos que devem ser implementados em classes filhas */
+    protected abstract LIB_Inicializar(handle: any, configPath: string, chaveCrypt: string): number;
+    protected abstract LIB_Finalizar(handle: any): number;
+    protected abstract LIB_UltimoRetorno(handle: any, mensagem: Buffer, refTamanho: any): number;
+    protected abstract LIB_Nome(handle: any, nome: Buffer, refTamanho: any): number;
+    protected abstract LIB_Versao(handle: any, versao: Buffer, refTamanho: any): number;
+    protected abstract LIB_ConfigLer(handle: any, arqConfig: string): number;
+    protected abstract LIB_ConfigGravar(handle: any, arqConfig: string): number;
+    protected abstract LIB_ConfigLerValor(handle: any, sessao: string, chave: string, valor: Buffer, refTamanho: any): number;
+    protected abstract LIB_ConfigGravarValor(handle: any, sessao: string, chave: string, valor: string): number;
+    protected abstract LIB_ConfigImportar(handle: any, arqConfig: string): number;
+    protected abstract LIB_ConfigExportar(handle: any, configuracoes: Buffer, refTamanho: any): number;
+    protected abstract LIB_OpenSSLInfo(handle: any, configuracoes: Buffer, refTamanho: any): number;
+}

package/dist/src/index.js

@@ -0,0 +1,470 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ACBrBuffer_1 = require("./ACBrBuffer");
+const ACBrBuffer_2 = __importDefault(require("./ACBrBuffer"));
+const exception_1 = require("./exception");
+const ACBrLibResultCodes_1 = require("./exception/ACBrLibResultCodes");
+const koffi = __importStar(require("koffi"));
+/**
+ * ACBrLibBaseMT é uma  classe de alto nível que implementa os métodos da ACBrLibComum Multi-Thread
+ * Implementa Disposable para auto-cleanup do handle
+ */
+class ACBrLibBaseMT {
+    handle; // ponteiro para ponteiro (void **)
+    isHandleInitialized = false;
+    acbrlib;
+    arquivoConfig;
+    chaveCrypt;
+    disposed = false;
+    constructor(acbrlib, arquivoConfig, chaveCrypt) {
+        this.arquivoConfig = arquivoConfig;
+        this.chaveCrypt = chaveCrypt;
+        this.acbrlib = acbrlib;
+        this.handle = null;
+    }
+    getAcbrlib() {
+        return this.acbrlib;
+    }
+    getHandle() {
+        return koffi.decode(this.handle, 'void *');
+    }
+    #isInitialized() {
+        // diferente do ref-napi que tem o metodo isNull() koffi até a presente versão não tem
+        // sendo impossivel saber se o handle é null (do lado nodejs) ou não, usamos o isHandleInitialized
+        // para saber se a biblioteca foi inicializada
+        // sem esse controle, é possivel liberar a memoria mais de uma vez e corromper o heap.
+        return this.isHandleInitialized;
+    }
+    /**
+     * Libera recursos alocados
+     */
+    destroy() {
+        if (!this.disposed) {
+            try {
+                // Finaliza a biblioteca se estiver inicializada
+                if (this.#isInitialized()) {
+                    this.finalizar();
+                }
+                this.disposed = true;
+            }
+            catch (error) {
+                console.error('Erro ao liberar recursos:', error);
+            }
+        }
+    }
+    /**
+     * Implementação do Disposable interface para using declaration
+     */
+    [Symbol.dispose]() {
+        this.destroy();
+    }
+    /**
+     * Implementação do AsyncDisposable interface para using await
+     */
+    async [Symbol.asyncDispose]() {
+        this.destroy();
+    }
+    inicializar(arquivoConfig, chaveCrypt) {
+        //let status = this.LIB_Inicializar(this.handle, arquivoConfig, chaveCrypt)
+        if (typeof arquivoConfig === "undefined" && typeof chaveCrypt === "undefined") {
+            return this.#inicializar(this.arquivoConfig, this.chaveCrypt);
+        }
+        else {
+            if (typeof arquivoConfig === "string" && typeof chaveCrypt === "string") {
+                return this.#inicializar(arquivoConfig, chaveCrypt);
+            }
+            throw new Error("inicializar precisa de dois parâmetros: chaveCrypt e arquivoConfig");
+        }
+    }
+    // metodo auxiliar para destruir o ponteiro do handle
+    #releaseHandle() {
+        if (!this.handle) {
+            return;
+        }
+        koffi.encode(this.getHandle(), 'void *', null);
+        koffi.free(this.handle);
+        this.handle = null;
+    }
+    /**
+     * Método usado para remover ACBrLib  e suas classes da memoria
+     * @returns 0 ou código de erro
+     */
+    finalizar() {
+        if (!this.#isInitialized()) {
+            return 0;
+        }
+        let status = this.LIB_Finalizar(this.getHandle());
+        if (status == ACBrLibResultCodes_1.ACBrLibResultCodes.OK) {
+            this.#releaseHandle();
+            this.isHandleInitialized = false;
+        }
+        this._checkResult(status);
+        return status;
+    }
+    /**
+     * @description Método que retornar o nome da biblioteca.
+     * @returns Uma string com o nome da biblioteca
+     */
+    nome() {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_1, new ACBrBuffer_2.default(ACBrBuffer_1.TAMANHO_PADRAO), false);
+            let status = this.LIB_Nome(this.getHandle(), acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            this._checkResult(status);
+            return this._processaResult(acbrBuffer);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    /**
+     * @description Método que retornar a versão da biblioteca.
+     * @returns  Uma string com o versão da biblioteca
+     */
+    versao() {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_2, new ACBrBuffer_2.default(ACBrBuffer_1.TAMANHO_PADRAO), false);
+            let status = this.LIB_Versao(this.getHandle(), acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            this._checkResult(status);
+            return this._processaResult(acbrBuffer);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    /**
+     * @description Método usado retornar o ultimo retorno processado pela biblioteca
+     * @returns Retorna uma string com o último retorno processado pela biblioteca.
+     */
+    ultimoRetorno() {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_3, new ACBrBuffer_2.default(ACBrBuffer_1.TAMANHO_PADRAO), false);
+            this.LIB_UltimoRetorno(this.getHandle(), acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            return this._processaResult(acbrBuffer);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    /**
+     * @description Método usado para ler a configuração da biblioteca do arquivo INI informado.
+     * @param arquivoConfig Arquivo INI para ler, se informado vazio será usado o valor padrão.
+     * @returns 0 ou código de erro
+     */
+    configLer(arquivoConfig) {
+        if (typeof arquivoConfig === "undefined") {
+            return this.#configLer(this.arquivoConfig);
+        }
+        return this.#configLer(arquivoConfig);
+    }
+    configGravar(arquivoConfig) {
+        if (typeof arquivoConfig === "undefined") {
+            return this.#configGravar(this.arquivoConfig);
+        }
+        return this.#configGravar(arquivoConfig);
+    }
+    /**
+     * @description Método usado para ler uma determinado item da configuração.
+     * @param sessao Nome da sessão de configuração.
+     * @param chave Nome da chave da sessão.
+     * @returns 0 ou código de erro
+     */
+    configLerValor(sessao, chave) {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_4, new ACBrBuffer_2.default(ACBrBuffer_1.TAMANHO_PADRAO), false);
+            let status = this.LIB_ConfigLerValor(this.getHandle(), sessao, chave, acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            this._checkResult(status);
+            return this._processaResult(acbrBuffer);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    }
+    /**
+     * @description Método usado para gravar um determinado item  da configuração.
+     * @param sessao Nome da sessão de configuração.
+     * @param chave Nome da chave da sessão.
+     * @param valor  Valor para ser gravado na configuração
+     * @returns 0 ou código de erro
+     */
+    configGravarValor(sessao, chave, valor) {
+        let status = this.LIB_ConfigGravarValor(this.getHandle(), sessao, chave, valor);
+        this._checkResult(status);
+        return status;
+    }
+    /**
+     * @description Método usado para exportar a configuração da biblioteca do arquivo INI informado.
+     * @returns Uma string com a configuração exportada.
+     */
+    configExportar() {
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_5, new ACBrBuffer_2.default(ACBrBuffer_1.TAMANHO_PADRAO), false);
+            let status = this.LIB_ConfigExportar(this.getHandle(), acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            this._checkResult(status);
+            return this._processaResult(acbrBuffer);
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    }
+    /**
+     *
+     * @description Método usado para importar a configuração da biblioteca do arquivo INI informado
+     * @param arquivoConfig  Arquivo INI para ler, se informado vazio será usado o valor padrão.
+     * @returns 0 ou código de erro
+     */
+    configImportar(arquivoConfig) {
+        let status = this.LIB_ConfigImportar(this.getHandle(), arquivoConfig);
+        this._checkResult(status);
+        return status;
+    }
+    /**
+      * @description Método que retorna informações da biblioteca OpenSsl
+      * @returns
+      */
+    openSslInfo() {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_6, new ACBrBuffer_2.default(ACBrBuffer_1.TAMANHO_PADRAO), false);
+            let status = this.LIB_OpenSSLInfo(this.getHandle(), acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            this._checkResult(status);
+            return this._processaResult(acbrBuffer);
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    }
+    /* Métodos protegidos */
+    _isRequiredReallocBuffer(requiredLen) {
+        return requiredLen > ACBrBuffer_1.TAMANHO_PADRAO;
+    }
+    _processaResult(buffer) {
+        let requiredLen = koffi.decode(buffer.getRefTamanhoBuffer(), 'int');
+        if (this._isRequiredReallocBuffer(requiredLen)) {
+            requiredLen = Math.round(requiredLen * 1.3);
+            return this._ultimoRetorno(requiredLen);
+        }
+        return buffer.toString();
+    }
+    /**
+     * Verifica se o resultado é um código de erro
+     * @param result
+     * @returns
+     */
+    _isResultErrorCode(result) {
+        return result < ACBrLibResultCodes_1.ACBrLibResultCodes.OK;
+    }
+    /**
+     * Checa o resultado da operação e propaga a exceção se result < 0
+     * @param result
+     */
+    _checkResult(result) {
+        // se o resultado é maior ou igual a OK, não há erro
+        if (!this._isResultErrorCode(result)) {
+            return;
+        }
+        let errorMessage = this.ultimoRetorno();
+        console.log("Checking result: ", result, " Error message: ", errorMessage);
+        switch (result) {
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrLibNaoInicializada:
+                throw new exception_1.ACBrLibLibNaoInicializadaError("Erro ao inicializar " + this.nome);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrLibNaoFinalizada:
+                throw new exception_1.ACBrLibLibNaoFinalizadaError("Erro ao finalizar a biblioteca");
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrConfigLer:
+                throw new exception_1.ACBrLibConfigLerError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrConfigGravar:
+                throw new exception_1.ACBrLibConfigGravarError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrArquivoNaoExiste:
+                throw new exception_1.ACBrLibArquivoNaoExisteError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrDiretorioNaoExiste:
+                throw new exception_1.ACBrLibDiretorioNaoExisteError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrHttp:
+                throw new exception_1.ACBrLibHttpError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrTimeOut:
+                throw new exception_1.ACBrLibTimeOutError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrDemoExpirado:
+                throw new exception_1.ACBrLibDemoExpiradoError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrNaoDisponivelEmModoConsole:
+                throw new exception_1.ACBrLibNaoDisponivelEmModoConsoleError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrParametroInvalido:
+                throw new exception_1.ACBrLibParametroInvalidoError(errorMessage);
+                break;
+            case ACBrLibResultCodes_1.ACBrLibResultCodes.ErrExecutandoMetodo:
+                throw new exception_1.ACBrLibParametroInvalidoError(errorMessage);
+                break;
+            default:
+                // se a exceção não é uma exceção comum a todas as bibliotecas, exibe a mensagem de erro
+                // as classes filhas devem implementar as exceções específicas
+                console.error("O código de erro ", result, " Mensagem: ", errorMessage);
+                break;
+        }
+    }
+    _ultimoRetorno(size) {
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            const acbrBuffer = __addDisposableResource(env_7, new ACBrBuffer_2.default(size), false);
+            this.LIB_UltimoRetorno(this.getHandle(), acbrBuffer.getBuffer(), acbrBuffer.getRefTamanhoBuffer());
+            return acbrBuffer.toString();
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            __disposeResources(env_7);
+        }
+    }
+    #configGravar(arquivoConfig) {
+        let status = this.LIB_ConfigGravar(this.getHandle(), arquivoConfig);
+        this._checkResult(status);
+        return status;
+    }
+    #configLer(arquivoConfig) {
+        let status = this.LIB_ConfigLer(this.getHandle(), arquivoConfig);
+        this._checkResult(status);
+        return status;
+    }
+    #inicializar(arquivoConfig, chaveCrypt) {
+        if (this.handle == null) {
+            this.handle = koffi.alloc('void *', 1);
+        }
+        let status = this.LIB_Inicializar(this.handle, arquivoConfig, chaveCrypt);
+        if (status === ACBrLibResultCodes_1.ACBrLibResultCodes.OK) {
+            this.isHandleInitialized = true;
+        }
+        else {
+            // por segurança, se a inicialização falhar, libera o handle
+            this.#releaseHandle();
+            this.isHandleInitialized = false;
+        }
+        this._checkResult(status);
+        return status;
+    }
+}
+exports.default = ACBrLibBaseMT;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projetoacbr/acbrlib-base-node",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -14,14 +14,14 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/doszapro/acbrlib-comum.git"
+    "url": "git+https://github.com/Projeto-ACBr-Oficial/ACBrLib-Nodejs.git"
   },
   "author": "",
   "license": "ISC",
   "bugs": {
-    "url": "https://github.com/doszapro/acbrlib-comum/issues"
+    "url": "https://github.com/Projeto-ACBr-Oficial/ACBrLib-Nodejs/issues"
   },
-  "homepage": "https://github.com/doszapro/acbrlib-comum#readme",
+  "homepage": "https://github.com/Projeto-ACBr-Oficial/ACBrLib-Nodejs#readme",
   "devDependencies": {
     "@types/node": "^22.5.4",
     "typescript": "^5.5.4"