devtoolz-library 1.0.0

package/dist/baseFactory.d.ts

@@ -0,0 +1,12 @@
+import { IFactory } from "./interfaces/IFactory";
+import { IServiceCategory } from "./interfaces/IServiceCategory";
+export declare abstract class BaseFactory<TService> implements IFactory<TService> {
+    protected services: IServiceCategory[];
+    protected map: Map<string, TService>;
+    constructor(services: IServiceCategory[]);
+    private set _setServices(value);
+    private _registerServices;
+    protected abstract registerService(service: IServiceCategory): void;
+    protected throwServiceNotFoundError(serviceId: string): never;
+    createService(serviceId: string): TService;
+}

package/dist/baseFactory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFactory = void 0;
+class BaseFactory {
+    constructor(services) {
+        this.services = [];
+        this.map = new Map();
+        this._setServices = services;
+        this._registerServices();
+    }
+    set _setServices(services) {
+        if (services.length === 0) {
+            throw new Error("Nenhuma categoria de serviço foi fornecida.");
+        }
+        this.services = services;
+    }
+    _registerServices() {
+        this.services.forEach(category => {
+            this.registerService(category);
+        });
+    }
+    throwServiceNotFoundError(serviceId) {
+        throw new Error(`O serviço solicitado não está implementado: ${serviceId}`);
+    }
+    createService(serviceId) {
+        const service = this.map.get(serviceId);
+        if (!service) {
+            this.throwServiceNotFoundError(serviceId);
+        }
+        return service;
+    }
+}
+exports.BaseFactory = BaseFactory;

package/dist/constants/regexPatterns.d.ts

@@ -0,0 +1,2 @@
+export declare const cnpjPattern: RegExp;
+export declare const cpfPattern: RegExp;

package/dist/constants/regexPatterns.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cpfPattern = exports.cnpjPattern = void 0;
+// export const decimalNumber = "^(\d+(\.)?)+(\,{1}\d{2}){1}$";
+// export const decimalNumberWithSign = "(^R\$ )?(\d+(\.)?)+(\,{1}\d{2}){1}$";
+// export const emailDomain = "@[a-z0-9]+\.?-?[a-z0-9]+?(\.[a-z0-9]{2,3})+$";
+// export const email = "^(\w+\.?|-?\w+?)+@[a-z0-9]+\.?-?[a-z0-9]+?(\.[a-z0-9]{2,3})+$";
+exports.cnpjPattern = /^(\d{2})\.?(\d{3})\.?(\d{3})\/?([0-9]{4})\-?(\d{2})$/;
+exports.cpfPattern = /^(\d{3})\.?(\d{3})\.?(\d{3})\-?(\d{2}$)$/;

package/dist/converters/numeric-systems/interfaces/INumericSystem.converter.d.ts

@@ -0,0 +1,4 @@
+export interface INumericSystemConverter {
+    fromDecimal(value: number): string;
+    toDecimal(value: string): number;
+}

package/dist/converters/numeric-systems/interfaces/INumericSystem.converter.factory.d.ts

@@ -0,0 +1,4 @@
+import { IFactory } from "../../../interfaces/IFactory";
+import { INumericSystemConverter } from "./INumericSystem.converter";
+export interface INumericSystemConverterFactory extends IFactory<INumericSystemConverter> {
+}

package/dist/converters/numeric-systems/interfaces/INumericSystem.converter.factory.js

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

package/dist/converters/numeric-systems/interfaces/INumericSystem.converter.js

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

package/dist/converters/numeric-systems/numericSystem.converter.d.ts

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

package/dist/converters/numeric-systems/numericSystem.converter.factory.d.ts

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

package/dist/converters/numeric-systems/numericSystem.converter.factory.js

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

package/dist/converters/numeric-systems/numericSystem.converter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericSystemConverter = void 0;
+const numericSystem_converter_factory_1 = require("./numericSystem.converter.factory");
+class NumericSystemConverter {
+    constructor() {
+        this.factory = new numericSystem_converter_factory_1.NumericSystemConverterFactory();
+    }
+    convert(content, from, to) {
+        const source = this.factory.createService(from);
+        const target = this.factory.createService(to);
+        const decimal = source.toDecimal(content);
+        const result = target.fromDecimal(decimal);
+        return result;
+    }
+}
+exports.NumericSystemConverter = NumericSystemConverter;

package/dist/converters/numeric-systems/provider.d.ts

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

package/dist/converters/numeric-systems/provider.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systems = void 0;
+exports.systems = [
+    { id: "binary" },
+    { id: "octadecimal" },
+    { id: "decimal" },
+    { id: "hexadecimal" },
+    // { id: "sexagesimal" },
+    { id: "roman" },
+];

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

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

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

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

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

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

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

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const binary_converter_1 = require("./binary.converter");
+describe('BinarySystemConverter', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new binary_converter_1.BinarySystemConverter();
+    });
+    describe('fromDecimal', () => {
+        it('deve converter zero para binário', () => {
+            expect(converter.fromDecimal(0)).toBe('0');
+        });
+        it('deve converter números positivos básicos para binário', () => {
+            expect(converter.fromDecimal(1)).toBe('1');
+            expect(converter.fromDecimal(2)).toBe('10');
+            expect(converter.fromDecimal(3)).toBe('11');
+            expect(converter.fromDecimal(4)).toBe('100');
+            expect(converter.fromDecimal(5)).toBe('101');
+            expect(converter.fromDecimal(8)).toBe('1000');
+        });
+        it('deve converter potências de 2 para binário', () => {
+            expect(converter.fromDecimal(1)).toBe('1'); // 2^0
+            expect(converter.fromDecimal(2)).toBe('10'); // 2^1
+            expect(converter.fromDecimal(4)).toBe('100'); // 2^2
+            expect(converter.fromDecimal(8)).toBe('1000'); // 2^3
+            expect(converter.fromDecimal(16)).toBe('10000'); // 2^4
+            expect(converter.fromDecimal(32)).toBe('100000'); // 2^5
+            expect(converter.fromDecimal(64)).toBe('1000000'); // 2^6
+        });
+        it('deve converter números comuns para binário', () => {
+            expect(converter.fromDecimal(7)).toBe('111');
+            expect(converter.fromDecimal(15)).toBe('1111');
+            expect(converter.fromDecimal(31)).toBe('11111');
+            expect(converter.fromDecimal(63)).toBe('111111');
+            expect(converter.fromDecimal(127)).toBe('1111111');
+            expect(converter.fromDecimal(255)).toBe('11111111');
+        });
+        it('deve converter números maiores para binário', () => {
+            expect(converter.fromDecimal(256)).toBe('100000000');
+            expect(converter.fromDecimal(512)).toBe('1000000000');
+            expect(converter.fromDecimal(1024)).toBe('10000000000');
+            expect(converter.fromDecimal(65535)).toBe('1111111111111111');
+        });
+        it('deve converter números negativos para binário', () => {
+            expect(converter.fromDecimal(-1)).toBe('-1');
+            expect(converter.fromDecimal(-2)).toBe('-10');
+            expect(converter.fromDecimal(-8)).toBe('-1000');
+            expect(converter.fromDecimal(-255)).toBe('-11111111');
+        });
+        it('deve converter números decimais truncando a parte fracionária', () => {
+            expect(converter.fromDecimal(5.1)).toBe('101.0001100110011001100110011001100110011001100110011');
+            expect(converter.fromDecimal(5.9)).toBe('101.1110011001100110011001100110011001100110011001101');
+            expect(converter.fromDecimal(7.5)).toBe('111.1');
+            expect(converter.fromDecimal(15.99)).toBe('1111.1111110101110000101000111101011100001010001111011');
+        });
+        it('deve lidar com números muito grandes', () => {
+            expect(converter.fromDecimal(1048576)).toBe('100000000000000000000');
+            expect(converter.fromDecimal(Number.MAX_SAFE_INTEGER)).toBe('11111111111111111111111111111111111111111111111111111');
+        });
+        it('deve lidar com valores especiais', () => {
+            expect(converter.fromDecimal(Infinity)).toBe('Infinity');
+            expect(converter.fromDecimal(-Infinity)).toBe('-Infinity');
+            expect(converter.fromDecimal(NaN)).toBe('NaN');
+        });
+    });
+    describe('toDecimal', () => {
+        it('deve converter zero binário para decimal', () => {
+            expect(converter.toDecimal('0')).toBe(0);
+        });
+        it('deve converter números binários básicos para decimal', () => {
+            expect(converter.toDecimal('1')).toBe(1);
+            expect(converter.toDecimal('10')).toBe(2);
+            expect(converter.toDecimal('11')).toBe(3);
+            expect(converter.toDecimal('100')).toBe(4);
+            expect(converter.toDecimal('101')).toBe(5);
+            expect(converter.toDecimal('1000')).toBe(8);
+        });
+        it('deve converter potências de 2 binário para decimal', () => {
+            expect(converter.toDecimal('1')).toBe(1); // 2^0
+            expect(converter.toDecimal('10')).toBe(2); // 2^1
+            expect(converter.toDecimal('100')).toBe(4); // 2^2
+            expect(converter.toDecimal('1000')).toBe(8); // 2^3
+            expect(converter.toDecimal('10000')).toBe(16); // 2^4
+            expect(converter.toDecimal('100000')).toBe(32); // 2^5
+            expect(converter.toDecimal('1000000')).toBe(64); // 2^6
+        });
+        it('deve converter padrões binários comuns para decimal', () => {
+            expect(converter.toDecimal('111')).toBe(7);
+            expect(converter.toDecimal('1111')).toBe(15);
+            expect(converter.toDecimal('11111')).toBe(31);
+            expect(converter.toDecimal('111111')).toBe(63);
+            expect(converter.toDecimal('1111111')).toBe(127);
+            expect(converter.toDecimal('11111111')).toBe(255);
+        });
+        it('deve converter números binários maiores para decimal', () => {
+            expect(converter.toDecimal('100000000')).toBe(256);
+            expect(converter.toDecimal('1000000000')).toBe(512);
+            expect(converter.toDecimal('10000000000')).toBe(1024);
+            expect(converter.toDecimal('1111111111111111')).toBe(65535);
+        });
+        it('deve lidar com espaços em branco', () => {
+            expect(converter.toDecimal(' 101 ')).toBe(5);
+            expect(converter.toDecimal('\t1000\n')).toBe(8);
+            expect(converter.toDecimal('  1111  ')).toBe(15);
+        });
+        it('deve lidar com zeros à esquerda', () => {
+            expect(converter.toDecimal('0001')).toBe(1);
+            expect(converter.toDecimal('000101')).toBe(5);
+            expect(converter.toDecimal('0001000')).toBe(8);
+        });
+        it('deve retornar NaN para strings inválidas', () => {
+            expect(converter.toDecimal('')).toBe(0);
+            expect(converter.toDecimal('abc')).toBeNaN();
+            expect(converter.toDecimal('xyz')).toBeNaN();
+            expect(converter.toDecimal('2')).toBeNaN(); // 2 não é válido em binário
+            expect(converter.toDecimal('invalid')).toBeNaN();
+            expect(converter.toDecimal('   ')).toBeNaN();
+        });
+        it('deve parar no primeiro dígito inválido', () => {
+            expect(converter.toDecimal('101abc')).toBe(5); // Para no 'a'
+            expect(converter.toDecimal('123')).toBe(1); // Para no '2'
+            expect(converter.toDecimal('102')).toBe(2); // Para no '0', depois para no '2' 
+            expect(converter.toDecimal('1002')).toBe(4); // Para no primeiro '2'
+            expect(converter.toDecimal('110xyz')).toBe(6); // Para no 'x'
+            expect(converter.toDecimal('111 000')).toBe(7); // Para no espaço
+            expect(converter.toDecimal('1a1')).toBe(1); // Para no 'a'
+        });
+        it('deve lidar com prefixos comuns de binário', () => {
+            expect(converter.toDecimal('0b101')).toBe(0); // Para no 'b'
+            expect(converter.toDecimal('101b')).toBe(5); // Para no 'b'
+        });
+        it('deve converter números binários muito grandes', () => {
+            expect(converter.toDecimal('100000000000000000000')).toBe(1048576);
+            expect(converter.toDecimal('11111111111111111111111111111111111111111111111111111')).toBe(Number.MAX_SAFE_INTEGER);
+        });
+    });
+    describe('conversões bidirecionais', () => {
+        it('deve manter consistência em conversões de ida e volta', () => {
+            const testNumbers = [0, 1, 2, 3, 4, 5, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128, 255, 256, 1023, 1024];
+            testNumbers.forEach(num => {
+                const binary = converter.fromDecimal(num);
+                const backToDecimal = converter.toDecimal(binary);
+                expect(backToDecimal).toBe(num);
+            });
+        });
+        it('deve manter consistência com strings binárias válidas', () => {
+            const testBinaryValues = ['0', '1', '10', '11', '100', '101', '111', '1000', '1111', '10000'];
+            testBinaryValues.forEach(binary => {
+                const decimal = converter.toDecimal(binary);
+                const backToBinary = converter.fromDecimal(decimal);
+                expect(backToBinary).toBe(binary);
+            });
+        });
+        it('deve perder parte decimal em conversões bidirecionais', () => {
+            const decimalNumbers = [5.7, 7.2, 15.9];
+            decimalNumbers.forEach(num => {
+                const binary = converter.fromDecimal(num);
+                const backToDecimal = converter.toDecimal(binary);
+                expect(backToDecimal).toBe(Math.floor(num));
+            });
+        });
+    });
+    describe('casos extremos', () => {
+        it('deve lidar com Number.MAX_SAFE_INTEGER', () => {
+            const maxSafe = Number.MAX_SAFE_INTEGER;
+            const binary = converter.fromDecimal(maxSafe);
+            const backToDecimal = converter.toDecimal(binary);
+            expect(backToDecimal).toBe(maxSafe);
+        });
+        it('deve lidar com Number.MIN_SAFE_INTEGER', () => {
+            const minSafe = Number.MIN_SAFE_INTEGER;
+            const binary = converter.fromDecimal(minSafe);
+            expect(binary).toBe('-11111111111111111111111111111111111111111111111111111');
+        });
+        it('deve lidar com strings binárias muito longas', () => {
+            const longBinary = '1'.repeat(53); // Próximo ao limite de precisão do JavaScript
+            const result = converter.toDecimal(longBinary);
+            expect(typeof result).toBe('number');
+            expect(result).toBeGreaterThan(0);
+        });
+        it('deve lidar com Number.MAX_VALUE', () => {
+            const result = converter.fromDecimal(Number.MAX_VALUE);
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+        });
+    });
+    describe('validação específica para sistema binário', () => {
+        it('deve aceitar apenas dígitos 0 e 1', () => {
+            expect(converter.toDecimal('0')).toBe(0);
+            expect(converter.toDecimal('1')).toBe(1);
+            expect(converter.toDecimal('01')).toBe(1);
+            expect(converter.toDecimal('10')).toBe(2);
+            expect(converter.toDecimal('11')).toBe(3);
+        });
+        it('deve rejeitar dígitos 2-9', () => {
+            expect(converter.toDecimal('2')).toBeNaN();
+            expect(converter.toDecimal('12')).toBe(1); // Para no 2
+            expect(converter.toDecimal('19')).toBe(1); // Para no 9
+            expect(converter.toDecimal('101234')).toBe(5); // Para no 2
+        });
+        it('deve rejeitar caracteres não numéricos (exceto espaços)', () => {
+            expect(converter.toDecimal('a')).toBeNaN();
+            expect(converter.toDecimal('1a0')).toBe(1);
+            expect(converter.toDecimal('z101')).toBeNaN();
+        });
+    });
+    describe('padrões binários importantes', () => {
+        it('deve converter corretamente bytes (8 bits)', () => {
+            expect(converter.toDecimal('00000000')).toBe(0);
+            expect(converter.toDecimal('00000001')).toBe(1);
+            expect(converter.toDecimal('10000000')).toBe(128);
+            expect(converter.toDecimal('11111111')).toBe(255);
+        });
+        it('deve converter corretamente nibbles (4 bits)', () => {
+            expect(converter.toDecimal('0000')).toBe(0);
+            expect(converter.toDecimal('0001')).toBe(1);
+            expect(converter.toDecimal('1000')).toBe(8);
+            expect(converter.toDecimal('1111')).toBe(15);
+        });
+        it('deve converter corretamente words (16 bits)', () => {
+            expect(converter.toDecimal('0000000000000000')).toBe(0);
+            expect(converter.toDecimal('0000000000000001')).toBe(1);
+            expect(converter.toDecimal('1000000000000000')).toBe(32768);
+            expect(converter.toDecimal('1111111111111111')).toBe(65535);
+        });
+    });
+    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('101010');
+            expect(typeof result).toBe('number');
+        });
+    });
+    describe('comportamentos específicos do parseInt com base 2', () => {
+        it('deve usar base 2 explicitamente', () => {
+            expect(converter.toDecimal('010')).toBe(2); // Interpreta como binário
+            expect(converter.toDecimal('0x10')).toBe(0); // Para no 'x'
+        });
+        it('deve parar no primeiro caractere inválido para base 2', () => {
+            expect(converter.toDecimal('1012')).toBe(5); // Para no '2'
+            expect(converter.toDecimal('101a')).toBe(5); // Para no 'a'
+            expect(converter.toDecimal('11 00')).toBe(3); // Para no espaço
+        });
+    });
+});

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

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

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

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

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

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