cabloy 5.1.167 → 5.1.169

package/zova/src/suite/cabloy-basic/modules/basic-resource/test/lib/resourcePickerPageHost.test.ts

@@ -0,0 +1,94 @@
+import type { IResourceRenderBlockOptionsBlock } from 'zova-module-a-openapi';
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createResourcePickerPageHost } from '../../src/lib/resourcePickerPageHost.ts';
+
+function createDialog() {
+  const resolved: unknown[] = [];
+  let cancelled = false;
+  const dialog = {
+    id: 1,
+    props: {
+      resource: 'training-student:student',
+      selectionMode: 'multiple' as const,
+      selectionMax: 2,
+    },
+    session: {
+      selectedIds: [1],
+      selectedRows: [{ id: 1, name: 'One' }],
+    },
+    resolve(value: unknown) {
+      resolved.push(value);
+    },
+    cancel() {
+      cancelled = true;
+    },
+  };
+  return {
+    dialog,
+    resolved,
+    get cancelled() {
+      return cancelled;
+    },
+  };
+}
+
+test('Basic picker host adapts only the Basic page block and preserves picker state', () => {
+  const { dialog } = createDialog();
+  const host = createResourcePickerPageHost(dialog);
+  const unrelated: IResourceRenderBlockOptionsBlock = {
+    render: 'other:block' as never,
+    options: { class: 'other' },
+  };
+  const basicPage: IResourceRenderBlockOptionsBlock = {
+    render: 'basic-page:blockPage' as never,
+    options: {
+      blocks: [{ render: 'basic-page:blockTable' as never }],
+    } as any,
+  };
+
+  const context = {
+    options: dialog.props,
+    session: dialog.session,
+    dialog: host,
+  };
+  const blocks = host.prepareBlocks([unrelated, basicPage], context)!;
+
+  assert.equal(blocks[0], unrelated);
+  assert.deepEqual(blocks[1].options, {
+    actionPath: undefined,
+    queryFixed: undefined,
+    selectionPolicy: 'always',
+    selectionMode: 'multiple',
+    selectionMax: 2,
+    selectedIds: [1],
+    selectedRows: [{ id: 1, name: 'One' }],
+    blocks: [
+      { render: 'basic-page:blockTable' },
+      { render: 'basic-resource:blockResourcePickerActions' },
+    ],
+  });
+
+  const onSelectionChange = (blocks[1].options as any).onSelectionChange as (
+    selection: any,
+  ) => void;
+  onSelectionChange({ ids: [2], rows: [{ id: 2, name: 'Two' }], count: 1 });
+  assert.deepEqual(dialog.session, {
+    selectedIds: [2],
+    selectedRows: [{ id: 2, name: 'Two' }],
+  });
+});
+
+test('Basic picker host forwards resolve and cancel', () => {
+  const { dialog, resolved, cancelled } = createDialog();
+  const host = createResourcePickerPageHost(dialog);
+  const selection = { ids: [1], rows: [{ id: 1 }], count: 1 };
+
+  host.resolve(selection);
+  host.cancel();
+
+  assert.deepEqual(resolved, [selection]);
+  assert.equal(cancelled, true);
+});

package/zova/src/suite/cabloy-basic/modules/basic-table/src/component/table/render.tsx

@@ -16,6 +16,7 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
         sorting={this.$props.sorting}
         onSortingChange={this.$props.onSortingChange}
         enableRowSelection={this.$props.enableRowSelection}
+        selectionMode={this.$props.selectionMode}
         rowSelection={this.$props.rowSelection}
         onRowSelectionChange={this.$props.onRowSelectionChange}
         tableScope={this.$props.tableScope}
@@ -48,6 +49,7 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
 
   public _renderTable($$table: ControllerTable<TData>) {
     const table = $$table.table;
+    const selectionMode = this.$props.selectionMode ?? 'multiple';
     const selectionEnabled = $$table.columns.some(column => column.id === TableColumnIdSelection);
     return (
       <table class="table">
@@ -61,16 +63,18 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
               const headerDefinition = column.columnDef.header;
               const selection = selectionEnabled && column.id === TableColumnIdSelection;
               const headerContent = selection ? (
-                <input
-                  type="checkbox"
-                  class="checkbox checkbox-sm"
-                  checked={table.getIsAllPageRowsSelected()}
-                  indeterminate={table.getIsSomePageRowsSelected()}
-                  aria-checked={table.getIsSomePageRowsSelected() ? 'mixed' : undefined}
-                  aria-label={this.scope.locale.SelectAllPageRows()}
-                  disabled={table.getRowModel().rows.every(row => !row.getCanSelect())}
-                  onChange={table.getToggleAllPageRowsSelectedHandler()}
-                />
+                selectionMode === 'single' ? null : (
+                  <input
+                    type="checkbox"
+                    class="checkbox checkbox-sm"
+                    checked={table.getIsAllPageRowsSelected()}
+                    indeterminate={table.getIsSomePageRowsSelected()}
+                    aria-checked={table.getIsSomePageRowsSelected() ? 'mixed' : undefined}
+                    aria-label={this.scope.locale.SelectAllPageRows()}
+                    disabled={table.getRowModel().rows.every(row => !row.getCanSelect())}
+                    onChange={table.getToggleAllPageRowsSelectedHandler()}
+                  />
+                )
               ) : (
                 <FlexRender render={headerDefinition} props={header.getContext()}></FlexRender>
               );
@@ -123,8 +127,10 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
                     >
                       {selection ? (
                         <input
-                          type="checkbox"
-                          class="checkbox checkbox-sm"
+                          type={selectionMode === 'single' ? 'radio' : 'checkbox'}
+                          class={
+                            selectionMode === 'single' ? 'radio radio-sm' : 'checkbox checkbox-sm'
+                          }
                           checked={row.getIsSelected()}
                           disabled={!row.getCanSelect()}
                           aria-label={this.scope.locale.SelectRow(row.id)}

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-rest-resource",
-  "version": "5.1.52",
+  "version": "5.1.54",
   "gitHead": "4dece229b6d3f4735930e833afcb4b95ec51bf86",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/.metadata/component/resourcePickerContext.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerResourcePickerContextProps } from '../../component/resourcePickerContext/controller.jsx';
+
+import { ControllerResourcePickerContext } from '../../component/resourcePickerContext/controller.jsx';
+export type ZResourcePickerContextProps = {
+  controllerRef?: (ref: ControllerResourcePickerContext) => void;
+} & ControllerResourcePickerContextProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerResourcePickerContextProps,
+  keyof typeof ControllerResourcePickerContext.$propsDefault
+>;
+declare module 'zova-module-rest-resource' {
+  export interface ControllerResourcePickerContext {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZResourcePickerContext = defineComponent((_props: ZResourcePickerContextProps) => {
+  useController(ControllerResourcePickerContext, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions());
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'rest-resource:resourcePickerContext': ControllerResourcePickerContextProps;
+  }
+}

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/.metadata/index.ts

@@ -26,7 +26,7 @@ declare module 'zova-module-rest-resource' {
 }
 /** model: end */
 /** model: begin */
-import { ModelResource } from '../model/resource.js';
+import type { ModelResource } from '../model/resource.js';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordGeneral {
@@ -35,9 +35,11 @@ declare module 'zova' {
 }
 /** model: end */
 /** controller: begin */
+export * from '../component/resourcePickerContext/controller.jsx';
 export * from '../page/entry/controller.jsx';
 export * from '../page/entryCreate/controller.jsx';
 export * from '../page/resource/controller.jsx';
+export * from '../page/resourcePicker/controller.jsx';
 
 import 'zova';
 declare module 'zova' {
@@ -46,6 +48,11 @@ declare module 'zova' {
 }
 declare module 'zova-module-rest-resource' {
 
+        export interface ControllerResourcePickerContext {
+          /** @internal */
+          get scope(): ScopeModuleRestResource;
+        }
+
         export interface ControllerPageEntry {
           /** @internal */
           get scope(): ScopeModuleRestResource;
@@ -55,18 +62,27 @@ declare module 'zova-module-rest-resource' {
           /** @internal */
           get scope(): ScopeModuleRestResource;
         }
+
+        export interface ControllerPageResourcePicker {
+          /** @internal */
+          get scope(): ScopeModuleRestResource;
+        }
 }
 /** controller: end */
 /** controller: begin */
-import { ControllerPageEntry } from '../page/entry/controller.jsx';
-import { ControllerPageEntryCreate } from '../page/entryCreate/controller.jsx';
-import { ControllerPageResource } from '../page/resource/controller.jsx';
+import type { ControllerResourcePickerContext } from '../component/resourcePickerContext/controller.jsx';
+import type { ControllerPageEntry } from '../page/entry/controller.jsx';
+import type { ControllerPageEntryCreate } from '../page/entryCreate/controller.jsx';
+import type { ControllerPageResource } from '../page/resource/controller.jsx';
+import type { ControllerPageResourcePicker } from '../page/resourcePicker/controller.jsx';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordLocal {
-    'rest-resource.controller.pageEntry': ControllerPageEntry;
+    'rest-resource.controller.resourcePickerContext': ControllerResourcePickerContext;
+'rest-resource.controller.pageEntry': ControllerPageEntry;
 'rest-resource.controller.pageEntryCreate': ControllerPageEntryCreate;
 'rest-resource.controller.pageResource': ControllerPageResource;
+'rest-resource.controller.pageResourcePicker': ControllerPageResourcePicker;
   }
 }
 /** controller: end */
@@ -77,6 +93,8 @@ export * from './page/entryCreate.js';
 import { NSControllerPageEntryCreate } from './page/entryCreate.js';
 export * from './page/resource.js';
 import { NSControllerPageResource } from './page/resource.js';
+export * from './page/resourcePicker.js';
+import { NSControllerPageResourcePicker } from './page/resourcePicker.js';
 export * from '../routes.js';
 import { TypePagePathSchema } from 'zova-module-a-router';
 import 'zova';
@@ -85,11 +103,13 @@ export interface IPagePathRecord {
   '/rest/resource/:resource/:id/:formScene?': TypePagePathSchema<NSControllerPageEntry.ParamsInput,undefined>;
 '/rest/resource/:resource/create': TypePagePathSchema<NSControllerPageEntryCreate.ParamsInput,undefined>;
 '/rest/resource/:resource': TypePagePathSchema<NSControllerPageResource.ParamsInput,undefined>;
+'/rest/resource/:resource/picker': TypePagePathSchema<NSControllerPageResourcePicker.ParamsInput,undefined>;
 }
 export interface IPageNameRecord {
   'rest-resource:entry': TypePagePathSchema<NSControllerPageEntry.ParamsInput,undefined>;
 'rest-resource:entryCreate': TypePagePathSchema<NSControllerPageEntryCreate.ParamsInput,undefined>;
 'rest-resource:resource': TypePagePathSchema<NSControllerPageResource.ParamsInput,undefined>;
+'rest-resource:resourcePicker': TypePagePathSchema<NSControllerPageResourcePicker.ParamsInput,undefined>;
 }
 }
 export const pagePathSchemas = {
@@ -107,6 +127,10 @@ export const pageNameSchemas = {
 'rest-resource:resource': {
           params: NSControllerPageResource.paramsSchema,
 
+        },
+'rest-resource:resourcePicker': {
+          params: NSControllerPageResourcePicker.paramsSchema,
+
         },
 };
 declare module 'zova-module-rest-resource' {
@@ -119,9 +143,28 @@ export interface ControllerPageEntryCreate {
 export interface ControllerPageResource {
         $params: NSControllerPageResource.ParamsOutput;
       }
+export interface ControllerPageResourcePicker {
+        $params: NSControllerPageResourcePicker.ParamsOutput;
+      }
 }
 /** pages: end */
 
+/** components: begin */
+export * from './component/resourcePickerContext.js';
+import { ZResourcePickerContext } from './component/resourcePickerContext.js';
+export const components = {
+  'resourcePickerContext': ZResourcePickerContext,
+};
+import 'zova';
+declare module 'zova' {
+export interface IComponentRecord {
+  'rest-resource:resourcePickerContext': ControllerResourcePickerContext;
+}
+export interface IZovaComponentRecord {
+  'rest-resource:resourcePickerContext': typeof ZResourcePickerContext;
+}
+}
+/** components: end */
 /** scope: begin */
 import { BeanScopeBase, type BeanScopeUtil } from 'zova';
 import { Scope } from 'zova-module-a-bean';

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/.metadata/page/resourcePicker.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { createZovaComponentPage } from 'zova';
+
+import { ControllerPageResourcePicker } from '../../page/resourcePicker/controller.jsx';
+import { ControllerPageResourcePickerSchemaParams } from '../../page/resourcePicker/controller.jsx';
+export namespace NSControllerPageResourcePicker {
+  export const paramsSchema = ControllerPageResourcePickerSchemaParams;
+  export type ParamsInput = z.input<typeof ControllerPageResourcePickerSchemaParams>;
+  export type ParamsOutput = z.output<typeof ControllerPageResourcePickerSchemaParams>;
+}
+
+export const ZPageResourcePicker = createZovaComponentPage(
+  ControllerPageResourcePicker,
+  undefined,
+  undefined,
+);

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/component/resourcePickerContext/controller.tsx

@@ -0,0 +1,26 @@
+import { BeanControllerBase } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+import type { IResourcePickerPageContext } from '../../page/resourcePicker/controller.js';
+
+import { resourcePickerPageContextKey } from '../../lib/resourcePicker.js';
+
+export interface ControllerResourcePickerContextProps {
+  context: IResourcePickerPageContext;
+}
+
+@Controller()
+export class ControllerResourcePickerContext extends BeanControllerBase {
+  static $propsDefault = {};
+
+  protected async __init__() {
+    this.bean._setBean(
+      resourcePickerPageContextKey,
+      (this.$props as ControllerResourcePickerContextProps).context,
+    );
+  }
+
+  protected render() {
+    return this.$slotDefault?.();
+  }
+}

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/index.ts

@@ -1,2 +1,4 @@
 export * from './.metadata/index.js';
 export * from './types/index.js';
+export * from './lib/resourcePicker.js';
+export * from './page/resourcePicker/controller.js';

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/lib/resourcePicker.ts

@@ -0,0 +1,43 @@
+import type { TableIdentity } from 'table-identity';
+import type {
+  IResourceRenderBlockOptionsBlock,
+  IResourceTableSelectionPayload,
+  ITableQuery,
+} from 'zova-module-a-openapi';
+
+export const resourcePickerPageContextKey = '$resourcePickerPageContext';
+export const resourcePickerPageHostKey = '$resourcePickerPageHost';
+
+export interface IResourcePickerPageOptions extends Record<string, unknown> {
+  resource: string;
+  actionPath?: string;
+  query?: ITableQuery;
+  selectionMode: 'single' | 'multiple';
+  selectionMax?: number;
+  selectedIds?: readonly TableIdentity[];
+}
+
+export interface IResourcePickerPageSession {
+  selectedIds: TableIdentity[];
+  selectedRows: Record<string, unknown>[];
+}
+
+export interface IResourcePickerPageDialog {
+  resolve(value: IResourceTableSelectionPayload): void;
+  cancel(): void;
+}
+
+export interface IResourcePickerPageContext {
+  options: IResourcePickerPageOptions;
+  session: IResourcePickerPageSession;
+  dialog: IResourcePickerPageDialog;
+}
+
+export interface IResourcePickerPageHost extends IResourcePickerPageDialog {
+  options: IResourcePickerPageOptions;
+  session: IResourcePickerPageSession;
+  prepareBlocks(
+    blocks: IResourceRenderBlockOptionsBlock[] | undefined,
+    context: IResourcePickerPageContext,
+  ): IResourceRenderBlockOptionsBlock[] | undefined;
+}

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/page/resourcePicker/controller.tsx

@@ -0,0 +1,85 @@
+import type { VNode } from 'vue';
+
+import { z } from 'zod';
+import { BeanControllerPageBase, deepExtend, Use, usePrepareArg } from 'zova';
+import { ZovaJsx } from 'zova-jsx';
+import { Controller } from 'zova-module-a-bean';
+import { $QueryEnsureLoaded } from 'zova-module-a-model';
+import { ZPage } from 'zova-module-home-base';
+
+import type {
+  IResourcePickerPageContext,
+  IResourcePickerPageHost,
+} from '../../lib/resourcePicker.js';
+import type { ModelResource } from '../../model/resource.js';
+
+import { ZResourcePickerContext } from '../../.metadata/component/resourcePickerContext.js';
+import { resourcePickerPageHostKey } from '../../lib/resourcePicker.js';
+
+export const ControllerPageResourcePickerSchemaParams = z.object({
+  resource: z.string(),
+});
+
+@Controller()
+export class ControllerPageResourcePicker extends BeanControllerPageBase {
+  jsxZova: ZovaJsx;
+
+  @Use({ beanFullName: 'rest-resource.model.resource' })
+  get $$modelResource(): ModelResource {
+    return usePrepareArg(this.resource, true);
+  }
+
+  @Use({ name: resourcePickerPageHostKey, injectionScope: 'host' })
+  $$pickerHost: IResourcePickerPageHost | undefined;
+
+  get resource() {
+    return this.$params.resource;
+  }
+
+  get pickerContext(): IResourcePickerPageContext {
+    const host = this.$$pickerHost;
+    if (!host) {
+      throw new Error('resource picker requires a page host');
+    }
+    const options = host.options;
+    const session = host.session;
+    if (options.resource !== this.resource) {
+      throw new Error('resource picker context does not match route resource');
+    }
+    return {
+      options,
+      session,
+      dialog: host,
+    };
+  }
+
+  protected async __init__() {
+    this.jsxZova = this.bean._newBeanSimple(ZovaJsx, false);
+    await $QueryEnsureLoaded(() => this.$$modelResource.apiSchemasSelect.sdk);
+  }
+
+  get schemaRow() {
+    return this.$$modelResource.schemaRow;
+  }
+
+  public render() {
+    const pickerContext = this.pickerContext;
+    const blocks = this.$$pickerHost!.prepareBlocks(this.schemaRow?.rest?.blocks, pickerContext);
+    if (!blocks || blocks.length === 0) return;
+    const domBlocks: VNode[] = [];
+    blocks.forEach((block, index) => {
+      const options = deepExtend({ key: index }, { resource: this.resource }, block.options);
+      const domBlock = this.jsxZova.render(block.render!, options);
+      if (!domBlock) return;
+      if (Array.isArray(domBlock)) domBlocks.push(...domBlock);
+      else domBlocks.push(domBlock);
+    });
+    return (
+      <ZResourcePickerContext context={pickerContext}>
+        <ZPage>{domBlocks}</ZPage>
+      </ZResourcePickerContext>
+    );
+  }
+}
+
+export type { IResourcePickerPageContext } from '../../lib/resourcePicker.js';

package/zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/routes.ts

@@ -3,6 +3,7 @@ import type { IModuleRoute } from 'zova-module-a-router';
 import { ZPageEntry } from './.metadata/page/entry.js';
 import { ZPageEntryCreate } from './.metadata/page/entryCreate.js';
 import { ZPageResource } from './.metadata/page/resource.js';
+import { ZPageResourcePicker } from './.metadata/page/resourcePicker.js';
 import { resourceRouteMeta, resourceTabKey } from './lib/resourceRouteMeta.js';
 
 export const routes: IModuleRoute[] = [
@@ -21,6 +22,14 @@ export const routes: IModuleRoute[] = [
       ssrProfile: 'session',
     },
   },
+  {
+    name: 'resourcePicker',
+    path: ':resource/picker',
+    component: ZPageResourcePicker,
+    meta: {
+      ssrProfile: 'session',
+    },
+  },
   {
     name: 'entry',
     path: ':resource/:id/:formScene?',

package/zova/src/suite-vendor/a-cabloy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-suite-a-cabloy",
-  "version": "5.1.53",
+  "version": "5.1.55",
   "gitHead": "4dece229b6d3f4735930e833afcb4b95ec51bf86",
   "description": "",
   "author": "",
@@ -8,7 +8,7 @@
   "type": "module",
   "dependencies": {
     "zova-module-a-rbac": "^5.0.1",
-    "zova-module-rest-resource": "^5.1.52"
+    "zova-module-rest-resource": "^5.1.54"
   },
   "title": "a-cabloy"
 }

package/zova/src/suite-vendor/a-zova/modules/a-bean/cli/controller/metadata/generateFileComponent.ts

@@ -13,6 +13,7 @@ export async function generateFileComponent(
   const { moduleName } = options;
   const { className } = globFile;
   const {
+    type,
     name,
     nameCapitalize,
     controllerExtJs,
@@ -63,6 +64,12 @@ export async function generateFileComponent(
       `import type { ${_contentImportTypeController.join(', ')} } from '../../component/${name}/controller${controllerExtJs}';`,
     );
   }
+  if (type === 'component' && name === 'routedDialog') {
+    contentImports.push(
+      "import { routeLocationKey, routerKey, routerViewLocationKey, viewDepthKey } from '@cabloy/vue-router';",
+      "import { computed, provide, shallowReactive } from 'vue';",
+    );
+  }
   contentImports.push("import { defineComponent } from 'vue'");
   contentImports.push("import { prepareComponentOptions, useController } from 'zova';");
   // controller
@@ -137,7 +144,39 @@ export async function generateFileComponent(
     }`;
   }
   // component
-  const contentComponent = `export const Z${nameCapitalize} = defineComponent(
+  const contentComponent =
+    type === 'component' && name === 'routedDialog'
+      ? `export const Z${nameCapitalize} = defineComponent(
+    ${genericDeclare}(props: ${typeControllerPublicPropsName}${genericArguments}) => {
+      const router = props.item.state.router;
+      if (router) {
+        const currentRoute = router.currentRoute;
+        const reactiveRoute = {} as Record<string, unknown>;
+        for (const key in currentRoute.value) {
+          Object.defineProperty(reactiveRoute, key, {
+            get: () => currentRoute.value[key],
+            enumerable: true,
+          });
+        }
+        provide(routerKey, router.router);
+        provide(routeLocationKey, shallowReactive(reactiveRoute) as any);
+        provide(routerViewLocationKey, currentRoute);
+        provide(
+          viewDepthKey,
+          computed(() => router.getEmbeddedRouterViewDepth(currentRoute.value)),
+        );
+      }
+      useController(${className}, ${hasRenderFirst ? classNameRenderFirst : undefined}, ${hasStyleFirst ? classNameStyleFirst : undefined});
+      return () => {};
+    },
+    {
+      ...prepareComponentOptions(${componentOptions}),
+      props: {
+        item: { type: Object, required: true },
+      },
+    },
+  );`
+      : `export const Z${nameCapitalize} = defineComponent(
     ${genericDeclare}(_props: ${typeControllerPublicPropsName}${genericArguments}) => {
       useController(${className}, ${hasRenderFirst ? classNameRenderFirst : undefined}, ${hasStyleFirst ? classNameStyleFirst : undefined});
       return () => {};

package/zova/src/suite-vendor/a-zova/modules/a-bean/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-bean",
-  "version": "5.1.33",
+  "version": "5.1.35",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-router/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-router",
-  "version": "5.1.35",
+  "version": "5.1.37",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "router",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-router/src/lib/routerViewBase.tsx

@@ -39,6 +39,10 @@ export class BeanRouterViewBase extends BeanControllerBase implements IRouterVie
     throw new Error('Not Implemented');
   }
 
+  protected getPageHostProviders(): Record<string, unknown> | undefined {
+    return undefined;
+  }
+
   protected render() {
     const slots = {
       default: (component: IRouterViewSlotParams) => {
@@ -50,6 +54,7 @@ export class BeanRouterViewBase extends BeanControllerBase implements IRouterVie
               route: component.route,
             });
             cast(vnode).zovaHostProviders = {
+              ...this.getPageHostProviders(),
               [pageRouteKey]: component.route,
               'a-router.bean.router': this.$router,
             };

package/zova/src/suite-vendor/a-zova/modules/a-routerstack/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-routerstack",
-  "version": "5.1.27",
+  "version": "5.1.29",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-routerstack/src/component/routerViewStack/controller.tsx

@@ -9,7 +9,9 @@ import {
 
 import type { ModelStack } from '../../model/stack.js';
 
-export interface ControllerRouterViewStackProps extends IRouterViewPropsBase {}
+export interface ControllerRouterViewStackProps extends IRouterViewPropsBase {
+  pageHostProviders?: Record<string, unknown>;
+}
 
 @Controller()
 export class ControllerRouterViewStack extends BeanRouterViewBase {
@@ -35,4 +37,8 @@ export class ControllerRouterViewStack extends BeanRouterViewBase {
   protected getKeepAliveInclude(): string[] | undefined {
     return this.$$modelStack.keepAliveInclude;
   }
+
+  protected getPageHostProviders(): Record<string, unknown> | undefined {
+    return this.$props.pageHostProviders;
+  }
 }