@azure-net/kit 0.8.8 → 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/dist/core/ui/index.d.ts

@@ -1,2 +1,3 @@
 export * from './eventModifiers/index.js';
 export * from './onClickOutside/index.js';
+export * from './mask/index.js';

package/dist/core/ui/index.js

@@ -1,2 +1,3 @@
 export * from './eventModifiers/index.js';
 export * from './onClickOutside/index.js';
+export * from './mask/index.js';

package/dist/core/ui/mask/Mask.d.ts

@@ -0,0 +1,13 @@
+export type TokenSettings = {
+    pattern?: RegExp;
+    escape?: boolean;
+    transform?: (v: string) => string;
+};
+export type Tokens = Record<string, TokenSettings>;
+export declare class Mask {
+    static tokens: Tokens;
+    static dynamicMask(maskIt: typeof Mask.maskIt, masks: string[], tokens: Tokens): (value: string, masked?: boolean) => string;
+    static maskIt(value: string, mask: string | undefined, masked: boolean | undefined, tokens: Tokens): string;
+    static masker(value: string, mask: string | undefined, masked: boolean | undefined, tokens: Tokens): string;
+}
+export declare const masked: (el: HTMLInputElement, mask?: string, tokens?: Tokens) => void;

package/dist/core/ui/mask/Mask.js

@@ -0,0 +1,110 @@
+export class Mask {
+    static tokens = {
+        X: { pattern: /[0-9a-zA-Z]/ },
+        S: { pattern: /[a-zA-Z]/ },
+        A: { pattern: /[a-zA-Z]/, transform: (v) => v.toLocaleUpperCase() },
+        a: { pattern: /[a-zA-Z]/, transform: (v) => v.toLocaleLowerCase() },
+        '#': { pattern: /\d/ },
+        '!': { escape: true }
+    };
+    static dynamicMask(maskIt, masks, tokens) {
+        masks = masks.sort((a, b) => a.length - b.length);
+        return function (value, masked = true) {
+            let i = 0;
+            while (i < masks.length) {
+                const currentMask = masks[i];
+                i++;
+                const nextMask = masks[i];
+                if (!(nextMask && maskIt(value, nextMask, true, tokens).length > currentMask.length)) {
+                    return maskIt(value, currentMask, masked, tokens);
+                }
+            }
+            return '';
+        };
+    }
+    static maskIt(value, mask = undefined, masked = true, tokens) {
+        value = value || '';
+        mask = mask || '';
+        let iMask = 0;
+        let iValue = 0;
+        let output = '';
+        while (iMask < mask.length && iValue < value.length) {
+            let cMask = mask[iMask];
+            const masker = tokens[cMask];
+            const cValue = value[iValue];
+            if (masker && !masker.escape) {
+                if (masker.pattern?.test(cValue)) {
+                    output += masker.transform ? masker.transform(cValue) : cValue;
+                    iMask++;
+                }
+                iValue++;
+            }
+            else {
+                if (masker && masker.escape) {
+                    iMask++;
+                    cMask = mask[iMask];
+                }
+                if (masked)
+                    output += cMask;
+                if (cValue === cMask)
+                    iValue++;
+                iMask++;
+            }
+        }
+        let restOutput = '';
+        while (iMask < mask.length && masked) {
+            const cMask = mask[iMask];
+            if (tokens[cMask]) {
+                restOutput = '';
+                break;
+            }
+            restOutput += cMask;
+            iMask++;
+        }
+        return output + restOutput;
+    }
+    static masker(value, mask = undefined, masked = true, tokens) {
+        return Array.isArray(mask) ? this.dynamicMask(Mask.maskIt, mask, tokens)(value, masked) : this.maskIt(value, mask, masked, tokens);
+    }
+}
+export const masked = (el, mask, tokens) => {
+    const config = {
+        mask,
+        tokens: tokens ? { ...Mask.tokens, ...tokens } : Mask.tokens
+    };
+    if (el.tagName.toLocaleUpperCase() !== 'INPUT') {
+        const els = el.getElementsByTagName('input');
+        if (els.length !== 1) {
+            throw new Error('mask requires 1 input, found ' + els.length);
+        }
+        else {
+            el = els[0];
+        }
+    }
+    if (config.mask) {
+        el.oninput = function (evt) {
+            if (!evt.isTrusted)
+                return;
+            let position = el.selectionEnd;
+            if (position) {
+                const digit = el.value[position - 1];
+                el.value = Mask.masker(el.value, config.mask, true, config.tokens);
+                while (position < el.value.length && el.value.charAt(position - 1) !== digit) {
+                    position++;
+                }
+            }
+            if (el === document.activeElement) {
+                el.setSelectionRange(position, position);
+                setTimeout(function () {
+                    el.setSelectionRange(position, position);
+                }, 0);
+            }
+            el.dispatchEvent(new Event('input'));
+        };
+        const newDisplay = Mask.masker(el.value, config.mask, true, config.tokens);
+        if (newDisplay !== el.value) {
+            el.value = newDisplay;
+            el.dispatchEvent(new Event('input'));
+        }
+    }
+};

package/dist/core/ui/mask/index.d.ts

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

package/dist/core/ui/mask/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "0.8.8",
+  "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",