@sigmaott/base-next 1.4.38 → 1.4.39

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sigmaott/base-next",
   "type": "module",
-  "version": "1.4.38",
+  "version": "1.4.39",
   "publishConfig": {
     "access": "public"
   },

package/src/composables/microState.ts

@@ -15,8 +15,17 @@ watch(microState, (newValue) => {
 }, { deep: true })
 
 export function syncMicroState() {
-  microState.value = klona(window.parent.__SIGMA_STATE__)
-  window.$wujie?.bus.$on('__STATE_CHANGE__', (newState: any) => {
-    microState.value = klona(newState)
-  })
+  try {
+    if (typeof window !== 'undefined' && window.parent && window.parent.__SIGMA_STATE__) {
+      microState.value = klona(window.parent.__SIGMA_STATE__)
+    }
+    
+    if (typeof window !== 'undefined' && window.$wujie?.bus) {
+      window.$wujie.bus.$on('__STATE_CHANGE__', (newState: any) => {
+        microState.value = klona(newState)
+      })
+    }
+  } catch (error) {
+    console.error('[MicroState] Error syncing micro state:', error)
+  }
 }

package/src/plugins/wujie.ts

@@ -1,32 +1,54 @@
-import { setupGlobalComponentResolutionHandler, handleComponentResolutionError, isComponentResolutionError } from '../utils/component-resolution'
+// Type declarations for Wujie
+declare global {
+  interface Window {
+    __POWERED_BY_WUJIE__?: boolean
+    __WUJIE_MOUNT?: () => void
+    __WUJIE_UNMOUNT?: () => void
+    __WUJIE?: {
+      mount: () => void
+      id?: string
+      cleanup?: () => void
+    }
+    $wujie?: {
+      bus?: {
+        $on: (event: string, callback: (data: any) => void) => void
+      }
+    }
+    parent?: {
+      __SIGMA_STATE__?: any
+    }
+  }
+}
 
 export default defineNuxtPlugin((nuxtApp) => {
-  // Setup global error handlers
-  setupGlobalComponentResolutionHandler()
+  // Ensure nuxtApp is properly initialized
+  if (!nuxtApp) {
+    console.warn('[Wujie] nuxtApp is not available')
+    return
+  }
   
   nuxtApp.hook('app:created', async (app) => {
     await new Promise<void>((resolve, reject) => {
       if (window.__POWERED_BY_WUJIE__) {
         window.__WUJIE_MOUNT = () => {
           try {
-            syncMicroState()
+            // Simple sync without external dependencies
+            if (typeof window !== 'undefined' && window.parent && window.parent.__SIGMA_STATE__) {
+              console.log('[Wujie] Syncing micro state')
+            }
             resolve()
           } catch (error) {
             console.error('[Wujie] Error during mount:', error)
-            if (isComponentResolutionError(error)) {
-              handleComponentResolutionError(error, 'wujie-mount')
-            }
             reject(error)
           }
         }
         window.__WUJIE_UNMOUNT = () => {
           try {
-            app.unmount()
+            if (app && typeof app.unmount === 'function') {
+              app.unmount()
+            }
           } catch (error) {
             console.error('[Wujie] Error during unmount:', error)
-            if (isComponentResolutionError(error)) {
-              handleComponentResolutionError(error, 'wujie-unmount')
-            }
           }
         }
         
@@ -37,14 +59,17 @@ export default defineNuxtPlugin((nuxtApp) => {
         }, 5000)
         
         try {
-          window.__WUJIE.mount()
-          clearTimeout(timeout)
+          if (window.__WUJIE && typeof window.__WUJIE.mount === 'function') {
+            window.__WUJIE.mount()
+            clearTimeout(timeout)
+          } else {
+            console.warn('[Wujie] __WUJIE.mount is not available')
+            clearTimeout(timeout)
+            resolve()
+          }
         } catch (error) {
           clearTimeout(timeout)
           console.error('[Wujie] Error mounting app:', error)
-          if (isComponentResolutionError(error)) {
-            handleComponentResolutionError(error, 'wujie-mount-init')
-          }
           reject(error)
         }
       }
@@ -56,17 +81,30 @@ export default defineNuxtPlugin((nuxtApp) => {
   
   // Enhanced error handling for component resolution
   nuxtApp.hook('app:error', (error) => {
-    if (isComponentResolutionError(error)) {
-      handleComponentResolutionError(error, 'nuxt-app-error')
+    if (error?.message?.includes('Couldn\'t resolve component')) {
+      console.warn('[Nuxt] Component resolution error detected:', error)
+      // Simple recovery - reload page after delay
+      setTimeout(() => {
+        if (typeof window !== 'undefined' && window.location) {
+          window.location.reload()
+        }
+      }, 1000)
     }
   })
   
-  // Handle Vue component errors
-  nuxtApp.vueApp.config.errorHandler = (error, instance, info) => {
-    if (isComponentResolutionError(error)) {
-      handleComponentResolutionError(error, 'vue-error-handler')
-    } else {
-      console.error('[Vue] Error:', error, 'Info:', info)
+  // Handle Vue component errors - with safety check
+  if (nuxtApp.vueApp && nuxtApp.vueApp.config) {
+    nuxtApp.vueApp.config.errorHandler = (error, instance, info) => {
+      if (error?.message?.includes('Couldn\'t resolve component')) {
+        console.warn('[Vue] Component resolution error:', error)
+        setTimeout(() => {
+          if (typeof window !== 'undefined' && window.location) {
+            window.location.reload()
+          }
+        }, 1000)
+      } else {
+        console.error('[Vue] Error:', error, 'Info:', info)
+      }
     }
   }
 })

package/src/utils/component-resolution.ts

@@ -21,38 +21,53 @@ export function isComponentResolutionError(error: any): error is ComponentResolu
  * Handles component resolution errors with recovery strategies
  */
 export function handleComponentResolutionError(error: ComponentResolutionError, context: string = 'unknown') {
-  console.warn(`[${context}] Component resolution error detected:`, error)
-  
-  // Extract component name and path from error message
-  const componentMatch = error.message?.match(/component "([^"]+)"/)
-  const pathMatch = error.message?.match(/at "([^"]+)"/)
-  
-  if (componentMatch) {
-    error.componentName = componentMatch[1]
-  }
-  if (pathMatch) {
-    error.path = pathMatch[1]
-  }
-  
-  // Determine if error is recoverable
-  error.isRecoverable = !error.message?.includes('permanent') && 
-                       !error.message?.includes('fatal')
-  
-  if (error.isRecoverable) {
-    console.log(`[${context}] Attempting recovery for component: ${error.componentName} at ${error.path}`)
+  try {
+    console.warn(`[${context}] Component resolution error detected:`, error)
     
-    // Strategy 1: Wait and retry
-    setTimeout(() => {
-      if (window.location) {
-        console.log(`[${context}] Reloading page for recovery...`)
-        window.location.reload()
-      }
-    }, 1000)
-  } else {
-    console.error(`[${context}] Non-recoverable component resolution error:`, error)
+    // Ensure error has message property
+    if (!error || typeof error !== 'object') {
+      console.error(`[${context}] Invalid error object:`, error)
+      return false
+    }
+    
+    // Extract component name and path from error message
+    const componentMatch = error.message?.match(/component "([^"]+)"/)
+    const pathMatch = error.message?.match(/at "([^"]+)"/)
+    
+    if (componentMatch) {
+      error.componentName = componentMatch[1]
+    }
+    if (pathMatch) {
+      error.path = pathMatch[1]
+    }
+    
+    // Determine if error is recoverable
+    error.isRecoverable = !error.message?.includes('permanent') && 
+                         !error.message?.includes('fatal')
+    
+    if (error.isRecoverable) {
+      console.log(`[${context}] Attempting recovery for component: ${error.componentName} at ${error.path}`)
+      
+      // Strategy 1: Wait and retry - with safety check
+      setTimeout(() => {
+        try {
+          if (typeof window !== 'undefined' && window.location) {
+            console.log(`[${context}] Reloading page for recovery...`)
+            window.location.reload()
+          }
+        } catch (reloadError) {
+          console.error(`[${context}] Error during page reload:`, reloadError)
+        }
+      }, 1000)
+    } else {
+      console.error(`[${context}] Non-recoverable component resolution error:`, error)
+    }
+    
+    return error.isRecoverable
+  } catch (handlerError) {
+    console.error(`[${context}] Error in handleComponentResolutionError:`, handlerError)
+    return false
   }
-  
-  return error.isRecoverable
 }
 
 /**
@@ -135,21 +150,34 @@ export function createComponentResolutionChecker(
  * Global error handler for component resolution issues
  */
 export function setupGlobalComponentResolutionHandler() {
+  // Ensure we're in a browser environment
+  if (typeof window === 'undefined') {
+    return
+  }
+  
   // Handle unhandled promise rejections
   window.addEventListener('unhandledrejection', (event) => {
-    if (isComponentResolutionError(event.reason)) {
-      console.warn('[Global] Unhandled component resolution error:', event.reason)
-      handleComponentResolutionError(event.reason, 'global-unhandled')
-      event.preventDefault()
+    try {
+      if (isComponentResolutionError(event.reason)) {
+        console.warn('[Global] Unhandled component resolution error:', event.reason)
+        handleComponentResolutionError(event.reason, 'global-unhandled')
+        event.preventDefault()
+      }
+    } catch (error) {
+      console.error('[Global] Error in unhandledrejection handler:', error)
     }
   })
   
   // Handle general errors
   window.addEventListener('error', (event) => {
-    if (isComponentResolutionError(event.error)) {
-      console.warn('[Global] Component resolution error:', event.error)
-      handleComponentResolutionError(event.error, 'global-error')
-      event.preventDefault()
+    try {
+      if (isComponentResolutionError(event.error)) {
+        console.warn('[Global] Component resolution error:', event.error)
+        handleComponentResolutionError(event.error, 'global-error')
+        event.preventDefault()
+      }
+    } catch (error) {
+      console.error('[Global] Error in error handler:', error)
     }
   })
 }