zova-core 5.1.47 → 5.1.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zova-core",
-  "version": "5.1.47",
-  "gitHead": "3f9b52609e567f257c17cdeef8fc8ef90cec7ff6",
+  "version": "5.1.49",
+  "gitHead": "7332ce2a4b44504a88c64da981b60336ebef7e9b",
   "description": "A vue3 framework with ioc",
   "keywords": [
     "ioc",
@@ -51,7 +51,7 @@
     "@cabloy/vue-compiler-sfc": "^3.5.14",
     "@cabloy/vue-reactivity": "^3.5.16",
     "@cabloy/vue-router": "^4.4.16",
-    "@cabloy/vue-runtime-core": "^3.5.53",
+    "@cabloy/vue-runtime-core": "^3.5.56",
     "@cabloy/vue-runtime-dom": "^3.5.13",
     "@cabloy/vue-server-renderer": "^3.5.18",
     "@cabloy/word-utils": "^2.1.14",

package/src/bean/beanContainer.ts

@@ -103,7 +103,7 @@ export class BeanContainer {
             beanInstance,
           );
           this.runWithInstanceScopeOrAppContext(() => {
-            beanInstance.__dispose__();
+            return beanInstance.__dispose__();
           });
           this.app.meta.module._monkeyModuleSync(
             false,
@@ -630,8 +630,8 @@ export class BeanContainer {
       await this.app?.meta.module._monkeyModule(true, 'beanInit', undefined, this, beanInstance);
     }
     if (!(beanInstance instanceof BeanAopBase) && beanInstance.__init__) {
-      await this.runWithInstanceScopeOrAppContext(async () => {
-        await beanInstance.__init__(...args);
+      await this.runWithInstanceScopeOrAppContext(() => {
+        return beanInstance.__init__(...args);
       });
     }
     if (this.containerType === 'sys') {

package/src/bean/beanControllerPageBase.ts

@@ -21,6 +21,7 @@ export class BeanControllerPageBase extends BeanBase {
 
   /** @internal */
   public __updateControllerData() {
+    if (!this.app) return;
     this.app.meta.module._monkeyModuleSync(true, 'controllerDataUpdate', undefined, this);
   }
 }

package/src/core/component/module.ts

@@ -11,6 +11,7 @@ import type {
   IMonkeyApp,
   IMonkeyController,
   IMonkeyModule,
+  PluginZovaModulesMeta,
   TypeMonkeyName,
 } from '../../types/index.ts';
 
@@ -23,6 +24,14 @@ export class AppModule extends BeanSimple {
   private mainInstances: Record<string, IModuleMain> = {};
   private monkeyInstances: Record<string, IMonkeyModule & IMonkeyApp & IMonkeyController> = {};
 
+  private _ensureModulesMeta(): PluginZovaModulesMeta {
+    const modulesMeta = this.sys.meta.module.getModulesMeta();
+    if (!modulesMeta) {
+      throw new Error('module registry has been disposed');
+    }
+    return modulesMeta;
+  }
+
   /** @internal */
   public async initialize() {
     await this._requireAllSpecifics('preload');
@@ -34,6 +43,7 @@ export class AppModule extends BeanSimple {
   get(moduleName: string, forceLoad?: boolean): IModule | undefined;
   get(moduleName: IModuleInfo, forceLoad?: boolean): IModule | undefined;
   get(moduleName: string | IModuleInfo, forceLoad?: boolean): IModule | undefined {
+    if (!this.sys.meta.module.getModulesMeta()) return undefined;
     // module info
     if (!moduleName) return undefined;
     const moduleInfo =
@@ -67,8 +77,9 @@ export class AppModule extends BeanSimple {
     // should not try check get directly
     // const module = this.getOnly(relativeName);
     // if (module) return module;
+    const modulesMeta = this._ensureModulesMeta();
     // module
-    const moduleRepo = this.sys.meta.module.modulesMeta.modules[relativeName];
+    const moduleRepo = modulesMeta.modules[relativeName];
     if (!moduleRepo) throw new Error(`module not exists: ${relativeName}`);
     // install
     await this._install(relativeName, moduleRepo);
@@ -84,15 +95,16 @@ export class AppModule extends BeanSimple {
   }
 
   private async _requireAllSpecifics(capabilityName: 'preload' | 'monkey' | 'sync') {
-    const moduleNames = this.sys.meta.module.modulesMeta.moduleNames.filter(moduleName => {
-      const module = this.sys.meta.module.modulesMeta.modules[moduleName];
+    const modulesMeta = this._ensureModulesMeta();
+    const moduleNames = modulesMeta.moduleNames.filter(moduleName => {
+      const module = modulesMeta.modules[moduleName];
       return module.info.capabilities?.[capabilityName];
     });
     // if (moduleNames.length > 0) {
     //   this.sys.meta.logger.child('module', 'default').debug(`app modules: ${capabilityName}: ${moduleNames.join(',')}`);
     // }
     for (const moduleName of moduleNames) {
-      const module = this.sys.meta.module.modulesMeta.modules[moduleName];
+      const module = modulesMeta.modules[moduleName];
       await this._install(moduleName, module);
     }
   }
@@ -167,29 +179,31 @@ export class AppModule extends BeanSimple {
     moduleTarget?: IModule,
     ...monkeyData: any[]
   ) {
+    const modulesMeta = this.sys.meta.module.getModulesMeta();
+    if (!modulesMeta) return;
     // self: main
     if (moduleTarget) {
       const mainInstance = this.mainInstances[moduleTarget.info.relativeName];
       if (mainInstance && mainInstance[monkeyName]) {
         // @ts-ignore ignore
-        await this.app.vue.runWithContext(async () => {
-          await mainInstance[monkeyName](...monkeyData);
+        await this.app.vue.runWithContext(() => {
+          return mainInstance[monkeyName](...monkeyData);
         });
       }
     }
     // module monkey
-    await forEach(this.sys.meta.module.modulesMeta.moduleNames, order, async key => {
-      const moduleMonkey: IModule = this.sys.meta.module.modulesMeta.modules[key];
+    await forEach(modulesMeta.moduleNames, order, async key => {
+      const moduleMonkey: IModule = modulesMeta.modules[key];
       if (moduleMonkey.info.capabilities?.monkey) {
         const monkeyInstance = this.monkeyInstances[key];
         if (monkeyInstance && monkeyInstance[monkeyName]) {
-          await this.app.vue.runWithContext(async () => {
+          await this.app.vue.runWithContext(() => {
             if (moduleTarget === undefined) {
               // @ts-ignore ignore
-              await monkeyInstance[monkeyName](...monkeyData);
+              return monkeyInstance[monkeyName](...monkeyData);
             } else {
               // @ts-ignore ignore
-              await monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+              return monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
             }
           });
         }
@@ -198,13 +212,13 @@ export class AppModule extends BeanSimple {
     // app monkey
     const appMonkey = this.app.meta.appMonkey;
     if (appMonkey && appMonkey[monkeyName]) {
-      await this.app.vue.runWithContext(async () => {
+      await this.app.vue.runWithContext(() => {
         if (moduleTarget === undefined) {
           // @ts-ignore ignore
-          await appMonkey[monkeyName](...monkeyData);
+          return appMonkey[monkeyName](...monkeyData);
         } else {
           // @ts-ignore ignore
-          await appMonkey[monkeyName](moduleTarget, ...monkeyData);
+          return appMonkey[monkeyName](moduleTarget, ...monkeyData);
         }
       });
     }
@@ -217,29 +231,31 @@ export class AppModule extends BeanSimple {
     moduleTarget?: IModule,
     ...monkeyData: any[]
   ) {
+    const modulesMeta = this.sys.meta.module.getModulesMeta();
+    if (!modulesMeta) return;
     // self: main
     if (moduleTarget) {
       const mainInstance = this.mainInstances[moduleTarget.info.relativeName];
       if (mainInstance && mainInstance[monkeyName]) {
         // @ts-ignore ignore
-        this.app.vue.runWithContext(async () => {
-          mainInstance[monkeyName](...monkeyData);
+        this.app.vue.runWithContext(() => {
+          return mainInstance[monkeyName](...monkeyData);
         });
       }
     }
     // module monkey
-    forEachSync(this.sys.meta.module.modulesMeta.moduleNames, order, key => {
-      const moduleMonkey: IModule = this.sys.meta.module.modulesMeta.modules[key];
+    forEachSync(modulesMeta.moduleNames, order, key => {
+      const moduleMonkey: IModule = modulesMeta.modules[key];
       if (moduleMonkey.info.capabilities?.monkey) {
         const monkeyInstance = this.monkeyInstances[key];
         if (monkeyInstance && monkeyInstance[monkeyName]) {
-          this.app.vue.runWithContext(async () => {
+          this.app.vue.runWithContext(() => {
             if (moduleTarget === undefined) {
               // @ts-ignore ignore
-              monkeyInstance[monkeyName](...monkeyData);
+              return monkeyInstance[monkeyName](...monkeyData);
             } else {
               // @ts-ignore ignore
-              monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+              return monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
             }
           });
         }
@@ -248,13 +264,13 @@ export class AppModule extends BeanSimple {
     // app monkey
     const appMonkey = this.app.meta.appMonkey;
     if (appMonkey && appMonkey[monkeyName]) {
-      this.app.vue.runWithContext(async () => {
+      this.app.vue.runWithContext(() => {
         if (moduleTarget === undefined) {
           // @ts-ignore ignore
-          appMonkey[monkeyName](...monkeyData);
+          return appMonkey[monkeyName](...monkeyData);
         } else {
           // @ts-ignore ignore
-          appMonkey[monkeyName](moduleTarget, ...monkeyData);
+          return appMonkey[monkeyName](moduleTarget, ...monkeyData);
         }
       });
     }

package/src/core/context/component.ts

@@ -4,15 +4,21 @@ import { BeanSimple } from '../../bean/beanSimple.ts';
 import { BeanControllerIdentifier, BeanRenderIdentifier } from '../../bean/type.ts';
 import { cast } from '../../types/utils/cast.ts';
 
+const SymbolTypeSSRRenderOriginal = Symbol('SymbolTypeSSRRenderOriginal');
+const SymbolTypeSSRRenderResetCount = Symbol('SymbolTypeSSRRenderResetCount');
+
 export class CtxComponent extends BeanSimple {
   private _bean_render_original: any;
+  private _instance_ssrRender_original: any;
+  private _renderPatched = false;
+  private _ssrRenderReset = false;
 
   activate() {
     if (this.ctx.disposed) return;
     const renderMethod = 'render';
-    const self = this;
     const instance = cast(this.ctx.instance);
     this._bean_render_original = instance[renderMethod];
+    const self = this;
     instance[renderMethod] = function (this, ...args) {
       if (instance.isUnmounted) return;
       if (!self.ctx.meta.state.inited.state) {
@@ -33,16 +39,42 @@ export class CtxComponent extends BeanSimple {
       //   return render.render();
       // }
     };
-    instance.type.ssrRender = null;
+    this._renderPatched = true;
+    const componentType = cast(instance.type);
+    const ssrRenderResetCount = componentType[SymbolTypeSSRRenderResetCount] ?? 0;
+    if (ssrRenderResetCount === 0) {
+      componentType[SymbolTypeSSRRenderOriginal] = componentType.ssrRender;
+      componentType.ssrRender = null;
+    }
+    componentType[SymbolTypeSSRRenderResetCount] = ssrRenderResetCount + 1;
+    this._instance_ssrRender_original = instance.ssrRender;
     instance.ssrRender = null;
+    this._ssrRenderReset = true;
   }
 
   /** @internal */
   public dispose() {
     const renderMethod = 'render';
     const instance = cast(this.ctx.instance);
-    instance[renderMethod] = this._bean_render_original;
+    if (this._renderPatched) {
+      instance[renderMethod] = this._bean_render_original;
+    }
+    if (this._ssrRenderReset) {
+      instance.ssrRender = this._instance_ssrRender_original;
+      const componentType = cast(instance.type);
+      const ssrRenderResetCount = componentType[SymbolTypeSSRRenderResetCount] ?? 0;
+      if (ssrRenderResetCount <= 1) {
+        componentType.ssrRender = componentType[SymbolTypeSSRRenderOriginal];
+        componentType[SymbolTypeSSRRenderOriginal] = undefined;
+        componentType[SymbolTypeSSRRenderResetCount] = 0;
+      } else {
+        componentType[SymbolTypeSSRRenderResetCount] = ssrRenderResetCount - 1;
+      }
+    }
     this._bean_render_original = null;
+    this._instance_ssrRender_original = null;
+    this._renderPatched = false;
+    this._ssrRenderReset = false;
   }
 
   private _getRender(): any {

package/src/core/context/util.ts

@@ -1,4 +1,4 @@
-import { setCurrentInstance } from '@cabloy/vue-runtime-core';
+import { withCurrentInstanceScope, withCurrentInstanceScopeSSR } from '@cabloy/vue-runtime-core';
 import { pauseTracking, resetTracking } from '@vue/reactivity';
 
 import { BeanSimple } from '../../bean/beanSimple.ts';
@@ -9,17 +9,21 @@ export class CtxUtil extends BeanSimple {
     if (this.ctx.disposed) {
       throwErrorComponentUnmounted();
     }
-    const reset = setCurrentInstance(this.ctx.instance as any);
-    if (!tracking) {
-      pauseTracking();
-    }
-    try {
-      return fn();
-    } finally {
+    const instance = this.ctx.instance as any;
+    const runner = process.env.SERVER ? withCurrentInstanceScopeSSR : withCurrentInstanceScope;
+    const result = runner(instance, () => {
       if (!tracking) {
-        resetTracking();
+        pauseTracking();
       }
-      reset();
-    }
+      try {
+        const result = fn();
+        return result;
+      } finally {
+        if (!tracking) {
+          resetTracking();
+        }
+      }
+    });
+    return result;
   }
 }

package/src/core/sys/module.ts

@@ -20,7 +20,7 @@ import { StateLock } from '../../utils/stateLock.ts';
 import { deepExtend } from '../sys/util.ts';
 
 export class SysModule extends BeanSimple {
-  public modulesMeta: PluginZovaModulesMeta;
+  public modulesMeta: PluginZovaModulesMeta | undefined;
   private modules: Record<string, IModule> = shallowReactive({});
   private mainInstances: Record<string, IModuleMainSys> = {};
   private monkeyInstances: Record<string, IMonkeyModuleSys & IMonkeySys> = {};
@@ -39,13 +39,26 @@ export class SysModule extends BeanSimple {
 
   /** @internal */
   public dispose() {
-    this.modulesMeta = undefined as any;
+    this.modulesMeta = undefined;
+  }
+
+  public getModulesMeta(): PluginZovaModulesMeta | undefined {
+    return this.modulesMeta;
+  }
+
+  private _ensureModulesMeta(): PluginZovaModulesMeta {
+    const modulesMeta = this.modulesMeta;
+    if (!modulesMeta) {
+      throw new Error('module registry has been disposed');
+    }
+    return modulesMeta;
   }
 
   get<K extends TypeBeanScopeRecordKeys>(moduleName: K): IModule | undefined;
   get(moduleName: string): IModule | undefined;
   get(moduleName: IModuleInfo): IModule | undefined;
   get(moduleName: string | IModuleInfo): IModule | undefined {
+    if (!this.modulesMeta) return undefined;
     // module info
     if (!moduleName) return undefined;
     const moduleInfo =
@@ -75,8 +88,9 @@ export class SysModule extends BeanSimple {
     // should not try check get directly
     // const module = this.getOnly(relativeName);
     // if (module) return module;
+    const modulesMeta = this._ensureModulesMeta();
     // module
-    const moduleRepo = this.modulesMeta.modules[relativeName];
+    const moduleRepo = modulesMeta.modules[relativeName];
     if (!moduleRepo) throw new Error(`module not exists: ${relativeName}`);
     // install
     await this._install(relativeName, moduleRepo);
@@ -88,19 +102,22 @@ export class SysModule extends BeanSimple {
   exists(moduleName: string): boolean;
   exists(moduleName: IModuleInfo): boolean;
   exists(moduleName: string | IModuleInfo): boolean {
+    const modulesMeta = this.modulesMeta;
+    if (!modulesMeta) return false;
     // module info
     if (!moduleName) return false;
     const moduleInfo =
       typeof moduleName === 'string' ? ModuleInfo.parseInfo(moduleName) : moduleName;
     if (!moduleInfo) throw new Error(`invalid module name: ${moduleName}`);
-    const moduleRepo = this.modulesMeta.modules[moduleInfo.relativeName];
+    const moduleRepo = modulesMeta.modules[moduleInfo.relativeName];
     return !!moduleRepo;
   }
 
   private async _loadAllMonkeysAndSyncsAndPreloads() {
+    const modulesMeta = this._ensureModulesMeta();
     const moduleNames: string[] = [];
-    for (const moduleName of this.modulesMeta.moduleNames) {
-      const module = this.modulesMeta.modules[moduleName];
+    for (const moduleName of modulesMeta.moduleNames) {
+      const module = modulesMeta.modules[moduleName];
       const info = module.info;
       const shouldLoad =
         process.env.SERVER ||
@@ -119,10 +136,11 @@ export class SysModule extends BeanSimple {
 
   public async loadModules(moduleNames: string[]) {
     if (moduleNames.length === 0) return;
+    const modulesMeta = this._ensureModulesMeta();
     const promises: Promise<IModuleResource>[] = [];
     const moduleNamesLoading: string[] = [];
     for (const moduleName of moduleNames) {
-      const module = this.modulesMeta.modules[moduleName];
+      const module = modulesMeta.modules[moduleName];
       if (!module) throw new Error(`module not found: ${moduleName}`);
       const moduleResource = module.resource as any;
       if (typeof moduleResource === 'function') {
@@ -137,13 +155,14 @@ export class SysModule extends BeanSimple {
     const modulesResource = await Promise.all(promises);
     for (let i = 0; i < modulesResource.length; i++) {
       const moduleName = moduleNamesLoading[i];
-      this.modulesMeta.modules[moduleName].resource = modulesResource[i];
+      modulesMeta.modules[moduleName].resource = modulesResource[i];
     }
   }
 
   private async _requireAllSpecifics(capabilityName: 'preload' | 'monkey' | 'sync') {
-    const moduleNames = this.modulesMeta.moduleNames.filter(moduleName => {
-      const module = this.modulesMeta.modules[moduleName];
+    const modulesMeta = this._ensureModulesMeta();
+    const moduleNames = modulesMeta.moduleNames.filter(moduleName => {
+      const module = modulesMeta.modules[moduleName];
       return module.info.capabilities?.[capabilityName];
     });
     if (moduleNames.length > 0) {
@@ -152,14 +171,15 @@ export class SysModule extends BeanSimple {
         .debug(`modules ${capabilityName}: ${moduleNames.join(',')}`);
     }
     for (const moduleName of moduleNames) {
-      const module = this.modulesMeta.modules[moduleName];
+      const module = modulesMeta.modules[moduleName];
       await this._install(moduleName, module);
     }
   }
 
   private async _requireAllOthers() {
-    for (const moduleName of this.modulesMeta.moduleNames) {
-      const module = this.modulesMeta.modules[moduleName];
+    const modulesMeta = this._ensureModulesMeta();
+    for (const moduleName of modulesMeta.moduleNames) {
+      const module = modulesMeta.modules[moduleName];
       const info = module.info;
       const shouldInstall =
         !info.capabilities?.monkey && !info.capabilities?.sync && !info.capabilities?.preload;
@@ -273,6 +293,8 @@ export class SysModule extends BeanSimple {
     moduleTarget?: IModule,
     ...monkeyData: any[]
   ) {
+    const modulesMeta = this.modulesMeta;
+    if (!modulesMeta) return;
     // self: main
     if (moduleTarget) {
       const mainInstance = this.mainInstances[moduleTarget.info.relativeName];
@@ -281,8 +303,8 @@ export class SysModule extends BeanSimple {
       }
     }
     // module monkey
-    await forEach(this.modulesMeta.moduleNames, order, async key => {
-      const moduleMonkey: IModule = this.modulesMeta.modules[key];
+    await forEach(modulesMeta.moduleNames, order, async key => {
+      const moduleMonkey: IModule = modulesMeta.modules[key];
       if (moduleMonkey.info.capabilities?.monkey) {
         const monkeyInstance = this.monkeyInstances[key];
         if (monkeyInstance && monkeyInstance[monkeyName]) {
@@ -316,6 +338,8 @@ export class SysModule extends BeanSimple {
     moduleTarget?: IModule,
     ...monkeyData: any[]
   ) {
+    const modulesMeta = this.modulesMeta;
+    if (!modulesMeta) return;
     // self: main
     if (moduleTarget) {
       const mainInstance = this.mainInstances[moduleTarget.info.relativeName];
@@ -324,8 +348,8 @@ export class SysModule extends BeanSimple {
       }
     }
     // module monkey
-    forEachSync(this.modulesMeta.moduleNames, order, key => {
-      const moduleMonkey: IModule = this.modulesMeta.modules[key];
+    forEachSync(modulesMeta.moduleNames, order, key => {
+      const moduleMonkey: IModule = modulesMeta.modules[key];
       if (moduleMonkey.info.capabilities?.monkey) {
         const monkeyInstance = this.monkeyInstances[key];
         if (monkeyInstance && monkeyInstance[monkeyName]) {

package/src/core/sys/sys.ts

@@ -96,11 +96,12 @@ export class ZovaSys {
       viteHot.on('vite:beforeFullReload', hook);
     }
     if (process.env.CLIENT && typeof window !== 'undefined') {
-      const hook = () => {
+      const hook = (event: PageTransitionEvent) => {
+        if (event.persisted) return;
         this.close();
-        window.removeEventListener('beforeunload', hook);
+        window.removeEventListener('pagehide', hook);
       };
-      window.addEventListener('beforeunload', hook);
+      window.addEventListener('pagehide', hook);
     }
   }