@zauru-sdk/hooks 2.0.118 → 2.0.121

package/dist/catalogs.d.ts

@@ -1,5 +1,22 @@
 import type { AgencyGraphQL, BitacoraPOMassive, BundleGraphQL, CaseGraphQL, CurrencyGraphQL, EmployeeGraphQL, FormGraphQL, InvoiceGraphQL, ItemCategoryGraphQL, ItemGraphQL, LotStockGraphQL, MotivoRechazo, PayeeCategoryGraphQL, PayeeGraphQL, PaymentTermGraphQL, ReceptionType, ShipmentGraphQL, SubmissionCasesGraphQL, SubmissionInvoicesGraphQL, SuggestedPriceGraphQL, Template, TipoMuestra, WebAppRowGraphQL, PrintTemplateGraphQL, PaymentMethodGraphQL } from "@zauru-sdk/types";
-import { ReduxParamsConfig } from "@zauru-sdk/redux";
+import { CATALOGS_NAMES, ReduxParamsConfig } from "@zauru-sdk/redux";
+type CatalogType<T> = {
+    data: T[];
+    loading: boolean;
+};
+/**
+ *
+ * @param CATALOG_NAME
+ * @param param1
+ * @returns
+ *
+ * otherParams usage example:
+ *
+ * otherParams: {
+      includeDiscounts: "true",
+    }
+ */
+export declare function useGetReduxCatalog<T>(CATALOG_NAME: CATALOGS_NAMES, { online, wheres, otherParams }?: ReduxParamsConfig): CatalogType<T>;
 /**
  *
  * ======================= HOOKS
@@ -154,7 +171,7 @@ export declare const useGetCaseForms: (config?: ReduxParamsConfig) => {
     loading: boolean;
     data: FormGraphQL[];
 };
-export declare const useGetInvoiceFormSubmissionsByAgencyId: (agency_id: number | string) => {
+export declare const useGetInvoiceFormSubmissionsByAgencyId: (config?: ReduxParamsConfig) => {
     loading: boolean;
     data: SubmissionInvoicesGraphQL[];
 };
@@ -166,3 +183,4 @@ export declare const useGetInvoiceFormSubmissionsByInvoiceId: (config?: ReduxPar
     loading: boolean;
     data: SubmissionInvoicesGraphQL[];
 };
+export {};

package/dist/esm/catalogs.js

@@ -1,65 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useGetInvoiceFormSubmissionsByInvoiceId = exports.useGetMyCaseFormSubmissions = exports.useGetInvoiceFormSubmissionsByAgencyId = exports.useGetCaseForms = exports.useGetInvoiceForms = exports.useGetAllForms = exports.useGetBitacoraRechazoMasivo = exports.useGetMotivosDeRechazo = exports.useGetTiposDeMuestra = exports.useGetInvoicesByCurrentAgency = exports.useGetInvoicesByLab = exports.useGetShipmentsToMyAgency = exports.useGetEmployees = exports.useGetEmployeesByCurrentAgency = exports.useGetEmployeesByLab = exports.useGetPaymentMethods = exports.useGetPaymentTerms = exports.useGetSuggestedPrices = exports.useGetAgencies = exports.useGetPrintTemplates = exports.useGetPayeesForLab = exports.useGetPayees = exports.useGetClientCategories = exports.useGetProviderCategories = exports.useGetMyCases = exports.useGetProviders = exports.useGetReceptionTypes = exports.useGetCurrencies = exports.useGetBundlesForLab = exports.useGetBundlesRecipForLab = exports.useGetPayeeCategoriesLabPrices = exports.useGetPayeeCategories = exports.useGetTemplates = exports.useGetBookings = exports.useGetItemCategoriesForLab = exports.useGetItemServicesByLab = exports.useGetMyAgencyLotStocks = exports.useGetItemsByLab = exports.useGetItemsByReception = exports.useGetItems = void 0;
+exports.useGetReduxCatalog = useGetReduxCatalog;
 const react_1 = require("@remix-run/react");
 const react_2 = require("react");
 const index_js_1 = require("./components/index.js");
 const redux_1 = require("@zauru-sdk/redux");
-const useApiCatalog = (CATALOG_NAME, otherParams) => {
-    try {
-        const fetcher = (0, react_1.useFetcher)();
-        const [data, setData] = (0, react_2.useState)({
-            data: [],
-            loading: true,
-        });
-        (0, react_2.useEffect)(() => {
-            if (fetcher.data?.title) {
-                (0, index_js_1.showAlert)({
-                    description: fetcher.data?.description?.toString(),
-                    title: fetcher.data?.title?.toString(),
-                    type: fetcher.data?.type?.toString(),
-                });
-            }
-        }, [fetcher.data]);
-        (0, react_2.useEffect)(() => {
-            if (fetcher.state === "idle" && fetcher.data != null) {
-                const receivedData = fetcher.data;
-                if (receivedData) {
-                    setData({ data: receivedData[CATALOG_NAME], loading: false });
-                }
-            }
-        }, [fetcher, CATALOG_NAME]);
-        (0, react_2.useEffect)(() => {
-            try {
-                setData({ ...data, loading: true });
-                // Convert otherParams to query string
-                const paramsString = otherParams
-                    ? Object.entries(otherParams)
-                        .map(([key, value]) => `${key}=${value}`)
-                        .join("&")
-                    : "";
-                const url = `/api/catalogs?catalog=${CATALOG_NAME}${paramsString ? `&${paramsString}` : ""}`;
-                fetcher.load(url);
-            }
-            catch (ex) {
-                (0, index_js_1.showAlert)({
-                    type: "error",
-                    title: `Ocurrió un error al cargar el catálogo: ${CATALOG_NAME}.`,
-                    description: "Error: " + ex,
-                });
-            }
-        }, []);
-        return data;
-    }
-    catch (ex) {
-        (0, index_js_1.showAlert)({
-            type: "error",
-            title: `Ocurrió un error al cargar el catálogo: ${CATALOG_NAME}.`,
-            description: "Error: " + ex,
-        });
-        return { data: [], loading: false };
-    }
-};
 /**
  *
  * @param CATALOG_NAME
@@ -72,64 +18,174 @@ const useApiCatalog = (CATALOG_NAME, otherParams) => {
       includeDiscounts: "true",
     }
  */
-const useGetReduxCatalog = (CATALOG_NAME, { online = false, wheres = [], otherParams } = {}) => {
-    const fetcher = (0, react_1.useFetcher)();
+function useGetReduxCatalog(CATALOG_NAME, { online = false, wheres = [], otherParams } = {}) {
     const dispatch = (0, redux_1.useAppDispatch)();
+    const fetcher = (0, react_1.useFetcher)();
     const catalogData = (0, redux_1.useAppSelector)((state) => state.catalogs[CATALOG_NAME]);
+    // Verifica si ya tenemos algo en Redux
+    const hasLocalData = Boolean(catalogData?.data?.length);
     const [data, setData] = (0, react_2.useState)({
-        data: catalogData?.data?.length ? catalogData.data : [],
-        loading: catalogData.loading,
+        data: hasLocalData ? catalogData.data : [],
+        loading: false,
     });
-    (0, react_2.useEffect)(() => {
-        if (fetcher.data?.description) {
-            (0, index_js_1.showAlert)({
-                description: fetcher.data?.description?.toString(),
-                title: fetcher.data?.title?.toString(),
-                type: fetcher.data?.type?.toString(),
-            });
-        }
-    }, [fetcher.data]);
-    (0, react_2.useEffect)(() => {
-        if (fetcher.state === "idle" && fetcher.data != null) {
-            const receivedData = fetcher.data;
-            if (receivedData) {
-                setData({ data: receivedData[CATALOG_NAME], loading: false });
-                dispatch((0, redux_1.catalogsFetchSuccess)({
-                    name: CATALOG_NAME,
-                    data: receivedData[CATALOG_NAME],
-                }));
-            }
-        }
-    }, [fetcher, dispatch, CATALOG_NAME]);
-    (0, react_2.useEffect)(() => {
-        if (catalogData?.data?.length <= 0 || catalogData?.reFetch || online) {
-            try {
-                setData({ ...data, loading: true });
+    try {
+        /**
+         * Efecto que decide si llamar o no a la API.
+         *
+         * Lógica:
+         * - Si `online: true`, forzamos el fetch.
+         * - Si `reFetch: true`, también forzamos el fetch.
+         * - Si `online: false` y SÍ tenemos data local, NO hacemos fetch (solo mostramos lo que hay).
+         * - Si `online: false` y NO hay data local, SÍ hacemos fetch (porque no hay nada que mostrar).
+         */
+        (0, react_2.useEffect)(() => {
+            const mustFetch = online || catalogData?.reFetch || !hasLocalData;
+            if (mustFetch) {
+                setData((prev) => ({ ...prev, loading: true }));
                 dispatch((0, redux_1.catalogsFetchStart)(CATALOG_NAME));
-                // Convierte cada elemento del array a una cadena codificada para URL
-                const encodedWheres = wheres.map((where) => encodeURIComponent(where));
-                // Une los elementos codificados con '&'
+                // Construimos el query para `wheres` y `otherParams`
+                const encodedWheres = (wheres || []).map((where) => encodeURIComponent(where));
                 const wheresQueryParam = encodedWheres.join("&");
-                // Convert otherParams to query string
                 const paramsString = otherParams
                     ? Object.entries(otherParams)
-                        .map(([key, value]) => `${key}=${value}`)
+                        .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
                         .join("&")
                     : "";
-                fetcher.load(`/api/catalogs?catalog=${CATALOG_NAME}&wheres=${wheresQueryParam}${paramsString ? `&${paramsString}` : ""}`);
+                const queryStringParts = [];
+                if (wheresQueryParam)
+                    queryStringParts.push(`wheres=${wheresQueryParam}`);
+                if (paramsString)
+                    queryStringParts.push(paramsString);
+                const queryString = queryStringParts.length
+                    ? `&${queryStringParts.join("&")}`
+                    : "";
+                // Disparamos la carga a través de fetcher
+                try {
+                    fetcher.load(`/api/catalogs?catalog=${CATALOG_NAME}${queryString}`);
+                }
+                catch (error) {
+                    console.error(error);
+                    // Si hay datos locales, mostramos los datos locales
+                    setData({
+                        data: catalogData?.data || [],
+                        loading: false,
+                    });
+                    (0, index_js_1.showAlert)({
+                        type: "error",
+                        title: "Error al cargar el catálogo",
+                        description: `Error al cargar el catálogo ${CATALOG_NAME}, por favor intente nuevamente. Error: ${error}`,
+                    });
+                }
             }
-            catch (ex) {
-                (0, index_js_1.showAlert)({
-                    type: "error",
-                    title: `Ocurrió un error al cargar el catálogo: ${CATALOG_NAME}.`,
-                    description: "Error: " + ex,
+            else {
+                // Si no vamos a hacer fetch, asegurarnos de que loading esté en false
+                // y mantener lo que ya tengamos en Redux
+                setData({
+                    data: catalogData?.data || [],
+                    loading: false,
                 });
-                setData({ ...data, loading: false });
             }
-        }
-    }, []);
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [online, catalogData?.reFetch, hasLocalData]);
+        /**
+         * Efecto que observa la finalización del fetch (fetcher.state === "idle")
+         * y decide qué hacer con la data o error recibidos.
+         */
+        (0, react_2.useEffect)(() => {
+            // Cuando fetcher se pone en "idle", significa que ya terminó la petición.
+            if (fetcher.state === "idle") {
+                // Caso: tenemos algo en fetcher.data
+                if (fetcher.data) {
+                    const possibleError = fetcher.data;
+                    const possibleData = fetcher.data;
+                    // Si es un error "clásico" con description, lo manejamos
+                    if (possibleError?.description) {
+                        // Aquí interpretamos que la API pudo haber respondido algo tipo { description, ... } => error
+                        // Pero OJO: si ya teníamos datos locales, no mostramos error "fatal" para no romper el fallback
+                        if (hasLocalData) {
+                            // Ya tenemos datos en Redux, así que sólo mostramos el alert informativo,
+                            // pero no borramos lo que hay en data
+                            (0, index_js_1.showAlert)({
+                                type: possibleError.type || "error",
+                                title: possibleError.title || "Error",
+                                description: possibleError.description,
+                            });
+                            // Marcamos loading false pero dejamos intacto `data.data`
+                            setData((prev) => ({ ...prev, loading: false }));
+                        }
+                        else {
+                            // No hay datos locales -> mostramos error y no tenemos fallback
+                            (0, index_js_1.showAlert)({
+                                type: "error",
+                                title: possibleError.title || "Error",
+                                description: possibleError.description,
+                            });
+                            setData((prev) => ({ ...prev, loading: false }));
+                        }
+                    }
+                    else {
+                        // Caso: la respuesta sí es data real
+                        const newData = possibleData[CATALOG_NAME];
+                        if (Array.isArray(newData)) {
+                            // Guardamos en redux y en el state local
+                            dispatch((0, redux_1.catalogsFetchSuccess)({
+                                name: CATALOG_NAME,
+                                data: newData,
+                            }));
+                            setData({
+                                data: newData,
+                                loading: false,
+                            });
+                        }
+                        else {
+                            // Por alguna razón no llegó el array esperado
+                            // Revisamos si hay fallback local
+                            if (hasLocalData) {
+                                // No reportar error: usamos lo local
+                                setData((prev) => ({ ...prev, loading: false }));
+                            }
+                            else {
+                                // No hay nada local -> error
+                                (0, index_js_1.showAlert)({
+                                    type: "error",
+                                    title: "Error al recibir el catálogo",
+                                    description: `No se obtuvo la propiedad "${CATALOG_NAME}" en la respuesta.`,
+                                });
+                                setData((prev) => ({ ...prev, loading: false }));
+                            }
+                        }
+                    }
+                }
+                else {
+                    // fetcher.state === "idle" pero fetcher.data es null/undefined => seguramente hubo error global
+                    if (hasLocalData) {
+                        // Fallback a datos locales
+                        setData((prev) => ({ ...prev, loading: false }));
+                    }
+                    else {
+                        // Ni API ni local data => error
+                        (0, index_js_1.showAlert)({
+                            type: "error",
+                            title: "Error al cargar el catálogo",
+                            description: `No se obtuvo respuesta y no hay datos locales para ${CATALOG_NAME}`,
+                        });
+                        setData((prev) => ({ ...prev, loading: false }));
+                    }
+                }
+            }
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [fetcher.state]);
+    }
+    catch (error) {
+        console.error(error);
+        (0, index_js_1.showAlert)({
+            type: "error",
+            title: "Error al cargar el catálogo",
+            description: `Error al cargar el catálogo ${CATALOG_NAME}, por favor intente nuevamente. Error: ${error}`,
+        });
+    }
     return data;
-};
+}
 /**
  *
  * ======================= HOOKS
@@ -260,9 +316,12 @@ const useGetCaseForms = (config) => {
     };
 };
 exports.useGetCaseForms = useGetCaseForms;
-const useGetInvoiceFormSubmissionsByAgencyId = (agency_id) => {
-    const data = useApiCatalog("invoiceFormSubmissionsByAgencyId", {
-        agency_id: `${agency_id}`,
+const useGetInvoiceFormSubmissionsByAgencyId = (config) => {
+    const agencyId = config?.otherParams?.agency_id;
+    const data = useGetReduxCatalog("invoiceFormSubmissionsByAgencyId", {
+        otherParams: {
+            agency_id: `${agencyId}`,
+        },
     });
     // Filtrar los registros para obtener sólo los de la versión más alta.
     const groupedByVersion = (data.data || []).reduce((acc, record) => {
@@ -299,9 +358,11 @@ exports.useGetMyCaseFormSubmissions = useGetMyCaseFormSubmissions;
 const useGetInvoiceFormSubmissionsByInvoiceId = (config) => {
     const invoiceId = config?.otherParams?.invoiceId;
     const withFiles = config?.otherParams?.withFiles;
-    const data = useApiCatalog("invoiceFormSubmissionsByInvoiceId", {
-        invoiceId: `${invoiceId}`,
-        withFiles: `${withFiles}`,
+    const data = useGetReduxCatalog("invoiceFormSubmissionsByInvoiceId", {
+        otherParams: {
+            invoiceId: `${invoiceId}`,
+            withFiles: `${withFiles}`,
+        },
     });
     // Filtrar los registros para obtener sólo los de la versión más alta.
     const groupedByVersion = (data.data || []).reduce((acc, record) => {

package/dist/esm/templates.js

@@ -5,60 +5,151 @@ const react_1 = require("@remix-run/react");
 const redux_1 = require("@zauru-sdk/redux");
 const react_2 = require("react");
 const index_js_1 = require("./index.js");
-const useGetTemplateObject = (TEMPLATE_NAME, config = { online: false }) => {
+function useGetTemplateObject(TEMPLATE_NAME, config = {}) {
     try {
-        const fetcher = (0, react_1.useFetcher)();
         const dispatch = (0, redux_1.useAppDispatch)();
+        const fetcher = (0, react_1.useFetcher)();
+        // Obtenemos del store lo que ya se tenga
         const objectData = (0, redux_1.useAppSelector)((state) => state.templates[TEMPLATE_NAME]);
+        // Verifica si ya tenemos algo en Redux
+        const hasLocalData = objectData?.data && Object.keys(objectData.data).length > 0;
+        // Estado local para data y loading
         const [data, setData] = (0, react_2.useState)({
-            data: objectData?.data && Object.keys(objectData?.data).length
-                ? objectData?.data
-                : {},
-            loading: objectData.loading,
+            data: hasLocalData ? objectData?.data : {},
+            loading: false,
         });
+        /**
+         * 1) Efecto para decidir si hacemos fetch o no.
+         *    - Si `config.online === true`, forzamos fetch.
+         *    - Si `objectData.reFetch === true`, forzamos fetch (si así lo manejas en redux).
+         *    - Si no tenemos datos locales, forzamos fetch.
+         *    - En caso contrario, mostramos datos locales y no hacemos fetch.
+         */
         (0, react_2.useEffect)(() => {
-            if (fetcher.data?.title) {
-                (0, index_js_1.showAlert)({
-                    description: fetcher.data?.description,
-                    title: fetcher.data?.title,
-                    type: fetcher.data?.type,
-                });
-            }
-        }, [fetcher.data]);
-        (0, react_2.useEffect)(() => {
-            if (fetcher.state === "idle" && fetcher.data != null) {
-                const receivedData = fetcher.data;
-                if (receivedData) {
-                    setData({ data: receivedData[TEMPLATE_NAME], loading: false });
-                    dispatch((0, redux_1.templateFetchSuccess)({
-                        name: TEMPLATE_NAME,
-                        data: receivedData[TEMPLATE_NAME],
-                    }));
-                }
-            }
-        }, [fetcher, dispatch, TEMPLATE_NAME]);
-        (0, react_2.useEffect)(() => {
-            if ((objectData?.data && Object.keys(objectData?.data).length <= 0) ||
-                config?.online) {
+            const mustFetch = config.online || objectData?.reFetch || !hasLocalData;
+            if (mustFetch) {
+                setData((prev) => ({ ...prev, loading: true }));
+                dispatch((0, redux_1.templateFetchStart)(TEMPLATE_NAME));
+                // Aquí hacemos la llamada a la API a través del fetcher
                 try {
-                    setData({ ...data, loading: true });
-                    dispatch((0, redux_1.templateFetchStart)(TEMPLATE_NAME));
                     fetcher.load(`/api/templates?object=${TEMPLATE_NAME}`);
                 }
-                catch (ex) {
+                catch (error) {
+                    console.error(error);
+                    // Si hay datos locales, los conservamos; si no, data queda vacío
+                    setData({
+                        data: hasLocalData ? objectData?.data : {},
+                        loading: false,
+                    });
                     (0, index_js_1.showAlert)({
                         type: "error",
-                        title: `Ocurrió un error al cargar el object de templates: ${TEMPLATE_NAME}.`,
-                        description: "Error: " + ex,
+                        title: `Error al cargar la plantilla: ${TEMPLATE_NAME}`,
+                        description: `Error: ${String(error)}`,
                     });
                 }
             }
-        }, []);
+            else {
+                // Si NO debemos hacer fetch, aseguramos loading en false
+                // y usamos lo que haya en Redux
+                setData({
+                    data: hasLocalData ? objectData?.data : {},
+                    loading: false,
+                });
+            }
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [config.online, objectData?.reFetch, hasLocalData, TEMPLATE_NAME]);
+        /**
+         * 2) Efecto para cuando el fetcher termina (fetcher.state === "idle").
+         *    Decidimos si lo que vino es error o data, y procedemos.
+         */
+        (0, react_2.useEffect)(() => {
+            if (fetcher.state === "idle") {
+                if (fetcher.data) {
+                    // Podría ser un error o ser la data
+                    const possibleError = fetcher.data;
+                    const possibleData = fetcher.data;
+                    // Si detectamos que es un objeto con 'description', interpretamos error
+                    if (possibleError.description) {
+                        // Ya teníamos datos locales?
+                        if (hasLocalData) {
+                            // Mostramos alert, pero NO borramos los datos locales
+                            (0, index_js_1.showAlert)({
+                                type: possibleError.type || "error",
+                                title: possibleError.title || "Error",
+                                description: possibleError.description,
+                            });
+                            // Dejamos loading en false, data queda como estaba
+                            setData((prev) => ({ ...prev, loading: false }));
+                        }
+                        else {
+                            // No hay datos locales, error fatal
+                            (0, index_js_1.showAlert)({
+                                type: possibleError.type || "error",
+                                title: possibleError.title || "Error",
+                                description: possibleError.description,
+                            });
+                            setData({ data: {}, loading: false });
+                        }
+                    }
+                    else {
+                        // Caso: es data real (ajusta la forma en que tu backend envía la info)
+                        const newData = possibleData[TEMPLATE_NAME];
+                        if (newData) {
+                            // Guardamos en redux y en el state local
+                            dispatch((0, redux_1.templateFetchSuccess)({
+                                name: TEMPLATE_NAME,
+                                data: newData,
+                            }));
+                            setData({ data: newData, loading: false });
+                        }
+                        else {
+                            // No llegó la propiedad esperada en la respuesta
+                            if (hasLocalData) {
+                                // No reportar error, usamos lo local
+                                setData((prev) => ({ ...prev, loading: false }));
+                            }
+                            else {
+                                // No tenemos nada local -> error
+                                (0, index_js_1.showAlert)({
+                                    type: "error",
+                                    title: `Error al recibir la plantilla: ${TEMPLATE_NAME}`,
+                                    description: `No se encontró "${TEMPLATE_NAME}" en la respuesta de la API.`,
+                                });
+                                setData((prev) => ({ ...prev, loading: false }));
+                            }
+                        }
+                    }
+                }
+                else {
+                    // fetcher.state === "idle" pero fetcher.data = null/undefined
+                    // probablemente un error global (red, servidor caído, etc.)
+                    if (hasLocalData) {
+                        // Fallback a datos locales
+                        setData((prev) => ({ ...prev, loading: false }));
+                    }
+                    else {
+                        // Ni API ni local data => error
+                        (0, index_js_1.showAlert)({
+                            type: "error",
+                            title: `Error al cargar la plantilla ${TEMPLATE_NAME}`,
+                            description: `No se obtuvo respuesta y no hay datos locales.`,
+                        });
+                        setData({ data: {}, loading: false });
+                    }
+                }
+            }
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [fetcher.state]);
+        // Retornamos el estado final
         return data;
     }
-    catch (ex) {
-        return { data: {}, loading: false };
+    catch (err) {
+        console.error(err);
+        return {
+            data: {},
+            loading: false,
+        };
     }
-};
+}
 const useGetReceptionTemplate = (config) => useGetTemplateObject("receptionTemplate", config);
 exports.useGetReceptionTemplate = useGetReceptionTemplate;

package/dist/templates.d.ts

@@ -1,8 +1,5 @@
-type ConfigProps = {
-    online?: boolean;
-};
-export declare const useGetReceptionTemplate: (config?: ConfigProps) => {
+import { ReduxParamsConfig } from "@zauru-sdk/redux";
+export declare const useGetReceptionTemplate: (config?: ReduxParamsConfig) => {
     loading: boolean;
     data: string;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/hooks",
-  "version": "2.0.118",
+  "version": "2.0.121",
   "description": "Hooks reutilizables dentro de las webapps de Zauru.",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -28,10 +28,10 @@
     "@remix-run/react": "^2.8.1",
     "@zauru-sdk/common": "^2.0.118",
     "@zauru-sdk/icons": "^2.0.99",
-    "@zauru-sdk/redux": "^2.0.109",
+    "@zauru-sdk/redux": "^2.0.121",
     "@zauru-sdk/types": "^2.0.109",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
-  "gitHead": "55d3c00659f63b8032e38aa08d125caa0f2482b0"
+  "gitHead": "1ab1f6514793de7ce7f19aa022f7642db78ac9ad"
 }