devtoolz-library 1.0.0

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

@@ -0,0 +1,295 @@
+"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('volume');
+describe('Conversão completa entre unidades de volume', () => {
+    // Testes de conversão para a mesma unidade
+    describe('Conversões para a mesma unidade', () => {
+        test('1000 mililitro → mililitro ≈ 1000.0', () => {
+            expect(converter.convert(1000, 'mililitro', 'mililitro')).toBeCloseTo(1000.0, 10);
+        });
+        test('5 litro → litro ≈ 5.0', () => {
+            expect(converter.convert(5, 'litro', 'litro')).toBeCloseTo(5.0, 10);
+        });
+        test('2.5 metro-cubico → metro-cubico ≈ 2.5', () => {
+            expect(converter.convert(2.5, 'metro-cubico', 'metro-cubico')).toBeCloseTo(2.5, 10);
+        });
+    });
+    // Testes de conversão métrica básica
+    describe('Conversões métricas básicas', () => {
+        test('1000 mililitro → litro ≈ 1.0', () => {
+            expect(converter.convert(1000, 'mililitro', 'litro')).toBeCloseTo(1.0, 10);
+        });
+        test('1 litro → mililitro ≈ 1000.0', () => {
+            expect(converter.convert(1, 'litro', 'mililitro')).toBeCloseTo(1000.0, 10);
+        });
+        test('10 centilitro → mililitro ≈ 100.0', () => {
+            expect(converter.convert(10, 'centilitro', 'mililitro')).toBeCloseTo(100.0, 10);
+        });
+        test('100 mililitro → decilitro ≈ 1.0', () => {
+            expect(converter.convert(100, 'mililitro', 'decilitro')).toBeCloseTo(1.0, 10);
+        });
+        test('1000 litro → hectolitro ≈ 10.0', () => {
+            expect(converter.convert(1000, 'litro', 'hectolitro')).toBeCloseTo(10.0, 10);
+        });
+        test('1 hectolitro → litro ≈ 100.0', () => {
+            expect(converter.convert(1, 'hectolitro', 'litro')).toBeCloseTo(100.0, 10);
+        });
+        test('100 centilitro → litro ≈ 1.0', () => {
+            expect(converter.convert(100, 'centilitro', 'litro')).toBeCloseTo(1.0, 10);
+        });
+        test('10 decilitro → litro ≈ 1.0', () => {
+            expect(converter.convert(10, 'decilitro', 'litro')).toBeCloseTo(1.0, 10);
+        });
+    });
+    // Testes de conversão cúbicas métricas
+    describe('Conversões de unidades cúbicas métricas', () => {
+        test('1 mililitro → milimetro-cubico ≈ 1000.0', () => {
+            expect(converter.convert(1, 'mililitro', 'milimetro-cubico')).toBeCloseTo(1000.0, 10);
+        });
+        test('1 mililitro → centimetro-cubico ≈ 1.0', () => {
+            expect(converter.convert(1, 'mililitro', 'centimetro-cubico')).toBeCloseTo(1.0, 10);
+        });
+        test('1 litro → decimetro-cubico ≈ 1.0', () => {
+            expect(converter.convert(1, 'litro', 'decimetro-cubico')).toBeCloseTo(1.0, 10);
+        });
+        test('1 metro-cubico → litro ≈ 1000.0', () => {
+            expect(converter.convert(1, 'metro-cubico', 'litro')).toBeCloseTo(1000.0, 10);
+        });
+        test('1000 centimetro-cubico → litro ≈ 1.0', () => {
+            expect(converter.convert(1000, 'centimetro-cubico', 'litro')).toBeCloseTo(1.0, 10);
+        });
+        test('1 decimetro-cubico → mililitro ≈ 1000.0', () => {
+            expect(converter.convert(1, 'decimetro-cubico', 'mililitro')).toBeCloseTo(1000.0, 10);
+        });
+    });
+    // Testes de conversão de medidas culinárias americanas
+    describe('Conversões de medidas culinárias americanas', () => {
+        test('3 colher-cha-eua → colher-sopa-eua ≈ 1.0', () => {
+            expect(converter.convert(3, 'colher-cha-eua', 'colher-sopa-eua')).toBeCloseTo(1.0, 8);
+        });
+        test('2 colher-sopa-eua → onca-fluida-eua ≈ 1.0', () => {
+            expect(converter.convert(2, 'colher-sopa-eua', 'onca-fluida-eua')).toBeCloseTo(1.0, 8);
+        });
+        test('8 onca-fluida-eua → xicara-eua ≈ 1.0', () => {
+            expect(converter.convert(8, 'onca-fluida-eua', 'xicara-eua')).toBeCloseTo(1.0, 8);
+        });
+        test('2 xicara-eua → pinta-eua ≈ 1.0', () => {
+            expect(converter.convert(2, 'xicara-eua', 'pinta-eua')).toBeCloseTo(1.0, 8);
+        });
+        test('2 pinta-eua → quarto-eua ≈ 1.0', () => {
+            expect(converter.convert(2, 'pinta-eua', 'quarto-eua')).toBeCloseTo(1.0, 8);
+        });
+        test('4 quarto-eua → galao-liquido-eua ≈ 1.0', () => {
+            expect(converter.convert(4, 'quarto-eua', 'galao-liquido-eua')).toBeCloseTo(1.0, 8);
+        });
+        test('1 colher-cha-eua → mililitro ≈ 4.929', () => {
+            expect(converter.convert(1, 'colher-cha-eua', 'mililitro')).toBeCloseTo(4.92892159375, 8);
+        });
+        test('1 colher-sopa-eua → mililitro ≈ 14.787', () => {
+            expect(converter.convert(1, 'colher-sopa-eua', 'mililitro')).toBeCloseTo(14.78676478125, 8);
+        });
+        test('1 xicara-eua → mililitro ≈ 236.588', () => {
+            expect(converter.convert(1, 'xicara-eua', 'mililitro')).toBeCloseTo(236.5882365, 6);
+        });
+        test('1 galao-liquido-eua → litro ≈ 3.785', () => {
+            expect(converter.convert(1, 'galao-liquido-eua', 'litro')).toBeCloseTo(3.785411784, 8);
+        });
+    });
+    // Testes de conversão de medidas culinárias imperiais
+    describe('Conversões de medidas culinárias imperiais', () => {
+        test('3 colher-cha-imperial → colher-sopa-imperial ≈ 1.0', () => {
+            expect(converter.convert(3, 'colher-cha-imperial', 'colher-sopa-imperial')).toBeCloseTo(0.9999983106395919, 8);
+        });
+        test('20 onca-fluida-imperial → pinta-imperial ≈ 1.0', () => {
+            expect(converter.convert(20, 'onca-fluida-imperial', 'pinta-imperial')).toBeCloseTo(1.0, 8);
+        });
+        test('2 pinta-imperial → quarto-imperial ≈ 1.0', () => {
+            expect(converter.convert(2, 'pinta-imperial', 'quarto-imperial')).toBeCloseTo(1.0, 8);
+        });
+        test('4 quarto-imperial → galao-imperial ≈ 1.0', () => {
+            expect(converter.convert(4, 'quarto-imperial', 'galao-imperial')).toBeCloseTo(1.0, 8);
+        });
+        test('1 colher-cha-imperial → mililitro ≈ 5.919', () => {
+            expect(converter.convert(1, 'colher-cha-imperial', 'mililitro')).toBeCloseTo(5.91939, 5);
+        });
+        test('1 onca-fluida-imperial → mililitro ≈ 28.413', () => {
+            expect(converter.convert(1, 'onca-fluida-imperial', 'mililitro')).toBeCloseTo(28.4130625, 7);
+        });
+        test('1 galao-imperial → litro ≈ 4.546', () => {
+            expect(converter.convert(1, 'galao-imperial', 'litro')).toBeCloseTo(4.54609, 5);
+        });
+    });
+    // Testes de conversão de unidades cúbicas imperiais
+    describe('Conversões de unidades cúbicas imperiais', () => {
+        test('1 polegada-cubica → mililitro ≈ 16.387', () => {
+            expect(converter.convert(1, 'polegada-cubica', 'mililitro')).toBeCloseTo(16.387064, 6);
+        });
+        test('1728 polegada-cubica → pe-cubico ≈ 1.0', () => {
+            expect(converter.convert(1728, 'polegada-cubica', 'pe-cubico')).toBeCloseTo(1.0, 6);
+        });
+        test('27 pe-cubico → jarda-cubica ≈ 1.0', () => {
+            expect(converter.convert(27, 'pe-cubico', 'jarda-cubica')).toBeCloseTo(1.0, 6);
+        });
+        test('1 pe-cubico → litro ≈ 28.317', () => {
+            expect(converter.convert(1, 'pe-cubico', 'litro')).toBeCloseTo(28.316846592, 6);
+        });
+        test('1 jarda-cubica → metro-cubico ≈ 0.765', () => {
+            expect(converter.convert(1, 'jarda-cubica', 'metro-cubico')).toBeCloseTo(0.764554857984, 6);
+        });
+    });
+    // Testes de comparação entre sistemas americano e imperial
+    describe('Comparações entre sistemas americano e imperial', () => {
+        test('1 galao-liquido-eua vs 1 galao-imperial', () => {
+            const galEUA = converter.convert(1, 'galao-liquido-eua', 'litro');
+            const galImperial = converter.convert(1, 'galao-imperial', 'litro');
+            expect(galImperial).toBeGreaterThan(galEUA);
+            expect(galImperial / galEUA).toBeCloseTo(1.201, 2); // Imperial é ~20% maior
+        });
+        test('1 pinta-eua vs 1 pinta-imperial', () => {
+            const pintaEUA = converter.convert(1, 'pinta-eua', 'mililitro');
+            const pintaImperial = converter.convert(1, 'pinta-imperial', 'mililitro');
+            expect(pintaImperial).toBeGreaterThan(pintaEUA);
+            expect(pintaImperial / pintaEUA).toBeCloseTo(1.201, 2);
+        });
+        test('1 onca-fluida-eua vs 1 onca-fluida-imperial', () => {
+            const oncaEUA = converter.convert(1, 'onca-fluida-eua', 'mililitro');
+            const oncaImperial = converter.convert(1, 'onca-fluida-imperial', 'mililitro');
+            expect(oncaEUA).toBeGreaterThan(oncaImperial);
+            expect(oncaEUA / oncaImperial).toBeCloseTo(1.04, 2);
+        });
+    });
+    // Testes de conversões para culinária
+    describe('Conversões práticas para culinária', () => {
+        test('1 xicara-eua → centilitro ≈ 23.659', () => {
+            expect(converter.convert(1, 'xicara-eua', 'centilitro')).toBeCloseTo(23.659, 2);
+        });
+        test('250 mililitro → xicara-eua ≈ 1.057', () => {
+            expect(converter.convert(250, 'mililitro', 'xicara-eua')).toBeCloseTo(1.057, 2);
+        });
+        test('1 colher-sopa-eua → colher-cha-eua ≈ 3.0', () => {
+            expect(converter.convert(1, 'colher-sopa-eua', 'colher-cha-eua')).toBeCloseTo(3.0, 8);
+        });
+        test('15 mililitro → colher-sopa-eua ≈ 1.014', () => {
+            expect(converter.convert(15, 'mililitro', 'colher-sopa-eua')).toBeCloseTo(1.014, 2);
+        });
+        test('5 mililitro → colher-cha-eua ≈ 1.014', () => {
+            expect(converter.convert(5, 'mililitro', 'colher-cha-eua')).toBeCloseTo(1.014, 2);
+        });
+    });
+    // Testes de volumes grandes
+    describe('Conversões de volumes grandes', () => {
+        test('1 metro-cubico → galao-liquido-eua ≈ 264.172', () => {
+            expect(converter.convert(1, 'metro-cubico', 'galao-liquido-eua')).toBeCloseTo(264.172, 2);
+        });
+        test('1 metro-cubico → galao-imperial ≈ 219.969', () => {
+            expect(converter.convert(1, 'metro-cubico', 'galao-imperial')).toBeCloseTo(219.969, 2);
+        });
+        test('1 acre-pe-cubico → metro-cubico ≈ 1233481.837', () => {
+            expect(converter.convert(1, 'acre-pe-cubico', 'metro-cubico')).toBeCloseTo(1233.4818365478402, 0);
+        });
+        test('1 hectolitro → metro-cubico ≈ 0.1', () => {
+            expect(converter.convert(1, 'hectolitro', 'metro-cubico')).toBeCloseTo(0.1, 10);
+        });
+    });
+    // Testes de conversões bidirecionais
+    describe('Conversões bidirecionais', () => {
+        test('Conversão bidirecional: litro ↔ galao-liquido-eua', () => {
+            const litros = 10;
+            const galoesEUA = converter.convert(litros, 'litro', 'galao-liquido-eua');
+            const litrosNovamente = converter.convert(galoesEUA, 'galao-liquido-eua', 'litro');
+            expect(litrosNovamente).toBeCloseTo(litros, 8);
+        });
+        test('Conversão bidirecional: mililitro ↔ onca-fluida-eua', () => {
+            const mililitros = 100;
+            const oncasEUA = converter.convert(mililitros, 'mililitro', 'onca-fluida-eua');
+            const mililitrosNovamente = converter.convert(oncasEUA, 'onca-fluida-eua', 'mililitro');
+            expect(mililitrosNovamente).toBeCloseTo(mililitros, 8);
+        });
+        test('Conversão bidirecional: metro-cubico ↔ pe-cubico', () => {
+            const metrosCubicos = 2;
+            const pesCubicos = converter.convert(metrosCubicos, 'metro-cubico', 'pe-cubico');
+            const metrosCubicosNovamente = converter.convert(pesCubicos, 'pe-cubico', 'metro-cubico');
+            expect(metrosCubicosNovamente).toBeCloseTo(metrosCubicos, 6);
+        });
+    });
+    // Testes com valores decimais
+    describe('Conversões com valores decimais', () => {
+        test('0.5 litro → mililitro ≈ 500.0', () => {
+            expect(converter.convert(0.5, 'litro', 'mililitro')).toBeCloseTo(500.0, 10);
+        });
+        test('2.5 xicara-eua → mililitro ≈ 591.471', () => {
+            expect(converter.convert(2.5, 'xicara-eua', 'mililitro')).toBeCloseTo(591.471, 2);
+        });
+        test('0.25 galao-liquido-eua → litro ≈ 0.946', () => {
+            expect(converter.convert(0.25, 'galao-liquido-eua', 'litro')).toBeCloseTo(0.946, 2);
+        });
+        test('1.5 colher-sopa-eua → mililitro ≈ 22.180', () => {
+            expect(converter.convert(1.5, 'colher-sopa-eua', 'mililitro')).toBeCloseTo(22.180, 2);
+        });
+    });
+    // Testes de casos extremos
+    describe('Casos extremos', () => {
+        test('0 volume → qualquer unidade ≈ 0.0', () => {
+            expect(converter.convert(0, 'litro', 'mililitro')).toBeCloseTo(0.0, 10);
+            expect(converter.convert(0, 'galao-liquido-eua', 'litro')).toBeCloseTo(0.0, 10);
+            expect(converter.convert(0, 'metro-cubico', 'pe-cubico')).toBeCloseTo(0.0, 10);
+        });
+        test('Conversões muito pequenas', () => {
+            expect(converter.convert(0.001, 'mililitro', 'milimetro-cubico')).toBeCloseTo(1, 10);
+            expect(converter.convert(1, 'mililitro', 'centimetro-cubico')).toBeCloseTo(1, 10);
+        });
+        test('Conversões muito grandes', () => {
+            expect(converter.convert(1000000, 'litro', 'metro-cubico')).toBeCloseTo(1000.0, 5);
+            expect(converter.convert(1000000, 'mililitro', 'hectolitro')).toBeCloseTo(10.0, 5);
+        });
+    });
+    // Testes de conversões em cadeia
+    describe('Conversões em cadeia', () => {
+        test('Múltiplas conversões mantêm precisão', () => {
+            const valorInicial = 100;
+            let resultado = valorInicial;
+            // mililitro → litro → galao-eua → xicara-eua → onca-eua → colher-sopa-eua → mililitro
+            resultado = converter.convert(resultado, 'mililitro', 'litro');
+            resultado = converter.convert(resultado, 'litro', 'galao-liquido-eua');
+            resultado = converter.convert(resultado, 'galao-liquido-eua', 'xicara-eua');
+            resultado = converter.convert(resultado, 'xicara-eua', 'onca-fluida-eua');
+            resultado = converter.convert(resultado, 'onca-fluida-eua', 'colher-sopa-eua');
+            resultado = converter.convert(resultado, 'colher-sopa-eua', 'mililitro');
+            expect(resultado).toBeCloseTo(valorInicial, 6);
+        });
+        test('Conversão métrica em cadeia', () => {
+            const valorInicial = 1;
+            let resultado = valorInicial;
+            // metro-cubico → litro → mililitro → centimetro-cubico → decimetro-cubico → metro-cubico
+            resultado = converter.convert(resultado, 'metro-cubico', 'litro');
+            resultado = converter.convert(resultado, 'litro', 'mililitro');
+            resultado = converter.convert(resultado, 'mililitro', 'centimetro-cubico');
+            resultado = converter.convert(resultado, 'centimetro-cubico', 'decimetro-cubico');
+            resultado = converter.convert(resultado, 'decimetro-cubico', 'metro-cubico');
+            expect(resultado).toBeCloseTo(valorInicial, 8);
+        });
+    });
+    // Testes de precisão específica
+    describe('Testes de precisão específica', () => {
+        test('Galão seco vs líquido (EUA)', () => {
+            const galaoLiquido = converter.convert(1, 'galao-liquido-eua', 'litro');
+            const galaoSeco = converter.convert(1, 'galao-seco-eua', 'litro');
+            expect(galaoSeco).toBeGreaterThan(galaoLiquido);
+            expect(galaoSeco / galaoLiquido).toBeCloseTo(1.164, 2);
+        });
+        test('Relação exata entre unidades cúbicas', () => {
+            // 1 m³ = 1000 L = 1000000 mL = 1000000 cm³
+            expect(converter.convert(1, 'metro-cubico', 'litro')).toBeCloseTo(1000.0, 10);
+            expect(converter.convert(1, 'metro-cubico', 'mililitro')).toBeCloseTo(1000000.0, 5);
+            expect(converter.convert(1, 'metro-cubico', 'centimetro-cubico')).toBeCloseTo(1000000.0, 5);
+        });
+        test('Relação entre colheres (EUA)', () => {
+            // 1 Tbsp = 3 tsp exatamente
+            const colherSopa = converter.convert(1, 'colher-sopa-eua', 'mililitro');
+            const colherCha = converter.convert(3, 'colher-cha-eua', 'mililitro');
+            expect(colherSopa).toBeCloseTo(colherCha, 10);
+        });
+    });
+});

package/dist/converters/unit-converter/services/weight-mass/weight-mass.converter.d.ts

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

package/dist/converters/unit-converter/services/weight-mass/weight-mass.converter.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeightMassConverter = void 0;
+const converter_base_1 = require("../../converter-base");
+class WeightMassConverter extends converter_base_1.ConverterBaseService {
+    constructor() {
+        super([
+            // Base: grama
+            { id: 'micrograma', name: 'Micrograma', symbol: 'µg', conversionFactor: 0.000001, isBaseUnit: false },
+            { id: 'miligrama', name: 'Miligrama', symbol: 'mg', conversionFactor: 0.001, isBaseUnit: false },
+            { id: 'centigrama', name: 'Centigrama', symbol: 'cg', conversionFactor: 0.01, isBaseUnit: false },
+            { id: 'decigrama', name: 'Decigrama', symbol: 'dg', conversionFactor: 0.1, isBaseUnit: false },
+            { id: 'grama', name: 'Grama', symbol: 'g', conversionFactor: 1, isBaseUnit: true },
+            { id: 'decagrama', name: 'Decagrama', symbol: 'dag', conversionFactor: 10, isBaseUnit: false },
+            { id: 'hectograma', name: 'Hectograma', symbol: 'hg', conversionFactor: 100, isBaseUnit: false },
+            { id: 'quilograma', name: 'Quilograma', symbol: 'kg', conversionFactor: 1000, isBaseUnit: false },
+            { id: 'tonelada-metrica', name: 'Tonelada Métrica', symbol: 't', conversionFactor: 1000000, isBaseUnit: false },
+            { id: 'grao', name: 'Grão', symbol: 'gr', conversionFactor: 0.06479891, isBaseUnit: false },
+            { id: 'quilate', name: 'Quilate (métrico)', symbol: 'ct', conversionFactor: 0.2, isBaseUnit: false },
+            { id: 'onca', name: 'Onça (avoirdupois)', symbol: 'oz', conversionFactor: 28.349523125, isBaseUnit: false },
+            { id: 'libra', name: 'Libra (avoirdupois)', symbol: 'lb', conversionFactor: 453.59237, isBaseUnit: false },
+            { id: 'pedra', name: 'Pedra', symbol: 'st', conversionFactor: 6350.29318, isBaseUnit: false },
+            { id: 'tonelada-curta', name: 'Tonelada Curta (EUA)', symbol: 'sh.t', conversionFactor: 907184.74, isBaseUnit: false },
+            { id: 'tonelada-longa', name: 'Tonelada Longa (Reino Unido)', symbol: 'l.t', conversionFactor: 1016046.9088, isBaseUnit: false },
+            { id: 'quintal', name: 'Quintal (métrico)', symbol: 'q', conversionFactor: 100000, isBaseUnit: false },
+        ]);
+    }
+}
+exports.WeightMassConverter = WeightMassConverter;

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

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

package/dist/converters/unit-converter/services/weight-mass/weight-mass.converter.test.js

@@ -0,0 +1,218 @@
+"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('weight-mass');
+describe('Conversão completa entre unidades de massa', () => {
+    // Testes de conversão para a mesma unidade
+    describe('Conversões para a mesma unidade', () => {
+        test('1 grama → grama ≈ 1.0', () => {
+            expect(converter.convert(1, 'grama', 'grama')).toBeCloseTo(1.0, 10);
+        });
+        test('1 quilograma → quilograma ≈ 1.0', () => {
+            expect(converter.convert(1, 'quilograma', 'quilograma')).toBeCloseTo(1.0, 10);
+        });
+        test('1 miligrama → miligrama ≈ 1.0', () => {
+            expect(converter.convert(1, 'miligrama', 'miligrama')).toBeCloseTo(1.0, 10);
+        });
+        test('1 tonelada-metrica → tonelada-metrica ≈ 1.0', () => {
+            expect(converter.convert(1, 'tonelada-metrica', 'tonelada-metrica')).toBeCloseTo(1.0, 10);
+        });
+    });
+    // Conversões básicas do sistema métrico
+    describe('Conversões do sistema métrico - unidade base: grama', () => {
+        test('1 micrograma → grama = 0.000001', () => {
+            expect(converter.convert(1, 'micrograma', 'grama')).toBeCloseTo(0.000001, 10);
+        });
+        test('1 miligrama → grama = 0.001', () => {
+            expect(converter.convert(1, 'miligrama', 'grama')).toBeCloseTo(0.001, 10);
+        });
+        test('1 centigrama → grama = 0.01', () => {
+            expect(converter.convert(1, 'centigrama', 'grama')).toBeCloseTo(0.01, 10);
+        });
+        test('1 decigrama → grama = 0.1', () => {
+            expect(converter.convert(1, 'decigrama', 'grama')).toBeCloseTo(0.1, 10);
+        });
+        test('1 decagrama → grama = 10', () => {
+            expect(converter.convert(1, 'decagrama', 'grama')).toBeCloseTo(10, 10);
+        });
+        test('1 hectograma → grama = 100', () => {
+            expect(converter.convert(1, 'hectograma', 'grama')).toBeCloseTo(100, 10);
+        });
+        test('1 quilograma → grama = 1000', () => {
+            expect(converter.convert(1, 'quilograma', 'grama')).toBeCloseTo(1000, 10);
+        });
+        test('1 tonelada-metrica → grama = 1000000', () => {
+            expect(converter.convert(1, 'tonelada-metrica', 'grama')).toBeCloseTo(1000000, 10);
+        });
+        test('1 quintal → grama = 100000', () => {
+            expect(converter.convert(1, 'quintal', 'grama')).toBeCloseTo(100000, 10);
+        });
+    });
+    // Conversões inversas do sistema métrico
+    describe('Conversões inversas do sistema métrico', () => {
+        test('1 grama → micrograma = 1000000', () => {
+            expect(converter.convert(1, 'grama', 'micrograma')).toBeCloseTo(1000000, 10);
+        });
+        test('1 grama → miligrama = 1000', () => {
+            expect(converter.convert(1, 'grama', 'miligrama')).toBeCloseTo(1000, 10);
+        });
+        test('1 grama → quilograma = 0.001', () => {
+            expect(converter.convert(1, 'grama', 'quilograma')).toBeCloseTo(0.001, 10);
+        });
+        test('1 quilograma → tonelada-metrica = 0.001', () => {
+            expect(converter.convert(1, 'quilograma', 'tonelada-metrica')).toBeCloseTo(0.001, 10);
+        });
+    });
+    // Conversões do sistema imperial/americano
+    describe('Conversões do sistema imperial/americano', () => {
+        test('1 grao → grama ≈ 0.06479891', () => {
+            expect(converter.convert(1, 'grao', 'grama')).toBeCloseTo(0.06479891, 8);
+        });
+        test('1 quilate → grama = 0.2', () => {
+            expect(converter.convert(1, 'quilate', 'grama')).toBeCloseTo(0.2, 10);
+        });
+        test('1 onca → grama ≈ 28.349523125', () => {
+            expect(converter.convert(1, 'onca', 'grama')).toBeCloseTo(28.349523125, 8);
+        });
+        test('1 libra → grama ≈ 453.59237', () => {
+            expect(converter.convert(1, 'libra', 'grama')).toBeCloseTo(453.59237, 8);
+        });
+        test('1 pedra → grama ≈ 6350.29318', () => {
+            expect(converter.convert(1, 'pedra', 'grama')).toBeCloseTo(6350.29318, 8);
+        });
+        test('1 tonelada-curta → grama ≈ 907184.74', () => {
+            expect(converter.convert(1, 'tonelada-curta', 'grama')).toBeCloseTo(907184.74, 6);
+        });
+        test('1 tonelada-longa → grama ≈ 1016046.9088', () => {
+            expect(converter.convert(1, 'tonelada-longa', 'grama')).toBeCloseTo(1016046.9088, 6);
+        });
+    });
+    // Conversões entre unidades imperiais
+    describe('Conversões entre sistemas imperial/americano', () => {
+        test('1 libra → onca = 16', () => {
+            expect(converter.convert(1, 'libra', 'onca')).toBeCloseTo(16, 8);
+        });
+        test('1 pedra → libra = 14', () => {
+            expect(converter.convert(1, 'pedra', 'libra')).toBeCloseTo(14, 8);
+        });
+        test('1 tonelada-curta → libra = 2000', () => {
+            expect(converter.convert(1, 'tonelada-curta', 'libra')).toBeCloseTo(2000, 6);
+        });
+        test('1 tonelada-longa → libra ≈ 2240', () => {
+            expect(converter.convert(1, 'tonelada-longa', 'libra')).toBeCloseTo(2240, 6);
+        });
+    });
+    // Conversões comuns do dia a dia
+    describe('Conversões comuns do cotidiano', () => {
+        test('500 gramas → quilograma = 0.5', () => {
+            expect(converter.convert(500, 'grama', 'quilograma')).toBeCloseTo(0.5, 10);
+        });
+        test('2.5 quilogramas → gramas = 2500', () => {
+            expect(converter.convert(2.5, 'quilograma', 'grama')).toBeCloseTo(2500, 10);
+        });
+        test('100 miligramas → gramas = 0.1', () => {
+            expect(converter.convert(100, 'miligrama', 'grama')).toBeCloseTo(0.1, 10);
+        });
+        test('5 quilates → gramas = 1', () => {
+            expect(converter.convert(5, 'quilate', 'grama')).toBeCloseTo(1, 10);
+        });
+        test('1 libra → quilograma ≈ 0.45359237', () => {
+            expect(converter.convert(1, 'libra', 'quilograma')).toBeCloseTo(0.45359237, 8);
+        });
+        test('10 toneladas métricas → quilogramas = 10000', () => {
+            expect(converter.convert(10, 'tonelada-metrica', 'quilograma')).toBeCloseTo(10000, 10);
+        });
+    });
+    // Testes com valores decimais
+    describe('Conversões com valores decimais', () => {
+        test('0.5 quilograma → grama = 500', () => {
+            expect(converter.convert(0.5, 'quilograma', 'grama')).toBeCloseTo(500, 10);
+        });
+        test('1.25 libras → onças = 20', () => {
+            expect(converter.convert(1.25, 'libra', 'onca')).toBeCloseTo(20, 8);
+        });
+        test('0.001 tonelada-metrica → grama = 1000', () => {
+            expect(converter.convert(0.001, 'tonelada-metrica', 'grama')).toBeCloseTo(1000, 10);
+        });
+        test('2.5 hectogramas → quilograma = 0.25', () => {
+            expect(converter.convert(2.5, 'hectograma', 'quilograma')).toBeCloseTo(0.25, 10);
+        });
+    });
+    // Testes com valores grandes
+    describe('Conversões com valores grandes', () => {
+        test('1000000 miligramas → quilograma = 1', () => {
+            expect(converter.convert(1000000, 'miligrama', 'quilograma')).toBeCloseTo(1, 10);
+        });
+        test('1000 toneladas métricas → quilogramas = 1000000', () => {
+            expect(converter.convert(1000, 'tonelada-metrica', 'quilograma')).toBeCloseTo(1000000, 10);
+        });
+        test('50000 grãos → quilograma ≈ 3.239945', () => {
+            expect(converter.convert(50000, 'grao', 'quilograma')).toBeCloseTo(3.2399455, 6);
+        });
+    });
+    // Testes com valores pequenos
+    describe('Conversões com valores pequenos', () => {
+        test('0.001 grama → miligrama = 1', () => {
+            expect(converter.convert(0.001, 'grama', 'miligrama')).toBeCloseTo(1, 10);
+        });
+        test('0.0001 onça → miligrama ≈ 2.8349523', () => {
+            expect(converter.convert(0.0001, 'onca', 'miligrama')).toBeCloseTo(2.8349523, 7);
+        });
+        test('0.5 micrograma → nanograma = 500', () => {
+            // Assumindo que nanograma seria 0.000000001 se existisse
+            expect(converter.convert(0.5, 'micrograma', 'grama')).toBeCloseTo(0.0000005, 10);
+        });
+    });
+    // Testes de casos extremos
+    describe('Casos extremos', () => {
+        test('0 grama → quilograma = 0', () => {
+            expect(converter.convert(0, 'grama', 'quilograma')).toBe(0);
+        });
+        test('Número muito grande: 999999 quilogramas → tonelada-metrica ≈ 999.999', () => {
+            expect(converter.convert(999999, 'quilograma', 'tonelada-metrica')).toBeCloseTo(999.999, 3);
+        });
+        test('Número muito pequeno: 0.000001 quilograma → micrograma = 1000', () => {
+            expect(converter.convert(0.000001, 'quilograma', 'micrograma')).toBeCloseTo(1000, 10);
+        });
+    });
+    // Testes de precisão
+    describe('Testes de precisão', () => {
+        test('Conversão ida e volta: grama → quilograma → grama', () => {
+            const original = 1500;
+            const converted = converter.convert(original, 'grama', 'quilograma');
+            const backConverted = converter.convert(converted, 'quilograma', 'grama');
+            expect(backConverted).toBeCloseTo(original, 8);
+        });
+        test('Conversão ida e volta: libra → grama → libra', () => {
+            const original = 2.5;
+            const converted = converter.convert(original, 'libra', 'grama');
+            const backConverted = converter.convert(converted, 'grama', 'libra');
+            expect(backConverted).toBeCloseTo(original, 8);
+        });
+        test('Conversão ida e volta: micrograma → tonelada-metrica → micrograma', () => {
+            const original = 5000000000; // 5 bilhões de microgramas
+            const converted = converter.convert(original, 'micrograma', 'tonelada-metrica');
+            const backConverted = converter.convert(converted, 'tonelada-metrica', 'micrograma');
+            expect(backConverted).toBeCloseTo(original, 6);
+        });
+    });
+    // Testes de equivalências conhecidas
+    describe('Equivalências conhecidas', () => {
+        test('1 quilograma = 2.20462 libras (aproximadamente)', () => {
+            expect(converter.convert(1, 'quilograma', 'libra')).toBeCloseTo(2.20462, 5);
+        });
+        test('1 onça = 28.35 gramas (aproximadamente)', () => {
+            expect(converter.convert(1, 'onca', 'grama')).toBeCloseTo(28.35, 2);
+        });
+        test('1 tonelada métrica = 1.10231 tonelada curta (aproximadamente)', () => {
+            expect(converter.convert(1, 'tonelada-metrica', 'tonelada-curta')).toBeCloseTo(1.10231, 5);
+        });
+        test('1 pedra = 6.35 quilogramas (aproximadamente)', () => {
+            expect(converter.convert(1, 'pedra', 'quilograma')).toBeCloseTo(6.35, 2);
+        });
+        test('5 quilates = 1 grama', () => {
+            expect(converter.convert(5, 'quilate', 'grama')).toBeCloseTo(1, 10);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitConverterFactory = void 0;
+const baseFactory_1 = require("../../baseFactory");
+const provider_1 = require("./provider");
+class UnitConverterFactory extends baseFactory_1.BaseFactory {
+    constructor() {
+        super(provider_1.categories);
+    }
+    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.UnitConverterFactory = UnitConverterFactory;