@arc-js/cp-request 0.0.1

package/index.js

@@ -0,0 +1,642 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var qust = require('@arc-js/qust');
+var Pajo = require('@arc-js/pajo');
+var JON = require('@arc-js/jon');
+
+
+
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const NODEENV = 'development'; 
+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'];
+[...tabAlphabetique, ...tabAlphabetique.map(x => x.toUpperCase())];
+
+function defaultMapAction$1(code, type, message, data, cleanedData, error, errors) {
+    return ({
+        response: {
+            code,
+            type,
+            message,
+        },
+        data: cleanedData,
+        error,
+        errors,
+    });
+}
+function defaultErrMapAction$1(code, type, message, data, cleanedData, error, errors) {
+    return ({
+        response: {
+            code,
+            type,
+            message,
+        },
+        data: cleanedData,
+        error,
+        errors,
+    });
+}
+function defaultSuccessAction$1(response) {
+    {
+        console.log('HttpRequest - actionRequest | successActionF - response:: ', response);
+    }
+}
+function defaultErrorAction$1(response) {
+    {
+        console.log('HttpRequest - actionRequest | errorActionF - response:: ', response, ' && (typeof response):: ', (typeof response));
+    }
+}
+function getNotifRequestType(status = undefined) {
+    let type = "success";
+    if ([200].includes(status) || !status) {
+        status = 200;
+        type = "success";
+    }
+    else if ([422].includes(status)) {
+        type = "warning";
+    }
+    else if ([403, 409].includes(status)) {
+        type = "error_auth";
+    }
+    else if ([419, 401].includes(status)) {
+        type = "error_auth_required";
+    }
+    else if ([404, 405, 500, 400].includes(status)) {
+        type = "error";
+    }
+    else if ([501].includes(status)) {
+        type = "info";
+    }
+    else {
+        type = "error";
+    }
+    return type;
+}
+class HttpRequest {
+    constructor() {
+        this.lang = 'fr';
+    }
+    initConfig(host, lang) {
+        if (typeof host === 'string' && host.length > 0) {
+            this.host = host;
+        }
+        if (['fr', 'en'].includes(lang)) {
+            this.lang = lang;
+        }
+        return this;
+    }
+    getDefaultError() {
+        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),
+        };
+    }
+    actionRequest() {
+        return __awaiter(this, arguments, void 0, function* (urlParams = {
+            path: "",
+            method: "GET",
+        }, otherParams = {}, schema = undefined, mapAction, errMapAction, successAction, errorAction) {
+            var _a, _b, _c;
+            {
+                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 = (!!(urlParams === null || urlParams === void 0 ? void 0 : urlParams.responseType) &&
+                ["json", "arraybuffer", "blob", "text"].includes(urlParams === null || urlParams === void 0 ? void 0 : urlParams.responseType)) ? urlParams === null || urlParams === void 0 ? void 0 : urlParams.responseType : 'json';
+            const method = [
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+            ].includes(urlParams === null || urlParams === void 0 ? void 0 : urlParams.method) ? urlParams === null || urlParams === void 0 ? void 0 : urlParams.method : "GET";
+            let path = (typeof (urlParams === null || urlParams === void 0 ? void 0 : urlParams.path) === "string") ? urlParams === null || urlParams === void 0 ? void 0 : urlParams.path : "";
+            let headers = (typeof (urlParams === null || urlParams === void 0 ? void 0 : urlParams.headers) === "object" &&
+                Array.isArray(urlParams === null || urlParams === void 0 ? void 0 : urlParams.headers) === false &&
+                Object.keys(urlParams === null || urlParams === void 0 ? void 0 : urlParams.headers).length > 0) ? urlParams === null || urlParams === void 0 ? void 0 : urlParams.headers : undefined;
+            let params = (typeof (urlParams === null || urlParams === void 0 ? void 0 : urlParams.params) === "object" &&
+                Array.isArray(urlParams === null || urlParams === void 0 ? void 0 : urlParams.params) === false &&
+                Object.keys(urlParams === null || urlParams === void 0 ? void 0 : urlParams.params).length > 0) ? urlParams === null || urlParams === void 0 ? void 0 : urlParams.params : undefined;
+            let body = ((typeof (urlParams === null || urlParams === void 0 ? void 0 : urlParams.body) === "object" &&
+                Array.isArray(urlParams === null || urlParams === void 0 ? void 0 : urlParams.body) === false) || (urlParams === null || urlParams === void 0 ? void 0 : urlParams.body) instanceof FormData) ? urlParams === null || urlParams === void 0 ? void 0 : urlParams.body : undefined;
+            if (typeof body === "object" &&
+                Array.isArray(body) === false) {
+                body = JSON.stringify(urlParams === null || urlParams === void 0 ? void 0 : urlParams.body);
+            }
+            otherParams = (typeof otherParams === "object" &&
+                Array.isArray(otherParams) == false) ? otherParams : {};
+            if (!!(urlParams === null || urlParams === void 0 ? void 0 : urlParams.auth)) {
+                headers = Object.assign(Object.assign({}, headers), { Authorization: `Basic ${btoa(`${(_a = urlParams === null || urlParams === void 0 ? void 0 : urlParams.auth) === null || _a === void 0 ? void 0 : _a.username}:${(_b = urlParams === null || urlParams === void 0 ? void 0 : urlParams.auth) === null || _b === void 0 ? void 0 : _b.password}`)}` });
+            }
+            const mapActionF = (!!mapAction) ? mapAction : defaultMapAction$1;
+            const errMapActionF = (!!errMapAction) ? errMapAction : defaultErrMapAction$1;
+            const successActionF = !!successAction ? successAction : defaultSuccessAction$1;
+            const errorActionF = (!!errorAction) ? errorAction : defaultErrorAction$1;
+            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.qust.stringify(params)}`;
+                }
+                let resConfig = Object.assign({ 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 = yield FetchClass(path, Object.assign({}, resConfig));
+                const hasContentType = !!res.headers.get("content-type");
+                const isJson = (_c = res.headers.get("content-type")) === null || _c === void 0 ? void 0 : _c.includes("application/json");
+                if (NODEENV === 'development') {
+                    console.log('HttpRequest - actionRequest | res:: ', res);
+                }
+                const statusResponse = res.status;
+                const typeResponse = getNotifRequestType(statusResponse);
+                let httpRes = undefined;
+                if (responseType === 'text' && hasContentType) {
+                    httpRes = yield res.text();
+                }
+                else if (responseType === 'json' && !!isJson) {
+                    httpRes = yield res.json();
+                }
+                else if (responseType === 'arraybuffer' && hasContentType) {
+                    httpRes = yield res.arrayBuffer();
+                }
+                let errors = undefined;
+                if (typeof httpRes === 'object' &&
+                    !Array.isArray(httpRes)) {
+                    errors = httpRes === null || httpRes === void 0 ? void 0 : httpRes.errors;
+                }
+                else if (typeof httpRes === 'string' &&
+                    !(['info', 'success'].includes(typeResponse))) {
+                    errors = httpRes;
+                }
+                if (NODEENV === 'development') {
+                    console.log('HttpRequest - actionRequest | httpRes:: ', httpRes);
+                }
+                let messageNotif = 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 === null || httpRes === void 0 ? void 0 : httpRes.message)) {
+                        messageNotif = httpRes === null || httpRes === void 0 ? void 0 : 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 = 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 === null || errorsF === void 0 ? void 0 : 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") {
+                    yield successActionF(cleanedData);
+                }
+                else {
+                    yield errorActionF(cleanedData);
+                }
+            }
+            catch (error) {
+                let message = 'erreur inconnue';
+                if (typeof (error === null || error === void 0 ? void 0 : error.message) === 'string') {
+                    message = error === null || error === void 0 ? void 0 : 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];
+                }
+                {
+                    console.log("[ERROR] HttpRequest - actionRequest | error:: ", error);
+                    console.log("[ERROR] HttpRequest - actionRequest | message:: ", message);
+                }
+                let codeF = (error === null || error === void 0 ? void 0 : error.status) || 404;
+                let typeF = !!(error === null || error === void 0 ? void 0 : error.status) ? getNotifRequestType(error === null || error === void 0 ? void 0 : error.status) : "error";
+                let messageF = message;
+                let dataF = error;
+                let correctDataF = schema.isValid(dataF);
+                let cleanedDataF = !!correctDataF ? dataF : this.getDefaultError();
+                let errorsF = [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 === null || errorsF === void 0 ? void 0 : errorsF[0];
+                errorF = (!(errorF instanceof Error || typeof errorF === 'undefined' || errorF === null)) ? new Error(`${errorF}`) : errorF;
+                if (!errorF && !!message) {
+                    errorF = new Error(`${message}`);
+                    errorsF = [message];
+                }
+                {
+                    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);
+                {
+                    console.log("[ERROR] HttpRequest - actionRequest | errorDatas:: ", errorDatas);
+                }
+                yield errorActionF(errorDatas);
+                return errorDatas;
+            }
+        });
+    }
+    findAllRequests() {
+        return __awaiter(this, arguments, void 0, function* (urlParams = {
+            path: "",
+            method: "GET",
+        }, otherParams = {}, successAction = defaultSuccessAction$1, errorAction = defaultErrorAction$1) {
+            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 = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData === null || cleanedData === void 0 ? void 0 : cleanedData.datas,
+                    error,
+                    errors,
+                });
+            };
+            const errMapAction = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData === null || cleanedData === void 0 ? void 0 : cleanedData.datas,
+                    error,
+                    errors,
+                });
+            };
+            yield this.actionRequest(urlParams, otherParams, schema, mapAction, errMapAction, successAction, errorAction);
+        });
+    }
+    findOneRequest() {
+        return __awaiter(this, arguments, void 0, function* (urlParams = {
+            path: "",
+            method: "GET",
+        }, otherParams = {}, successAction = defaultSuccessAction$1, errorAction = defaultErrorAction$1) {
+            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 = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData === null || cleanedData === void 0 ? void 0 : cleanedData.data,
+                    error,
+                    errors,
+                });
+            };
+            const errMapAction = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData === null || cleanedData === void 0 ? void 0 : cleanedData.data,
+                    error,
+                    errors,
+                });
+            };
+            yield this.actionRequest(urlParams, otherParams, schema, mapAction, errMapAction, successAction, errorAction);
+        });
+    }
+    getFetchClass() {
+        return (typeof window !== "undefined") ? window.fetch : fetch;
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.HttpRequest = HttpRequest;
+        }
+    }
+}
+if (typeof window !== "undefined") {
+    window.HttpRequest = HttpRequest;
+}
+
+function defaultMapAction(code, type, message, data, cleanedData, error, errors) {
+    return {
+        response: { code, type, message },
+        data: cleanedData,
+        error,
+        errors,
+    };
+}
+function defaultErrMapAction(code, type, message, data, cleanedData, error, errors) {
+    return {
+        response: { code, type, message },
+        data: cleanedData,
+        error,
+        errors,
+    };
+}
+function defaultSuccessAction(res) {
+    {
+        console.log("WsRequest | success :: ", res);
+    }
+}
+function defaultErrorAction(res) {
+    {
+        console.log("WsRequest | error :: ", res);
+    }
+}
+class WsRequest {
+    constructor() {
+        this.lang = "fr";
+        this.socket = null;
+        this.connected = false;
+        this.autoReconnect = true;
+        this.reconnectDelay = 2000;
+        this.maxReconnectAttempts = 10;
+        this.reconnectAttempts = 0;
+        this.messageQueue = [];
+    }
+    initConfig(host, lang) {
+        if (host && typeof host === "string") {
+            this.host = host;
+        }
+        if (["fr", "en"].includes(lang)) {
+            this.lang = lang;
+        }
+        return this;
+    }
+    connect(params) {
+        const { path, auth, headers = {}, autoReconnect = true, reconnectDelay = 2000, maxReconnectAttempts = 10, } = params;
+        let urlParams = (typeof (params === null || params === void 0 ? void 0 : params.params) === "object" &&
+            !Array.isArray(params === null || params === void 0 ? void 0 : params.params) &&
+            Object.keys(params === null || params === void 0 ? void 0 : params.params).length > 0) ? params === null || params === void 0 ? void 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.qust.stringify(urlParams)}`;
+        }
+        if (auth) {
+            headers["Authorization"] =
+                "Basic " + btoa(`${auth.username}:${auth.password}`);
+        }
+        {
+            console.log("WsRequest | connecting to:", url);
+        }
+        this.socket = new (this.getWsClass())(url || '');
+        this.socket.onopen = () => {
+            var _a;
+            this.connected = true;
+            this.reconnectAttempts = 0;
+            {
+                console.log("WsRequest | WebSocket connected");
+            }
+            while (this.messageQueue.length > 0) {
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(this.messageQueue.shift());
+            }
+        };
+        this.socket.onerror = (err) => {
+            {
+                console.log("WsRequest | error:", err);
+            }
+        };
+        this.socket.onclose = () => {
+            this.connected = false;
+            {
+                console.log("WsRequest | closed");
+            }
+            if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                setTimeout(() => {
+                    this.reconnectAttempts++;
+                    {
+                        console.log("WsRequest | reconnect attempt:", this.reconnectAttempts);
+                    }
+                    this.connect(params);
+                }, this.reconnectDelay);
+            }
+        };
+    }
+    actionMessage(message_1) {
+        return __awaiter(this, arguments, void 0, function* (message, schema = undefined, mapAction = defaultMapAction, errMapAction = defaultErrMapAction, successAction = defaultSuccessAction, errorAction = defaultErrorAction) {
+            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((resolve) => {
+                this.socket.onmessage = (e) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c, _d, _e, _f;
+                    let resJson = undefined;
+                    try {
+                        resJson = JSON.parse(e.data);
+                    }
+                    catch (err) {
+                        resJson = e.data;
+                    }
+                    let isValid = schema.isValid(resJson);
+                    let cleaned = isValid ? resJson : undefined;
+                    let codeF = (_b = (_a = resJson === null || resJson === void 0 ? void 0 : resJson.response) === null || _a === void 0 ? void 0 : _a.code) !== null && _b !== void 0 ? _b : 200;
+                    let typeF = (_d = (_c = resJson === null || resJson === void 0 ? void 0 : resJson.response) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : "success";
+                    let messageF = (_f = (_e = resJson === null || resJson === void 0 ? void 0 : resJson.response) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : undefined;
+                    let errorsF = [];
+                    if (resJson === null || resJson === void 0 ? void 0 : resJson.errors) {
+                        errorsF = Array.isArray(resJson.errors)
+                            ? resJson.errors
+                            : Object.values(resJson.errors);
+                    }
+                    let errorF = errorsF === null || errorsF === void 0 ? void 0 : 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") {
+                        yield successAction(responseCleaned);
+                    }
+                    else {
+                        yield errorAction(responseCleaned);
+                    }
+                    resolve(responseCleaned);
+                });
+                this.socket.send(payload);
+            });
+        });
+    }
+    findAllMessages(message_1) {
+        return __awaiter(this, arguments, void 0, function* (message, successAction = defaultSuccessAction, errorAction = 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())
+                    .default([]),
+            });
+            const mapAction = (code, type, message, data, cleaned, error, errors) => {
+                return {
+                    response: { code, type, message },
+                    data: (cleaned === null || cleaned === void 0 ? void 0 : cleaned.datas) || [],
+                    error,
+                    errors,
+                };
+            };
+            return yield this.actionMessage(message, schema, mapAction, mapAction, successAction, errorAction);
+        });
+    }
+    findOneMessage(message_1) {
+        return __awaiter(this, arguments, void 0, function* (message, successAction = defaultSuccessAction, errorAction = 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 = (code, type, message, data, cleaned, error, errors) => {
+                return {
+                    response: { code, type, message },
+                    data: (cleaned === null || cleaned === void 0 ? void 0 : cleaned.data) || null,
+                    error,
+                    errors,
+                };
+            };
+            return yield this.actionMessage(message, schema, mapAction, mapAction, successAction, errorAction);
+        });
+    }
+    getWsClass() {
+        return (typeof window !== "undefined") ? window.WebSocket : WebSocket;
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.WsRequest = WsRequest;
+        }
+    }
+}
+if (typeof window !== "undefined") {
+    window.WsRequest = WsRequest;
+}
+
+var index = {
+    HttpRequest,
+    WsRequest,
+};
+
+exports.HttpRequest = HttpRequest;
+exports.WsRequest = WsRequest;
+exports.default = index;