zova-module-a-router 5.0.35 → 5.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-router",
-  "version": "5.0.35",
+  "version": "5.0.38",
   "title": "a-router",
   "zovaModule": {
     "capabilities": {
@@ -37,5 +37,5 @@
   "dependencies": {
     "vue-router": "^4.3.2"
   },
-  "gitHead": "66609919a02dea2e2e6818412225d719223ae290"
+  "gitHead": "90bb78df182aa8db862d6b44e86d23aa33b195fa"
 }

package/src/api/index.ts

@@ -0,0 +1,2 @@
+export * from './interface/index.js';
+export * from './service/index.js';

package/src/api/interface/index.ts

@@ -0,0 +1 @@
+export {};

package/src/api/service/index.ts

@@ -0,0 +1 @@
+export const services = {};

package/src/bean/{store.router.ts → bean.router.ts}

@@ -1,14 +1,14 @@
-import { BeanBase, Cast, IModule, IPageNameRecord, IPagePathRecord, Store, TypeEventOff } from 'zova';
+import { Bean, BeanBase, Cast, IModule, IPageNameRecord, IPagePathRecord, TypeEventOff } from 'zova';
 import { Router } from 'vue-router';
 import * as ModuleInfo from '@cabloy/module-info';
 import { IModuleRoute, IModuleRouteComponent } from '../types.js';
 
 const SymbolRouter = Symbol('SymbolRouter');
 
-export type StoreRouterLike = StoreRouter & Router;
+export type BeanRouterLike = BeanRouter & Router;
 
-@Store()
-export class StoreRouter extends BeanBase {
+@Bean({ scene: 'bean', name: 'router', containerScope: 'ctx' })
+export class BeanRouter extends BeanBase {
   [SymbolRouter]: Router;
   eventRouterGuards: TypeEventOff;
 
@@ -27,7 +27,7 @@ export class StoreRouter extends BeanBase {
       if (!router) {
         throw new Error('Should provide router');
       }
-      this.bean.provide('a-router:router', Cast<StoreRouterLike>(this));
+      this.bean.provide('a-router:router', Cast<BeanRouterLike>(this));
       // event
       this.eventRouterGuards = this.app.meta.event.on('a-router:routerGuards', async (context, next) => {
         this._routerGuards(context.data);
@@ -98,7 +98,7 @@ export class StoreRouter extends BeanBase {
     return `${fullPath}${join}${query2str}`;
   }
 
-  private _routerGuards(router: StoreRouterLike) {
+  private _routerGuards(router: BeanRouterLike) {
     router.beforeEach(async to => {
       // fullPath
       const fullPath = to.fullPath;

package/src/bean/virtual.router.ts

@@ -1,5 +1,5 @@
 import { BeanBase, TypeEventOff, Virtual } from 'zova';
-import { StoreRouterLike } from './store.router.js';
+import { BeanRouterLike } from './bean.router.js';
 
 @Virtual()
 export class BeanRouterBase<TScopeModule = unknown> extends BeanBase<TScopeModule> {
@@ -18,5 +18,5 @@ export class BeanRouterBase<TScopeModule = unknown> extends BeanBase<TScopeModul
     }
   }
 
-  protected onRouterGuards(_router: StoreRouterLike) {}
+  protected onRouterGuards(_router: BeanRouterLike) {}
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './config/index.js';
 export * from './resource/index.js';
+export * from './api/index.js';
 export * from './routes.js';
 export * from './types.js';
 export * from './monkey.js';

package/src/monkey.ts

@@ -13,10 +13,10 @@ import {
 } from 'zova';
 import * as ModuleInfo from '@cabloy/module-info';
 import { useRoute } from 'vue-router';
-import { StoreRouterLike } from './bean/store.router.js';
+import { BeanRouterLike } from './bean/bean.router.js';
 
 export class Monkey extends BeanSimple implements IMonkeySystem, IMonkeyModule, IMonkeyController {
-  private _storeRouter: StoreRouterLike;
+  private _beanRouter: BeanRouterLike;
   private _moduleSelf: IModule;
 
   constructor(moduleSelf: IModule) {
@@ -24,15 +24,15 @@ export class Monkey extends BeanSimple implements IMonkeySystem, IMonkeyModule,
     this._moduleSelf = moduleSelf;
   }
 
-  async getStoreRouter() {
-    if (!this._storeRouter) {
-      this._storeRouter = (await this.bean._getBean('a-router.store.router', false)) as StoreRouterLike;
+  async getBeanRouter() {
+    if (!this._beanRouter) {
+      this._beanRouter = (await this.bean._getBean('a-router.bean.router', false)) as BeanRouterLike;
     }
-    return this._storeRouter;
+    return this._beanRouter;
   }
 
-  async appInitialize() {}
-  async appInitialized() {
+  async appInitialize(_bean: BeanContainerLike) {}
+  async appInitialized(_bean: BeanContainerLike) {
     // emit event
     const router = this.bean.inject('a-router:router');
     await this.app.meta.event.emit('a-router:routerGuards', router);
@@ -51,8 +51,8 @@ export class Monkey extends BeanSimple implements IMonkeySystem, IMonkeyModule,
   beanDisposed(_bean: BeanContainerLike, _beanInstance: BeanBase) {}
   async moduleLoading(module: IModule) {
     if (this._moduleSelf === module) return;
-    const storeRouter = await this.getStoreRouter();
-    storeRouter._registerRoutes(module);
+    const beanRouter = await this.getBeanRouter();
+    beanRouter._registerRoutes(module);
   }
   async moduleLoaded(_module: IModule) {}
   async configLoaded(_module: IModule, _config) {}
@@ -61,25 +61,29 @@ export class Monkey extends BeanSimple implements IMonkeySystem, IMonkeyModule,
   }
   controllerDataInit(controllerData: IControllerData, controller: BeanBase) {
     // only for controller page
-    if (controller instanceof BeanControllerPageBase) {
-      const route = controllerData.context.route;
-      const schemaKey = String(route.name || route.path);
-      let schemas: TypePageSchema | undefined;
-      const moduleName = ModuleInfo.parseName(schemaKey)!;
-      const module = this.app.meta.module.get(moduleName)!;
-      if (route.name) {
-        schemas = module.resource.pageNameSchemas?.[schemaKey];
-      } else {
-        schemas = module.resource.pagePathSchemas?.[schemaKey];
-      }
-      controller.$params = useComputed(() => {
-        if (!schemas?.params) throw new Error(`page params schema not found: ${schemaKey}`);
-        return schemas.params.parse(route.params);
-      });
-      controller.$query = useComputed(() => {
-        if (!schemas?.query) throw new Error(`page query schema not found: ${schemaKey}`);
-        return schemas.query.parse(route.query);
-      });
+    if (!(controller instanceof BeanControllerPageBase)) return;
+    const route = controllerData.context.route;
+    if (!route) return;
+    const schemaKey = String(route.name || route.path);
+    let schemas: TypePageSchema | undefined;
+    const moduleInfo = ModuleInfo.parseInfo(ModuleInfo.parseName(schemaKey));
+    if (!moduleInfo) {
+      // do nothing
+      return;
     }
+    const module = this.app.meta.module.get(moduleInfo.relativeName)!;
+    if (route.name) {
+      schemas = module.resource.pageNameSchemas?.[schemaKey];
+    } else {
+      schemas = module.resource.pagePathSchemas?.[schemaKey];
+    }
+    controller.$params = useComputed(() => {
+      if (!schemas?.params) throw new Error(`page params schema not found: ${schemaKey}`);
+      return schemas.params.parse(route.params);
+    });
+    controller.$query = useComputed(() => {
+      if (!schemas?.query) throw new Error(`page query schema not found: ${schemaKey}`);
+      return schemas.query.parse(route.query);
+    });
   }
 }

package/src/resource/beans.ts

@@ -1,9 +1,9 @@
-export * from '../bean/store.router.js';
+export * from '../bean/bean.router.js';
 export * from '../bean/virtual.router.js';
-import { StoreRouter } from '../bean/store.router.js';
+import { BeanRouter } from '../bean/bean.router.js';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecord {
-    'a-router.store.router': StoreRouter;
+    'a-router.bean.router': BeanRouter;
   }
 }

package/src/resource/events.ts

@@ -1,9 +1,9 @@
-import { StoreRouterLike } from './beans.js';
+import { BeanRouterLike } from './beans.js';
 
 import 'zova';
 declare module 'zova' {
   export interface IEventRecord {
-    'a-router:routerGuards': StoreRouterLike;
+    'a-router:routerGuards': BeanRouterLike;
   }
 
   export interface IEventResultRecord {

package/src/resource/injects.ts

@@ -1,10 +1,10 @@
 import { Router } from 'vue-router';
-import { StoreRouterLike } from '../bean/store.router.js';
+import { BeanRouterLike } from '../bean/bean.router.js';
 
 import 'zova';
 declare module 'zova' {
   export interface IInjectRecord {
     'a-router:appRouter': Router;
-    'a-router:router': StoreRouterLike;
+    'a-router:router': BeanRouterLike;
   }
 }

package/src/resource/scope.ts

@@ -1,6 +1,7 @@
 import { BeanScopeBase, Scope, TypeLocaleBase, TypeModuleResource } from 'zova';
 import { config, Errors, locales, constants } from '../config/index.js';
 import { components } from './components.js';
+import { services } from '../api/service/index.js';
 
 @Scope()
 export class ScopeModuleARouter extends BeanScopeBase {}
@@ -11,7 +12,8 @@ export interface ScopeModuleARouter
     typeof config,
     typeof Errors,
     (typeof locales)[TypeLocaleBase],
-    typeof constants
+    typeof constants,
+    typeof services
   > {}
 
 import 'zova';

package/src/types.ts

@@ -1,6 +1,6 @@
 import { IComponentLayoutRecord, TypePageSchemas } from 'zova';
 import { RouteComponent, RouteLocationNormalizedLoaded, RouteRecordRaw } from 'vue-router';
-import { StoreRouterLike } from './bean/store.router.js';
+import { BeanRouterLike } from './bean/bean.router.js';
 
 export type Lazy<T> = () => Promise<T>;
 export type IModuleRouteComponent = RouteComponent | Lazy<RouteComponent>;
@@ -17,7 +17,7 @@ declare module 'vue-router' {
 
 declare module 'zova' {
   export interface BeanBase {
-    $router: StoreRouterLike;
+    $router: BeanRouterLike;
   }
 
   export interface IModuleResource {