@jsarc/cp-request 0.0.0

package/index.ts

@@ -0,0 +1,1064 @@
+import JON from '@jsarc/jon';
+import { Pajo } from '@jsarc/pajo';
+import { qust, Qust } from '@jsarc/qust';
+
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    HttpRequest: any;
+    WsRequest: any;
+    __bundledModules: any;
+}
+
+interface HTTPRequestParams {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    path: string;
+    headers?: any;
+    params?: any;
+    body?: any;
+    responseType?: "json" | "arraybuffer" | "blob" | "text";
+    auth?: {
+        username: string;
+        password: string;
+    };
+}
+
+interface HTTPRequestResponse {
+    response: {
+        code: number;
+        type: string;
+        message: any;
+    };
+    data: any;
+    error?: any;
+    errors?: any[];
+}
+
+
+type HttpRequestMapAction = (code: number, type: string, message: string, data: any, cleanedData?: any, error?: any, errors?: any[]) => HTTPRequestResponse;
+
+type HttpRequestReponseAction = (response: HTTPRequestResponse) => Promise<void> | void;
+
+interface WSRequestParams {
+    path: string;
+    headers?: Record<string, string>;
+    params?: any;
+    auth?: {
+        username: string;
+        password: string;
+    };
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+}
+
+
+interface WSMessageResponse {
+    response: {
+        code: number;
+        type: string;
+        message: any;
+    };
+    data: any;
+    error?: any;
+    errors?: any[];
+}
+
+
+type WsRequestMapAction = (
+    code: number,
+    type: string,
+    message: string,
+    data: any,
+    cleanedData?: any,
+    error?: any,
+    errors?: any[],
+) => WSMessageResponse;
+
+type WsRequestReponseAction = (response: WSMessageResponse) => Promise<void> | void;
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+    const NODEENV: 'development' | 'production' | 'debug' = 'development'; // development | debug | production
+
+    const langs = ['en', 'fr'];
+    const langCodes = {
+        'fr': 'fr_FR',
+        'en': 'en_US',
+    };
+
+    const dateTimeFormatInitial = '%Y-%m-%dT%H:%M:%S.%fZ';
+    const dateFormatInitial = '%Y-%m-%d';
+    const timeFormatInitial = '%H:%M:%S.%fZ';
+
+    const dateFormatForFile = '%Y%m%d%H%M%S';
+    const dateFormat1 = '%Y/%m/%d %H:%M:%S.%fZ';
+    const dateFormat2 = '%Y/%m/%d %H:%M:%S';
+    const dateFormat3 = '%Y/%m/%d %H:%M';
+    const dateFormat4 = '%d/%m/%Y %H:%M:%S GMT%z';
+    const dateFormat5 = '%Y/%m/%d';
+    const timeFormat1 = '%H:%M:%S.%fZ';
+    const timeFormat2 = '%H:%M:%S';
+    const timeFormat3 = '%H:%M:%S.%f';
+    const pagesPossibles = [5, 10, 15, 25, 50, 100, -1];
+
+    const regExpForAlphanumeric = /^[\w\s]{1,}/;
+
+    const tabNumerique = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+    const tabAlphabetique = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
+    const tabAlphabetiqueInsensitive = [...tabAlphabetique, ...tabAlphabetique.map(x => x.toUpperCase())];
+    const tabAlphanumerique = [...tabNumerique, ...tabAlphabetique];
+    const tabAlphanumeriqueInsensitive = [...tabNumerique, ...tabAlphabetiqueInsensitive];
+    
+
+
+
+
+
+
+
+    function defaultMapAction(
+        code: number,
+        type: string,
+        message: string,
+        data: any,
+        cleanedData: any,
+        error?: any,
+        errors?: any[],
+    ) {
+        return ({
+            response: {
+                code,
+                type,
+                message,
+            },
+            data: cleanedData,
+            error,
+            errors,
+        });
+    };
+    function defaultErrMapAction(
+        code: number,
+        type: string,
+        message: string,
+        data: any,
+        cleanedData: any,
+        error?: any,
+        errors?: any[],
+    ) {
+        return ({
+            response: {
+                code,
+                type,
+                message,
+            },
+            data: cleanedData,
+            error,
+            errors,
+        });
+    }
+    function defaultSuccessAction(response: HTTPRequestResponse) {
+        if (NODEENV === 'development') {
+            console.log('HttpRequest - actionRequest | successActionF - response:: ', response);
+        }
+    }
+    function defaultErrorAction(response: HTTPRequestResponse) {
+        if (NODEENV === 'development') {
+            console.log('HttpRequest - actionRequest | errorActionF - response:: ', response, ' && (typeof response):: ', (typeof response));
+        }
+    }
+
+    function getNotifRequestType(status: number | undefined = undefined) {
+        let type = "success";
+        if ([200].includes(status as any) || !status) {
+            status = 200;
+            type = "success";
+        } else if ([422].includes(status as any)) {
+            type = "warning";
+        } else if ([403, 409].includes(status as any)) {
+            type = "error_auth";
+        } else if ([419, 401].includes(status as any)) {
+            type = "error_auth_required";
+        } else if ([404, 405, 500, 400].includes(status as any)) {
+            type = "error";
+        } else if ([501].includes(status as any)) {
+            type = "info";
+        } else {
+            type = "error";
+        }
+
+        return type;
+    }
+
+    class HttpRequest {
+        protected host: string | undefined;
+        protected lang: 'fr' | 'en' = 'fr';
+
+        constructor() {
+        }
+
+        public initConfig(host: string, lang: 'fr' | 'en'): this {
+            if (typeof host === 'string' && host.length > 0) {
+                this.host = host;
+            }
+            if(['fr', 'en'].includes(lang)) {
+                this.lang = lang;
+            }
+            return this;
+        }
+
+        private getDefaultError(): HTTPRequestResponse {
+            const message = {
+                fr: 'Error lors de la recuperation de la reponse',
+                en: 'Error lors de la recuperation de la reponse',
+            }[this.lang];
+            return {
+                response: {
+                    code: 404,
+                    type: 'error',
+                    message: message
+                },
+                data: undefined,
+                error: new Error(message),
+            };
+        }
+
+        protected async actionRequest<T = any>(
+            urlParams: HTTPRequestParams = {
+                path: "",
+                method: "GET",
+            },
+            otherParams: any = {},
+            schema: any = undefined,
+            mapAction: HttpRequestMapAction,
+            errMapAction?: HttpRequestMapAction,
+            successAction?: HttpRequestReponseAction,
+            errorAction?: HttpRequestReponseAction,
+        ) {
+            if (NODEENV === 'development') {
+                console.log('HttpRequest - actionRequest | urlParams:: ', urlParams);
+                console.log('HttpRequest - actionRequest | otherParams:: ', otherParams);
+                console.log('HttpRequest - actionRequest | schema:: ', schema);
+            }
+            const FetchClass = this.getFetchClass();
+            urlParams = (
+                typeof urlParams === "object" &&
+                Array.isArray(urlParams) === false
+            ) ? urlParams : {
+                path: "",
+                method: "GET",
+            };
+            const responseType: "json" | "arraybuffer" | "blob" | "text" = (
+                !!urlParams?.responseType &&
+                ["json", "arraybuffer", "blob", "text"].includes(urlParams?.responseType)
+            ) ? urlParams?.responseType : 'json';
+            const method: "GET" | "POST" | "PUT" | "DELETE" = [
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+            ].includes(urlParams?.method) ? urlParams?.method : "GET";
+            let path: string = (typeof urlParams?.path === "string") ? urlParams?.path : "";
+            let headers = (
+                typeof urlParams?.headers === "object" &&
+                Array.isArray(urlParams?.headers) === false &&
+                Object.keys(urlParams?.headers).length > 0
+            ) ? urlParams?.headers : undefined;
+            let params = (
+                typeof urlParams?.params === "object" &&
+                Array.isArray(urlParams?.params) === false &&
+                Object.keys(urlParams?.params).length > 0
+            ) ? urlParams?.params : undefined;
+            let body: any = (
+                (
+                    typeof urlParams?.body === "object" &&
+                    Array.isArray(urlParams?.body) === false
+                ) || urlParams?.body instanceof FormData
+            ) ? urlParams?.body : undefined;
+            if (
+                typeof body === "object" &&
+                Array.isArray(body) === false
+            ) {
+                body = JSON.stringify(urlParams?.body);
+            }
+
+            otherParams = (
+                typeof otherParams === "object" &&
+                Array.isArray(otherParams) == false
+            ) ? otherParams : {};
+
+            if (!!urlParams?.auth) {
+                headers = {
+                    ...headers,
+                    Authorization: `Basic ${btoa(`${urlParams?.auth?.username}:${urlParams?.auth?.password}`)}`,
+                };
+            }
+
+            const mapActionF = (!!mapAction) ? mapAction : defaultMapAction;
+            const errMapActionF = (!!errMapAction) ? errMapAction : defaultErrMapAction;
+            const successActionF = !!successAction ? successAction : defaultSuccessAction;
+            const errorActionF = (!!errorAction) ? errorAction : defaultErrorAction;
+            if(!(schema instanceof JON.Object)) {
+                schema = new JON.Object(this.lang);
+            }
+            schema = schema.required();
+
+            try {
+                const newPath = (
+                    typeof this.host === 'string' &&
+                    this.host.length > 0
+                ) ? Pajo.joinWithHost(this.host, path) : Pajo.join(path);
+                if (!!newPath) {
+                    path = newPath;
+                }
+                if (!!params) {
+                    path = `${path}${qust.stringify(params)}`;
+                }
+
+                let resConfig: RequestInit = {
+                    method,
+                    headers,
+                    ...otherParams,
+                };
+                if (!!body) {
+                    resConfig.body = body;
+                }
+
+                if (NODEENV === 'development') {
+                    console.log('HttpRequest - actionRequest | path (final):: ', path);
+                    console.log('HttpRequest - actionRequest | resConfig:: ', resConfig);
+                }
+                const res = await FetchClass(path, {
+                    ...resConfig,
+                });
+                const hasContentType = !!res.headers.get("content-type");
+                const isJson = res.headers.get("content-type")?.includes("application/json");
+                if (NODEENV === 'development') {
+                    console.log('HttpRequest - actionRequest | res:: ', res);
+                }
+
+                const statusResponse = res.status;
+                const typeResponse = getNotifRequestType(statusResponse);
+                let httpRes: any = undefined;
+                if (responseType === 'text' && hasContentType) {
+                    httpRes = await res.text();
+                } else if (responseType === 'json' && !!isJson) {
+                    httpRes = await res.json();
+                } else if (responseType === 'arraybuffer' && hasContentType) {
+                    httpRes = await res.arrayBuffer();
+                }
+                let errors: any = undefined;
+                if (
+                    typeof httpRes === 'object' &&
+                    !Array.isArray(httpRes)
+                ) {
+                    errors = httpRes?.errors;
+                } else if (
+                    typeof httpRes === 'string' &&
+                    !(['info', 'success'].includes(typeResponse))
+                ) {
+                    errors = httpRes;
+                }
+
+                if (NODEENV === 'development') {
+                    console.log('HttpRequest - actionRequest | httpRes:: ', httpRes);
+                }
+
+                let messageNotif: any = undefined;
+                if (!res.ok) {
+                    if (
+                        typeof errors === 'object' &&
+                        !Array.isArray(errors) &&
+                        Object.keys(errors).length > 0
+                    ) {
+                        messageNotif = errors[
+                            Object.keys(errors)[
+                            Object.keys(errors).length - 1
+                            ]
+                        ];
+                    } else if (
+                        !!httpRes?.message
+                    ) {
+                        messageNotif = httpRes?.message;
+                    } else {
+                        messageNotif = {
+                            en: "unknown error",
+                            fr: "erreur inconnue",
+                        }[this.lang];
+                    }
+                }
+                if (NODEENV === 'development') {
+                    console.log("HttpRequest - actionRequest | messageNotif:: ", messageNotif);
+                }
+
+                let codeF = statusResponse || (!!res.ok ? 200 : 404);
+                let typeF = (!!statusResponse ? typeResponse : (!!res.ok ? "success" : "error"));
+                let messageF = messageNotif;
+                let correctDataF = schema.isValid(httpRes);
+                let dataF = ((!!res.ok) ? httpRes : undefined);
+                let cleanedDataF = !!correctDataF ? dataF : this.getDefaultError();
+                let errorsF: any | undefined = undefined;
+                if(typeof errors === 'object' && !Array.isArray(errors)) {
+                    errorsF = Object.values(errors);
+                } else if(typeof errors === 'object' && !!Array.isArray(errors)) {
+                    errorsF = errorsF;
+                } else if(typeof errors === 'string' && errors.length > 0) {
+                    errorsF = [errorsF]
+                }
+                let errorF = errorsF?.[0];
+                errorF = (!(errorF instanceof Error || typeof errorF === 'undefined' || errorF === null)) ? new Error(`${errorF}`) : errorF;
+                if(!errorF && !!messageNotif) {
+                    errorF = new Error(`${messageNotif}`);
+                    errorsF = [messageNotif];
+                }
+
+                const cleanedData = (['success', 'info'].includes(typeF)) ? mapActionF(
+                    codeF,
+                    typeF,
+                    messageF,
+                    dataF,
+                    cleanedDataF,
+                    errorF,
+                    errorsF,
+                ) : errMapActionF(
+                    codeF,
+                    typeF,
+                    messageF,
+                    dataF,
+                    cleanedDataF,
+                    errorF,
+                    errorsF,
+                );
+                if (NODEENV === 'development') {
+                    console.log("HttpRequest - actionRequest | cleanedData (OLD):: ", cleanedData);
+                }
+
+                if (cleanedData.response.type === "success") {
+                    await successActionF(cleanedData);
+                } else {
+                    await errorActionF(cleanedData);
+                }
+            } catch (error: any) {
+                let message = 'erreur inconnue';
+                if(typeof error?.message === 'string') {
+                    message = error?.message;
+                } else if(typeof error === 'string') {
+                    message = error;
+                }
+                if (message.toLowerCase() === 'failed to fetch') {
+                    message = {
+                        en: "Service unavailable. Please try again later.",
+                        fr: "Service indisponible. Veuillez réessayer plus tard.",
+                    }[this.lang];
+                }
+
+                if (NODEENV === 'development') {
+                    console.log("[ERROR] HttpRequest - actionRequest | error:: ", error);
+                    console.log("[ERROR] HttpRequest - actionRequest | message:: ", message);
+                }
+
+                let codeF: number = error?.status || 404;
+                let typeF: string = !!error?.status ? getNotifRequestType(error?.status) : "error";
+                let messageF: string = message;
+                let dataF: any = error;
+                let correctDataF = schema.isValid(dataF);
+                let cleanedDataF = !!correctDataF ? dataF : this.getDefaultError();
+                let errorsF: any | undefined = [message];
+                if(typeof errorsF === 'object' && !Array.isArray(errorsF)) {
+                    errorsF = Object.values(errorsF);
+                } else if(typeof errorsF === 'object' && !!Array.isArray(errorsF)) {
+                    errorsF = errorsF;
+                } else if(typeof errorsF === 'string' && errorsF.length > 0) {
+                    errorsF = [errorsF]
+                }
+                let errorF = errorsF?.[0];
+                errorF = (!(errorF instanceof Error || typeof errorF === 'undefined' || errorF === null)) ? new Error(`${errorF}`) : errorF;
+                if(!errorF && !!message) {
+                    errorF = new Error(`${message}`);
+                    errorsF = [message];
+                }
+
+                if (NODEENV === 'development') {
+                    console.log("[ERROR] HttpRequest - actionRequest | codeF:: ", codeF);
+                    console.log("[ERROR] HttpRequest - actionRequest | typeF:: ", typeF);
+                    console.log("[ERROR] HttpRequest - actionRequest | dataF:: ", dataF);
+                    console.log("[ERROR] HttpRequest - actionRequest | correctDataF:: ", correctDataF);
+                    console.log("[ERROR] HttpRequest - actionRequest | cleanedDataF:: ", cleanedDataF);
+                    console.log("[ERROR] HttpRequest - actionRequest | errorsF:: ", errorsF);
+                    console.log("[ERROR] HttpRequest - actionRequest | errorsF:: ", errorsF);
+                }
+
+                const errorDatas = errMapActionF(
+                    codeF,
+                    typeF,
+                    messageF,
+                    dataF,
+                    cleanedDataF,
+                    errorF,
+                    errorsF,
+                );
+                if (NODEENV === 'development') {
+                    console.log("[ERROR] HttpRequest - actionRequest | errorDatas:: ", errorDatas);
+                }
+
+                await errorActionF(errorDatas);
+
+                return errorDatas as T;
+            }
+        }
+
+        public async findAllRequests<T = any>(
+            urlParams: HTTPRequestParams = {
+                path: "",
+                method: "GET",
+            },
+            otherParams: any = {},
+            successAction: HttpRequestReponseAction = defaultSuccessAction,
+            errorAction: HttpRequestReponseAction = defaultErrorAction,
+        ) {
+            const schema = new JON.Object(this.lang).struct({
+                response: new JON.Object(this.lang).struct({
+                    type: new JON.Enum(this.lang).choices('warning', 'success', 'danger', 'info').required(),
+                    code: new JON.Number(this.lang).required(),
+                    message: new JON.String(this.lang),
+                }),
+                datas: new JON.Array(this.lang).types(
+                    new JON.Object(this.lang).min(1).required(),
+                ).required().default([]),
+            });
+            const mapAction: HttpRequestMapAction = (
+                code,
+                type,
+                message,
+                data,
+                cleanedData,
+                error,
+                errors
+            ) => { 
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.datas,
+                    error,
+                    errors,
+                });
+            };
+            const errMapAction: HttpRequestMapAction = (
+                code,
+                type,
+                message,
+                data,
+                cleanedData,
+                error,
+                errors
+            ) => { 
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.datas,
+                    error,
+                    errors,
+                });
+            };
+            await this.actionRequest<T>(
+                urlParams,
+                otherParams,
+                schema,
+                mapAction,
+                errMapAction,
+                successAction,
+                errorAction,
+            )
+        }
+        public async findOneRequest<T = any>(
+            urlParams: HTTPRequestParams = {
+                path: "",
+                method: "GET",
+            },
+            otherParams: any = {},
+            successAction: HttpRequestReponseAction = defaultSuccessAction,
+            errorAction: HttpRequestReponseAction = defaultErrorAction,
+        ) {
+            const schema = new JON.Object(this.lang).struct({
+                response: new JON.Object(this.lang).struct({
+                    type: new JON.Enum(this.lang).choices('warning', 'success', 'danger', 'info').required(),
+                    code: new JON.Number(this.lang).required(),
+                    message: new JON.String(this.lang),
+                }),
+                data: new JON.Object(this.lang).min(1),
+            });
+            const mapAction: HttpRequestMapAction = (
+                code,
+                type,
+                message,
+                data,
+                cleanedData,
+                error,
+                errors
+            ) => { 
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.data,
+                    error,
+                    errors,
+                });
+            };
+            const errMapAction: HttpRequestMapAction = (
+                code,
+                type,
+                message,
+                data,
+                cleanedData,
+                error,
+                errors
+            ) => { 
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.data,
+                    error,
+                    errors,
+                });
+            };
+            await this.actionRequest<T>(
+                urlParams,
+                otherParams,
+                schema,
+                mapAction,
+                errMapAction,
+                successAction,
+                errorAction,
+            )
+        }
+
+        protected getFetchClass() {
+            return (typeof window !== "undefined") ? (window as any).fetch : fetch;
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).HttpRequest = HttpRequest;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        (window as any).HttpRequest = HttpRequest;
+    }
+
+
+
+    
+
+
+
+
+
+
+
+
+
+    function defaultMapActionWS(
+        code: number,
+        type: string,
+        message: string,
+        data: any,
+        cleanedData: any,
+        error?: any,
+        errors?: any[],
+    ) {
+        return {
+            response: { code, type, message },
+            data: cleanedData,
+            error,
+            errors,
+        };
+    }
+
+    function defaultErrMapActionWS(
+        code: number,
+        type: string,
+        message: string,
+        data: any,
+        cleanedData: any,
+        error?: any,
+        errors?: any[],
+    ) {
+        return {
+            response: { code, type, message },
+            data: cleanedData,
+            error,
+            errors,
+        };
+    }
+
+    function defaultSuccessActionWS(res: WSMessageResponse) {
+        if (NODEENV === "development") {
+            console.log("WsRequest | success :: ", res);
+        }
+    }
+
+    function defaultErrorActionWS(res: WSMessageResponse) {
+        if (NODEENV === "development") {
+            console.log("WsRequest | error :: ", res);
+        }
+    }
+
+    class WsRequest {
+        protected host: string | undefined;
+        protected lang: "fr" | "en" = "fr";
+
+        private socket: WebSocket | null = null;
+        private connected = false;
+
+        private autoReconnect = true;
+        private reconnectDelay = 2000;
+        private maxReconnectAttempts = 10;
+        private reconnectAttempts = 0;
+
+        private messageQueue: any[] = [];
+
+        constructor() {}
+
+        public initConfig(host: string, lang: "fr" | "en"): this {
+            if (host && typeof host === "string") {
+                this.host = host;
+            }
+            if (["fr", "en"].includes(lang)) {
+                this.lang = lang;
+            }
+            return this;
+        }
+
+        public connect(params: WSRequestParams): void {
+            const {
+                path,
+                auth,
+                headers = {},
+                autoReconnect = true,
+                reconnectDelay = 2000,
+                maxReconnectAttempts = 10,
+            } = params;
+            let urlParams = (
+                typeof params?.params === "object" &&
+                !Array.isArray(params?.params) &&
+                Object.keys(params?.params).length > 0
+            ) ? params?.params : undefined;
+
+            this.autoReconnect = autoReconnect;
+            this.reconnectDelay = reconnectDelay;
+            this.maxReconnectAttempts = maxReconnectAttempts;
+
+            let url = (
+                typeof this.host === 'string' &&
+                this.host.length > 0
+            ) ? Pajo.joinWithHost(this.host, path) : Pajo.join(path);
+            if (!!urlParams) {
+                url = `${url}${qust.stringify(urlParams)}`;
+            }
+
+            if (auth) {
+                headers["Authorization"] =
+                    "Basic " + btoa(`${auth.username}:${auth.password}`);
+            }
+
+            if (NODEENV === "development") {
+                console.log("WsRequest | connecting to:", url);
+            }
+
+            this.socket = new (this.getWsClass())(url || '');
+
+            if(!!this.socket) {
+                this.socket.onopen = () => {
+                    this.connected = true;
+                    this.reconnectAttempts = 0;
+
+                    if (NODEENV === "development") {
+                        console.log("WsRequest | WebSocket connected");
+                    }
+
+                    while (this.messageQueue.length > 0) {
+                        this.socket?.send(this.messageQueue.shift());
+                    }
+                };
+
+                this.socket.onerror = (err) => {
+                    if (NODEENV === "development") {
+                        console.log("WsRequest | error:", err);
+                    }
+                };
+
+                this.socket.onclose = () => {
+                    this.connected = false;
+                    if (NODEENV === "development") {
+                        console.log("WsRequest | closed");
+                    }
+
+                    if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                        setTimeout(() => {
+                            this.reconnectAttempts++;
+                            if (NODEENV === "development") {
+                                console.log("WsRequest | reconnect attempt:", this.reconnectAttempts);
+                            }
+                            this.connect(params);
+                        }, this.reconnectDelay);
+                    }
+                };
+            }
+        }
+
+        public async actionMessage<T = any>(
+            message: any,
+            schema: any = undefined,
+            mapAction: WsRequestMapAction = defaultMapActionWS,
+            errMapAction: WsRequestMapAction = defaultErrMapActionWS,
+            successAction: WsRequestReponseAction = defaultSuccessActionWS,
+            errorAction: WsRequestReponseAction = defaultErrorActionWS,
+        ) {
+            if (!this.connected || !this.socket) {
+                this.messageQueue.push(JSON.stringify(message));
+                return;
+            }
+
+            if(!(schema instanceof JON.Object)) {
+                schema = new JON.Object(this.lang);
+            }
+            schema = schema.required();
+
+            const payload = JSON.stringify(message);
+
+            return new Promise<T>((resolve) => {
+                this.socket!.onmessage = async (e) => {
+                    let resJson: any = undefined;
+                    try {
+                        resJson = JSON.parse(e.data);
+                    } catch (err) {
+                        resJson = e.data;
+                    }
+
+                    let isValid = schema.isValid(resJson);
+                    let cleaned = isValid ? resJson : undefined;
+
+                    let codeF = resJson?.response?.code ?? 200;
+                    let typeF = resJson?.response?.type ?? "success";
+                    let messageF = resJson?.response?.message ?? undefined;
+
+                    let errorsF: any[] | undefined = [];
+                    if (resJson?.errors) {
+                        errorsF = Array.isArray(resJson.errors)
+                            ? resJson.errors
+                            : Object.values(resJson.errors);
+                    }
+
+                    let errorF = errorsF?.[0];
+
+                    if (!(errorF instanceof Error)) {
+                        if (typeof errorF !== "undefined") errorF = new Error(`${errorF}`);
+                    }
+
+                    const responseCleaned =
+                        typeF === "success" || typeF === "info"
+                            ? mapAction(
+                                  codeF,
+                                  typeF,
+                                  messageF,
+                                  resJson,
+                                  cleaned,
+                                  errorF,
+                                  errorsF,
+                              )
+                            : errMapAction(
+                                  codeF,
+                                  typeF,
+                                  messageF,
+                                  resJson,
+                                  cleaned,
+                                  errorF,
+                                  errorsF,
+                              );
+
+                    if (responseCleaned.response.type === "success") {
+                        await successAction(responseCleaned);
+                    } else {
+                        await errorAction(responseCleaned);
+                    }
+
+                    resolve(responseCleaned as T);
+                };
+
+                this.socket!.send(payload);
+            });
+        }
+
+        public async findAllMessages<T = any>(
+            message: any,
+            successAction: WsRequestReponseAction = defaultSuccessActionWS,
+            errorAction: WsRequestReponseAction = defaultErrorActionWS,
+        ) {
+            const schema = new JON.Object(this.lang).struct({
+                response: new JON.Object(this.lang).struct({
+                    type: new JON.Enum(this.lang)
+                        .choices("warning", "success", "danger", "info")
+                        .required(),
+                    code: new JON.Number(this.lang).required(),
+                    message: new JON.String(this.lang),
+                }),
+                datas: new JON.Array(this.lang)
+                    .types(new JON.Object(this.lang).min(1).required())
+                    .default([]),
+            });
+
+            const mapAction: WsRequestMapAction = (code, type, message, data, cleaned, error, errors) => {
+                return {
+                    response: { code, type, message },
+                    data: cleaned?.datas || [],
+                    error,
+                    errors,
+                };
+            };
+
+            return await this.actionMessage<T>(
+                message,
+                schema,
+                mapAction,
+                mapAction,
+                successAction,
+                errorAction,
+            );
+        }
+
+        public async findOneMessage<T = any>(
+            message: any,
+            successAction: WsRequestReponseAction = defaultSuccessActionWS,
+            errorAction: WsRequestReponseAction = defaultErrorActionWS,
+        ) {
+            const schema = new JON.Object(this.lang).struct({
+                response: new JON.Object(this.lang).struct({
+                    type: new JON.Enum(this.lang)
+                        .choices("warning", "success", "danger", "info")
+                        .required(),
+                    code: new JON.Number(this.lang).required(),
+                    message: new JON.String(this.lang),
+                }),
+                data: new JON.Object(this.lang).min(1),
+            });
+
+            const mapAction: WsRequestMapAction = (code, type, message, data, cleaned, error, errors) => {
+                return {
+                    response: { code, type, message },
+                    data: cleaned?.data || null,
+                    error,
+                    errors,
+                };
+            };
+
+            return await this.actionMessage<T>(
+                message,
+                schema,
+                mapAction,
+                mapAction,
+                successAction,
+                errorAction,
+            );
+        }
+
+        protected getWsClass() {
+            return (typeof window !== "undefined") ? (window as any).WebSocket : WebSocket;
+        }
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).WsRequest = WsRequest;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        (window as any).WsRequest = WsRequest;
+    }
+
+
+
+    
+
+
+    const defaultExport = {
+        HttpRequest,
+        WsRequest,
+    };
+
+
+
+    
+    const globalFunctModule = {
+        default: defaultExport,
+        HttpRequest: HttpRequest,
+        WsRequest: WsRequest,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = defaultExport;
+        (global as any).HttpRequest = HttpRequest;
+        (global as any).WsRequest = WsRequest;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = defaultExport;
+        (window as any).HttpRequest = HttpRequest;
+        (window as any).WsRequest = WsRequest;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = defaultExport;
+        exports.HttpRequest = HttpRequest;
+        exports.WsRequest = WsRequest;
+    }
+	return globalFunctModule;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type HttpRequestElementTypeGF = typeof globalFunct.HttpRequest;
+
+type WsRequestElementTypeGF = typeof globalFunct.WsRequest;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const HttpRequestElementGF: HttpRequestElementTypeGF = globalFunct.HttpRequest;
+
+const WsRequestElementGF: WsRequestElementTypeGF = globalFunct.WsRequest;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+export {
+	defaultElementGF as default,
+	HttpRequestElementGF as HttpRequest,
+	WsRequestElementGF as WsRequest,
+};
+export type {
+	DefaultElementTypeGF,
+	HttpRequestElementTypeGF,WsRequestElementTypeGF,
+};