drf-react-by-schema 0.28.8 → 0.28.10

package/dist/context/APIWrapper.js

@@ -0,0 +1,593 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const axios_1 = __importDefault(require("axios"));
+const useMediaQuery_1 = __importDefault(require("@mui/material/useMediaQuery"));
+const utils_1 = require("../utils");
+const DialogActions_1 = __importDefault(require("../components/DialogActions"));
+const DRFReactBySchemaContext_1 = require("./DRFReactBySchemaContext");
+const api_1 = require("../api");
+const APIWrapperContext_1 = require("./APIWrapperContext");
+const DialogFormBySchema_1 = __importDefault(require("../components/forms/DialogFormBySchema"));
+const PrivateContext_1 = require("./PrivateContext");
+function APIWrapper({ handleLoading, setSnackBar, setDialog, pageForm, setPageForm, resetPageForm, formTools, setFormTools, children, }) {
+    const { serverEndPoint, theme, schemas } = (0, DRFReactBySchemaContext_1.useDRFReactBySchema)();
+    const isMobile = (0, useMediaQuery_1.default)(theme.breakpoints.down('md'));
+    const [usuaria, setUsuaria] = (0, react_1.useState)(null);
+    const [optionsAC, setOptionsAC] = (0, react_1.useReducer)((utils_1.reducer), null);
+    const editModel = (0, react_1.useRef)({});
+    const pageFormRef = (0, react_1.useRef)(pageForm);
+    const optionsACRef = (0, react_1.useRef)(optionsAC);
+    // BASIC OPERATIONS DEPENDING DIRECTLY ON SERVER_ENDPOINT:
+    const localGetRawData = (0, react_1.useCallback)((route) => __awaiter(this, void 0, void 0, function* () {
+        return (0, api_1.getRawData)({ path: route, serverEndPoint });
+    }), [serverEndPoint]);
+    const localGetAutoComplete = (0, react_1.useCallback)((model, queryParams) => {
+        return (0, api_1.getAutoComplete)({ model, queryParams, serverEndPoint });
+    }, [serverEndPoint]);
+    const localGetGenericModelList = (0, react_1.useCallback)((params) => __awaiter(this, void 0, void 0, function* () {
+        return (0, api_1.getGenericModelList)(Object.assign(Object.assign({}, params), { serverEndPoint, schemas }));
+    }), [serverEndPoint, schemas]);
+    const localGetGenericModel = (0, react_1.useCallback)((params) => __awaiter(this, void 0, void 0, function* () {
+        return (0, api_1.getGenericModel)(Object.assign(Object.assign({}, params), { serverEndPoint, schemas }));
+    }), [serverEndPoint, schemas]);
+    const localGetAllModels = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, api_1.getAllModels)(serverEndPoint);
+        if (axios_1.default.isAxiosError(response)) {
+            return [];
+        }
+        return response;
+    }), [serverEndPoint]);
+    const localLoginByPayload = (0, react_1.useCallback)((payload) => __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, api_1.loginByPayload)(payload, serverEndPoint);
+        if (typeof response !== 'boolean') {
+            console.log({
+                error: response,
+                payload,
+            });
+            return false;
+        }
+        return response;
+    }), [serverEndPoint]);
+    const localSignUp = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, api_1.signUp)(data, serverEndPoint);
+        return response;
+    }), [serverEndPoint]);
+    const localGetSignupOptions = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, api_1.getSignUpOptions)(serverEndPoint);
+        return response;
+    }), [serverEndPoint]);
+    const localRequestPasswordReset = (0, react_1.useCallback)((email) => __awaiter(this, void 0, void 0, function* () { return (0, api_1.requestPasswordReset)(email, serverEndPoint); }), [serverEndPoint]);
+    const localConfirmPasswordReset = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () { return (0, api_1.confirmPasswordReset)(data, serverEndPoint); }), [serverEndPoint]);
+    const localChangePassword = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () { return (0, api_1.changePassword)(data, serverEndPoint); }), [serverEndPoint]);
+    const signOut = (0, react_1.useCallback)(() => {
+        (0, api_1.clearJWT)();
+        setUsuaria(null);
+    }, []);
+    const localUpdateModel = (0, react_1.useCallback)((params) => __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, api_1.updateData)(Object.assign(Object.assign({}, params), { serverEndPoint }));
+        return response;
+    }), [serverEndPoint]);
+    const postData = (0, react_1.useCallback)((params) => __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, api_1.createData)(Object.assign(Object.assign({}, params), { serverEndPoint }));
+        return response;
+    }), [serverEndPoint]);
+    const updateUsuaria = (0, react_1.useCallback)(() => {
+        (0, api_1.isLoggedIn)(serverEndPoint).then((newUsuaria) => {
+            setUsuaria(newUsuaria || { erro: 'token inválido' });
+        });
+    }, [serverEndPoint]);
+    const localIsLoggedIn = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () { return (0, api_1.isLoggedIn)(serverEndPoint); }), [serverEndPoint]);
+    // END OF SERVER_ENDPOINT DEPENDENT FUNCTIONS
+    const onTriggerSnackBar = (0, react_1.useCallback)(({ msg, severity = 'info' }) => {
+        setSnackBar({
+            open: true,
+            msg,
+            severity,
+        });
+    }, [setSnackBar]);
+    const populateOptionsAC = (0, react_1.useCallback)((optionsACModels) => __awaiter(this, void 0, void 0, function* () {
+        const promises = [];
+        for (const model of optionsACModels) {
+            promises.push(localGetAutoComplete(model));
+        }
+        const results = yield Promise.all(promises);
+        const newOptionsAC = {};
+        results.map((result, index) => {
+            if (!axios_1.default.isAxiosError(result)) {
+                newOptionsAC[optionsACModels[index]] = result;
+            }
+        });
+        setOptionsAC(newOptionsAC);
+    }), [localGetAutoComplete]);
+    const loadSinglePageData = (0, react_1.useCallback)((_a) => __awaiter(this, [_a], void 0, function* ({ model, objId, optionsACModels, defaults, extraValidators, fieldsLayout, objTitleField, }) {
+        handleLoading(true);
+        if (!objId || objId === 'novo') {
+            objId = (0, utils_1.getTmpId)();
+        }
+        const response = yield (0, api_1.getGenericModel)({
+            model,
+            serverEndPoint,
+            id: (0, utils_1.isTmpId)(objId) ? null : objId,
+            schemas,
+        });
+        if (axios_1.default.isAxiosError(response)) {
+            resetPageForm();
+            handleLoading(false);
+            console.log('Houve um erro ao tentar carregar os dados!');
+            return response;
+        }
+        const { data: newData, schema: newSchema, columns: newColumns, modelOptions: newModelOptions, } = response;
+        if (optionsACModels) {
+            populateOptionsAC(optionsACModels);
+        }
+        const { values, finalSchema, validationSchema } = (0, utils_1.loadSinglePageDataHelper)({
+            data: newData,
+            schema: newSchema,
+            columns: newColumns,
+            fieldsLayout: fieldsLayout,
+            defaults: defaults,
+            extraValidators: extraValidators,
+        });
+        setPageForm({
+            id: objId,
+            model,
+            modelVerboseName: newModelOptions.verbose_name,
+            modelVerboseNamePlural: newModelOptions.verbose_name_plural,
+            schema: finalSchema,
+            columns: newColumns,
+            initialValues: values,
+            validationSchema,
+            objTitleField,
+        });
+        handleLoading(false);
+        return values;
+    }), [handleLoading, populateOptionsAC, serverEndPoint, resetPageForm, schemas, setPageForm]);
+    const onSubmit = (0, react_1.useCallback)((model, id, data) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const currentSchema = (_a = pageFormRef.current) === null || _a === void 0 ? void 0 : _a.schema;
+        const currentOptionsAC = optionsACRef.current;
+        if (!currentSchema) {
+            console.log('there must be a pageForm!');
+            return { message: 'there must be a pageForm!', isAxiosError: true };
+        }
+        handleLoading(true);
+        const response = yield (0, api_1.updateDataBySchema)({
+            model,
+            modelObjectId: id,
+            serverEndPoint,
+            data,
+            schema: currentSchema,
+        });
+        if (axios_1.default.isAxiosError(response)) {
+            // If the backend returned field-level validation errors (e.g. raised in
+            // a serializer's `validate()`), the form component maps them onto the
+            // offending fields. So point the user to those instead of a generic
+            // "contact support" message.
+            const hasFieldErrors = Object.keys((0, utils_1.getFieldErrorsFromResponse)((_b = response.response) === null || _b === void 0 ? void 0 : _b.data, currentSchema !== null && currentSchema !== void 0 ? currentSchema : undefined))
+                .length > 0;
+            onTriggerSnackBar({
+                msg: hasFieldErrors
+                    ? 'Não foi possível salvar. Confira os campos destacados.'
+                    : 'Houve um problema ao salvar seus dados! Por favor, entre em contato',
+                severity: 'error',
+            });
+            console.log({
+                msg: 'Error saving model',
+                errors: response,
+                data,
+            });
+            handleLoading(false);
+            return response;
+        }
+        if (currentOptionsAC) {
+            populateOptionsAC(Object.keys(currentOptionsAC));
+        }
+        onTriggerSnackBar({
+            msg: id ? 'Dados atualizados com sucesso!' : 'Criado com sucesso!',
+        });
+        handleLoading(false);
+        return response.id;
+    }), [handleLoading, onTriggerSnackBar, populateOptionsAC, serverEndPoint]);
+    const onEditModelSave = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () {
+        setDialog({ open: false });
+        handleLoading(true);
+        const { fieldKey, index, model, id, setValue, getValues, schema } = editModel.current;
+        const response = yield (0, api_1.updateDataBySchema)({
+            model,
+            modelObjectId: id,
+            serverEndPoint,
+            data,
+            schema,
+        });
+        if (axios_1.default.isAxiosError(response)) {
+            onTriggerSnackBar({
+                msg: 'Houve um problema ao salvar seus dados.',
+                severity: 'error',
+            });
+            console.log({
+                msg: 'Error saving model',
+                response,
+                data,
+            });
+            return response;
+        }
+        onTriggerSnackBar({
+            msg: 'Alterações salvas com sucesso!',
+            severity: 'info',
+        });
+        if (setValue && getValues) {
+            const targetKey = fieldKey && index >= 0 ? `${fieldKey}.${index}.${model}` : model;
+            const value = getValues(targetKey);
+            const newValue = Array.isArray(value)
+                ? value.map((item) => {
+                    return item.id === response.id ? response : item;
+                })
+                : Object.assign({}, response);
+            setValue(targetKey, newValue);
+            populateOptionsAC([model]);
+        }
+        handleLoading(false);
+        return true;
+    }), [handleLoading, onTriggerSnackBar, populateOptionsAC, serverEndPoint, setDialog]);
+    const onEditModelDataGridSave = (0, react_1.useCallback)((_a) => __awaiter(this, [_a], void 0, function* ({ model, newRow, schema }) {
+        const response = yield (0, api_1.updateDataBySchema)({
+            model,
+            modelObjectId: newRow.id,
+            serverEndPoint,
+            data: newRow,
+            schema,
+            path: model,
+        });
+        if (axios_1.default.isAxiosError(response)) {
+            onTriggerSnackBar({
+                msg: 'Não foi possível salvar os dados. Confira os erros.',
+                severity: 'error',
+            });
+            console.log({
+                msg: 'Error saving model',
+                response,
+                data: newRow,
+            });
+            return response;
+        }
+        onTriggerSnackBar({
+            msg: 'Alterações salvas com sucesso!',
+            severity: 'info',
+        });
+        return response;
+    }), [onTriggerSnackBar, serverEndPoint]);
+    const onEditModel = (0, react_1.useCallback)(({ fieldKey, index, model, id, labelKey, setValue, getValues, fieldsLayout, initialValuesPartial, }) => {
+        setDialog({
+            open: true,
+            loading: true,
+        });
+        (0, api_1.getGenericModel)({ model, serverEndPoint, id, schemas }).then((result) => {
+            if (axios_1.default.isAxiosError(result)) {
+                setDialog({
+                    open: true,
+                    loading: false,
+                    title: 'Falha ao carregar o formulário',
+                    Body: react_1.default.createElement(react_1.default.Fragment, null, "N\u00E3o foi poss\u00EDvel carregar o formul\u00E1rio!"),
+                });
+                return false;
+            }
+            const populatedValues = (0, utils_1.populateValues)({
+                data: result.data,
+                schema: result.schema,
+            });
+            const uiFields = fieldsLayout
+                ? (0, utils_1.getFieldsFromFieldsLayout)(fieldsLayout)
+                : result.columns
+                    ? result.columns.map(({ field }) => field)
+                    : undefined;
+            const yupSchema = (0, utils_1.buildGenericYupValidationSchema)({
+                schema: result.schema,
+                data: populatedValues,
+                uiFields,
+            });
+            const values = (0, utils_1.isTmpId)(id) && initialValuesPartial
+                ? Object.assign(Object.assign({}, populatedValues), initialValuesPartial) : Object.assign({}, populatedValues);
+            setDialog({
+                open: true,
+                loading: false,
+                title: 'Editar',
+                Body: (react_1.default.createElement(DialogFormBySchema_1.default, { schema: result.schema, validationSchema: yupSchema, initialValues: values, setDialog: setDialog, getAutoComplete: localGetAutoComplete, onEditModelSave: onEditModelSave, fieldsLayout: fieldsLayout, isCancelDisabled: true, forceSaveEnabled: true, optionsAC: optionsACRef.current, setOptionsAC: setOptionsAC })),
+                Actions: react_1.default.createElement(react_1.default.Fragment, null),
+                isCancelDisabled: true,
+            });
+            editModel.current = {
+                fieldKey,
+                index,
+                model,
+                id,
+                labelKey,
+                setValue,
+                getValues,
+                schema: result.schema,
+            };
+        });
+    }, [localGetAutoComplete, onEditModelSave, serverEndPoint, setDialog, schemas]);
+    const onDeleteModelSave = (0, react_1.useCallback)((model, id, onSuccess, event) => __awaiter(this, void 0, void 0, function* () {
+        setDialog({ open: false });
+        handleLoading(true);
+        const ret = yield (0, api_1.deleteData)(model, serverEndPoint, id);
+        if (ret === true) {
+            onTriggerSnackBar({
+                msg: 'Apagado com com sucesso!',
+                severity: 'info',
+            });
+            if (onSuccess && event) {
+                onSuccess(event);
+            }
+            resetPageForm();
+            handleLoading(false);
+            return true;
+        }
+        handleLoading(false);
+        onTriggerSnackBar({
+            msg: 'Houve um problema ao remover o item! Por favor, entre em contato.',
+            severity: 'error',
+        });
+        return false;
+    }), [handleLoading, onTriggerSnackBar, serverEndPoint, setDialog, resetPageForm]);
+    const onDeleteModel = (0, react_1.useCallback)((model, id, onSuccess) => {
+        setDialog({
+            open: true,
+            loading: false,
+            title: 'Apagar',
+            Body: 'Tem certeza de que deseja apagar este item?',
+            Actions: (react_1.default.createElement(DialogActions_1.default, { setDialog: setDialog, handleSave: (event) => {
+                    return onDeleteModelSave(model, id, onSuccess, event);
+                }, btnConfirm: "Sim, apagar" })),
+        });
+    }, [onDeleteModelSave, setDialog]);
+    const localDeleteData = (0, react_1.useCallback)((model, id) => {
+        return (0, api_1.deleteData)(model, serverEndPoint, id);
+    }, [serverEndPoint]);
+    const localExportExcelData = (0, react_1.useCallback)(({ model, modelParent, modelParentId, paginationModel, }) => {
+        return (0, api_1.exportExcelData)({
+            model,
+            modelParent,
+            modelParentId,
+            paginationModel,
+            serverEndPoint,
+        });
+    }, [serverEndPoint]);
+    const onEditRelatedModelSave = (0, react_1.useCallback)((_a) => __awaiter(this, [_a], void 0, function* ({ model, id, relatedModel, newRow, schema, onlyAddExisting, }) {
+        const updateUrl = `${model}/${id}/${relatedModel}`;
+        if (onlyAddExisting && 'id_to_add' in newRow) {
+            const response = yield (0, api_1.addExistingRelatedModel)({
+                model,
+                id,
+                serverEndPoint,
+                data: {
+                    onlyAddExisting: {
+                        key: relatedModel,
+                        value: newRow.id_to_add,
+                    },
+                },
+            });
+            if (axios_1.default.isAxiosError(response)) {
+                console.log(response);
+                onTriggerSnackBar({
+                    msg: 'Houve um problema ao salvar a alteração! Por favor, entre em contato.',
+                    severity: 'error',
+                });
+                return response;
+            }
+            onTriggerSnackBar({
+                msg: 'Alterações salvas com sucesso!',
+                severity: 'info',
+            });
+            const object = yield (0, api_1.getGenericModel)({
+                model,
+                id,
+                serverEndPoint,
+                relatedModel,
+                relatedModelId: newRow.id_to_add,
+            });
+            return object;
+        }
+        // This is important for related data
+        if (schema[model] && !newRow[model]) {
+            newRow[model] = id;
+        }
+        const response = yield (0, api_1.updateDataBySchema)({
+            model: relatedModel,
+            modelObjectId: newRow.id,
+            serverEndPoint,
+            data: newRow,
+            schema,
+            path: updateUrl,
+        });
+        if (axios_1.default.isAxiosError(response)) {
+            onTriggerSnackBar({
+                msg: 'Não foi possível salvar os dados. Confira os erros.',
+                severity: 'error',
+            });
+            console.log({
+                error: response,
+                data: newRow,
+            });
+            return response;
+        }
+        onTriggerSnackBar({
+            msg: 'Alterações salvas com sucesso!',
+            severity: 'info',
+        });
+        return response;
+    }), [onTriggerSnackBar, serverEndPoint]);
+    const localUpdateModelBySchema = (0, react_1.useCallback)((props) => __awaiter(this, void 0, void 0, function* () {
+        return (0, api_1.updateDataBySchema)(Object.assign({ serverEndPoint }, props));
+    }), [serverEndPoint]);
+    const onDeleteRelatedModel = (0, react_1.useCallback)((_a) => __awaiter(this, [_a], void 0, function* ({ model, id, relatedModel, relatedModelId }) {
+        const deleteUrl = `${model}/${id}/${relatedModel}`;
+        const response = yield (0, api_1.deleteData)(deleteUrl, serverEndPoint, relatedModelId);
+        if (axios_1.default.isAxiosError(response)) {
+            onTriggerSnackBar({
+                msg: `Houve um problema ao remover o item! Por favor, entre em contato. Mensagem de erro: ${response.message}`,
+                severity: 'error',
+            });
+            console.log({
+                error: response.message,
+                id,
+            });
+            return response;
+        }
+        onTriggerSnackBar({
+            msg: 'Alterações salvas com sucesso!',
+            severity: 'info',
+        });
+        return response;
+    }), [onTriggerSnackBar, serverEndPoint]);
+    (0, react_1.useEffect)(() => {
+        updateUsuaria();
+        resetPageForm();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    (0, react_1.useEffect)(() => {
+        pageFormRef.current = pageForm;
+    }, [pageForm]);
+    (0, react_1.useEffect)(() => {
+        optionsACRef.current = optionsAC;
+    }, [optionsAC]);
+    const privateContextValue = (0, react_1.useMemo)(() => ({
+        setPageForm,
+        setFormTools,
+    }), [setPageForm, setFormTools]);
+    const publicContextValue = (0, react_1.useMemo)(() => {
+        return {
+            usuaria,
+            updateUsuaria,
+            isLoggedIn: localIsLoggedIn,
+            onSubmit,
+            loadSinglePageData,
+            handleLoading,
+            optionsAC,
+            setOptionsAC,
+            pageForm,
+            resetPageForm,
+            formTools,
+            onEditModel,
+            onEditModelSave,
+            onEditModelDataGridSave,
+            onDeleteModel,
+            onEditRelatedModelSave,
+            onDeleteRelatedModel,
+            rawUpdateDataBySchema: localUpdateModelBySchema,
+            rawDeleteData: localDeleteData,
+            onTriggerSnackBar,
+            setDialog,
+            // api utils:
+            getRawData: localGetRawData,
+            getAutoComplete: localGetAutoComplete,
+            getGenericModel: localGetGenericModel,
+            getGenericModelList: localGetGenericModelList,
+            getAllModels: localGetAllModels,
+            loginByPayload: localLoginByPayload,
+            getSignUpOptions: localGetSignupOptions,
+            signUp: localSignUp,
+            signOut,
+            requestPasswordReset: localRequestPasswordReset,
+            confirmPasswordReset: localConfirmPasswordReset,
+            changePassword: localChangePassword,
+            postData: postData,
+            editModel,
+            updateModel: localUpdateModel,
+            populateOptionsAC,
+            isMobile,
+            exportExcelData: localExportExcelData,
+        };
+    }, [
+        handleLoading,
+        isMobile,
+        loadSinglePageData,
+        localGetAllModels,
+        localGetAutoComplete,
+        localGetGenericModel,
+        localGetGenericModelList,
+        localGetRawData,
+        localGetSignupOptions,
+        localLoginByPayload,
+        localSignUp,
+        localChangePassword,
+        localConfirmPasswordReset,
+        localRequestPasswordReset,
+        localUpdateModel,
+        onDeleteModel,
+        onDeleteRelatedModel,
+        localUpdateModelBySchema,
+        localDeleteData,
+        onEditModel,
+        onEditModelDataGridSave,
+        onEditModelSave,
+        onEditRelatedModelSave,
+        onSubmit,
+        onTriggerSnackBar,
+        optionsAC,
+        pageForm,
+        resetPageForm,
+        formTools,
+        populateOptionsAC,
+        postData,
+        setDialog,
+        signOut,
+        updateUsuaria,
+        usuaria,
+        localIsLoggedIn,
+        localExportExcelData,
+    ]);
+    if (!serverEndPoint) {
+        console.error('There must be a serverEndPoint properly configured for apiWrapper to work!');
+        return react_1.default.createElement(react_1.default.Fragment, null, children);
+    }
+    return (react_1.default.createElement(PrivateContext_1.PrivateContext.Provider, { value: privateContextValue },
+        react_1.default.createElement(APIWrapperContext_1.APIWrapperContext.Provider, { value: publicContextValue }, children)));
+}
+exports.default = react_1.default.memo(APIWrapper);