cabloy 5.1.162 → 5.1.164

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

@@ -9,6 +9,8 @@ import { VNode } from 'vue';
 import { BeanControllerBase, Use } from 'zova';
 import { Controller } from 'zova-module-a-bean';
 
+import { resolveTableActionBulkDynamicProps } from '../../lib/selection.js';
+
 declare module 'zova-module-a-openapi' {
   export interface IResourceBlockRecord {
     'basic-page:blockToolbarBulk'?: ControllerBlockToolbarBulkProps;
@@ -22,23 +24,67 @@ export interface ControllerBlockToolbarBulkProps extends IResourceBlockOptionsBa
 @Controller()
 export class ControllerBlockToolbarBulk extends BeanControllerBase {
   static $propsDefault = {};
+
+  private _selectionRequired = false;
   static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
 
   @Use({ injectionScope: 'host' })
   $$renderContext: IJsxRenderContextPage;
 
-  protected async __init__() {}
+  protected async __init__() {
+    this._setSelectionRequired(this._hasSelectionAction());
+    this.$watch(
+      () => this.$props.actions,
+      actions => {
+        this._setSelectionRequired(
+          actions?.some(action => action.options?.requiresSelection) ?? false,
+        );
+      },
+    );
+  }
+
+  protected __dispose__() {
+    this._setSelectionRequired(false);
+  }
+
+  private _hasSelectionAction() {
+    return this.$props.actions?.some(action => action.options?.requiresSelection) ?? false;
+  }
+
+  private _setSelectionRequired(required: boolean) {
+    if (this._selectionRequired === required) return;
+    this._selectionRequired = required;
+    this.$$renderContext.$$page.setSelectionRequired(required);
+  }
 
   get permissions() {
     return this.$$renderContext.$celScope.permissions;
   }
 
   protected render() {
+    const { $$page } = this.$$renderContext;
     const domActions = this._renderActions();
-    if (!domActions || domActions.length === 0) return;
+    const selectionAvailable = $$page.selectionAvailable;
+    if ((!domActions || domActions.length === 0) && !selectionAvailable) return;
     return (
       <div class={this.$props.class}>
-        <div class="join">{domActions}</div>
+        <div class="join" role="toolbar" aria-label={this.scope.locale.BulkActions()}>
+          {$$page.selectionToggleAvailable && (
+            <button type="button" class="btn join-item" onClick={() => $$page.toggleSelection()}>
+              {$$page.selectionVisible ? this.scope.locale.Done() : this.scope.locale.Select()}
+            </button>
+          )}
+          {$$page.selectionEnabled && (
+            <span
+              class="join-item border-base-300 bg-base-200 px-3 py-2"
+              role="status"
+              aria-live="polite"
+            >
+              {this.scope.locale.SelectedItems($$page.selection.count)}
+            </span>
+          )}
+          {domActions}
+        </div>
       </div>
     );
   }
@@ -52,7 +98,33 @@ export class ControllerBlockToolbarBulk extends BeanControllerBase {
       const actionName = action.name;
       const permissionHint = action.options?.permission;
       if (!this.$passport.checkPermission(this.permissions, actionName, permissionHint)) return;
-      const options = Object.assign({ key: index }, action.options);
+      const selection = this.$$renderContext.$$page.selection;
+      const completeSelection = selection.rows.length === selection.count;
+      const selectionAllowed =
+        selection.count > 0 &&
+        completeSelection &&
+        this.$passport.checkPermission(
+          this.permissions,
+          actionName,
+          permissionHint,
+          selection.rows,
+        );
+      const dynamicProps = resolveTableActionBulkDynamicProps(
+        action.options,
+        selection,
+        selectionAllowed,
+      );
+      const options = Object.assign({}, action.options, {
+        key: index,
+        dynamicSelection: dynamicProps.dynamicSelection,
+        dynamicDisabled: dynamicProps.dynamicDisabled,
+        dynamicDisabledReason:
+          dynamicProps.dynamicDisabledReason === 'maxExceeded'
+            ? this.scope.locale.SelectionActionMaxExceeded(dynamicProps.selectedMaxIds!)
+            : dynamicProps.dynamicDisabledReason === 'selectionUnavailable'
+              ? this.scope.locale.SelectionActionUnavailable()
+              : undefined,
+      });
       const domAction = $jsx.render(action.render!, options, $celScope, this.$$renderContext);
       if (!domAction) return;
       if (Array.isArray(domAction)) {

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

@@ -3,4 +3,11 @@ export default {
   Reset: 'Reset',
   PagedTotalItems: 'Total',
   PagedTotalPages: 'Pages',
+  Select: 'Select',
+  Done: 'Done',
+  SelectedItems: 'Selected %d items',
+  SelectedItems_1: 'Selected one item',
+  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

@@ -3,4 +3,10 @@ export default {
   Reset: '重置',
   PagedTotalItems: '总条数',
   PagedTotalPages: '总页数',
+  Select: '选择',
+  Done: '完成',
+  SelectedItems: '已选择 %d 项',
+  BulkActions: '批量操作',
+  SelectionActionUnavailable: '请选择一个或多个有权限的行以启用此操作',
+  SelectionActionMaxExceeded: '最多选择 %d 项以启用此操作',
 };

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

@@ -0,0 +1,84 @@
+import type { RowSelectionState } from '@tanstack/vue-table';
+import type { TableIdentity } from 'table-identity';
+import type {
+  IResourceTableActionBulkOptionsBase,
+  IResourceTableSelectionPayload,
+} from 'zova-module-a-openapi';
+
+import { isNil } from '@cabloy/utils';
+
+export const ResourceSelectedMaxIds = 100;
+
+export function resolveSelectionMaxIds(selectedMaxIds: number | undefined): number {
+  return selectedMaxIds ?? ResourceSelectedMaxIds;
+}
+
+export type TypeTableActionBulkDynamicDisabledReason = 'maxExceeded' | 'selectionUnavailable';
+
+export interface IResourceTableActionBulkDynamicProps {
+  dynamicSelection: IResourceTableSelectionPayload;
+  dynamicDisabled: boolean;
+  dynamicDisabledReason?: TypeTableActionBulkDynamicDisabledReason;
+  selectedMaxIds?: number;
+}
+
+export function resolveTableActionBulkDynamicProps(
+  options: IResourceTableActionBulkOptionsBase | undefined,
+  selection: IResourceTableSelectionPayload,
+  selectionAllowed: boolean,
+): IResourceTableActionBulkDynamicProps {
+  const requiresSelection = options?.requiresSelection === true;
+  const selectedMaxIds =
+    options?.selectedMaxIds !== undefined || requiresSelection
+      ? resolveSelectionMaxIds(options?.selectedMaxIds)
+      : undefined;
+  const selectionMaxExceeded = selectedMaxIds !== undefined && selection.count > selectedMaxIds;
+  return {
+    dynamicSelection: selection,
+    dynamicDisabled: selectionMaxExceeded || (requiresSelection && !selectionAllowed),
+    dynamicDisabledReason: selectionMaxExceeded
+      ? 'maxExceeded'
+      : requiresSelection && !selectionAllowed
+        ? 'selectionUnavailable'
+        : undefined,
+    selectedMaxIds,
+  };
+}
+
+export function selectionKey(id: TableIdentity): string {
+  if (isNil(id) || id === '') throw new Error('row id cannot empty');
+  return String(id);
+}
+
+export function selectionRowId(row: Record<string, unknown>): TableIdentity {
+  const id = row.id as TableIdentity;
+  selectionKey(id);
+  return id;
+}
+
+export function selectionRowIds(rows: readonly Record<string, unknown>[]): Set<string> {
+  const ids = new Set<string>();
+  for (const row of rows) {
+    const id = selectionKey(selectionRowId(row));
+    if (ids.has(id)) throw new Error(`duplicate row id: ${id}`);
+    ids.add(id);
+  }
+  return ids;
+}
+
+export function reconcileSelection(
+  selection: RowSelectionState,
+  rows: readonly Record<string, unknown>[],
+  next: RowSelectionState,
+): RowSelectionState {
+  const rowIds = selectionRowIds(rows);
+  const result = { ...selection };
+  for (const id of rowIds) {
+    if (next[id]) {
+      result[id] = true;
+    } else {
+      delete result[id];
+    }
+  }
+  return result;
+}

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

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  reconcileSelection,
+  resolveSelectionMaxIds,
+  resolveTableActionBulkDynamicProps,
+  selectionKey,
+  selectionRowIds,
+} from '../../src/lib/selection.ts';
+
+test('selection maximum uses action metadata before the frontend fallback', () => {
+  assert.equal(resolveSelectionMaxIds(undefined), 100);
+  assert.equal(resolveSelectionMaxIds(100), 100);
+  assert.equal(resolveSelectionMaxIds(101), 101);
+  assert.equal(resolveSelectionMaxIds(0), 0);
+});
+
+test('bulk action runtime props do not overwrite static action metadata', () => {
+  const selection = { ids: [1], rows: [{ id: 1 }], count: 1 };
+
+  assert.deepEqual(
+    resolveTableActionBulkDynamicProps(
+      { requiresSelection: true, disabled: true },
+      selection,
+      true,
+    ),
+    {
+      dynamicSelection: selection,
+      dynamicDisabled: false,
+      dynamicDisabledReason: undefined,
+      selectedMaxIds: 100,
+    },
+  );
+  assert.deepEqual(
+    resolveTableActionBulkDynamicProps(
+      { requiresSelection: true, selectedMaxIds: 1 },
+      selection,
+      true,
+    ),
+    {
+      dynamicSelection: selection,
+      dynamicDisabled: false,
+      dynamicDisabledReason: undefined,
+      selectedMaxIds: 1,
+    },
+  );
+  assert.deepEqual(
+    resolveTableActionBulkDynamicProps(
+      { requiresSelection: true, selectedMaxIds: 0 },
+      selection,
+      true,
+    ),
+    {
+      dynamicSelection: selection,
+      dynamicDisabled: true,
+      dynamicDisabledReason: 'maxExceeded',
+      selectedMaxIds: 0,
+    },
+  );
+  assert.deepEqual(
+    resolveTableActionBulkDynamicProps({ requiresSelection: true }, selection, false),
+    {
+      dynamicSelection: selection,
+      dynamicDisabled: true,
+      dynamicDisabledReason: 'selectionUnavailable',
+      selectedMaxIds: 100,
+    },
+  );
+});
+
+test('selection keys normalize numeric and string identities', () => {
+  assert.equal(selectionKey(7), '7');
+  assert.equal(selectionKey('student-7'), 'student-7');
+  assert.throws(() => selectionKey(''), /row id cannot empty/);
+  assert.throws(() => selectionKey(undefined as never), /row id cannot empty/);
+});
+
+test('selection rejects duplicate loaded row identities', () => {
+  assert.throws(() => selectionRowIds([{ id: '1' }, { id: 1 }]), /duplicate row id: 1/);
+});
+
+test('current-page selection changes preserve off-page selections', () => {
+  const selection = { previous: true, 1: true };
+  const rows = [{ id: '1' }, { id: '2' }];
+
+  const selected = reconcileSelection(selection, rows, { 1: true, 2: true });
+  assert.deepEqual(selected, { previous: true, 1: true, 2: true });
+
+  const deselected = reconcileSelection(selected, rows, { 2: true });
+  assert.deepEqual(deselected, { previous: true, 2: true });
+});
+
+test('current-page reconciliation removes only deselected loaded identities', () => {
+  const rows = [{ id: '1' }, { id: '2' }];
+  const selection = reconcileSelection({ 1: true, 2: true, previous: true }, rows, {});
+
+  assert.deepEqual(selection, { previous: true });
+});

package/zova/src/suite/cabloy-basic/modules/basic-table/src/.metadata/component/actionDeleteBulk.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerActionDeleteBulkProps } from '../../component/actionDeleteBulk/controller.jsx';
+
+import { ControllerActionDeleteBulk } from '../../component/actionDeleteBulk/controller.jsx';
+export type ZActionDeleteBulkProps = {
+  controllerRef?: (ref: ControllerActionDeleteBulk) => void;
+} & ControllerActionDeleteBulkProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerActionDeleteBulkProps,
+  keyof typeof ControllerActionDeleteBulk.$propsDefault
+>;
+declare module 'zova-module-basic-table' {
+  export interface ControllerActionDeleteBulk {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZActionDeleteBulk = defineComponent((_props: ZActionDeleteBulkProps) => {
+  useController(ControllerActionDeleteBulk, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions(ControllerActionDeleteBulk.$componentOptions));
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-table:actionDeleteBulk': ControllerActionDeleteBulkProps;
+  }
+}

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

@@ -1,6 +1,7 @@
 // eslint-disable
 /** controller: begin */
 export * from '../component/actionCreate/controller.jsx';
+export * from '../component/actionDeleteBulk/controller.jsx';
 export * from '../component/table/controller.jsx';
 
 import 'zova';
@@ -15,6 +16,11 @@ declare module 'zova-module-basic-table' {
           get scope(): ScopeModuleBasicTable;
         }
 
+        export interface ControllerActionDeleteBulk {
+          /** @internal */
+          get scope(): ScopeModuleBasicTable;
+        }
+
         export interface ControllerTable {
           /** @internal */
           get scope(): ScopeModuleBasicTable;
@@ -23,11 +29,13 @@ declare module 'zova-module-basic-table' {
 /** controller: end */
 /** controller: begin */
 import { ControllerActionCreate } from '../component/actionCreate/controller.jsx';
+import { ControllerActionDeleteBulk } from '../component/actionDeleteBulk/controller.jsx';
 import { ControllerTable } from '../component/table/controller.jsx';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordLocal {
     'basic-table.controller.actionCreate': ControllerActionCreate;
+'basic-table.controller.actionDeleteBulk': ControllerActionDeleteBulk;
 'basic-table.controller.table': ControllerTable;
   }
 }
@@ -36,20 +44,25 @@ declare module 'zova' {
 /** components: begin */
 export * from './component/actionCreate.js';
 import { ZActionCreate } from './component/actionCreate.js';
+export * from './component/actionDeleteBulk.js';
+import { ZActionDeleteBulk } from './component/actionDeleteBulk.js';
 export * from './component/table.js';
 import { ZTable } from './component/table.js';
 export const components = {
   'actionCreate': ZActionCreate,
+'actionDeleteBulk': ZActionDeleteBulk,
 'table': ZTable,
 };
 import 'zova';
 declare module 'zova' {
 export interface IComponentRecord {
   'basic-table:actionCreate': ControllerActionCreate;
+'basic-table:actionDeleteBulk': ControllerActionDeleteBulk;
 'basic-table:table': ControllerTable;
 }
 export interface IZovaComponentRecord {
   'basic-table:actionCreate': typeof ZActionCreate;
+'basic-table:actionDeleteBulk': typeof ZActionDeleteBulk;
 'basic-table:table': typeof ZTable;
 }
 }

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

@@ -1,7 +1,7 @@
 import type { IComponentOptions } from 'zova';
 import type {
   IJsxRenderContextPage,
-  IResourceTableActionBulkOptionsBase,
+  IResourceTableActionBulkPropsBase,
 } from 'zova-module-a-openapi';
 
 import { BeanControllerBase, Use } from 'zova';
@@ -13,7 +13,7 @@ declare module 'zova-module-a-openapi' {
   }
 }
 
-export interface ControllerActionCreateProps extends IResourceTableActionBulkOptionsBase {}
+export interface ControllerActionCreateProps extends IResourceTableActionBulkPropsBase {}
 
 @Controller()
 export class ControllerActionCreate extends BeanControllerBase {
@@ -26,11 +26,14 @@ export class ControllerActionCreate extends BeanControllerBase {
   protected async __init__() {}
 
   protected render() {
+    const disabled = this.$props.disabled === true || this.$props.dynamicDisabled === true;
     return (
       <button
         class={this.$props.class}
         type="button"
+        disabled={disabled}
         onClick={async () => {
+          if (disabled) return;
           await this.$performCommand('basic-commands:create', this.$props, this.$$renderContext);
         }}
       >

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

@@ -0,0 +1,57 @@
+import type { IComponentOptions } from 'zova';
+import type {
+  IJsxRenderContextPage,
+  IResourceTableActionBulkPropsBase,
+} from 'zova-module-a-openapi';
+
+import { BeanControllerBase, Use } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+declare module 'zova-module-a-openapi' {
+  export interface IResourceTableActionBulkRecord {
+    'basic-table:actionDeleteBulk'?: ControllerActionDeleteBulkProps;
+  }
+}
+
+export interface ControllerActionDeleteBulkProps extends IResourceTableActionBulkPropsBase {}
+
+@Controller()
+export class ControllerActionDeleteBulk extends BeanControllerBase {
+  static $propsDefault = { class: 'btn btn-error join-item' };
+  static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
+
+  @Use({ injectionScope: 'host' })
+  $$renderContext: IJsxRenderContextPage;
+
+  protected render() {
+    const { dynamicDisabledReason, dynamicSelection } = this.$props;
+    const disabled = this.$props.disabled === true || this.$props.dynamicDisabled === true;
+    return (
+      <button
+        class={this.$props.class}
+        type="button"
+        disabled={disabled}
+        title={dynamicDisabledReason}
+        aria-description={dynamicDisabledReason}
+        onClick={async () => {
+          if (disabled) return;
+          const confirmed = await this.$performCommand(
+            'basic-commands:confirm',
+            {
+              text: this.scope.locale.DeleteBulkConfirm(dynamicSelection?.count ?? 0),
+            },
+            this.$$renderContext,
+          );
+          if (!confirmed) return;
+          await this.$performCommand(
+            'basic-commands:deleteBulk',
+            this.$props,
+            this.$$renderContext,
+          );
+        }}
+      >
+        {this.scope.locale.DeleteBulk() as string}
+      </button>
+    );
+  }
+}

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

@@ -3,7 +3,7 @@ import type { AriaAttributes, CSSProperties } from 'vue';
 import { FlexRender } from '@tanstack/vue-table';
 import { BeanRenderBase } from 'zova';
 import { Render } from 'zova-module-a-bean';
-import { ControllerTable, ZTable } from 'zova-module-a-table';
+import { ControllerTable, TableColumnIdSelection, ZTable } from 'zova-module-a-table';
 
 @Render()
 export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
@@ -15,6 +15,9 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
         schemaOrder={this.$props.schemaOrder}
         sorting={this.$props.sorting}
         onSortingChange={this.$props.onSortingChange}
+        enableRowSelection={this.$props.enableRowSelection}
+        rowSelection={this.$props.rowSelection}
+        onRowSelectionChange={this.$props.onRowSelectionChange}
         tableScope={this.$props.tableScope}
         getColumns={this.$props.getColumns}
         getRowId={this.$props.getRowId}
@@ -45,6 +48,7 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
 
   public _renderTable($$table: ControllerTable<TData>) {
     const table = $$table.table;
+    const selectionEnabled = $$table.columns.some(column => column.id === TableColumnIdSelection);
     return (
       <table class="table">
         <thead>
@@ -55,7 +59,19 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
               const sorted = column.getIsSorted();
               const fixed = column.getIsPinned();
               const headerDefinition = column.columnDef.header;
-              const headerContent = (
+              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()}
+                />
+              ) : (
                 <FlexRender render={headerDefinition} props={header.getContext()}></FlexRender>
               );
               let sortAria: AriaAttributes['aria-sort'] = 'none';
@@ -95,19 +111,31 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
         <tbody>
           {table.getRowModel().rows.map(row => {
             return (
-              <tr key={row.id}>
+              <tr key={row.id} aria-selected={row.getIsSelected()}>
                 {row.getVisibleCells().map(cell => {
                   const column = cell.column;
+                  const selection = selectionEnabled && column.id === TableColumnIdSelection;
                   return (
                     <td
                       key={cell.id}
                       class={column.getIsPinned() ? 'bg-base-100' : undefined}
                       style={this._getColumnStyle(column)}
                     >
-                      <FlexRender
-                        render={column.columnDef.cell}
-                        props={cell.getContext()}
-                      ></FlexRender>
+                      {selection ? (
+                        <input
+                          type="checkbox"
+                          class="checkbox checkbox-sm"
+                          checked={row.getIsSelected()}
+                          disabled={!row.getCanSelect()}
+                          aria-label={this.scope.locale.SelectRow(row.id)}
+                          onChange={row.getToggleSelectedHandler()}
+                        />
+                      ) : (
+                        <FlexRender
+                          render={column.columnDef.cell}
+                          props={cell.getContext()}
+                        ></FlexRender>
+                      )}
                     </td>
                   );
                 })}

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

@@ -1,4 +1,8 @@
 export default {
   Create: 'Create',
   DeleteConfirm: 'Are you sure you want to delete this item?',
+  SelectAllPageRows: 'Select all rows on this page',
+  SelectRow: 'Select row %s',
+  DeleteBulk: 'Bulk Delete',
+  DeleteBulkConfirm: 'Are you sure you want to bulk delete %d selected items?',
 };

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

@@ -1,4 +1,8 @@
 export default {
   Create: '创建',
   DeleteConfirm: '您确认要删除本数据吗？',
+  SelectAllPageRows: '选择本页所有行',
+  SelectRow: '选择行 %s',
+  DeleteBulk: '批量删除',
+  DeleteBulkConfirm: '您确认要批量删除已选择的 %d 项吗？',
 };

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

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

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

@@ -0,0 +1,15 @@
+import type { TableIdentity } from 'table-identity';
+
+import { isNil } from '@cabloy/utils';
+
+export function validateSelectedIds(ids: readonly TableIdentity[]): TableIdentity[] {
+  if (ids.length === 0) throw new Error('selected ids cannot empty');
+  const keys = new Set<string>();
+  for (const id of ids) {
+    if (isNil(id) || id === '') throw new Error('selected row id cannot empty');
+    const key = String(id);
+    if (keys.has(key)) throw new Error(`duplicate selected row id: ${key}`);
+    keys.add(key);
+  }
+  return [...ids];
+}