devtoolz-library 1.0.0

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

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const decimal_converter_1 = require("./decimal.converter");
+describe('DecimalSystemConverter', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new decimal_converter_1.DecimalSystemConverter();
+    });
+    describe('fromDecimal', () => {
+        it('deve converter zero para string', () => {
+            expect(converter.fromDecimal(0)).toBe('0');
+        });
+        it('deve converter números positivos para string', () => {
+            expect(converter.fromDecimal(1)).toBe('1');
+            expect(converter.fromDecimal(42)).toBe('42');
+            expect(converter.fromDecimal(123)).toBe('123');
+            expect(converter.fromDecimal(9999)).toBe('9999');
+        });
+        it('deve converter números negativos para string', () => {
+            expect(converter.fromDecimal(-1)).toBe('-1');
+            expect(converter.fromDecimal(-42)).toBe('-42');
+            expect(converter.fromDecimal(-123)).toBe('-123');
+            expect(converter.fromDecimal(-9999)).toBe('-9999');
+        });
+        it('deve converter números decimais para string', () => {
+            expect(converter.fromDecimal(3.14)).toBe('3.14');
+            expect(converter.fromDecimal(0.5)).toBe('0.5');
+            expect(converter.fromDecimal(-2.7)).toBe('-2.7');
+            expect(converter.fromDecimal(123.456)).toBe('123.456');
+        });
+        it('deve lidar com números muito pequenos', () => {
+            expect(converter.fromDecimal(0.000001)).toBe('0.000001');
+            expect(converter.fromDecimal(Number.MIN_VALUE)).toBe('5e-324');
+        });
+        it('deve lidar com números muito grandes', () => {
+            expect(converter.fromDecimal(1000000)).toBe('1000000');
+            expect(converter.fromDecimal(Number.MAX_SAFE_INTEGER)).toBe('9007199254740991');
+            expect(converter.fromDecimal(Number.MAX_VALUE)).toBe('1.7976931348623157e+308');
+        });
+        it('deve lidar com notação científica', () => {
+            expect(converter.fromDecimal(1e6)).toBe('1000000');
+            expect(converter.fromDecimal(1e-6)).toBe('0.000001');
+            expect(converter.fromDecimal(2.5e3)).toBe('2500');
+        });
+        it('deve lidar com valores especiais', () => {
+            expect(converter.fromDecimal(Infinity)).toBe('Infinity');
+            expect(converter.fromDecimal(-Infinity)).toBe('-Infinity');
+            expect(converter.fromDecimal(NaN)).toBe('NaN');
+        });
+        it('deve manter precisão de ponto flutuante', () => {
+            expect(converter.fromDecimal(0.1 + 0.2)).toBe('0.30000000000000004');
+            expect(converter.fromDecimal(9007199254740992)).toBe('9007199254740992');
+        });
+    });
+    describe('toDecimal', () => {
+        it('deve converter string zero para número', () => {
+            expect(converter.toDecimal('0')).toBe(0);
+        });
+        it('deve converter strings numéricas positivas', () => {
+            expect(converter.toDecimal('1')).toBe(1);
+            expect(converter.toDecimal('42')).toBe(42);
+            expect(converter.toDecimal('123')).toBe(123);
+            expect(converter.toDecimal('9999')).toBe(9999);
+        });
+        it('deve converter strings numéricas negativas', () => {
+            expect(converter.toDecimal('-1')).toBe(-1);
+            expect(converter.toDecimal('-42')).toBe(-42);
+            expect(converter.toDecimal('-123')).toBe(-123);
+            expect(converter.toDecimal('-9999')).toBe(-9999);
+        });
+        it('deve ignorar decimais ao usar parseInt', () => {
+            expect(converter.toDecimal('3.14')).toBe(3);
+            expect(converter.toDecimal('42.99')).toBe(42);
+            expect(converter.toDecimal('-5.7')).toBe(-5);
+            expect(converter.toDecimal('0.9')).toBe(0);
+        });
+        it('deve lidar com strings com espaços em branco', () => {
+            expect(converter.toDecimal(' 42 ')).toBe(42);
+            expect(converter.toDecimal('\t123\n')).toBe(123);
+            expect(converter.toDecimal('  -456  ')).toBe(-456);
+        });
+        it('deve parar na primeira parte numérica válida', () => {
+            expect(converter.toDecimal('42abc')).toBe(42);
+            expect(converter.toDecimal('123xyz789')).toBe(123);
+            expect(converter.toDecimal('-456def')).toBe(-456);
+            expect(converter.toDecimal('100px')).toBe(100);
+        });
+        it('deve retornar NaN para strings inválidas', () => {
+            expect(converter.toDecimal('abc')).toBeNaN();
+            expect(converter.toDecimal('xyz123')).toBeNaN();
+            expect(converter.toDecimal('')).toBe(0);
+            expect(converter.toDecimal('   ')).toBeNaN();
+            expect(converter.toDecimal('invalid')).toBeNaN();
+        });
+        it('deve lidar com strings numéricas grandes', () => {
+            expect(converter.toDecimal('1000000')).toBe(1000000);
+            expect(converter.toDecimal('9007199254740991')).toBe(9007199254740991);
+        });
+        it('deve lidar com zeros à esquerda', () => {
+            expect(converter.toDecimal('007')).toBe(7);
+            expect(converter.toDecimal('00042')).toBe(42);
+            expect(converter.toDecimal('-0123')).toBe(-123);
+        });
+        it('deve lidar com sinal de mais explícito', () => {
+            expect(converter.toDecimal('+42')).toBe(42);
+            expect(converter.toDecimal('+123')).toBe(123);
+        });
+        it('deve lidar com notação científica em strings', () => {
+            expect(converter.toDecimal('1e6')).toBe(1);
+            expect(converter.toDecimal('2.5e3')).toBe(2);
+        });
+    });
+    describe('conversões bidirecionais', () => {
+        it('deve manter consistência para números inteiros', () => {
+            const testNumbers = [0, 1, -1, 42, -42, 123, -123, 9999, -9999];
+            testNumbers.forEach(num => {
+                const str = converter.fromDecimal(num);
+                const backToNumber = converter.toDecimal(str);
+                expect(backToNumber).toBe(num);
+            });
+        });
+        it('deve perder precisão decimal devido ao parseInt', () => {
+            const decimalNumbers = [3.14, -2.7, 123.456];
+            decimalNumbers.forEach(num => {
+                const str = converter.fromDecimal(num);
+                const backToNumber = converter.toDecimal(str);
+                expect(backToNumber).toBe(Math.floor(Math.abs(num)) * Math.sign(num));
+            });
+        });
+        it('deve manter consistência com strings numéricas inteiras', () => {
+            const testStrings = ['0', '1', '-1', '42', '-42', '123', '-123'];
+            testStrings.forEach(str => {
+                const num = converter.toDecimal(str);
+                const backToString = converter.fromDecimal(num);
+                expect(backToString).toBe(str);
+            });
+        });
+    });
+    describe('casos extremos', () => {
+        it('deve lidar com Number.MAX_SAFE_INTEGER', () => {
+            const maxSafe = Number.MAX_SAFE_INTEGER;
+            const str = converter.fromDecimal(maxSafe);
+            const back = converter.toDecimal(str);
+            expect(back).toBe(maxSafe);
+        });
+        it('deve lidar com Number.MIN_SAFE_INTEGER', () => {
+            const minSafe = Number.MIN_SAFE_INTEGER;
+            const str = converter.fromDecimal(minSafe);
+            const back = converter.toDecimal(str);
+            expect(back).toBe(minSafe);
+        });
+        it('deve lidar com valores que excedem precisão de parseInt', () => {
+            const largeNumber = 9007199254740993; // Maior que MAX_SAFE_INTEGER
+            const str = converter.fromDecimal(largeNumber);
+            expect(str).toBe('9007199254740992'); // JavaScript limita precisão
+        });
+        it('deve lidar com strings muito longas', () => {
+            const longNumberString = '123456789012345678901234567890';
+            const result = converter.toDecimal(longNumberString);
+            expect(result).toBe(123456789012345680000000000000); // Perda de precisão
+        });
+    });
+    describe('comportamentos específicos do parseInt', () => {
+        it('deve usar base 10 por padrão', () => {
+            expect(converter.toDecimal('010')).toBe(10); // Não interpreta como octal
+            expect(converter.toDecimal('0x10')).toBe(0); // Para na primeira parte válida
+        });
+        it('deve parar no primeiro caractere inválido', () => {
+            expect(converter.toDecimal('123.456.789')).toBe(123);
+            expect(converter.toDecimal('12a34')).toBe(12);
+            expect(converter.toDecimal('45 67')).toBe(45);
+        });
+    });
+    describe('implementação da interface', () => {
+        it('deve implementar corretamente INumericSystemConverter', () => {
+            expect(typeof converter.fromDecimal).toBe('function');
+            expect(typeof converter.toDecimal).toBe('function');
+        });
+        it('fromDecimal deve retornar string', () => {
+            const result = converter.fromDecimal(42);
+            expect(typeof result).toBe('string');
+        });
+        it('toDecimal deve retornar number', () => {
+            const result = converter.toDecimal('42');
+            expect(typeof result).toBe('number');
+        });
+    });
+    describe('edge cases importantes', () => {
+        it('deve alertar sobre limitações do parseInt com decimais', () => {
+            // Teste documentando comportamento que pode ser inesperado
+            expect(converter.toDecimal('3.99')).toBe(3);
+            expect(converter.toDecimal('-4.99')).toBe(-4);
+        });
+        it('deve documentar comportamento com strings mistas', () => {
+            expect(converter.toDecimal('12px')).toBe(12);
+            expect(converter.toDecimal('width: 100')).toBeNaN();
+        });
+    });
+});

package/dist/converters/numeric-systems/services/hexadecimal/hexadecimal.converter.d.ts

@@ -0,0 +1,5 @@
+import { INumericSystemConverter } from "../../interfaces/INumericSystem.converter";
+export declare class HexadecimalSystemConverter implements INumericSystemConverter {
+    fromDecimal(value: number): string;
+    toDecimal(value: string): number;
+}

package/dist/converters/numeric-systems/services/hexadecimal/hexadecimal.converter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HexadecimalSystemConverter = void 0;
+class HexadecimalSystemConverter {
+    fromDecimal(value) {
+        return value.toString(16);
+    }
+    toDecimal(value) {
+        if (value === '')
+            return 0;
+        if (value === 'NaN')
+            return 0;
+        if (value === 'Infinity')
+            return 0;
+        return parseInt(value, 16);
+    }
+}
+exports.HexadecimalSystemConverter = HexadecimalSystemConverter;

package/dist/converters/numeric-systems/services/hexadecimal/hexadecimal.converter.test.d.ts

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

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hexadecimal_converter_1 = require("./hexadecimal.converter");
+describe('HexadecimalSystemConverter', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new hexadecimal_converter_1.HexadecimalSystemConverter();
+    });
+    describe('fromDecimal', () => {
+        it('deve converter zero para hexadecimal', () => {
+            expect(converter.fromDecimal(0)).toBe('0');
+        });
+        it('deve converter números positivos básicos para hexadecimal', () => {
+            expect(converter.fromDecimal(1)).toBe('1');
+            expect(converter.fromDecimal(9)).toBe('9');
+            expect(converter.fromDecimal(10)).toBe('a');
+            expect(converter.fromDecimal(15)).toBe('f');
+            expect(converter.fromDecimal(16)).toBe('10');
+        });
+        it('deve converter números maiores para hexadecimal', () => {
+            expect(converter.fromDecimal(255)).toBe('ff');
+            expect(converter.fromDecimal(256)).toBe('100');
+            expect(converter.fromDecimal(4095)).toBe('fff');
+            expect(converter.fromDecimal(65535)).toBe('ffff');
+        });
+        it('deve converter números negativos para hexadecimal', () => {
+            expect(converter.fromDecimal(-1)).toBe('-1');
+            expect(converter.fromDecimal(-10)).toBe('-a');
+            expect(converter.fromDecimal(-255)).toBe('-ff');
+        });
+        it('deve converter números decimais (com ponto flutuante)', () => {
+            expect(converter.fromDecimal(10.5)).toBe('a.8');
+            expect(converter.fromDecimal(15.9)).toBe('f.e666666666668');
+        });
+        it('deve lidar com números muito grandes', () => {
+            expect(converter.fromDecimal(1048576)).toBe('100000');
+            expect(converter.fromDecimal(Number.MAX_SAFE_INTEGER)).toBe('1fffffffffffff');
+        });
+    });
+    describe('toDecimal', () => {
+        it('deve converter zero hexadecimal para decimal', () => {
+            expect(converter.toDecimal('0')).toBe(0);
+        });
+        it('deve converter dígitos hexadecimais básicos para decimal', () => {
+            expect(converter.toDecimal('1')).toBe(1);
+            expect(converter.toDecimal('9')).toBe(9);
+            expect(converter.toDecimal('a')).toBe(10);
+            expect(converter.toDecimal('A')).toBe(10);
+            expect(converter.toDecimal('f')).toBe(15);
+            expect(converter.toDecimal('F')).toBe(15);
+        });
+        it('deve converter números hexadecimais de múltiplos dígitos', () => {
+            expect(converter.toDecimal('10')).toBe(16);
+            expect(converter.toDecimal('ff')).toBe(255);
+            expect(converter.toDecimal('FF')).toBe(255);
+            expect(converter.toDecimal('100')).toBe(256);
+            expect(converter.toDecimal('fff')).toBe(4095);
+            expect(converter.toDecimal('ffff')).toBe(65535);
+        });
+        it('deve ser case-insensitive', () => {
+            expect(converter.toDecimal('abc')).toBe(2748);
+            expect(converter.toDecimal('ABC')).toBe(2748);
+            expect(converter.toDecimal('AbC')).toBe(2748);
+        });
+        it('deve lidar com strings vazias e inválidas', () => {
+            expect(converter.toDecimal('')).toBe(0);
+            expect(converter.toDecimal('invalid')).toBeNaN();
+            expect(converter.toDecimal('xyz')).toBeNaN();
+            expect(converter.toDecimal('g')).toBeNaN();
+        });
+        it('deve converter números hexadecimais grandes', () => {
+            expect(converter.toDecimal('100000')).toBe(1048576);
+            expect(converter.toDecimal('1fffffffffffff')).toBe(Number.MAX_SAFE_INTEGER);
+        });
+        it('deve lidar com espaços em branco', () => {
+            expect(converter.toDecimal(' ff ')).toBe(255);
+            expect(converter.toDecimal('\t10\n')).toBe(16);
+        });
+    });
+    describe('conversões bidirecionais', () => {
+        it('deve manter consistência em conversões de ida e volta', () => {
+            const testNumbers = [0, 1, 10, 15, 16, 255, 256, 4095, 65535];
+            testNumbers.forEach(num => {
+                const hex = converter.fromDecimal(num);
+                const backToDecimal = converter.toDecimal(hex);
+                expect(backToDecimal).toBe(num);
+            });
+        });
+        it('deve manter consistência com strings hexadecimais válidas', () => {
+            const testHexValues = ['0', '1', 'a', 'f', '10', 'ff', '100', 'fff', 'ffff'];
+            testHexValues.forEach(hex => {
+                const decimal = converter.toDecimal(hex);
+                const backToHex = converter.fromDecimal(decimal);
+                expect(backToHex).toBe(hex.toLowerCase());
+            });
+        });
+    });
+    describe('casos extremos', () => {
+        it('deve lidar com Number.MAX_VALUE', () => {
+            const result = converter.fromDecimal(Number.MAX_VALUE);
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('deve lidar com Number.MIN_VALUE', () => {
+            const result = converter.fromDecimal(Number.MIN_VALUE);
+            expect(result).toBe('0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004');
+        });
+        it('deve lidar com Infinity', () => {
+            expect(converter.fromDecimal(Infinity)).toBe('Infinity');
+            expect(converter.fromDecimal(-Infinity)).toBe('-Infinity');
+        });
+        it('deve lidar com NaN', () => {
+            expect(converter.fromDecimal(NaN)).toBe('NaN');
+        });
+    });
+    describe('implementação da interface', () => {
+        it('deve implementar corretamente INumericSystemConverter', () => {
+            expect(typeof converter.fromDecimal).toBe('function');
+            expect(typeof converter.toDecimal).toBe('function');
+        });
+        it('fromDecimal deve retornar string', () => {
+            const result = converter.fromDecimal(42);
+            expect(typeof result).toBe('string');
+        });
+        it('toDecimal deve retornar number', () => {
+            const result = converter.toDecimal('2a');
+            expect(typeof result).toBe('number');
+        });
+    });
+});

package/dist/converters/numeric-systems/services/octadecimal/octadecimal.converter.d.ts

@@ -0,0 +1,5 @@
+import { INumericSystemConverter } from "../../interfaces/INumericSystem.converter";
+export declare class OctadecimalSystemConverter implements INumericSystemConverter {
+    fromDecimal(value: number): string;
+    toDecimal(value: string): number;
+}

package/dist/converters/numeric-systems/services/octadecimal/octadecimal.converter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OctadecimalSystemConverter = void 0;
+class OctadecimalSystemConverter {
+    fromDecimal(value) {
+        return value.toString(8);
+    }
+    toDecimal(value) {
+        if (value === '')
+            return 0; // parseInt behavior for empty string
+        const result = parseInt(value, 8);
+        return isNaN(result) ? 0 : result; // Retorna 0 se
+    }
+}
+exports.OctadecimalSystemConverter = OctadecimalSystemConverter;

package/dist/converters/numeric-systems/services/octadecimal/octadecimal.converter.test.d.ts

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

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const octadecimal_converter_1 = require("./octadecimal.converter");
+describe('OctadecimalSystemConverter', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new octadecimal_converter_1.OctadecimalSystemConverter();
+    });
+    describe('fromDecimal', () => {
+        it('should convert decimal 0 to octal "0"', () => {
+            const result = converter.fromDecimal(0);
+            expect(result).toBe('0');
+        });
+        it('should convert decimal 8 to octal "10"', () => {
+            const result = converter.fromDecimal(8);
+            expect(result).toBe('10');
+        });
+        it('should convert decimal 64 to octal "100"', () => {
+            const result = converter.fromDecimal(64);
+            expect(result).toBe('100');
+        });
+        it('should convert decimal 255 to octal "377"', () => {
+            const result = converter.fromDecimal(255);
+            expect(result).toBe('377');
+        });
+        it('should convert small decimal numbers correctly', () => {
+            expect(converter.fromDecimal(1)).toBe('1');
+            expect(converter.fromDecimal(2)).toBe('2');
+            expect(converter.fromDecimal(3)).toBe('3');
+            expect(converter.fromDecimal(4)).toBe('4');
+            expect(converter.fromDecimal(5)).toBe('5');
+            expect(converter.fromDecimal(6)).toBe('6');
+            expect(converter.fromDecimal(7)).toBe('7');
+        });
+        it('should convert larger decimal numbers correctly', () => {
+            expect(converter.fromDecimal(100)).toBe('144');
+            expect(converter.fromDecimal(512)).toBe('1000');
+            expect(converter.fromDecimal(1000)).toBe('1750');
+        });
+        it('should handle negative numbers', () => {
+            const result = converter.fromDecimal(-8);
+            expect(result).toBe('-10');
+        });
+        it('should handle floating point numbers by truncating', () => {
+            const result = converter.fromDecimal(8.7);
+            expect(result).toBe('10.5463146314631463');
+        });
+    });
+    describe('toDecimal', () => {
+        it('should convert octal "0" to decimal 0', () => {
+            const result = converter.toDecimal('0');
+            expect(result).toBe(0);
+        });
+        it('should convert octal "10" to decimal 8', () => {
+            const result = converter.toDecimal('10');
+            expect(result).toBe(8);
+        });
+        it('should convert octal "100" to decimal 64', () => {
+            const result = converter.toDecimal('100');
+            expect(result).toBe(64);
+        });
+        it('should convert octal "377" to decimal 255', () => {
+            const result = converter.toDecimal('377');
+            expect(result).toBe(255);
+        });
+        it('should convert single digit octal numbers correctly', () => {
+            expect(converter.toDecimal('1')).toBe(1);
+            expect(converter.toDecimal('2')).toBe(2);
+            expect(converter.toDecimal('3')).toBe(3);
+            expect(converter.toDecimal('4')).toBe(4);
+            expect(converter.toDecimal('5')).toBe(5);
+            expect(converter.toDecimal('6')).toBe(6);
+            expect(converter.toDecimal('7')).toBe(7);
+        });
+        it('should convert larger octal numbers correctly', () => {
+            expect(converter.toDecimal('144')).toBe(100);
+            expect(converter.toDecimal('1000')).toBe(512);
+            expect(converter.toDecimal('1750')).toBe(1000);
+        });
+        it('should handle negative octal numbers', () => {
+            const result = converter.toDecimal('-10');
+            expect(result).toBe(-8);
+        });
+        it('should return NaN for invalid octal strings', () => {
+            expect(converter.toDecimal('8')).toBe(0);
+            expect(converter.toDecimal('9')).toBe(0);
+            expect(converter.toDecimal('abc')).toBe(0);
+            expect(converter.toDecimal('')).toBe(0); // parseInt behavior
+        });
+        it('should handle strings with leading zeros', () => {
+            expect(converter.toDecimal('010')).toBe(8);
+            expect(converter.toDecimal('0100')).toBe(64);
+        });
+        it('should handle whitespace by ignoring leading/trailing spaces', () => {
+            expect(converter.toDecimal(' 10 ')).toBe(8);
+            expect(converter.toDecimal('  100  ')).toBe(64);
+        });
+    });
+    describe('bidirectional conversion', () => {
+        it('should maintain consistency in bidirectional conversion', () => {
+            const testValues = [0, 1, 7, 8, 15, 64, 100, 255, 512, 1000];
+            testValues.forEach(value => {
+                const octal = converter.fromDecimal(value);
+                const backToDecimal = converter.toDecimal(octal);
+                expect(backToDecimal).toBe(value);
+            });
+        });
+        it('should maintain consistency for negative numbers', () => {
+            const testValues = [-1, -8, -64, -100];
+            testValues.forEach(value => {
+                const octal = converter.fromDecimal(value);
+                const backToDecimal = converter.toDecimal(octal);
+                expect(backToDecimal).toBe(value);
+            });
+        });
+    });
+    describe('interface compliance', () => {
+        it('should implement INumericSystemConverter interface', () => {
+            expect(converter.fromDecimal).toBeDefined();
+            expect(converter.toDecimal).toBeDefined();
+            expect(typeof converter.fromDecimal).toBe('function');
+            expect(typeof converter.toDecimal).toBe('function');
+        });
+        it('should return string from fromDecimal', () => {
+            const result = converter.fromDecimal(8);
+            expect(typeof result).toBe('string');
+        });
+        it('should return number from toDecimal', () => {
+            const result = converter.toDecimal('10');
+            expect(typeof result).toBe('number');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle maximum safe integer', () => {
+            const maxSafe = Number.MAX_SAFE_INTEGER;
+            const octal = converter.fromDecimal(maxSafe);
+            const backToDecimal = converter.toDecimal(octal);
+            expect(backToDecimal).toBe(maxSafe);
+        });
+        it('should handle minimum safe integer', () => {
+            const minSafe = Number.MIN_SAFE_INTEGER;
+            const octal = converter.fromDecimal(minSafe);
+            const backToDecimal = converter.toDecimal(octal);
+            expect(backToDecimal).toBe(minSafe);
+        });
+        it('should handle zero correctly', () => {
+            expect(converter.fromDecimal(0)).toBe('0');
+            expect(converter.toDecimal('0')).toBe(0);
+        });
+    });
+});

package/dist/converters/numeric-systems/services/roman/roman.converter.d.ts

@@ -0,0 +1,7 @@
+import { INumericSystemConverter } from "../../interfaces/INumericSystem.converter";
+export declare class RomanSystemConverter implements INumericSystemConverter {
+    private readonly ROMAN_NUMBERS;
+    private isValidRoman;
+    fromDecimal(value: number): string;
+    toDecimal(value: string): number;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RomanSystemConverter = void 0;
+class RomanSystemConverter {
+    constructor() {
+        this.ROMAN_NUMBERS = [
+            { symbol: 'M', value: 1000, },
+            { symbol: 'CM', value: 900 },
+            { symbol: 'D', value: 500 },
+            { symbol: 'CD', value: 400 },
+            { symbol: 'C', value: 100 },
+            { symbol: 'XC', value: 90 },
+            { symbol: 'L', value: 50 },
+            { symbol: 'XL', value: 40 },
+            { symbol: 'X', value: 10 },
+            { symbol: 'IX', value: 9 },
+            { symbol: 'V', value: 5 },
+            { symbol: 'IV', value: 4 },
+            { symbol: 'I', value: 1 },
+        ];
+    }
+    isValidRoman(roman) {
+        // Regex para validar formato básico de números romanos
+        const romanRegex = /^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/;
+        return romanRegex.test(roman);
+    }
+    fromDecimal(value) {
+        if (!Number.isInteger(value) || value < 1 || value > 3999) {
+            throw new Error('Número deve ser um inteiro entre 1 e 3999');
+        }
+        let result = '';
+        let remaining = value;
+        for (const romanNumber of this.ROMAN_NUMBERS) {
+            const count = Math.floor(remaining / romanNumber.value);
+            if (count > 0) {
+                result += romanNumber.symbol.repeat(count);
+                remaining -= romanNumber.value * count;
+            }
+        }
+        return result;
+    }
+    toDecimal(value) {
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error('Entrada deve ser uma string não vazia');
+        }
+        const normalizedRoman = value.toUpperCase().trim();
+        if (!this.isValidRoman(normalizedRoman)) {
+            throw new Error('Formato de número romano inválido');
+        }
+        let result = 0;
+        let i = 0;
+        while (i < normalizedRoman.length) {
+            // Verifica primeiro por símbolos de dois caracteres (IV, IX, XL, etc.)
+            if (i + 1 < normalizedRoman.length) {
+                const twoChar = normalizedRoman.substring(i, i + 2);
+                const twoCharValue = this.ROMAN_NUMBERS.find(rn => rn.symbol === twoChar);
+                if (twoCharValue) {
+                    result += twoCharValue.value;
+                    i += 2;
+                    continue;
+                }
+            }
+            // Símbolos de um caractere
+            const oneChar = normalizedRoman[i];
+            const oneCharValue = this.ROMAN_NUMBERS.find(rn => rn.symbol === oneChar);
+            if (oneCharValue) {
+                result += oneCharValue.value;
+                i += 1;
+            }
+            else {
+                throw new Error(`Caractere romano inválido: ${oneChar}`);
+            }
+        }
+        return result;
+    }
+}
+exports.RomanSystemConverter = RomanSystemConverter;

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

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