devtoolz-library 1.0.0

package/dist/converters/numeric-systems/services/roman/roman.converter.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const numericSystem_converter_factory_1 = require("../../numericSystem.converter.factory");
+describe("Sistema Numérico Romano", () => {
+    let converter;
+    let factory;
+    beforeEach(() => {
+        factory = new numericSystem_converter_factory_1.NumericSystemConverterFactory();
+        converter = factory.createService('roman');
+    });
+    describe("fromDecimal", () => {
+        it("2025", () => {
+            const decimalValue = 2025;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("MMXXV");
+        });
+        it("1999", () => {
+            const decimalValue = 1999;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("MCMXCIX");
+        });
+        it("1992", () => {
+            const decimalValue = 1992;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("MCMXCII");
+        });
+        it("1843", () => {
+            const decimalValue = 1843;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("MDCCCXLIII");
+        });
+        it("5", () => {
+            const decimalValue = 5;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("V");
+        });
+        it("6", () => {
+            const decimalValue = 6;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("VI");
+        });
+        it("1", () => {
+            const decimalValue = 1;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("I");
+        });
+        it("3", () => {
+            const decimalValue = 3;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("III");
+        });
+        it("4", () => {
+            const decimalValue = 4;
+            const romamValue = converter.fromDecimal(decimalValue);
+            expect(romamValue).toBe("IV");
+        });
+    });
+    describe("toDecimal", () => {
+        it("MMXXV", () => {
+            const romanValue = "MMXXV";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(2025);
+        });
+        it("MCMXCIX", () => {
+            const romanValue = "MCMXCIX";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(1999);
+        });
+        it("MCMXCII", () => {
+            const romanValue = "MCMXCII";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(1992);
+        });
+        it("MDCCCXLIII", () => {
+            const romanValue = "MDCCCXLIII";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(1843);
+        });
+        it("VI", () => {
+            const romanValue = "VI";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(6);
+        });
+        it("V", () => {
+            const romanValue = "V";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(5);
+        });
+        it("IV", () => {
+            const romanValue = "IV";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(4);
+        });
+        it("III", () => {
+            const romanValue = "III";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(3);
+        });
+        it("I", () => {
+            const romanValue = "I";
+            const decimalValue = converter.toDecimal(romanValue);
+            expect(decimalValue).toBe(1);
+        });
+    });
+});

package/dist/converters/serialization/interfaces/ISerialization.converter.d.ts

@@ -0,0 +1,5 @@
+import { ISerializationOption } from "./ISerializationOptions";
+export interface ISerializationConverter {
+    toJson(content: string, options?: ISerializationOption): string;
+    fromJson(content: string, options?: ISerializationOption): string;
+}

package/dist/converters/serialization/interfaces/ISerialization.converter.factory.d.ts

@@ -0,0 +1,4 @@
+import { IFactory } from "../../../interfaces/IFactory";
+import { ISerializationConverter } from "./ISerialization.converter";
+export interface ISerializationConverterFactory extends IFactory<ISerializationConverter> {
+}

package/dist/converters/serialization/interfaces/ISerialization.converter.factory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/converters/serialization/interfaces/ISerialization.converter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/converters/serialization/interfaces/ISerializationOptions.d.ts

@@ -0,0 +1,4 @@
+export interface ISerializationOption {
+    separatorCharacter: string;
+    considerEmptyAsNull: boolean;
+}

package/dist/converters/serialization/interfaces/ISerializationOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/converters/serialization/provider.d.ts

@@ -0,0 +1,2 @@
+import { IServiceCategory } from "../../interfaces/IServiceCategory";
+export declare const serializations: IServiceCategory[];

package/dist/converters/serialization/provider.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializations = void 0;
+exports.serializations = [
+    { id: 'csv' },
+    { id: 'json' },
+];

package/dist/converters/serialization/serialization.converter.d.ts

@@ -0,0 +1,6 @@
+import { ISerializationOption } from "./interfaces/ISerializationOptions";
+export declare class SerializationConverter {
+    private readonly factory;
+    constructor();
+    convert(content: string, from: string, to: string, options?: ISerializationOption): string;
+}

package/dist/converters/serialization/serialization.converter.factory.d.ts

@@ -0,0 +1,9 @@
+import { BaseFactory } from "../../baseFactory";
+import { IServiceCategory } from "../../interfaces/IServiceCategory";
+import { ISerializationConverter } from "./interfaces/ISerialization.converter";
+import { ISerializationConverterFactory } from "./interfaces/ISerialization.converter.factory";
+export declare class SerializationConverterFactory extends BaseFactory<ISerializationConverter> implements ISerializationConverterFactory {
+    constructor();
+    protected throwServiceNotFoundError(serviceId: string): never;
+    protected registerService(service: IServiceCategory): void;
+}

package/dist/converters/serialization/serialization.converter.factory.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializationConverterFactory = void 0;
+const baseFactory_1 = require("../../baseFactory");
+const provider_1 = require("./provider");
+class SerializationConverterFactory extends baseFactory_1.BaseFactory {
+    constructor() {
+        super(provider_1.serializations);
+    }
+    throwServiceNotFoundError(serviceId) {
+        throw new Error(`O conversor solicitado não está implementado: ${serviceId}`);
+    }
+    registerService(service) {
+        const module = require("./services/" + service.id + "/" + service.id + ".converter");
+        // Atribui o construtor: preferencialmente `default`, ou a primeira propriedade exportada
+        const implementation = module.default || Object.values(module)[0];
+        this.map.set(service.id, new implementation());
+    }
+}
+exports.SerializationConverterFactory = SerializationConverterFactory;

package/dist/converters/serialization/serialization.converter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializationConverter = void 0;
+const serialization_converter_factory_1 = require("./serialization.converter.factory");
+class SerializationConverter {
+    constructor() {
+        this.factory = new serialization_converter_factory_1.SerializationConverterFactory();
+    }
+    convert(content, from, to, options) {
+        const source = this.factory.createService(from);
+        const target = this.factory.createService(to);
+        const json = source.toJson(content, options);
+        const result = target.fromJson(json, options);
+        return result;
+    }
+}
+exports.SerializationConverter = SerializationConverter;

package/dist/converters/serialization/services/csv/csv.converter.d.ts

@@ -0,0 +1,6 @@
+import { ISerializationConverter } from "../../interfaces/ISerialization.converter";
+import { ISerializationOption } from "../../interfaces/ISerializationOptions";
+export declare class CsvConverter implements ISerializationConverter {
+    toJson(content: string, options?: ISerializationOption): string;
+    fromJson(content: string, options?: ISerializationOption): string;
+}

package/dist/converters/serialization/services/csv/csv.converter.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvConverter = void 0;
+class CsvConverter {
+    toJson(content, options) {
+        const separator = options?.separatorCharacter ?? ',';
+        const lines = content.split('\n');
+        const headers = lines[0].split(separator);
+        let jsonContent = [];
+        lines.slice(1).map((line, index) => {
+            const data = line.replaceAll(" ", "_").split(separator);
+            const item = {};
+            if (headers.length < data.length)
+                throw new Error(`A linha ${index + 1} está com mais colunas do que a quantidade de cabeçalho`);
+            if (headers.length > data.length)
+                throw new Error(`A linha ${index + 1} está com menos colunas do que a quantidade de cabeçalho`);
+            data.map(((value, index) => {
+                const header = headers[index];
+                const info = value.replaceAll("\"", "").replaceAll("\r", "");
+                if (options?.considerEmptyAsNull ?? false)
+                    item[header] = null;
+                else
+                    item[header] = info;
+            }));
+            jsonContent.push(item);
+        });
+        const json = JSON.stringify(jsonContent, null, 2);
+        return json;
+    }
+    fromJson(content, options) {
+        if (content === "")
+            throw new Error('O conteúdo JSON não pode ser convertido para CSV válido.');
+        const json = JSON.parse(content);
+        if (!Array.isArray(json)) {
+            throw new Error("O conteúdo JSON deve ser um array.");
+        }
+        if (json.length === 0)
+            throw new Error('Não há conteúdo no JSON fornecido.');
+        const headers = Object.keys(json[0]);
+        if (headers.length === 0)
+            throw new Error('Não há conteúdo no JSON fornecido.');
+        const separator = options?.separatorCharacter ?? ',';
+        const csvLines = json.map(item => {
+            return headers.map(header => {
+                const value = item[header];
+                if (value === null || value === undefined)
+                    return '';
+                return value.toString().replace(/,/g, ''); // Remover vírgulas para evitar problemas no CSV
+            }).join(separator);
+        });
+        csvLines.unshift(headers.join(separator)); // Adicionar cabeçalho
+        const csvContent = csvLines.join('\n');
+        // Tratar o caso de conteúdo vazio
+        if (csvContent.trim() === '') {
+            return '';
+        }
+        // Verificar se o conteúdo CSV é válido
+        const isValidCsv = csvContent.split('\n').every(line => {
+            return line.split(separator).length === headers.length;
+        });
+        if (!isValidCsv) {
+            throw new Error("O conteúdo JSON não pode ser convertido para CSV válido.");
+        }
+        // Retornar o conteúdo CSV
+        return csvContent;
+    }
+}
+exports.CsvConverter = CsvConverter;

package/dist/converters/serialization/services/csv/csv.converter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/converters/serialization/services/csv/csv.converter.test.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serialization_converter_factory_1 = require("../../serialization.converter.factory");
+describe('CsvConverter', () => {
+    let csvConverter;
+    let factory;
+    beforeEach(() => {
+        factory = new serialization_converter_factory_1.SerializationConverterFactory();
+        csvConverter = factory.createService('csv');
+    });
+    describe('toJson', () => {
+        describe('comportamento padrão (sem opções)', () => {
+            it('deve converter CSV simples para JSON formatado', () => {
+                const csvContent = 'nome,idade,cidade\nJoão,30,São Paulo\nMaria,25,Rio de Janeiro';
+                const expectedJson = JSON.stringify([
+                    { nome: 'João', idade: '30', cidade: 'São_Paulo' },
+                    { nome: 'Maria', idade: '25', cidade: 'Rio_de_Janeiro' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve converter CSV com uma única linha de dados', () => {
+                const csvContent = 'nome,idade\nJoão,30';
+                const expectedJson = JSON.stringify([
+                    { nome: 'João', idade: '30' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve substituir espaços por underscore nos valores', () => {
+                const csvContent = 'nome,descricao\nJoão Silva,Analista de Sistemas';
+                const expectedJson = JSON.stringify([
+                    { nome: 'João_Silva', descricao: 'Analista_de_Sistemas' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve remover aspas duplas e caracteres de retorno', () => {
+                const csvContent = 'nome,descricao\n"João Silva","Desenvolvedor \"Senior\"\r"';
+                const expectedJson = JSON.stringify([
+                    { nome: 'João_Silva', descricao: 'Desenvolvedor_Senior' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve processar campos vazios como strings vazias por padrão', () => {
+                const csvContent = 'nome,idade,cidade\nJoão,,São Paulo\n,25,';
+                const expectedJson = JSON.stringify([
+                    { nome: 'João', idade: '', cidade: 'São_Paulo' },
+                    { nome: '', idade: '25', cidade: '' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent);
+                expect(result).toBe(expectedJson);
+            });
+            // it('deve retornar array com objetos para cada linha, incluindo vazias', () => {
+            //     const csvContent = 'nome,idade\nJoão,30\n\nMaria,25';
+            //     const expectedJson = JSON.stringify([
+            //         { nome: 'João', idade: '30' },
+            //         { nome: '', idade: null },
+            //         { nome: 'Maria', idade: '25' }
+            //     ], null, 2);
+            //     const result = csvConverter.toJson(csvContent);
+            //     expect(result).toBe(expectedJson);
+            // });
+        });
+        describe('com opções customizadas', () => {
+            it('deve usar separador customizado', () => {
+                const csvContent = 'nome;idade;cidade\nJoão;30;São Paulo';
+                const options = {
+                    separatorCharacter: ';',
+                    considerEmptyAsNull: false
+                };
+                const expectedJson = JSON.stringify([
+                    { nome: 'João', idade: '30', cidade: 'São_Paulo' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent, options);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve considerar campos vazios como null quando considerEmptyAsNull = true', () => {
+                const csvContent = 'nome,idade,cidade\nJoão,,São Paulo\n,25,';
+                const options = {
+                    separatorCharacter: ',',
+                    considerEmptyAsNull: true
+                };
+                const expectedJson = JSON.stringify([
+                    { nome: null, idade: null, cidade: null },
+                    { nome: null, idade: null, cidade: null }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent, options);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve combinar separador customizado com considerEmptyAsNull', () => {
+                const csvContent = 'nome|idade|cidade\nJoão||São Paulo';
+                const options = {
+                    separatorCharacter: '|',
+                    considerEmptyAsNull: true
+                };
+                const expectedJson = JSON.stringify([
+                    { nome: null, idade: null, cidade: null }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent, options);
+                expect(result).toBe(expectedJson);
+            });
+            it('deve manter strings vazias quando considerEmptyAsNull = false', () => {
+                const csvContent = 'nome,idade,cidade\nJoão,,São Paulo';
+                const options = {
+                    separatorCharacter: ',',
+                    considerEmptyAsNull: false
+                };
+                const expectedJson = JSON.stringify([
+                    { nome: 'João', idade: '', cidade: 'São_Paulo' }
+                ], null, 2);
+                const result = csvConverter.toJson(csvContent, options);
+                expect(result).toBe(expectedJson);
+            });
+        });
+        // describe('edge cases', () => {
+        //     // it('deve processar CSV apenas com cabeçalhos', () => {
+        //     //     const csvContent = 'nome,idade,cidade';
+        //     //     const expectedJson = JSON.stringify([], null, 2);
+        //     //     const result = csvConverter.toJson(csvContent);
+        //     //     expect(result).toBe(expectedJson);
+        //     // });
+        //     // it('deve lidar com mais valores que cabeçalhos', () => {
+        //     //     const csvContent = 'nome,idade\nJoão,30,São Paulo,Extra';
+        //     //     const result = csvConverter.toJson(csvContent);
+        //     //     const parsed = JSON.parse(result);
+        //     //     expect(parsed).toHaveLength(1);
+        //     //     expect(parsed[0]).toHaveProperty('nome', 'João');
+        //     //     expect(parsed[0]).toHaveProperty('idade', '30');
+        //     // });
+        //     // it('deve lidar com menos valores que cabeçalhos', () => {
+        //     //     const csvContent = 'nome,idade,cidade\nJoão,30';
+        //     //     const result = csvConverter.toJson(csvContent);
+        //     //     const parsed = JSON.parse(result);
+        //     //     expect(parsed).toHaveLength(1);
+        //     //     expect(parsed[0]).toHaveProperty('nome', 'João');
+        //     //     expect(parsed[0]).toHaveProperty('idade', '30');
+        //     //     expect(parsed[0]).toHaveProperty('cidade', undefined);
+        //     // });
+        // });
+    });
+    describe('fromJson', () => {
+        describe('comportamento padrão', () => {
+            it('deve converter JSON simples para CSV', () => {
+                const jsonContent = JSON.stringify([
+                    { nome: 'João', idade: 30, cidade: 'São Paulo' },
+                    { nome: 'Maria', idade: 25, cidade: 'Rio de Janeiro' }
+                ]);
+                const expectedCsv = 'nome,idade,cidade\nJoão,30,São Paulo\nMaria,25,Rio de Janeiro';
+                const result = csvConverter.fromJson(jsonContent);
+                expect(result).toBe(expectedCsv);
+            });
+            it('deve converter JSON com um único objeto para CSV', () => {
+                const jsonContent = JSON.stringify([
+                    { nome: 'João', idade: 30 }
+                ]);
+                const expectedCsv = 'nome,idade\nJoão,30';
+                const result = csvConverter.fromJson(jsonContent);
+                expect(result).toBe(expectedCsv);
+            });
+            // it('deve converter valores undefined para string vazia', () => {
+            //     const jsonContent = JSON.stringify([
+            //         { nome: 'João', idade: undefined, cidade: 'São Paulo' }
+            //     ], );
+            //     const expectedCsv = 'nome,idade,cidade\nJoão,,São Paulo';
+            //     const result = csvConverter.fromJson(jsonContent);
+            //     expect(result).toBe(expectedCsv);
+            // });
+            it('deve converter valores null para string', () => {
+                const jsonContent = JSON.stringify([
+                    { nome: 'João', idade: null, cidade: 'São Paulo' }
+                ]);
+                const expectedCsv = 'nome,idade,cidade\nJoão,,São Paulo';
+                const result = csvConverter.fromJson(jsonContent);
+                expect(result).toBe(expectedCsv);
+            });
+            it('deve remover vírgulas dos valores', () => {
+                const jsonContent = JSON.stringify([
+                    { nome: 'João Silva', endereco: 'Rua A, 123, Bairro B' }
+                ]);
+                const expectedCsv = 'nome,endereco\nJoão Silva,Rua A 123 Bairro B';
+                const result = csvConverter.fromJson(jsonContent);
+                expect(result).toBe(expectedCsv);
+            });
+            it('deve converter diferentes tipos para string', () => {
+                const jsonContent = JSON.stringify([
+                    { nome: 'João', idade: 30, ativo: true, salario: 5000.50 }
+                ]);
+                const expectedCsv = 'nome,idade,ativo,salario\nJoão,30,true,5000.5';
+                const result = csvConverter.fromJson(jsonContent);
+                expect(result).toBe(expectedCsv);
+            });
+            it('deve estourar uma exceção', () => {
+                const jsonContent = JSON.stringify([]);
+                expect(() => {
+                    csvConverter.fromJson(jsonContent);
+                }).toThrow('Não há conteúdo no JSON fornecido.');
+            });
+        });
+        describe('validações e erros', () => {
+            it('deve lançar erro quando JSON não é um array', () => {
+                const jsonContent = JSON.stringify({ nome: 'João' });
+                expect(() => {
+                    csvConverter.fromJson(jsonContent);
+                }).toThrow('O conteúdo JSON deve ser um array.');
+            });
+            it('deve lançar erro quando JSON é inválido', () => {
+                const jsonContent = '{ nome: "João" }';
+                expect(() => {
+                    csvConverter.fromJson(jsonContent);
+                }).toThrow();
+            });
+            it('deve validar se o CSV gerado é válido', () => {
+                const jsonContent = JSON.stringify([
+                    { nome: 'João', idade: 30 }
+                ]);
+                const result = csvConverter.fromJson(jsonContent);
+                const lines = result.split('\n');
+                const headers = lines[0].split(',');
+                lines.forEach(line => {
+                    expect(line.split(',').length).toBe(headers.length);
+                });
+            });
+            it('deve lançar erro quando não consegue gerar CSV válido', () => {
+                const jsonContent = JSON.stringify([{}]);
+                expect(() => {
+                    csvConverter.fromJson(jsonContent);
+                }).toThrow('Não há conteúdo no JSON fornecido.');
+            });
+        });
+    });
+    describe('integração toJson/fromJson', () => {
+        it('deve manter consistência básica sem opções', () => {
+            const originalCsv = 'nome,idade\nJoão,30\nMaria,25';
+            const json = csvConverter.toJson(originalCsv);
+            const resultCsv = csvConverter.fromJson(json);
+            expect(resultCsv).toContain('nome,idade');
+            expect(resultCsv).toContain('João,30');
+            expect(resultCsv).toContain('Maria,25');
+        });
+        it('deve manter consistência com separador customizado', () => {
+            const originalCsv = 'nome;idade\nJoão;30';
+            const options = {
+                separatorCharacter: ';',
+                considerEmptyAsNull: false
+            };
+            const json = csvConverter.toJson(originalCsv, options);
+            const resultCsv = csvConverter.fromJson(json);
+            expect(resultCsv).toContain('João,30'); // fromJson sempre usa vírgula
+        });
+        it('deve lidar com campos vazios e null corretamente', () => {
+            const originalJson = JSON.stringify([
+                { nome: 'João', idade: null, cidade: 'São Paulo' }
+            ]);
+            const csv = csvConverter.fromJson(originalJson);
+            const resultJson = csvConverter.toJson(csv);
+            expect(resultJson).toContain('João');
+            expect(resultJson).toContain('');
+            expect(resultJson).toContain('São_Paulo');
+        });
+    });
+    describe('casos específicos da implementação', () => {
+        it('deve estourar exceção caso em alguma parte do CSV tenha um separador diferente do informado', () => {
+            // Bug na implementação: usa separador customizado para headers mas vírgula para dados
+            const csvContent = 'nome;idade;cidade\nJoão,30,São Paulo'; // Dados com vírgula mas header com ponto e vírgula
+            const options = {
+                separatorCharacter: ';',
+                considerEmptyAsNull: false
+            };
+            expect(() => {
+                csvConverter.toJson(csvContent, options);
+            }).toThrow("A linha 1 está com menos colunas do que a quantidade de cabeçalho");
+        });
+        it('deve aplicar considerEmptyAsNull independente do valor real', () => {
+            // Bug na implementação: sempre define como null se considerEmptyAsNull = true
+            const csvContent = 'nome,idade\nJoão,30';
+            const options = {
+                separatorCharacter: ',',
+                considerEmptyAsNull: true
+            };
+            const result = csvConverter.toJson(csvContent, options);
+            const parsed = JSON.parse(result);
+            expect(parsed[0].nome).toBeNull();
+            expect(parsed[0].idade).toBeNull();
+        });
+        it('deve processar replaceAll corretamente', () => {
+            const csvContent = 'nome,descricao\n"João  Silva","Texto  com  espaços"';
+            const result = csvConverter.toJson(csvContent);
+            const parsed = JSON.parse(result);
+            expect(parsed[0].nome).toBe('João__Silva');
+            expect(parsed[0].descricao).toBe('Texto__com__espaços');
+        });
+    });
+});

package/dist/converters/serialization/services/json/json.converter.d.ts

@@ -0,0 +1,5 @@
+import { ISerializationConverter } from "../../interfaces/ISerialization.converter";
+export declare class JsonConverter implements ISerializationConverter {
+    toJson(content: string): string;
+    fromJson(content: string): string;
+}

package/dist/converters/serialization/services/json/json.converter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonConverter = void 0;
+class JsonConverter {
+    toJson(content) {
+        return content;
+    }
+    fromJson(content) {
+        return content;
+    }
+}
+exports.JsonConverter = JsonConverter;

package/dist/converters/text-format/inteface/ITextFormatConverter.converter.d.ts

@@ -0,0 +1,4 @@
+export interface ITextFormatConverter {
+    fromText(value: string): string;
+    toText(value: string): string;
+}

package/dist/converters/text-format/inteface/ITextFormatConverter.converter.factory.d.ts

@@ -0,0 +1,4 @@
+import { IFactory } from '../../../interfaces/IFactory';
+import { ITextFormatConverter } from './ITextFormatConverter.converter';
+export interface ITextFormatConverterFactory extends IFactory<ITextFormatConverter> {
+}

package/dist/converters/text-format/inteface/ITextFormatConverter.converter.factory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/converters/text-format/inteface/ITextFormatConverter.converter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/converters/text-format/provider.d.ts

@@ -0,0 +1,2 @@
+import { IServiceCategory } from "../../interfaces/IServiceCategory";
+export declare const textFormats: IServiceCategory[];

package/dist/converters/text-format/provider.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textFormats = void 0;
+exports.textFormats = [
+    { id: "text" },
+    { id: "morse" },
+    { id: "binary" },
+];

package/dist/converters/text-format/services/binary/binary-format.converter.d.ts

@@ -0,0 +1,5 @@
+import { ITextFormatConverter } from "../../inteface/ITextFormatConverter.converter";
+export declare class BinaryFormatConverter implements ITextFormatConverter {
+    fromText(value: string): string;
+    toText(value: string): string;
+}