@dashadmin/dash-admin 1.3.24 → 1.3.26

package/dist/hooks/useBreadcrumbs.js

@@ -1 +1,208 @@
-import{useCallback as R,useEffect as L,useMemo as S}from"react";import{useLocation as y,useParams as H}from"react-router-dom";import{useDispatch as $,useSelector as v}from"react-redux";import{useStore as E}from"react-admin";import{DASH_REDUX_ACTIONS as P}from"@dashadmin/dash-admin-state";import{DASHAdminSystemConstants as F}from"@dashadmin/dash-constants";const D={create:"Crear",edit:"Editar",show:"Ver",list:"Lista",inline:"Detalle",trash:"Papelera",admin:"Admin",system:"Sistema",settings:"Configuraci\xF3n",users:"Usuarios",roles:"Roles",permissions:"Permisos",tenants:"Tenants",profile:"Perfil",dashboard:"Dashboard"},N=(e,d,i)=>d[e]?d[e]:D[e]?D[e]:i&&i.model?.includes(e)?i.label||e:e.replace(/[-_]/g," ").replace(/\b\w/g,f=>f.toUpperCase()),_=e=>!!(/^\d+$/.test(e)||/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(e)||/^[a-z0-9]{20,}$/i.test(e)),x=(e,d,i,f,g,I,p)=>{const m=F.system.URL_PREFIX||"";let l=e;m&&l.startsWith(m)&&(l=l.slice(m.length));const r=l.split("/").filter(Boolean);if(r.length===0)return[];const t=[];f&&t.push({label:I||"Home",path:g||"/"});let n=m;n&&!n.startsWith("/")&&(n=`/${n}`);let c=-1;return r.forEach((a,o)=>{n+=`/${a}`;const s=o===r.length-1;if(_(a)){c=o,p&&s?t.push({label:p,path:s?void 0:n,isActive:s}):t.push({label:`#${a.substring(0,8)}${a.length>8?"...":""}`,path:s?void 0:n,isActive:s,data:{id:a}});return}const h=N(a,d,i);t.push({label:h,path:s?void 0:n,isActive:s})}),t},M=(e={})=>{const{autoUpdate:d=!0,labelMap:i={},includeHome:f=!1,homePath:g="/",homeLabel:I="Home",customGenerator:p,fetchRecordName:m=!0,recordNameField:l="name"}=e,r=$(),t=y(),n=H(),[c]=E("resourceConfig"),a=v(b=>b.page),o=null,s=S(()=>({...D,...i}),[i]),A=S(()=>{if(!m||!o)return;const b=[l,"name","title","label","displayName","username"];for(const u of b)if(o[u])return String(o[u]);if(c?.recordRepresentation){const u=c.recordRepresentation;if(typeof u=="string"&&o[u])return String(o[u])}},[o,m,l,c]),h=S(()=>p?p(t.pathname,c):x(t.pathname,s,c,f,g,I,A),[t.pathname,s,c,f,g,I,A,p]),B=R(b=>{r(P.updatePage({breadcrumbs:b}))},[r]),C=R(b=>{const u=a.breadcrumbs||[];r(P.updatePage({breadcrumbs:[...u,b]}))},[r,a.breadcrumbs]),U=R(()=>{r(P.updatePage({breadcrumbs:[]}))},[r]);return L(()=>{d&&h.length>0&&B(h)},[d,h,B]),{breadcrumbs:a.breadcrumbs||h,setBreadcrumbs:B,addBreadcrumb:C,clearBreadcrumbs:U,pathname:t.pathname}};var J=M;export{J as default,M as useBreadcrumbs};
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { useCallback, useEffect, useMemo } from "react";
+import { useLocation, useParams } from "react-router-dom";
+import { useDispatch, useSelector } from "react-redux";
+import { useStore } from "react-admin";
+import { DASH_REDUX_ACTIONS } from "dash-admin-state";
+import { DASHAdminSystemConstants } from "dash-constants";
+const defaultLabelMap = {
+  // Common actions
+  "create": "Crear",
+  "edit": "Editar",
+  "show": "Ver",
+  "list": "Lista",
+  "inline": "Detalle",
+  "trash": "Papelera",
+  // Common routes
+  "admin": "Admin",
+  "system": "Sistema",
+  "settings": "Configuraci\xF3n",
+  "users": "Usuarios",
+  "roles": "Roles",
+  "permissions": "Permisos",
+  "tenants": "Tenants",
+  "profile": "Perfil",
+  "dashboard": "Dashboard"
+};
+const parseSegmentLabel = (segment, labelMap, resourceConfig) => {
+  var _a;
+  if (labelMap[segment]) {
+    return labelMap[segment];
+  }
+  if (defaultLabelMap[segment]) {
+    return defaultLabelMap[segment];
+  }
+  if (resourceConfig && ((_a = resourceConfig.model) == null ? void 0 : _a.includes(segment))) {
+    return resourceConfig.label || segment;
+  }
+  return segment.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+};
+const isIdSegment = (segment) => {
+  if (/^\d+$/.test(segment)) {
+    return true;
+  }
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment)) {
+    return true;
+  }
+  if (/^[a-z0-9]{20,}$/i.test(segment)) {
+    return true;
+  }
+  return false;
+};
+const generateBreadcrumbsFromPath = (pathname, labelMap, resourceConfig, includeHome, homePath, homeLabel, recordName) => {
+  const URL_PREFIX = DASHAdminSystemConstants.system.URL_PREFIX || "";
+  let cleanPath = pathname;
+  if (URL_PREFIX && cleanPath.startsWith(URL_PREFIX)) {
+    cleanPath = cleanPath.slice(URL_PREFIX.length);
+  }
+  const segments = cleanPath.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return [];
+  }
+  const breadcrumbs = [];
+  if (includeHome) {
+    breadcrumbs.push({
+      label: homeLabel || "Home",
+      path: homePath || "/"
+    });
+  }
+  let currentPath = URL_PREFIX;
+  if (currentPath && !currentPath.startsWith("/")) {
+    currentPath = `/${currentPath}`;
+  }
+  let lastIdIndex = -1;
+  segments.forEach((segment, index) => {
+    currentPath += `/${segment}`;
+    const isLast = index === segments.length - 1;
+    const isId = isIdSegment(segment);
+    if (isId) {
+      lastIdIndex = index;
+      if (recordName && isLast) {
+        breadcrumbs.push({
+          label: recordName,
+          path: isLast ? void 0 : currentPath,
+          isActive: isLast
+        });
+      } else {
+        breadcrumbs.push({
+          label: `#${segment.substring(0, 8)}${segment.length > 8 ? "..." : ""}`,
+          path: isLast ? void 0 : currentPath,
+          isActive: isLast,
+          data: { id: segment }
+        });
+      }
+      return;
+    }
+    const label = parseSegmentLabel(segment, labelMap, resourceConfig);
+    breadcrumbs.push({
+      label,
+      path: isLast ? void 0 : currentPath,
+      isActive: isLast
+    });
+  });
+  return breadcrumbs;
+};
+const useBreadcrumbs = (options = {}) => {
+  const {
+    autoUpdate = true,
+    labelMap = {},
+    includeHome = false,
+    homePath = "/",
+    homeLabel = "Home",
+    customGenerator,
+    fetchRecordName = true,
+    recordNameField = "name"
+  } = options;
+  const dispatch = useDispatch();
+  const location = useLocation();
+  const params = useParams();
+  const [resourceConfig] = useStore("resourceConfig");
+  const pageState = useSelector(
+    (state) => state.page
+  );
+  const record = null;
+  const mergedLabelMap = useMemo(() => __spreadValues(__spreadValues({}, defaultLabelMap), labelMap), [labelMap]);
+  const recordName = useMemo(() => {
+    if (!fetchRecordName || !record) return void 0;
+    const nameFields = [recordNameField, "name", "title", "label", "displayName", "username"];
+    for (const field of nameFields) {
+      if (record[field]) {
+        return String(record[field]);
+      }
+    }
+    if (resourceConfig == null ? void 0 : resourceConfig.recordRepresentation) {
+      const repr = resourceConfig.recordRepresentation;
+      if (typeof repr === "string" && record[repr]) {
+        return String(record[repr]);
+      }
+    }
+    return void 0;
+  }, [record, fetchRecordName, recordNameField, resourceConfig]);
+  const breadcrumbs = useMemo(() => {
+    if (customGenerator) {
+      return customGenerator(location.pathname, resourceConfig);
+    }
+    return generateBreadcrumbsFromPath(
+      location.pathname,
+      mergedLabelMap,
+      resourceConfig,
+      includeHome,
+      homePath,
+      homeLabel,
+      recordName
+    );
+  }, [
+    location.pathname,
+    mergedLabelMap,
+    resourceConfig,
+    includeHome,
+    homePath,
+    homeLabel,
+    recordName,
+    customGenerator
+  ]);
+  const setBreadcrumbs = useCallback((items) => {
+    dispatch(DASH_REDUX_ACTIONS.updatePage({ breadcrumbs: items }));
+  }, [dispatch]);
+  const addBreadcrumb = useCallback((item) => {
+    const currentBreadcrumbs = pageState.breadcrumbs || [];
+    dispatch(DASH_REDUX_ACTIONS.updatePage({
+      breadcrumbs: [...currentBreadcrumbs, item]
+    }));
+  }, [dispatch, pageState.breadcrumbs]);
+  const clearBreadcrumbs = useCallback(() => {
+    dispatch(DASH_REDUX_ACTIONS.updatePage({ breadcrumbs: [] }));
+  }, [dispatch]);
+  useEffect(() => {
+    if (autoUpdate && breadcrumbs.length > 0) {
+      setBreadcrumbs(breadcrumbs);
+    }
+  }, [autoUpdate, breadcrumbs, setBreadcrumbs]);
+  return {
+    breadcrumbs: pageState.breadcrumbs || breadcrumbs,
+    setBreadcrumbs,
+    addBreadcrumb,
+    clearBreadcrumbs,
+    pathname: location.pathname
+  };
+};
+var useBreadcrumbs_default = useBreadcrumbs;
+export {
+  useBreadcrumbs_default as default,
+  useBreadcrumbs
+};

package/dist/hooks/useClickOutside.js

@@ -1 +1,18 @@
-import{useEffect as r}from"react";const i=(e,c)=>{const t=n=>{e.current&&!e.current.contains(n.target)&&c()};r(()=>(document.addEventListener("click",t),()=>{document.removeEventListener("click",t)}))};var u=i;export{u as default};
+import { useEffect } from "react";
+const useClickOutside = (ref, callback) => {
+  const handleClick = (e) => {
+    if (ref.current && !ref.current.contains(e.target)) {
+      callback();
+    }
+  };
+  useEffect(() => {
+    document.addEventListener("click", handleClick);
+    return () => {
+      document.removeEventListener("click", handleClick);
+    };
+  });
+};
+var useClickOutside_default = useClickOutside;
+export {
+  useClickOutside_default as default
+};

package/dist/hooks/useFormPersistance.js

@@ -1 +1,129 @@
-import{useEffect as F,useCallback as a,useRef as x}from"react";import{useFormContext as P}from"react-hook-form";import{useParams as S}from"react-router-dom";import{dashStorage as n}from"@dashadmin/dash-utils";const v=(g={})=>{const{persistState:s=!1,storageKey:y,debounceMs:m=1e3,excludeFields:d=[]}=g,{watch:f,setValue:p,getValues:D}=P(),{id:c}=S(),o=x(null),t=y||`tab-form-${c}`,u=a(e=>{if(s)try{const r={...e};d.forEach(T=>{delete r[T]});const i={formData:r,timestamp:Date.now(),tabId:c};n.setItem(t,JSON.stringify(i)),console.log("\u{1F4E6} Form data persisted:",t)}catch(r){console.error("Failed to persist form data:",r)}},[s,t,d,c]),l=a(()=>{if(!s)return null;try{const e=n.getItem(t);if(!e)return null;const r=JSON.parse(e),i=1440*60*1e3;return Date.now()-r.timestamp>i?(n.removeItem(t),null):(console.log("\u{1F4E6} Form data loaded from storage:",t),r.formData)}catch(e){return console.error("Failed to load form data:",e),null}},[s,t]),b=a(()=>{const e=l();if(!e)return!1;try{return Object.keys(e).forEach(r=>{p(r,e[r],{shouldDirty:!0,shouldTouch:!0,shouldValidate:!1})}),console.log("\u2705 Form data restored successfully"),!0}catch(r){return console.error("Failed to restore form data:",r),!1}},[l,p]),h=a(()=>{try{n.removeItem(t),console.log("\u{1F5D1}\uFE0F Persisted form data cleared:",t)}catch(e){console.error("Failed to clear persisted data:",e)}},[t]);return F(()=>{if(!s)return;const e=f(r=>{o.current&&clearTimeout(o.current),o.current=setTimeout(()=>{u(r)},m)});return()=>{e.unsubscribe(),o.current&&clearTimeout(o.current)}},[f,s,u,m]),F(()=>()=>{o.current&&clearTimeout(o.current)},[]),{restoreFormData:b,clearPersistedData:h,loadFormData:l,saveFormData:()=>u(D())}};var K=v;export{K as default,v as useFormPersistence};
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { useEffect, useCallback, useRef } from "react";
+import { useFormContext } from "react-hook-form";
+import { useParams } from "react-router-dom";
+import { dashStorage } from "dash-utils";
+const useFormPersistence = (options = {}) => {
+  const {
+    persistState = false,
+    storageKey,
+    debounceMs = 1e3,
+    excludeFields = []
+  } = options;
+  const { watch, setValue, getValues } = useFormContext();
+  const { id: tabId } = useParams();
+  const debounceRef = useRef(null);
+  const finalStorageKey = storageKey || `tab-form-${tabId}`;
+  const saveFormData = useCallback((data) => {
+    if (!persistState) return;
+    try {
+      const filteredData = __spreadValues({}, data);
+      excludeFields.forEach((field) => {
+        delete filteredData[field];
+      });
+      const persistData = {
+        formData: filteredData,
+        timestamp: Date.now(),
+        tabId
+      };
+      dashStorage.setItem(finalStorageKey, JSON.stringify(persistData));
+      console.log("\u{1F4E6} Form data persisted:", finalStorageKey);
+    } catch (error) {
+      console.error("Failed to persist form data:", error);
+    }
+  }, [persistState, finalStorageKey, excludeFields, tabId]);
+  const loadFormData = useCallback(() => {
+    if (!persistState) return null;
+    try {
+      const stored = dashStorage.getItem(finalStorageKey);
+      if (!stored) return null;
+      const persistData = JSON.parse(stored);
+      const maxAge = 24 * 60 * 60 * 1e3;
+      if (Date.now() - persistData.timestamp > maxAge) {
+        dashStorage.removeItem(finalStorageKey);
+        return null;
+      }
+      console.log("\u{1F4E6} Form data loaded from storage:", finalStorageKey);
+      return persistData.formData;
+    } catch (error) {
+      console.error("Failed to load form data:", error);
+      return null;
+    }
+  }, [persistState, finalStorageKey]);
+  const restoreFormData = useCallback(() => {
+    const savedData = loadFormData();
+    if (!savedData) return false;
+    try {
+      Object.keys(savedData).forEach((fieldName) => {
+        setValue(fieldName, savedData[fieldName], {
+          shouldDirty: true,
+          shouldTouch: true,
+          shouldValidate: false
+        });
+      });
+      console.log("\u2705 Form data restored successfully");
+      return true;
+    } catch (error) {
+      console.error("Failed to restore form data:", error);
+      return false;
+    }
+  }, [loadFormData, setValue]);
+  const clearPersistedData = useCallback(() => {
+    try {
+      dashStorage.removeItem(finalStorageKey);
+      console.log("\u{1F5D1}\uFE0F Persisted form data cleared:", finalStorageKey);
+    } catch (error) {
+      console.error("Failed to clear persisted data:", error);
+    }
+  }, [finalStorageKey]);
+  useEffect(() => {
+    if (!persistState) return;
+    const subscription = watch((data) => {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+      debounceRef.current = setTimeout(() => {
+        saveFormData(data);
+      }, debounceMs);
+    });
+    return () => {
+      subscription.unsubscribe();
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, [watch, persistState, saveFormData, debounceMs]);
+  useEffect(() => {
+    return () => {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, []);
+  return {
+    restoreFormData,
+    clearPersistedData,
+    loadFormData,
+    saveFormData: () => saveFormData(getValues())
+  };
+};
+var useFormPersistance_default = useFormPersistence;
+export {
+  useFormPersistance_default as default,
+  useFormPersistence
+};

package/dist/hooks/useGlobalErrorMediator.js

@@ -1 +1,37 @@
-import e from"react";import{dashStorage as t}from"@dashadmin/dash-utils";const n=()=>{const[o,s]=e.useState(null),a=e.useCallback(r=>{t.getItem("lastGlobalError")!==JSON.stringify(r.data)&&(s(r.data),t.setItem("lastGlobalError",JSON.stringify(r.data)),setTimeout(()=>{t.setItem("lastGlobalError",JSON.stringify({}))},1e3))},[]);e.useEffect(()=>(t.setItem("lastGlobalError",JSON.stringify({})),window.addEventListener("GlobalError",a),()=>{t.setItem("lastGlobalError",JSON.stringify({})),window.removeEventListener("GlobalError",a)}),[]);const l=e.useCallback(r=>{window.dispatchEvent(new MessageEvent("GlobalError",{data:{error:r}}))},[o]);return{error:o,sendError:r=>{l(r)}}};var b=n;export{b as default};
+import React from "react";
+import { dashStorage } from "dash-utils";
+const useGlobalErrorMediator = () => {
+  const [error, setError] = React.useState(null);
+  const errorChangeHandler = React.useCallback((e) => {
+    if (dashStorage.getItem("lastGlobalError") === JSON.stringify(e.data)) {
+      return;
+    }
+    setError(e.data);
+    dashStorage.setItem("lastGlobalError", JSON.stringify(e.data));
+    setTimeout(() => {
+      dashStorage.setItem("lastGlobalError", JSON.stringify({}));
+    }, 1e3);
+  }, []);
+  React.useEffect(() => {
+    dashStorage.setItem("lastGlobalError", JSON.stringify({}));
+    window.addEventListener("GlobalError", errorChangeHandler);
+    return () => {
+      dashStorage.setItem("lastGlobalError", JSON.stringify({}));
+      window.removeEventListener("GlobalError", errorChangeHandler);
+    };
+  }, []);
+  const _update = React.useCallback(
+    (newError) => {
+      window.dispatchEvent(new MessageEvent("GlobalError", { data: { error: newError } }));
+    },
+    [error]
+  );
+  const sendError = (error2) => {
+    _update(error2);
+  };
+  return { error, sendError };
+};
+var useGlobalErrorMediator_default = useGlobalErrorMediator;
+export {
+  useGlobalErrorMediator_default as default
+};

package/dist/hooks/useGlobalLoaderMgr.js

@@ -1 +1,20 @@
-import t,{useState as o}from"react";const r=()=>{const e=o(!1);return t.useEffect(()=>(window.addEventListener("dash-global-loader",a=>e[1](a.data)),()=>{window.removeEventListener("dash-global-loader",a=>e[1](a.data))}),[]),e};var u=r;export{u as default};
+import React, { useState } from "react";
+const useGlobalLoaderMgr = () => {
+  const useLoader = useState(false);
+  React.useEffect(() => {
+    window.addEventListener("dash-global-loader", (e) => {
+      return useLoader[1](e.data);
+    });
+    return () => {
+      window.removeEventListener(
+        "dash-global-loader",
+        (e) => useLoader[1](e.data)
+      );
+    };
+  }, []);
+  return useLoader;
+};
+var useGlobalLoaderMgr_default = useGlobalLoaderMgr;
+export {
+  useGlobalLoaderMgr_default as default
+};

package/dist/hooks/useHash.js

@@ -1 +1,24 @@
-import a from"react";const o=()=>{const[e,s]=a.useState(()=>window.location.hash),n=a.useCallback(()=>{s(window.location.hash)},[]);a.useEffect(()=>(window.addEventListener("hashchange",n),()=>{window.removeEventListener("hashchange",n)}),[]);const t=a.useCallback(h=>{window.location.hash=h},[e]);return[e,t]};var i=o;export{i as default};
+import React from "react";
+const useHash = () => {
+  const [hash, setHash] = React.useState(() => window.location.hash);
+  const hashChangeHandler = React.useCallback(() => {
+    setHash(window.location.hash);
+  }, []);
+  React.useEffect(() => {
+    window.addEventListener("hashchange", hashChangeHandler);
+    return () => {
+      window.removeEventListener("hashchange", hashChangeHandler);
+    };
+  }, []);
+  const updateHash = React.useCallback(
+    (newHash) => {
+      window.location.hash = newHash;
+    },
+    [hash]
+  );
+  return [hash, updateHash];
+};
+var useHash_default = useHash;
+export {
+  useHash_default as default
+};

package/dist/hooks/useLocalStorage.js

@@ -1 +1,68 @@
-import{useCallback as i,useEffect as l,useState as g}from"react";import{dashStorage as n}from"@dashadmin/dash-utils";const S=typeof window<"u",w=()=>{if(!S)return!1;const t=`test-${Date.now()}`;try{return n.setItem(t,t),n.removeItem(t),!0}catch{return!1}},p=(t,o="")=>{const r=w(),c=i(()=>{try{if(!r)return o;const e=n.getItem(t);return e?JSON.parse(e):o}catch{return o}},[r,o,t]),m=c(),[u,a]=g(m);l(()=>{if(r){const e=c();a(e)}},[r]);const f=i(e=>{const{key:s,newValue:d}=e;t===s&&a(JSON.parse(d))},[t]);return l(()=>{if(r)return window.addEventListener("storage",f),()=>{window.removeEventListener("storage",f)}},[r]),[u,e=>{if(!r)return!1;const s=e instanceof Function?e(u):e;n.setItem(t,JSON.stringify(s)),a(s)}]};var V=p;export{V as default};
+import { useCallback, useEffect, useState } from "react";
+import { dashStorage } from "dash-utils";
+const isBrowser = typeof window !== "undefined";
+const isLocalStorageAvailable = () => {
+  if (!isBrowser) {
+    return false;
+  }
+  const test = `test-${Date.now()}`;
+  try {
+    dashStorage.setItem(test, test);
+    dashStorage.removeItem(test);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+const useLocalStorage = (key, initialValue = "") => {
+  const available = isLocalStorageAvailable();
+  const getValueFromLocalStorage = useCallback(() => {
+    try {
+      if (!available) {
+        return initialValue;
+      }
+      const item = dashStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      return initialValue;
+    }
+  }, [available, initialValue, key]);
+  const _initialValue = getValueFromLocalStorage();
+  const [storedValue, setStoredValue] = useState(_initialValue);
+  useEffect(() => {
+    if (available) {
+      const value = getValueFromLocalStorage();
+      setStoredValue(value);
+    }
+  }, [available]);
+  const changeHandler = useCallback(
+    (e) => {
+      const { key: changeKey, newValue } = e;
+      if (key === changeKey) {
+        setStoredValue(JSON.parse(newValue));
+      }
+    },
+    [key]
+  );
+  useEffect(() => {
+    if (available) {
+      window.addEventListener("storage", changeHandler);
+      return () => {
+        window.removeEventListener("storage", changeHandler);
+      };
+    }
+  }, [available]);
+  const setValue = (value) => {
+    if (!available) {
+      return false;
+    }
+    const valueToStore = value instanceof Function ? value(storedValue) : value;
+    dashStorage.setItem(key, JSON.stringify(valueToStore));
+    setStoredValue(valueToStore);
+  };
+  return [storedValue, setValue];
+};
+var useLocalStorage_default = useLocalStorage;
+export {
+  useLocalStorage_default as default
+};

package/dist/hooks/usePolyglotTranslation.js

@@ -1 +1,57 @@
-import{useSelector as s,useDispatch as c}from"react-redux";import{useMemo as o,useCallback as i}from"react";import g from"node-polyglot";import{DASH_REDUX_ACTIONS as p}from"@dashadmin/dash-admin-state";const h=({locales:t}={})=>{const a=s(e=>e.settings?.availableLocales);return o(()=>t&&t.length>0?t:a||[{locale:"es",name:"Espa\xF1ol",languageId:"spanish",icon:"es"},{locale:"en",name:"English",languageId:"english",icon:"en"}],[t,a])},I=()=>{const t=c(),a=s(n=>n.settings?.locale||"es"),e=i(n=>{t(p.switchLanguage(n)),localStorage.setItem("dash-user-locale",n)},[t]);return[a,e]},D=()=>{const t=s(e=>e.settings?.locale||"es"),a=s(e=>e.settings?.translations||{});return o(()=>{const e=a[t]||a.es,n=new g({phrases:e,locale:t,allowMissing:!0});return(l,r)=>n.t(l,r)},[t,a])};export{I as useLocaleState,h as useLocales,D as useTranslate};
+import { useSelector, useDispatch } from "react-redux";
+import { useMemo, useCallback } from "react";
+import Polyglot from "node-polyglot";
+import { DASH_REDUX_ACTIONS } from "dash-admin-state";
+const useLocales = ({ locales } = {}) => {
+  const availableLocales = useSelector((state) => {
+    var _a;
+    return (_a = state.settings) == null ? void 0 : _a.availableLocales;
+  });
+  return useMemo(() => {
+    if (locales && locales.length > 0) {
+      return locales;
+    }
+    return availableLocales || [
+      { locale: "es", name: "Espa\xF1ol", languageId: "spanish", icon: "es" },
+      { locale: "en", name: "English", languageId: "english", icon: "en" }
+    ];
+  }, [locales, availableLocales]);
+};
+const useLocaleState = () => {
+  const dispatch = useDispatch();
+  const currentLocale = useSelector((state) => {
+    var _a;
+    return ((_a = state.settings) == null ? void 0 : _a.locale) || "es";
+  });
+  const setLocale = useCallback((newLocale) => {
+    dispatch(DASH_REDUX_ACTIONS.switchLanguage(newLocale));
+    localStorage.setItem("dash-user-locale", newLocale);
+  }, [dispatch]);
+  return [currentLocale, setLocale];
+};
+const useTranslate = () => {
+  const locale = useSelector((state) => {
+    var _a;
+    return ((_a = state.settings) == null ? void 0 : _a.locale) || "es";
+  });
+  const translations = useSelector((state) => {
+    var _a;
+    return ((_a = state.settings) == null ? void 0 : _a.translations) || {};
+  });
+  return useMemo(() => {
+    const messages = translations[locale] || translations["es"];
+    const polyglot = new Polyglot({
+      phrases: messages,
+      locale,
+      allowMissing: true
+    });
+    return (key, options) => {
+      return polyglot.t(key, options);
+    };
+  }, [locale, translations]);
+};
+export {
+  useLocaleState,
+  useLocales,
+  useTranslate
+};

package/dist/hooks/usePrevious.js

@@ -1 +1,12 @@
-import{useEffect as t,useRef as u}from"react";const f=r=>{const e=u(void 0);return t(()=>{e.current=r}),e.current};var o=f;export{o as default};
+import { useEffect, useRef } from "react";
+const usePrevious = (value) => {
+  const ref = useRef(void 0);
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+};
+var usePrevious_default = usePrevious;
+export {
+  usePrevious_default as default
+};

package/dist/hooks/usePrintSelected.js

@@ -1 +1,30 @@
-import s,{useState as a}from"react";const l=()=>{const t=a(null),d=(e,r)=>{window.dispatchEvent(new MessageEvent("printSelected",{data:{value:{selectedIds:e,filterValues:r}}}))},n=e=>{t[1](e.data.value)};return s.useEffect(()=>(window.addEventListener("printSelected",n),()=>{window.removeEventListener("printSelected",n)}),[]),{printSelectedUseState:t,sendPrintSelectedEvent:d}};var i=l;export{i as default};
+import React, { useState } from "react";
+const usePrintSelected = () => {
+  const printSelectedUseState = useState(null);
+  const sendPrintSelectedEvent = (selectedIds, filterValues) => {
+    window.dispatchEvent(
+      new MessageEvent("printSelected", {
+        data: {
+          value: { selectedIds, filterValues }
+        }
+      })
+    );
+  };
+  const eventHook = (e) => {
+    printSelectedUseState[1](e.data.value);
+  };
+  React.useEffect(() => {
+    window.addEventListener("printSelected", eventHook);
+    return () => {
+      window.removeEventListener("printSelected", eventHook);
+    };
+  }, []);
+  return {
+    printSelectedUseState,
+    sendPrintSelectedEvent
+  };
+};
+var usePrintSelected_default = usePrintSelected;
+export {
+  usePrintSelected_default as default
+};

package/dist/hooks/useVirtualHash.js

@@ -1 +1,28 @@
-import a from"react";const i=()=>{const[e,n]=a.useState(()=>window.location.hash),s=a.useCallback(t=>{n(t.data)},[]);a.useEffect(()=>(window.addEventListener("virtualhash",s),()=>{window.removeEventListener("virtualhash",s)}),[]);const r=a.useCallback(t=>{history.replaceState(null,null,`#${t}`),window.dispatchEvent(new MessageEvent("virtualhash",{data:`#${t}`}))},[e]);return{hash:e,setVirtualHash:t=>{r(t)}}};var d=i;export{d as default};
+import React from "react";
+const useVirtualHash = () => {
+  const [hash, setHash] = React.useState(() => window.location.hash);
+  const hashChangeHandler = React.useCallback((e) => {
+    setHash(e.data);
+  }, []);
+  React.useEffect(() => {
+    window.addEventListener("virtualhash", hashChangeHandler);
+    return () => {
+      window.removeEventListener("virtualhash", hashChangeHandler);
+    };
+  }, []);
+  const _update = React.useCallback(
+    (newHash) => {
+      history.replaceState(null, null, `#${newHash}`);
+      window.dispatchEvent(new MessageEvent("virtualhash", { data: `#${newHash}` }));
+    },
+    [hash]
+  );
+  const setVirtualHash = (hash2) => {
+    _update(hash2);
+  };
+  return { hash, setVirtualHash };
+};
+var useVirtualHash_default = useVirtualHash;
+export {
+  useVirtualHash_default as default
+};