@atlantjs/arch 15.6.6 → 15.7.0

package/src/objects/datetime/points/week-day.enum.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WeekDayEnum = void 0;
-var WeekDayEnum;
-(function (WeekDayEnum) {
-    WeekDayEnum["sunday"] = "sunday";
-    WeekDayEnum["monday"] = "monday";
-    WeekDayEnum["tuesday"] = "tuesday";
-    WeekDayEnum["wednesday"] = "wednesday";
-    WeekDayEnum["thursday"] = "thursday";
-    WeekDayEnum["friday"] = "friday";
-    WeekDayEnum["saturday"] = "saturday";
-})(WeekDayEnum || (exports.WeekDayEnum = WeekDayEnum = {}));

package/src/objects/failure/edges/failure.abstract.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FailureAbstract = void 0;
-const index_1 = require("#/index");
-const environment_point_1 = require("#/objects/@common/points/environment.point");
-class FailureAbstract {
-    constructor(props) {
-        this.props = props;
-        this._code = this.props.failureClass.name.toKebabCase();
-        if (index_1._.and(index_1._.isEqual(process.env.ENVIRONMENT, environment_point_1.EnvironmentPoint.development), index_1._.isNotNullOrUndefined(this.props.stackTrace))) {
-            this._message = `${this.props.message} - ${this.props.stackTrace.toString()}`;
-        }
-        else {
-            this._message = this.props.message;
-        }
-    }
-    toPolygon() {
-        return {
-            code: this._code,
-            message: this._message,
-        };
-    }
-}
-exports.FailureAbstract = FailureAbstract;

package/src/objects/failure/edges/failure.abstract.polygon.js

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

package/src/objects/language/points/language.point.js

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LanguagePoint = void 0;
-// Android-supported BCP 47 locale tags
-// Reference: https://developer.android.com/reference/java/util/Locale
-var LanguagePoint;
-(function (LanguagePoint) {
-    // =========================
-    // AFRO-ASIATIC
-    // =========================
-    LanguagePoint["amharic"] = "am";
-    LanguagePoint["arabic"] = "ar";
-    LanguagePoint["hebrew"] = "he";
-    // =========================
-    // AUSTRONESIAN
-    // =========================
-    LanguagePoint["filipino"] = "fil";
-    LanguagePoint["indonesian"] = "id";
-    LanguagePoint["malay"] = "ms";
-    // =========================
-    // DRAVIDIAN
-    // =========================
-    LanguagePoint["kannada"] = "kn";
-    LanguagePoint["malayalam"] = "ml";
-    LanguagePoint["tamil"] = "ta";
-    LanguagePoint["telugu"] = "te";
-    // =========================
-    // INDO-EUROPEAN — GERMANIC
-    // =========================
-    LanguagePoint["afrikaans"] = "af";
-    LanguagePoint["danish"] = "da";
-    LanguagePoint["dutch"] = "nl";
-    LanguagePoint["english"] = "en";
-    LanguagePoint["englishUs"] = "en-US";
-    LanguagePoint["englishGb"] = "en-GB";
-    LanguagePoint["german"] = "de";
-    LanguagePoint["icelandic"] = "is";
-    LanguagePoint["norwegian"] = "no";
-    LanguagePoint["swedish"] = "sv";
-    // =========================
-    // INDO-EUROPEAN — ROMANCE
-    // =========================
-    LanguagePoint["catalan"] = "ca";
-    LanguagePoint["french"] = "fr";
-    LanguagePoint["frenchFr"] = "fr-FR";
-    LanguagePoint["frenchCa"] = "fr-CA";
-    LanguagePoint["galician"] = "gl";
-    LanguagePoint["italian"] = "it";
-    LanguagePoint["portuguese"] = "pt";
-    LanguagePoint["portugueseBr"] = "pt-BR";
-    LanguagePoint["portuguesePt"] = "pt-PT";
-    LanguagePoint["romanian"] = "ro";
-    LanguagePoint["spanish"] = "es";
-    LanguagePoint["spanishEs"] = "es-ES";
-    LanguagePoint["spanishMx"] = "es-MX";
-    LanguagePoint["spanishAr"] = "es-AR";
-    // =========================
-    // INDO-EUROPEAN — SLAVIC
-    // =========================
-    LanguagePoint["bulgarian"] = "bg";
-    LanguagePoint["croatian"] = "hr";
-    LanguagePoint["czech"] = "cs";
-    LanguagePoint["polish"] = "pl";
-    LanguagePoint["russian"] = "ru";
-    LanguagePoint["serbian"] = "sr";
-    LanguagePoint["slovak"] = "sk";
-    LanguagePoint["slovenian"] = "sl";
-    LanguagePoint["ukrainian"] = "uk";
-    // =========================
-    // INDO-EUROPEAN — INDO-ARYAN
-    // =========================
-    LanguagePoint["bengali"] = "bn";
-    LanguagePoint["gujarati"] = "gu";
-    LanguagePoint["hindi"] = "hi";
-    LanguagePoint["marathi"] = "mr";
-    LanguagePoint["nepali"] = "ne";
-    LanguagePoint["punjabi"] = "pa";
-    LanguagePoint["sinhala"] = "si";
-    LanguagePoint["urdu"] = "ur";
-    // =========================
-    // INDO-EUROPEAN — OTHER
-    // =========================
-    LanguagePoint["armenian"] = "hy";
-    LanguagePoint["greek"] = "el";
-    LanguagePoint["latvian"] = "lv";
-    LanguagePoint["lithuanian"] = "lt";
-    LanguagePoint["persian"] = "fa";
-    // =========================
-    // KARTVELIAN
-    // =========================
-    LanguagePoint["georgian"] = "ka";
-    // =========================
-    // JAPONIC
-    // =========================
-    LanguagePoint["japanese"] = "ja";
-    // =========================
-    // KOREANIC
-    // =========================
-    LanguagePoint["korean"] = "ko";
-    // =========================
-    // SINO-TIBETAN
-    // =========================
-    LanguagePoint["chineseSimplified"] = "zh-CN";
-    LanguagePoint["chineseTraditional"] = "zh-TW";
-    LanguagePoint["burmese"] = "my";
-    // =========================
-    // TAI-KADAI
-    // =========================
-    LanguagePoint["thai"] = "th";
-    LanguagePoint["lao"] = "lo";
-    // =========================
-    // TURKIC
-    // =========================
-    LanguagePoint["azerbaijani"] = "az";
-    LanguagePoint["kazakh"] = "kk";
-    LanguagePoint["turkish"] = "tr";
-    LanguagePoint["uzbek"] = "uz";
-    // =========================
-    // URALIC
-    // =========================
-    LanguagePoint["estonian"] = "et";
-    LanguagePoint["finnish"] = "fi";
-    LanguagePoint["hungarian"] = "hu";
-    // =========================
-    // AUSTROASIATIC
-    // =========================
-    LanguagePoint["khmer"] = "km";
-    LanguagePoint["vietnamese"] = "vi";
-    // =========================
-    // OTHER
-    // =========================
-    LanguagePoint["basque"] = "eu";
-    LanguagePoint["swahili"] = "sw";
-    LanguagePoint["zulu"] = "zu";
-})(LanguagePoint || (exports.LanguagePoint = LanguagePoint = {}));

package/src/objects/metadata/metadata.edge.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataEdge = void 0;
-const edge_abstract_1 = require("#/objects-interface/edges/edge.abstract");
-const datetime_edge_1 = require("#/objects/datetime/edges/datetime.edge");
-class MetadataEdge extends edge_abstract_1.EdgeAbstract {
-    constructor(_createdAt = new datetime_edge_1.DatetimeEdge(), _updatedAt = new datetime_edge_1.DatetimeEdge()) {
-        super();
-        this._createdAt = _createdAt;
-        this._updatedAt = _updatedAt;
-    }
-    get createdAt() {
-        return this._createdAt;
-    }
-    get updatedAt() {
-        return this._updatedAt;
-    }
-    toPolygon() {
-        return {
-            createdAt: this._createdAt.toISOString(),
-            updatedAt: this._updatedAt.toISOString(),
-        };
-    }
-}
-exports.MetadataEdge = MetadataEdge;

package/src/objects/metadata/metadata.polygon.js

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

package/src/objects/metadata/metadata.uv.js

@@ -1,29 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataUv = void 0;
-const class_validator_1 = require("class-validator");
-const datetime_edge_1 = require("#/objects/datetime/edges/datetime.edge");
-const metadata_edge_1 = require("#/objects/metadata/metadata.edge");
-class MetadataUv {
-    toEntity() {
-        return new metadata_edge_1.MetadataEdge(new datetime_edge_1.DatetimeEdge(this.createdAt), new datetime_edge_1.DatetimeEdge(this.updatedAt));
-    }
-}
-exports.MetadataUv = MetadataUv;
-__decorate([
-    (0, class_validator_1.IsDateString)(),
-    __metadata("design:type", String)
-], MetadataUv.prototype, "createdAt", void 0);
-__decorate([
-    (0, class_validator_1.IsDateString)(),
-    __metadata("design:type", String)
-], MetadataUv.prototype, "updatedAt", void 0);

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

@@ -1,175 +0,0 @@
-"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 {
-    constructor(password) {
-        this.password = password;
-        this.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 }),
-        ];
-        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.js

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

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

@@ -1,34 +0,0 @@
-"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 {
-    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.js

@@ -1,61 +0,0 @@
-"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 {
-    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.js

@@ -1,27 +0,0 @@
-"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 {
-    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.js

@@ -1,34 +0,0 @@
-"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 {
-    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.js

@@ -1,19 +0,0 @@
-"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 {
-    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.js

@@ -1,17 +0,0 @@
-"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 {
-    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.js

@@ -1,13 +0,0 @@
-"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.js

@@ -1,14 +0,0 @@
-"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.js

@@ -1,14 +0,0 @@
-"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;