@dashadmin/dash-admin 1.3.25 → 1.3.26

package/dist/contexts/DashQueryClientContext.js

@@ -1 +1,78 @@
-import{jsx as r}from"react/jsx-runtime";import d,{useContext as o}from"react";import{QueryClientProvider as a}from"@tanstack/react-query";import{PersistQueryClientProvider as y}from"@tanstack/react-query-persist-client";const t=d.createContext(void 0),P=({queryClient:e,children:i,persister:s,persistOptions:C})=>{const n={queryClient:e,persister:s};if(e){if(s){const l={maxAge:72e5,dehydrateOptions:{shouldDehydrateQuery:u=>u.state.status==="success"&&u.state.data!==void 0},...C};return r(y,{client:e,persistOptions:{persister:s,...l},children:r(t.Provider,{value:n,children:i})})}return r(a,{client:e,children:r(t.Provider,{value:n,children:i})})}return r(t.Provider,{value:n,children:i})},D=()=>{const e=o(t);if(!e)throw new Error("useDashQueryClient must be used within a DASHQueryClientProvider");return e.queryClient},m=()=>o(t)?.persister,O=()=>!!o(t)?.persister;var I=P;export{t as DashQueryClientContext,I as default,D as useDashQueryClient,m as useDashQueryPersister,O as useIsCachePersisted};
+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 { jsx } from "react/jsx-runtime";
+import React, { useContext } from "react";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client";
+const DashQueryClientContext = React.createContext(void 0);
+const DashQueryClientProvider = ({
+  queryClient,
+  children,
+  persister,
+  persistOptions
+}) => {
+  const contextValue = { queryClient, persister };
+  if (queryClient) {
+    if (persister) {
+      const defaultPersistOptions = __spreadValues({
+        maxAge: 1e3 * 60 * 60 * 2,
+        // 2 hours default
+        dehydrateOptions: {
+          // Only persist successful queries that have data
+          shouldDehydrateQuery: (query) => {
+            return query.state.status === "success" && query.state.data !== void 0;
+          }
+        }
+      }, persistOptions);
+      return /* @__PURE__ */ jsx(
+        PersistQueryClientProvider,
+        {
+          client: queryClient,
+          persistOptions: __spreadValues({
+            persister
+          }, defaultPersistOptions),
+          children: /* @__PURE__ */ jsx(DashQueryClientContext.Provider, { value: contextValue, children })
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(DashQueryClientContext.Provider, { value: contextValue, children }) });
+  }
+  return /* @__PURE__ */ jsx(DashQueryClientContext.Provider, { value: contextValue, children });
+};
+const useDashQueryClient = () => {
+  const context = useContext(DashQueryClientContext);
+  if (!context) {
+    throw new Error("useDashQueryClient must be used within a DASHQueryClientProvider");
+  }
+  return context.queryClient;
+};
+const useDashQueryPersister = () => {
+  const context = useContext(DashQueryClientContext);
+  return context == null ? void 0 : context.persister;
+};
+const useIsCachePersisted = () => {
+  const context = useContext(DashQueryClientContext);
+  return !!(context == null ? void 0 : context.persister);
+};
+var DashQueryClientContext_default = DashQueryClientProvider;
+export {
+  DashQueryClientContext,
+  DashQueryClientContext_default as default,
+  useDashQueryClient,
+  useDashQueryPersister,
+  useIsCachePersisted
+};

package/dist/contexts/DashResourceContext.js

@@ -1 +1,21 @@
-import{jsx as a}from"react/jsx-runtime";import t,{createContext as n,useContext as u,useMemo as c}from"react";const o=n(void 0),i=t.memo(({resourceConfig:e,children:r})=>{const s=c(()=>({resourceConfig:e}),[e]);return a(o.Provider,{value:s,children:r})});i.displayName="DashResourceProvider";const D=()=>{const e=u(o);if(e===void 0)throw new Error("useDashResource must be used within a DashResourceProvider");return e};export{i as DashResourceProvider,D as useDashResource};
+import { jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useMemo } from "react";
+const DashResourceContext = createContext(void 0);
+const DashResourceProvider = React.memo(({ resourceConfig, children }) => {
+  const contextValue = useMemo(() => ({
+    resourceConfig
+  }), [resourceConfig]);
+  return /* @__PURE__ */ jsx(DashResourceContext.Provider, { value: contextValue, children });
+});
+DashResourceProvider.displayName = "DashResourceProvider";
+const useDashResource = () => {
+  const context = useContext(DashResourceContext);
+  if (context === void 0) {
+    throw new Error("useDashResource must be used within a DashResourceProvider");
+  }
+  return context;
+};
+export {
+  DashResourceProvider,
+  useDashResource
+};

package/dist/contexts/I18nBridgeContext.js

@@ -1 +1,123 @@
-import{jsx as C}from"react/jsx-runtime";import I,{createContext as f,useContext as x,useState as g,useCallback as L,useEffect as P}from"react";const u="dash:locale-change",l=f({i18nProvider:null,locale:"es",setI18nProvider:()=>{},setLocale:()=>{}}),B=({children:e})=>{const[n,i]=g(null),[o,a]=g(()=>typeof window<"u"&&localStorage.getItem("dash-user-locale")||"es"),v=L(async t=>{console.log("\u{1F310} I18nBridgeContext: Setting bridged i18nProvider",{hasGetLocales:!!t?.getLocales,locales:t?.getLocales?.(),providerLocale:t?.getLocale?.(),desiredLocale:o}),i(t);const c=t?.getLocale?.();if(c&&c!==o&&t?.changeLocale){console.log(`\u{1F310} I18nBridgeContext: Provider locale (${c}) differs from desired (${o}), switching...`);try{await t.changeLocale(o),console.log(`\u{1F310} I18nBridgeContext: Successfully switched provider to ${o}`)}catch(d){console.warn("\u{1F310} I18nBridgeContext: Failed to switch provider locale:",d)}}else t?.getLocale&&a(t.getLocale())},[o]);return P(()=>{const t=async c=>{const r=c.detail?.locale;if(r&&r!==o){if(console.log("\u{1F310} I18nBridgeContext: Received locale change event:",r),n?.changeLocale)try{await n.changeLocale(r)}catch(h){console.warn("Failed to change provider locale:",h)}a(r)}};return window.addEventListener(u,t),()=>{window.removeEventListener(u,t)}},[n,o]),C(l.Provider,{value:{i18nProvider:n,locale:o,setI18nProvider:v,setLocale:a},children:e})},s=()=>x(l),E=()=>{const{i18nProvider:e}=s();return I.useMemo(()=>e?.getLocales?e.getLocales():[],[e])},m=()=>{const{i18nProvider:e,setLocale:n}=s();return L(async o=>{e?.changeLocale&&await e.changeLocale(o),n(o)},[e,n])},p=()=>{const{locale:e}=s();return e};var y=l;export{B as I18nBridgeProvider,u as LOCALE_CHANGE_EVENT,y as default,m as useBridgedChangeLocale,p as useBridgedLocale,E as useBridgedLocales,s as useI18nBridge};
+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 { jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useState, useCallback, useEffect } from "react";
+const LOCALE_CHANGE_EVENT = "dash:locale-change";
+const I18nBridgeContext = createContext({
+  i18nProvider: null,
+  locale: "es",
+  // Default to es
+  setI18nProvider: () => {
+  },
+  setLocale: () => {
+  }
+});
+const I18nBridgeProvider = ({ children }) => {
+  const [i18nProvider, setI18nProviderState] = useState(null);
+  const [locale, setLocale] = useState(() => {
+    if (typeof window !== "undefined") {
+      return localStorage.getItem("dash-user-locale") || "es";
+    }
+    return "es";
+  });
+  const setI18nProvider = useCallback((provider) => __async(null, null, function* () {
+    var _a, _b, _c;
+    console.log("\u{1F310} I18nBridgeContext: Setting bridged i18nProvider", {
+      hasGetLocales: !!(provider == null ? void 0 : provider.getLocales),
+      locales: (_a = provider == null ? void 0 : provider.getLocales) == null ? void 0 : _a.call(provider),
+      providerLocale: (_b = provider == null ? void 0 : provider.getLocale) == null ? void 0 : _b.call(provider),
+      desiredLocale: locale
+    });
+    setI18nProviderState(provider);
+    const providerLocale = (_c = provider == null ? void 0 : provider.getLocale) == null ? void 0 : _c.call(provider);
+    if (providerLocale && providerLocale !== locale && (provider == null ? void 0 : provider.changeLocale)) {
+      console.log(`\u{1F310} I18nBridgeContext: Provider locale (${providerLocale}) differs from desired (${locale}), switching...`);
+      try {
+        yield provider.changeLocale(locale);
+        console.log(`\u{1F310} I18nBridgeContext: Successfully switched provider to ${locale}`);
+      } catch (e) {
+        console.warn("\u{1F310} I18nBridgeContext: Failed to switch provider locale:", e);
+      }
+    } else if (provider == null ? void 0 : provider.getLocale) {
+      setLocale(provider.getLocale());
+    }
+  }), [locale]);
+  useEffect(() => {
+    const handleLocaleChange = (event) => __async(null, null, function* () {
+      var _a;
+      const newLocale = (_a = event.detail) == null ? void 0 : _a.locale;
+      if (newLocale && newLocale !== locale) {
+        console.log("\u{1F310} I18nBridgeContext: 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]);
+  return /* @__PURE__ */ jsx(I18nBridgeContext.Provider, { value: { i18nProvider, locale, setI18nProvider, setLocale }, children });
+};
+const useI18nBridge = () => {
+  const context = useContext(I18nBridgeContext);
+  return context;
+};
+const useBridgedLocales = () => {
+  const { i18nProvider } = useI18nBridge();
+  const locales = React.useMemo(() => {
+    if (!(i18nProvider == null ? void 0 : i18nProvider.getLocales)) {
+      return [];
+    }
+    return i18nProvider.getLocales();
+  }, [i18nProvider]);
+  return locales;
+};
+const useBridgedChangeLocale = () => {
+  const { i18nProvider, setLocale } = useI18nBridge();
+  const changeLocale = useCallback((locale) => __async(null, null, function* () {
+    if (i18nProvider == null ? void 0 : i18nProvider.changeLocale) {
+      yield i18nProvider.changeLocale(locale);
+    }
+    setLocale(locale);
+  }), [i18nProvider, setLocale]);
+  return changeLocale;
+};
+const useBridgedLocale = () => {
+  const { locale } = useI18nBridge();
+  return locale;
+};
+var I18nBridgeContext_default = I18nBridgeContext;
+export {
+  I18nBridgeProvider,
+  LOCALE_CHANGE_EVENT,
+  I18nBridgeContext_default as default,
+  useBridgedChangeLocale,
+  useBridgedLocale,
+  useBridgedLocales,
+  useI18nBridge
+};

package/dist/contexts/I18nBridgeSetter.js

@@ -1 +1,29 @@
-import{useEffect as c}from"react";import{useI18nProvider as n,useLocaleState as s}from"react-admin";import{useI18nBridge as i}from"./I18nBridgeContext";const l=()=>{const e=n(),[t]=s(),{setI18nProvider:o,setLocale:r}=i();return c(()=>{e&&(console.log("\u{1F310} I18nBridgeSetter: Setting bridge from AdminContext",{hasGetLocales:!!e.getLocales,locales:e.getLocales?.(),currentLocale:t}),o(e))},[e,o,t]),c(()=>{t&&r(t)},[t,r]),null};var m=l;export{m as default};
+import { useEffect } from "react";
+import { useI18nProvider, useLocaleState } from "react-admin";
+import { useI18nBridge } from "./I18nBridgeContext";
+const I18nBridgeSetter = () => {
+  const i18nProvider = useI18nProvider();
+  const [locale] = useLocaleState();
+  const { setI18nProvider, setLocale } = useI18nBridge();
+  useEffect(() => {
+    var _a;
+    if (i18nProvider) {
+      console.log("\u{1F310} I18nBridgeSetter: Setting bridge from AdminContext", {
+        hasGetLocales: !!i18nProvider.getLocales,
+        locales: (_a = i18nProvider.getLocales) == null ? void 0 : _a.call(i18nProvider),
+        currentLocale: locale
+      });
+      setI18nProvider(i18nProvider);
+    }
+  }, [i18nProvider, setI18nProvider, locale]);
+  useEffect(() => {
+    if (locale) {
+      setLocale(locale);
+    }
+  }, [locale, setLocale]);
+  return null;
+};
+var I18nBridgeSetter_default = I18nBridgeSetter;
+export {
+  I18nBridgeSetter_default as default
+};

package/dist/contexts/I18nReduxSync.js

@@ -1 +1,16 @@
-import{useEffect as c}from"react";import{useSetLocale as r,useLocaleState as o}from"react-admin";const s=({locale:e})=>{const t=r(),[n]=o();return c(()=>{e&&e!==n&&t(e)},[e,n,t]),null};var i=s;export{i as default};
+import { useEffect } from "react";
+import { useSetLocale, useLocaleState } from "react-admin";
+const I18nReduxSync = ({ locale }) => {
+  const setLocale = useSetLocale();
+  const [currentLocale] = useLocaleState();
+  useEffect(() => {
+    if (locale && locale !== currentLocale) {
+      setLocale(locale);
+    }
+  }, [locale, currentLocale, setLocale]);
+  return null;
+};
+var I18nReduxSync_default = I18nReduxSync;
+export {
+  I18nReduxSync_default as default
+};

package/dist/contexts/SubscriptionPlanFormatsProvider.js

@@ -1 +1,175 @@
-import{jsx as E}from"react/jsx-runtime";import{useAxios as w}from"@dashadmin/dash-axios-hook";import{createContext as C,useContext as x,useState as f,useRef as T,useEffect as b}from"react";import{idbSet as u,idbGet as F}from"./SystemRequestsCache";const r=!0,S=C({formats:null,addonFormats:null,loading:!1,fetchFormats:async()=>{}}),D=({cacheSeconds:i=300,children:_})=>{const p=w(),P="subscription_plan_limit_formats_cache",h="subscription_plan_addon_formats_cache",t=T({fetchPromise:null,formats:null,addonFormats:null,lastFetchTime:0}),[s,c]=f(t.current.formats),[n,m]=f(t.current.addonFormats),[g,e]=f(!t.current.formats&&!t.current.fetchPromise),l=async()=>{if(r&&console.log("[SubscriptionPlanFormats] fetchFormats called"),t.current.fetchPromise)return r&&console.log("[SubscriptionPlanFormats] fetchPromise already in progress"),t.current.fetchPromise;const d=Date.now();if(t.current.formats&&t.current.addonFormats&&d-t.current.lastFetchTime<i*1e3){r&&console.log(`[SubscriptionPlanFormats] Using cached data (age: ${(d-t.current.lastFetchTime)/1e3}s)`),s||c(t.current.formats),n||m(t.current.addonFormats);return}return e(!0),t.current.fetchPromise=(async()=>{try{r&&console.log("[SubscriptionPlanFormats] FETCHING limit formats and addon formats");const[a,o]=await Promise.all([p.get("system/subscription-plan/limitFormats"),p.get("system/subscription-plan/addonFormats")]);t.current.formats=a.data,t.current.addonFormats=o.data,t.current.lastFetchTime=Date.now(),c(a.data),m(o.data);try{await u(`${P}_formats`,a.data),await u(`${h}_formats`,o.data),await u("subscription_plan_formats_lastFetchTime",t.current.lastFetchTime),r&&console.log("[SubscriptionPlanFormats] Saved to IndexedDB")}catch(y){r&&console.error("[SubscriptionPlanFormats] Error writing to IndexedDB:",y)}}catch(a){r&&console.error("[SubscriptionPlanFormats] Error fetching formats:",a)}finally{e(!1),t.current.fetchPromise=null,r&&console.log("[SubscriptionPlanFormats] fetchPromise cleared")}})(),t.current.fetchPromise};return b(()=>{(async()=>{r&&console.log("[SubscriptionPlanFormats] loadCachedFormats");try{if(!t.current.formats){const o=await F(`${P}_formats`);o&&(t.current.formats=o,c(o),r&&console.log("[SubscriptionPlanFormats] Loaded limit formats from IndexedDB"))}if(!t.current.addonFormats){const o=await F(`${h}_formats`);o&&(t.current.addonFormats=o,m(o),r&&console.log("[SubscriptionPlanFormats] Loaded addon formats from IndexedDB"))}const a=await F("subscription_plan_formats_lastFetchTime");if(a&&(t.current.lastFetchTime=a),t.current.formats&&t.current.addonFormats&&Date.now()-t.current.lastFetchTime<i*1e3){e(!1);return}await l()}catch(a){r&&console.error("[SubscriptionPlanFormats] Error loading cached formats:",a),await l()}})()},[i]),b(()=>{s&&n&&e(!1)},[s,n]),E(S.Provider,{value:{formats:(s||t.current.formats)??null,addonFormats:(n||t.current.addonFormats)??null,fetchFormats:l,loading:g},children:_})};function R(){return x(S)}var B=D;export{D as SubscriptionPlanFormatsProvider,B as default,R as useSubscriptionPlanFormats};
+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 { jsx } from "react/jsx-runtime";
+import { useAxios } from "dash-axios-hook";
+import { createContext, useContext, useState, useRef, useEffect } from "react";
+import { idbSet, idbGet } from "./SystemRequestsCache";
+const DEBUG_SUBSCRIPTION_PLAN_FORMATS = true;
+const SubscriptionPlanFormatsContext = createContext({
+  formats: null,
+  addonFormats: null,
+  loading: false,
+  fetchFormats: () => __async(null, null, function* () {
+  })
+});
+const SubscriptionPlanFormatsProvider = ({
+  cacheSeconds = 300,
+  children
+}) => {
+  var _a, _b;
+  const axios = useAxios();
+  const CACHE_KEY_LIMITS = "subscription_plan_limit_formats_cache";
+  const CACHE_KEY_ADDONS = "subscription_plan_addon_formats_cache";
+  const GLOBALS = useRef({
+    fetchPromise: null,
+    formats: null,
+    addonFormats: null,
+    lastFetchTime: 0
+  });
+  const [formats, setFormats] = useState(GLOBALS.current.formats);
+  const [addonFormats, setAddonFormats] = useState(GLOBALS.current.addonFormats);
+  const [loading, setLoading] = useState(!GLOBALS.current.formats && !GLOBALS.current.fetchPromise);
+  const fetchFormats = () => __async(null, null, function* () {
+    if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+      console.log(`[SubscriptionPlanFormats] fetchFormats called`);
+    }
+    if (GLOBALS.current.fetchPromise) {
+      if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+        console.log(`[SubscriptionPlanFormats] fetchPromise already in progress`);
+      }
+      return GLOBALS.current.fetchPromise;
+    }
+    const now = Date.now();
+    if (GLOBALS.current.formats && GLOBALS.current.addonFormats && now - GLOBALS.current.lastFetchTime < cacheSeconds * 1e3) {
+      if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+        console.log(`[SubscriptionPlanFormats] Using cached data (age: ${(now - GLOBALS.current.lastFetchTime) / 1e3}s)`);
+      }
+      if (!formats) setFormats(GLOBALS.current.formats);
+      if (!addonFormats) setAddonFormats(GLOBALS.current.addonFormats);
+      return;
+    }
+    setLoading(true);
+    GLOBALS.current.fetchPromise = (() => __async(null, null, function* () {
+      try {
+        if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+          console.log(`[SubscriptionPlanFormats] FETCHING limit formats and addon formats`);
+        }
+        const [limitsResponse, addonsResponse] = yield Promise.all([
+          axios.get("system/subscription-plan/limitFormats"),
+          axios.get("system/subscription-plan/addonFormats")
+        ]);
+        GLOBALS.current.formats = limitsResponse.data;
+        GLOBALS.current.addonFormats = addonsResponse.data;
+        GLOBALS.current.lastFetchTime = Date.now();
+        setFormats(limitsResponse.data);
+        setAddonFormats(addonsResponse.data);
+        try {
+          yield idbSet(`${CACHE_KEY_LIMITS}_formats`, limitsResponse.data);
+          yield idbSet(`${CACHE_KEY_ADDONS}_formats`, addonsResponse.data);
+          yield idbSet(`subscription_plan_formats_lastFetchTime`, GLOBALS.current.lastFetchTime);
+          if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+            console.log(`[SubscriptionPlanFormats] Saved to IndexedDB`);
+          }
+        } catch (error) {
+          if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+            console.error(`[SubscriptionPlanFormats] Error writing to IndexedDB:`, error);
+          }
+        }
+      } catch (error) {
+        if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+          console.error(`[SubscriptionPlanFormats] Error fetching formats:`, error);
+        }
+      } finally {
+        setLoading(false);
+        GLOBALS.current.fetchPromise = null;
+        if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+          console.log(`[SubscriptionPlanFormats] fetchPromise cleared`);
+        }
+      }
+    }))();
+    return GLOBALS.current.fetchPromise;
+  });
+  useEffect(() => {
+    const loadCachedFormats = () => __async(null, null, function* () {
+      if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+        console.log(`[SubscriptionPlanFormats] loadCachedFormats`);
+      }
+      try {
+        if (!GLOBALS.current.formats) {
+          const cachedFormats = yield idbGet(`${CACHE_KEY_LIMITS}_formats`);
+          if (cachedFormats) {
+            GLOBALS.current.formats = cachedFormats;
+            setFormats(cachedFormats);
+            if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+              console.log(`[SubscriptionPlanFormats] Loaded limit formats from IndexedDB`);
+            }
+          }
+        }
+        if (!GLOBALS.current.addonFormats) {
+          const cachedAddonFormats = yield idbGet(`${CACHE_KEY_ADDONS}_formats`);
+          if (cachedAddonFormats) {
+            GLOBALS.current.addonFormats = cachedAddonFormats;
+            setAddonFormats(cachedAddonFormats);
+            if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+              console.log(`[SubscriptionPlanFormats] Loaded addon formats from IndexedDB`);
+            }
+          }
+        }
+        const cachedTime = yield idbGet(`subscription_plan_formats_lastFetchTime`);
+        if (cachedTime) {
+          GLOBALS.current.lastFetchTime = cachedTime;
+        }
+        if (GLOBALS.current.formats && GLOBALS.current.addonFormats) {
+          const now = Date.now();
+          if (now - GLOBALS.current.lastFetchTime < cacheSeconds * 1e3) {
+            setLoading(false);
+            return;
+          }
+        }
+        yield fetchFormats();
+      } catch (error) {
+        if (DEBUG_SUBSCRIPTION_PLAN_FORMATS) {
+          console.error(`[SubscriptionPlanFormats] Error loading cached formats:`, error);
+        }
+        yield fetchFormats();
+      }
+    });
+    loadCachedFormats();
+  }, [cacheSeconds]);
+  useEffect(() => {
+    if (formats && addonFormats) setLoading(false);
+  }, [formats, addonFormats]);
+  return /* @__PURE__ */ jsx(SubscriptionPlanFormatsContext.Provider, { value: {
+    formats: (_a = formats || GLOBALS.current.formats) != null ? _a : null,
+    addonFormats: (_b = addonFormats || GLOBALS.current.addonFormats) != null ? _b : null,
+    fetchFormats,
+    loading
+  }, children });
+};
+function useSubscriptionPlanFormats() {
+  return useContext(SubscriptionPlanFormatsContext);
+}
+var SubscriptionPlanFormatsProvider_default = SubscriptionPlanFormatsProvider;
+export {
+  SubscriptionPlanFormatsProvider,
+  SubscriptionPlanFormatsProvider_default as default,
+  useSubscriptionPlanFormats
+};

package/dist/contexts/SystemRequestsCache.js

@@ -1 +1,194 @@
-import{jsx as p}from"react/jsx-runtime";import{useAxios as P}from"@dashadmin/dash-axios-hook";import{createContext as x,useContext as w,useState as h,useRef as D,useEffect as y}from"react";const E="SystemRequestsCacheDB",i="kvstore",T=1;function C(){return new Promise((t,n)=>{const r=indexedDB.open(E,T);r.onupgradeneeded=()=>{r.result.createObjectStore(i)},r.onsuccess=()=>t(r.result),r.onerror=()=>n(r.error)})}async function S(t,n){const r=await C();return new Promise((c,m)=>{const e=r.transaction(i,"readwrite");e.objectStore(i).put(n,t),e.oncomplete=()=>c(),e.onerror=()=>m(e.error)})}async function R(t){const n=await C();return new Promise((r,c)=>{const e=n.transaction(i,"readonly").objectStore(i).get(t);e.onsuccess=()=>r(e.result),e.onerror=()=>c(e.error)})}const o=!0,g=x({formats:null,fetchFormats:async()=>{},loading:!1}),$=({cacheKey:t,apiUrl:n,cacheSeconds:r=10,children:c})=>{const m=P(),e=D({fetchPromise:null,formats:null,lastFetchTime:0}),[f,u]=h(e.current.formats),[q,a]=h(!e.current.formats&&!e.current.fetchPromise),l=async()=>{if(o&&console.log(`[SystemRequestsCache] fetchFormats called for key=${t}, url=${n}`),e.current.fetchPromise)return o&&console.log(`[SystemRequestsCache] fetchPromise already in progress for key=${t}`),e.current.fetchPromise;const d=Date.now();if(!e.current.lastFetchTime)try{e.current.lastFetchTime=await R(t)||0,o&&console.log(`[SystemRequestsCache] Loaded lastFetchTime from IndexedDB: ${e.current.lastFetchTime}`)}catch(s){o&&console.error("[SystemRequestsCache] Error reading lastFetchTime from IndexedDB:",s)}if(e.current.formats&&d-e.current.lastFetchTime<r*1e3){o&&console.log(`[SystemRequestsCache] Using cached formats for key=${t} (age: ${(d-e.current.lastFetchTime)/1e3}s)`),f||u(e.current.formats);return}return a(!0),e.current.fetchPromise=(async()=>{try{o&&console.log(`[SystemRequestsCache] FETCHING ${n} for key=${t}`);const{data:s}=await m.get(n);e.current.formats=s,e.current.lastFetchTime=Date.now(),u(s);try{await S(t,e.current.lastFetchTime),await S(`${t}_formats`,s),o&&console.log(`[SystemRequestsCache] Saved formats and lastFetchTime to IndexedDB for key=${t}`)}catch(F){o&&console.error("[SystemRequestsCache] Error writing to IndexedDB:",F)}}catch(s){o&&console.error("[SystemRequestsCache] Error fetching settings formats:",s)}finally{a(!1),e.current.fetchPromise=null,o&&console.log(`[SystemRequestsCache] fetchPromise cleared for key=${t}`)}})(),e.current.fetchPromise};return y(()=>{(async()=>{o&&console.log(`[SystemRequestsCache] loadCachedFormats for key=${t}`);try{if(!e.current.formats){const s=await R(`${t}_formats`);s&&(e.current.formats=s,u(s),a(!1),o&&console.log(`[SystemRequestsCache] Loaded formats from IndexedDB for key=${t}`))}e.current.formats||a(!0),await l()}catch(s){o&&console.error("[SystemRequestsCache] Error loading cached formats:",s),a(!0),await l()}})()},[t,n,r]),y(()=>{f&&a(!1)},[f]),p(g.Provider,{value:{formats:(f||e.current.formats)??null,fetchFormats:l,loading:q},children:c})};function v(){return w(g)}var k=$;export{$ as SystemRequestsCacheProvider,k as default,R as idbGet,S as idbSet,v as useSystemRequestsCache};
+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 { jsx } from "react/jsx-runtime";
+import { useAxios } from "dash-axios-hook";
+import { createContext, useContext, useState, useRef, useEffect } from "react";
+const DB_NAME = "SystemRequestsCacheDB";
+const STORE_NAME = "kvstore";
+const DB_VERSION = 1;
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(STORE_NAME);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbSet(key, value) {
+  return __async(this, null, function* () {
+    const db = yield openDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      tx.objectStore(STORE_NAME).put(value, key);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  });
+}
+function idbGet(key) {
+  return __async(this, null, function* () {
+    const db = yield openDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const req = tx.objectStore(STORE_NAME).get(key);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  });
+}
+const DEBUG_SYSTEM_REQUESTS_CACHE = true;
+const SystemRequestsCacheContext = createContext({
+  formats: null,
+  fetchFormats: () => __async(null, null, function* () {
+  }),
+  loading: false
+});
+const SystemRequestsCacheProvider = ({
+  cacheKey,
+  apiUrl,
+  cacheSeconds = 10,
+  children
+}) => {
+  var _a;
+  const axios = useAxios();
+  const GLOBALS = useRef({
+    fetchPromise: null,
+    formats: null,
+    lastFetchTime: 0
+  });
+  const [formats, setFormats] = useState(GLOBALS.current.formats);
+  const [loading, setLoading] = useState(!GLOBALS.current.formats && !GLOBALS.current.fetchPromise);
+  const fetchFormats = () => __async(null, null, function* () {
+    if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+      console.log(`[SystemRequestsCache] fetchFormats called for key=${cacheKey}, url=${apiUrl}`);
+    }
+    if (GLOBALS.current.fetchPromise) {
+      if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+        console.log(`[SystemRequestsCache] fetchPromise already in progress for key=${cacheKey}`);
+      }
+      return GLOBALS.current.fetchPromise;
+    }
+    const now = Date.now();
+    if (!GLOBALS.current.lastFetchTime) {
+      try {
+        GLOBALS.current.lastFetchTime = (yield idbGet(cacheKey)) || 0;
+        if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+          console.log(`[SystemRequestsCache] Loaded lastFetchTime from IndexedDB: ${GLOBALS.current.lastFetchTime}`);
+        }
+      } catch (error) {
+        if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+          console.error(`[SystemRequestsCache] Error reading lastFetchTime from IndexedDB:`, error);
+        }
+      }
+    }
+    if (GLOBALS.current.formats && now - GLOBALS.current.lastFetchTime < cacheSeconds * 1e3) {
+      if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+        console.log(`[SystemRequestsCache] Using cached formats for key=${cacheKey} (age: ${(now - GLOBALS.current.lastFetchTime) / 1e3}s)`);
+      }
+      if (!formats) setFormats(GLOBALS.current.formats);
+      return;
+    }
+    setLoading(true);
+    GLOBALS.current.fetchPromise = (() => __async(null, null, function* () {
+      try {
+        if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+          console.log(`[SystemRequestsCache] FETCHING ${apiUrl} for key=${cacheKey}`);
+        }
+        const { data } = yield axios.get(apiUrl);
+        GLOBALS.current.formats = data;
+        GLOBALS.current.lastFetchTime = Date.now();
+        setFormats(data);
+        try {
+          yield idbSet(cacheKey, GLOBALS.current.lastFetchTime);
+          yield idbSet(`${cacheKey}_formats`, data);
+          if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+            console.log(`[SystemRequestsCache] Saved formats and lastFetchTime to IndexedDB for key=${cacheKey}`);
+          }
+        } catch (error) {
+          if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+            console.error(`[SystemRequestsCache] Error writing to IndexedDB:`, error);
+          }
+        }
+      } catch (error) {
+        if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+          console.error(`[SystemRequestsCache] Error fetching settings formats:`, error);
+        }
+      } finally {
+        setLoading(false);
+        GLOBALS.current.fetchPromise = null;
+        if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+          console.log(`[SystemRequestsCache] fetchPromise cleared for key=${cacheKey}`);
+        }
+      }
+    }))();
+    return GLOBALS.current.fetchPromise;
+  });
+  useEffect(() => {
+    const loadCachedFormats = () => __async(null, null, function* () {
+      if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+        console.log(`[SystemRequestsCache] loadCachedFormats for key=${cacheKey}`);
+      }
+      try {
+        if (!GLOBALS.current.formats) {
+          const cachedFormats = yield idbGet(`${cacheKey}_formats`);
+          if (cachedFormats) {
+            GLOBALS.current.formats = cachedFormats;
+            setFormats(cachedFormats);
+            setLoading(false);
+            if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+              console.log(`[SystemRequestsCache] Loaded formats from IndexedDB for key=${cacheKey}`);
+            }
+          }
+        }
+        if (!GLOBALS.current.formats) setLoading(true);
+        yield fetchFormats();
+      } catch (error) {
+        if (DEBUG_SYSTEM_REQUESTS_CACHE) {
+          console.error(`[SystemRequestsCache] Error loading cached formats:`, error);
+        }
+        setLoading(true);
+        yield fetchFormats();
+      }
+    });
+    loadCachedFormats();
+  }, [cacheKey, apiUrl, cacheSeconds]);
+  useEffect(() => {
+    if (formats) setLoading(false);
+  }, [formats]);
+  return /* @__PURE__ */ jsx(SystemRequestsCacheContext.Provider, { value: {
+    formats: (_a = formats || GLOBALS.current.formats) != null ? _a : null,
+    fetchFormats,
+    loading
+  }, children });
+};
+function useSystemRequestsCache() {
+  return useContext(SystemRequestsCacheContext);
+}
+var SystemRequestsCache_default = SystemRequestsCacheProvider;
+export {
+  SystemRequestsCacheProvider,
+  SystemRequestsCache_default as default,
+  idbGet,
+  idbSet,
+  useSystemRequestsCache
+};