@azure-net/kit 0.8.9 → 0.9.1

package/dist/core/delivery/injectableDependencies/ErrorHandler.d.ts

@@ -1,20 +1,20 @@
-import { BaseRequest, type RequestErrors } from '../../shared/request/index.js';
 import { HttpServiceError } from '../../infra/httpService/index.js';
-export type AppErrorType = 'http' | 'request' | 'app' | 'abort';
+import { SchemaFail, type RequestErrors } from '../schema/index.js';
+export type AppErrorType = 'http' | 'app' | 'schema' | 'abort';
 export interface AppError<T = unknown, D = never> {
     type: AppErrorType;
     message: string;
     fields?: RequestErrors<T>;
     status?: number;
-    original?: HttpServiceError<T> | BaseRequest<T, T> | Error;
+    original?: HttpServiceError<T> | SchemaFail<T> | Error;
     custom?: D;
 }
-export type ErrorType<T = unknown> = Error | BaseRequest<T, T> | HttpServiceError<T>;
-export declare const parseHttpError: <T = unknown, D = never>(error: HttpServiceError<T>) => AppError<T, D>;
-export declare const parseRequestError: <T = unknown, D = never>(error: BaseRequest<T, T>) => AppError<T, D>;
-export declare const parseBaseError: <D = never>(error: Error) => AppError<never, D>;
-export declare const createErrorParser: <Custom = unknown>(customHandler?: <T = unknown>(error: ErrorType<T>, utils: {
-    parseBaseError: typeof parseBaseError;
-    parseRequestError: typeof parseRequestError;
-    parseHttpError: typeof parseHttpError;
-}) => AppError<T, Custom>) => (<T>(error: ErrorType<T>) => AppError<T, Custom>);
+export type ErrorType<T = unknown> = Error | HttpServiceError<T> | SchemaFail<T>;
+export declare const baseParseHttpError: <T = unknown, D = never>(error: HttpServiceError<T>) => AppError<T, D>;
+export declare const baseParseSchemaError: <SchemaData = unknown, D = never>(error: SchemaFail<SchemaData>) => AppError<SchemaData, D>;
+export declare const baseParseBaseError: <D = never>(error: Error) => AppError<never, D>;
+export declare const createErrorParser: <Custom = unknown>(parsers?: {
+    parseBaseError: typeof baseParseBaseError;
+    parseHttpError: typeof baseParseHttpError;
+    parseSchemaError: typeof baseParseSchemaError;
+}) => (<T>(error: ErrorType<T>) => AppError<T, Custom>);

package/dist/core/delivery/injectableDependencies/ErrorHandler.js

@@ -1,6 +1,6 @@
-import { BaseRequest } from '../../shared/request/index.js';
 import { HttpServiceError } from '../../infra/httpService/index.js';
-export const parseHttpError = (error) => {
+import { SchemaFail } from '../schema/index.js';
+export const baseParseHttpError = (error) => {
     return {
         type: 'http',
         message: error.message ?? 'unexpected error',
@@ -8,40 +8,32 @@ export const parseHttpError = (error) => {
         original: error
     };
 };
-export const parseRequestError = (error) => {
+export const baseParseSchemaError = (error) => {
     return {
-        type: 'request',
-        message: 'validation error',
+        type: 'schema',
+        message: 'schema validation error',
         status: 422,
         fields: error.getErrors(),
         original: error
     };
 };
-export const parseBaseError = (error) => {
+export const baseParseBaseError = (error) => {
     return {
         type: 'app',
         message: error.message,
         original: error
     };
 };
-export const createErrorParser = (customHandler) => {
+export const createErrorParser = (parsers) => {
     return (error) => {
-        if (customHandler) {
-            return customHandler(error, {
-                parseBaseError,
-                parseRequestError,
-                parseHttpError
-            });
-        }
-        else {
-            switch (true) {
-                case error instanceof HttpServiceError:
-                    return parseHttpError(error);
-                case error instanceof BaseRequest:
-                    return parseRequestError(error);
-                default:
-                    return parseBaseError(error);
-            }
+        const { parseBaseError = baseParseBaseError, parseHttpError = baseParseHttpError, parseSchemaError = baseParseSchemaError } = parsers ?? {};
+        switch (true) {
+            case error instanceof HttpServiceError:
+                return parseHttpError(error);
+            case error instanceof SchemaFail:
+                return parseSchemaError(error);
+            default:
+                return parseBaseError(error);
         }
     };
 };

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

@@ -1,10 +1,10 @@
-type DeepKeys<T> = T extends object ? {
-    [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
-}[keyof T & string] : never;
-export type ValidationParams<T = unknown, V = unknown, K = string> = {
-    val: V;
-    listValues?: Partial<T>;
-    key?: K;
+type DeepKeys<SchemaData> = SchemaData extends object ? {
+    [K in keyof SchemaData & string]: SchemaData[K] extends object ? K | `${K}.${DeepKeys<SchemaData[K]>}` : K;
+}[keyof SchemaData & string] : never;
+export type ValidationParams<SchemaData = unknown, CurrentValue = unknown, CurrentKey = string> = {
+    val: CurrentValue;
+    listValues?: Partial<SchemaData>;
+    key?: CurrentKey;
 };
 export type ValidationMessage = string | {
     key: string;
@@ -15,19 +15,31 @@ export interface ValidationErrorsMap {
 }
 export type ValidationResult = ValidationMessage | ValidationErrorsMap | ValidationErrorsMap[] | undefined;
 export type ValidationRuleResult<CurrentValue, ListValues = unknown, CurrentKey = string> = (params: ValidationParams<CurrentValue, ListValues, CurrentKey>) => ValidationResult;
-type ValidationErrors<T> = T extends ReadonlyArray<infer U> ? ValidationErrors<U>[] : T extends object ? {
-    [K in keyof T]?: ValidationErrors<T[K]>;
+type ValidationErrors<Errors> = Errors extends ReadonlyArray<infer U> ? ValidationErrors<U>[] : Errors extends object ? {
+    [K in keyof Errors]?: ValidationErrors<Errors[K]>;
 } : ValidationMessage;
-export type RequestErrors<Dict> = Partial<ValidationErrors<Dict>>;
-export type RequestRules<D> = Partial<Record<DeepKeys<D>, ValidationRuleResult<D>[]>>;
-export declare const createSchemaFactory: <Rules>(rulesList: Rules) => <IncomingData, DataAfterTransform = IncomingData>(params: {
-    schema: (rules: Rules) => RequestRules<IncomingData>;
-    transform: (data: IncomingData) => DataAfterTransform;
-}) => {
-    from: (data: IncomingData) => void;
-    json: () => DataAfterTransform;
-    formData: () => FormData;
-    validate: () => undefined;
-    readonly errors: Partial<ValidationErrors<IncomingData>>;
+export type RequestErrors<SchemaData> = Partial<ValidationErrors<SchemaData>>;
+export type RequestRules<SchemaData> = Partial<Record<DeepKeys<SchemaData>, ValidationRuleResult<SchemaData>[]>>;
+export declare class SchemaFail<SchemaData> {
+    private _errors;
+    constructor(_errors: RequestErrors<SchemaData>);
+    getErrors(): Partial<ValidationErrors<SchemaData>>;
+}
+interface SchemaBuilder<SchemaData, Rules = unknown, TransformResult = SchemaData, CustomMethods = unknown> {
+    rules(callback: (factory: Rules) => RequestRules<SchemaData>): SchemaBuilder<SchemaData, Rules, TransformResult, CustomMethods>;
+    transform<T>(callback: (data: SchemaData) => T): SchemaBuilder<SchemaData, Rules, T, CustomMethods>;
+    with<M extends Record<string, unknown>>(callback: () => M): SchemaBuilder<SchemaData, Rules, TransformResult, M>;
+    create(): Schema<SchemaData, TransformResult, CustomMethods>;
+}
+interface SchemaInstance<TransformResult> {
+    json(): TransformResult;
+    formData(): FormData;
+    validated(): boolean;
+}
+type Schema<SchemaData, TransformResult, CustomMethods> = CustomMethods & {
+    from(data: Partial<SchemaData>): SchemaInstance<TransformResult>;
+    getSchemaError(e: unknown): RequestErrors<SchemaData>;
 };
+export declare const createSchemaFactory: <Rules extends Record<string, unknown>>(rules: Rules) => <SchemaData>() => SchemaBuilder<SchemaData, Rules>;
+export declare const schema: <SchemaData>() => SchemaBuilder<SchemaData>;
 export {};

package/dist/core/delivery/schema/Schema.js

@@ -1,13 +1,46 @@
-import { FormDataUtil } from 'azure-net-tools';
-export const createSchemaFactory = (rulesList) => {
-    return (params) => {
-        let schemaData;
-        let _errors = {};
-        let _isValid = true;
-        const { schema, transform = (data) => data } = params;
-        const definedSchema = schema(rulesList);
-        const getByPath = (path) => {
-            return path.split('.').reduce((o, k) => (o && typeof o === 'object' ? o[k] : undefined), schemaData);
+import { FormDataUtil, ObjectUtil } from 'azure-net-tools';
+export class SchemaFail {
+    _errors;
+    constructor(_errors) {
+        this._errors = _errors;
+    }
+    getErrors() {
+        return this._errors;
+    }
+}
+class SchemaBuilderImpl {
+    _rulesFactory;
+    _rules;
+    _transform;
+    _customMethods;
+    constructor(_rulesFactory = {}) {
+        this._rulesFactory = _rulesFactory;
+    }
+    rules(callback) {
+        this._rules = callback;
+        return this;
+    }
+    transform(callback) {
+        this._transform = callback;
+        return this;
+    }
+    with(callback) {
+        this._customMethods = callback;
+        return this;
+    }
+    create() {
+        const rules = this._rules;
+        const transform = this._transform || ((data) => data);
+        const customMethods = this._customMethods ? this._customMethods() : {};
+        const rulesFactory = this._rulesFactory;
+        const prepare = (dataToPrepare) => {
+            if (dataToPrepare instanceof FormData) {
+                return FormDataUtil.toObject(dataToPrepare);
+            }
+            return ObjectUtil.deepClone(dataToPrepare);
+        };
+        const getByPath = (path, data) => {
+            return path.split('.').reduce((o, k) => (o && typeof o === 'object' ? o[k] : undefined), data);
         };
         const setByPath = (obj, path, value) => {
             const keys = path.split('.');
@@ -21,58 +54,70 @@ export const createSchemaFactory = (rulesList) => {
             }
             current[keys[(keys.length - 1)]] = value;
         };
-        const prepare = (dataToPrepare) => {
-            if (dataToPrepare instanceof FormData) {
-                return FormDataUtil.toObject(dataToPrepare);
-            }
-            return dataToPrepare;
-        };
-        const validate = () => {
-            _isValid = true;
-            _errors = {};
-            if (typeof schemaData !== 'object') {
-                throw Error('Data to validate is not an object');
-            }
-            for (const key in definedSchema) {
-                const fieldRules = definedSchema[key] ?? [];
-                const value = getByPath(key);
-                for (const rule of fieldRules) {
-                    const failMessage = rule({
-                        val: value,
-                        listValues: schemaData,
-                        key: key
-                    });
-                    if (failMessage) {
-                        setByPath(_errors, key, failMessage);
-                        _isValid = false;
-                        break;
-                    }
+        const schema = {
+            ...customMethods,
+            getSchemaError(e) {
+                if (e instanceof SchemaFail) {
+                    return e.getErrors();
                 }
-            }
-            if (!_isValid) {
-                throw this;
-            }
-            return this;
-        };
-        const from = (data) => {
-            schemaData = prepare(data);
-        };
-        const formData = () => {
-            validate();
-            return FormDataUtil.fromObject(transform(schemaData));
-        };
-        const json = () => {
-            validate();
-            return transform(schemaData);
-        };
-        return {
-            from,
-            json,
-            formData,
-            validate,
-            get errors() {
-                return _errors;
+            },
+            from(data) {
+                const _preparedData = prepare(data);
+                let _errors = {};
+                let _isValid = true;
+                if (typeof _preparedData !== 'object') {
+                    throw Error('Data to validate is not an object');
+                }
+                const validated = () => {
+                    if (!rules)
+                        return true;
+                    _isValid = true;
+                    _errors = {};
+                    const definedSchema = rules(rulesFactory);
+                    for (const key in definedSchema) {
+                        const fieldRules = definedSchema[key] ?? [];
+                        const value = getByPath(key, _preparedData);
+                        for (const rule of fieldRules) {
+                            const failMessage = rule({
+                                val: value,
+                                listValues: _preparedData,
+                                key: key
+                            });
+                            if (failMessage) {
+                                setByPath(_errors, key, failMessage);
+                                _isValid = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (!_isValid) {
+                        throw new SchemaFail(_errors);
+                    }
+                    return true;
+                };
+                const json = () => {
+                    validated();
+                    return transform(_preparedData);
+                };
+                const formData = () => {
+                    validated();
+                    return FormDataUtil.fromObject(transform(_preparedData));
+                };
+                return {
+                    json,
+                    formData,
+                    validated
+                };
             }
         };
+        return schema;
+    }
+}
+export const createSchemaFactory = (rules) => {
+    return () => {
+        return new SchemaBuilderImpl(rules);
     };
 };
+export const schema = () => {
+    return new SchemaBuilderImpl();
+};

package/dist/core/delivery/schema/rules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Rules.js';
+export * from './messages/index.js';

package/dist/core/delivery/schema/rules/index.js

@@ -0,0 +1,2 @@
+export * from './Rules.js';
+export * from './messages/index.js';

package/dist/core/index.d.ts

@@ -1,7 +1,7 @@
 export * from './delivery/index.js';
-export * from './shared/request/index.js';
 export * from './shared/middleware/index.js';
 export * from './shared/classMirror/index.js';
 export * from './shared/cookie/index.js';
 export * from './shared/boundaryProvider/index.js';
 export * from './ui/index.js';
+export * from './svelte/index.js';

package/dist/core/index.js

@@ -1,7 +1,7 @@
 export * from './delivery/index.js';
-export * from './shared/request/index.js';
 export * from './shared/middleware/index.js';
 export * from './shared/classMirror/index.js';
 export * from './shared/cookie/index.js';
 export * from './shared/boundaryProvider/index.js';
 export * from './ui/index.js';
+export * from './svelte/index.js';

package/dist/core/shared/middleware/Middleware.d.ts

@@ -1,12 +1,13 @@
 import { error, type Page, type RequestEvent } from '@sveltejs/kit';
 import { UniversalCookie } from '../cookie/index.js';
+type RedirectStatus = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
 export type IMiddleware = (middlewareData: {
     to: RequestEvent['url'] | Page['url'];
     from?: RequestEvent['url'] | Page['url'];
     error: typeof error;
-    next: (location?: string | URL, status?: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | number) => void;
+    next: (location?: string | URL, status?: RedirectStatus) => void;
     isServer: boolean;
-    cookies: UniversalCookie;
+    cookies: typeof UniversalCookie;
     event?: RequestEvent;
     page: Page;
 }) => Promise<void> | void;
@@ -14,3 +15,4 @@ export declare const createMiddlewareManager: (middlewares: IMiddleware[]) => {
     serverMiddleware: () => Promise<void>;
     clientMiddleware: () => void;
 };
+export {};

package/dist/core/shared/middleware/Middleware.js

@@ -4,16 +4,16 @@ import { beforeNavigate, goto } from '$app/navigation';
 import { page } from '$app/state';
 import { EnvironmentUtil } from 'azure-net-tools';
 import { UniversalCookie } from '../cookie/index.js';
-const universalRedirect = (location, status = 301, navigation) => {
-    if (EnvironmentUtil.isBrowser && navigation) {
-        navigation?.cancel();
-        return goto(location);
-    }
-    else {
-        return redirect(status, location);
-    }
-};
 export const createMiddlewareManager = (middlewares) => {
+    const universalRedirect = (location, status = 301, navigation) => {
+        if (EnvironmentUtil.isBrowser && navigation) {
+            navigation?.cancel();
+            return goto(location);
+        }
+        else {
+            return redirect(status, location);
+        }
+    };
     const executeMiddlewares = async (navigation) => {
         let event;
         let from = undefined;

package/dist/{svelte → core/svelte}/ActiveForm/ActiveForm.svelte.d.ts

@@ -1,16 +1,13 @@
-import { type RequestErrors, BaseRequest } from '../../core/index.js';
 export interface FormConfig<T> {
     onSubmit: (data: T) => Promise<void> | void;
     initialData?: T;
     validation?: {
-        schema?: new (data: Partial<T>) => BaseRequest<T, T>;
         validateOnChange?: boolean;
         validateOnBlur?: boolean;
     };
 }
 export interface ActiveForm<T> {
     data: Partial<T>;
-    errors: RequestErrors<T>;
     touched: Partial<Record<keyof T, boolean>>;
     pending: boolean;
     dirty: boolean;
@@ -19,6 +16,5 @@ export interface ActiveForm<T> {
     validate: (field?: keyof T) => void;
     reset: () => void;
     setField: <K extends keyof T>(field: K, value: T[K]) => void;
-    setErrors: (errors: RequestErrors<T>) => void;
     touchField: (field: keyof T) => void;
 }

package/dist/{svelte → core/svelte}/ActiveForm/ActiveForm.svelte.js

@@ -1,4 +1,4 @@
-import { BaseRequest } from '../../core/index.js';
+export {};
 // export function createActiveForm<T extends object>(config: FormConfig<T>): ActiveForm<T> {
 // 	const initial: Partial<T> = config.initialData ?? {};
 // 	let data = $state<Partial<T>>(structuredClone(initial));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "0.8.9",
+  "version": "0.9.1",
   "files": [
     "dist",
     "!dist/**/*.test.*",
@@ -21,17 +21,9 @@
       "types": "./dist/core/infra/index.d.ts",
       "svelte": "./dist/core/infra/index.js"
     },
-    "./svelte": {
-      "types": "./dist/svelte/index.d.ts",
-      "svelte": "./dist/svelte/index.js"
-    },
-    "./request/rules": {
-      "types": "./dist/core/shared/request/rules/index.d.ts",
-      "svelte": "./dist/core/shared/request/rules/index.js"
-    },
-    "./request/messages": {
-      "types": "./dist/core/shared/request/rules/messages/index.d.ts",
-      "svelte": "./dist/core/shared/request/rules/messages/index.js"
+    "./schema": {
+      "types": "./dist/core/delivery/schema/rules/index.d.ts",
+      "svelte": "./dist/core/delivery/schema/rules/index.js"
     },
     "./edges": {
       "types": "./dist/edges/index.d.ts",

package/dist/core/shared/request/BaseRequest.d.ts

@@ -1,41 +0,0 @@
-type DeepKeys<T> = T extends object ? {
-    [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
-}[keyof T & string] : never;
-export type ValidationParams<T = unknown, V = unknown, K = string> = {
-    val: V;
-    listValues?: Partial<T>;
-    key?: K;
-};
-export type ValidationMessage = string | {
-    key: string;
-    vars?: Record<string, unknown>;
-};
-export interface ValidationErrorsMap {
-    [key: string]: ValidationMessage | ValidationErrorsMap;
-}
-export type ValidationResult = ValidationMessage | ValidationErrorsMap | ValidationErrorsMap[] | undefined;
-export type ValidationRuleResult<CurrentValue, ListValues = unknown, CurrentKey = string> = (params: ValidationParams<CurrentValue, ListValues, CurrentKey>) => ValidationResult;
-type ValidationErrors<T> = T extends ReadonlyArray<infer U> ? ValidationErrors<U>[] : T extends object ? {
-    [K in keyof T]?: ValidationErrors<T[K]>;
-} : ValidationMessage;
-export type RequestErrors<Dict> = Partial<ValidationErrors<Dict>>;
-export type RequestRules<D> = Partial<Record<DeepKeys<D>, ValidationRuleResult<D>[]>>;
-export interface IRequest<T, D = T> {
-    rules?(): RequestRules<D>;
-}
-export declare class BaseRequest<T, D = T> implements IRequest<T, D> {
-    data: D;
-    errors: RequestErrors<D>;
-    isValid: boolean;
-    constructor(data: Partial<D> | FormData);
-    rules(): RequestRules<D>;
-    private prepareData;
-    transform(data: D): T;
-    formData(): FormData;
-    json(): T;
-    getErrors(): Partial<ValidationErrors<D>>;
-    private getByPath;
-    private setByPath;
-    validated(): this;
-}
-export {};

package/dist/core/shared/request/BaseRequest.js

@@ -1,72 +0,0 @@
-import { FormDataUtil } from 'azure-net-tools';
-export class BaseRequest {
-    data;
-    errors = {};
-    isValid = true;
-    constructor(data) {
-        this.data = this.prepareData(data);
-    }
-    rules() {
-        return {};
-    }
-    prepareData(data) {
-        if (data instanceof FormData) {
-            return FormDataUtil.toObject(data);
-        }
-        return data;
-    }
-    transform(data) {
-        return data;
-    }
-    formData() {
-        this.validated();
-        return FormDataUtil.fromObject(this.transform(this.data));
-    }
-    json() {
-        this.validated();
-        return this.transform(this.data);
-    }
-    getErrors() {
-        return this.errors;
-    }
-    getByPath(path) {
-        return path.split('.').reduce((o, k) => (o && typeof o === 'object' ? o[k] : undefined), this.data);
-    }
-    setByPath(obj, path, value) {
-        const keys = path.split('.');
-        let current = obj;
-        for (let i = 0; i < keys.length - 1; i++) {
-            const k = keys[i];
-            if (!(k in current) || typeof current[k] !== 'object') {
-                current[k] = {};
-            }
-            current = current[k];
-        }
-        current[keys[(keys.length - 1)]] = value;
-    }
-    validated() {
-        this.isValid = true;
-        this.errors = {};
-        const definedRules = this.rules();
-        for (const key in definedRules) {
-            const fieldRules = definedRules[key] ?? [];
-            const value = this.getByPath(key);
-            for (const rule of fieldRules) {
-                const failMessage = rule({
-                    val: value,
-                    listValues: this.data,
-                    key: key
-                });
-                if (failMessage) {
-                    this.setByPath(this.errors, key, failMessage);
-                    this.isValid = false;
-                    break;
-                }
-            }
-        }
-        if (!this.isValid) {
-            throw this;
-        }
-        return this;
-    }
-}

package/dist/core/shared/request/index.d.ts

@@ -1 +0,0 @@
-export * from './BaseRequest.js';

package/dist/core/shared/request/index.js

@@ -1 +0,0 @@
-export * from './BaseRequest.js';

package/dist/core/shared/request/rules/Rules.d.ts

@@ -1,62 +0,0 @@
-import { type CountryCode } from 'libphonenumber-js';
-import type { BaseValidationMessages } from './messages/types.js';
-import type { ValidationRuleResult, ValidationParams } from '../BaseRequest.js';
-export type ValidationRuleParams<T extends keyof BaseValidationMessages, D = object> = D & {
-    message?: BaseValidationMessages[T];
-};
-export type LengthParams = {
-    length?: {
-        min?: number;
-        max?: number;
-    };
-};
-export type RangeParams = {
-    range?: {
-        min?: number;
-        max?: number;
-    };
-};
-type ArrayItemRules<Context> = ValidationRuleResult<Context>[] | Record<string, ValidationRuleResult<Context>[]>;
-type ArrayParams<Context> = LengthParams & {
-    schema?: ArrayItemRules<Context>;
-};
-export declare class Rules<M extends BaseValidationMessages> {
-    private readonly validationMessages;
-    constructor(validationMessages: M);
-    private checkVal;
-    string<T = unknown, D = unknown>(params?: ValidationRuleParams<'string', LengthParams>): ValidationRuleResult<T, D>;
-    number<T = unknown, D = unknown>(params?: ValidationRuleParams<'number', RangeParams>): ValidationRuleResult<T, D>;
-    finite<T = unknown, D = unknown>(params?: ValidationRuleParams<'finite', RangeParams & {
-        maxDigitsAfterDot?: number;
-    }>): ValidationRuleResult<T, D>;
-    boolean<T = unknown, D = unknown>(params?: ValidationRuleParams<'boolean', {
-        expected?: boolean;
-    }>): ValidationRuleResult<T, D>;
-    array<T = unknown>(params?: ValidationRuleParams<'array', ArrayParams<T>>): ValidationRuleResult<T>;
-    phone<T = unknown, D = unknown>(params?: ValidationRuleParams<'phone', {
-        country: CountryCode;
-    }>): ValidationRuleResult<T, D>;
-    email<T = unknown, D = unknown>(params?: ValidationRuleParams<'email'>): ValidationRuleResult<T, D>;
-    lettersOnly<T = unknown, D = unknown>(params?: ValidationRuleParams<'lettersOnly', {
-        whiteSpaces?: boolean;
-    }>): ValidationRuleResult<T, D>;
-    allowedOnly<T = unknown, D = unknown>(params?: ValidationRuleParams<'allowedOnly', {
-        allowed?: unknown[];
-    }>): ValidationRuleResult<T, D>;
-    sameAs<T = unknown, D = unknown>(params: ValidationRuleParams<'sameAs', {
-        key: keyof T | string;
-    }>): ValidationRuleResult<T, D>;
-    notSameAs<T = unknown, D = unknown>(params: ValidationRuleParams<'sameAs', {
-        key: keyof T | string;
-    }>): ValidationRuleResult<T, D>;
-    required<T = unknown, D = unknown, J = unknown>(params?: ValidationRuleParams<'required', {
-        byCondition?: (params: ValidationParams<T, D, J>) => boolean;
-    }>): ValidationRuleResult<T, D, J>;
-    password<T = unknown, D = unknown>(params?: ValidationRuleParams<'password', {
-        length?: number;
-        specialChars?: boolean | number;
-        numbers?: boolean | number;
-        lowerUpperCasePattern?: boolean;
-    }>): ValidationRuleResult<T, D>;
-}
-export {};

package/dist/core/shared/request/rules/Rules.js

@@ -1,288 +0,0 @@
-import { isValidNumber } from 'libphonenumber-js';
-export class Rules {
-    validationMessages;
-    constructor(validationMessages) {
-        this.validationMessages = validationMessages;
-    }
-    checkVal(val) {
-        return val !== undefined && val !== null;
-    }
-    string(params) {
-        const { message, length } = { ...params, message: { ...this.validationMessages.string, ...params?.message } };
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                if (typeof val !== 'string') {
-                    return message.base();
-                }
-                switch (true) {
-                    case length && this.checkVal(length.min) && val.length < length.min:
-                        return message.min(length.min);
-                    case length && this.checkVal(length.max) && val.length > length.max:
-                        return message.max(length.max);
-                    default:
-                        return undefined;
-                }
-            }
-            return undefined;
-        };
-    }
-    number(params) {
-        const { message, range } = { ...params, message: { ...this.validationMessages.number, ...params?.message } };
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                const numberVal = Number(val);
-                if (!Number.isInteger(numberVal) || Number.isNaN(numberVal)) {
-                    return message.base();
-                }
-                switch (true) {
-                    case range && this.checkVal(range?.min) && numberVal < range.min:
-                        return message.min(range.min);
-                    case range && this.checkVal(range?.max) && numberVal > range.max:
-                        return message.max(range.max);
-                    default:
-                        return undefined;
-                }
-            }
-            return undefined;
-        };
-    }
-    finite(params) {
-        const { message, maxDigitsAfterDot, range } = { ...params, message: { ...this.validationMessages.finite, ...params?.message } };
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                const numVal = Number(val);
-                if (!Number.isFinite(numVal) || String(val)[0] === '.') {
-                    return message.base();
-                }
-                if (typeof maxDigitsAfterDot === 'number') {
-                    const digitsAfterDot = val.toString().split('.')[1]?.length ?? 0;
-                    if (digitsAfterDot > maxDigitsAfterDot) {
-                        return message.maxDigitsAfterDot(maxDigitsAfterDot);
-                    }
-                }
-                if (range?.min !== undefined && numVal < range.min)
-                    return message.min(range.min);
-                if (range?.max !== undefined && numVal > range.max)
-                    return message.max(range.max);
-                return undefined;
-            }
-            return undefined;
-        };
-    }
-    boolean(params) {
-        const { message, expected } = { ...params, message: { ...this.validationMessages.boolean, ...params?.message } };
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                if (typeof val !== 'boolean')
-                    return message.base();
-                if (expected !== undefined && val !== expected)
-                    return message.expected(String(expected));
-                return undefined;
-            }
-            return undefined;
-        };
-    }
-    array(params) {
-        const { message, length = {}, schema } = { ...params, message: { ...this.validationMessages.array, ...params?.message } };
-        return ({ val, listValues, key }) => {
-            if (this.checkVal(val)) {
-                if (!Array.isArray(val))
-                    return message.base();
-                if (length.min && val.length < length.min)
-                    return message.min(length.min);
-                if (length.max && val.length > length.max)
-                    return message.max(length.max);
-                if (schema) {
-                    const nestedErrors = [];
-                    for (let index = 0; index < val.length; index++) {
-                        const element = val[index];
-                        const itemErrors = {};
-                        if (Array.isArray(schema)) {
-                            for (const rule of schema) {
-                                const fail = rule({
-                                    val: element,
-                                    listValues,
-                                    key: `${key}[${index}]`
-                                });
-                                if (fail) {
-                                    itemErrors['_error'] = fail;
-                                    break;
-                                }
-                            }
-                        }
-                        else if (typeof schema === 'object' && schema !== null) {
-                            if (typeof element !== 'object' || element === null) {
-                                itemErrors['_error'] = message.base();
-                            }
-                            else {
-                                for (const fieldKey in schema) {
-                                    const fieldRules = schema[fieldKey] ?? [];
-                                    const fieldValue = element?.[fieldKey];
-                                    for (const rule of fieldRules) {
-                                        const fail = rule({
-                                            val: fieldValue,
-                                            listValues,
-                                            key: `${key}[${index}].${fieldKey}`
-                                        });
-                                        if (fail) {
-                                            itemErrors[fieldKey] = fail;
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        nestedErrors[index] = itemErrors;
-                    }
-                    if (nestedErrors.some((e) => Object.keys(e).length > 0)) {
-                        return nestedErrors;
-                    }
-                }
-            }
-            return undefined;
-        };
-    }
-    phone(params) {
-        const { message, country = 'RU' } = { ...params, message: params?.message ?? this.validationMessages.phone };
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                return isValidNumber(String(val), country) ? undefined : message();
-            }
-            return undefined;
-        };
-    }
-    email(params) {
-        const { message } = { message: params?.message ?? this.validationMessages.email };
-        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 (this.checkVal(val)) {
-                const stringedVal = typeof val === 'string' ? String(val) : undefined;
-                return stringedVal && emailRegExp.test(stringedVal) ? undefined : message();
-            }
-            return undefined;
-        };
-    }
-    lettersOnly(params) {
-        const { message, whiteSpaces = false } = { ...params, message: params?.message ?? this.validationMessages.lettersOnly };
-        const lettersRegex = whiteSpaces ? /^[а-яА-Яa-zA-Z\s]+$/ : /^[а-яА-Яa-zA-Z]+$/;
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                const stringedVal = typeof val === 'string' ? String(val) : undefined;
-                return stringedVal && lettersRegex.test(stringedVal) ? undefined : message(whiteSpaces);
-            }
-            return undefined;
-        };
-    }
-    allowedOnly(params) {
-        const { message, allowed } = { ...params, message: params?.message ?? this.validationMessages.allowedOnly };
-        return ({ val }) => {
-            if (this.checkVal(val)) {
-                switch (true) {
-                    case !!allowed && Array.isArray(allowed):
-                        if (!allowed?.length) {
-                            return message('');
-                        }
-                        return allowed.includes(val) ? undefined : message(allowed.join(', '));
-                    default:
-                        return undefined;
-                }
-            }
-            return undefined;
-        };
-    }
-    sameAs(params) {
-        const { message, key } = { ...params, message: params?.message ?? this.validationMessages.sameAs };
-        return ({ val, listValues }) => {
-            if (this.checkVal(val)) {
-                switch (true) {
-                    case typeof val === 'object':
-                        if (!listValues?.[key] || typeof listValues[key] !== 'object') {
-                            return message(String(key));
-                        }
-                        try {
-                            return JSON.stringify(val) === JSON.stringify(listValues[key]) ? undefined : message(String(key));
-                        }
-                        catch {
-                            return undefined;
-                        }
-                    default:
-                        return String(val ?? '') === String(listValues?.[key] ?? '') ? undefined : message(String(key));
-                }
-            }
-            return undefined;
-        };
-    }
-    notSameAs(params) {
-        const { message, key } = { ...params, message: params?.message ?? this.validationMessages.notSameAs };
-        return ({ val, listValues }) => {
-            if (this.checkVal(val)) {
-                switch (true) {
-                    case typeof val === 'object':
-                        if (!listValues?.[key] || typeof listValues[key] !== 'object') {
-                            return message(String(key));
-                        }
-                        try {
-                            return JSON.stringify(val) !== JSON.stringify(listValues[key]) ? undefined : message(String(key));
-                        }
-                        catch {
-                            return undefined;
-                        }
-                    default:
-                        return String(val) === String(listValues?.[key]) ? undefined : message(String(key));
-                }
-            }
-            return undefined;
-        };
-    }
-    required(params) {
-        const { message, byCondition } = { ...params, message: params?.message ?? this.validationMessages.required };
-        return ({ val, listValues, key }) => {
-            if (!this.checkVal(val))
-                return message();
-            if (byCondition && !byCondition({ val, listValues, key }))
-                return undefined;
-            if (typeof val === 'string' && !val.length)
-                return message();
-            if (val instanceof File && val.size < 1)
-                return message();
-            if (typeof val === 'number' && !String(val).length)
-                return message();
-            return undefined;
-        };
-    }
-    password(params) {
-        const { message, length = 8, specialChars, numbers, lowerUpperCasePattern } = { ...params, message: { ...this.validationMessages.password, ...params?.message } };
-        return ({ val }) => {
-            if (!this.checkVal(val))
-                return undefined;
-            const str = String(val);
-            if (str.length < length) {
-                return message.length(length);
-            }
-            if (specialChars) {
-                const minCount = typeof specialChars === 'number' ? specialChars : 1;
-                const count = (str.match(/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/g) || []).length;
-                if (count < minCount) {
-                    return message.specialChars(minCount);
-                }
-            }
-            if (numbers) {
-                const minCount = typeof numbers === 'number' ? numbers : 1;
-                const count = (str.match(/[0-9]/g) || []).length;
-                if (count < minCount) {
-                    return message.numbers(minCount);
-                }
-            }
-            if (lowerUpperCasePattern) {
-                const hasLower = /[a-z]/.test(str);
-                const hasUpper = /[A-Z]/.test(str);
-                if (!hasLower || !hasUpper) {
-                    return message.lowerUpperCasePattern();
-                }
-            }
-            return undefined;
-        };
-    }
-}

package/dist/core/shared/request/rules/index.d.ts

@@ -1 +0,0 @@
-export * from './Rules.js';

package/dist/core/shared/request/rules/index.js

@@ -1 +0,0 @@
-export * from './Rules.js';

package/dist/core/shared/request/rules/messages/En.d.ts

@@ -1,2 +0,0 @@
-import type { BaseValidationMessages } from './types.js';
-export declare const validationMessagesEn: BaseValidationMessages;

package/dist/core/shared/request/rules/messages/En.js

@@ -1,40 +0,0 @@
-export const validationMessagesEn = {
-    phone: () => 'Invalid phone number format',
-    email: () => 'Invalid email address',
-    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',
-    sameAs: (value) => `This field must match the ${value} field`,
-    notSameAs: (value) => `This field must not match the ${value} field`,
-    boolean: {
-        base: () => 'This field must be a boolean value',
-        expected: (value) => `Expected value: ${value}`
-    },
-    finite: {
-        base: () => 'This field must be a number',
-        min: (value) => `The number must be at least ${value}`,
-        max: (value) => `The number must be at most ${value}`,
-        maxDigitsAfterDot: (value) => `Number of digits after the decimal point must not exceed ${value}`
-    },
-    number: {
-        base: () => 'This field must be an integer',
-        min: (value) => `The number must be at least ${value}`,
-        max: (value) => `The number must be at most ${value}`
-    },
-    string: {
-        base: () => 'This field must be a string',
-        min: (value) => `Minimum string length is ${value}`,
-        max: (value) => `Maximum string length is ${value}`
-    },
-    array: {
-        base: () => 'This field must be an array',
-        min: (value) => `Minimum array length is ${value}`,
-        max: (value) => `Maximum array length is ${value}`
-    },
-    password: {
-        length: (value) => `Minimum password length is ${value}`,
-        specialChars: (value) => `Password must contain at least ${value} special character(s)`,
-        lowerUpperCasePattern: () => 'Password must contain both uppercase and lowercase letters',
-        numbers: (value) => `Password must contain at least ${value} number(s)`
-    }
-};

package/dist/core/shared/request/rules/messages/Ru.d.ts

@@ -1,2 +0,0 @@
-import type { BaseValidationMessages } from './types.js';
-export declare const validationMessagesRu: BaseValidationMessages;

package/dist/core/shared/request/rules/messages/Ru.js

@@ -1,40 +0,0 @@
-export const validationMessagesRu = {
-    phone: () => 'Неверный формат номера телефона',
-    email: () => 'Невалидный email',
-    required: () => 'Поле обязательно к заполнению',
-    lettersOnly: (whiteSpaces) => `Поле может содержать только буквы ${whiteSpaces ? '' : 'и не должно содержать пробелы'}`,
-    allowedOnly: (value) => value && value.length ? `Поле может содержать только одно из следующих значений:: ${value}` : 'Поле не имеет допустимых значений',
-    sameAs: (value) => `Поле должно совпадать с полем ${value}`,
-    notSameAs: (value) => `Поле не должно совпадать с полем ${value}`,
-    boolean: {
-        base: () => 'Поле должно содержать значение типа boolean',
-        expected: (value) => `Ожидаемое значение поля - ${value}`
-    },
-    finite: {
-        base: () => 'Поле должно быть числом',
-        min: (value) => `Число должно быть не менее ${value}`,
-        max: (value) => `Число должно быть не более ${value}`,
-        maxDigitsAfterDot: (value) => `Количество символов после точки не более ${value}`
-    },
-    number: {
-        base: () => 'Поле должно быть целым числом',
-        min: (value) => `Число должно быть не менее ${value}`,
-        max: (value) => `Число должно быть не более ${value}`
-    },
-    string: {
-        base: () => 'Поле должно быть строкой',
-        min: (value) => `Минимальная длина строки - ${value}`,
-        max: (value) => `Максимальная длина строки - ${value}`
-    },
-    array: {
-        base: () => 'Поле должно быть массивом',
-        min: (value) => `Минимальная длина массива - ${value}`,
-        max: (value) => `Максимальная длина массива - ${value}`
-    },
-    password: {
-        length: (value) => `Минимальная длина пароля - ${value}`,
-        specialChars: (value) => `В пароле должно быть спецсимволы в количестве не менее ${value}`,
-        lowerUpperCasePattern: () => 'В пароле должны быть буквы верхнего и нижнего регистра',
-        numbers: (value) => `В пароле должно быть цифры в количестве не менее ${value}`
-    }
-};

package/dist/core/shared/request/rules/messages/WithI18n.d.ts

@@ -1,2 +0,0 @@
-import type { BaseValidationMessages } from './types.js';
-export declare const validationMessagesI18n: BaseValidationMessages;

package/dist/core/shared/request/rules/messages/WithI18n.js

@@ -1,40 +0,0 @@
-export const validationMessagesI18n = {
-    phone: () => 'validation.phone',
-    email: () => 'validation.email',
-    required: () => 'validation.required',
-    lettersOnly: (whiteSpaces) => (whiteSpaces ? 'validation.lettersOnlyWithWhiteSpaces' : 'validation.lettersOnly'),
-    allowedOnly: (value) => ({ key: value && value.length ? 'validation.allowedOnly.base' : 'validation.allowedOnly.nothing', vars: { value } }),
-    sameAs: (value) => ({ key: 'validation.sameAs', vars: { value } }),
-    notSameAs: (value) => ({ key: 'validation.notSameAs', vars: { value } }),
-    boolean: {
-        base: () => 'validation.boolean.base',
-        expected: (value) => ({ key: 'validation.boolean.expected', vars: { value } })
-    },
-    finite: {
-        base: () => 'validation.finite.base',
-        min: (value) => ({ key: 'validation.finite.minLength', vars: { value } }),
-        max: (value) => ({ key: 'validation.finite.maxLength', vars: { value } }),
-        maxDigitsAfterDot: (value) => ({ key: 'validation.finite.maxDigitsAfterDot', vars: { value } })
-    },
-    number: {
-        base: () => 'validation.number.base',
-        min: (value) => ({ key: 'validation.number.minLength', vars: { value } }),
-        max: (value) => ({ key: 'validation.number.maxLength', vars: { value } })
-    },
-    string: {
-        base: () => 'validation.string.base',
-        min: (value) => ({ key: 'validation.string.minLength', vars: { value } }),
-        max: (value) => ({ key: 'validation.string.maxLength', vars: { value } })
-    },
-    array: {
-        base: () => 'validation.array.base',
-        min: (value) => ({ key: 'validation.array.minLength', vars: { value } }),
-        max: (value) => ({ key: 'validation.array.maxLength', vars: { value } })
-    },
-    password: {
-        length: (value) => ({ key: 'validation.password.length', vars: { value } }),
-        specialChars: (value) => ({ key: 'validation.password.specialChars', vars: { value } }),
-        lowerUpperCasePattern: () => ({ key: 'validation.password.lowerUpperCasePattern' }),
-        numbers: (value) => ({ key: 'validation.password.numbers', vars: { value } })
-    }
-};

package/dist/core/shared/request/rules/messages/index.d.ts

@@ -1,3 +0,0 @@
-export * from './Ru.js';
-export * from './En.js';
-export * from './WithI18n.js';

package/dist/core/shared/request/rules/messages/index.js

@@ -1,3 +0,0 @@
-export * from './Ru.js';
-export * from './En.js';
-export * from './WithI18n.js';

package/dist/core/shared/request/rules/messages/types.d.ts

@@ -1,41 +0,0 @@
-import type { ValidationMessage } from '../../index.js';
-export type BaseValidationMessages = {
-    phone: () => ValidationMessage;
-    email: () => ValidationMessage;
-    required: () => ValidationMessage;
-    lettersOnly: (whiteSpaces: boolean) => ValidationMessage;
-    allowedOnly: (allowed: string) => ValidationMessage;
-    sameAs: (value: string) => ValidationMessage;
-    notSameAs: (value: string) => ValidationMessage;
-    boolean: {
-        base: () => ValidationMessage;
-        expected: (value: string) => ValidationMessage;
-    };
-    finite: {
-        base: () => ValidationMessage;
-        min: (value: number) => ValidationMessage;
-        max: (value: number) => ValidationMessage;
-        maxDigitsAfterDot: (value: number) => ValidationMessage;
-    };
-    number: {
-        base: () => ValidationMessage;
-        min: (value: number) => ValidationMessage;
-        max: (value: number) => ValidationMessage;
-    };
-    string: {
-        base: () => ValidationMessage;
-        min: (value: number) => ValidationMessage;
-        max: (value: number) => ValidationMessage;
-    };
-    array: {
-        base: () => ValidationMessage;
-        min: (value: number) => ValidationMessage;
-        max: (value: number) => ValidationMessage;
-    };
-    password: {
-        length: (value: number) => ValidationMessage;
-        specialChars: (value: number) => ValidationMessage;
-        lowerUpperCasePattern: () => ValidationMessage;
-        numbers: (value: number) => ValidationMessage;
-    };
-};

package/dist/core/shared/request/rules/messages/types.js

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