@jsarc/cp-request 0.0.0

package/js/index.js

@@ -0,0 +1,665 @@
+import JON from '@jsarc/jon';
+import { Pajo } from '@jsarc/pajo';
+import { qust } from '@jsarc/qust';
+const globalFunct = (function (global) {
+    'use strict';
+    const NODEENV = 'development'; 
+    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, 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(response) {
+        if (NODEENV === 'development') {
+            console.log('HttpRequest - actionRequest | successActionF - response:: ', response);
+        }
+    }
+    function defaultErrorAction(response) {
+        if (NODEENV === 'development') {
+            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 {
+        host;
+        lang = 'fr';
+        constructor() {
+        }
+        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),
+            };
+        }
+        async actionRequest(urlParams = {
+            path: "",
+            method: "GET",
+        }, otherParams = {}, schema = undefined, mapAction, errMapAction, successAction, errorAction) {
+            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 = (!!urlParams?.responseType &&
+                ["json", "arraybuffer", "blob", "text"].includes(urlParams?.responseType)) ? urlParams?.responseType : 'json';
+            const method = [
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+            ].includes(urlParams?.method) ? urlParams?.method : "GET";
+            let path = (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 = ((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 = {
+                    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 = 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 = 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 = 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 = 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) {
+                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 = error?.status || 404;
+                let typeF = !!error?.status ? getNotifRequestType(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?.[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;
+            }
+        }
+        async findAllRequests(urlParams = {
+            path: "",
+            method: "GET",
+        }, otherParams = {}, 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()).required().default([]),
+            });
+            const mapAction = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.datas,
+                    error,
+                    errors,
+                });
+            };
+            const errMapAction = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.datas,
+                    error,
+                    errors,
+                });
+            };
+            await this.actionRequest(urlParams, otherParams, schema, mapAction, errMapAction, successAction, errorAction);
+        }
+        async findOneRequest(urlParams = {
+            path: "",
+            method: "GET",
+        }, otherParams = {}, 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, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.data,
+                    error,
+                    errors,
+                });
+            };
+            const errMapAction = (code, type, message, data, cleanedData, error, errors) => {
+                return ({
+                    response: {
+                        code,
+                        type,
+                        message,
+                    },
+                    data: cleanedData?.data,
+                    error,
+                    errors,
+                });
+            };
+            await 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 defaultMapActionWS(code, type, message, data, cleanedData, error, errors) {
+        return {
+            response: { code, type, message },
+            data: cleanedData,
+            error,
+            errors,
+        };
+    }
+    function defaultErrMapActionWS(code, type, message, data, cleanedData, error, errors) {
+        return {
+            response: { code, type, message },
+            data: cleanedData,
+            error,
+            errors,
+        };
+    }
+    function defaultSuccessActionWS(res) {
+        if (NODEENV === "development") {
+            console.log("WsRequest | success :: ", res);
+        }
+    }
+    function defaultErrorActionWS(res) {
+        if (NODEENV === "development") {
+            console.log("WsRequest | error :: ", res);
+        }
+    }
+    class WsRequest {
+        host;
+        lang = "fr";
+        socket = null;
+        connected = false;
+        autoReconnect = true;
+        reconnectDelay = 2000;
+        maxReconnectAttempts = 10;
+        reconnectAttempts = 0;
+        messageQueue = [];
+        constructor() { }
+        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?.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);
+                    }
+                };
+            }
+        }
+        async actionMessage(message, schema = undefined, mapAction = defaultMapActionWS, errMapAction = defaultErrMapActionWS, successAction = defaultSuccessActionWS, errorAction = 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((resolve) => {
+                this.socket.onmessage = async (e) => {
+                    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 = resJson?.response?.code ?? 200;
+                    let typeF = resJson?.response?.type ?? "success";
+                    let messageF = resJson?.response?.message ?? undefined;
+                    let errorsF = [];
+                    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);
+                };
+                this.socket.send(payload);
+            });
+        }
+        async findAllMessages(message, successAction = defaultSuccessActionWS, errorAction = 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 = (code, type, message, data, cleaned, error, errors) => {
+                return {
+                    response: { code, type, message },
+                    data: cleaned?.datas || [],
+                    error,
+                    errors,
+                };
+            };
+            return await this.actionMessage(message, schema, mapAction, mapAction, successAction, errorAction);
+        }
+        async findOneMessage(message, successAction = defaultSuccessActionWS, errorAction = 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 = (code, type, message, data, cleaned, error, errors) => {
+                return {
+                    response: { code, type, message },
+                    data: cleaned?.data || null,
+                    error,
+                    errors,
+                };
+            };
+            return await 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;
+    }
+    const defaultExport = {
+        HttpRequest,
+        WsRequest,
+    };
+    const globalFunctModule = {
+        default: defaultExport,
+        HttpRequest: HttpRequest,
+        WsRequest: WsRequest,
+    };
+    const __bundledModules = globalFunctModule;
+    if (typeof global !== 'undefined') {
+        global.default = defaultExport;
+        global.HttpRequest = HttpRequest;
+        global.WsRequest = WsRequest;
+        global.__bundledModules = __bundledModules;
+    }
+    if (typeof window !== "undefined") {
+        window.default = defaultExport;
+        window.HttpRequest = HttpRequest;
+        window.WsRequest = WsRequest;
+        window.__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 :
+                {});
+const HttpRequestElementGF = globalFunct.HttpRequest;
+const WsRequestElementGF = globalFunct.WsRequest;
+const defaultElementGF = globalFunct.default;
+export { defaultElementGF as default, HttpRequestElementGF as HttpRequest, WsRequestElementGF as WsRequest, };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@jsarc/cp-request",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "description": "CP-REQUEST est une bibliothèque TypeScript complète pour gérer les requêtes HTTP et WebSocket avec une API unifiée et type-safe. Elle offre une solution robuste pour les communications client-serveur avec gestion automatique des erreurs, validation des schémas et support multi-langue.",
+  "main": "index.ts",
+  "keywords": [],
+  "author": "INICODE <contact.inicode@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "init": "npm init --scope=@jsarc/cp-request",
+    "login": "npm login"
+  },
+  "devDependencies": {},
+  "dependencies": {
+    "@jsarc/jon": "^0.0.1",
+    "@jsarc/pajo": "^0.0.1-beta.0.1",
+    "@jsarc/qust": "^0.0.1-beta.0.1"
+  }
+}