@dashadmin/dash-boilerplate 1.3.25 → 1.3.28

package/dist/index.cjs

@@ -0,0 +1,1234 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AppWrapperLight: () => AppWrapperLight,
+  CustomErrorBoundary: () => CustomErrorBoundary,
+  DEFAULT_LAYOUT_DIMENSIONS: () => DEFAULT_LAYOUT_DIMENSIONS,
+  DashThemeContext: () => DashThemeContext,
+  DashThemeProviderLight: () => DashThemeProviderLight,
+  DefaultAppLoadErrorFallback: () => DefaultAppLoadErrorFallback,
+  DefaultInitializationErrorFallback: () => DefaultInitializationErrorFallback,
+  GlobalLoaderHtmlMarkup: () => GlobalLoaderHtmlMarkup,
+  GlobalSmallLoader: () => GlobalSmallLoader,
+  I18nBridgeContext: () => I18nBridgeContext,
+  I18nBridgeProviderLight: () => I18nBridgeProviderLight,
+  createDefaultPanelSettings: () => createDefaultPanelSettings,
+  createLazyAppLoader: () => createLazyAppLoader,
+  createSimpleI18nProvider: () => createSimpleI18nProvider,
+  getCssVariableNumber: () => getCssVariableNumber2,
+  getCssVariableString: () => getCssVariableString,
+  getElectronStoreValue: () => getElectronStoreValue,
+  getLayoutDimensionsFromCss: () => getLayoutDimensionsFromCss,
+  initializeThemeEarly: () => initializeThemeEarly,
+  injectCriticalStyles: () => injectCriticalStyles,
+  isElectron: () => isElectron,
+  setElectronStoreValue: () => setElectronStoreValue,
+  syncElectronStore: () => syncElectronStore,
+  syncElectronStoreToLocalStorage: () => syncElectronStoreToLocalStorage,
+  useAppInitialization: () => useAppInitialization,
+  useBridgedChangeLocaleLight: () => useBridgedChangeLocaleLight,
+  useBridgedLocaleLight: () => useBridgedLocaleLight,
+  useBridgedLocalesLight: () => useBridgedLocalesLight,
+  useDashThemeContextLight: () => useDashThemeContextLight,
+  useEarlyThemeInit: () => useEarlyThemeInit,
+  useI18nBridgeLight: () => useI18nBridgeLight,
+  useInitializeReduxFromPersisted: () => useInitializeReduxFromPersisted,
+  useLogoutEventListener: () => useLogoutEventListener,
+  usePathnameTracker: () => usePathnameTracker,
+  usePendingRedirect: () => usePendingRedirect,
+  useTranslateLight: () => useTranslateLight,
+  useUrlLocaleDetection: () => useUrlLocaleDetection
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/i18n/createSimpleI18nProvider.ts
+var getNestedValue = (obj, path) => {
+  return path.split(".").reduce((prev, curr) => prev ? prev[curr] : null, obj);
+};
+var interpolate = (text, options) => {
+  if (!options || !text) return text;
+  return Object.keys(options).reduce((acc, key) => {
+    return acc.replace(new RegExp(`%\\{${key}\\}`, "g"), String(options[key]));
+  }, text);
+};
+var defaultLocales = [
+  { locale: "en", name: "English" },
+  { locale: "es", name: "Espa\xF1ol" }
+];
+var createSimpleI18nProvider = (options) => {
+  const {
+    translations,
+    initialLocale = "es",
+    fallbackLocale = "en",
+    locales = defaultLocales,
+    onLocaleChange
+  } = options;
+  let currentLocale = initialLocale;
+  const translate = (key, interpolationOptions) => {
+    const messages = translations[currentLocale] || translations[fallbackLocale] || {};
+    const text = getNestedValue(messages, key);
+    if (typeof text === "string") {
+      return interpolate(text, interpolationOptions);
+    }
+    if (currentLocale !== fallbackLocale) {
+      const fallbackMessages = translations[fallbackLocale] || {};
+      const fallbackText = getNestedValue(fallbackMessages, key);
+      if (typeof fallbackText === "string") {
+        return interpolate(fallbackText, interpolationOptions);
+      }
+    }
+    return key;
+  };
+  const changeLocale = (newLocale) => __async(null, null, function* () {
+    if (translations[newLocale]) {
+      currentLocale = newLocale;
+      localStorage.setItem("dash-user-locale", newLocale);
+      onLocaleChange == null ? void 0 : onLocaleChange(newLocale);
+      return Promise.resolve();
+    }
+    return Promise.reject(new Error(`Locale '${newLocale}' not found`));
+  });
+  const getLocale = () => currentLocale;
+  const getLocales = () => locales;
+  const getMessages = (locale) => {
+    return translations[locale] || {};
+  };
+  return {
+    translate,
+    changeLocale,
+    getLocale,
+    getLocales,
+    getMessages
+  };
+};
+
+// src/i18n/I18nBridgeProviderLight.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var LOCALE_CHANGE_EVENT = "dash:locale-change";
+var defaultContextValue = {
+  i18nProvider: null,
+  locale: "es",
+  setI18nProvider: () => {
+  },
+  setLocale: () => {
+  }
+};
+var I18nBridgeContext = (0, import_react.createContext)(defaultContextValue);
+var I18nBridgeProviderLight = ({
+  children,
+  defaultLocale = "es"
+}) => {
+  const [i18nProvider, setI18nProviderState] = (0, import_react.useState)(null);
+  const [locale, setLocale] = (0, import_react.useState)(() => {
+    if (typeof window !== "undefined") {
+      return localStorage.getItem("dash-user-locale") || defaultLocale;
+    }
+    return defaultLocale;
+  });
+  const setI18nProvider = (0, import_react.useCallback)((provider) => __async(null, null, function* () {
+    var _a, _b;
+    console.log("\u{1F310} I18nBridgeProviderLight: Setting bridged i18nProvider", {
+      providerLocale: (_a = provider == null ? void 0 : provider.getLocale) == null ? void 0 : _a.call(provider),
+      desiredLocale: locale
+    });
+    setI18nProviderState(provider);
+    const providerLocale = (_b = provider == null ? void 0 : provider.getLocale) == null ? void 0 : _b.call(provider);
+    if (providerLocale && providerLocale !== locale && (provider == null ? void 0 : provider.changeLocale)) {
+      console.log(`\u{1F310} I18nBridgeProviderLight: Provider locale (${providerLocale}) differs from desired (${locale}), switching...`);
+      try {
+        yield provider.changeLocale(locale);
+        console.log(`\u{1F310} I18nBridgeProviderLight: Successfully switched provider to ${locale}`);
+      } catch (e) {
+        console.warn("\u{1F310} I18nBridgeProviderLight: Failed to switch provider locale:", e);
+      }
+    } else if (provider == null ? void 0 : provider.getLocale) {
+      setLocale(provider.getLocale());
+    }
+  }), [locale]);
+  (0, import_react.useEffect)(() => {
+    const handleLocaleChange = (event) => __async(null, null, function* () {
+      var _a;
+      const customEvent = event;
+      const newLocale = (_a = customEvent.detail) == null ? void 0 : _a.locale;
+      if (newLocale && newLocale !== locale) {
+        console.log("\u{1F310} I18nBridgeProviderLight: Received locale change event:", newLocale);
+        if (i18nProvider == null ? void 0 : i18nProvider.changeLocale) {
+          try {
+            yield i18nProvider.changeLocale(newLocale);
+          } catch (e) {
+            console.warn("Failed to change provider locale:", e);
+          }
+        }
+        setLocale(newLocale);
+      }
+    });
+    window.addEventListener(LOCALE_CHANGE_EVENT, handleLocaleChange);
+    return () => {
+      window.removeEventListener(LOCALE_CHANGE_EVENT, handleLocaleChange);
+    };
+  }, [i18nProvider, locale]);
+  const contextValue = (0, import_react.useMemo)(() => ({
+    i18nProvider,
+    locale,
+    setI18nProvider,
+    setLocale
+  }), [i18nProvider, locale, setI18nProvider]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(I18nBridgeContext.Provider, { value: contextValue, children });
+};
+var useI18nBridgeLight = () => {
+  const context = (0, import_react.useContext)(I18nBridgeContext);
+  return context;
+};
+var useBridgedLocalesLight = () => {
+  const { i18nProvider } = useI18nBridgeLight();
+  const locales = (0, import_react.useMemo)(() => {
+    if (!(i18nProvider == null ? void 0 : i18nProvider.getLocales)) {
+      return [];
+    }
+    return i18nProvider.getLocales();
+  }, [i18nProvider]);
+  return locales;
+};
+var useBridgedChangeLocaleLight = () => {
+  const { i18nProvider, setLocale } = useI18nBridgeLight();
+  const changeLocale = (0, import_react.useCallback)((locale) => __async(null, null, function* () {
+    if (i18nProvider == null ? void 0 : i18nProvider.changeLocale) {
+      yield i18nProvider.changeLocale(locale);
+      setLocale(locale);
+    }
+  }), [i18nProvider, setLocale]);
+  return changeLocale;
+};
+var useBridgedLocaleLight = () => {
+  const { locale } = useI18nBridgeLight();
+  return locale;
+};
+var useTranslateLight = () => {
+  const { i18nProvider } = useI18nBridgeLight();
+  const translate = (0, import_react.useCallback)((key, options) => {
+    if (i18nProvider == null ? void 0 : i18nProvider.translate) {
+      return i18nProvider.translate(key, options);
+    }
+    return key;
+  }, [i18nProvider]);
+  return translate;
+};
+
+// src/components/GlobalSmallLoader.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var loaderSvgMarkup = `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="32px" height="32px" style="shape-rendering:geometricPrecision; text-rendering:geometricPrecision; image-rendering:optimizeQuality; fill-rule:evenodd; clip-rule:evenodd" viewBox="0 0 16 16"><g><path style="opacity:1" fill="#FFFFFF" d="M11.506 12.388q0.306 0.011 0.617 0.008v1.281h-0.89a2 2 0 0 1 -0.898 -0.215 1.24 1.24 0 0 1 -0.629 -0.761 2.5 2.5 0 0 1 -0.094 -0.554q-0.006 -1.082 -0.004 -2.163h-0.609q0.002 -0.398 -0.004 -0.796a616 616 0 0 0 -1.676 2.023 657 657 0 0 0 2.069 2.46q-0.935 0.012 -1.874 0.008L6.003 11.61q-0.006 1.035 -0.004 2.069H4.485q0.004 -2.983 -0.008 -5.966 -0.661 -0.21 -0.863 -0.875a2 2 0 0 1 -0.039 -0.258q-0.008 -2.108 0 -4.217 0.12 -0.356 0.48 -0.246 0.153 0.079 0.191 0.246l0.008 3.272q0.05 0.116 0.168 0.066 0.035 -0.027 0.051 -0.066l0.008 -3.264q0.095 -0.329 0.433 -0.269 0.191 0.059 0.238 0.254l0.008 3.272q0.065 0.14 0.195 0.055l0.023 -0.039 0.008 -3.264q0.086 -0.321 0.418 -0.285 0.197 0.057 0.254 0.254a352 352 0 0 1 0.016 3.295q0.062 0.109 0.176 0.051 0.029 -0.028 0.043 -0.066l0.008 -3.28q0.045 -0.17 0.207 -0.238 0.25 -0.074 0.41 0.129a0.5 0.5 0 0 1 0.047 0.109q0.014 1.063 0.012 2.128 0.002 1.088 -0.012 2.175 -0.137 0.844 -0.96 1.078a301 301 0 0 0 0 3.006q0.753 -1.005 1.503 -2.011 1.05 -0.006 2.101 -0.004 0.002 -0.519 -0.004 -1.039a1.82 1.82 0 0 1 -1.281 -1.101q-0.197 -0.504 -0.211 -1.046a4.7 4.7 0 0 1 0.383 -2.03q0.242 -0.547 0.668 -0.964 0.395 -0.364 0.929 -0.445 0.695 -0.056 1.218 0.398 0.476 0.438 0.73 1.035 0.513 1.212 0.32 2.514a2.26 2.26 0 0 1 -0.484 1.07 1.75 1.75 0 0 1 -0.754 0.5v1.109h0.992v1.265h-0.992q-0.002 1.042 0.004 2.085 0.05 0.323 0.379 0.32"/></g></svg>`;
+var KTIcon = () => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { dangerouslySetInnerHTML: { __html: loaderSvgMarkup } });
+var GlobalSmallLoader = ({
+  message,
+  showMessage = false
+}) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "initial-loader", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "initial-loader-spinner" }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "initial-loader-icon", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(KTIcon, {}) })
+  ] }),
+  showMessage && message && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "initial-loader-text", children: message })
+] });
+var GlobalLoaderHtmlMarkup = `<div class="initial-loader">
+    <div class="initial-loader-spinner">
+        <span class="initial-loader-icon">
+        ${loaderSvgMarkup}
+        </span>
+    </div>
+    <div class="initial-loader-text"></div>
+</div>`;
+var injectCriticalStyles = () => {
+  if (typeof document === "undefined") return;
+  if (document.getElementById("critical-loading-styles")) return;
+  const style = document.createElement("style");
+  style.id = "critical-loading-styles";
+  style.textContent = `
+        .initial-loader {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            color: var(--text-color, #fff);
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            z-index: 9999;
+        }
+        .initial-loader-spinner {
+            width: 40px;
+            height: 40px;
+            border: 3px solid rgba(255,255,255,0.1);
+            border-top-color: var(--primary-color, #3f51b5);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            position: relative;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        .initial-loader-icon {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            width: 16px;
+            height: 16px;
+            transform: translate(-50%, -50%);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            pointer-events: none;
+        }
+        .initial-loader-text {
+            margin-top: 16px;
+            font-size: 14px;
+            opacity: 0.7;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+    `;
+  document.head.appendChild(style);
+};
+
+// src/components/CustomErrorBoundary.tsx
+var import_react2 = __toESM(require("react"), 1);
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var CustomErrorBoundary = class extends import_react2.default.Component {
+  constructor(props) {
+    super(props);
+    __publicField(this, "handleReload", () => {
+      window.location.reload();
+    });
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    var _a, _b;
+    console.error("CustomErrorBoundary caught error:", error, errorInfo);
+    (_b = (_a = this.props).onError) == null ? void 0 : _b.call(_a, error, errorInfo);
+  }
+  render() {
+    var _a;
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+        "div",
+        {
+          style: {
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            height: "100vh",
+            backgroundColor: "var(--bodybg-primary, #121212)",
+            color: "var(--text-color, #ffffff)",
+            flexDirection: "column",
+            gap: "20px"
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h2", { children: "Something went wrong" }),
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: { opacity: 0.8 }, children: (_a = this.state.error) == null ? void 0 : _a.message }),
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+              "button",
+              {
+                onClick: this.handleReload,
+                style: {
+                  padding: "10px 20px",
+                  backgroundColor: "var(--primary-color, #007bff)",
+                  color: "white",
+                  border: "none",
+                  borderRadius: "4px",
+                  cursor: "pointer",
+                  fontSize: "14px",
+                  fontWeight: 500
+                },
+                children: "Reload Page"
+              }
+            )
+          ]
+        }
+      );
+    }
+    return this.props.children;
+  }
+};
+
+// src/components/AppWrapperLight.tsx
+var import_react3 = __toESM(require("react"), 1);
+var import_react_error_boundary = require("react-error-boundary");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var ErrorFallback = ({ error, resetErrorBoundary }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+  "div",
+  {
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      height: "100vh",
+      gap: "16px",
+      color: "var(--text-color)",
+      backgroundColor: "var(--bodybg-primary)"
+    },
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h1", { style: { margin: 0, fontSize: "1.5rem" }, children: "Something went wrong" }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { style: { margin: 0, opacity: 0.8 }, children: (error == null ? void 0 : error.message) || "Unknown error" }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        "button",
+        {
+          onClick: resetErrorBoundary,
+          style: {
+            padding: "8px 24px",
+            backgroundColor: "var(--primary-color)",
+            color: "var(--primary-contrast)",
+            border: "none",
+            borderRadius: "4px",
+            cursor: "pointer",
+            fontSize: "14px",
+            fontWeight: 500
+          },
+          children: "Try Again"
+        }
+      )
+    ]
+  }
+);
+var SimpleLoader = () => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+  "div",
+  {
+    style: {
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center",
+      height: "100vh",
+      backgroundColor: "var(--bodybg-primary)"
+    },
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        "div",
+        {
+          className: "loading-spinner",
+          style: {
+            width: "40px",
+            height: "40px",
+            border: "3px solid rgba(255,255,255,0.1)",
+            borderTopColor: "var(--primary-color)",
+            borderRadius: "50%",
+            animation: "spin 1s linear infinite"
+          }
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("style", { children: `
+            @keyframes spin {
+                to { transform: rotate(360deg); }
+            }
+        ` })
+    ]
+  }
+);
+var AppWrapperLight = ({
+  children,
+  onReset,
+  showSplash = true
+}) => {
+  const [isPending, startTransition] = (0, import_react3.useTransition)();
+  const [isInitialRender, setIsInitialRender] = (0, import_react3.useState)(true);
+  import_react3.default.useEffect(() => {
+    startTransition(() => {
+      setIsInitialRender(false);
+    });
+  }, []);
+  const handleReset = () => {
+    if (onReset) {
+      onReset();
+    } else {
+      window.location.reload();
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_error_boundary.ErrorBoundary, { FallbackComponent: ErrorFallback, onReset: handleReset, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react3.Suspense, { fallback: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SimpleLoader, {}), children }) }),
+    showSplash && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: !isPending && !isInitialRender ? "dash-splash fade-out" : "dash-splash" })
+  ] });
+};
+
+// src/components/DefaultFallbacks.tsx
+var import_react4 = __toESM(require("react"), 1);
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var defaultContainerStyle = {
+  display: "flex",
+  flexDirection: "column",
+  justifyContent: "center",
+  alignItems: "center",
+  minHeight: "100vh",
+  gap: "16px",
+  color: "var(--text-color, #333)",
+  backgroundColor: "var(--background-color, #fff)"
+};
+var defaultErrorMessageStyle = {
+  margin: 0,
+  fontSize: "1.25rem",
+  fontWeight: 500,
+  color: "#f44336"
+};
+var defaultButtonStyle = {
+  marginTop: "16px",
+  padding: "8px 16px",
+  backgroundColor: "#1976d2",
+  color: "white",
+  border: "none",
+  borderRadius: "4px",
+  cursor: "pointer",
+  fontSize: "14px",
+  fontWeight: 500
+};
+var DefaultInitializationErrorFallback = ({
+  error,
+  message = "Failed to initialize application",
+  onRetry = () => window.location.reload(),
+  retryLabel = "Retry",
+  containerStyle,
+  messageStyle,
+  buttonStyle
+}) => {
+  const errorMessage = error instanceof Error ? error.message : error || message;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: __spreadValues(__spreadValues({}, defaultContainerStyle), containerStyle), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("h6", { style: __spreadValues(__spreadValues({}, defaultErrorMessageStyle), messageStyle), children: errorMessage }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "button",
+      {
+        onClick: onRetry,
+        style: __spreadValues(__spreadValues({}, defaultButtonStyle), buttonStyle),
+        children: retryLabel
+      }
+    )
+  ] });
+};
+var DefaultAppLoadErrorFallback = ({
+  message = "Failed to load application",
+  onRetry = () => window.location.reload(),
+  retryLabel = "Retry",
+  containerStyle,
+  messageStyle,
+  buttonStyle
+}) => {
+  const appLoadContainerStyle = {
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "center",
+    alignItems: "center",
+    height: "100vh",
+    color: "#000000",
+    gap: "12px"
+  };
+  const appLoadButtonStyle = {
+    padding: "8px 24px",
+    backgroundColor: "#57005aff",
+    color: "#fff",
+    border: "none",
+    borderRadius: "4px",
+    cursor: "pointer"
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: __spreadValues(__spreadValues({}, appLoadContainerStyle), containerStyle), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("h1", { style: messageStyle, children: message }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "button",
+      {
+        onClick: onRetry,
+        style: __spreadValues(__spreadValues({}, appLoadButtonStyle), buttonStyle),
+        children: retryLabel
+      }
+    )
+  ] });
+};
+var createLazyAppLoader = ({
+  importFn,
+  delay = 100,
+  ErrorFallback: ErrorFallback2 = DefaultAppLoadErrorFallback,
+  errorMessage = "Failed to load application"
+}) => {
+  return import_react4.default.lazy(() => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        importFn().then((mod) => {
+          resolve({ default: mod.default });
+        }).catch((error) => {
+          console.error("Failed to load application:", error);
+          resolve({
+            default: () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+              ErrorFallback2,
+              {
+                error,
+                message: errorMessage
+              }
+            )
+          });
+        });
+      }, delay);
+    });
+  });
+};
+
+// src/theme/DashThemeProviderLight.tsx
+var import_react5 = require("react");
+var import_CssBaseline = __toESM(require("@mui/material/CssBaseline"), 1);
+var import_material = require("@mui/material");
+var import_dash_utils = require("dash-utils");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var getCssVariableNumber = (varName, defaultValue) => {
+  if (typeof document === "undefined") return defaultValue;
+  const value = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+};
+var getCssVariable = (varName) => {
+  if (typeof document === "undefined") return null;
+  const value = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+  return value || null;
+};
+var getThemeColors = (mode) => {
+  const colors = {};
+  const suffix = `--${mode}`;
+  const primaryColor = getCssVariable(`--primary-color${suffix}`);
+  if (primaryColor) colors.primaryColor = primaryColor;
+  const primaryContrast = getCssVariable(`--primary-contrast${suffix}`);
+  if (primaryContrast) colors.primaryContrast = primaryContrast;
+  const secondaryColor = getCssVariable(`--secondary-color${suffix}`);
+  if (secondaryColor) colors.secondaryColor = secondaryColor;
+  const bodyBgPrimary = getCssVariable(`--bodybg-primary${suffix}`);
+  if (bodyBgPrimary) colors.bodyBgPrimary = bodyBgPrimary;
+  const bodyBgSecondary = getCssVariable(`--bodybg-secondary${suffix}`);
+  if (bodyBgSecondary) colors.bodyBgSecondary = bodyBgSecondary;
+  const componentBg = getCssVariable(`--component-bg${suffix}`);
+  if (componentBg) colors.componentBg = componentBg;
+  const textColor = getCssVariable(`--text-color${suffix}`);
+  if (textColor) colors.textColor = textColor;
+  const textContrast = getCssVariable(`--text-contrast${suffix}`);
+  if (textContrast) colors.textContrast = textContrast;
+  const headingColor = getCssVariable(`--heading-color${suffix}`);
+  if (headingColor) colors.headingColor = headingColor;
+  const linkColor = getCssVariable(`--link-color${suffix}`);
+  if (linkColor) colors.linkColor = linkColor;
+  const borderColor = getCssVariable(`--border-color${suffix}`);
+  if (borderColor) colors.borderColor = borderColor;
+  return colors;
+};
+var createMinimalTheme = (mode, extendedOptions) => {
+  const colors = getThemeColors(mode);
+  const fontSizeBase = getCssVariableNumber("--font-size-base", 14);
+  const borderRadiusBase = getCssVariableNumber("--border-radius-base", 6);
+  const _a = extendedOptions || {}, { palette: _p, colorSchemes: _cs, defaultColorScheme: _dcs } = _a, safeExtendedOptions = __objRest(_a, ["palette", "colorSchemes", "defaultColorScheme"]);
+  return (0, import_material.createTheme)(__spreadValues({
+    breakpoints: {
+      keys: ["xs", "sm", "md", "lg", "xl"],
+      values: { xs: 0, sm: 600, md: 900, lg: 1200, xl: 1536 }
+    },
+    palette: {
+      mode,
+      primary: {
+        main: colors.primaryColor,
+        contrastText: colors.primaryContrast
+      },
+      secondary: {
+        main: colors.secondaryColor
+      },
+      background: {
+        default: colors.bodyBgPrimary,
+        paper: colors.componentBg
+      },
+      text: {
+        primary: colors.textColor,
+        secondary: colors.textContrast
+      },
+      divider: colors.borderColor
+    },
+    typography: {
+      fontFamily: '"Montserrat", "Roboto", "Helvetica", "Arial", sans-serif',
+      fontSize: fontSizeBase
+    },
+    shape: {
+      borderRadius: borderRadiusBase
+    },
+    components: {
+      MuiButton: {
+        styleOverrides: {
+          root: {
+            transition: "all 0.2s ease-in-out",
+            textTransform: "none"
+          }
+        }
+      },
+      MuiCssBaseline: {
+        styleOverrides: {
+          body: {
+            backgroundColor: colors.bodyBgPrimary,
+            color: colors.textColor
+          }
+        }
+      },
+      MuiPaper: {
+        styleOverrides: {
+          root: {
+            backgroundImage: "none"
+          }
+        }
+      }
+    }
+  }, safeExtendedOptions));
+};
+var DashThemeContext = (0, import_react5.createContext)(null);
+var useDashThemeContextLight = () => {
+  const context = (0, import_react5.useContext)(DashThemeContext);
+  if (!context) {
+    throw new Error("useDashThemeContextLight must be used within a DashThemeProviderLight");
+  }
+  return context;
+};
+var DashThemeProviderLight = ({
+  children,
+  extendedOptions,
+  defaultMode
+}) => {
+  const [currentMode, setCurrentMode] = (0, import_react5.useState)(() => {
+    if (typeof document === "undefined") return defaultMode || "dark";
+    const stored = document.documentElement.getAttribute("data-theme");
+    return stored === "light" || stored === "dark" ? stored : defaultMode || "dark";
+  });
+  const [themeVersion, setThemeVersion] = (0, import_react5.useState)(0);
+  const theme = (0, import_react5.useMemo)(() => {
+    return createMinimalTheme(currentMode, extendedOptions);
+  }, [currentMode, extendedOptions, themeVersion]);
+  const setMode = (mode) => {
+    setCurrentMode(mode);
+    if (typeof document !== "undefined") {
+      document.documentElement.setAttribute("data-theme", mode);
+      localStorage.setItem("theme", mode);
+      (0, import_dash_utils.updateDomCssVariables)(mode);
+    }
+  };
+  const toggleMode = () => {
+    setMode(currentMode === "dark" ? "light" : "dark");
+  };
+  const refreshTheme = () => {
+    setThemeVersion((v) => v + 1);
+  };
+  (0, import_react5.useEffect)(() => {
+    if (typeof document === "undefined") return;
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        if (mutation.type === "attributes" && mutation.attributeName === "data-theme") {
+          const newMode = document.documentElement.getAttribute("data-theme");
+          if (newMode === "light" || newMode === "dark") {
+            if (newMode !== currentMode) {
+              setCurrentMode(newMode);
+            }
+          }
+        }
+      });
+    });
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["data-theme"]
+    });
+    return () => observer.disconnect();
+  }, [currentMode]);
+  (0, import_react5.useEffect)(() => {
+    if (typeof document === "undefined") return;
+    (0, import_dash_utils.updateDomCssVariables)(currentMode);
+  }, [currentMode]);
+  (0, import_react5.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const handler = () => {
+      console.log("DashThemeProviderLight: Refreshing theme from CSS variables");
+      refreshTheme();
+    };
+    window.addEventListener("DASHTRefreshTheme", handler);
+    return () => window.removeEventListener("DASHTRefreshTheme", handler);
+  }, []);
+  const contextValue = (0, import_react5.useMemo)(
+    () => ({
+      theme,
+      currentMode,
+      setMode,
+      toggleMode,
+      refreshTheme
+    }),
+    [theme, currentMode]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_material.ThemeProvider, { theme, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_CssBaseline.default, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DashThemeContext.Provider, { value: contextValue, children })
+  ] });
+};
+
+// src/utils/DashBootstrapUtils.ts
+var import_react6 = require("react");
+var import_react_redux = require("react-redux");
+var import_dash_auth = require("dash-auth");
+var import_dash_admin_state = require("dash-admin-state");
+var import_Auth = require("dash-admin-state/src/redux/reducers/Auth");
+var import_DASHAuthenticationService = __toESM(require("dash-admin/src/contexts/auth/DASHAuthenticationService"), 1);
+var import_dash_utils2 = require("dash-utils");
+var useInitializeReduxFromPersisted = (currentAuthState) => {
+  const dispatch = (0, import_react_redux.useDispatch)();
+  (0, import_react6.useEffect)(() => {
+    const initializeReduxFromPersisted = () => {
+      console.log("\u{1F50D} Bootstrap: Checking for persisted auth data...");
+      const storedUser = import_dash_auth.AuthPersistenceService.getUser();
+      const storedToken = import_dash_auth.AuthPersistenceService.getToken();
+      const isAuthenticated = JSON.parse(import_dash_utils2.dashStorage.getItem("authenticated") || "false");
+      const persistedAuth = import_dash_auth.AuthPersistenceService.getAuth();
+      console.log("\u{1F50D} Bootstrap: Persisted data check:", {
+        hasStoredUser: !!storedUser,
+        hasStoredToken: !!storedToken,
+        isAuthenticated,
+        hasPersistedAuth: !!persistedAuth,
+        currentReduxAuth: currentAuthState
+      });
+      if (isAuthenticated && storedUser && storedToken && !currentAuthState) {
+        console.log("\u{1F504} Bootstrap: Restoring auth session to Redux from localStorage");
+        let userObject = storedUser;
+        if (typeof storedUser === "string") {
+          console.error("\u274C Bootstrap: Stored user is string, this should not happen");
+          try {
+            userObject = JSON.parse(storedUser);
+          } catch (e) {
+            console.error("\u274C Bootstrap: Cannot parse user string, clearing auth data");
+            import_dash_auth.AuthPersistenceService.clearAuth();
+            return;
+          }
+        }
+        dispatch(
+          import_dash_admin_state.DASH_REDUX_ACTIONS.updateAuth(import_Auth.ACTION_UPDATE_AUTH, {
+            user: userObject,
+            authenticated: true,
+            auth: (persistedAuth == null ? void 0 : persistedAuth.auth) || null
+          })
+        );
+        console.log("\u2705 Bootstrap: Redux state restored from persisted data");
+      }
+    };
+    initializeReduxFromPersisted();
+  }, [dispatch, currentAuthState]);
+};
+var useLogoutEventListener = () => {
+  const dispatch = (0, import_react_redux.useDispatch)();
+  (0, import_react6.useEffect)(() => {
+    const handleLogoutEvent = (event) => {
+      console.log("\u{1F510} Bootstrap: Received logout event", event.detail);
+      dispatch(
+        import_dash_admin_state.DASH_REDUX_ACTIONS.updateAuth(import_Auth.ACTION_UPDATE_AUTH, {
+          user: null,
+          authenticated: false,
+          auth: null
+        })
+      );
+      import_dash_auth.AuthPersistenceService.clearAuth();
+      localStorage.clear();
+    };
+    window.addEventListener("auth:logout", handleLogoutEvent);
+    return () => {
+      window.removeEventListener("auth:logout", handleLogoutEvent);
+    };
+  }, [dispatch]);
+};
+var useAppInitialization = () => {
+  const [isLoading, setIsLoading] = (0, import_react6.useState)(true);
+  const [initializationError, setInitializationError] = (0, import_react6.useState)(null);
+  const dispatch = (0, import_react_redux.useDispatch)();
+  (0, import_react6.useEffect)(() => {
+    const initializeApp = () => __async(null, null, function* () {
+      var _a, _b;
+      try {
+        console.log("\u{1F680} Bootstrap: Starting app initialization...");
+        yield (0, import_dash_auth.syncDeviceStoreToLocalStorage)();
+        const initResult = yield import_DASHAuthenticationService.default.initializeApp(true);
+        console.log("\u{1F50D} Bootstrap: Initialization result:", initResult);
+        if (initResult.success) {
+          console.log("\u2705 Bootstrap: Auto-login successful");
+          dispatch(
+            import_dash_admin_state.DASH_REDUX_ACTIONS.updateAuth(import_Auth.ACTION_UPDATE_AUTH, {
+              user: initResult.user,
+              authenticated: true,
+              auth: initResult.auth || null
+            })
+          );
+          (_b = window.DashIPCService) == null ? void 0 : _b.speak(`${(_a = initResult.user) == null ? void 0 : _a.name}, Bienvenido!`);
+          yield (0, import_dash_auth.syncLocalStorageToDeviceStore)();
+          setInitializationError(null);
+          if (initResult.redirectAfterLogin) {
+            console.log("\u{1F504} Bootstrap: Emitting auth:redirect event", initResult.redirectAfterLogin);
+            const event = new CustomEvent("auth:redirect", {
+              detail: { to: initResult.redirectAfterLogin }
+            });
+            window.dispatchEvent(event);
+          }
+        } else {
+          console.log("\u2139\uFE0F Bootstrap: No valid authentication found");
+          const authData = import_dash_auth.AuthPersistenceService.getAuth();
+          if (authData && authData.auth) {
+            console.log("\u{1F504} Bootstrap: Found persisted auth data, attempting token initialization...");
+            try {
+              const tokenInitResult = yield import_DASHAuthenticationService.default.initializeFromToken();
+              if (tokenInitResult.success) {
+                console.log("\u2705 Bootstrap: Token initialization successful");
+                dispatch(
+                  import_dash_admin_state.DASH_REDUX_ACTIONS.updateAuth(import_Auth.ACTION_UPDATE_AUTH, {
+                    user: tokenInitResult.user,
+                    authenticated: true,
+                    auth: tokenInitResult.auth || null
+                  })
+                );
+                yield (0, import_dash_auth.syncLocalStorageToDeviceStore)();
+                setInitializationError(null);
+                if (tokenInitResult.redirectAfterLogin) {
+                  console.log(
+                    "\u{1F504} Bootstrap: Emitting auth:redirect event",
+                    tokenInitResult.redirectAfterLogin
+                  );
+                  const event = new CustomEvent("auth:redirect", {
+                    detail: { to: tokenInitResult.redirectAfterLogin }
+                  });
+                  window.dispatchEvent(event);
+                }
+              } else {
+                console.log("\u274C Bootstrap: Token initialization failed:", tokenInitResult.error);
+                setInitializationError(null);
+                import_dash_auth.AuthPersistenceService.clearAuth();
+              }
+            } catch (error) {
+              console.error("\u274C Bootstrap: Token initialization error:", error);
+              setInitializationError(null);
+              import_dash_auth.AuthPersistenceService.clearAuth();
+            }
+          } else {
+            console.log("\u2139\uFE0F Bootstrap: No persisted auth data found");
+            import_dash_auth.AuthPersistenceService.clearAuth();
+          }
+        }
+      } catch (error) {
+        console.error("\u274C Bootstrap: App initialization failed:", error);
+        setInitializationError("Failed to initialize application");
+      } finally {
+        setIsLoading(false);
+      }
+    });
+    if (isLoading) {
+      initializeApp();
+    }
+  }, [dispatch, isLoading]);
+  return { isLoading, initializationError };
+};
+var usePendingRedirect = () => {
+  (0, import_react6.useEffect)(() => {
+    const searchParams = new URLSearchParams(window.location.search);
+    const redirectTo = searchParams.get("redirect");
+    if (redirectTo && redirectTo !== "/login") {
+      console.log("\u2139\uFE0F RedirectTO: Setting redirect to by searchParams to:", redirectTo);
+      import_DASHAuthenticationService.default.setPendingRedirect(redirectTo);
+    }
+  }, []);
+};
+var LOCALE_CHANGE_EVENT2 = "dash:locale-change";
+var useUrlLocaleDetection = (availableLocales = ["es", "en"], defaultLocale = "es") => {
+  const dispatch = (0, import_react_redux.useDispatch)();
+  (0, import_react6.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const searchParams = new URLSearchParams(window.location.search);
+    const langParam = searchParams.get("lang");
+    const storedLocale = localStorage.getItem("dash-user-locale");
+    let targetLocale = defaultLocale;
+    if (langParam && availableLocales.includes(langParam)) {
+      targetLocale = langParam;
+    } else if (storedLocale && availableLocales.includes(storedLocale)) {
+      targetLocale = storedLocale;
+    }
+    const isNewLocale = storedLocale !== targetLocale;
+    if (isNewLocale) {
+      console.log(`\u{1F310} Bootstrap: Locale change detected: ${storedLocale} -> ${targetLocale}`);
+      localStorage.setItem("dash-user-locale", targetLocale);
+    } else {
+      console.log(`\u{1F310} Bootstrap: Initializing locale from storage: ${targetLocale}`);
+    }
+    console.log(`\u{1F310} Bootstrap: Dispatching locale to Redux: ${targetLocale}`);
+    dispatch(import_dash_admin_state.DASH_REDUX_ACTIONS.switchLanguage(targetLocale));
+    console.log(`\u{1F310} Bootstrap: Emitting locale change event: ${targetLocale}`);
+    window.dispatchEvent(new CustomEvent(LOCALE_CHANGE_EVENT2, {
+      detail: { locale: targetLocale }
+    }));
+  }, [dispatch, availableLocales, defaultLocale]);
+};
+var usePathnameTracker = () => {
+  const [pathname, setPathname] = (0, import_react6.useState)(
+    typeof window !== "undefined" ? window.location.pathname : "/"
+  );
+  (0, import_react6.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const handleUrlChange = () => {
+      const newPathname = window.location.pathname;
+      if (newPathname !== pathname) {
+        console.log("\u{1F50D} Bootstrap: URL changed from", pathname, "to", newPathname);
+        setPathname(newPathname);
+      }
+    };
+    window.addEventListener("popstate", handleUrlChange);
+    return () => window.removeEventListener("popstate", handleUrlChange);
+  }, [pathname]);
+  return pathname;
+};
+var useEarlyThemeInit = (defaultTheme = "dark") => {
+  (0, import_react6.useEffect)(() => {
+    if (typeof document === "undefined") return;
+    const stored = localStorage.getItem("theme");
+    const theme = stored === "light" || stored === "dark" ? stored : defaultTheme;
+    document.documentElement.setAttribute("data-theme", theme);
+    if (!stored) {
+      localStorage.setItem("theme", theme);
+    }
+  }, [defaultTheme]);
+};
+var initializeThemeEarly = (defaultTheme) => {
+  if (typeof document === "undefined" || typeof localStorage === "undefined") return;
+  const stored = localStorage.getItem("theme");
+  const theme = stored === "light" || stored === "dark" ? stored : defaultTheme;
+  document.documentElement.setAttribute("data-theme", theme);
+  if (!stored) {
+    localStorage.setItem("theme", theme);
+  }
+  try {
+    (0, import_dash_utils2.updateDomCssVariables)(theme);
+    console.log("\u{1F3A8} Bootstrap: Initialized theme variables for:", theme);
+  } catch (error) {
+    console.warn("Failed to initialize theme variables:", error);
+  }
+};
+var syncElectronStore = () => __async(null, null, function* () {
+  if (typeof window === "undefined") return;
+  const electronStore = window.electronStore;
+  if (electronStore) {
+    const all = yield electronStore.syncToLocalStorage();
+    Object.entries(all).forEach(([key, value]) => {
+      window.localStorage.setItem(key, JSON.stringify(value));
+    });
+  }
+});
+
+// src/utils/electronStore.ts
+var syncElectronStoreToLocalStorage = () => __async(null, null, function* () {
+  if (typeof window === "undefined") return;
+  if (window.electronStore) {
+    try {
+      const all = yield window.electronStore.syncToLocalStorage();
+      Object.entries(all).forEach(([key, value]) => {
+        window.localStorage.setItem(key, JSON.stringify(value));
+      });
+      console.log("\u2705 Electron store synced to localStorage");
+    } catch (error) {
+      console.error("\u274C Failed to sync Electron store:", error);
+    }
+  }
+});
+var isElectron = () => {
+  return typeof window !== "undefined" && !!window.electronStore;
+};
+var getElectronStoreValue = (key, defaultValue) => __async(null, null, function* () {
+  if (typeof window === "undefined") return defaultValue;
+  if (window.electronStore) {
+    try {
+      return yield window.electronStore.get(key);
+    } catch (e) {
+      return defaultValue;
+    }
+  }
+  const stored = localStorage.getItem(key);
+  if (stored) {
+    try {
+      return JSON.parse(stored);
+    } catch (e) {
+      return stored;
+    }
+  }
+  return defaultValue;
+});
+var setElectronStoreValue = (key, value) => __async(null, null, function* () {
+  if (typeof window === "undefined") return;
+  if (window.electronStore) {
+    try {
+      yield window.electronStore.set(key, value);
+    } catch (error) {
+      console.error("Failed to set Electron store value:", error);
+    }
+  }
+  localStorage.setItem(key, JSON.stringify(value));
+});
+
+// src/utils/cssVariables.ts
+var getCssVariableNumber2 = (varName, defaultValue) => {
+  if (typeof document === "undefined") return defaultValue;
+  const value = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+};
+var getCssVariableString = (varName, defaultValue = "") => {
+  if (typeof document === "undefined") return defaultValue;
+  const value = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+  return value || defaultValue;
+};
+var DEFAULT_LAYOUT_DIMENSIONS = {
+  sidebarLargeWidth: 255,
+  sidebarSmallWidth: 64,
+  sidebarHorizontalHeight: 120,
+  logoVerticalMaxWidth: 130,
+  logoVerticalMaxHeight: 130,
+  logoHorizontalMaxWidth: 200,
+  logoHorizontalMaxHeight: 60
+};
+var getLayoutDimensionsFromCss = () => {
+  return {
+    sidebarLargeWidth: getCssVariableNumber2("--sidebar-large-width", DEFAULT_LAYOUT_DIMENSIONS.sidebarLargeWidth),
+    sidebarSmallWidth: getCssVariableNumber2("--sidebar-small-width", DEFAULT_LAYOUT_DIMENSIONS.sidebarSmallWidth),
+    sidebarHorizontalHeight: getCssVariableNumber2("--sidebar-horizontal-height", DEFAULT_LAYOUT_DIMENSIONS.sidebarHorizontalHeight),
+    logoVerticalMaxWidth: getCssVariableNumber2("--logo-vertical-max-width", DEFAULT_LAYOUT_DIMENSIONS.logoVerticalMaxWidth),
+    logoVerticalMaxHeight: getCssVariableNumber2("--logo-vertical-max-height", DEFAULT_LAYOUT_DIMENSIONS.logoVerticalMaxHeight),
+    logoHorizontalMaxWidth: getCssVariableNumber2("--logo-horizontal-max-width", DEFAULT_LAYOUT_DIMENSIONS.logoHorizontalMaxWidth),
+    logoHorizontalMaxHeight: getCssVariableNumber2("--logo-horizontal-max-height", DEFAULT_LAYOUT_DIMENSIONS.logoHorizontalMaxHeight)
+  };
+};
+var createDefaultPanelSettings = (options = {}) => {
+  const dimensions = __spreadValues(__spreadValues(__spreadValues({}, DEFAULT_LAYOUT_DIMENSIONS), getLayoutDimensionsFromCss()), options.layoutDimensions);
+  return __spreadProps(__spreadValues({
+    appName: options.appName || "Dash App",
+    horizontalLogo: options.horizontalLogo,
+    squaredLogo: options.squaredLogo,
+    loginBackground: options.loginBackground,
+    sidebarPosition: options.sidebarPosition || "left"
+  }, dimensions), {
+    // Padding configuration (derived from sidebar sizes)
+    paddingHorizontal: dimensions.sidebarLargeWidth,
+    paddingVertical: dimensions.sidebarHorizontalHeight
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppWrapperLight,
+  CustomErrorBoundary,
+  DEFAULT_LAYOUT_DIMENSIONS,
+  DashThemeContext,
+  DashThemeProviderLight,
+  DefaultAppLoadErrorFallback,
+  DefaultInitializationErrorFallback,
+  GlobalLoaderHtmlMarkup,
+  GlobalSmallLoader,
+  I18nBridgeContext,
+  I18nBridgeProviderLight,
+  createDefaultPanelSettings,
+  createLazyAppLoader,
+  createSimpleI18nProvider,
+  getCssVariableNumber,
+  getCssVariableString,
+  getElectronStoreValue,
+  getLayoutDimensionsFromCss,
+  initializeThemeEarly,
+  injectCriticalStyles,
+  isElectron,
+  setElectronStoreValue,
+  syncElectronStore,
+  syncElectronStoreToLocalStorage,
+  useAppInitialization,
+  useBridgedChangeLocaleLight,
+  useBridgedLocaleLight,
+  useBridgedLocalesLight,
+  useDashThemeContextLight,
+  useEarlyThemeInit,
+  useI18nBridgeLight,
+  useInitializeReduxFromPersisted,
+  useLogoutEventListener,
+  usePathnameTracker,
+  usePendingRedirect,
+  useTranslateLight,
+  useUrlLocaleDetection
+});