@atlantjs/arch 15.7.7 → 15.7.8

package/src/objects/password/password.edge.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordEdge = void 0;
+const guardian_1 = require("../../@tool-box/utils/type-guard/guardian");
+const with_at_least_one_letter_step_1 = require("../../objects/password/steps/with-at-least-one-letter-step");
+const with_at_least_one_number_digit_step_1 = require("../../objects/password/steps/with-at-least-one-number-digit-step");
+const with_at_least_one_special_char_step_1 = require("../../objects/password/steps/with-at-least-one-special-char-step");
+const with_length_step_1 = require("../../objects/password/steps/with-length-step");
+class PasswordEdge {
+    password;
+    validationSteps = [
+        new with_at_least_one_letter_step_1.WithAtLeastOneLetterStep(),
+        new with_at_least_one_number_digit_step_1.WithAtLeastOneNumberDigitStep(),
+        new with_at_least_one_special_char_step_1.WithAtLeastOneSpecialCharStep(),
+        new with_length_step_1.WithLengthStep({ min: 6, max: 999 }),
+    ];
+    constructor(password) {
+        this.password = password;
+        const { valid, validationStepsResults } = this.validate(this.password);
+        if (!valid) {
+            // 🐛 fix: valid é boolean, não tem método .falsy()
+            throw new TypeError(`Password is invalid: ${validationStepsResults.map((result) => result.name).join(", ")}`);
+        }
+    }
+    validate(password) {
+        if (guardian_1._.isEqual(this.validationSteps.length, 0)) {
+            throw new TypeError("No validations found");
+        }
+        const validationStepsResults = [];
+        for (const step of this.validationSteps) {
+            validationStepsResults.push(step.validate(password));
+        }
+        const valid = validationStepsResults.every((result) => result.valid);
+        return { valid, validationStepsResults };
+    }
+    // ==================== Getters ====================
+    /**
+     * Retorna a senha como string.
+     * @returns String interna da senha
+     * @example
+     * new PasswordEdge("Abc@123").toString() // "Abc@123"
+     */
+    toString() {
+        return this.password;
+    }
+    /**
+     * Retorna o comprimento da senha.
+     * @returns Número de caracteres da senha
+     * @example
+     * new PasswordEdge("Abc@123").length() // 7
+     */
+    length() {
+        return this.password.length;
+    }
+    // ==================== Verificações ====================
+    /**
+     * Verifica se a senha contém ao menos uma letra maiúscula.
+     * @returns true se contém ao menos uma letra maiúscula, false caso contrário
+     * @example
+     * new PasswordEdge("Abc@123").hasUpperCase() // true
+     * new PasswordEdge("abc@123").hasUpperCase() // false
+     */
+    hasUpperCase() {
+        return /[A-Z]/.test(this.password);
+    }
+    /**
+     * Verifica se a senha contém ao menos uma letra minúscula.
+     * @returns true se contém ao menos uma letra minúscula, false caso contrário
+     * @example
+     * new PasswordEdge("Abc@123").hasLowerCase() // true
+     * new PasswordEdge("ABC@123").hasLowerCase() // false
+     */
+    hasLowerCase() {
+        return /[a-z]/.test(this.password);
+    }
+    /**
+     * Verifica se a senha contém ao menos um dígito numérico.
+     * @returns true se contém ao menos um número, false caso contrário
+     * @example
+     * new PasswordEdge("Abc@123").hasNumber() // true
+     * new PasswordEdge("Abcdef@").hasNumber() // false
+     */
+    hasNumber() {
+        return /[0-9]/.test(this.password);
+    }
+    /**
+     * Verifica se a senha contém ao menos um caractere especial.
+     * @returns true se contém ao menos um caractere especial, false caso contrário
+     * @example
+     * new PasswordEdge("Abc@123").hasSpecialChar() // true
+     * new PasswordEdge("Abc1234").hasSpecialChar() // false
+     */
+    hasSpecialChar() {
+        return /[^a-zA-Z0-9]/.test(this.password);
+    }
+    /**
+     * Verifica se a senha contém espaços.
+     * @returns true se contém ao menos um espaço, false caso contrário
+     * @example
+     * new PasswordEdge("Abc @123").hasWhitespace() // true
+     * new PasswordEdge("Abc@123").hasWhitespace() // false
+     */
+    hasWhitespace() {
+        return /\s/.test(this.password);
+    }
+    /**
+     * Verifica se a senha é igual a outra.
+     * @param password - String ou PasswordEdge para comparação
+     * @returns true se as senhas são iguais, false caso contrário
+     * @example
+     * new PasswordEdge("Abc@123").isEqual(new PasswordEdge("Abc@123")) // true
+     * new PasswordEdge("Abc@123").isEqual("Abc@123") // true
+     * new PasswordEdge("Abc@123").isEqual("xyz@999") // false
+     */
+    isEqual(password) {
+        const comparand = password instanceof PasswordEdge ? password.toString() : password;
+        return this.password === comparand;
+    }
+    /**
+     * Avalia a força da senha com base em critérios de complexidade.
+     * @returns "weak" | "medium" | "strong" conforme a pontuação
+     * @example
+     * new PasswordEdge("abc@123").strength() // "weak"
+     * new PasswordEdge("Abcd@123").strength() // "medium"
+     * new PasswordEdge("Abcd@1234!X").strength() // "strong"
+     */
+    strength() {
+        let score = 0;
+        if (this.hasUpperCase())
+            score++;
+        if (this.hasLowerCase())
+            score++;
+        if (this.hasNumber())
+            score++;
+        if (this.hasSpecialChar())
+            score++;
+        if (this.password.length >= 10)
+            score++;
+        if (this.password.length >= 16)
+            score++;
+        if (score <= 2)
+            return "weak";
+        if (score <= 4)
+            return "medium";
+        return "strong";
+    }
+    /**
+     * Retorna o resultado detalhado de cada etapa de validação da senha.
+     * @returns Array com o resultado de cada ValidationStep
+     * @example
+     * new PasswordEdge("Abc@123").validationResults()
+     * // [{ name: "WithAtLeastOneLetterStep", valid: true }, ...]
+     */
+    validationResults() {
+        return this.validate(this.password).validationStepsResults;
+    }
+    // ==================== Métodos Estáticos ====================
+    /**
+     * Verifica se uma string é uma senha válida sem lançar exceção.
+     * @param password - String a ser verificada
+     * @returns true se a senha é válida, false caso contrário
+     * @example
+     * PasswordEdge.isValid("Abc@123") // true
+     * PasswordEdge.isValid("abc") // false
+     */
+    static isValid(password) {
+        try {
+            new PasswordEdge(password);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.PasswordEdge = PasswordEdge;

package/src/objects/password/password.polygon.d.ts

@@ -1,6 +1,5 @@
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStepResult } from "../../objects/password/validation-step.type";
 export interface PasswordPolicyResultPolygon {
     valid: boolean;
     validationStepsResults: ValidationStepResult[];
 }
-//# sourceMappingURL=password.polygon.d.ts.map

package/src/objects/password/password.polygon.js

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

package/src/objects/password/steps/not-allowing-consecutive-chars-step.d.ts

@@ -1,5 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export interface NotAllowingConsecutiveCharsStepOptions {
     maxAllowedConsecutiveChars: number;
 }
@@ -9,4 +9,3 @@ export declare class NotAllowingConsecutiveCharsStep extends ValidationStep {
     validate(password: string): ValidationStepResult;
     private getMaxNumberOfConsecutiveChars;
 }
-//# sourceMappingURL=not-allowing-consecutive-chars-step.d.ts.map

package/src/objects/password/steps/not-allowing-consecutive-chars-step.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingConsecutiveCharsStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NotAllowingConsecutiveCharsStep extends validation_step_1.ValidationStep {
+    params;
+    constructor(params) {
+        super();
+        this.params = params;
+    }
+    validate(password) {
+        return {
+            valid: this.getMaxNumberOfConsecutiveChars(password) <=
+                this.params.maxAllowedConsecutiveChars,
+            name: this.name,
+        };
+    }
+    getMaxNumberOfConsecutiveChars(password) {
+        let numberOfConsecutiveChars = 1;
+        let maxNumberOfConsecutiveChars = 1;
+        for (let i = 1; i < password.length; i++) {
+            const previousChar = password[i - 1];
+            const char = password[i];
+            if (Math.abs(previousChar.charCodeAt(0) - char.charCodeAt(0)) === 1) {
+                numberOfConsecutiveChars += 1;
+            }
+            else {
+                maxNumberOfConsecutiveChars = Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
+                numberOfConsecutiveChars = 1;
+            }
+        }
+        return Math.max(numberOfConsecutiveChars, maxNumberOfConsecutiveChars);
+    }
+}
+exports.NotAllowingConsecutiveCharsStep = NotAllowingConsecutiveCharsStep;

package/src/objects/password/steps/not-allowing-date-step.d.ts

@@ -1,5 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class NotAllowingDateStep extends ValidationStep {
     private readonly notAllowedDate;
     constructor(notAllowedDate: Date);
@@ -9,4 +9,3 @@ export declare class NotAllowingDateStep extends ValidationStep {
     private buildMonthFormats;
     private buildYearFormat;
 }
-//# sourceMappingURL=not-allowing-date-step.d.ts.map

package/src/objects/password/steps/not-allowing-date-step.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingDateStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NotAllowingDateStep extends validation_step_1.ValidationStep {
+    notAllowedDate;
+    constructor(notAllowedDate) {
+        super();
+        this.notAllowedDate = notAllowedDate;
+    }
+    validate(password) {
+        const cleanPassword = password.replace(/[^\w]/gi, "");
+        const result = this.possibleDateCombinations().every((dateFormat) => !cleanPassword.includes(dateFormat.toLowerCase()));
+        return {
+            valid: result,
+            name: this.name,
+        };
+    }
+    possibleDateCombinations() {
+        const formats = [];
+        this.buildDayFormats().forEach((day) => {
+            this.buildMonthFormats().forEach((month) => {
+                this.buildYearFormat().forEach((year) => {
+                    formats.push(`${day}${month}`);
+                    formats.push(`${month}${day}`);
+                    formats.push(`${day}${month}${year}`);
+                    formats.push(`${month}${day}${year}`);
+                    formats.push(`${year}${month}${day}`);
+                });
+            });
+        });
+        return [...new Set(formats)];
+    }
+    buildDayFormats() {
+        const day = this.notAllowedDate.getUTCDate();
+        const dayLength = 2;
+        return [
+            ...new Set([day.toString(), day.toString().padStart(dayLength, "0")]),
+        ];
+    }
+    buildMonthFormats() {
+        const month = this.notAllowedDate.getUTCMonth() + 1;
+        const monthLength = 2;
+        return [
+            ...new Set([
+                month.toString(),
+                month.toString().padStart(monthLength, "0"),
+            ]),
+        ];
+    }
+    buildYearFormat() {
+        const year = this.notAllowedDate.getUTCFullYear();
+        const abbreviateYearLength = 2;
+        return [
+            ...new Set([
+                year.toString(),
+                year.toString().slice(-abbreviateYearLength),
+            ]),
+        ];
+    }
+}
+exports.NotAllowingDateStep = NotAllowingDateStep;

package/src/objects/password/steps/not-allowing-phone-step.d.ts

@@ -1,8 +1,7 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class NotAllowingPhoneStep extends ValidationStep {
     private readonly notAllowedPhone?;
     constructor(phone: string);
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=not-allowing-phone-step.d.ts.map

package/src/objects/password/steps/not-allowing-phone-step.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingPhoneStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NotAllowingPhoneStep extends validation_step_1.ValidationStep {
+    notAllowedPhone;
+    constructor(phone) {
+        super();
+        const matches = phone.match(/\d{4}-?\d{4}$/);
+        if (matches) {
+            this.notAllowedPhone = matches[0].replace(/-/, "");
+        }
+    }
+    validate(password) {
+        if (!this.notAllowedPhone) {
+            return {
+                valid: true,
+                name: this.name,
+            };
+        }
+        const cleanPassword = password.replace(/[-\s]/gi, "");
+        return {
+            valid: !cleanPassword.includes(this.notAllowedPhone),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingPhoneStep = NotAllowingPhoneStep;

package/src/objects/password/steps/not-allowing-repeated-chars-step.d.ts

@@ -1,5 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export interface NotAllowingRepeatedCharsStepOptions {
     maxAllowedRepeatedChars: number;
 }
@@ -9,4 +9,3 @@ export declare class NotAllowingRepeatedCharsStep extends ValidationStep {
     validate(password: string): ValidationStepResult;
     private getMaxNumberOfRepeatedChars;
 }
-//# sourceMappingURL=not-allowing-repeated-chars-step.d.ts.map

package/src/objects/password/steps/not-allowing-repeated-chars-step.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingRepeatedCharsStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NotAllowingRepeatedCharsStep extends validation_step_1.ValidationStep {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: this.getMaxNumberOfRepeatedChars(password) <=
+                this.options.maxAllowedRepeatedChars,
+            name: this.name,
+        };
+    }
+    getMaxNumberOfRepeatedChars(password) {
+        let numberOfRepeatedChars = 1;
+        let maxNumberOfRepeatedChars = 1;
+        for (let i = 1; i < password.length; i++) {
+            const previousChar = password[i - 1];
+            const char = password[i];
+            if (previousChar === char) {
+                numberOfRepeatedChars += 1;
+            }
+            else {
+                maxNumberOfRepeatedChars = Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
+                numberOfRepeatedChars = 1;
+            }
+        }
+        return Math.max(numberOfRepeatedChars, maxNumberOfRepeatedChars);
+    }
+}
+exports.NotAllowingRepeatedCharsStep = NotAllowingRepeatedCharsStep;

package/src/objects/password/steps/not-allowing-string-step.d.ts

@@ -1,8 +1,7 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class NotAllowingStringStep extends ValidationStep {
     private readonly forbiddenString;
     constructor(forbiddenString: string);
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=not-allowing-string-step.d.ts.map

package/src/objects/password/steps/not-allowing-string-step.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingStringStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NotAllowingStringStep extends validation_step_1.ValidationStep {
+    forbiddenString;
+    constructor(forbiddenString) {
+        super();
+        this.forbiddenString = forbiddenString;
+    }
+    validate(password) {
+        return {
+            valid: !password
+                .toLowerCase()
+                .includes(this.forbiddenString.toLowerCase()),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingStringStep = NotAllowingStringStep;

package/src/objects/password/steps/not-allowing-these-chars-step.d.ts

@@ -1,5 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export interface NotAllowingTheseCharsStepOptions {
     notAllowedCharsList: string[];
 }
@@ -8,4 +8,3 @@ export declare class NotAllowingTheseCharsStep extends ValidationStep {
     constructor(options: NotAllowingTheseCharsStepOptions);
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=not-allowing-these-chars-step.d.ts.map

package/src/objects/password/steps/not-allowing-these-chars-step.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowingTheseCharsStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NotAllowingTheseCharsStep extends validation_step_1.ValidationStep {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: this.options.notAllowedCharsList.every((char) => !password.toLowerCase().includes(char.toLowerCase())),
+            name: this.name,
+        };
+    }
+}
+exports.NotAllowingTheseCharsStep = NotAllowingTheseCharsStep;

package/src/objects/password/steps/numeric-step.d.ts

@@ -1,6 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class NumericStep extends ValidationStep {
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=numeric-step.d.ts.map

package/src/objects/password/steps/numeric-step.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class NumericStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        return {
+            valid: /^\d+$/.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.NumericStep = NumericStep;

package/src/objects/password/steps/with-at-least-one-letter-step.d.ts

@@ -1,6 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class WithAtLeastOneLetterStep extends ValidationStep {
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=with-at-least-one-letter-step.d.ts.map

package/src/objects/password/steps/with-at-least-one-letter-step.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithAtLeastOneLetterStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class WithAtLeastOneLetterStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        const regex = /[a-zA-Z]/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.WithAtLeastOneLetterStep = WithAtLeastOneLetterStep;

package/src/objects/password/steps/with-at-least-one-number-digit-step.d.ts

@@ -1,6 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class WithAtLeastOneNumberDigitStep extends ValidationStep {
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=with-at-least-one-number-digit-step.d.ts.map

package/src/objects/password/steps/with-at-least-one-number-digit-step.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithAtLeastOneNumberDigitStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class WithAtLeastOneNumberDigitStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        const regex = /\d/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.WithAtLeastOneNumberDigitStep = WithAtLeastOneNumberDigitStep;

package/src/objects/password/steps/with-at-least-one-special-char-step.d.ts

@@ -1,6 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export declare class WithAtLeastOneSpecialCharStep extends ValidationStep {
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=with-at-least-one-special-char-step.d.ts.map

package/src/objects/password/steps/with-at-least-one-special-char-step.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithAtLeastOneSpecialCharStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class WithAtLeastOneSpecialCharStep extends validation_step_1.ValidationStep {
+    validate(password) {
+        const regex = /[ `!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?~]/;
+        return {
+            valid: regex.test(password),
+            name: this.name,
+        };
+    }
+}
+exports.WithAtLeastOneSpecialCharStep = WithAtLeastOneSpecialCharStep;

package/src/objects/password/steps/with-length-step.d.ts

@@ -1,5 +1,5 @@
-import { ValidationStep } from "#/objects/password/validation-step";
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStep } from "../../../objects/password/validation-step";
+import { ValidationStepResult } from "../../../objects/password/validation-step.type";
 export interface WithLengthStepOptions {
     min: number;
     max: number;
@@ -9,4 +9,3 @@ export declare class WithLengthStep extends ValidationStep {
     constructor(options: WithLengthStepOptions);
     validate(password: string): ValidationStepResult;
 }
-//# sourceMappingURL=with-length-step.d.ts.map

package/src/objects/password/steps/with-length-step.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithLengthStep = void 0;
+const validation_step_1 = require("../../../objects/password/validation-step");
+class WithLengthStep extends validation_step_1.ValidationStep {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validate(password) {
+        return {
+            valid: password.length >= this.options.min &&
+                password.length <= this.options.max,
+            name: this.name,
+        };
+    }
+}
+exports.WithLengthStep = WithLengthStep;

package/src/objects/password/validation-step.d.ts

@@ -1,6 +1,5 @@
-import { ValidationStepResult } from "#/objects/password/validation-step.type";
+import { ValidationStepResult } from "../../objects/password/validation-step.type";
 export declare abstract class ValidationStep {
     abstract validate(password: string): ValidationStepResult;
     protected get name(): string;
 }
-//# sourceMappingURL=validation-step.d.ts.map

package/src/objects/password/validation-step.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationStep = void 0;
+class ValidationStep {
+    get name() {
+        return this.constructor.name;
+    }
+}
+exports.ValidationStep = ValidationStep;

package/src/objects/password/validation-step.type.d.ts

@@ -2,4 +2,3 @@ export interface ValidationStepResult {
     valid: boolean;
     name: string;
 }
-//# sourceMappingURL=validation-step.type.d.ts.map

package/src/objects/password/validation-step.type.js

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

package/src/objects/primitives/boolean.edge.sketch.d.ts

@@ -107,4 +107,3 @@ export declare abstract class BooleanEdgeSketch {
      */
     fold<T>(onTrue: T, onFalse: T): T;
 }
-//# sourceMappingURL=boolean.edge.sketch.d.ts.map