devtoolz-library 1.0.0

package/dist/documents/cpf/tests/cpf.validator.test.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cpf_generator_1 = require("../cpf.generator");
+const cpf_validator_1 = require("../cpf.validator");
+describe("CpfValidator", () => {
+    let validator;
+    let generator;
+    beforeEach(() => {
+        validator = new cpf_validator_1.CpfValidator();
+        generator = new cpf_generator_1.CpfGenerator();
+    });
+    // -------------------------------------------------------------------------
+    // Casos inválidos — estrutura
+    // -------------------------------------------------------------------------
+    describe("Dado um CPF vazio", () => {
+        it("deve retornar inválido ao receber string vazia", () => {
+            const result = validator.validate("");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF está vazio.");
+        });
+        it("deve retornar inválido ao receber apenas espaços", () => {
+            const result = validator.validate("   ");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF está vazio.");
+        });
+    });
+    describe("Dado um CPF com formato inválido", () => {
+        it("deve retornar inválido para letras", () => {
+            const result = validator.validate("abc.def.ghi-jk");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF com formato inválido.");
+        });
+        it("deve retornar inválido para menos de 11 dígitos", () => {
+            const result = validator.validate("1234567");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF com formato inválido.");
+        });
+        it("deve retornar inválido para mais de 11 dígitos", () => {
+            const result = validator.validate("123456789012");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF com formato inválido.");
+        });
+        it("deve retornar inválido para máscara incorreta", () => {
+            const result = validator.validate("123-456-789.01");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF com formato inválido.");
+        });
+    });
+    describe("Dado um CPF com todos os dígitos iguais", () => {
+        it.each([
+            "000.000.000-00",
+            "111.111.111-11",
+            "222.222.222-22",
+            "333.333.333-33",
+            "444.444.444-44",
+            "555.555.555-55",
+            "666.666.666-66",
+            "777.777.777-77",
+            "888.888.888-88",
+            "999.999.999-99",
+        ])("deve rejeitar %s", (cpf) => {
+            const result = validator.validate(cpf);
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CPF não pode ter todos os dígitos iguais.");
+        });
+    });
+    describe("Dado um CPF com dígito verificador inválido", () => {
+        it("deve retornar inválido quando o primeiro dígito verificador está errado", () => {
+            const valid = generator.generate(false);
+            const tampered = valid.substring(0, 9) + String((Number(valid[9]) + 1) % 10) + valid[10];
+            const result = validator.validate(tampered);
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("Primeiro dígito verificador é inválido.");
+        });
+        it("deve retornar inválido quando o segundo dígito verificador está errado", () => {
+            const valid = generator.generate(false);
+            const tampered = valid.substring(0, 10) + String((Number(valid[10]) + 1) % 10);
+            const result = validator.validate(tampered);
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("Segundo dígito verificador é inválido.");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Casos válidos
+    // -------------------------------------------------------------------------
+    describe("Dado um CPF válido", () => {
+        it("deve aceitar CPF gerado sem máscara", () => {
+            const cpf = generator.generate(false);
+            const result = validator.validate(cpf);
+            expect(result.isValid).toBe(true);
+            expect(result.message).toBe("Válido");
+        });
+        it("deve aceitar CPF gerado com máscara", () => {
+            const cpf = generator.generate(true);
+            const result = validator.validate(cpf);
+            expect(result.isValid).toBe(true);
+            expect(result.message).toBe("Válido");
+        });
+        it("deve aceitar 10 CPFs gerados consecutivamente", () => {
+            for (let i = 0; i < 10; i++) {
+                const cpf = generator.generate(i % 2 === 0);
+                const result = validator.validate(cpf);
+                expect(result.isValid).toBe(true);
+            }
+        });
+        it("deve aceitar o mesmo CPF com e sem máscara", () => {
+            const raw = generator.generate(false);
+            const formatted = raw.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, "$1.$2.$3-$4");
+            expect(validator.validate(raw).isValid).toBe(true);
+            expect(validator.validate(formatted).isValid).toBe(true);
+        });
+    });
+});

package/dist/documents/interfaces/formatter.interface.d.ts

@@ -0,0 +1,4 @@
+export interface IFormatter {
+    applyMask(document: string): string;
+    removeMask(document: string): string;
+}

package/dist/documents/interfaces/formatter.interface.js

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

package/dist/documents/interfaces/generator.interface.d.ts

@@ -0,0 +1,3 @@
+export interface IGenerator {
+    generate(formatted?: boolean): string;
+}

package/dist/documents/interfaces/generator.interface.js

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

package/dist/documents/interfaces/validator.interface.d.ts

@@ -0,0 +1,4 @@
+import { IValidationResult } from "../models/validation-result.model";
+export interface IValidator {
+    validate(value: string): IValidationResult;
+}

package/dist/documents/interfaces/validator.interface.js

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

package/dist/documents/models/validation-result.model.d.ts

@@ -0,0 +1,4 @@
+export interface IValidationResult {
+    readonly isValid: boolean;
+    readonly message: string;
+}

package/dist/documents/models/validation-result.model.js

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

package/dist/enums/cryptProvider.d.ts

@@ -0,0 +1,6 @@
+export declare enum CryptProvider {
+    Rijndael = 0,
+    RC2 = 1,
+    DES = 2,
+    TripleDES = 3
+}

package/dist/enums/cryptProvider.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptProvider = void 0;
+var CryptProvider;
+(function (CryptProvider) {
+    CryptProvider[CryptProvider["Rijndael"] = 0] = "Rijndael";
+    CryptProvider[CryptProvider["RC2"] = 1] = "RC2";
+    CryptProvider[CryptProvider["DES"] = 2] = "DES";
+    CryptProvider[CryptProvider["TripleDES"] = 3] = "TripleDES";
+})(CryptProvider || (exports.CryptProvider = CryptProvider = {}));

package/dist/extensions/array.extensions.d.ts

@@ -0,0 +1,6 @@
+export {};
+declare global {
+    interface Array<T> {
+        contains(predicate: (value: T, index: number, array: T[]) => boolean): boolean;
+    }
+}

package/dist/extensions/array.extensions.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Array.prototype.contains = function (predicate) {
+    let list = this;
+    let item = list.find(predicate);
+    return item !== undefined && item !== null;
+};

package/dist/extensions/boolean.extensions.d.ts

@@ -0,0 +1,6 @@
+export {};
+declare global {
+    interface Boolean {
+        toNumber(value: boolean): number;
+    }
+}

package/dist/extensions/boolean.extensions.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Boolean.prototype.toNumber = function () {
+    return this.valueOf() ? 1 : 0;
+};

package/dist/extensions/number.extensions.d.ts

@@ -0,0 +1,11 @@
+export {};
+declare global {
+    interface Number {
+        between(lowestValue: Number, highestValue: Number, inclusive: boolean): boolean;
+        isEqual(value: Number): boolean;
+        isNotEqual(value: Number): boolean;
+        greaterThan(value: Number): boolean;
+        lessThan(value: Number): boolean;
+        toBoolean(value: Number): boolean;
+    }
+}

package/dist/extensions/number.extensions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Number.prototype.isEqual = function (value) {
+    return this.valueOf() === value;
+};
+Number.prototype.isNotEqual = function (value) {
+    return this.valueOf() !== value;
+};
+Number.prototype.greaterThan = function (value) {
+    return this.valueOf() > value;
+};
+Number.prototype.lessThan = function (value) {
+    return this.valueOf() < value;
+};
+Number.prototype.between = function (lowestValue, highestValue, inclusive) {
+    let value = this.valueOf();
+    if (inclusive)
+        return value >= lowestValue && value <= highestValue;
+    else
+        return value > lowestValue && value < highestValue;
+};
+Number.prototype.toBoolean = function () {
+    return Math.abs(this) !== 0;
+};

package/dist/extensions/string.extensions.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    interface String {
+        empty: string;
+        forEach(action: (element: string) => void): void;
+        isEqual(value: string): boolean;
+        isEmpty(): boolean;
+        isNotEmpty(): boolean;
+        isNumber(): boolean;
+        toNumber(): number;
+    }
+}
+export {};
+export declare const EMPTY_STRING = "";

package/dist/extensions/string.extensions.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_STRING = void 0;
+// String.prototype.empty = "";
+String.prototype.forEach = function (action) {
+    let value = this.toString();
+    for (let i = 0; i < value.length; i++)
+        action(value[i]);
+};
+String.prototype.isEqual = function (value) {
+    return value === this.toString();
+};
+String.prototype.isEmpty = function () {
+    return this.trim() === exports.EMPTY_STRING;
+};
+String.prototype.isNotEmpty = function () {
+    let value = this.toString().trim();
+    return value !== "";
+};
+String.prototype.isNumber = function () {
+    const val = this.toString().trim();
+    return val.length > 0 && !isNaN(Number(val));
+};
+String.prototype.toNumber = function () {
+    let value = Number(this.toString());
+    return isNaN(value) ? 0 : value;
+};
+exports.EMPTY_STRING = "";

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from './extensions/string.extensions';
+export * from './extensions/number.extensions';
+export * from './extensions/boolean.extensions';
+export * from './extensions/array.extensions';
+export * from './documents/models/validation-result.model';
+export * from './documents/interfaces/validator.interface';
+export * from './documents/interfaces/generator.interface';
+export * from './documents/interfaces/formatter.interface';
+export * from './documents/cpf/cpf';
+export * from './documents/cpf/cpf.validator';
+export * from './documents/cpf/cpf.generator';
+export * from './documents/cpf/cpf.formatter';
+export * from './documents/cnpj/cnpj';
+export * from './documents/cnpj/cnpj.validator';
+export * from './documents/cnpj/cnpj.generator';
+export * from './documents/cnpj/cnpj.formatter';
+export * from './random';
+export * from './converters/unit-converter/unit.converter.factory';
+export * from './converters/unit-converter/interfaces/IUnitConverter';
+export * from './converters/unit-converter/models/unit';
+export * from './converters/serialization/serialization.converter';
+export * from './converters/numeric-systems/numericSystem.converter';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/extensions/index.ts
+__exportStar(require("./extensions/string.extensions"), exports);
+__exportStar(require("./extensions/number.extensions"), exports);
+__exportStar(require("./extensions/boolean.extensions"), exports);
+__exportStar(require("./extensions/array.extensions"), exports);
+__exportStar(require("./documents/models/validation-result.model"), exports);
+__exportStar(require("./documents/interfaces/validator.interface"), exports);
+__exportStar(require("./documents/interfaces/generator.interface"), exports);
+__exportStar(require("./documents/interfaces/formatter.interface"), exports);
+__exportStar(require("./documents/cpf/cpf"), exports);
+__exportStar(require("./documents/cpf/cpf.validator"), exports);
+__exportStar(require("./documents/cpf/cpf.generator"), exports);
+__exportStar(require("./documents/cpf/cpf.formatter"), exports);
+__exportStar(require("./documents/cnpj/cnpj"), exports);
+__exportStar(require("./documents/cnpj/cnpj.validator"), exports);
+__exportStar(require("./documents/cnpj/cnpj.generator"), exports);
+__exportStar(require("./documents/cnpj/cnpj.formatter"), exports);
+__exportStar(require("./random"), exports);
+__exportStar(require("./converters/unit-converter/unit.converter.factory"), exports);
+__exportStar(require("./converters/unit-converter/interfaces/IUnitConverter"), exports);
+__exportStar(require("./converters/unit-converter/models/unit"), exports);
+__exportStar(require("./converters/serialization/serialization.converter"), exports);
+__exportStar(require("./converters/numeric-systems/numericSystem.converter"), exports);

package/dist/interfaces/IFactory.d.ts

@@ -0,0 +1,3 @@
+export interface IFactory<TService> {
+    createService(serviceId: string): TService;
+}

package/dist/interfaces/IFactory.js

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

package/dist/interfaces/IServiceCategory.d.ts

@@ -0,0 +1,3 @@
+export interface IServiceCategory {
+    id: string;
+}

package/dist/interfaces/IServiceCategory.js

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

package/dist/interfaces/validator.d.ts

@@ -0,0 +1,5 @@
+export interface IValidator {
+    message: string;
+    isValid(): boolean;
+    isValid(value: string): boolean;
+}

package/dist/interfaces/validator.js

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

package/dist/interfaces/value.d.ts

@@ -0,0 +1,3 @@
+export interface IValue {
+    value: string;
+}

package/dist/interfaces/value.js

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

package/dist/interfaces/valueGenerator.d.ts

@@ -0,0 +1,4 @@
+export interface IValueGenerator {
+    generate<T>(): T;
+    generate<T>(condition?: boolean): T;
+}

package/dist/interfaces/valueGenerator.js

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

package/dist/random.d.ts

@@ -0,0 +1,12 @@
+import { IValueGenerator } from "./interfaces/valueGenerator";
+export declare class Random implements IValueGenerator {
+    int: boolean;
+    min: number;
+    max: number;
+    constructor();
+    constructor(min: number, max: number, int: boolean);
+    private _getRandomNumber;
+    private _getRandomInteger;
+    generate(): number;
+    generate(condition: boolean): number;
+}

package/dist/random.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Random = void 0;
+class Random {
+    constructor(min, max, int) {
+        this.int = false;
+        this.min = 0;
+        this.max = 1;
+        this.int = int ?? false;
+        this.min = min ?? 0;
+        this.max = max ?? 9999;
+    }
+    _getRandomNumber(min, max) {
+        return Math.random() * (max - min) + min;
+    }
+    _getRandomInteger(min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min)) + min;
+    }
+    generate(condition) {
+        this.int = condition ?? false;
+        if (this.int)
+            return this._getRandomInteger(this.min, this.max);
+        else
+            return this._getRandomNumber(this.min, this.max);
+    }
+}
+exports.Random = Random;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "devtoolz-library",
+  "version": "1.0.0",
+  "description": "Biblioteca de funcionalidades gerais usadas no dia a dia de um desenvolvedor",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "test": "jest",
+    "debug-test": "npm test --watch"
+  },
+  "author": "Lucas Zottis",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.5.5",
+    "jest": "^30.0.2",
+    "ts-jest": "^29.4.0",
+    "typescript": "^5.6.2"
+  },
+  "files": [
+    "./dist/**/*"
+  ]
+}