devtoolz-library 1.0.0

package/dist/converters/unit-converter/services/data/data.converter.test.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_converter_1 = require("./data.converter");
+describe('DigitalConverter', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new data_converter_1.DataConverter();
+    });
+    describe('Inicialização', () => {
+        it('deve inicializar com todas as unidades de informação digital', () => {
+            const units = converter.getUnits();
+            expect(units).toHaveLength(18);
+        });
+        it('deve ter bit como unidade base', () => {
+            const baseUnit = converter.getBaseUnit();
+            expect(baseUnit.id).toBe('bit');
+            expect(baseUnit.isBaseUnit).toBe(true);
+            expect(baseUnit.conversionFactor).toBe(1);
+        });
+    });
+    describe('Busca de unidades', () => {
+        it('deve encontrar unidade por ID', () => {
+            const unit = converter.getUnitById('megabyte');
+            expect(unit).toBeDefined();
+            expect(unit?.name).toBe('Megabyte');
+            expect(unit?.symbol).toBe('MB');
+        });
+        it('deve encontrar unidade por símbolo', () => {
+            const unit = converter.getUnitBySymbol('GB');
+            expect(unit).toBeDefined();
+            expect(unit?.id).toBe('gigabyte');
+            expect(unit?.name).toBe('Gigabyte');
+        });
+        it('deve encontrar unidade por nome', () => {
+            const unit = converter.getUnitByName('Kilobit');
+            expect(unit).toBeDefined();
+            expect(unit?.id).toBe('kilobit');
+            expect(unit?.symbol).toBe('kbit');
+        });
+        it('deve retornar undefined para unidade inexistente', () => {
+            expect(converter.getUnitById('inexistente')).toBeUndefined();
+            expect(converter.getUnitBySymbol('XX')).toBeUndefined();
+            expect(converter.getUnitByName('Unidade Inexistente')).toBeUndefined();
+        });
+    });
+    describe('Conversões básicas', () => {
+        it('deve converter bits para bytes', () => {
+            const result = converter.convert(8, 'bit', 'byte');
+            expect(result).toBe(1);
+        });
+        it('deve converter bytes para bits', () => {
+            const result = converter.convert(1, 'byte', 'bit');
+            expect(result).toBe(8);
+        });
+        it('deve converter da mesma unidade para ela mesma', () => {
+            const result = converter.convert(100, 'megabyte', 'megabyte');
+            expect(result).toBe(100);
+        });
+    });
+    describe('Conversões entre bits', () => {
+        it('deve converter bits para kilobits', () => {
+            const result = converter.convert(1000, 'bit', 'kilobit');
+            expect(result).toBe(1);
+        });
+        it('deve converter kilobits para megabits', () => {
+            const result = converter.convert(1000, 'kilobit', 'megabit');
+            expect(result).toBe(1);
+        });
+        it('deve converter megabits para gigabits', () => {
+            const result = converter.convert(1000, 'megabit', 'gigabit');
+            expect(result).toBe(1);
+        });
+        it('deve converter gigabits para terabits', () => {
+            const result = converter.convert(1000, 'gigabit', 'terabit');
+            expect(result).toBe(1);
+        });
+    });
+    describe('Conversões entre bytes', () => {
+        it('deve converter bytes para kilobytes', () => {
+            const result = converter.convert(1000, 'byte', 'kilobyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter kilobytes para megabytes', () => {
+            const result = converter.convert(1000, 'kilobyte', 'megabyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter megabytes para gigabytes', () => {
+            const result = converter.convert(1000, 'megabyte', 'gigabyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter gigabytes para terabytes', () => {
+            const result = converter.convert(1000, 'gigabyte', 'terabyte');
+            expect(result).toBe(1);
+        });
+    });
+    describe('Conversões mistas (bits para bytes)', () => {
+        it('deve converter kilobits para kilobytes', () => {
+            const result = converter.convert(8, 'kilobit', 'kilobyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter megabits para megabytes', () => {
+            const result = converter.convert(8, 'megabit', 'megabyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter gigabits para gigabytes', () => {
+            const result = converter.convert(8, 'gigabit', 'gigabyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter terabits para terabytes', () => {
+            const result = converter.convert(8, 'terabit', 'terabyte');
+            expect(result).toBe(1);
+        });
+    });
+    describe('Conversões mistas (bytes para bits)', () => {
+        it('deve converter kilobytes para kilobits', () => {
+            const result = converter.convert(1, 'kilobyte', 'kilobit');
+            expect(result).toBe(8);
+        });
+        it('deve converter megabytes para megabits', () => {
+            const result = converter.convert(1, 'megabyte', 'megabit');
+            expect(result).toBe(8);
+        });
+        it('deve converter gigabytes para gigabits', () => {
+            const result = converter.convert(1, 'gigabyte', 'gigabit');
+            expect(result).toBe(8);
+        });
+        it('deve converter terabytes para terabits', () => {
+            const result = converter.convert(1, 'terabyte', 'terabit');
+            expect(result).toBe(8);
+        });
+    });
+    describe('Conversões de unidades grandes', () => {
+        it('deve converter petabytes para terabytes', () => {
+            const result = converter.convert(1, 'petabyte', 'terabyte');
+            expect(result).toBe(1000);
+        });
+        it('deve converter exabytes para petabytes', () => {
+            const result = converter.convert(1, 'exabyte', 'petabyte');
+            expect(result).toBe(1000);
+        });
+        it('deve converter zetabytes para exabytes', () => {
+            const result = converter.convert(1, 'zetabyte', 'exabyte');
+            expect(result).toBe(1000);
+        });
+        it('deve converter yottabytes para zetabytes', () => {
+            const result = converter.convert(1, 'yottabyte', 'zetabyte');
+            expect(result).toBe(1000);
+        });
+    });
+    describe('Conversões extremas', () => {
+        it('deve converter bits para yottabytes', () => {
+            const result = converter.convert(8000000000000000000000000, 'bit', 'yottabyte');
+            expect(result).toBe(1);
+        });
+        it('deve converter yottabytes para bits', () => {
+            const result = converter.convert(1, 'yottabyte', 'bit');
+            expect(result).toBe(8000000000000000000000000);
+        });
+        it('deve converter yottabits para bits', () => {
+            const result = converter.convert(1, 'yottabit', 'bit');
+            expect(result).toBe(1000000000000000000000000);
+        });
+    });
+    describe('Tratamento de erros', () => {
+        it('deve lançar erro para unidade de origem não encontrada', () => {
+            expect(() => {
+                converter.convert(100, 'unidade_inexistente', 'byte');
+            }).toThrow('Unidades não encontradas');
+        });
+        it('deve lançar erro para unidade de destino não encontrada', () => {
+            expect(() => {
+                converter.convert(100, 'byte', 'unidade_inexistente');
+            }).toThrow('Unidades não encontradas');
+        });
+        it('deve lançar erro para ambas as unidades não encontradas', () => {
+            expect(() => {
+                converter.convert(100, 'unidade1', 'unidade2');
+            }).toThrow('Unidades não encontradas');
+        });
+    });
+    describe('Valores decimais', () => {
+        it('deve converter valores decimais corretamente', () => {
+            const result = converter.convert(0.5, 'kilobyte', 'byte');
+            expect(result).toBe(500);
+        });
+        it('deve converter para valores decimais corretamente', () => {
+            const result = converter.convert(500, 'byte', 'kilobyte');
+            expect(result).toBe(0.5);
+        });
+        it('deve manter precisão em conversões decimais', () => {
+            const result = converter.convert(1.5, 'megabyte', 'kilobyte');
+            expect(result).toBe(1500);
+        });
+    });
+    describe('Verificação de fatores de conversão', () => {
+        it('deve ter fatores de conversão corretos para bits', () => {
+            expect(converter.getUnitById('bit')?.conversionFactor).toBe(1);
+            expect(converter.getUnitById('kilobit')?.conversionFactor).toBe(1000);
+            expect(converter.getUnitById('megabit')?.conversionFactor).toBe(1000000);
+            expect(converter.getUnitById('gigabit')?.conversionFactor).toBe(1000000000);
+        });
+        it('deve ter fatores de conversão corretos para bytes', () => {
+            expect(converter.getUnitById('byte')?.conversionFactor).toBe(8);
+            expect(converter.getUnitById('kilobyte')?.conversionFactor).toBe(8000);
+            expect(converter.getUnitById('megabyte')?.conversionFactor).toBe(8000000);
+            expect(converter.getUnitById('gigabyte')?.conversionFactor).toBe(8000000000);
+        });
+    });
+});

package/dist/converters/unit-converter/services/energy/energy.converter.d.ts

@@ -0,0 +1,4 @@
+import { ConverterBaseService } from '../../converter-base';
+export declare class LengthConverter extends ConverterBaseService {
+    constructor();
+}

package/dist/converters/unit-converter/services/energy/energy.converter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LengthConverter = void 0;
+const converter_base_1 = require("../../converter-base");
+class LengthConverter extends converter_base_1.ConverterBaseService {
+    constructor() {
+        super([
+            // Base: Joule
+            { id: 'joule', name: 'Joule', symbol: 'J', conversionFactor: 1, isBaseUnit: true },
+            { id: 'quilojoule', name: 'Quilojoule', symbol: 'kJ', conversionFactor: 1000, isBaseUnit: false },
+            { id: 'eletron-volt', name: 'Elétron-volt', symbol: 'eV', conversionFactor: 1.602176634e-19, isBaseUnit: false },
+            { id: 'caloria-termica', name: 'Caloria térmica (cal)', symbol: 'cal', conversionFactor: 4.184, isBaseUnit: false },
+            { id: 'caloria-alimentar', name: 'Caloria alimentar (kcal)', symbol: 'kcal', conversionFactor: 4184, isBaseUnit: false },
+            { id: 'libra-pe', name: 'Libra-pé', symbol: 'lbf·ft', conversionFactor: 1.3558179483314, isBaseUnit: false },
+            { id: 'btu', name: 'Unidade Térmica Britânica (BTU)', symbol: 'BTU', conversionFactor: 1055.05585262, isBaseUnit: false },
+            // { id: 'quilowatt-hora', name: 'Quilowatt-hora', symbol: 'kWh', conversionFactor: 3.6e6, isBaseUnit: false }
+        ]);
+    }
+}
+exports.LengthConverter = LengthConverter;

package/dist/converters/unit-converter/services/energy/energy.converter.test.d.ts

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

package/dist/converters/unit-converter/services/energy/energy.converter.test.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const unit_converter_factory_1 = require("../../unit.converter.factory");
+const factory = new unit_converter_factory_1.UnitConverterFactory();
+const converter = factory.createService('energy');
+describe('Conversão completa entre unidades de energia', () => {
+    test('1 joule → joule ≈ 1.0', () => {
+        expect(converter.convert(1, 'joule', 'joule')).toBeCloseTo(1.0, 10);
+    });
+    test('1 joule → quilojoule ≈ 0.001', () => {
+        expect(converter.convert(1, 'joule', 'quilojoule')).toBeCloseTo(0.001, 10);
+    });
+    test('1 joule → eletron-volt ≈ 6.241509074460763e+18', () => {
+        expect(converter.convert(1, 'joule', 'eletron-volt')).toBeCloseTo(6.241509074460763e+18, 10);
+    });
+    test('1 joule → caloria-termica ≈ 0.239005736137667', () => {
+        expect(converter.convert(1, 'joule', 'caloria-termica')).toBeCloseTo(0.239005736137667, 10);
+    });
+    test('1 joule → caloria-alimentar ≈ 0.000239005736138', () => {
+        expect(converter.convert(1, 'joule', 'caloria-alimentar')).toBeCloseTo(0.000239005736138, 10);
+    });
+    test('1 joule → libra-pe ≈ 0.737562149277266', () => {
+        expect(converter.convert(1, 'joule', 'libra-pe')).toBeCloseTo(0.737562149277266, 10);
+    });
+    test('1 joule → btu ≈ 0.000947817120313', () => {
+        expect(converter.convert(1, 'joule', 'btu')).toBeCloseTo(0.000947817120313, 10);
+    });
+    test('1 quilojoule → joule ≈ 1000.0', () => {
+        expect(converter.convert(1, 'quilojoule', 'joule')).toBeCloseTo(1000.0, 10);
+    });
+    test('1 quilojoule → quilojoule ≈ 1.0', () => {
+        expect(converter.convert(1, 'quilojoule', 'quilojoule')).toBeCloseTo(1.0, 10);
+    });
+    test('1 quilojoule → eletron-volt ≈ 6.241509074460763e+21', () => {
+        expect(converter.convert(1, 'quilojoule', 'eletron-volt')).toBeCloseTo(6.241509074460763e+21, 10);
+    });
+    test('1 quilojoule → caloria-termica ≈ 239.0057361376673', () => {
+        expect(converter.convert(1, 'quilojoule', 'caloria-termica')).toBeCloseTo(239.0057361376673, 10);
+    });
+    test('1 quilojoule → caloria-alimentar ≈ 0.239005736137667', () => {
+        expect(converter.convert(1, 'quilojoule', 'caloria-alimentar')).toBeCloseTo(0.239005736137667, 10);
+    });
+    test('1 quilojoule → libra-pe ≈ 737.5621492772657', () => {
+        expect(converter.convert(1, 'quilojoule', 'libra-pe')).toBeCloseTo(737.5621492772657, 10);
+    });
+    test('1 quilojoule → btu ≈ 0.947817120313317', () => {
+        expect(converter.convert(1, 'quilojoule', 'btu')).toBeCloseTo(0.947817120313317, 10);
+    });
+    test('1 eletron-volt → joule ≈ 0.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'joule')).toBeCloseTo(0.0, 10);
+    });
+    test('1 eletron-volt → quilojoule ≈ 0.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'quilojoule')).toBeCloseTo(0.0, 10);
+    });
+    test('1 eletron-volt → eletron-volt ≈ 1.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'eletron-volt')).toBeCloseTo(1.0, 10);
+    });
+    test('1 eletron-volt → caloria-termica ≈ 0.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'caloria-termica')).toBeCloseTo(0.0, 10);
+    });
+    test('1 eletron-volt → caloria-alimentar ≈ 0.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'caloria-alimentar')).toBeCloseTo(0.0, 10);
+    });
+    test('1 eletron-volt → libra-pe ≈ 0.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'libra-pe')).toBeCloseTo(0.0, 10);
+    });
+    test('1 eletron-volt → btu ≈ 0.0', () => {
+        expect(converter.convert(1, 'eletron-volt', 'btu')).toBeCloseTo(0.0, 10);
+    });
+    test('1 caloria-termica → joule ≈ 4.184', () => {
+        expect(converter.convert(1, 'caloria-termica', 'joule')).toBeCloseTo(4.184, 10);
+    });
+    test('1 caloria-termica → quilojoule ≈ 0.004184', () => {
+        expect(converter.convert(1, 'caloria-termica', 'quilojoule')).toBeCloseTo(0.004184, 10);
+    });
+    test('1 caloria-termica → eletron-volt ≈ 2.6114473967543833e+19', () => {
+        expect(converter.convert(1, 'caloria-termica', 'eletron-volt')).toBeCloseTo(2.6114473967543833e+19, 10);
+    });
+    test('1 caloria-termica → caloria-termica ≈ 1.0', () => {
+        expect(converter.convert(1, 'caloria-termica', 'caloria-termica')).toBeCloseTo(1.0, 10);
+    });
+    test('1 caloria-termica → caloria-alimentar ≈ 0.001', () => {
+        expect(converter.convert(1, 'caloria-termica', 'caloria-alimentar')).toBeCloseTo(0.001, 10);
+    });
+    test('1 caloria-termica → libra-pe ≈ 3.08596003257608', () => {
+        expect(converter.convert(1, 'caloria-termica', 'libra-pe')).toBeCloseTo(3.08596003257608, 10);
+    });
+    test('1 caloria-termica → btu ≈ 0.003965666831391', () => {
+        expect(converter.convert(1, 'caloria-termica', 'btu')).toBeCloseTo(0.003965666831391, 10);
+    });
+    test('1 caloria-alimentar → joule ≈ 4184.0', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'joule')).toBeCloseTo(4184.0, 10);
+    });
+    test('1 caloria-alimentar → quilojoule ≈ 4.184', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'quilojoule')).toBeCloseTo(4.184, 10);
+    });
+    test('1 caloria-alimentar → eletron-volt ≈ 2.6114473967543833e+22', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'eletron-volt')).toBeCloseTo(2.6114473967543833e+22, 10);
+    });
+    test('1 caloria-alimentar → caloria-termica ≈ 1000.0', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'caloria-termica')).toBeCloseTo(1000.0, 10);
+    });
+    test('1 caloria-alimentar → caloria-alimentar ≈ 1.0', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'caloria-alimentar')).toBeCloseTo(1.0, 10);
+    });
+    test('1 caloria-alimentar → libra-pe ≈ 3085.9600325760794', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'libra-pe')).toBeCloseTo(3085.9600325760794, 10);
+    });
+    test('1 caloria-alimentar → btu ≈ 3.965666831390919', () => {
+        expect(converter.convert(1, 'caloria-alimentar', 'btu')).toBeCloseTo(3.965666831390919, 10);
+    });
+    test('1 libra-pe → joule ≈ 1.3558179483314', () => {
+        expect(converter.convert(1, 'libra-pe', 'joule')).toBeCloseTo(1.3558179483314, 10);
+    });
+    test('1 libra-pe → quilojoule ≈ 0.001355817948331', () => {
+        expect(converter.convert(1, 'libra-pe', 'quilojoule')).toBeCloseTo(0.001355817948331, 10);
+    });
+    test('1 libra-pe → eletron-volt ≈ 8.462350027827206e+18', () => {
+        expect(converter.convert(1, 'libra-pe', 'eletron-volt')).toBeCloseTo(8.462350027827206e+18, 10);
+    });
+    test('1 libra-pe → caloria-termica ≈ 0.324048266809608', () => {
+        expect(converter.convert(1, 'libra-pe', 'caloria-termica')).toBeCloseTo(0.324048266809608, 10);
+    });
+    test('1 libra-pe → caloria-alimentar ≈ 0.00032404826681', () => {
+        expect(converter.convert(1, 'libra-pe', 'caloria-alimentar')).toBeCloseTo(0.00032404826681, 10);
+    });
+    test('1 libra-pe → libra-pe ≈ 1.0', () => {
+        expect(converter.convert(1, 'libra-pe', 'libra-pe')).toBeCloseTo(1.0, 10);
+    });
+    test('1 libra-pe → btu ≈ 0.001285067463457', () => {
+        expect(converter.convert(1, 'libra-pe', 'btu')).toBeCloseTo(0.001285067463457, 10);
+    });
+    test('1 btu → joule ≈ 1055.05585262', () => {
+        expect(converter.convert(1, 'btu', 'joule')).toBeCloseTo(1055.05585262, 10);
+    });
+    test('1 btu → quilojoule ≈ 1.05505585262', () => {
+        expect(converter.convert(1, 'btu', 'quilojoule')).toBeCloseTo(1.05505585262, 10);
+    });
+    test('1 btu → eletron-volt ≈ 6.585140678190667e+21', () => {
+        expect(converter.convert(1, 'btu', 'eletron-volt')).toBeCloseTo(6.585140678190667e+21, 10);
+    });
+    test('1 btu → caloria-termica ≈ 252.1644007217973', () => {
+        expect(converter.convert(1, 'btu', 'caloria-termica')).toBeCloseTo(252.1644007217973, 10);
+    });
+    test('1 btu → caloria-alimentar ≈ 0.252164400721797', () => {
+        expect(converter.convert(1, 'btu', 'caloria-alimentar')).toBeCloseTo(0.252164400721797, 10);
+    });
+    test('1 btu → libra-pe ≈ 778.1692622659652', () => {
+        expect(converter.convert(1, 'btu', 'libra-pe')).toBeCloseTo(778.1692622659652, 10);
+    });
+    test('1 btu → btu ≈ 1.0', () => {
+        expect(converter.convert(1, 'btu', 'btu')).toBeCloseTo(1.0, 10);
+    });
+});

package/dist/converters/unit-converter/services/length/length.converter.d.ts

@@ -0,0 +1,4 @@
+import { ConverterBaseService } from '../../converter-base';
+export declare class LengthConverter extends ConverterBaseService {
+    constructor();
+}

package/dist/converters/unit-converter/services/length/length.converter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LengthConverter = void 0;
+const converter_base_1 = require("../../converter-base");
+class LengthConverter extends converter_base_1.ConverterBaseService {
+    constructor() {
+        super([
+            // Base: Metro
+            { id: 'angstrom', name: 'Ångström', symbol: 'Å', conversionFactor: 1e-10, isBaseUnit: false },
+            { id: 'micron', name: 'Mícron', symbol: 'µ', conversionFactor: 1e-6, isBaseUnit: false },
+            { id: 'picometro', name: 'Picômetro', symbol: 'pm', conversionFactor: 1e-12, isBaseUnit: false },
+            { id: 'nanometro', name: 'Nanômetro', symbol: 'nm', conversionFactor: 1e-9, isBaseUnit: false },
+            { id: 'micrometro', name: 'Micrômetro', symbol: 'µm', conversionFactor: 1e-6, isBaseUnit: false },
+            { id: 'milimetro', name: 'Milímetro', symbol: 'mm', conversionFactor: 1e-3, isBaseUnit: false },
+            { id: 'centimetro', name: 'Centímetro', symbol: 'cm', conversionFactor: 1e-2, isBaseUnit: false },
+            { id: 'decimetro', name: 'Decímetro', symbol: 'dm', conversionFactor: 1e-1, isBaseUnit: false },
+            { id: 'metro', name: 'Metro', symbol: 'm', conversionFactor: 1, isBaseUnit: true },
+            { id: 'quilometro', name: 'Quilômetro', symbol: 'km', conversionFactor: 1e3, isBaseUnit: false },
+            { id: 'polegada', name: 'Polegada', symbol: 'in', conversionFactor: 0.0254, isBaseUnit: false },
+            { id: 'pes', name: 'Pé', symbol: 'ft', conversionFactor: 0.3048, isBaseUnit: false },
+            { id: 'jarda', name: 'Jarda', symbol: 'yd', conversionFactor: 0.9144, isBaseUnit: false },
+            { id: 'milha', name: 'Milha terrestre', symbol: 'mi', conversionFactor: 1609.344, isBaseUnit: false },
+            { id: 'milha-nautica', name: 'Milha náutica', symbol: 'nmi', conversionFactor: 1852, isBaseUnit: false },
+            { id: 'parsec', name: 'Parsec', symbol: 'pc', conversionFactor: 3.085677581491367e16, isBaseUnit: false },
+            { id: 'distancia-lunar', name: 'Distância lunar média', symbol: 'LD', conversionFactor: 384400000, isBaseUnit: false },
+            { id: 'unidade-astronomica', name: 'Unidade astronômica', symbol: 'au', conversionFactor: 1.495978707e11, isBaseUnit: false },
+            { id: 'ano-luz', name: 'Ano-luz', symbol: 'ly', conversionFactor: 9.4607304725808e15, isBaseUnit: false },
+        ]);
+    }
+}
+exports.LengthConverter = LengthConverter;

package/dist/converters/unit-converter/services/length/length.converter.test.d.ts

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

package/dist/converters/unit-converter/services/length/length.converter.test.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const unit_converter_factory_1 = require("../../unit.converter.factory");
+const factory = new unit_converter_factory_1.UnitConverterFactory();
+const converter = factory.createService('length');
+describe('Conversão completa entre unidades de comprimento', () => {
+    // Testes de conversão para a mesma unidade
+    describe('Conversões para a mesma unidade', () => {
+        test('1 metro → metro ≈ 1.0', () => {
+            expect(converter.convert(1, 'metro', 'metro')).toBeCloseTo(1.0, 10);
+        });
+        test('5 quilômetro → quilômetro ≈ 5.0', () => {
+            expect(converter.convert(5, 'quilometro', 'quilometro')).toBeCloseTo(5.0, 10);
+        });
+        test('100 polegada → polegada ≈ 100.0', () => {
+            expect(converter.convert(100, 'polegada', 'polegada')).toBeCloseTo(100.0, 10);
+        });
+    });
+    // Testes de conversão métrica básica
+    describe('Conversões métricas básicas', () => {
+        test('1000 milímetro → metro ≈ 1.0', () => {
+            expect(converter.convert(1000, 'milimetro', 'metro')).toBeCloseTo(1.0, 10);
+        });
+        test('100 centímetro → metro ≈ 1.0', () => {
+            expect(converter.convert(100, 'centimetro', 'metro')).toBeCloseTo(1.0, 10);
+        });
+        test('10 decímetro → metro ≈ 1.0', () => {
+            expect(converter.convert(10, 'decimetro', 'metro')).toBeCloseTo(1.0, 10);
+        });
+        test('1 quilômetro → metro ≈ 1000.0', () => {
+            expect(converter.convert(1, 'quilometro', 'metro')).toBeCloseTo(1000.0, 10);
+        });
+        test('1 metro → milímetro ≈ 1000.0', () => {
+            expect(converter.convert(1, 'metro', 'milimetro')).toBeCloseTo(1000.0, 10);
+        });
+        test('1 metro → centímetro ≈ 100.0', () => {
+            expect(converter.convert(1, 'metro', 'centimetro')).toBeCloseTo(100.0, 10);
+        });
+        test('1 metro → quilômetro ≈ 0.001', () => {
+            expect(converter.convert(1, 'metro', 'quilometro')).toBeCloseTo(0.001, 10);
+        });
+    });
+    // Testes de unidades muito pequenas
+    describe('Conversões de unidades muito pequenas', () => {
+        test('1 metro → angstrom ≈ 1e10', () => {
+            expect(converter.convert(1, 'metro', 'angstrom')).toBeCloseTo(1e10, 5);
+        });
+        test('1 metro → picometro ≈ 1e12', () => {
+            expect(converter.convert(1, 'metro', 'picometro')).toBeCloseTo(1e12, 5);
+        });
+        test('1 metro → nanometro ≈ 1e9', () => {
+            expect(converter.convert(1, 'metro', 'nanometro')).toBeCloseTo(1e9, 5);
+        });
+        test('1 metro → micrometro ≈ 1e6', () => {
+            expect(converter.convert(1, 'metro', 'micrometro')).toBeCloseTo(1e6, 5);
+        });
+        test('1 metro → micron ≈ 1e6', () => {
+            expect(converter.convert(1, 'metro', 'micron')).toBeCloseTo(1e6, 5);
+        });
+        test('1000 nanometro → micrometro ≈ 1.0', () => {
+            expect(converter.convert(1000, 'nanometro', 'micrometro')).toBeCloseTo(1.0, 10);
+        });
+    });
+    // Testes de unidades imperiais
+    describe('Conversões de unidades imperiais', () => {
+        test('1 polegada → centímetro ≈ 2.54', () => {
+            expect(converter.convert(1, 'polegada', 'centimetro')).toBeCloseTo(2.54, 10);
+        });
+        test('1 pé → metro ≈ 0.3048', () => {
+            expect(converter.convert(1, 'pes', 'metro')).toBeCloseTo(0.3048, 10);
+        });
+        test('1 jarda → metro ≈ 0.9144', () => {
+            expect(converter.convert(1, 'jarda', 'metro')).toBeCloseTo(0.9144, 10);
+        });
+        test('1 milha → quilômetro ≈ 1.609344', () => {
+            expect(converter.convert(1, 'milha', 'quilometro')).toBeCloseTo(1.609344, 6);
+        });
+        test('12 polegada → pé ≈ 1.0', () => {
+            expect(converter.convert(12, 'polegada', 'pes')).toBeCloseTo(1.0, 10);
+        });
+        test('3 pé → jarda ≈ 1.0', () => {
+            expect(converter.convert(3, 'pes', 'jarda')).toBeCloseTo(1.0, 10);
+        });
+        test('1760 jarda → milha ≈ 1.0', () => {
+            expect(converter.convert(1760, 'jarda', 'milha')).toBeCloseTo(1.0, 8);
+        });
+    });
+    // Testes de unidades náuticas e astronômicas
+    describe('Conversões de unidades especiais', () => {
+        test('1 milha-nautica → metro ≈ 1852.0', () => {
+            expect(converter.convert(1, 'milha-nautica', 'metro')).toBeCloseTo(1852.0, 10);
+        });
+        test('1 unidade-astronomica → quilômetro ≈ 149597870.7', () => {
+            expect(converter.convert(1, 'unidade-astronomica', 'quilometro')).toBeCloseTo(149597870.7, 1);
+        });
+        test('1 ano-luz → unidade-astronomica ≈ 63241.08', () => {
+            expect(converter.convert(1, 'ano-luz', 'unidade-astronomica')).toBeCloseTo(63241.08, 0);
+        });
+        test('1 parsec → ano-luz ≈ 3.2616', () => {
+            expect(converter.convert(1, 'parsec', 'ano-luz')).toBeCloseTo(3.2616, 3);
+        });
+        test('1 distancia-lunar → quilômetro ≈ 384400.0', () => {
+            expect(converter.convert(1, 'distancia-lunar', 'quilometro')).toBeCloseTo(384400.0, 1);
+        });
+    });
+    // Testes com valores decimais
+    describe('Conversões com valores decimais', () => {
+        test('0.5 metro → centímetro ≈ 50.0', () => {
+            expect(converter.convert(0.5, 'metro', 'centimetro')).toBeCloseTo(50.0, 10);
+        });
+        test('2.5 quilômetro → metro ≈ 2500.0', () => {
+            expect(converter.convert(2.5, 'quilometro', 'metro')).toBeCloseTo(2500.0, 10);
+        });
+        test('0.1 polegada → milímetro ≈ 2.54', () => {
+            expect(converter.convert(0.1, 'polegada', 'milimetro')).toBeCloseTo(2.54, 10);
+        });
+    });
+    // Testes com valores grandes
+    describe('Conversões com valores grandes', () => {
+        test('1000000 metro → quilômetro ≈ 1000.0', () => {
+            expect(converter.convert(1000000, 'metro', 'quilometro')).toBeCloseTo(1000.0, 10);
+        });
+        test('100 quilômetro → milha ≈ 62.137', () => {
+            expect(converter.convert(100, 'quilometro', 'milha')).toBeCloseTo(62.137, 2);
+        });
+    });
+    // Testes de casos extremos
+    describe('Casos extremos', () => {
+        test('0 metro → qualquer unidade ≈ 0.0', () => {
+            expect(converter.convert(0, 'metro', 'quilometro')).toBeCloseTo(0.0, 10);
+            expect(converter.convert(0, 'metro', 'centimetro')).toBeCloseTo(0.0, 10);
+            expect(converter.convert(0, 'metro', 'polegada')).toBeCloseTo(0.0, 10);
+        });
+        test('Conversões muito pequenas', () => {
+            expect(converter.convert(1, 'angstrom', 'metro')).toBeCloseTo(1e-10, 15);
+            expect(converter.convert(1, 'picometro', 'metro')).toBeCloseTo(1e-12, 15);
+        });
+        test('Conversões astronômicas grandes', () => {
+            expect(converter.convert(1, 'parsec', 'metro')).toBeCloseTo(3.085677581491367e16, 10);
+            expect(converter.convert(1, 'ano-luz', 'metro')).toBeCloseTo(9.4607304725808e15, 10);
+        });
+    });
+    // Testes de conversões bidirecionais
+    describe('Conversões bidirecionais', () => {
+        test('Conversão bidirecional: metro ↔ polegada', () => {
+            const metros = 1;
+            const polegadas = converter.convert(metros, 'metro', 'polegada');
+            const metrosNovamente = converter.convert(polegadas, 'polegada', 'metro');
+            expect(metrosNovamente).toBeCloseTo(metros, 10);
+        });
+        test('Conversão bidirecional: quilômetro ↔ milha', () => {
+            const quilometros = 10;
+            const milhas = converter.convert(quilometros, 'quilometro', 'milha');
+            const quilometrosNovamente = converter.convert(milhas, 'milha', 'quilometro');
+            expect(quilometrosNovamente).toBeCloseTo(quilometros, 8);
+        });
+        test('Conversão bidirecional: nanometro ↔ micrometro', () => {
+            const nanometros = 5000;
+            const micrometros = converter.convert(nanometros, 'nanometro', 'micrometro');
+            const nanometrosNovamente = converter.convert(micrometros, 'micrometro', 'nanometro');
+            expect(nanometrosNovamente).toBeCloseTo(nanometros, 10);
+        });
+    });
+    // Testes de precisão para conversões complexas
+    describe('Testes de precisão', () => {
+        test('Conversão de alta precisão: angstrom → parsec', () => {
+            const angstroms = 1e20;
+            const parsecs = converter.convert(angstroms, 'angstrom', 'parsec');
+            expect(parsecs).toBeCloseTo(3.2408e-7, 10);
+        });
+        test('Múltiplas conversões em cadeia mantêm precisão', () => {
+            const valorInicial = 100;
+            let resultado = valorInicial;
+            // metro → km → milha → jarda → pé → polegada → cm → mm → metro
+            resultado = converter.convert(resultado, 'metro', 'quilometro');
+            resultado = converter.convert(resultado, 'quilometro', 'milha');
+            resultado = converter.convert(resultado, 'milha', 'jarda');
+            resultado = converter.convert(resultado, 'jarda', 'pes');
+            resultado = converter.convert(resultado, 'pes', 'polegada');
+            resultado = converter.convert(resultado, 'polegada', 'centimetro');
+            resultado = converter.convert(resultado, 'centimetro', 'milimetro');
+            resultado = converter.convert(resultado, 'milimetro', 'metro');
+            expect(resultado).toBeCloseTo(valorInicial, 6);
+        });
+    });
+});

package/dist/converters/unit-converter/services/power/power.converter.d.ts

@@ -0,0 +1,4 @@
+import { ConverterBaseService } from '../../converter-base';
+export declare class PowerConverter extends ConverterBaseService {
+    constructor();
+}

package/dist/converters/unit-converter/services/power/power.converter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerConverter = void 0;
+const converter_base_1 = require("../../converter-base");
+class PowerConverter extends converter_base_1.ConverterBaseService {
+    constructor() {
+        super([
+            // Base: Watt
+            { id: 'watt', name: 'Watt', symbol: 'W', conversionFactor: 1, isBaseUnit: true },
+            { id: 'quilowatt', name: 'Quilowatt', symbol: 'kW', conversionFactor: 1000, isBaseUnit: false },
+            { id: 'cavalo-vapor-eua', name: 'Cavalo-vapor (EUA)', symbol: 'hp (EUA)', conversionFactor: 745.69987158227022, isBaseUnit: false },
+            { id: 'libra-pe-por-minuto', name: 'Libra-pé por minuto', symbol: 'lbf·ft/min', conversionFactor: 0.0225969658, isBaseUnit: false },
+            { id: 'btu-por-minuto', name: 'BTU por minuto', symbol: 'BTU/min', conversionFactor: 17.5842666667, isBaseUnit: false },
+        ]);
+    }
+}
+exports.PowerConverter = PowerConverter;

package/dist/converters/unit-converter/services/power/power.converter.test.d.ts

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