@azure-net/kit 5.1.0 → 5.1.1

package/dist/delivery/schema/Schema.d.ts

@@ -16,10 +16,12 @@ export type ValidationMessage = string | {
     key: string;
     vars?: Record<string, unknown>;
 };
+export declare const SKIP_REMAINING_VALIDATION: unique symbol;
+export type ValidationControl = typeof SKIP_REMAINING_VALIDATION;
 export interface ValidationErrorsMap {
     [key: string]: ValidationMessage | ValidationErrorsMap;
 }
-export type ValidationResult = ValidationMessage | ValidationErrorsMap | ValidationErrorsMap[] | undefined;
+export type ValidationResult = ValidationMessage | ValidationErrorsMap | ValidationErrorsMap[] | ValidationControl | undefined;
 export type ValidationRuleResult<CurrentValue, ListValues = unknown, CurrentKey = string> = (params: ValidationParams<CurrentValue, ListValues, CurrentKey>) => ValidationResult;
 type ValidationErrors<Errors> = Errors extends ReadonlyArray<infer U> ? ValidationErrors<U>[] : IsAtomic<Errors> extends true ? ValidationMessage : Errors extends object ? {
     [K in keyof Errors]?: ValidationErrors<Errors[K]>;

package/dist/delivery/schema/Schema.js

@@ -1,5 +1,6 @@
 import { FormDataUtil } from '../../external/tools/index.js';
 import { AzureNetKitInternalError } from '../../shared/app-error/AppError.js';
+export const SKIP_REMAINING_VALIDATION = Symbol('skipRemainingValidation');
 export class SchemaFail extends Error {
     _errors;
     data;
@@ -92,6 +93,8 @@ class SchemaBuilderImpl {
                                     listValues: _preparedData,
                                     key: key
                                 });
+                                if (failMessage === SKIP_REMAINING_VALIDATION)
+                                    break;
                                 if (failMessage) {
                                     setByPath(_errors, key, failMessage);
                                     _isValid = false;

package/dist/delivery/schema/rules/Rules.d.ts

@@ -1,7 +1,8 @@
 import type { BaseValidationMessages } from './messages/Types.js';
 import type { ValidationParams, ValidationRuleResult } from '../index.js';
+type ValidationMessageOverride<T> = T extends (...args: never[]) => unknown ? T : Partial<T>;
 export type ValidationRuleParams<T extends keyof BaseValidationMessages, D = object> = D & {
-    message?: BaseValidationMessages[T];
+    message?: ValidationMessageOverride<BaseValidationMessages[T]>;
 };
 export type LengthParams = {
     length?: {
@@ -15,6 +16,35 @@ export type RangeParams = {
         max?: number;
     };
 };
+export type DateRangeParams = {
+    range?: {
+        min?: Date | string;
+        max?: Date | string;
+    };
+};
+export type PatternParams = {
+    regexp: RegExp;
+};
+export type UrlParams = {
+    protocols?: string[];
+    allowRelative?: boolean;
+};
+export type FileParams = {
+    maxSize?: number;
+    mimeTypes?: string[];
+    extensions?: string[];
+};
+export type EmailParams = {
+    trim?: boolean;
+    maxLength?: number;
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+};
+export type PhoneParams = {
+    requireCountryCode?: boolean;
+    minDigits?: number;
+    maxDigits?: number;
+};
 type ArrayItemRules<Context> = ValidationRuleResult<Context>[] | Record<string, ValidationRuleResult<Context>[]>;
 type ArrayParams<Context> = LengthParams & {
     schema?: ArrayItemRules<Context>;
@@ -47,17 +77,21 @@ export declare const createRules: <M extends BaseValidationMessages>(validationM
     boolean: <T = unknown, D_6 = unknown>(params?: ValidationRuleParams<"boolean", {
         expected?: boolean;
     }>) => ValidationRuleResult<T, D_6>;
-    email: <T = unknown, D_7 = unknown>(params?: ValidationRuleParams<"email">) => ValidationRuleResult<T, D_7>;
+    email: <T = unknown, D_7 = unknown>(params?: ValidationRuleParams<"email", EmailParams>) => ValidationRuleResult<T, D_7>;
     finite: <T = unknown, D_8 = unknown>(params?: ValidationRuleParams<"finite", RangeParams & {
         maxDigitsAfterDot?: number;
     }>) => ValidationRuleResult<T, D_8>;
     lettersOnly: <T = unknown, D_9 = unknown>(params?: ValidationRuleParams<"lettersOnly", {
         whiteSpaces?: boolean;
     }>) => ValidationRuleResult<T, D_9>;
-    phone: <T = unknown, D_10 = unknown>(params?: ValidationRuleParams<"phone">) => ValidationRuleResult<T, D_10>;
-    date: <T = unknown, D_11 = unknown>(params?: ValidationRuleParams<"date">) => ValidationRuleResult<T, D_11>;
-    allowedOnly: <T = unknown, D_12 = unknown>(params?: ValidationRuleParams<"allowedOnly", {
+    phone: <T = unknown, D_10 = unknown>(params?: ValidationRuleParams<"phone", PhoneParams>) => ValidationRuleResult<T, D_10>;
+    date: <T = unknown, D_11 = unknown>(params?: ValidationRuleParams<"date", DateRangeParams>) => ValidationRuleResult<T, D_11>;
+    condition: <T = unknown, D_12 = unknown, K = string>(predicate: (params: ValidationParams<T, D_12, K>) => boolean) => ValidationRuleResult<T, D_12, K>;
+    pattern: <T = unknown, D_13 = unknown>(params: ValidationRuleParams<"pattern", PatternParams>) => ValidationRuleResult<T, D_13>;
+    url: <T = unknown, D_14 = unknown>(params?: ValidationRuleParams<"url", UrlParams>) => ValidationRuleResult<T, D_14>;
+    file: <T = unknown, D_15 = unknown>(params?: ValidationRuleParams<"file", FileParams>) => ValidationRuleResult<T, D_15>;
+    allowedOnly: <T = unknown, D_16 = unknown>(params?: ValidationRuleParams<"allowedOnly", {
         allowed?: unknown[];
-    }>) => ValidationRuleResult<T, D_12>;
+    }>) => ValidationRuleResult<T, D_16>;
 };
 export {};

package/dist/delivery/schema/rules/Rules.js

@@ -1,4 +1,5 @@
 import { DateUtil, ObjectUtil } from '../../../external/tools/index.js';
+import { SKIP_REMAINING_VALIDATION } from '../Schema.js';
 /**
  *
  * @param validationMessages - BaseValidationMessages
@@ -9,6 +10,98 @@ export const createRules = (validationMessages) => {
     const checkVal = (val) => {
         return val !== undefined && val !== null;
     };
+    /**
+     * Checks a value against a regular expression.
+     */
+    const pattern = (params) => {
+        const { regexp, message = validationMessages.pattern } = params;
+        return ({ val }) => {
+            if (!checkVal(val))
+                return undefined;
+            if (typeof val !== 'string')
+                return message();
+            regexp.lastIndex = 0;
+            const matches = regexp.test(val);
+            regexp.lastIndex = 0;
+            return matches ? undefined : message();
+        };
+    };
+    /**
+     * Checks absolute URLs and, when enabled, relative URL paths.
+     */
+    const url = (params) => {
+        const { protocols, allowRelative = false, message } = {
+            ...params,
+            message: { ...validationMessages.url, ...params?.message }
+        };
+        const normalizedProtocols = protocols?.map((protocol) => protocol.toLowerCase().replace(/:$/, '')).filter(Boolean);
+        return ({ val }) => {
+            if (!checkVal(val))
+                return undefined;
+            if (typeof val !== 'string' || !val.length)
+                return message.base();
+            let parsed;
+            let relative = false;
+            try {
+                parsed = new URL(val);
+            }
+            catch {
+                if (!allowRelative || !val.startsWith('/') || val.startsWith('//'))
+                    return message.base();
+                parsed = new URL(val, 'https://azure-net.local');
+                relative = true;
+            }
+            if (!relative && normalizedProtocols?.length && !normalizedProtocols.includes(parsed.protocol.slice(0, -1).toLowerCase())) {
+                return message.protocol(normalizedProtocols.join(', '));
+            }
+            return undefined;
+        };
+    };
+    /**
+     * Checks one or multiple File/Blob values and optional size, MIME type and extension constraints.
+     */
+    const file = (params) => {
+        const { maxSize, mimeTypes, extensions, message } = {
+            ...params,
+            message: { ...validationMessages.file, ...params?.message }
+        };
+        const normalizedMimeTypes = mimeTypes?.map((mimeType) => mimeType.trim().toLowerCase()).filter(Boolean);
+        const normalizedExtensions = extensions?.map((extension) => extension.trim().toLowerCase().replace(/^\./, '')).filter(Boolean);
+        const isBlobLike = (value) => typeof value === 'object' &&
+            value !== null &&
+            typeof value.size === 'number' &&
+            typeof value.type === 'string' &&
+            typeof value.arrayBuffer === 'function';
+        const matchesMimeType = (actual, expected) => {
+            if (expected === '*/*')
+                return true;
+            if (expected.endsWith('/*'))
+                return actual.startsWith(expected.slice(0, -1));
+            return actual === expected;
+        };
+        return ({ val }) => {
+            if (!checkVal(val))
+                return undefined;
+            const rawFiles = Array.isArray(val) ? val : typeof FileList !== 'undefined' && val instanceof FileList ? Array.from(val) : [val];
+            if (!rawFiles.length || !rawFiles.every(isBlobLike))
+                return message.base();
+            for (const currentFile of rawFiles) {
+                if (maxSize !== undefined && currentFile.size > maxSize)
+                    return message.maxSize(maxSize);
+                const mimeType = currentFile.type.toLowerCase();
+                if (normalizedMimeTypes?.length && !normalizedMimeTypes.some((allowed) => matchesMimeType(mimeType, allowed))) {
+                    return message.mimeType(normalizedMimeTypes.join(', '));
+                }
+                if (normalizedExtensions?.length) {
+                    const fileName = currentFile.name?.toLowerCase() ?? '';
+                    const extension = fileName.includes('.') ? (fileName.split('.').pop() ?? '') : '';
+                    if (!normalizedExtensions.includes(extension))
+                        return message.extension(normalizedExtensions.join(', '));
+                }
+            }
+            return undefined;
+        };
+    };
     /**
      *
      * @param params - ValidationRuleParams<'string', LengthParams>
@@ -136,6 +229,8 @@ export const createRules = (validationMessages) => {
                                     listValues,
                                     key: `${key}[${index}]`
                                 });
+                                if (fail === SKIP_REMAINING_VALIDATION)
+                                    break;
                                 if (fail) {
                                     itemErrors['_error'] = fail;
                                     break;
@@ -156,6 +251,8 @@ export const createRules = (validationMessages) => {
                                             listValues,
                                             key: `${key}[${index}].${fieldKey}`
                                         });
+                                        if (fail === SKIP_REMAINING_VALIDATION)
+                                            break;
                                         if (fail) {
                                             itemErrors[fieldKey] = fail;
                                             break;
@@ -176,73 +273,109 @@ export const createRules = (validationMessages) => {
     };
     /**
      *
-     * @param params - ValidationRuleParams<'phone'>
+     * @param params - ValidationRuleParams<'phone', PhoneParams>
      * @returns ValidationRuleResult<T, D>
      * @description Checks if the value is a phone number and if it is valid.
      */
     const phone = (params) => {
-        const { message } = { ...params, message: params?.message ?? validationMessages.phone };
+        const { requireCountryCode = false, minDigits = 7, maxDigits = 15, message } = {
+            ...params,
+            message: { ...validationMessages.phone, ...params?.message }
+        };
         return ({ val }) => {
             if (checkVal(val)) {
                 const rawVal = String(val).trim();
                 if (!rawVal) {
-                    return message();
+                    return message.base();
                 }
                 if (!/^[\d+\s().-]+$/.test(rawVal)) {
-                    return message();
+                    return message.base();
                 }
                 const normalized = rawVal.replace(/[\s().-]/g, '');
                 if (!normalized) {
-                    return message();
+                    return message.base();
                 }
                 const plusCount = (normalized.match(/\+/g) ?? []).length;
                 if (plusCount > 1 || (plusCount === 1 && !normalized.startsWith('+'))) {
-                    return message();
+                    return message.base();
                 }
                 const hasInternationalPrefix = normalized.startsWith('+');
                 const digitsOnly = hasInternationalPrefix ? normalized.slice(1) : normalized;
                 if (!/^\d+$/.test(digitsOnly)) {
-                    return message();
-                }
-                if (hasInternationalPrefix) {
-                    return /^[1-9]\d{6,14}$/.test(digitsOnly) ? undefined : message();
+                    return message.base();
                 }
-                return /^\d{7,15}$/.test(digitsOnly) ? undefined : message();
+                if (requireCountryCode && !hasInternationalPrefix)
+                    return message.countryCode();
+                if (hasInternationalPrefix && digitsOnly.startsWith('0'))
+                    return message.base();
+                if (digitsOnly.length < minDigits)
+                    return params?.minDigits === undefined ? message.base() : message.minDigits(minDigits);
+                if (digitsOnly.length > maxDigits)
+                    return params?.maxDigits === undefined ? message.base() : message.maxDigits(maxDigits);
+                return undefined;
             }
             return undefined;
         };
     };
     /**
      *
-     * @param params - ValidationRuleParams<'date'>
+     * @param params - ValidationRuleParams<'date', DateRangeParams>
      * @returns ValidationRuleResult<T, D>
      * @description Checks if the value is a valid date.
      */
     const date = (params) => {
-        const { message } = { ...params, message: params?.message ?? validationMessages.date };
+        const { message, range } = { ...params, message: { ...validationMessages.date, ...params?.message } };
         return ({ val }) => {
-            if (checkVal(val)) {
-                return val instanceof Date || typeof val === 'string' ? (DateUtil.isDate(val) ? undefined : message()) : message();
-            }
+            if (!checkVal(val))
+                return undefined;
+            if (!(val instanceof Date || typeof val === 'string') || !DateUtil.isDate(val))
+                return message.base();
+            if (range?.min !== undefined && DateUtil.isBefore(val, range.min))
+                return message.min(range.min);
+            if (range?.max !== undefined && DateUtil.isAfter(val, range.max))
+                return message.max(range.max);
             return undefined;
         };
     };
+    /**
+     * Stops validation of the current field when the predicate returns false.
+     */
+    const condition = (predicate) => {
+        return (params) => (predicate(params) ? undefined : SKIP_REMAINING_VALIDATION);
+    };
     /**
      *
-     * @param params - ValidationRuleParams<'email'>
+     * @param params - ValidationRuleParams<'email', EmailParams>
      * @returns ValidationRuleResult<T, D>
      * @description Checks if the value is a valid email address.
      */
     const email = (params) => {
-        const { message } = { message: params?.message ?? validationMessages.email };
+        const { trim = false, maxLength, allowedDomains, blockedDomains, message } = {
+            ...params,
+            message: { ...validationMessages.email, ...params?.message }
+        };
+        const normalizeDomain = (domain) => domain.trim().toLowerCase().replace(/^@/, '');
+        const normalizedAllowedDomains = allowedDomains?.map(normalizeDomain).filter(Boolean);
+        const normalizedBlockedDomains = blockedDomains?.map(normalizeDomain).filter(Boolean);
         const emailRegExp = 
         // eslint-disable-next-line no-control-regex
         /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|[\x01-\x09\x0B\x0C\x0E-\x7F])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21-\x5A\x53-\x7F]|\\[\x01-\x09\x0B\x0C\x0E-\x7F])+)])$/i;
         return ({ val }) => {
-            if (checkVal(val)) {
-                const stringedVal = typeof val === 'string' ? String(val) : undefined;
-                return stringedVal && emailRegExp.test(stringedVal) ? undefined : message();
+            if (!checkVal(val))
+                return undefined;
+            if (typeof val !== 'string')
+                return message.base();
+            const emailValue = trim ? val.trim() : val;
+            if (!emailRegExp.test(emailValue))
+                return message.base();
+            if (maxLength !== undefined && emailValue.length > maxLength)
+                return message.maxLength(maxLength);
+            const domain = normalizeDomain(emailValue.slice(emailValue.lastIndexOf('@') + 1));
+            if (normalizedAllowedDomains?.length && !normalizedAllowedDomains.includes(domain)) {
+                return message.allowedDomain(normalizedAllowedDomains.join(', '));
             }
+            if (normalizedBlockedDomains?.length && normalizedBlockedDomains.includes(domain))
+                return message.blockedDomain(domain);
             return undefined;
         };
     };
@@ -377,5 +510,24 @@ export const createRules = (validationMessages) => {
             return undefined;
         };
     };
-    return { string, number, required, password, notSameAs, sameAs, array, boolean, email, finite, lettersOnly, phone, date, allowedOnly };
+    return {
+        string,
+        number,
+        required,
+        password,
+        notSameAs,
+        sameAs,
+        array,
+        boolean,
+        email,
+        finite,
+        lettersOnly,
+        phone,
+        date,
+        condition,
+        pattern,
+        url,
+        file,
+        allowedOnly
+    };
 };

package/dist/delivery/schema/rules/messages/En.js

@@ -1,7 +1,32 @@
 export const validationMessagesEn = {
-    date: () => 'Invalid date format',
-    phone: () => 'Invalid phone number format',
-    email: () => 'Invalid email address',
+    pattern: () => 'Invalid field format',
+    url: {
+        base: () => 'Invalid URL format',
+        protocol: (value) => `URL protocol must be one of: ${value}`
+    },
+    file: {
+        base: () => 'This field must contain a file',
+        maxSize: (value) => `File size must not exceed ${value} bytes`,
+        mimeType: (value) => `File type must be one of: ${value}`,
+        extension: (value) => `File extension must be one of: ${value}`
+    },
+    date: {
+        base: () => 'Invalid date format',
+        min: (value) => `The date must be on or after ${value instanceof Date ? value.toISOString() : value}`,
+        max: (value) => `The date must be on or before ${value instanceof Date ? value.toISOString() : value}`
+    },
+    phone: {
+        base: () => 'Invalid phone number format',
+        countryCode: () => 'Phone number must include an international country code',
+        minDigits: (value) => `Phone number must contain at least ${value} digits`,
+        maxDigits: (value) => `Phone number must contain at most ${value} digits`
+    },
+    email: {
+        base: () => 'Invalid email address',
+        maxLength: (value) => `Email address must not exceed ${value} characters`,
+        allowedDomain: (value) => `Email domain must be one of: ${value}`,
+        blockedDomain: (value) => `Email domain is not allowed: ${value}`
+    },
     required: () => 'This field is required',
     lettersOnly: (whiteSpaces) => `This field may contain letters only${whiteSpaces ? '' : ' and must not contain spaces'}`,
     allowedOnly: (value) => value && value.length ? `This field may contain only one of the following values: ${value}` : 'This field has no allowed values',

package/dist/delivery/schema/rules/messages/Ru.js

@@ -1,7 +1,32 @@
 export const validationMessagesRu = {
-    date: () => 'Неверный формат даты',
-    phone: () => 'Неверный формат номера телефона',
-    email: () => 'Невалидный email',
+    pattern: () => 'Значение не соответствует требуемому формату',
+    url: {
+        base: () => 'Неверный формат URL',
+        protocol: (value) => `Протокол URL должен быть одним из: ${value}`
+    },
+    file: {
+        base: () => 'Поле должно содержать файл',
+        maxSize: (value) => `Размер файла не должен превышать ${value} байт`,
+        mimeType: (value) => `Тип файла должен быть одним из: ${value}`,
+        extension: (value) => `Расширение файла должно быть одним из: ${value}`
+    },
+    date: {
+        base: () => 'Неверный формат даты',
+        min: (value) => `Дата должна быть не раньше ${value instanceof Date ? value.toISOString() : value}`,
+        max: (value) => `Дата должна быть не позже ${value instanceof Date ? value.toISOString() : value}`
+    },
+    phone: {
+        base: () => 'Неверный формат номера телефона',
+        countryCode: () => 'Номер телефона должен содержать международный код страны',
+        minDigits: (value) => `Номер телефона должен содержать не менее ${value} цифр`,
+        maxDigits: (value) => `Номер телефона должен содержать не более ${value} цифр`
+    },
+    email: {
+        base: () => 'Невалидный email',
+        maxLength: (value) => `Email не должен быть длиннее ${value} символов`,
+        allowedDomain: (value) => `Домен email должен быть одним из: ${value}`,
+        blockedDomain: (value) => `Домен email запрещен: ${value}`
+    },
     required: () => 'Поле обязательно к заполнению',
     lettersOnly: (whiteSpaces) => `Поле может содержать только буквы ${whiteSpaces ? '' : 'и не должно содержать пробелы'}`,
     allowedOnly: (value) => value && value.length ? `Поле может содержать только одно из следующих значений:: ${value}` : 'Поле не имеет допустимых значений',

package/dist/delivery/schema/rules/messages/Types.d.ts

@@ -1,8 +1,33 @@
 import type { ValidationMessage } from '../../index.js';
 export type BaseValidationMessages = {
-    date: () => ValidationMessage;
-    phone: () => ValidationMessage;
-    email: () => ValidationMessage;
+    pattern: () => ValidationMessage;
+    url: {
+        base: () => ValidationMessage;
+        protocol: (value: string) => ValidationMessage;
+    };
+    file: {
+        base: () => ValidationMessage;
+        maxSize: (value: number) => ValidationMessage;
+        mimeType: (value: string) => ValidationMessage;
+        extension: (value: string) => ValidationMessage;
+    };
+    date: {
+        base: () => ValidationMessage;
+        min: (value: Date | string) => ValidationMessage;
+        max: (value: Date | string) => ValidationMessage;
+    };
+    phone: {
+        base: () => ValidationMessage;
+        countryCode: () => ValidationMessage;
+        minDigits: (value: number) => ValidationMessage;
+        maxDigits: (value: number) => ValidationMessage;
+    };
+    email: {
+        base: () => ValidationMessage;
+        maxLength: (value: number) => ValidationMessage;
+        allowedDomain: (value: string) => ValidationMessage;
+        blockedDomain: (value: string) => ValidationMessage;
+    };
     required: () => ValidationMessage;
     lettersOnly: (whiteSpaces: boolean) => ValidationMessage;
     allowedOnly: (allowed: string) => ValidationMessage;

package/dist/delivery/schema/rules/messages/WithI18n.js

@@ -1,7 +1,32 @@
 export const validationMessagesI18n = {
-    date: () => 'validation.date',
-    phone: () => 'validation.phone',
-    email: () => 'validation.email',
+    pattern: () => 'validation.pattern',
+    url: {
+        base: () => 'validation.url',
+        protocol: (value) => ({ key: 'validation.urlProtocol', vars: { value } })
+    },
+    file: {
+        base: () => 'validation.file',
+        maxSize: (value) => ({ key: 'validation.fileMaxSize', vars: { value } }),
+        mimeType: (value) => ({ key: 'validation.fileMimeType', vars: { value } }),
+        extension: (value) => ({ key: 'validation.fileExtension', vars: { value } })
+    },
+    date: {
+        base: () => 'validation.date',
+        min: (value) => ({ key: 'validation.dateMin', vars: { value: value instanceof Date ? value.toISOString() : value } }),
+        max: (value) => ({ key: 'validation.dateMax', vars: { value: value instanceof Date ? value.toISOString() : value } })
+    },
+    phone: {
+        base: () => 'validation.phone',
+        countryCode: () => 'validation.phoneCountryCode',
+        minDigits: (value) => ({ key: 'validation.phoneMinDigits', vars: { value } }),
+        maxDigits: (value) => ({ key: 'validation.phoneMaxDigits', vars: { value } })
+    },
+    email: {
+        base: () => 'validation.email',
+        maxLength: (value) => ({ key: 'validation.emailMaxLength', vars: { value } }),
+        allowedDomain: (value) => ({ key: 'validation.emailAllowedDomain', vars: { value } }),
+        blockedDomain: (value) => ({ key: 'validation.emailBlockedDomain', vars: { value } })
+    },
     required: () => 'validation.required',
     lettersOnly: (whiteSpaces) => (whiteSpaces ? 'validation.lettersOnlyWithWhiteSpaces' : 'validation.lettersOnly'),
     allowedOnly: (value) => ({ key: value && value.length ? 'validation.allowedOnly.base' : 'validation.allowedOnly.nothing', vars: { value } }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",