@datlv-trustshop/shopify-inapp-components 0.1.10 → 0.1.12

package/dist/core/global-manager.d.ts

@@ -19,15 +19,14 @@ export declare class GlobalDashboardManager {
     private stateListeners;
     private globalState;
     private initPromise;
-    private autoInitTimer;
     private lastConfig;
-    private isInitializing;
+    private pendingLocaleRefresh;
     private constructor();
     static getInstance(): GlobalDashboardManager;
     /**
      * Register a provider instance
      */
-    registerProvider(id: string, config?: DashboardConfig): void;
+    registerProvider(id: string, config?: DashboardConfig, autoRefreshOnLocaleChange?: boolean): void;
     /**
      * Unregister a provider instance
      */
@@ -44,14 +43,6 @@ export declare class GlobalDashboardManager {
      * Check if two configs are equal
      */
     private configEquals;
-    /**
-     * Schedule auto-initialization
-     */
-    private scheduleAutoInit;
-    /**
-     * Auto-initialize the engine
-     */
-    private autoInit;
     /**
      * Initialize the shared engine
      */

package/dist/core/global-manager.js

@@ -23,9 +23,8 @@ export class GlobalDashboardManager {
             lastFetch: null,
         };
         this.initPromise = null;
-        this.autoInitTimer = null;
         this.lastConfig = null;
-        this.isInitializing = false;
+        this.pendingLocaleRefresh = null;
         // Private constructor for singleton
     }
     static getInstance() {
@@ -37,19 +36,31 @@ export class GlobalDashboardManager {
     /**
      * Register a provider instance
      */
-    registerProvider(id, config) {
+    registerProvider(id, config, autoRefreshOnLocaleChange = false) {
         this.providers.set(id, {
             id,
             mounted: true,
-            config
+            config,
+            autoRefreshOnLocaleChange
         });
         // Update config if provided and different
         if (config && !this.configEquals(this.lastConfig, config)) {
             this.updateGlobalConfig(config);
         }
-        // Auto-initialize if this is the first provider
-        if (this.providers.size === 1 && config) {
-            this.scheduleAutoInit();
+        // Check if we need to initialize due to pending locale refresh
+        // This handles the case where all providers have autoInit=false but want locale refresh
+        if (this.pendingLocaleRefresh && autoRefreshOnLocaleChange) {
+            const locale = this.pendingLocaleRefresh;
+            this.pendingLocaleRefresh = null;
+            // Force initialization with the new locale if not initialized
+            if (!this.engine || !this.engine.isInitialized()) {
+                if (this.lastConfig) {
+                    this.init({ ...this.lastConfig, locale }).catch(console.error);
+                }
+            }
+            else {
+                this.engine.setLocale(locale).catch(console.error);
+            }
         }
     }
     /**
@@ -88,21 +99,43 @@ export class GlobalDashboardManager {
      * Update the global configuration
      */
     updateGlobalConfig(config) {
+        const previousLocale = this.lastConfig?.locale;
         this.lastConfig = config;
         if (this.engine) {
             // Update existing engine config
             this.engine.updateConfig(config);
-            // If locale changed and engine is initialized, refresh
-            if (config.locale && config.locale !== this.engine.getCurrentLocale()) {
-                const wasInitialized = this.engine.isInitialized();
-                if (wasInitialized) {
-                    this.engine.setLocale(config.locale).catch(console.error);
+            // If locale changed, we need to refresh data
+            if (config.locale && config.locale !== previousLocale) {
+                // Check if any provider wants auto-refresh on locale change
+                const shouldRefresh = Array.from(this.providers.values()).some(p => p.autoRefreshOnLocaleChange);
+                if (this.engine.isInitialized()) {
+                    // Engine is initialized, refresh immediately if any provider wants it
+                    if (shouldRefresh) {
+                        this.engine.setLocale(config.locale).catch(console.error);
+                    }
+                    else {
+                        this.engine.updateLocale(config.locale);
+                    }
                 }
                 else {
+                    // Engine not initialized yet
                     this.engine.updateLocale(config.locale);
+                    // If any provider wants refresh, force initialization NOW
+                    // This is critical for autoInit=false providers
+                    if (shouldRefresh) {
+                        this.init(config).catch(console.error);
+                    }
+                    else {
+                        // Mark for later refresh when a provider initializes
+                        this.pendingLocaleRefresh = config.locale;
+                    }
                 }
             }
         }
+        else if (config.locale && config.locale !== previousLocale) {
+            // No engine yet, but locale changed - mark for refresh when engine is created
+            this.pendingLocaleRefresh = config.locale;
+        }
     }
     /**
      * Check if two configs are equal
@@ -116,47 +149,31 @@ export class GlobalDashboardManager {
             a.retryAttempts === b.retryAttempts &&
             a.retryDelay === b.retryDelay);
     }
-    /**
-     * Schedule auto-initialization
-     */
-    scheduleAutoInit() {
-        if (this.autoInitTimer) {
-            clearTimeout(this.autoInitTimer);
-        }
-        // Delay slightly to allow all providers to mount
-        this.autoInitTimer = setTimeout(() => {
-            this.autoInit().catch(console.error);
-        }, 10);
-    }
-    /**
-     * Auto-initialize the engine
-     */
-    async autoInit() {
-        if (!this.lastConfig || this.isInitializing)
-            return;
-        const engine = this.getOrCreateEngine();
-        // Only init if not already initialized
-        if (!engine.isInitialized() && !this.initPromise) {
-            await this.init();
-        }
-    }
     /**
      * Initialize the shared engine
      */
     async init(config) {
+        // If we have a pending locale refresh and config has a different locale,
+        // use the pending locale instead
+        if (this.pendingLocaleRefresh && config) {
+            config = { ...config, locale: this.pendingLocaleRefresh };
+        }
         if (this.initPromise && !config) {
             return this.initPromise;
         }
         if (config) {
             this.updateGlobalConfig(config);
         }
-        this.isInitializing = true;
         this.updateGlobalState({ ...this.globalState, loading: true, error: null });
         this.initPromise = (async () => {
             try {
                 const engine = this.getOrCreateEngine(config);
                 await engine.init();
                 const data = engine.getData();
+                // Clear pending locale refresh since we just initialized with it
+                if (this.pendingLocaleRefresh) {
+                    this.pendingLocaleRefresh = null;
+                }
                 this.updateGlobalState({
                     data,
                     loading: false,
@@ -175,9 +192,6 @@ export class GlobalDashboardManager {
                 });
                 throw err;
             }
-            finally {
-                this.isInitializing = false;
-            }
         })();
         return this.initPromise;
     }
@@ -215,14 +229,35 @@ export class GlobalDashboardManager {
      * Update locale globally
      */
     async setLocale(locale) {
+        // Update the last config
+        if (this.lastConfig) {
+            this.lastConfig = { ...this.lastConfig, locale };
+        }
+        // Check if any provider wants auto-refresh
+        const shouldRefresh = Array.from(this.providers.values()).some(p => p.autoRefreshOnLocaleChange);
         if (!this.engine) {
-            // Update config for future initialization
-            if (this.lastConfig) {
-                this.lastConfig = { ...this.lastConfig, locale };
+            // No engine yet, but if any provider wants refresh, initialize NOW
+            if (shouldRefresh && this.lastConfig) {
+                await this.init({ ...this.lastConfig, locale });
+            }
+            else {
+                // Mark locale for refresh when engine is created
+                this.pendingLocaleRefresh = locale;
             }
             return;
         }
-        await this.engine.setLocale(locale);
+        // Engine exists, update locale
+        if (this.engine.isInitialized()) {
+            await this.engine.setLocale(locale);
+        }
+        else {
+            // Engine exists but not initialized
+            this.engine.updateLocale(locale);
+            // If any provider wants refresh, initialize now
+            if (shouldRefresh) {
+                await this.init();
+            }
+        }
     }
     /**
      * Get the current locale
@@ -291,10 +326,6 @@ export class GlobalDashboardManager {
     static reset() {
         if (GlobalDashboardManager.instance) {
             const manager = GlobalDashboardManager.instance;
-            // Clear timers
-            if (manager.autoInitTimer) {
-                clearTimeout(manager.autoInitTimer);
-            }
             // Clear listeners
             manager.stateListeners.clear();
             manager.providers.clear();

package/dist/provider/DashboardProvider.js

@@ -41,11 +41,11 @@ export const DashboardProvider = ({ children, config, locale, translations, auto
     // Register this provider
     useEffect(() => {
         const providerId = providerIdRef.current;
-        manager.registerProvider(providerId, currentConfig);
+        manager.registerProvider(providerId, currentConfig, autoRefreshOnLocaleChange);
         return () => {
             manager.unregisterProvider(providerId);
         };
-    }, [manager, currentConfig]);
+    }, [manager, currentConfig, autoRefreshOnLocaleChange]);
     // Subscribe to global state changes
     useEffect(() => {
         const providerId = providerIdRef.current;
@@ -77,6 +77,7 @@ export const DashboardProvider = ({ children, config, locale, translations, auto
             const oldLocale = lastLocaleRef.current;
             lastLocaleRef.current = locale;
             if (autoRefreshOnLocaleChange) {
+                // Always call setLocale which will handle initialization if needed
                 manager.setLocale(locale).catch((error) => {
                     console.error('Failed to set locale:', error);
                     if (onError) {
@@ -90,15 +91,21 @@ export const DashboardProvider = ({ children, config, locale, translations, auto
                 if (engine) {
                     engine.updateLocale(locale);
                 }
+                else {
+                    // No engine yet, update config for future initialization
+                    manager.registerProvider(providerIdRef.current, currentConfig);
+                }
             }
             if (onLocaleChange) {
                 onLocaleChange(locale, oldLocale);
             }
         }
-    }, [locale, manager, autoRefreshOnLocaleChange, onLocaleChange, onError]);
+    }, [locale, manager, autoRefreshOnLocaleChange, onLocaleChange, onError, currentConfig]);
     // Auto-init on mount if requested
     useEffect(() => {
-        if (autoInit && !manager.isInitialized()) {
+        if (autoInit) {
+            // Always attempt to initialize when autoInit is true
+            // The manager will handle deduplication
             manager.init(currentConfig).catch((error) => {
                 console.error("Failed to auto-initialize dashboard:", error);
                 if (onError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datlv-trustshop/shopify-inapp-components",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "private": false,
   "description": "React TypeScript components for Shopify in-app dashboard content",
   "main": "dist/index.js",