cabloy 5.1.167 → 5.1.168

package/zova/src/suite/cabloy-basic/modules/basic-app/src/.metadata/component/routedDialog.ts

@@ -6,7 +6,8 @@ import {
   routerViewLocationKey,
   viewDepthKey,
 } from '@cabloy/vue-router';
-import { computed, defineComponent, provide, shallowReactive } from 'vue';
+import { computed, provide, shallowReactive } from 'vue';
+import { defineComponent } from 'vue';
 import { prepareComponentOptions, useController } from 'zova';
 
 import type { ControllerRoutedDialogProps } from '../../component/routedDialog/controller.jsx';

package/zova/src/suite/cabloy-basic/modules/basic-app/src/component/routedDialog/controller.tsx

@@ -5,7 +5,7 @@ import { BeanControllerBase, cast } from 'zova';
 import { Controller } from 'zova-module-a-bean';
 import { ZRouterViewStack } from 'zova-module-a-routerstack';
 
-import type { IModalRoutedDialogItem } from '../../types/appModal.js';
+import { IModalRoutedDialogItem, routedDialogContextKey } from '../../types/appModal.js';
 
 export interface ControllerRoutedDialogProps {
   item: IModalRoutedDialogItem;
@@ -41,7 +41,11 @@ export class ControllerRoutedDialog extends BeanControllerBase {
     if (!this.$$modelStack) return <div class="loading loading-spinner"></div>;
     const router = item.state.router;
     if (!router) return <div class="text-error">Router unavailable</div>;
-    const vnode = h(ZRouterViewStack);
+    const vnode = h(ZRouterViewStack, {
+      pageHostProviders: {
+        [routedDialogContextKey]: item.state.context,
+      },
+    });
     cast(vnode).zovaHostProviders = {
       'a-router.bean.router': router,
       '$$modelStack': this.$$modelStack,

package/zova/src/suite/cabloy-basic/modules/basic-app/src/service/appModal.ts

@@ -14,7 +14,9 @@ import {
   IModalPromptOptions,
   IModalRoutedDialogOptions,
   IModalRoutedDialogPresentationOptions,
+  IModalRoutedDialogItem,
   IModalRoutedDialogState,
+  IRoutedDialogContext,
   IRoutedDialogHandle,
 } from '../types/appModal.js';
 
@@ -27,6 +29,11 @@ export class ServiceAppModal extends BeanBase {
     { resolve: () => void; reject: (error: unknown) => void }
   >();
 
+  private routedDialogResultSettlers = new Map<
+    number,
+    { resolve: (value: unknown | undefined) => void; reject: (error: unknown) => void }
+  >();
+
   private routedDialogHistories = new Map<number, RoutedDialogHistory>();
 
   protected async __init__() {}
@@ -101,10 +108,14 @@ export class ServiceAppModal extends BeanBase {
     return new AppModalItem(this, modalItem);
   }
 
-  public routedDialog(
-    options: IModalRoutedDialogOptions,
+  public routedDialog<
+    TResult = unknown,
+    TProps extends Record<string, unknown> = Record<string, unknown>,
+    TSession = unknown,
+  >(
+    options: IModalRoutedDialogOptions<TProps, TSession>,
     dialogOptions?: IModalRoutedDialogPresentationOptions,
-  ): IRoutedDialogHandle {
+  ): IRoutedDialogHandle<TResult> {
     const id = this.newModalItemId();
     let resolveReady!: () => void;
     let rejectReady!: (error: unknown) => void;
@@ -112,25 +123,47 @@ export class ServiceAppModal extends BeanBase {
       resolveReady = resolve;
       rejectReady = reject;
     });
-    // A close-before-ready rejection remains observable through the handle,
-    // without becoming an unhandled rejection when callers do not await it.
+    let resolveResult!: (value: TResult | undefined) => void;
+    let rejectResult!: (error: unknown) => void;
+    const result = new Promise<TResult | undefined>((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    // Both promises remain observable through the handle without becoming
+    // unhandled rejections when callers only need one lifecycle channel.
     void ready.catch(() => {});
-    const modalItem: IModalItem = {
+    void result.catch(() => {});
+    let modalItem!: IModalRoutedDialogItem<TResult, TProps, TSession>;
+    const context: IRoutedDialogContext<TResult, TProps, TSession> = {
+      id,
+      props: options.props,
+      session: options.session as TSession,
+      resolve: value => this._resolveRoutedDialog(modalItem, value),
+      cancel: () => this.close(id),
+    };
+    modalItem = {
       id,
       type: 'routedDialog',
       options,
       dialogOptions,
-      state: shallowReactive<IModalRoutedDialogState>({
+      state: shallowReactive<IModalRoutedDialogState<TResult, TProps, TSession>>({
         status: 'loading',
         canGoBack: false,
         ready,
+        result,
+        context,
       }),
     };
     this.modalItems.push(modalItem);
     this.routedDialogReadySettlers.set(id, { resolve: resolveReady, reject: rejectReady });
-    const handle = new AppModalItem(this, modalItem) as IRoutedDialogHandle;
+    this.routedDialogResultSettlers.set(id, {
+      resolve: value => resolveResult(value as TResult | undefined),
+      reject: rejectResult,
+    });
+    const handle = new AppModalItem(this, modalItem) as IRoutedDialogHandle<TResult>;
     Object.defineProperties(handle, {
       ready: { enumerable: true, get: () => ready },
+      result: { enumerable: true, get: () => result },
       push: {
         enumerable: true,
         value: (to: any) => this._navigateRoutedDialog(modalItem, to, false),
@@ -197,6 +230,7 @@ export class ServiceAppModal extends BeanBase {
       modalItem.state.status = 'error';
       modalItem.state.error = error;
       this._settleRoutedDialogReady(modalItem.id, 'reject', error);
+      this._settleRoutedDialogResult(modalItem.id, 'reject', error);
     }
   }
 
@@ -233,6 +267,23 @@ export class ServiceAppModal extends BeanBase {
     else settler.reject(error);
   }
 
+  private _settleRoutedDialogResult(id: number, action: 'resolve' | 'reject', value?: unknown) {
+    const settler = this.routedDialogResultSettlers.get(id);
+    if (!settler) return;
+    this.routedDialogResultSettlers.delete(id);
+    if (action === 'resolve') settler.resolve(value);
+    else settler.reject(value);
+  }
+
+  private _resolveRoutedDialog(
+    modalItem: Extract<IModalItem, { type: 'routedDialog' }>,
+    value: unknown,
+  ) {
+    if (!this._isRoutedDialogOpen(modalItem)) return;
+    this._settleRoutedDialogResult(modalItem.id, 'resolve', value);
+    this.close(modalItem.id);
+  }
+
   public close(id: number, _reason: string = 'api') {
     const [index, modalItem] = this.findModalItem(id);
     if (index === -1 || !modalItem) return;
@@ -245,6 +296,7 @@ export class ServiceAppModal extends BeanBase {
       this.routedDialogHistories.delete(modalItem.id);
       modalItem.state.router = undefined;
       this._settleRoutedDialogReady(modalItem.id, 'reject', new Error('routedDialog is closed'));
+      this._settleRoutedDialogResult(modalItem.id, 'resolve');
       modalItem.options.onClose?.();
       return;
     }

package/zova/src/suite/cabloy-basic/modules/basic-app/src/types/appModal.ts

@@ -71,15 +71,37 @@ export interface IModalDialogRenderOptions {
   onClose?: () => void;
 }
 
-export interface IModalRoutedDialogOptions extends IModalRoutedDialogPresentationOptions {
+export const routedDialogContextKey = '$routedDialogContext';
+
+export interface IRoutedDialogContext<
+  TResult = unknown,
+  TProps extends Record<string, unknown> = Record<string, unknown>,
+  TSession = unknown,
+> {
+  readonly id: number;
+  readonly props?: TProps;
+  readonly session: TSession;
+  resolve(value: TResult): void;
+  cancel(): void;
+}
+
+export interface IModalRoutedDialogOptions<
+  TProps extends Record<string, unknown> = Record<string, unknown>,
+  TSession = unknown,
+> extends IModalRoutedDialogPresentationOptions {
   route: RouteLocationRaw;
   icon?: keyof IIconRecord;
   title?: string;
-  props?: Record<string, unknown>;
+  props?: TProps;
+  session?: TSession;
   onClose?: () => void;
 }
 
-export interface IModalRoutedDialogState {
+export interface IModalRoutedDialogState<
+  TResult = unknown,
+  TProps extends Record<string, unknown> = Record<string, unknown>,
+  TSession = unknown,
+> {
   status: 'loading' | 'ready' | 'error' | 'closed';
   closed?: boolean;
   error?: unknown;
@@ -87,24 +109,34 @@ export interface IModalRoutedDialogState {
   currentRoute?: RouteLocationNormalizedLoadedGeneric;
   canGoBack: boolean;
   ready: Promise<void>;
+  result: Promise<TResult | undefined>;
+  context: IRoutedDialogContext<TResult, TProps, TSession>;
 }
 
-export type IModalRoutedDialogInput = Omit<IModalRoutedDialogOptions, 'route'>;
+export type IModalRoutedDialogInput<
+  TProps extends Record<string, unknown> = Record<string, unknown>,
+  TSession = unknown,
+> = Omit<IModalRoutedDialogOptions<TProps, TSession>, 'route'>;
 
 export interface IModalRoutedDialogNavigate {
   navigate(to: RouteLocationRaw, replace?: boolean): Promise<NavigationFailure | void | undefined>;
 }
 
-export interface IModalRoutedDialogItem {
+export interface IModalRoutedDialogItem<
+  TResult = unknown,
+  TProps extends Record<string, unknown> = Record<string, unknown>,
+  TSession = unknown,
+> {
   id: number;
   type: 'routedDialog';
-  options: IModalRoutedDialogOptions;
+  options: IModalRoutedDialogOptions<TProps, TSession>;
   dialogOptions?: IModalRoutedDialogPresentationOptions;
-  state: IModalRoutedDialogState;
+  state: IModalRoutedDialogState<TResult, TProps, TSession>;
 }
 
-export interface IRoutedDialogHandle extends AppModalItem {
+export interface IRoutedDialogHandle<TResult = unknown> extends AppModalItem {
   readonly ready: Promise<void>;
+  readonly result: Promise<TResult | undefined>;
   push(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
   replace(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
 }

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;
+  }
+}