devtoolz-library 1.0.0

package/dist/converters/text-format/services/morse/morse-format.converter.test.js

@@ -0,0 +1,518 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const textFormatConverter_converter_factory_1 = require("../../textFormatConverter.converter.factory");
+describe('MorseFormatConverter', () => {
+    let factory;
+    let converter;
+    beforeEach(() => {
+        factory = new textFormatConverter_converter_factory_1.TextFormatConverterFactory();
+        converter = factory.createService('morse');
+    });
+    describe('fromText', () => {
+        describe('Dado uma entrada válida', () => {
+            it('Deve converter letra A maiúscula para código Morse', () => {
+                // Arrange
+                const entrada = 'A';
+                const resultadoEsperado = '.-';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter letra B maiúscula para código Morse', () => {
+                // Arrange
+                const entrada = 'B';
+                const resultadoEsperado = '-...';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter letra S maiúscula para código Morse', () => {
+                // Arrange
+                const entrada = 'S';
+                const resultadoEsperado = '...';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter letra O maiúscula para código Morse', () => {
+                // Arrange
+                const entrada = 'O';
+                const resultadoEsperado = '---';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter SOS maiúsculo para código Morse', () => {
+                // Arrange
+                const entrada = 'SOS';
+                const resultadoEsperado = '...---...';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter HELLO maiúsculo para código Morse', () => {
+                // Arrange
+                const entrada = 'HELLO';
+                const resultadoEsperado = '......-...-..---';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter letra a minúscula para código Morse', () => {
+                // Arrange
+                const entrada = 'a';
+                const resultadoEsperado = '.-';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter hello minúsculo para código Morse', () => {
+                // Arrange
+                const entrada = 'hello';
+                const resultadoEsperado = '......-...-..---';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter número 0 para código Morse', () => {
+                // Arrange
+                const entrada = '0';
+                const resultadoEsperado = '-----';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter número 1 para código Morse', () => {
+                // Arrange
+                const entrada = '1';
+                const resultadoEsperado = '.----';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter número 9 para código Morse', () => {
+                // Arrange
+                const entrada = '9';
+                const resultadoEsperado = '----.';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter sequência 123 para código Morse', () => {
+                // Arrange
+                const entrada = '123';
+                const resultadoEsperado = '.----..---...--';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter A1 para código Morse', () => {
+                // Arrange
+                const entrada = 'A1';
+                const resultadoEsperado = '.-.----';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter ABC123 para código Morse', () => {
+                // Arrange
+                const entrada = 'ABC123';
+                const resultadoEsperado = '.--...-.-..----..---...--';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve preservar exclamação em A!', () => {
+                // Arrange
+                const entrada = 'A!';
+                const resultadoEsperado = '.-!';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve preservar espaço em A B', () => {
+                // Arrange
+                const entrada = 'A B';
+                const resultadoEsperado = '.- -...';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve preservar arroba em A@B', () => {
+                // Arrange
+                const entrada = 'A@B';
+                const resultadoEsperado = '.-@-...';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+        });
+        describe('Dado uma entrada de casos extremos', () => {
+            it('Deve retornar string vazia quando entrada for vazia', () => {
+                // Arrange
+                const entrada = '';
+                const resultadoEsperado = '';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve preservar símbolos especiais', () => {
+                // Arrange
+                const entrada = '!@#$%';
+                const resultadoEsperado = '!@#$%';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+        });
+    });
+    describe('toText', () => {
+        describe('Dado um código Morse válido', () => {
+            it('Deve converter código Morse de A para letra', () => {
+                // Arrange
+                const entrada = '.-';
+                const resultadoEsperado = 'A';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter código Morse de B para letra', () => {
+                // Arrange
+                const entrada = '-...';
+                const resultadoEsperado = 'B';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter código Morse de S para letra', () => {
+                // Arrange
+                const entrada = '...';
+                const resultadoEsperado = 'S';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter código Morse de O para letra', () => {
+                // Arrange
+                const entrada = '---';
+                const resultadoEsperado = 'O';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter código Morse de 0 para dígito', () => {
+                // Arrange
+                const entrada = '-----';
+                const resultadoEsperado = '0';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter código Morse de 1 para dígito', () => {
+                // Arrange
+                const entrada = '.----';
+                const resultadoEsperado = '1';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter código Morse de 9 para dígito', () => {
+                // Arrange
+                const entrada = '----.';
+                const resultadoEsperado = '9';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter códigos Morse AB separados por espaço', () => {
+                // Arrange
+                const entrada = '.- -...';
+                const resultadoEsperado = 'AB';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter códigos Morse SOS separados por espaço', () => {
+                // Arrange
+                const entrada = '... --- ...';
+                const resultadoEsperado = 'SOS';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter códigos Morse HELLO separados por espaço', () => {
+                // Arrange
+                const entrada = '.... . .-.. .-.. ---';
+                const resultadoEsperado = 'HELLO';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter HELLO WORLD com separador de palavras', () => {
+                // Arrange
+                const entrada = '.... . .-.. .-.. ---   .-- --- .-. .-.. -..';
+                const resultadoEsperado = 'HELLO WORLD';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter AB C com separador de palavras', () => {
+                // Arrange
+                const entrada = '.- -...   -.-.';
+                const resultadoEsperado = 'AB C';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+        });
+        describe('Dado um código Morse inválido', () => {
+            it('Deve retornar ? para código Morse desconhecido', () => {
+                // Arrange
+                const entrada = '..---..';
+                const resultadoEsperado = '?';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve retornar ? para código Morse longo desconhecido', () => {
+                // Arrange
+                const entrada = '.-.-.-.-';
+                const resultadoEsperado = '?';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve processar A + código inválido + B', () => {
+                // Arrange
+                const entrada = '.- invalid -...';
+                const resultadoEsperado = 'A?B';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve processar SO + código inválido', () => {
+                // Arrange
+                const entrada = '... --- invalid';
+                const resultadoEsperado = 'SO?';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+        });
+        describe('Dado uma entrada de casos extremos', () => {
+            it('Deve retornar string vazia quando entrada for vazia', () => {
+                // Arrange
+                const entrada = '';
+                const resultadoEsperado = '';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve retornar string vazia quando entrada for três espaços', () => {
+                // Arrange
+                const entrada = '   ';
+                const resultadoEsperado = '';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve retornar string vazia quando entrada for um espaço', () => {
+                // Arrange
+                const entrada = ' ';
+                const resultadoEsperado = '';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve retornar string vazia quando entrada for cinco espaços', () => {
+                // Arrange
+                const entrada = '     ';
+                const resultadoEsperado = '';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve remover espaços extras no final do resultado AB', () => {
+                // Arrange
+                const entrada = '.- -...';
+                const resultadoEsperado = 'AB';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+                expect(resultado.endsWith(' ')).toBe(false);
+            });
+        });
+    });
+    describe('Testes de Integração', () => {
+        describe('Conversões bidirecionais', () => {
+            it('Deve converter HELLO WORLD conhecido de Morse para texto', () => {
+                // Arrange
+                const entrada = '.... . .-.. .-.. ---   .-- --- .-. .-.. -..';
+                const resultadoEsperado = 'HELLO WORLD';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter SOS de texto para Morse', () => {
+                // Arrange
+                const entrada = 'SOS';
+                const resultadoEsperado = '...---...';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter SOS de Morse para texto', () => {
+                // Arrange
+                const entrada = '... --- ...';
+                const resultadoEsperado = 'SOS';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter alfabeto ABCDEFGHIJKLMNOPQRSTUVWXYZ para Morse', () => {
+                // Arrange
+                const entrada = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+                const resultadoEsperado = '.-' + '-...' + '-.-.' + '-..' + '.' + '..-.' +
+                    '--.' + '....' + '..' + '.---' + '-.-' + '.-..' +
+                    '--' + '-.' + '---' + '.--.' + '--.-' + '.-.' +
+                    '...' + '-' + '..-' + '...-' + '.--' + '-..-' +
+                    '-.--' + '--..';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter números 0123456789 para Morse', () => {
+                // Arrange
+                const entrada = '0123456789';
+                const resultadoEsperado = '-----.----..---...--....-.....-....--...---..----.';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter números em Morse para texto', () => {
+                // Arrange
+                const entrada = '----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----.';
+                const resultadoEsperado = '0123456789';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter A1B2 para Morse', () => {
+                // Arrange
+                const entrada = 'A1B2';
+                const resultadoEsperado = '.-.----' + '-...' + '..---';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+            it('Deve converter A1B2 em Morse para texto', () => {
+                // Arrange
+                const entrada = '.- .---- -... ..---';
+                const resultadoEsperado = 'A1B2';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe(resultadoEsperado);
+            });
+        });
+        describe('Cenários de validação', () => {
+            it('Deve converter HELLO para Morse retornando resultado não vazio', () => {
+                // Arrange
+                const entrada = 'HELLO';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBeTruthy();
+                expect(resultado.length).toBeGreaterThan(0);
+            });
+            it('Deve converter WORLD para Morse retornando resultado não vazio', () => {
+                // Arrange
+                const entrada = 'WORLD';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBeTruthy();
+                expect(resultado.length).toBeGreaterThan(0);
+            });
+            it('Deve tratar entrada vazia consistentemente em fromText', () => {
+                // Arrange
+                const entrada = '';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe('');
+            });
+            it('Deve tratar entrada vazia consistentemente em toText', () => {
+                // Arrange
+                const entrada = '';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe('');
+            });
+            it('Deve tratar entrada com espaços consistentemente em fromText', () => {
+                // Arrange
+                const entrada = '   ';
+                // Act
+                const resultado = converter.fromText(entrada);
+                // Assert
+                expect(resultado).toBe('');
+            });
+            it('Deve tratar entrada com espaços consistentemente em toText', () => {
+                // Arrange
+                const entrada = '   ';
+                // Act
+                const resultado = converter.toText(entrada);
+                // Assert
+                expect(resultado).toBe('');
+            });
+        });
+    });
+});

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

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

package/dist/converters/text-format/services/text/text-format.converter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextFormatConverter = void 0;
+class TextFormatConverter {
+    fromText(value) {
+        return value;
+    }
+    toText(value) {
+        return value;
+    }
+}
+exports.TextFormatConverter = TextFormatConverter;

package/dist/converters/text-format/textFormatConverter.converter.d.ts

@@ -0,0 +1,5 @@
+export declare class TextConverter {
+    private readonly factory;
+    constructor();
+    convert(value: string, from: string, to: string): string;
+}

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

@@ -0,0 +1,8 @@
+import { BaseFactory } from "../../baseFactory";
+import { ITextFormatConverter } from "./inteface/ITextFormatConverter.converter";
+import { ITextFormatConverterFactory } from "./inteface/ITextFormatConverter.converter.factory";
+import { IServiceCategory } from "../../interfaces/IServiceCategory";
+export declare class TextFormatConverterFactory extends BaseFactory<ITextFormatConverter> implements ITextFormatConverterFactory {
+    constructor();
+    protected registerService(service: IServiceCategory): void;
+}

package/dist/converters/text-format/textFormatConverter.converter.factory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextFormatConverterFactory = void 0;
+const baseFactory_1 = require("../../baseFactory");
+const provider_1 = require("./provider");
+class TextFormatConverterFactory extends baseFactory_1.BaseFactory {
+    constructor() {
+        super(provider_1.textFormats);
+    }
+    registerService(service) {
+        const module = require("./services/" + service.id + "/" + service.id + "-format" + ".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.TextFormatConverterFactory = TextFormatConverterFactory;

package/dist/converters/text-format/textFormatConverter.converter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextConverter = void 0;
+const textFormatConverter_converter_factory_1 = require("./textFormatConverter.converter.factory");
+class TextConverter {
+    constructor() {
+        this.factory = new textFormatConverter_converter_factory_1.TextFormatConverterFactory();
+    }
+    convert(value, from, to) {
+        const source = this.factory.createService(from);
+        const target = this.factory.createService(to);
+        const text = source.toText(value);
+        const result = target.fromText(text);
+        return result;
+    }
+}
+exports.TextConverter = TextConverter;

package/dist/converters/unit-converter/converter-base.d.ts

@@ -0,0 +1,19 @@
+import { IUnitConverter } from "./interfaces/IUnitConverter";
+import { Unit } from "./models/unit";
+export declare abstract class ConverterBaseService implements IUnitConverter {
+    private readonly _mapById;
+    private readonly _mapBySymbol;
+    private readonly _mapByName;
+    private readonly _units;
+    constructor(units: Unit[]);
+    private _mapUnitById;
+    private _mapUnitBySymbol;
+    private _mapUnitByName;
+    private _mapUnits;
+    convert(value: number, fromUnitId: string, toUnitId: string): number;
+    getUnits(): Unit[];
+    getBaseUnit(): Unit;
+    getUnitById(id: string): Unit | undefined;
+    getUnitBySymbol(symbol: string): Unit | undefined;
+    getUnitByName(name: string): Unit | undefined;
+}

package/dist/converters/unit-converter/converter-base.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterBaseService = void 0;
+class ConverterBaseService {
+    constructor(units) {
+        this._mapById = new Map();
+        this._mapBySymbol = new Map();
+        this._mapByName = new Map();
+        this._units = [];
+        this._units = units;
+        this._mapUnits();
+    }
+    _mapUnitById(unit) {
+        this._mapById.set(unit.id, unit);
+    }
+    _mapUnitBySymbol(unit) {
+        this._mapBySymbol.set(unit.symbol, unit);
+    }
+    _mapUnitByName(unit) {
+        this._mapByName.set(unit.name, unit);
+    }
+    _mapUnits() {
+        this._units.forEach(unit => {
+            this._mapUnitById(unit);
+            this._mapUnitBySymbol(unit);
+            this._mapUnitByName(unit);
+        });
+    }
+    convert(value, fromUnitId, toUnitId) {
+        const sourceUnit = this.getUnitById(fromUnitId);
+        const targetUnit = this.getUnitById(toUnitId);
+        if (!sourceUnit || !targetUnit) {
+            throw new Error('Unidades não encontradas');
+        }
+        // Converte para a unidade base (mililitros) e depois para a unidade alvo
+        const baseValue = value * sourceUnit.conversionFactor;
+        const result = baseValue / targetUnit.conversionFactor;
+        return result;
+    }
+    getUnits() {
+        return this._units;
+    }
+    getBaseUnit() {
+        return this._units.find(unit => unit.isBaseUnit);
+    }
+    getUnitById(id) {
+        return this._mapById.get(id);
+    }
+    getUnitBySymbol(symbol) {
+        return this._mapBySymbol.get(symbol);
+    }
+    getUnitByName(name) {
+        return this._mapByName.get(name);
+    }
+}
+exports.ConverterBaseService = ConverterBaseService;

package/dist/converters/unit-converter/interfaces/IUnitConverter.d.ts

@@ -0,0 +1,9 @@
+import { Unit } from "../models/unit";
+export interface IUnitConverter {
+    convert(value: number, fromUnit: string, toUnit: string): number;
+    getUnits(): Unit[];
+    getBaseUnit(): Unit;
+    getUnitById(id: string): Unit | undefined;
+    getUnitBySymbol(symbol: string): Unit | undefined;
+    getUnitByName(name: string): Unit | undefined;
+}