cabloy 5.1.166 → 5.1.168

package/zova/src/suite/cabloy-basic/modules/basic-app/test/lib/routedDialogRouter.test.ts

@@ -0,0 +1,35 @@
+import { createRouter } from '@cabloy/vue-router';
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { RoutedDialogHistory } from '../../src/lib/routedDialogHistory.js';
+
+function createRouterWithHistory() {
+  const routedDialogHistory = new RoutedDialogHistory();
+  const router = createRouter({
+    history: routedDialogHistory.history,
+    routes: [
+      { path: '/entry', component: {} },
+      { path: '/detail', component: {} },
+    ],
+  });
+  return { router, routedDialogHistory };
+}
+
+test('routed dialog router synchronizes Back availability after a pop navigation', async () => {
+  const { router, routedDialogHistory } = createRouterWithHistory();
+  const canGoBackAfterEach: boolean[] = [];
+
+  router.afterEach((_to, _from, failure) => {
+    if (!failure) canGoBackAfterEach.push(routedDialogHistory.canGoBack);
+  });
+  await router.replace('/entry');
+  await router.isReady();
+  await router.push('/detail');
+  router.back();
+  await new Promise(resolve => setTimeout(resolve));
+
+  assert.equal(router.currentRoute.value.fullPath, '/entry');
+  assert.equal(routedDialogHistory.canGoBack, false);
+  assert.deepEqual(canGoBackAfterEach, [false, true, false]);
+});

package/zova/src/suite/cabloy-basic/modules/basic-page/src/.metadata/index.ts

@@ -46,12 +46,12 @@ declare module 'zova-module-basic-page' {
 }
 /** controller: end */
 /** controller: begin */
-import { ControllerBlockFilter } from '../component/blockFilter/controller.jsx';
-import { ControllerBlockFilterActions } from '../component/blockFilterActions/controller.jsx';
-import { ControllerBlockPage } from '../component/blockPage/controller.jsx';
-import { ControllerBlockPager } from '../component/blockPager/controller.jsx';
-import { ControllerBlockTable } from '../component/blockTable/controller.jsx';
-import { ControllerBlockToolbarBulk } from '../component/blockToolbarBulk/controller.jsx';
+import type { ControllerBlockFilter } from '../component/blockFilter/controller.jsx';
+import type { ControllerBlockFilterActions } from '../component/blockFilterActions/controller.jsx';
+import type { ControllerBlockPage } from '../component/blockPage/controller.jsx';
+import type { ControllerBlockPager } from '../component/blockPager/controller.jsx';
+import type { ControllerBlockTable } from '../component/blockTable/controller.jsx';
+import type { ControllerBlockToolbarBulk } from '../component/blockToolbarBulk/controller.jsx';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordLocal {

package/zova/src/suite/cabloy-basic/modules/basic-page/src/component/blockPage/controller.tsx

@@ -6,6 +6,7 @@ import type {
   IPageScope,
   IResourceBlockOptionsBase,
   IResourceRenderBlockOptionsBlock,
+  IResourceTableSelectionPayload,
   ITablePaged,
   ITableQuery,
   ITableResPaged,
@@ -21,7 +22,14 @@ import { $QueriesEnsureLoaded } from 'zova-module-a-model';
 import { BeanControllerTableBase } from 'zova-module-a-table';
 import { ModelResource } from 'zova-module-rest-resource';
 
-import { reconcileSelection, selectionKey, selectionRowId } from '../../lib/selection.js';
+import {
+  limitPickerRowSelection,
+  reconcileSelection,
+  resolvePickerSelectionMax,
+  selectionKey,
+  selectionRowId,
+  TypeResourcePickerSelectionMode,
+} from '../../lib/selection.js';
 
 declare module 'zova-module-a-openapi' {
   export interface IResourceBlockRecord {
@@ -32,9 +40,15 @@ declare module 'zova-module-a-openapi' {
 export interface ControllerBlockPageProps extends IResourceBlockOptionsBase {
   blocks?: IResourceRenderBlockOptionsBlock[];
   resource?: string;
+  actionPath?: string;
   pageSize?: number;
   queryFixed?: ITableQuery;
   selectionPolicy?: 'always' | 'onDemand' | false;
+  selectionMode?: TypeResourcePickerSelectionMode;
+  selectionMax?: number;
+  selectedIds?: readonly TableIdentity[];
+  selectedRows?: readonly Record<string, unknown>[];
+  onSelectionChange?: (selection: IResourceTableSelectionPayload) => void;
 }
 
 @Controller()
@@ -65,6 +79,10 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
   selectionVisible = false;
   selectionRequiredCount = 0;
 
+  private _selectionChangeListeners = new Set<
+    (selection: IResourceTableSelectionPayload<TData>) => void
+  >();
+
   $$modelResource: ModelResource<TData>;
 
   protected async __init__() {
@@ -80,9 +98,9 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
     this.queryFilterData = {};
     this.querySortingData = {};
     this.sorting = [];
-    this.rowSelection = {};
-    this.selectedIds = [];
-    this.selectedRows = new Map();
+    this.selectedIds = this._normalizeSelectedIds(this.$props.selectedIds ?? []);
+    this.rowSelection = Object.fromEntries(this.selectedIds.map(id => [selectionKey(id), true]));
+    this.selectedRows = this._normalizeSelectedRows(this.$props.selectedRows ?? []);
     this.$watch(
       () => this.$props.queryFixed,
       queryFixed => {
@@ -103,6 +121,8 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
       () => this.$$modelResource.apiSchemasSelect.sdk,
       () => this.queryData,
     );
+    this._refreshSelectedRows((this.data ?? []) as unknown as Record<string, unknown>[]);
+    this._notifySelectionChange();
     // watch
     this.$watch(
       () => this.permissions,
@@ -115,6 +135,7 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
       () => this.data,
       data => {
         this._refreshSelectedRows((data ?? []) as unknown as Record<string, unknown>[]);
+        this._notifySelectionChange();
       },
     );
   }
@@ -123,6 +144,32 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
     return this.$props.resource;
   }
 
+  private _normalizeSelectedIds(ids: readonly TableIdentity[]) {
+    const selectedIds: TableIdentity[] = [];
+    const keys = new Set<string>();
+    for (const id of ids) {
+      const key = selectionKey(id);
+      if (keys.has(key)) continue;
+      keys.add(key);
+      selectedIds.push(id);
+    }
+    return this.selectionMode === 'single'
+      ? selectedIds.slice(-1)
+      : selectedIds.slice(0, this.selectionMax);
+  }
+
+  private _normalizeSelectedRows(rows: readonly Record<string, unknown>[]) {
+    const selectedKeys = new Set(this.selectedIds.map(selectionKey));
+    const selectedRows = new Map<string, TData>();
+    for (const row of rows) {
+      const id = selectionRowId(row);
+      const key = selectionKey(id);
+      if (!selectedKeys.has(key) || selectedRows.has(key)) continue;
+      selectedRows.set(key, row as TData);
+    }
+    return selectedRows;
+  }
+
   get query() {
     const { where: whereFixed, ...queryFixed } = this.queryFixedData;
     const { where: whereFilter, ...queryFilter } = this.queryFilterData;
@@ -136,7 +183,7 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
   }
 
   get queryData() {
-    return this.$$modelResource.select(this.query);
+    return this.$$modelResource.selectGeneral(this.$props.actionPath, this.query);
   }
 
   get data() {
@@ -174,6 +221,18 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
     };
   }
 
+  get selectionMode(): TypeResourcePickerSelectionMode {
+    return this.$props.selectionMode ?? 'multiple';
+  }
+
+  get selectionMax() {
+    return resolvePickerSelectionMax(this.$props.selectionMode, this.$props.selectionMax);
+  }
+
+  get selectionPersistent() {
+    return this.$props.selectionMode !== undefined || this.$props.selectionMax !== undefined;
+  }
+
   get selectionAvailable() {
     const policy = this.$props.selectionPolicy;
     return (
@@ -192,19 +251,45 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
     return policy === 'always' || (this.selectionVisible && policy !== false);
   }
 
+  onSelectionChange(listener: (selection: IResourceTableSelectionPayload<TData>) => void) {
+    this._selectionChangeListeners.add(listener);
+    return () => this._selectionChangeListeners.delete(listener);
+  }
+
   onRowSelectionChange(
     updater: RowSelectionState | ((old: RowSelectionState) => RowSelectionState),
   ) {
     const data = (this.data ?? []) as unknown as Record<string, unknown>[];
     const next = functionalUpdate(updater, this.rowSelection);
-    this.rowSelection = reconcileSelection(this.rowSelection, data, next);
+    const reconciled = reconcileSelection(this.rowSelection, data, next);
+    this.rowSelection = this._limitRowSelection(reconciled, data);
     this._reconcileSelectedRows(data);
+    this._notifySelectionChange();
+  }
+
+  private _limitRowSelection(
+    rowSelection: RowSelectionState,
+    data: readonly Record<string, unknown>[],
+  ) {
+    if (this.$props.selectionMode === undefined && this.$props.selectionMax === undefined) {
+      return rowSelection;
+    }
+    return limitPickerRowSelection(rowSelection, data, this.selectionMode, this.selectionMax);
   }
 
   clearSelection() {
     this.rowSelection = {};
     this.selectedIds = [];
     this.selectedRows = new Map();
+    this._notifySelectionChange();
+  }
+
+  private _notifySelectionChange() {
+    const selection = this.selection;
+    this.$props.onSelectionChange?.(selection);
+    for (const listener of this._selectionChangeListeners) {
+      listener(selection);
+    }
   }
 
   private _refreshSelectedRows(data: readonly Record<string, unknown>[]) {
@@ -263,7 +348,7 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
 
   setPageSize(pageSize: number) {
     if (this.queryPaged.pageSize !== pageSize) {
-      this.clearSelection();
+      if (!this.selectionPersistent) this.clearSelection();
       this.queryPaged.pageSize = pageSize;
       this.queryPaged.pageNo = 1;
     }
@@ -272,14 +357,14 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
   setQueryFixed(queryFixed?: ITableQuery) {
     const next = queryFixed ?? {};
     if (deepEqual(this.queryFixedData, next)) return;
-    this.clearSelection();
+    if (!this.selectionPersistent) this.clearSelection();
     this.queryFixedData = next;
     this.queryPaged.pageNo = 1;
   }
 
   onFilter(data: ITableQuery) {
     if (deepEqual(this.queryFilterData, data)) return;
-    this.clearSelection();
+    if (!this.selectionPersistent) this.clearSelection();
     this.queryFilterData = data;
     this.queryPaged.pageNo = 1;
   }
@@ -287,7 +372,7 @@ export class ControllerBlockPage<TData extends {} = {}> extends BeanControllerBa
   onSortingChange(updater: SortingState | ((old: SortingState) => SortingState)) {
     const sorting = functionalUpdate(updater, this.sorting).slice(0, 1);
     if (deepEqual(this.sorting, sorting)) return;
-    this.clearSelection();
+    if (!this.selectionPersistent) this.clearSelection();
     this.sorting = sorting;
     const first = this.sorting[0];
     this.querySortingData = first ? { orders: [[first.id, first.desc ? 'desc' : 'asc']] } : {};

package/zova/src/suite/cabloy-basic/modules/basic-page/src/component/blockTable/controller.tsx

@@ -46,6 +46,7 @@ export class ControllerBlockTable<TData extends {} = {}> extends BeanControllerB
           sorting={$$page.sorting}
           onSortingChange={updater => $$page.onSortingChange(updater)}
           enableRowSelection={$$page.selectionEnabled}
+          selectionMode={$$page.selectionMode}
           rowSelection={$$page.rowSelection}
           onRowSelectionChange={updater => $$page.onRowSelectionChange(updater)}
           tableScope={$$page.jsxCelScope}

package/zova/src/suite/cabloy-basic/modules/basic-page/src/config/locale/en-us.ts

@@ -7,6 +7,7 @@ export default {
   Done: 'Done',
   SelectedItems: 'Selected %d items',
   SelectedItems_1: 'Selected one item',
+  SelectedItemsWithMax: 'Selected %d / %d items',
   BulkActions: 'Bulk actions',
   SelectionActionUnavailable: 'Select one or more permitted rows to enable this action',
   SelectionActionMaxExceeded: 'Select at most %d items to enable this action',

package/zova/src/suite/cabloy-basic/modules/basic-page/src/config/locale/zh-cn.ts

@@ -6,6 +6,7 @@ export default {
   Select: '选择',
   Done: '完成',
   SelectedItems: '已选择 %d 项',
+  SelectedItemsWithMax: '已选择 %d / %d 项',
   BulkActions: '批量操作',
   SelectionActionUnavailable: '请选择一个或多个有权限的行以启用此操作',
   SelectionActionMaxExceeded: '最多选择 %d 项以启用此操作',

package/zova/src/suite/cabloy-basic/modules/basic-page/src/index.ts

@@ -1,3 +1,4 @@
 export * from './.metadata/index.js';
 export * from './.metadata/locales.js';
 export * from './types/index.js';
+export * from './lib/selection.js';

package/zova/src/suite/cabloy-basic/modules/basic-page/src/lib/selection.ts

@@ -8,11 +8,30 @@ import type {
 import { isNil } from '@cabloy/utils';
 
 export const ResourceSelectedMaxIds = 100;
+export const ResourcePickerSelectionMax = 100;
+
+export type TypeResourcePickerSelectionMode = 'single' | 'multiple';
 
 export function resolveSelectionMaxIds(selectedMaxIds: number | undefined): number {
   return selectedMaxIds ?? ResourceSelectedMaxIds;
 }
 
+export function resolvePickerSelectionMax(
+  selectionMode: TypeResourcePickerSelectionMode | undefined,
+  selectionMax: number | undefined,
+): number {
+  if (selectionMode === 'single') return 1;
+  if (
+    selectionMax === undefined ||
+    !Number.isFinite(selectionMax) ||
+    !Number.isInteger(selectionMax) ||
+    selectionMax < 0
+  ) {
+    return ResourcePickerSelectionMax;
+  }
+  return selectionMax;
+}
+
 export type TypeTableActionBulkDynamicDisabledReason = 'maxExceeded' | 'selectionUnavailable';
 
 export interface IResourceTableActionBulkDynamicProps {
@@ -82,3 +101,19 @@ export function reconcileSelection(
   }
   return result;
 }
+
+export function limitPickerRowSelection(
+  selection: RowSelectionState,
+  rows: readonly Record<string, unknown>[],
+  selectionMode: TypeResourcePickerSelectionMode,
+  selectionMax: number,
+): RowSelectionState {
+  const selectedKeys = Object.keys(selection).filter(key => selection[key]);
+  if (selectedKeys.length <= selectionMax) return selection;
+  const currentPageKeys = selectionRowIds(rows);
+  const retainedKeys =
+    selectionMode === 'single'
+      ? selectedKeys.filter(key => currentPageKeys.has(key)).slice(-1)
+      : selectedKeys.slice(0, selectionMax);
+  return Object.fromEntries(retainedKeys.map(key => [key, true]));
+}

package/zova/src/suite/cabloy-basic/modules/basic-page/test/lib/selection.test.ts

@@ -2,7 +2,9 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 
 import {
+  limitPickerRowSelection,
   reconcileSelection,
+  resolvePickerSelectionMax,
   resolveSelectionMaxIds,
   resolveTableActionBulkDynamicProps,
   selectionKey,
@@ -16,6 +18,17 @@ test('selection maximum uses action metadata before the frontend fallback', () =
   assert.equal(resolveSelectionMaxIds(0), 0);
 });
 
+test('picker selection maximum distinguishes single and multiple modes', () => {
+  assert.equal(resolvePickerSelectionMax(undefined, undefined), 100);
+  assert.equal(resolvePickerSelectionMax('multiple', undefined), 100);
+  assert.equal(resolvePickerSelectionMax('multiple', 3), 3);
+  assert.equal(resolvePickerSelectionMax('multiple', 0), 0);
+  assert.equal(resolvePickerSelectionMax('single', 99), 1);
+  assert.equal(resolvePickerSelectionMax('multiple', -1), 100);
+  assert.equal(resolvePickerSelectionMax('multiple', 1.5), 100);
+  assert.equal(resolvePickerSelectionMax('multiple', Number.NaN), 100);
+});
+
 test('bulk action runtime props do not overwrite static action metadata', () => {
   const selection = { ids: [1], rows: [{ id: 1 }], count: 1 };
 
@@ -97,3 +110,14 @@ test('current-page reconciliation removes only deselected loaded identities', ()
 
   assert.deepEqual(selection, { previous: true });
 });
+
+test('picker selection caps page-wide updates while retaining earlier identities', () => {
+  const rows = [{ id: '2' }, { id: '3' }, { id: '4' }];
+  assert.deepEqual(
+    limitPickerRowSelection({ 1: true, 2: true, 3: true, 4: true }, rows, 'multiple', 3),
+    { 1: true, 2: true, 3: true },
+  );
+  assert.deepEqual(limitPickerRowSelection({ previous: true, 2: true }, rows, 'single', 1), {
+    2: true,
+  });
+});

package/zova/src/suite/cabloy-basic/modules/basic-resource/src/.metadata/component/blockResourcePickerActions.ts

@@ -0,0 +1,34 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerBlockResourcePickerActionsProps } from '../../component/blockResourcePickerActions/controller.jsx';
+
+import { ControllerBlockResourcePickerActions } from '../../component/blockResourcePickerActions/controller.jsx';
+export type ZBlockResourcePickerActionsProps = {
+  controllerRef?: (ref: ControllerBlockResourcePickerActions) => void;
+} & ControllerBlockResourcePickerActionsProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerBlockResourcePickerActionsProps,
+  keyof typeof ControllerBlockResourcePickerActions.$propsDefault
+>;
+declare module 'zova-module-basic-resource' {
+  export interface ControllerBlockResourcePickerActions {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZBlockResourcePickerActions = defineComponent(
+  (_props: ZBlockResourcePickerActionsProps) => {
+    useController(ControllerBlockResourcePickerActions, undefined, undefined);
+    return () => {};
+  },
+  prepareComponentOptions(ControllerBlockResourcePickerActions.$componentOptions),
+);
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-resource:blockResourcePickerActions': ControllerBlockResourcePickerActionsProps;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-resource/src/.metadata/index.ts

@@ -1,5 +1,6 @@
 // eslint-disable
 /** controller: begin */
+export * from '../component/blockResourcePickerActions/controller.jsx';
 export * from '../component/formFieldResourcePicker/controller.jsx';
 
 import 'zova';
@@ -9,6 +10,11 @@ declare module 'zova' {
 }
 declare module 'zova-module-basic-resource' {
 
+        export interface ControllerBlockResourcePickerActions {
+          /** @internal */
+          get scope(): ScopeModuleBasicResource;
+        }
+
         export interface ControllerFormFieldResourcePicker {
           /** @internal */
           get scope(): ScopeModuleBasicResource;
@@ -16,28 +22,35 @@ declare module 'zova-module-basic-resource' {
 }
 /** controller: end */
 /** controller: begin */
-import { ControllerFormFieldResourcePicker } from '../component/formFieldResourcePicker/controller.jsx';
+import type { ControllerBlockResourcePickerActions } from '../component/blockResourcePickerActions/controller.jsx';
+import type { ControllerFormFieldResourcePicker } from '../component/formFieldResourcePicker/controller.jsx';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordLocal {
-    'basic-resource.controller.formFieldResourcePicker': ControllerFormFieldResourcePicker;
+    'basic-resource.controller.blockResourcePickerActions': ControllerBlockResourcePickerActions;
+'basic-resource.controller.formFieldResourcePicker': ControllerFormFieldResourcePicker;
   }
 }
 /** controller: end */
 
 /** components: begin */
+export * from './component/blockResourcePickerActions.js';
+import { ZBlockResourcePickerActions } from './component/blockResourcePickerActions.js';
 export * from './component/formFieldResourcePicker.js';
 import { ZFormFieldResourcePicker } from './component/formFieldResourcePicker.js';
 export const components = {
-  'formFieldResourcePicker': ZFormFieldResourcePicker,
+  'blockResourcePickerActions': ZBlockResourcePickerActions,
+'formFieldResourcePicker': ZFormFieldResourcePicker,
 };
 import 'zova';
 declare module 'zova' {
 export interface IComponentRecord {
-  'basic-resource:formFieldResourcePicker': ControllerFormFieldResourcePicker;
+  'basic-resource:blockResourcePickerActions': ControllerBlockResourcePickerActions;
+'basic-resource:formFieldResourcePicker': ControllerFormFieldResourcePicker;
 }
 export interface IZovaComponentRecord {
-  'basic-resource:formFieldResourcePicker': typeof ZFormFieldResourcePicker;
+  'basic-resource:blockResourcePickerActions': typeof ZBlockResourcePickerActions;
+'basic-resource:formFieldResourcePicker': typeof ZFormFieldResourcePicker;
 }
 }
 /** components: end */
@@ -68,7 +81,7 @@ declare module 'zova-module-basic-resource' {
 }
 /** tableCell: end */
 /** tableCell: begin */
-import { TableCellResourcePicker } from '../bean/tableCell.resourcePicker.jsx';
+import type { TableCellResourcePicker } from '../bean/tableCell.resourcePicker.jsx';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordGeneral {
@@ -76,8 +89,11 @@ declare module 'zova' {
   }
 }
 /** tableCell: end */
+/** locale: begin */
+import { locales } from './locales.js';
+/** locale: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil } from 'zova';
+import { BeanScopeBase, type BeanScopeUtil, TypeModuleLocales, TypeLocaleBase } from 'zova';
 import { Scope } from 'zova-module-a-bean';
 
 @Scope()
@@ -85,6 +101,7 @@ export class ScopeModuleBasicResource extends BeanScopeBase {}
 
 export interface ScopeModuleBasicResource {
   util: BeanScopeUtil;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
 }
 
 import 'zova';
@@ -95,9 +112,14 @@ declare module 'zova' {
 
 
 
-
+  export interface IBeanScopeLocale {
+    'basic-resource': (typeof locales)[TypeLocaleBase];
+  }
 
 
 }
 
+export function locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `basic-resource::${K}` {
+  return `basic-resource::${key}`;
+}
 /** scope: end */

package/zova/src/suite/cabloy-basic/modules/basic-resource/src/.metadata/locales.ts

@@ -0,0 +1,7 @@
+import locale_en_us from '../config/locale/en-us.js';
+import locale_zh_cn from '../config/locale/zh-cn.js';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};

package/zova/src/suite/cabloy-basic/modules/basic-resource/src/component/blockResourcePickerActions/controller.tsx

@@ -0,0 +1,92 @@
+import type { IComponentOptions } from 'zova';
+import type { IJsxRenderContextPage, IResourceBlockOptionsBase } from 'zova-module-a-openapi';
+import type { IResourcePickerPageContext } from 'zova-module-rest-resource';
+
+import { BeanControllerBase, Use } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+import { resolvePickerSelectionMax } from 'zova-module-basic-page';
+import { resourcePickerPageContextKey } from 'zova-module-rest-resource';
+
+declare module 'zova-module-a-openapi' {
+  export interface IResourceBlockRecord {
+    'basic-resource:blockResourcePickerActions'?: ControllerBlockResourcePickerActionsProps;
+  }
+}
+
+export interface ControllerBlockResourcePickerActionsProps extends IResourceBlockOptionsBase {}
+
+@Controller()
+export class ControllerBlockResourcePickerActions extends BeanControllerBase {
+  static $propsDefault = {
+    class: 'flex items-center justify-between gap-3',
+  };
+
+  static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
+
+  @Use({ injectionScope: 'host' })
+  $$renderContext: IJsxRenderContextPage;
+
+  @Use({ name: resourcePickerPageContextKey, injectionScope: 'host' })
+  $$pickerContext: IResourcePickerPageContext;
+
+  protected async __init__() {}
+
+  get pickerOptions() {
+    return this.$$pickerContext.options;
+  }
+
+  get selectionMax() {
+    return resolvePickerSelectionMax(
+      this.pickerOptions.selectionMode,
+      this.pickerOptions.selectionMax,
+    );
+  }
+
+  get selection() {
+    return this.$$renderContext.$$page.selection.ids;
+  }
+
+  get canConfirm() {
+    const count = this.selection.length;
+    return (
+      count > 0 &&
+      count <= this.selectionMax &&
+      (this.pickerOptions.selectionMode !== 'single' || count === 1)
+    );
+  }
+
+  public confirm() {
+    if (!this.canConfirm) return;
+    this.$$pickerContext.dialog.resolve(this.$$renderContext.$$page.selection);
+  }
+
+  public cancel() {
+    this.$$pickerContext.dialog.cancel();
+  }
+
+  protected render() {
+    const count = this.selection.length;
+    return (
+      <div class="flex items-center justify-between gap-3">
+        <span class="text-sm text-base-content/70" role="status" aria-live="polite">
+          {this.pickerOptions.selectionMode === 'multiple'
+            ? this.scope.locale.SelectedItemsWithMax(count, this.selectionMax)
+            : this.scope.locale.SelectedItems(count)}
+        </span>
+        <div class="join">
+          <button type="button" class="btn join-item" onClick={() => this.cancel()}>
+            {this.scope.locale.Cancel()}
+          </button>
+          <button
+            type="button"
+            class="btn btn-primary join-item"
+            disabled={!this.canConfirm}
+            onClick={() => this.confirm()}
+          >
+            {this.scope.locale.Select()}
+          </button>
+        </div>
+      </div>
+    );
+  }
+}