devtoolz-library 1.0.0

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cnpj_validator_1 = require("../cnpj.validator");
+describe("CnpjValidator", () => {
+    let validator;
+    beforeEach(() => {
+        validator = new cnpj_validator_1.CnpjValidator();
+    });
+    // -------------------------------------------------------------------------
+    // Casos inválidos — estrutura
+    // -------------------------------------------------------------------------
+    describe("Dado um CNPJ vazio", () => {
+        it("deve retornar inválido ao receber string vazia", () => {
+            const result = validator.validate("");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CNPJ 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("CNPJ está vazio.");
+        });
+    });
+    describe("Dado um CNPJ com formato inválido", () => {
+        it("deve retornar inválido para letras", () => {
+            const result = validator.validate("ab.cde.fgh/ijkl-mn");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CNPJ com formato inválido.");
+        });
+        it("deve retornar inválido para menos de 14 dígitos", () => {
+            const result = validator.validate("1234567");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CNPJ com formato inválido.");
+        });
+        it("deve retornar inválido para mais de 14 dígitos", () => {
+            const result = validator.validate("112223330001810");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CNPJ com formato inválido.");
+        });
+        it("deve retornar inválido para máscara incorreta", () => {
+            const result = validator.validate("11-222-333/0001.81");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CNPJ com formato inválido.");
+        });
+    });
+    describe("Dado um CNPJ com todos os dígitos iguais", () => {
+        it.each([
+            "00.000.000/0000-00",
+            "11.111.111/1111-11",
+            "22.222.222/2222-22",
+            "33.333.333/3333-33",
+            "44.444.444/4444-44",
+            "55.555.555/5555-55",
+            "66.666.666/6666-66",
+            "77.777.777/7777-77",
+            "88.888.888/8888-88",
+            "99.999.999/9999-99",
+        ])("deve rejeitar %s", (cnpj) => {
+            const result = validator.validate(cnpj);
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("CNPJ não pode ter todos os dígitos iguais.");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Dígitos verificadores inválidos
+    // -------------------------------------------------------------------------
+    describe("Dado um CNPJ com dígitos verificadores inválidos", () => {
+        it("deve retornar inválido quando o primeiro dígito verificador está errado", () => {
+            const result = validator.validate("11.222.333/0001-91");
+            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 result = validator.validate("11.222.333/0001-80");
+            expect(result.isValid).toBe(false);
+            expect(result.message).toBe("Segundo dígito verificador é inválido.");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // CNPJs válidos
+    // -------------------------------------------------------------------------
+    describe("Dado um CNPJ válido", () => {
+        it("deve aceitar CNPJ sem máscara", () => {
+            const result = validator.validate("11222333000181");
+            expect(result.isValid).toBe(true);
+            expect(result.message).toBe("Válido");
+        });
+        it("deve aceitar CNPJ com máscara", () => {
+            const result = validator.validate("11.222.333/0001-81");
+            expect(result.isValid).toBe(true);
+            expect(result.message).toBe("Válido");
+        });
+        it("deve aceitar múltiplos CNPJs válidos conhecidos", () => {
+            const validos = [
+                "11222333000181",
+                "11.222.333/0001-81",
+            ];
+            validos.forEach(cnpj => {
+                const result = validator.validate(cnpj);
+                expect(result.isValid).toBe(true);
+            });
+        });
+    });
+});

package/dist/documents/cpf/cpf.d.ts

@@ -0,0 +1,14 @@
+import { IValidationResult } from "../models/validation-result.model";
+export declare class Cpf {
+    readonly baseDigits: string;
+    readonly regionDigit: string;
+    readonly firstVerifyDigit: string;
+    readonly secondVerifyDigit: string;
+    private constructor();
+    toString(): string;
+    toFormatted(): string;
+    static validate(value: string): IValidationResult;
+    static generate(formatted?: boolean): Cpf;
+    static parse(value: string): Cpf;
+    static tryParse(value: string): Cpf | null;
+}

package/dist/documents/cpf/cpf.formatter.d.ts

@@ -0,0 +1,5 @@
+import { IFormatter } from "../interfaces/formatter.interface";
+export declare class CpfFormatter implements IFormatter {
+    applyMask(cpf: string): string;
+    removeMask(cpf: string): string;
+}

package/dist/documents/cpf/cpf.formatter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CpfFormatter = void 0;
+class CpfFormatter {
+    applyMask(cpf) {
+        return cpf.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, "$1.$2.$3-$4");
+    }
+    removeMask(cpf) {
+        return cpf.replace(/[^\d]/g, "");
+    }
+}
+exports.CpfFormatter = CpfFormatter;

package/dist/documents/cpf/cpf.generator.d.ts

@@ -0,0 +1,9 @@
+import "../../extensions/string.extensions";
+import { IGenerator } from "../interfaces/generator.interface";
+export declare class CpfGenerator implements IGenerator {
+    private readonly _formatter;
+    private _isRepeatedDigits;
+    private _calcVerifyingDigit;
+    private _generateCalculatingDigits;
+    generate(formatted?: boolean): string;
+}

package/dist/documents/cpf/cpf.generator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CpfGenerator = void 0;
+const random_1 = require("../../random");
+require("../../extensions/string.extensions");
+const cpf_formatter_1 = require("./cpf.formatter");
+class CpfGenerator {
+    constructor() {
+        this._formatter = new cpf_formatter_1.CpfFormatter();
+    }
+    _isRepeatedDigits(cpf) {
+        return /^(\d)\1{8}$/.test(cpf);
+    }
+    _calcVerifyingDigit(startCounter, digits) {
+        let result = 0;
+        digits.forEach(digit => {
+            result += digit.toNumber() * startCounter--;
+        });
+        const rest = result % 11;
+        return (rest < 2 ? 0 : 11 - rest).toString();
+    }
+    _generateCalculatingDigits() {
+        const random = new random_1.Random(0, 9, true);
+        let digits = "";
+        do {
+            digits = "";
+            for (let i = 0; i < 9; i++)
+                digits += random.generate(true).toString();
+        } while (this._isRepeatedDigits(digits));
+        return digits;
+    }
+    generate(formatted = false) {
+        const calculating = this._generateCalculatingDigits();
+        const first = this._calcVerifyingDigit(10, calculating);
+        const second = this._calcVerifyingDigit(11, calculating + first);
+        const cpf = calculating + first + second;
+        return formatted ? this._formatter.applyMask(cpf) : cpf;
+    }
+}
+exports.CpfGenerator = CpfGenerator;

package/dist/documents/cpf/cpf.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cpf = void 0;
+const cpf_validator_1 = require("./cpf.validator");
+const cpf_generator_1 = require("./cpf.generator");
+const cpf_formatter_1 = require("./cpf.formatter");
+class Cpf {
+    // private _value: string = EMPTY_STRING;
+    constructor(baseDigits, regionDigit, firstVerifyDigit, secondVerifyDigit) {
+        this.baseDigits = baseDigits;
+        this.regionDigit = regionDigit;
+        // this.estados = getEstadosPorDigito(Number(regionDigit));
+        this.firstVerifyDigit = firstVerifyDigit;
+        this.secondVerifyDigit = secondVerifyDigit;
+        Object.freeze(this);
+    }
+    toString() {
+        return this.baseDigits + this.regionDigit + this.firstVerifyDigit + this.secondVerifyDigit;
+    }
+    toFormatted() {
+        const raw = this.toString();
+        const formatter = new cpf_formatter_1.CpfFormatter();
+        return formatter.applyMask(this.toString());
+    }
+    static validate(value) {
+        const validator = new cpf_validator_1.CpfValidator();
+        return validator.validate(value ?? "");
+    }
+    static generate(formatted) {
+        const generator = new cpf_generator_1.CpfGenerator();
+        const generatedValue = generator.generate(formatted);
+        return this.parse(generatedValue);
+    }
+    static parse(value) {
+        const result = this.validate(value);
+        if (!result.isValid)
+            throw new Error(result.message);
+        const digits = value.replace(/[^\d]/g, "");
+        return new Cpf(digits.substring(0, 8), digits[8], digits[9], digits[10]);
+    }
+    static tryParse(value) {
+        try {
+            return Cpf.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.Cpf = Cpf;

package/dist/documents/cpf/cpf.validator.d.ts

@@ -0,0 +1,11 @@
+import "../../extensions/string.extensions";
+import { IValidator } from "../interfaces/validator.interface";
+import { IValidationResult } from "../models/validation-result.model";
+export declare class CpfValidator implements IValidator {
+    private readonly _formatter;
+    private _isRepeatedDigits;
+    private _isFormatValid;
+    private _calcVerifyingDigit;
+    private _fail;
+    validate(value: string): IValidationResult;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CpfValidator = void 0;
+const regexPatterns_1 = require("../../constants/regexPatterns");
+require("../../extensions/string.extensions");
+const cpf_formatter_1 = require("./cpf.formatter");
+class CpfValidator {
+    constructor() {
+        this._formatter = new cpf_formatter_1.CpfFormatter();
+    }
+    _isRepeatedDigits(cpf) {
+        return /^(\d)\1{10}$/.test(cpf);
+    }
+    _isFormatValid(cpf) {
+        return regexPatterns_1.cpfPattern.test(cpf);
+    }
+    _calcVerifyingDigit(startCounter, digits) {
+        let result = 0;
+        digits.forEach(digit => {
+            result += digit.toNumber() * startCounter--;
+        });
+        const rest = result % 11;
+        return (rest < 2 ? 0 : 11 - rest).toString();
+    }
+    _fail(message) {
+        return { isValid: false, message };
+    }
+    validate(value) {
+        if (!value || value.isEmpty())
+            return this._fail("CPF está vazio.");
+        if (!this._isFormatValid(value))
+            return this._fail("CPF com formato inválido.");
+        const cpf = this._formatter.removeMask(value);
+        if (this._isRepeatedDigits(cpf))
+            return this._fail("CPF não pode ter todos os dígitos iguais.");
+        const calculating = cpf.substring(0, 9);
+        const first = cpf[9];
+        const second = cpf[10];
+        if (this._calcVerifyingDigit(10, calculating) !== first)
+            return this._fail("Primeiro dígito verificador é inválido.");
+        if (this._calcVerifyingDigit(11, calculating + first) !== second)
+            return this._fail("Segundo dígito verificador é inválido.");
+        return { isValid: true, message: "Válido" };
+    }
+}
+exports.CpfValidator = CpfValidator;

package/dist/documents/cpf/tests/cpf.formatter.test.d.ts

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

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

@@ -0,0 +1,71 @@
+"use strict";
+// import { CpfFormatter } from "./cpf.formatter";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cpf_formatter_1 = require("../cpf.formatter");
+describe("CpfFormatter", () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new cpf_formatter_1.CpfFormatter();
+    });
+    // -------------------------------------------------------------------------
+    // applyMask
+    // -------------------------------------------------------------------------
+    describe("applyMask", () => {
+        it("deve formatar CPF sem máscara para o padrão NNN.NNN.NNN-NN", () => {
+            expect(formatter.applyMask("52998224725")).toBe("529.982.247-25");
+        });
+        it("deve formatar CPF com dígito verificador zero", () => {
+            expect(formatter.applyMask("87129210740")).toBe("871.292.107-40");
+        });
+        it("deve formatar CPF iniciado com zero", () => {
+            expect(formatter.applyMask("01234567890")).toBe("012.345.678-90");
+        });
+        it("deve retornar string vazia ao receber string vazia", () => {
+            expect(formatter.applyMask("")).toBe("");
+        });
+        it("não deve alterar entrada com menos de 11 dígitos", () => {
+            expect(formatter.applyMask("1234567")).toBe("1234567");
+        });
+        it("não deve alterar entrada com mais de 11 dígitos", () => {
+            // A regex captura apenas os primeiros 11 dígitos — o excedente fica sem máscara
+            const result = formatter.applyMask("529982247250");
+            expect(result).toMatch(/^\d{3}\.\d{3}\.\d{3}-\d{2}/);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // removeMask
+    // -------------------------------------------------------------------------
+    describe("removeMask", () => {
+        it("deve remover pontos e traço do CPF formatado", () => {
+            expect(formatter.removeMask("529.982.247-25")).toBe("52998224725");
+        });
+        it("deve retornar o mesmo valor se não houver máscara", () => {
+            expect(formatter.removeMask("52998224725")).toBe("52998224725");
+        });
+        it("deve remover qualquer caractere não numérico", () => {
+            expect(formatter.removeMask("529 982 247 25")).toBe("52998224725");
+        });
+        it("deve retornar string vazia ao receber string vazia", () => {
+            expect(formatter.removeMask("")).toBe("");
+        });
+        it("deve retornar string vazia ao receber apenas caracteres não numéricos", () => {
+            expect(formatter.removeMask("...--")).toBe("");
+        });
+        it("deve preservar zeros à esquerda", () => {
+            expect(formatter.removeMask("012.345.678-90")).toBe("01234567890");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Simetria — applyMask ↔ removeMask
+    // -------------------------------------------------------------------------
+    describe("simetria entre applyMask e removeMask", () => {
+        it("removeMask(applyMask(raw)) deve retornar o valor original", () => {
+            const raw = "52998224725";
+            expect(formatter.removeMask(formatter.applyMask(raw))).toBe(raw);
+        });
+        it("applyMask(removeMask(formatted)) deve retornar o valor original", () => {
+            const formatted = "529.982.247-25";
+            expect(formatter.applyMask(formatter.removeMask(formatted))).toBe(formatted);
+        });
+    });
+});

package/dist/documents/cpf/tests/cpf.generator.test.d.ts

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cpf_generator_1 = require("../cpf.generator");
+const cpf_validator_1 = require("../cpf.validator");
+describe("CpfGenerator", () => {
+    let generator;
+    let validator;
+    beforeEach(() => {
+        generator = new cpf_generator_1.CpfGenerator();
+        validator = new cpf_validator_1.CpfValidator();
+    });
+    // -------------------------------------------------------------------------
+    // generate — sem máscara
+    // -------------------------------------------------------------------------
+    describe("generate sem formatação", () => {
+        it("deve retornar uma string com 11 dígitos", () => {
+            const result = generator.generate();
+            expect(result).toHaveLength(11);
+            expect(result).toMatch(/^\d{11}$/);
+        });
+        it("deve gerar um CPF matematicamente válido", () => {
+            const result = generator.generate();
+            const validation = validator.validate(result);
+            expect(validation.isValid).toBe(true);
+        });
+        it("não deve gerar CPF com todos os dígitos iguais", () => {
+            for (let i = 0; i < 20; i++) {
+                const result = generator.generate();
+                expect(result).not.toMatch(/^(\d)\1{10}$/);
+            }
+        });
+        it("deve gerar CPFs diferentes entre chamadas", () => {
+            const results = new Set(Array.from({ length: 20 }, () => generator.generate()));
+            expect(results.size).toBeGreaterThan(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // generate — com máscara
+    // -------------------------------------------------------------------------
+    describe("generate com formatação", () => {
+        it("deve retornar CPF no formato NNN.NNN.NNN-NN", () => {
+            const result = generator.generate(true);
+            expect(result).toMatch(/^\d{3}\.\d{3}\.\d{3}-\d{2}$/);
+        });
+        it("deve gerar um CPF formatado matematicamente válido", () => {
+            const result = generator.generate(true);
+            const validation = validator.validate(result);
+            expect(validation.isValid).toBe(true);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Consistência entre chamadas
+    // -------------------------------------------------------------------------
+    describe("consistência", () => {
+        it("deve gerar 50 CPFs válidos consecutivos", () => {
+            for (let i = 0; i < 50; i++) {
+                const cpf = generator.generate();
+                const result = validator.validate(cpf);
+                expect(result.isValid).toBe(true);
+            }
+        });
+        it("CPF gerado sem máscara e com máscara devem representar o mesmo número", () => {
+            // Gera os dois e compara apenas os dígitos
+            const raw = generator.generate(false);
+            const formatted = generator.generate(true);
+            const formattedDigits = formatted.replace(/[^\d]/g, "");
+            expect(raw).toHaveLength(11);
+            expect(formattedDigits).toHaveLength(11);
+        });
+    });
+});

package/dist/documents/cpf/tests/cpf.test.d.ts

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

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cpf_1 = require("../cpf");
+describe("Cpf", () => {
+    // -------------------------------------------------------------------------
+    // parse
+    // -------------------------------------------------------------------------
+    describe("parse", () => {
+        it("deve criar um Cpf a partir de um valor formatado válido", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf).toBeInstanceOf(cpf_1.Cpf);
+        });
+        it("deve criar um Cpf a partir de um valor sem máscara válido", () => {
+            const cpf = cpf_1.Cpf.parse("52998224725");
+            expect(cpf).toBeInstanceOf(cpf_1.Cpf);
+        });
+        it("deve preencher baseDigits com os 8 primeiros dígitos", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf.baseDigits).toBe("52998224");
+        });
+        it("deve preencher regionDigit com o nono dígito", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf.regionDigit).toBe("7");
+        });
+        it("deve preencher firstVerifyDigit com o décimo dígito", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf.firstVerifyDigit).toBe("2");
+        });
+        it("deve preencher secondVerifyDigit com o décimo primeiro dígito", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf.secondVerifyDigit).toBe("5");
+        });
+        it("deve lançar erro ao receber CPF inválido", () => {
+            expect(() => cpf_1.Cpf.parse("000.000.000-00")).toThrow();
+        });
+        it("deve lançar erro ao receber string vazia", () => {
+            expect(() => cpf_1.Cpf.parse("")).toThrow("CPF está vazio.");
+        });
+        it("deve lançar erro ao receber formato inválido", () => {
+            expect(() => cpf_1.Cpf.parse("123")).toThrow("CPF com formato inválido.");
+        });
+        it("deve lançar erro com mensagem correta para dígito verificador errado", () => {
+            expect(() => cpf_1.Cpf.parse("529.982.247-99")).toThrow("Primeiro dígito verificador é inválido.");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // tryParse
+    // -------------------------------------------------------------------------
+    describe("tryParse", () => {
+        it("deve retornar instância de Cpf para valor válido", () => {
+            const cpf = cpf_1.Cpf.tryParse("529.982.247-25");
+            expect(cpf).toBeInstanceOf(cpf_1.Cpf);
+        });
+        it("deve retornar null para CPF inválido", () => {
+            const cpf = cpf_1.Cpf.tryParse("000.000.000-00");
+            expect(cpf).toBeNull();
+        });
+        it("deve retornar null para string vazia", () => {
+            const cpf = cpf_1.Cpf.tryParse("");
+            expect(cpf).toBeNull();
+        });
+        it("deve retornar null para formato inválido", () => {
+            const cpf = cpf_1.Cpf.tryParse("abc");
+            expect(cpf).toBeNull();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // validate
+    // -------------------------------------------------------------------------
+    describe("validate", () => {
+        it("deve retornar isValid true para CPF válido", () => {
+            const result = cpf_1.Cpf.validate("529.982.247-25");
+            expect(result.isValid).toBe(true);
+        });
+        it("deve retornar isValid false para CPF inválido", () => {
+            const result = cpf_1.Cpf.validate("000.000.000-00");
+            expect(result.isValid).toBe(false);
+        });
+        it("deve retornar mensagem descritiva no resultado", () => {
+            const result = cpf_1.Cpf.validate("529.982.247-25");
+            expect(result.message).toBe("Válido");
+        });
+        it("deve retornar mensagem de erro para CPF vazio", () => {
+            const result = cpf_1.Cpf.validate("");
+            expect(result.message).toBe("CPF está vazio.");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // generate
+    // -------------------------------------------------------------------------
+    describe("generate", () => {
+        it("deve retornar uma instância de Cpf", () => {
+            const cpf = cpf_1.Cpf.generate();
+            expect(cpf).toBeInstanceOf(cpf_1.Cpf);
+        });
+        it("deve gerar um CPF com baseDigits de 8 caracteres", () => {
+            const cpf = cpf_1.Cpf.generate();
+            expect(cpf.baseDigits).toHaveLength(8);
+        });
+        it("deve gerar um CPF com regionDigit de 1 caractere numérico", () => {
+            const cpf = cpf_1.Cpf.generate();
+            expect(cpf.regionDigit).toMatch(/^\d$/);
+        });
+        it("deve gerar um CPF com firstVerifyDigit de 1 caractere numérico", () => {
+            const cpf = cpf_1.Cpf.generate();
+            expect(cpf.firstVerifyDigit).toMatch(/^\d$/);
+        });
+        it("deve gerar um CPF com secondVerifyDigit de 1 caractere numérico", () => {
+            const cpf = cpf_1.Cpf.generate();
+            expect(cpf.secondVerifyDigit).toMatch(/^\d$/);
+        });
+        it("deve gerar CPF matematicamente válido", () => {
+            const cpf = cpf_1.Cpf.generate();
+            const result = cpf_1.Cpf.validate(cpf.toString());
+            expect(result.isValid).toBe(true);
+        });
+        it("deve gerar CPF formatado matematicamente válido ao passar formatted=true", () => {
+            const cpf = cpf_1.Cpf.generate(true);
+            const result = cpf_1.Cpf.validate(cpf.toString());
+            expect(result.isValid).toBe(true);
+        });
+        it("deve gerar CPFs diferentes entre chamadas", () => {
+            const results = new Set(Array.from({ length: 20 }, () => cpf_1.Cpf.generate().toString()));
+            expect(results.size).toBeGreaterThan(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // toString / toFormatted
+    // -------------------------------------------------------------------------
+    describe("toString", () => {
+        it("deve retornar 11 dígitos sem máscara", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf.toString()).toBe("52998224725");
+        });
+        it("deve retornar apenas dígitos", () => {
+            const cpf = cpf_1.Cpf.parse("529.982.247-25");
+            expect(cpf.toString()).toMatch(/^\d{11}$/);
+        });
+    });
+    describe("toFormatted", () => {
+        it("deve retornar o CPF no formato NNN.NNN.NNN-NN", () => {
+            const cpf = cpf_1.Cpf.parse("52998224725");
+            expect(cpf.toFormatted()).toBe("529.982.247-25");
+        });
+        it("deve retornar o mesmo resultado independente de o input ter máscara", () => {
+            const semMascara = cpf_1.Cpf.parse("52998224725").toFormatted();
+            const comMascara = cpf_1.Cpf.parse("529.982.247-25").toFormatted();
+            expect(semMascara).toBe(comMascara);
+        });
+    });
+});

package/dist/documents/cpf/tests/cpf.validator.test.d.ts

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