cabloy 5.1.167 → 5.1.169

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

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

@@ -1,15 +1,36 @@
+import type { TableIdentity } from 'table-identity';
 import type { IComponentOptions } from 'zova';
 import type { IFormFieldComponentOptions, IJsxRenderContextFormField } from 'zova-module-a-form';
-import type { IResourceFormFieldOptionsBase, ITableQuery } from 'zova-module-a-openapi';
+import type {
+  IResourceFormFieldOptionsBase,
+  IResourceTableSelectionPayload,
+  ITableQuery,
+} from 'zova-module-a-openapi';
+import type {
+  IResourcePickerPageOptions,
+  IResourcePickerPageSession,
+} from 'zova-module-rest-resource';
 
 import { classes } from 'typestyle';
 import { BeanControllerBase, Use } from 'zova';
 import { Controller } from 'zova-module-a-bean';
 import { ZFormField, ZFormFieldPreset } from 'zova-module-a-form';
 import { $QueryEnsureLoaded } from 'zova-module-a-model';
+import { resolvePickerSelectionMax } from 'zova-module-basic-page';
 import { ZSelect, ZSelectProps } from 'zova-module-basic-select';
+import { resourcePickerPageHostKey } from 'zova-module-rest-resource';
 import { ModelResource } from 'zova-module-rest-resource';
 
+import type { TypeResourcePickerSelectionMode } from '../../lib/resourcePicker.js';
+
+import {
+  normalizeResourcePickerIds,
+  resolveResourcePickerValue,
+} from '../../lib/resourcePicker.js';
+import { createResourcePickerPageHost } from '../../lib/resourcePickerPageHost.js';
+
+export type TypeResourcePickerMode = 'select' | 'routedDialog';
+
 declare module 'zova-module-a-openapi' {
   export interface IResourceFormFieldRecord {
     'basic-resource:formFieldResourcePicker'?: IResourceFormFieldResourcePickerOptions;
@@ -22,6 +43,9 @@ export interface IResourceFormFieldResourcePickerOptions extends IResourceFormFi
   query?: ITableQuery;
   relationName?: string;
   selectOptions?: ZSelectProps;
+  pickerMode?: TypeResourcePickerMode;
+  selectionMode?: TypeResourcePickerSelectionMode;
+  selectionMax?: number;
 }
 
 export interface ControllerFormFieldResourcePickerProps extends IFormFieldComponentOptions {
@@ -37,21 +61,21 @@ export class ControllerFormFieldResourcePicker extends BeanControllerBase {
   static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
 
   $$modelResource: ModelResource;
+  private _openingDialog = false;
+  private _pendingLabelIds = new Set<string>();
+  private _labelHydrationAttemptedIds = new Set<string>();
 
   @Use({ injectionScope: 'host' })
   $$renderContext: IJsxRenderContextFormField;
 
   protected async __init__() {
     const { ctx } = this.$$renderContext;
-    // readonly
-    if (this.$props.readonly) return;
-    // modelResource
+    if (this.$props.readonly || this.pickerMode === 'routedDialog') return;
     this.$$modelResource = await ctx.bean._getBeanSelector(
       'rest-resource.model.resource',
       true,
       this.resource,
     );
-    // load data
     await $QueryEnsureLoaded(() => this.queryData);
   }
 
@@ -65,6 +89,14 @@ export class ControllerFormFieldResourcePicker extends BeanControllerBase {
     return this.$props.options;
   }
 
+  get pickerMode(): TypeResourcePickerMode {
+    return this.resourcePickerOptions?.pickerMode ?? 'select';
+  }
+
+  get selectionMode(): TypeResourcePickerSelectionMode {
+    return this.resourcePickerOptions?.selectionMode ?? 'single';
+  }
+
   get queryData() {
     return this.$$modelResource.selectGeneral(
       this.resourcePickerOptions?.actionPath,
@@ -86,6 +118,11 @@ export class ControllerFormFieldResourcePicker extends BeanControllerBase {
         ></ZFormFieldPreset>
       );
     }
+    if (this.pickerMode === 'routedDialog') return this._renderRoutedDialogField();
+    return this._renderSelectField();
+  }
+
+  private _renderSelectField() {
     return (
       <ZFormField
         {...this.$props}
@@ -131,14 +168,190 @@ export class ControllerFormFieldResourcePicker extends BeanControllerBase {
     );
   }
 
+  private _renderRoutedDialogField() {
+    return (
+      <ZFormField
+        {...this.$props}
+        slotDefault={({ propsBucket, props }, $$formField) => {
+          const className = !propsBucket.needHandleBorder
+            ? classes(
+                props.class,
+                'grow w-full h-full min-h-0 border-0 rounded-none bg-transparent px-0 py-0 text-left outline-none',
+              )
+            : classes(props.class, 'input', !$$formField.field.state.meta.isValid && 'input-error');
+          return (
+            <button
+              {...props}
+              type="button"
+              class={className}
+              onBlur={() => $$formField.handleBlur()}
+              onClick={() => {
+                void this._openPicker(propsBucket.value, value => {
+                  $$formField.setValue(value, propsBucket.disableNotifyChanged);
+                }).catch(error => {
+                  this.$errorHandler(error, 'ControllerFormFieldResourcePicker.openPicker');
+                });
+              }}
+            >
+              {this._formatPickerValue(propsBucket.value) || this.scope.locale.PleaseSelect()}
+            </button>
+          );
+        }}
+      ></ZFormField>
+    );
+  }
+
+  private async _openPicker(value: unknown, setValue: (value: unknown) => void) {
+    if (this._openingDialog) return;
+    this._openingDialog = true;
+    try {
+      const selectedIds = normalizeResourcePickerIds(value);
+      const options: IResourcePickerPageOptions = {
+        resource: this.resource,
+        actionPath: this.resourcePickerOptions?.actionPath,
+        query: this.resourcePickerOptions?.query,
+        selectionMode: this.selectionMode,
+        selectionMax: this.resourcePickerOptions?.selectionMax,
+        selectedIds,
+      };
+      const session: IResourcePickerPageSession = {
+        selectedIds: [...selectedIds],
+        selectedRows: [],
+      };
+      const handle = this.$appModal.routedDialog<
+        IResourceTableSelectionPayload,
+        IResourcePickerPageOptions,
+        IResourcePickerPageSession
+      >({
+        route: {
+          name: 'rest-resource:resourcePicker',
+          params: { resource: this.resource },
+        },
+        props: options,
+        session,
+        createPageHostProviders: dialog => ({
+          [resourcePickerPageHostKey]: createResourcePickerPageHost(dialog),
+        }),
+      });
+      const result = await handle.result;
+      if (!result) return;
+      const nextValue = resolveResourcePickerValue(
+        result.ids,
+        this.selectionMode,
+        resolvePickerSelectionMax(this.selectionMode, this.resourcePickerOptions?.selectionMax),
+      );
+      this._syncRelationField(nextValue, result.rows);
+      setValue(nextValue);
+    } finally {
+      this._openingDialog = false;
+    }
+  }
+
+  private _formatPickerValue(value: unknown) {
+    const selectedIds = normalizeResourcePickerIds(value);
+    if (selectedIds.length === 0) return '';
+    const relationItems = this._getRelationItems();
+    const relationMap = new Map(
+      relationItems.map(item => [String(item.id as TableIdentity), item] as const),
+    );
+    const itemTitle = this._itemTitle;
+    const missingIds = selectedIds.filter(id => {
+      const item = relationMap.get(String(id));
+      return (
+        (item?.[itemTitle] === undefined || item[itemTitle] === null) &&
+        !this._labelHydrationAttemptedIds.has(String(id))
+      );
+    });
+    if (missingIds.length > 0) {
+      void this._hydrateMissingLabels(missingIds);
+    }
+    return selectedIds
+      .map(id => {
+        const title = relationMap.get(String(id))?.[itemTitle];
+        return title === undefined || title === null ? String(id) : String(title);
+      })
+      .join(', ');
+  }
+
   private _getValueByRelation() {
-    const { $$form } = this.$$renderContext;
-    let relationName = this.$props.options.relationName;
-    if (!relationName) {
-      relationName = this.$props.name!.substring(0, this.$props.name!.lastIndexOf('Id'));
+    const item = this._getRelationItems()[0];
+    return item?.[this._itemTitle];
+  }
+
+  private get _itemTitle() {
+    return String(this.resourcePickerOptions?.selectOptions?.itemTitle ?? 'name');
+  }
+
+  private get _relationName() {
+    const relationName = this.resourcePickerOptions?.relationName;
+    if (relationName) return relationName;
+    const fieldName = this.$props.name;
+    const index = fieldName?.lastIndexOf('Id') ?? -1;
+    return index > 0 ? fieldName!.substring(0, index) : undefined;
+  }
+
+  private _getRelationItems() {
+    const relationName = this._relationName;
+    if (!relationName) return [] as Record<string, unknown>[];
+    const value = this.$$renderContext.$$form.getFieldValue(relationName as never);
+    const items = Array.isArray(value) ? value : value ? [value] : [];
+    return items.filter(item => !!item && typeof item === 'object') as Record<string, unknown>[];
+  }
+
+  private _syncRelationField(value: unknown, rows: readonly Record<string, unknown>[]) {
+    const relationName = this._relationName;
+    if (!relationName) return;
+    const selectedIds = normalizeResourcePickerIds(value);
+    const itemTitle = this._itemTitle;
+    const rowMap = new Map(
+      this._getRelationItems().map(item => [String(item.id as TableIdentity), item] as const),
+    );
+    for (const row of rows) {
+      const id = row.id as TableIdentity;
+      if (id === undefined || id === null || id === '') continue;
+      const title = row[itemTitle];
+      if (title === undefined || title === null) continue;
+      rowMap.set(String(id), { id, [itemTitle]: title });
+    }
+    const relationItems = selectedIds.map(id => rowMap.get(String(id)) ?? { id });
+    const relationValue = this.selectionMode === 'multiple' ? relationItems : relationItems[0];
+    this.$$renderContext.$$form.setFieldValue(relationName as never, relationValue, true);
+  }
+
+  private async _hydrateMissingLabels(ids: readonly TableIdentity[]) {
+    const relationName = this._relationName;
+    if (!relationName) return;
+    const idsToLoad = ids.filter(id => {
+      const key = String(id);
+      if (this._pendingLabelIds.has(key) || this._labelHydrationAttemptedIds.has(key)) return false;
+      this._pendingLabelIds.add(key);
+      this._labelHydrationAttemptedIds.add(key);
+      return true;
+    });
+    if (idsToLoad.length === 0) return;
+    try {
+      const model = (await this.bean._getBeanSelector(
+        'rest-resource.model.resource',
+        true,
+        this.resource,
+      )) as ModelResource;
+      const rows = await Promise.all(
+        idsToLoad.map(async id => {
+          const result = await model.view(id).refetch();
+          return result.data;
+        }),
+      );
+      const currentIds = normalizeResourcePickerIds(
+        this.$$renderContext.$$form.getFieldValue(this.$props.name as never),
+      );
+      this._syncRelationField(currentIds, rows.filter(Boolean) as Record<string, unknown>[]);
+    } catch (error) {
+      this.$errorHandler(error, 'ControllerFormFieldResourcePicker.hydrateMissingLabels');
+    } finally {
+      for (const id of idsToLoad) {
+        this._pendingLabelIds.delete(String(id));
+      }
     }
-    const obj = $$form.getFieldValue(relationName);
-    return obj?.[String(this.$props.options.selectOptions!.itemTitle)];
   }
 
   private _ensureEmptyItemFallback(

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

@@ -0,0 +1,8 @@
+export default {
+  Cancel: 'Cancel',
+  PleaseSelect: 'Please select...',
+  Select: 'Select',
+  SelectedItems: 'Selected %d items',
+  SelectedItems_1: 'Selected one item',
+  SelectedItemsWithMax: 'Selected %d / %d items',
+};

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

@@ -0,0 +1,7 @@
+export default {
+  Cancel: '取消',
+  PleaseSelect: '请选择...',
+  Select: '选择',
+  SelectedItems: '已选择 %d 项',
+  SelectedItemsWithMax: '已选择 %d / %d 项',
+};

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

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

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

@@ -0,0 +1,29 @@
+import type { TableIdentity } from 'table-identity';
+
+import { isNil } from '@cabloy/utils';
+
+export type TypeResourcePickerSelectionMode = 'single' | 'multiple';
+
+export function normalizeResourcePickerIds(value: unknown): TableIdentity[] {
+  const values = Array.isArray(value) ? value : isNil(value) || value === '' ? [] : [value];
+  const ids: TableIdentity[] = [];
+  const keys = new Set<string>();
+  for (const value of values) {
+    if (isNil(value) || value === '') continue;
+    const id = value as TableIdentity;
+    const key = String(id);
+    if (keys.has(key)) continue;
+    keys.add(key);
+    ids.push(id);
+  }
+  return ids;
+}
+
+export function resolveResourcePickerValue(
+  value: unknown,
+  selectionMode: TypeResourcePickerSelectionMode,
+  selectionMax: number,
+): TableIdentity | TableIdentity[] | undefined {
+  const selectedIds = normalizeResourcePickerIds(value).slice(0, selectionMax);
+  return selectionMode === 'single' ? selectedIds[0] : selectedIds;
+}

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

@@ -0,0 +1,64 @@
+import type {
+  IResourceBlockOptionsBase,
+  IResourceRenderBlockOptionsBlock,
+  IResourceTableSelectionPayload,
+} from 'zova-module-a-openapi';
+import type { IRoutedDialogContext } from 'zova-module-basic-app';
+import type {
+  IResourcePickerPageContext,
+  IResourcePickerPageHost,
+} from 'zova-module-rest-resource';
+
+import { deepExtend } from 'zova';
+
+export function createResourcePickerPageHost(
+  dialog: IRoutedDialogContext<
+    IResourceTableSelectionPayload,
+    IResourcePickerPageContext['options'],
+    IResourcePickerPageContext['session']
+  >,
+): IResourcePickerPageHost {
+  const options = dialog.props;
+  const session = dialog.session;
+  if (!options || !session) {
+    throw new Error('resource picker requires dialog options and session');
+  }
+  return {
+    options,
+    session,
+    resolve: selection => dialog.resolve(selection),
+    cancel: () => dialog.cancel(),
+    prepareBlocks: (blocks, pickerContext) => {
+      if (!blocks) return;
+      return blocks.map(block => {
+        if (block.render !== 'basic-page:blockPage') return block;
+        return {
+          ...block,
+          options: deepExtend({}, block.options, {
+            actionPath: pickerContext.options.actionPath,
+            queryFixed: pickerContext.options.query,
+            selectionPolicy: 'always',
+            selectionMode: pickerContext.options.selectionMode,
+            selectionMax: pickerContext.options.selectionMax,
+            selectedIds: pickerContext.session.selectedIds,
+            selectedRows: pickerContext.session.selectedRows,
+            onSelectionChange: (selection: IResourceTableSelectionPayload) => {
+              pickerContext.session.selectedIds = [...selection.ids];
+              pickerContext.session.selectedRows = selection.rows.map(row => ({ ...row }));
+            },
+            blocks: [
+              ...((
+                block.options as IResourceBlockOptionsBase & {
+                  blocks?: IResourceRenderBlockOptionsBlock[];
+                }
+              ).blocks ?? []),
+              {
+                render: 'basic-resource:blockResourcePickerActions',
+              },
+            ],
+          }),
+        };
+      });
+    },
+  };
+}

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

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  normalizeResourcePickerIds,
+  resolveResourcePickerValue,
+} from '../../src/lib/resourcePicker.ts';
+
+test('resource picker normalization preserves identity types and deduplicates equivalent identities', () => {
+  assert.deepEqual(normalizeResourcePickerIds(undefined), []);
+  assert.deepEqual(normalizeResourcePickerIds(''), []);
+  assert.deepEqual(normalizeResourcePickerIds(7), [7]);
+  assert.deepEqual(normalizeResourcePickerIds([7, '7', 8, undefined, '']), [7, 8]);
+});
+
+test('resource picker result resolves a scalar identity for single mode', () => {
+  assert.equal(resolveResourcePickerValue([7, 8], 'single', 1), 7);
+  assert.equal(resolveResourcePickerValue([], 'single', 1), undefined);
+});
+
+test('resource picker result enforces the configured multiple selection maximum', () => {
+  assert.deepEqual(resolveResourcePickerValue([1, 2, 3], 'multiple', 2), [1, 2]);
+  assert.deepEqual(resolveResourcePickerValue([1, 2], 'multiple', 0), []);
+  assert.deepEqual(
+    resolveResourcePickerValue(
+      Array.from({ length: 101 }, (_value, index) => index + 1),
+      'multiple',
+      100,
+    ),
+    Array.from({ length: 100 }, (_value, index) => index + 1),
+  );
+});