@dashadmin/dash-app-common 1.3.25 → 1.3.28

package/dist/defaults/extensions/components/dashDefaultAutoAdminComponents.js

@@ -1 +1,67 @@
-const e={},a=async()=>{try{const[t,n,s]=await Promise.all([import("@dashadmin/dash-components").then(o=>({default:o.Json})),import("@dashadmin/dash-components").then(o=>({default:o.JsonColorSelectorEnhanced})),import("@dashadmin/dash-components").then(o=>({default:o.JsonCssVarValues}))]);return{Json:t.default,JsonColorSelector:n.default,JsonCssVarValues:s.default,...e}}catch(t){return console.error("Failed to load dash default auto admin components:",t),e}};var u=a;export{e as dashDefaultAutoAdminComponents,u as default,a as loadDashDefaultAutoAdminComponents};
+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;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const dashDefaultAutoAdminComponents = {
+  // Add default components here
+};
+const loadDashDefaultAutoAdminComponents = () => __async(null, null, function* () {
+  try {
+    const [
+      JsonComp,
+      JsonColorSelectorComp,
+      JsonCssVarValuesComp
+    ] = yield Promise.all([
+      import("dash-components").then((module) => ({ default: module.Json })),
+      import("dash-components").then((module) => ({ default: module.JsonColorSelectorEnhanced })),
+      import("dash-components").then((module) => ({ default: module.JsonCssVarValues }))
+    ]);
+    return __spreadValues({
+      // Dash components
+      Json: JsonComp.default,
+      JsonColorSelector: JsonColorSelectorComp.default,
+      JsonCssVarValues: JsonCssVarValuesComp.default
+    }, dashDefaultAutoAdminComponents);
+  } catch (error) {
+    console.error("Failed to load dash default auto admin components:", error);
+    return dashDefaultAutoAdminComponents;
+  }
+});
+var dashDefaultAutoAdminComponents_default = loadDashDefaultAutoAdminComponents;
+export {
+  dashDefaultAutoAdminComponents,
+  dashDefaultAutoAdminComponents_default as default,
+  loadDashDefaultAutoAdminComponents
+};

package/dist/defaults/extensions/components/dashDefaultNotification.js

@@ -1 +1,28 @@
-import{jsx as o}from"react/jsx-runtime";import{Notification as t}from"react-admin";const i=()=>o(t,{className:"dash-notification",autoHideDuration:8e3,multiLine:!0,anchorOrigin:{vertical:"top",horizontal:"right"}}),e={autoHideDuration:8e3,multiLine:!0,anchorOrigin:{vertical:"top",horizontal:"right"},className:"dash-notification"};var c=i;export{i as DashDefaultReactAdminNotification,e as dashDefaultNotificationConfig,c as default};
+import { jsx } from "react/jsx-runtime";
+import { Notification } from "react-admin";
+const DashDefaultReactAdminNotification = () => {
+  return /* @__PURE__ */ jsx(
+    Notification,
+    {
+      className: "dash-notification",
+      autoHideDuration: 8e3,
+      multiLine: true,
+      anchorOrigin: { vertical: "top", horizontal: "right" }
+    }
+  );
+};
+const dashDefaultNotificationConfig = {
+  autoHideDuration: 8e3,
+  multiLine: true,
+  anchorOrigin: {
+    vertical: "top",
+    horizontal: "right"
+  },
+  className: "dash-notification"
+};
+var dashDefaultNotification_default = DashDefaultReactAdminNotification;
+export {
+  DashDefaultReactAdminNotification,
+  dashDefaultNotificationConfig,
+  dashDefaultNotification_default as default
+};

package/dist/defaults/extensions/components/dashDefaultStaticComponents.js

@@ -1 +1,15 @@
-import{jsx as e}from"react/jsx-runtime";import a from"react";const s=a.lazy(()=>import("@dashadmin/dash-admin/src/pages/RecoverPassword")),t=a.lazy(()=>import("@dashadmin/dash-admin/src/pages/ChangePassword")),o={defaultRecoverPassword:e(a.Suspense,{fallback:e("div",{children:"Loading..."}),children:e(s,{})}),defaultChangePassword:e(a.Suspense,{fallback:e("div",{children:"Loading..."}),children:e(t,{})})},d=()=>o;var c=o;export{o as dashDefaultStaticComponents,c as default,d as getDashDefaultStaticComponents};
+import { jsx } from "react/jsx-runtime";
+import React from "react";
+const RecoverPassword = React.lazy(() => import("dash-admin/src/pages/RecoverPassword"));
+const ChangePassword = React.lazy(() => import("dash-admin/src/pages/ChangePassword"));
+const dashDefaultStaticComponents = {
+  defaultRecoverPassword: /* @__PURE__ */ jsx(React.Suspense, { fallback: /* @__PURE__ */ jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsx(RecoverPassword, {}) }),
+  defaultChangePassword: /* @__PURE__ */ jsx(React.Suspense, { fallback: /* @__PURE__ */ jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsx(ChangePassword, {}) })
+};
+const getDashDefaultStaticComponents = () => dashDefaultStaticComponents;
+var dashDefaultStaticComponents_default = dashDefaultStaticComponents;
+export {
+  dashDefaultStaticComponents,
+  dashDefaultStaticComponents_default as default,
+  getDashDefaultStaticComponents
+};

package/dist/defaults/extensions/components/index.js

@@ -1 +1,13 @@
-import{loadDashDefaultAutoAdminComponents as a,dashDefaultAutoAdminComponents as e}from"./dashDefaultAutoAdminComponents";import{dashDefaultStaticComponents as n,getDashDefaultStaticComponents as s}from"./dashDefaultStaticComponents";import{DashDefaultReactAdminNotification as i,dashDefaultNotificationConfig as m}from"./dashDefaultNotification";import{DashDefaultLoader as p}from"./DashDefaultLoader";export{p as DashDefaultLoader,i as DashDefaultReactAdminNotification,e as dashDefaultAutoAdminComponents,m as dashDefaultNotificationConfig,n as dashDefaultStaticComponents,s as getDashDefaultStaticComponents,a as loadDashDefaultAutoAdminComponents};
+import { loadDashDefaultAutoAdminComponents, dashDefaultAutoAdminComponents } from "./dashDefaultAutoAdminComponents";
+import { dashDefaultStaticComponents, getDashDefaultStaticComponents } from "./dashDefaultStaticComponents";
+import { DashDefaultReactAdminNotification, dashDefaultNotificationConfig } from "./dashDefaultNotification";
+import { DashDefaultLoader } from "./DashDefaultLoader";
+export {
+  DashDefaultLoader,
+  DashDefaultReactAdminNotification,
+  dashDefaultAutoAdminComponents,
+  dashDefaultNotificationConfig,
+  dashDefaultStaticComponents,
+  getDashDefaultStaticComponents,
+  loadDashDefaultAutoAdminComponents
+};

package/dist/defaults/extensions/electron/dashDefaultIpcListeners.js

@@ -1 +1,38 @@
-import{useEffect as u}from"react";import{getDashIPCService as i,onIPCStdout as r}from"@dashadmin/dash-utils";const a=n=>{const{onStdout:o,enableLogging:t=!0}=n||{};u(()=>(i()&&r(e=>{t&&console.log("[DashDefault IPC Stdout]:",e),o?.(e)}),()=>{}),[o,t])},l=n=>{const{onStdout:o,enableLogging:t=!0}=n||{};return i()&&r(e=>{t&&console.log("[DashDefault IPC Stdout]:",e),o?.(e)}),()=>{}};var f=a;export{f as default,l as setupDashDefaultIPCListeners,a as useDashDefaultIPCListeners};
+import { useEffect } from "react";
+import { getDashIPCService, onIPCStdout } from "dash-utils";
+const useDashDefaultIPCListeners = (options) => {
+  const { onStdout, enableLogging = true } = options || {};
+  useEffect(() => {
+    const ipcService = getDashIPCService();
+    if (ipcService) {
+      onIPCStdout((data) => {
+        if (enableLogging) {
+          console.log("[DashDefault IPC Stdout]:", data);
+        }
+        onStdout == null ? void 0 : onStdout(data);
+      });
+    }
+    return () => {
+    };
+  }, [onStdout, enableLogging]);
+};
+const setupDashDefaultIPCListeners = (options) => {
+  const { onStdout, enableLogging = true } = options || {};
+  const ipcService = getDashIPCService();
+  if (ipcService) {
+    onIPCStdout((data) => {
+      if (enableLogging) {
+        console.log("[DashDefault IPC Stdout]:", data);
+      }
+      onStdout == null ? void 0 : onStdout(data);
+    });
+  }
+  return () => {
+  };
+};
+var dashDefaultIpcListeners_default = useDashDefaultIPCListeners;
+export {
+  dashDefaultIpcListeners_default as default,
+  setupDashDefaultIPCListeners,
+  useDashDefaultIPCListeners
+};

package/dist/defaults/extensions/electron/index.js

@@ -1 +1,5 @@
-import{useDashDefaultIPCListeners as t,setupDashDefaultIPCListeners as a}from"./dashDefaultIpcListeners";export{a as setupDashDefaultIPCListeners,t as useDashDefaultIPCListeners};
+import { useDashDefaultIPCListeners, setupDashDefaultIPCListeners } from "./dashDefaultIpcListeners";
+export {
+  setupDashDefaultIPCListeners,
+  useDashDefaultIPCListeners
+};

package/dist/defaults/extensions/hooks/index.js

@@ -1 +1,12 @@
-import{useDashDefaultMountTracker as a}from"./useDashDefaultMountTracker";import{useDashDefaultRoutePath as t}from"./useDashDefaultRoutePath";import{useDashDefaultLazyI18nProvider as s}from"./useDashDefaultLazyI18nProvider";import{useDashDefaultLazyAutoAdminComponents as D}from"./useDashDefaultLazyAutoAdminComponents";import{useDashDefaultLazyResources as h}from"./useDashDefaultLazyResources";export{D as useDashDefaultLazyAutoAdminComponents,s as useDashDefaultLazyI18nProvider,h as useDashDefaultLazyResources,a as useDashDefaultMountTracker,t as useDashDefaultRoutePath};
+import { useDashDefaultMountTracker } from "./useDashDefaultMountTracker";
+import { useDashDefaultRoutePath } from "./useDashDefaultRoutePath";
+import { useDashDefaultLazyI18nProvider } from "./useDashDefaultLazyI18nProvider";
+import { useDashDefaultLazyAutoAdminComponents } from "./useDashDefaultLazyAutoAdminComponents";
+import { useDashDefaultLazyResources } from "./useDashDefaultLazyResources";
+export {
+  useDashDefaultLazyAutoAdminComponents,
+  useDashDefaultLazyI18nProvider,
+  useDashDefaultLazyResources,
+  useDashDefaultMountTracker,
+  useDashDefaultRoutePath
+};

package/dist/defaults/extensions/hooks/useDashDefaultLazyAutoAdminComponents.js

@@ -1 +1,17 @@
-import{useState as n,useEffect as a}from"react";import s from"../components/dashDefaultAutoAdminComponents";const m=()=>{const[t,o]=n(null);return a(()=>{s().then(o).catch(e=>{console.error("Failed to load dash default auto admin components:",e),o({})})},[]),t};var l=m;export{l as default,m as useDashDefaultLazyAutoAdminComponents};
+import { useState, useEffect } from "react";
+import loadDashDefaultAutoAdminComponents from "../components/dashDefaultAutoAdminComponents";
+const useDashDefaultLazyAutoAdminComponents = () => {
+  const [components, setComponents] = useState(null);
+  useEffect(() => {
+    loadDashDefaultAutoAdminComponents().then(setComponents).catch((error) => {
+      console.error("Failed to load dash default auto admin components:", error);
+      setComponents({});
+    });
+  }, []);
+  return components;
+};
+var useDashDefaultLazyAutoAdminComponents_default = useDashDefaultLazyAutoAdminComponents;
+export {
+  useDashDefaultLazyAutoAdminComponents_default as default,
+  useDashDefaultLazyAutoAdminComponents
+};

package/dist/defaults/extensions/hooks/useDashDefaultLazyI18nProvider.js

@@ -1 +1,51 @@
-import{useState as r,useEffect as f}from"react";import{useSelector as m}from"react-redux";import{loadDashDefaultTranslationsAsync as u,createDashDefaultI18nProviderAsync as p}from"../i18n/dashDefaultI18nProvider";const y=()=>{const[e,s]=r(null),[n,l]=r(null),a=m(o=>o.settings);return f(()=>{(async()=>{try{const t=await u();s(t);const i=await p(a?.locale||"en",a?.availableLocales?.map(({locale:c,name:d})=>({locale:c,name:d})));l(i)}catch(t){console.error("Failed to load translations:",t)}})()},[a?.locale,a?.availableLocales]),{translations:e,i18nProvider:n}};var I=y;export{I as default,y as useDashDefaultLazyI18nProvider};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { useState, useEffect } from "react";
+import { useSelector } from "react-redux";
+import { loadDashDefaultTranslationsAsync, createDashDefaultI18nProviderAsync } from "../i18n/dashDefaultI18nProvider";
+const useDashDefaultLazyI18nProvider = () => {
+  const [translations, setTranslations] = useState(null);
+  const [i18nProvider, setI18nProvider] = useState(null);
+  const settings = useSelector((state) => state.settings);
+  useEffect(() => {
+    const load = () => __async(null, null, function* () {
+      var _a;
+      try {
+        const translationsData = yield loadDashDefaultTranslationsAsync();
+        setTranslations(translationsData);
+        const provider = yield createDashDefaultI18nProviderAsync(
+          (settings == null ? void 0 : settings.locale) || "en",
+          (_a = settings == null ? void 0 : settings.availableLocales) == null ? void 0 : _a.map(({ locale, name }) => ({ locale, name }))
+        );
+        setI18nProvider(provider);
+      } catch (error) {
+        console.error("Failed to load translations:", error);
+      }
+    });
+    load();
+  }, [settings == null ? void 0 : settings.locale, settings == null ? void 0 : settings.availableLocales]);
+  return { translations, i18nProvider };
+};
+var useDashDefaultLazyI18nProvider_default = useDashDefaultLazyI18nProvider;
+export {
+  useDashDefaultLazyI18nProvider_default as default,
+  useDashDefaultLazyI18nProvider
+};

package/dist/defaults/extensions/hooks/useDashDefaultLazyResources.js

@@ -1 +1,19 @@
-import{useState as s,useEffect as u}from"react";import{getDASHResources as n}from"@dashadmin/dash-admin";const a=e=>{const[r,o]=s(null);return u(()=>{e||n().then(o).catch(t=>{console.error("Failed to load DASHResources:",t),o([])})},[e]),e||r};var d=a;export{d as default,a as useDashDefaultLazyResources};
+import { useState, useEffect } from "react";
+import { getDASHResources } from "dash-admin";
+const useDashDefaultLazyResources = (customResources) => {
+  const [loadedResources, setLoadedResources] = useState(null);
+  useEffect(() => {
+    if (!customResources) {
+      getDASHResources().then(setLoadedResources).catch((error) => {
+        console.error("Failed to load DASHResources:", error);
+        setLoadedResources([]);
+      });
+    }
+  }, [customResources]);
+  return customResources || loadedResources;
+};
+var useDashDefaultLazyResources_default = useDashDefaultLazyResources;
+export {
+  useDashDefaultLazyResources_default as default,
+  useDashDefaultLazyResources
+};

package/dist/defaults/extensions/hooks/useDashDefaultMountTracker.js

@@ -1 +1,22 @@
-import{useState as l,useEffect as a}from"react";import{dashStorage as e}from"@dashadmin/dash-utils";const s=t=>{const[o,r]=l(!1);return a(()=>{const u=parseInt(e.getItem("tmp"),10)||0;e.setItem("tmp",String(u+1))},[]),a(()=>{t?parseInt(e.getItem("tmp"),10)>=t&&r(!0):r(!0)},[t]),o};var n=s;export{n as default,s as useDashDefaultMountTracker};
+import { useState, useEffect } from "react";
+import { dashStorage } from "dash-utils";
+const useDashDefaultMountTracker = (expectedMounts) => {
+  const [fullyLoaded, setFullyLoaded] = useState(false);
+  useEffect(() => {
+    const currentValue = parseInt(dashStorage.getItem("tmp"), 10) || 0;
+    dashStorage.setItem("tmp", String(currentValue + 1));
+  }, []);
+  useEffect(() => {
+    if (!expectedMounts) {
+      setFullyLoaded(true);
+    } else if (parseInt(dashStorage.getItem("tmp"), 10) >= expectedMounts) {
+      setFullyLoaded(true);
+    }
+  }, [expectedMounts]);
+  return fullyLoaded;
+};
+var useDashDefaultMountTracker_default = useDashDefaultMountTracker;
+export {
+  useDashDefaultMountTracker_default as default,
+  useDashDefaultMountTracker
+};

package/dist/defaults/extensions/hooks/useDashDefaultRoutePath.js

@@ -1 +1,17 @@
-import{useState as u,useEffect as a}from"react";import{DASHAdminSystemConstants as l}from"@dashadmin/dash-constants";const c=(t,e)=>{const[o,n]=u("");return a(()=>{const s=t||e||l.system.URL_PREFIX,r=s.replace(/\/\*$/,"");console.log("ROUTE-BASE-PATH:",r),n(s)},[t,e]),o};var m=c;export{m as default,c as useDashDefaultRoutePath};
+import { useState, useEffect } from "react";
+import { DASHAdminSystemConstants } from "dash-constants";
+const useDashDefaultRoutePath = (appPath, commonAppPath) => {
+  const [routePath, setRoutePath] = useState("");
+  useEffect(() => {
+    const path = appPath || (commonAppPath || DASHAdminSystemConstants.system.URL_PREFIX);
+    const cleanPath = path.replace(/\/\*$/, "");
+    console.log("ROUTE-BASE-PATH:", cleanPath);
+    setRoutePath(path);
+  }, [appPath, commonAppPath]);
+  return routePath;
+};
+var useDashDefaultRoutePath_default = useDashDefaultRoutePath;
+export {
+  useDashDefaultRoutePath_default as default,
+  useDashDefaultRoutePath
+};

package/dist/defaults/extensions/i18n/dashDefaultI18nProvider.js

@@ -1 +1,44 @@
-import{useMemo as i}from"react";import t from"ra-i18n-polyglot";import{dashDefaultTranslations as l,dashDefaultAvailableLocales as r,dashDefaultLocale as n}from"./dashDefaultTranslations";import{dashDefaultTranslations as L,dashDefaultAvailableLocales as g,dashDefaultLocale as b}from"./dashDefaultTranslations";import{loadDashDefaultTranslationsAsync as x,createDashDefaultI18nProviderAsync as T}from"./dashDefaultTranslations";const h=a=>{const e=a.locale||n,o=a.availableLocales||r;return t(s=>l[s]||l.en,e,o)},f=a=>i(()=>{const e=a?.locale||n,o=a?.availableLocales||r;return t(s=>l[s]||l.en,e,o.map(({locale:s,name:c})=>({locale:s,name:c})))},[a?.locale,a?.availableLocales]),m=a=>t(e=>l[e]||l.en,a.settings.locale,a.settings.availableLocales.map(({locale:e,name:o})=>({locale:e,name:o})));var p=f;export{T as createDashDefaultI18nProviderAsync,m as createDashDefaultI18nProviderFromAppState,h as createDashDefaultI18nProviderWithSettings,g as dashDefaultAvailableLocales,b as dashDefaultLocale,L as dashDefaultTranslations,p as default,x as loadDashDefaultTranslationsAsync,f as useDashDefaultI18nProvider};
+import { useMemo } from "react";
+import polyglotI18nProvider from "ra-i18n-polyglot";
+import { dashDefaultTranslations, dashDefaultAvailableLocales, dashDefaultLocale } from "./dashDefaultTranslations";
+import { dashDefaultTranslations as dashDefaultTranslations2, dashDefaultAvailableLocales as dashDefaultAvailableLocales2, dashDefaultLocale as dashDefaultLocale2 } from "./dashDefaultTranslations";
+import { loadDashDefaultTranslationsAsync, createDashDefaultI18nProviderAsync } from "./dashDefaultTranslations";
+const createDashDefaultI18nProviderWithSettings = (settings) => {
+  const locale = settings.locale || dashDefaultLocale;
+  const locales = settings.availableLocales || dashDefaultAvailableLocales;
+  return polyglotI18nProvider(
+    (loc) => dashDefaultTranslations[loc] || dashDefaultTranslations.en,
+    locale,
+    locales
+  );
+};
+const useDashDefaultI18nProvider = (settings) => {
+  return useMemo(() => {
+    const locale = (settings == null ? void 0 : settings.locale) || dashDefaultLocale;
+    const locales = (settings == null ? void 0 : settings.availableLocales) || dashDefaultAvailableLocales;
+    return polyglotI18nProvider(
+      (loc) => dashDefaultTranslations[loc] || dashDefaultTranslations.en,
+      locale,
+      locales.map(({ locale: locale2, name }) => ({ locale: locale2, name }))
+    );
+  }, [settings == null ? void 0 : settings.locale, settings == null ? void 0 : settings.availableLocales]);
+};
+const createDashDefaultI18nProviderFromAppState = (appState) => {
+  return polyglotI18nProvider(
+    (loc) => dashDefaultTranslations[loc] || dashDefaultTranslations.en,
+    appState.settings.locale,
+    appState.settings.availableLocales.map(({ locale, name }) => ({ locale, name }))
+  );
+};
+var dashDefaultI18nProvider_default = useDashDefaultI18nProvider;
+export {
+  createDashDefaultI18nProviderAsync,
+  createDashDefaultI18nProviderFromAppState,
+  createDashDefaultI18nProviderWithSettings,
+  dashDefaultAvailableLocales2 as dashDefaultAvailableLocales,
+  dashDefaultLocale2 as dashDefaultLocale,
+  dashDefaultTranslations2 as dashDefaultTranslations,
+  dashDefaultI18nProvider_default as default,
+  loadDashDefaultTranslationsAsync,
+  useDashDefaultI18nProvider
+};

package/dist/defaults/extensions/i18n/dashDefaultTranslations.js

@@ -1 +1,87 @@
-import o from"ra-i18n-polyglot";import{en as i,es as c}from"@dashadmin/dash-admin/src/providers/i18n/languages";const n={en:{...i},es:{...c}},r=[{locale:"en",name:"English"},{locale:"es",name:"Espa\xF1ol"}],s="en",u=(e=s)=>o(t=>n[t]||n.en,e,r),d=async()=>{try{const[e,t]=await Promise.all([import("@dashadmin/dash-admin").then(a=>a.en),import("@dashadmin/dash-admin").then(a=>a.es)]);return{en:{...e},es:{...t}}}catch(e){return console.error("Failed to load dash default translations:",e),n}},h=async(e=s,t)=>{const a=await d();return o(l=>a[l]||a.en,e,t||r)};var y=n;export{u as createDashDefaultI18nProvider,h as createDashDefaultI18nProviderAsync,r as dashDefaultAvailableLocales,s as dashDefaultLocale,n as dashDefaultTranslations,y as default,d as loadDashDefaultTranslationsAsync};
+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;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import polyglotI18nProvider from "ra-i18n-polyglot";
+import { en, es } from "dash-admin/src/providers/i18n/languages";
+const dashDefaultTranslations = {
+  en: __spreadValues({}, en),
+  es: __spreadValues({}, es)
+};
+const dashDefaultAvailableLocales = [
+  { locale: "en", name: "English" },
+  { locale: "es", name: "Espa\xF1ol" }
+];
+const dashDefaultLocale = "en";
+const createDashDefaultI18nProvider = (locale = dashDefaultLocale) => {
+  return polyglotI18nProvider(
+    (loc) => dashDefaultTranslations[loc] || dashDefaultTranslations.en,
+    locale,
+    dashDefaultAvailableLocales
+  );
+};
+const loadDashDefaultTranslationsAsync = () => __async(null, null, function* () {
+  try {
+    const [enLang, esLang] = yield Promise.all([
+      import("dash-admin").then((module) => module.en),
+      import("dash-admin").then((module) => module.es)
+    ]);
+    return {
+      en: __spreadValues({}, enLang),
+      es: __spreadValues({}, esLang)
+    };
+  } catch (error) {
+    console.error("Failed to load dash default translations:", error);
+    return dashDefaultTranslations;
+  }
+});
+const createDashDefaultI18nProviderAsync = (..._0) => __async(null, [..._0], function* (locale = dashDefaultLocale, locales) {
+  const loadedTranslations = yield loadDashDefaultTranslationsAsync();
+  return polyglotI18nProvider(
+    (loc) => loadedTranslations[loc] || loadedTranslations.en,
+    locale,
+    locales || dashDefaultAvailableLocales
+  );
+});
+var dashDefaultTranslations_default = dashDefaultTranslations;
+export {
+  createDashDefaultI18nProvider,
+  createDashDefaultI18nProviderAsync,
+  dashDefaultAvailableLocales,
+  dashDefaultLocale,
+  dashDefaultTranslations,
+  dashDefaultTranslations_default as default,
+  loadDashDefaultTranslationsAsync
+};

package/dist/defaults/extensions/i18n/index.js

@@ -1 +1,24 @@
-import{dashDefaultTranslations as t,dashDefaultAvailableLocales as r,dashDefaultLocale as s,createDashDefaultI18nProvider as l,loadDashDefaultTranslationsAsync as o,createDashDefaultI18nProviderAsync as D}from"./dashDefaultTranslations";import{useDashDefaultI18nProvider as f,createDashDefaultI18nProviderWithSettings as h,createDashDefaultI18nProviderFromAppState as i}from"./dashDefaultI18nProvider";export{l as createDashDefaultI18nProvider,D as createDashDefaultI18nProviderAsync,i as createDashDefaultI18nProviderFromAppState,h as createDashDefaultI18nProviderWithSettings,r as dashDefaultAvailableLocales,s as dashDefaultLocale,t as dashDefaultTranslations,o as loadDashDefaultTranslationsAsync,f as useDashDefaultI18nProvider};
+import {
+  dashDefaultTranslations,
+  dashDefaultAvailableLocales,
+  dashDefaultLocale,
+  createDashDefaultI18nProvider,
+  loadDashDefaultTranslationsAsync,
+  createDashDefaultI18nProviderAsync
+} from "./dashDefaultTranslations";
+import {
+  useDashDefaultI18nProvider,
+  createDashDefaultI18nProviderWithSettings,
+  createDashDefaultI18nProviderFromAppState
+} from "./dashDefaultI18nProvider";
+export {
+  createDashDefaultI18nProvider,
+  createDashDefaultI18nProviderAsync,
+  createDashDefaultI18nProviderFromAppState,
+  createDashDefaultI18nProviderWithSettings,
+  dashDefaultAvailableLocales,
+  dashDefaultLocale,
+  dashDefaultTranslations,
+  loadDashDefaultTranslationsAsync,
+  useDashDefaultI18nProvider
+};