@archi-code/validation 0.0.0-stage → 3.0.0-alpha.1

package/dist/cjs/decorator/validations.js

@@ -0,0 +1,75 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownValidations = void 0;
+exports.isCustom = isCustom;
+exports.isValidatorName = isValidatorName;
+exports.keyOf = keyOf;
+exports.Validations = Validations;
+const validators_1 = require("../validators");
+const errors_1 = require("../helpers/errors");
+const hasOwn_1 = require("../helpers/hasOwn");
+const REGISTRY = Symbol.for('@archi-code/validation/decorator.v1');
+exports.ownValidations = ((_a = globalThis)[REGISTRY] ?? (_a[REGISTRY] = new WeakMap()));
+function isCustom(validation) {
+    return validation.custom !== undefined;
+}
+function isValidatorName(name) {
+    return (0, hasOwn_1.hasOwn)(validators_1.validator, name) && typeof validators_1.validator[name] === 'function';
+}
+function assertShape(validation) {
+    if (validation === null || typeof validation !== 'object')
+        throw new errors_1.ValidationConfigError('A validation must be an object');
+    const { validator: name, custom, fn } = validation;
+    if (name !== undefined && custom !== undefined)
+        throw new errors_1.ValidationConfigError('A validation cannot have both "validator" and "custom"');
+    if (custom !== undefined) {
+        if (typeof custom !== 'string' || custom === '')
+            throw new errors_1.ValidationConfigError('"custom" must be a non-empty string');
+        if (typeof fn !== 'function')
+            throw new errors_1.ValidationConfigError(`Custom "${custom}" needs a "fn" function`);
+        return;
+    }
+    if (name === undefined)
+        throw new errors_1.ValidationConfigError('A validation needs "validator" or "custom"');
+    if (!isValidatorName(name))
+        throw new errors_1.ValidationConfigError(`Unknown validator "${String(name)}"`);
+}
+function keyOf(validation) {
+    return isCustom(validation) ? `custom:${validation.custom}` : `validator:${validation.validator}`;
+}
+function snapshot(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(snapshot));
+    if (value !== null &&
+        typeof value === 'object' &&
+        Object.getPrototypeOf(value) === Object.prototype) {
+        const copy = {};
+        for (const [key, item] of Object.entries(value))
+            copy[key] = snapshot(item);
+        return Object.freeze(copy);
+    }
+    return value;
+}
+function Validations(validations) {
+    return (target) => {
+        if (typeof target !== 'function')
+            throw new errors_1.ValidationConfigError('@Validations can only decorate a class');
+        if (!Array.isArray(validations))
+            throw new errors_1.ValidationConfigError('@Validations expects an array of validations');
+        const declared = new Set();
+        for (const validation of validations) {
+            assertShape(validation);
+            const key = keyOf(validation);
+            if (declared.has(key))
+                throw new errors_1.ValidationConfigError(isCustom(validation)
+                    ? `Custom "${validation.custom}" is declared more than once`
+                    : `Validator "${validation.validator}" is declared more than once`);
+            declared.add(key);
+        }
+        const own = new Map((exports.ownValidations.get(target) ?? []).map((v) => [keyOf(v), v]));
+        for (const validation of validations)
+            own.set(keyOf(validation), snapshot(validation));
+        exports.ownValidations.set(target, [...own.values()]);
+    };
+}

package/dist/cjs/helpers/algorithms.d.ts

@@ -0,0 +1 @@
+export declare function reverseMultiplyAndSum(digits: number[], base: number): number;

package/dist/cjs/helpers/algorithms.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseMultiplyAndSum = reverseMultiplyAndSum;
+function reverseMultiplyAndSum(digits, base) {
+    let total = 0;
+    for (let i = 0; i < digits.length; i++) {
+        total += digits[i] * (base - i);
+    }
+    return total;
+}

package/dist/cjs/helpers/analyzePassword.d.ts

@@ -0,0 +1,9 @@
+export interface PasswordAnalysis {
+    length: number;
+    uniqueChars: number;
+    uppercaseCount: number;
+    lowercaseCount: number;
+    numberCount: number;
+    symbolCount: number;
+}
+export declare function analyzePassword(password: string): PasswordAnalysis;

package/dist/cjs/helpers/analyzePassword.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePassword = analyzePassword;
+const upperCaseRegex = /^\p{Lu}$/u;
+const lowerCaseRegex = /^\p{Ll}$/u;
+const numberRegex = /^\p{Nd}$/u;
+const symbolRegex = /^[\p{P}\p{S}\p{Zs}]$/u;
+function countCodePoints(codePoints) {
+    const result = new Map();
+    for (const char of codePoints) {
+        result.set(char, (result.get(char) ?? 0) + 1);
+    }
+    return result;
+}
+function analyzePassword(password) {
+    const codePoints = Array.from(password);
+    const charMap = countCodePoints(codePoints);
+    const analysis = {
+        length: codePoints.length,
+        uniqueChars: charMap.size,
+        uppercaseCount: 0,
+        lowercaseCount: 0,
+        numberCount: 0,
+        symbolCount: 0,
+    };
+    charMap.forEach((count, char) => {
+        if (upperCaseRegex.test(char)) {
+            analysis.uppercaseCount += count;
+        }
+        else if (lowerCaseRegex.test(char)) {
+            analysis.lowercaseCount += count;
+        }
+        else if (numberRegex.test(char)) {
+            analysis.numberCount += count;
+        }
+        else if (symbolRegex.test(char)) {
+            analysis.symbolCount += count;
+        }
+    });
+    return analysis;
+}

package/dist/cjs/helpers/assertString.d.ts

@@ -0,0 +1 @@
+export declare function assertString(input?: unknown): asserts input is string;

package/dist/cjs/helpers/assertString.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertString = assertString;
+function assertString(input = undefined) {
+    if (input === undefined || input === null)
+        throw new TypeError(`Expected a string but received a ${input}`);
+    if (typeof input !== 'string')
+        throw new TypeError(`Expected a string but received a ${typeof input}`);
+}

package/dist/cjs/helpers/boundedCache.d.ts

@@ -0,0 +1,9 @@
+export declare class BoundedCache<V> {
+    private readonly maxSize;
+    private readonly map;
+    constructor(maxSize?: number);
+    get size(): number;
+    getOrCreate(key: string, create: () => V): V;
+    private markMostRecentlyUsed;
+    private evictLeastRecentlyUsed;
+}

package/dist/cjs/helpers/boundedCache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedCache = void 0;
+class BoundedCache {
+    constructor(maxSize = 256) {
+        this.maxSize = maxSize;
+        this.map = new Map();
+    }
+    get size() {
+        return this.map.size;
+    }
+    getOrCreate(key, create) {
+        const hit = this.map.get(key);
+        if (hit !== undefined) {
+            this.markMostRecentlyUsed(key, hit);
+            return hit;
+        }
+        const value = create();
+        if (this.map.size >= this.maxSize) {
+            this.evictLeastRecentlyUsed();
+        }
+        this.map.set(key, value);
+        return value;
+    }
+    markMostRecentlyUsed(key, value) {
+        this.map.delete(key);
+        this.map.set(key, value);
+    }
+    evictLeastRecentlyUsed() {
+        this.map.delete(this.map.keys().next().value);
+    }
+}
+exports.BoundedCache = BoundedCache;

package/dist/cjs/helpers/checkHost.d.ts

@@ -0,0 +1,2 @@
+export declare function checkHost(host: string, matches: (string | RegExp)[]): boolean;
+export declare function hostList(list: unknown, name: string): (string | RegExp)[];

package/dist/cjs/helpers/checkHost.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkHost = checkHost;
+exports.hostList = hostList;
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+function normalizeHost(host) {
+    const lower = host.toLowerCase();
+    return lower.endsWith('.') ? lower.slice(0, -1) : lower;
+}
+function checkHost(host, matches) {
+    const normalized = normalizeHost(host);
+    for (const match of matches) {
+        if (typeof match === 'string') {
+            if (normalized === normalizeHost(match))
+                return true;
+            continue;
+        }
+        if (testFromStart(match, normalized)) {
+            return true;
+        }
+    }
+    return false;
+}
+function testFromStart(regex, text) {
+    regex.lastIndex = 0;
+    return regex.test(text);
+}
+function hostList(list, name) {
+    if (list === undefined || list === null)
+        return [];
+    if (!Array.isArray(list) || !list.every((m) => typeof m === 'string' || m instanceof RegExp)) {
+        throw new errors_1.ValidationConfigError(`${name} must be an array of strings or RegExps, got ${(0, config_1.configText)(list)}`);
+    }
+    return list;
+}

package/dist/cjs/helpers/config.d.ts

@@ -0,0 +1,10 @@
+export declare function optionsOf<T extends object>(options: T | null | undefined, name?: string): Partial<T>;
+export declare function configText(value: unknown): string;
+export declare function boundsOf<T extends {
+    min?: number;
+    max?: number;
+}>(options: T | null | undefined): {
+    options: Partial<T>;
+    min: number;
+    max: number | undefined;
+};

package/dist/cjs/helpers/config.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionsOf = optionsOf;
+exports.configText = configText;
+exports.boundsOf = boundsOf;
+const any_to_string_1 = require("../convert/any-to-string");
+const errors_1 = require("./errors");
+function optionsOf(options, name = 'options') {
+    if (options === undefined || options === null)
+        return {};
+    if (typeof options !== 'object') {
+        throw new errors_1.ValidationConfigError(`${name} must be an object, got ${configText(options)}`);
+    }
+    return options;
+}
+function configText(value) {
+    return (0, any_to_string_1.anyToString)(value);
+}
+function boundsOf(options) {
+    const opts = optionsOf(options);
+    return {
+        options: opts,
+        min: bound(opts.min, 'min') || 0,
+        max: bound(opts.max, 'max'),
+    };
+}
+function bound(value, name) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'symbol' || typeof value === 'function' || typeof value === 'object') {
+        throw new errors_1.ValidationConfigError(`${name} must be a number, got ${configText(value)}`);
+    }
+    return value;
+}

package/dist/cjs/helpers/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class ValidationConfigError extends Error {
+    constructor(message: string);
+}

package/dist/cjs/helpers/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationConfigError = void 0;
+class ValidationConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationConfigError';
+    }
+}
+exports.ValidationConfigError = ValidationConfigError;

package/dist/cjs/helpers/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(text: string): string;

package/dist/cjs/helpers/escapeRegExp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegExp = escapeRegExp;
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&');
+}

package/dist/cjs/helpers/hasOwn.d.ts

@@ -0,0 +1 @@
+export declare function hasOwn<T extends object>(table: T, key: unknown): key is keyof T;

package/dist/cjs/helpers/hasOwn.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOwn = hasOwn;
+function hasOwn(table, key) {
+    return typeof key === 'string' && Object.prototype.hasOwnProperty.call(table, key);
+}

package/dist/cjs/helpers/merge.d.ts

@@ -0,0 +1 @@
+export declare function merge<T extends object, D extends object>(obj: T | null | undefined, defaults: D): T & D;

package/dist/cjs/helpers/merge.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = merge;
+function merge(obj, defaults) {
+    if (obj === null || typeof obj !== 'object') {
+        return { ...defaults };
+    }
+    const result = { ...obj };
+    for (const key in defaults) {
+        if (typeof result[key] === 'undefined') {
+            result[key] = defaults[key];
+        }
+    }
+    return result;
+}

package/dist/cjs/helpers/scorePassword.d.ts

@@ -0,0 +1,9 @@
+export interface ScorePasswordOptions {
+    pointsPerUnique?: number;
+    pointsPerRepeat?: number;
+    pointsForContainingLower?: number;
+    pointsForContainingUpper?: number;
+    pointsForContainingNumber?: number;
+    pointsForContainingSymbol?: number;
+}
+export declare function scorePassword(str: unknown, options?: ScorePasswordOptions): number;

package/dist/cjs/helpers/scorePassword.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scorePassword = scorePassword;
+const merge_1 = require("./merge");
+const analyzePassword_1 = require("./analyzePassword");
+const string_1 = require("../convert/string");
+const defaultOptions = {
+    pointsPerUnique: 1,
+    pointsPerRepeat: 0.5,
+    pointsForContainingLower: 10,
+    pointsForContainingUpper: 10,
+    pointsForContainingNumber: 10,
+    pointsForContainingSymbol: 10,
+};
+function scorePassword(str, options) {
+    const stringResult = (0, string_1.toString)(str);
+    if (!stringResult.ok)
+        return 0;
+    const analysis = (0, analyzePassword_1.analyzePassword)(stringResult.value);
+    const scoringOptions = (0, merge_1.merge)(options || {}, defaultOptions);
+    let points = 0;
+    points += analysis.uniqueChars * scoringOptions.pointsPerUnique;
+    points += (analysis.length - analysis.uniqueChars) * scoringOptions.pointsPerRepeat;
+    if (analysis.lowercaseCount > 0) {
+        points += scoringOptions.pointsForContainingLower;
+    }
+    if (analysis.uppercaseCount > 0) {
+        points += scoringOptions.pointsForContainingUpper;
+    }
+    if (analysis.numberCount > 0) {
+        points += scoringOptions.pointsForContainingNumber;
+    }
+    if (analysis.symbolCount > 0) {
+        points += scoringOptions.pointsForContainingSymbol;
+    }
+    return points;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,103 @@
+export { validator } from './validators';
+export { equals } from './validators/equals';
+export { contains } from './validators/contains';
+export { matches } from './validators/matches';
+export { isEmail } from './validators/isEmail';
+export { isURL } from './validators/isURL';
+export { isMACAddress } from './validators/isMACAddress';
+export { isIP } from './validators/isIP';
+export { isIPRange } from './validators/isIPRange';
+export { isFQDN } from './validators/isFQDN';
+export { isBoolean } from './validators/isBoolean';
+export { isIBAN, locales as ibanLocales } from './validators/isIBAN';
+export { isBIC } from './validators/isBIC';
+export { isAbaRouting } from './validators/isAbaRouting';
+export { isAlpha, locales as isAlphaLocales } from './validators/isAlpha';
+export { isAlphanumeric, locales as isAlphanumericLocales } from './validators/isAlphanumeric';
+export { isNumeric } from './validators/isNumeric';
+export { isPassportNumber, locales as passportNumberLocales } from './validators/isPassportNumber';
+export { isPort } from './validators/isPort';
+export { isLowercase } from './validators/isLowercase';
+export { isUppercase } from './validators/isUppercase';
+export { isAscii } from './validators/isAscii';
+export { isFullWidth } from './validators/isFullWidth';
+export { isHalfWidth } from './validators/isHalfWidth';
+export { isVariableWidth } from './validators/isVariableWidth';
+export { isMultibyte } from './validators/isMultibyte';
+export { isSemVer } from './validators/isSemVer';
+export { isSurrogatePair } from './validators/isSurrogatePair';
+export { isInt } from './validators/isInt';
+export { isIMEI } from './validators/isIMEI';
+export { isFloat, locales as isFloatLocales } from './validators/isFloat';
+export { isDecimal } from './validators/isDecimal';
+export { isHexadecimal } from './validators/isHexadecimal';
+export { isOctal } from './validators/isOctal';
+export { isDivisibleBy } from './validators/isDivisibleBy';
+export { isHexColor } from './validators/isHexColor';
+export { isRgbColor } from './validators/isRgbColor';
+export { isHSL } from './validators/isHSL';
+export { isISRC } from './validators/isISRC';
+export { isMD5 } from './validators/isMD5';
+export { isHash } from './validators/isHash';
+export { isJWT } from './validators/isJWT';
+export { isJSON } from './validators/isJSON';
+export { isEmpty } from './validators/isEmpty';
+export { isNotEmpty } from './validators/isNotEmpty';
+export { isRequired } from './validators/isRequired';
+export { isLength } from './validators/isLength';
+export { isLocale } from './validators/isLocale';
+export { isByteLength } from './validators/isByteLength';
+export { isULID } from './validators/isULID';
+export { isUUID } from './validators/isUUID';
+export { isMongoId } from './validators/isMongoId';
+export { isAfter } from './validators/isAfter';
+export { isBefore } from './validators/isBefore';
+export { isIn } from './validators/isIn';
+export { isLuhnNumber } from './validators/isLuhnNumber';
+export { isCreditCard } from './validators/isCreditCard';
+export { isIdentityCard } from './validators/isIdentityCard';
+export { isEAN } from './validators/isEAN';
+export { isISIN } from './validators/isISIN';
+export { isISBN } from './validators/isISBN';
+export { isISSN } from './validators/isISSN';
+export { isMobilePhone, locales as isMobilePhoneLocales } from './validators/isMobilePhone';
+export { isPostalCode, locales as isPostalCodeLocales } from './validators/isPostalCode';
+export { isEthereumAddress } from './validators/isEthereumAddress';
+export { isCurrency } from './validators/isCurrency';
+export { isBtcAddress } from './validators/isBtcAddress';
+export { isISO6346, isFreightContainerID } from './validators/isISO6346';
+export { isISO6391 } from './validators/isISO6391';
+export { isISO8601 } from './validators/isISO8601';
+export { isISO15924 } from './validators/isISO15924';
+export { isRFC3339 } from './validators/isRFC3339';
+export { isISO31661Alpha2 } from './validators/isISO31661Alpha2';
+export { isISO31661Alpha3 } from './validators/isISO31661Alpha3';
+export { isISO31661Numeric } from './validators/isISO31661Numeric';
+export { isISO4217 } from './validators/isISO4217';
+export { isBase32 } from './validators/isBase32';
+export { isBase58 } from './validators/isBase58';
+export { isBase64 } from './validators/isBase64';
+export { isDataURI } from './validators/isDataURI';
+export { isMagnetURI } from './validators/isMagnetURI';
+export { isMailtoURI } from './validators/isMailtoURI';
+export { isMimeType } from './validators/isMimeType';
+export { isLatLong } from './validators/isLatLong';
+export { isWhitelisted } from './validators/isWhitelisted';
+export { isSlug } from './validators/isSlug';
+export { isStrongPassword } from './validators/isStrongPassword';
+export { isDate } from './validators/isDate';
+export { isTime } from './validators/isTime';
+export { isLicensePlate } from './validators/isLicensePlate';
+export { isVAT } from './validators/isVAT';
+export * from './canBe';
+export * from './convert';
+export * as sanitizer from './sanitizer';
+export { Validations } from './decorator/validations';
+export { runValidations } from './decorator/validate';
+export type { Validation, BuiltInValidation, CustomValidation, ValidatorName, ValidationProperties, ValidatedClass, } from './decorator/validations';
+export type { ValidationError, ValidationSuccess, ValidationFailure, ValidationResult, Validatable, } from './decorator/validate';
+export { scorePassword } from './helpers/scorePassword';
+export type { ScorePasswordOptions } from './helpers/scorePassword';
+export { ValidationConfigError } from './helpers/errors';
+export type * from './validators';
+export type { NormalizeEmailOptions } from './sanitizer/normalizeEmail';