cabloy 5.1.166 → 5.1.168

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

@@ -1,15 +1,34 @@
+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 { ModelResource } from 'zova-module-rest-resource';
 
+import type { TypeResourcePickerSelectionMode } from '../../lib/resourcePicker.js';
+
+import {
+  normalizeResourcePickerIds,
+  resolveResourcePickerValue,
+} from '../../lib/resourcePicker.js';
+
+export type TypeResourcePickerMode = 'select' | 'routedDialog';
+
 declare module 'zova-module-a-openapi' {
   export interface IResourceFormFieldRecord {
     'basic-resource:formFieldResourcePicker'?: IResourceFormFieldResourcePickerOptions;
@@ -22,6 +41,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 +59,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 +87,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 +116,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 +166,187 @@ 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,
+      });
+      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/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),
+  );
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export const resourcePickerPageContextKey = '$resourcePickerPageContext';

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

@@ -153,7 +153,7 @@ export class ModelResource<
           this.sys.util.apiActionPathTranslate(`${this.resourceApi}/:id`, { id }),
           this.sys.util.apiActionConfigPrepare(),
         );
-        return res ?? null;
+        return (res as Entity | null) ?? null;
       },
     });
   }