@nocobase/client-v2 2.1.0-beta.46 → 2.1.0-beta.48

package/src/components/form/ScanInput/index.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export * from './CodeScanner';
+export * from './ScanInput';
+export * from './types';

package/src/components/form/ScanInput/types.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type { Html5QrcodeSupportedFormats } from 'html5-qrcode';
+
+export type CodeFormatsToSupport = Html5QrcodeSupportedFormats[];

package/src/components/form/ScanInput/useCodeScanner.ts

@@ -0,0 +1,136 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Html5Qrcode, Html5QrcodeScannerState, Html5QrcodeSupportedFormats } from 'html5-qrcode';
+import { useCallback, useEffect, useState } from 'react';
+import type { CodeFormatsToSupport } from './types';
+
+type ScannerSize = {
+  width: number;
+  height: number;
+};
+
+type UseCodeScannerOptions = {
+  enabled: boolean;
+  elementId: string;
+  formatsToSupport?: CodeFormatsToSupport;
+  scanBoxSize?: ScannerSize;
+  onScannerSizeChanged?: (size: ScannerSize) => void;
+  onScanSuccess: (text: string) => void;
+  onScanFailure?: () => void;
+};
+
+export const DEFAULT_CODE_FORMATS: CodeFormatsToSupport = [
+  Html5QrcodeSupportedFormats.QR_CODE,
+  Html5QrcodeSupportedFormats.CODE_128,
+  Html5QrcodeSupportedFormats.CODE_39,
+  Html5QrcodeSupportedFormats.CODE_93,
+  Html5QrcodeSupportedFormats.CODABAR,
+  Html5QrcodeSupportedFormats.EAN_13,
+  Html5QrcodeSupportedFormats.EAN_8,
+  Html5QrcodeSupportedFormats.ITF,
+  Html5QrcodeSupportedFormats.UPC_A,
+  Html5QrcodeSupportedFormats.UPC_E,
+  Html5QrcodeSupportedFormats.DATA_MATRIX,
+  Html5QrcodeSupportedFormats.PDF_417,
+];
+
+export function getCodeScanBoxSize(width: number, height: number) {
+  return {
+    width: Math.floor(Math.min(width * 0.82, 520)),
+    height: Math.floor(Math.min(height * 0.32, 240)),
+  };
+}
+
+async function stopScanner(scanner?: Html5Qrcode, options: { clear?: boolean } = {}) {
+  if (!scanner) {
+    return;
+  }
+
+  const state = scanner.getState();
+  if ([Html5QrcodeScannerState.SCANNING, Html5QrcodeScannerState.PAUSED].includes(state)) {
+    await scanner.stop();
+  }
+  if (options.clear) {
+    scanner.clear();
+  }
+}
+
+export function useCodeScanner({
+  enabled,
+  elementId,
+  formatsToSupport,
+  scanBoxSize,
+  onScannerSizeChanged,
+  onScanSuccess,
+  onScanFailure,
+}: UseCodeScannerOptions) {
+  const [scanner, setScanner] = useState<Html5Qrcode>();
+
+  const startScanCamera = useCallback(
+    async (scannerInstance: Html5Qrcode) => {
+      await scannerInstance.start(
+        { facingMode: 'environment' },
+        {
+          fps: 10,
+          qrbox(width, height) {
+            onScannerSizeChanged?.({ width, height });
+            return scanBoxSize ?? getCodeScanBoxSize(width, height);
+          },
+        },
+        (decodedText) => {
+          onScanSuccess(decodedText);
+        },
+        undefined,
+      );
+    },
+    [onScanSuccess, onScannerSizeChanged, scanBoxSize],
+  );
+
+  const startScanFile = useCallback(
+    async (file: File) => {
+      if (!scanner) {
+        return;
+      }
+
+      await stopScanner(scanner);
+      try {
+        const result = await scanner.scanFileV2(file, false);
+        onScanSuccess(result.decodedText);
+      } catch (error) {
+        onScanFailure?.();
+        await startScanCamera(scanner);
+      }
+    },
+    [onScanFailure, onScanSuccess, scanner, startScanCamera],
+  );
+
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    const scannerInstance = new Html5Qrcode(elementId, {
+      formatsToSupport: formatsToSupport?.length ? formatsToSupport : DEFAULT_CODE_FORMATS,
+      verbose: false,
+    });
+    setScanner(scannerInstance);
+    startScanCamera(scannerInstance).catch(() => {
+      onScanFailure?.();
+    });
+
+    return () => {
+      stopScanner(scannerInstance, { clear: true }).catch(() => undefined);
+    };
+  }, [elementId, enabled, formatsToSupport, onScanFailure, startScanCamera]);
+
+  return {
+    startScanFile,
+  };
+}

package/src/components/form/filter/CollectionFilter.tsx

@@ -19,6 +19,8 @@ const identity = (s: string) => s;
 export interface CollectionFilterProps {
   /** Collection whose fields drive the filter row's field picker. */
   collection: Collection | undefined;
+  /** Previously compiled filter param used to seed the editable filter group. */
+  initialValue?: CompiledFilter;
   /** Called on Submit or Reset with the compiled NocoBase filter param (`undefined` when cleared). */
   onChange: (filter: CompiledFilter) => void;
   /** Translator. Defaults to identity. */
@@ -55,6 +57,7 @@ export interface CollectionFilterProps {
 export const CollectionFilter: FC<CollectionFilterProps> = (props) => {
   const {
     collection,
+    initialValue,
     onChange,
     t = identity,
     filterableFieldNames,
@@ -71,6 +74,7 @@ export const CollectionFilter: FC<CollectionFilterProps> = (props) => {
 
   const filterAction = useFilterActionProps({
     collection,
+    initialValue,
     filterableFieldNames,
     nonfilterableFieldNames,
     noIgnore,

package/src/components/form/filter/CollectionFilterPanel.tsx

@@ -0,0 +1,97 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type { Collection } from '@nocobase/flow-engine';
+import { Empty } from 'antd';
+import React, { forwardRef, useImperativeHandle } from 'react';
+import { FilterGroup } from '../../../flow/components/filter';
+import {
+  compileFilterGroup,
+  type CompiledFilter,
+  type FilterApplyAction,
+  useFilterActionProps,
+} from './useFilterActionProps';
+
+const identity = (s: string) => s;
+
+export interface CollectionFilterPanelRef {
+  getFilter: () => CompiledFilter;
+  reset: () => void;
+}
+
+export interface CollectionFilterPanelProps {
+  /** Collection whose fields drive the filter row's field picker. */
+  collection: Collection | undefined;
+  /** Previously compiled filter param used to seed the editable filter group. */
+  initialValue?: CompiledFilter;
+  /** Called when the condition group structure changes or `reset()` is invoked. */
+  onChange?: (filter: CompiledFilter) => void;
+  /** Translator. Defaults to identity. */
+  t?: (key: string, options?: Record<string, unknown>) => string;
+  /** Whitelist of root-level field names to expose. */
+  filterableFieldNames?: string[];
+  /**
+   * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`.
+   */
+  nonfilterableFieldNames?: string[];
+  /** Bypass the `filterableFieldNames` whitelist. */
+  noIgnore?: boolean;
+}
+
+/**
+ * Inline collection filter editor for forms and drawers. Unlike `CollectionFilter`, this does not render a trigger button, popover, or nested `<form>`, so it can safely live inside an antd form and be submitted by the outer drawer action.
+ */
+export const CollectionFilterPanel = forwardRef<CollectionFilterPanelRef, CollectionFilterPanelProps>((props, ref) => {
+  const {
+    collection,
+    initialValue,
+    onChange,
+    t = identity,
+    filterableFieldNames,
+    nonfilterableFieldNames,
+    noIgnore,
+  } = props;
+
+  const filterAction = useFilterActionProps({
+    collection,
+    initialValue,
+    filterableFieldNames,
+    nonfilterableFieldNames,
+    noIgnore,
+    t,
+    onApply: (filter: CompiledFilter, _action: FilterApplyAction) => {
+      onChange?.(filter);
+    },
+  });
+
+  useImperativeHandle(
+    ref,
+    () => ({
+      getFilter: () => compileFilterGroup(filterAction.value),
+      reset: filterAction.onReset,
+    }),
+    [filterAction.onReset, filterAction.value],
+  );
+
+  if (!collection || !filterAction.FilterItem) {
+    return <Empty image={Empty.PRESENTED_IMAGE_SIMPLE} description={t('No data')} />;
+  }
+
+  return (
+    <FilterGroup
+      value={filterAction.value}
+      FilterItem={filterAction.FilterItem}
+      onChange={() => onChange?.(compileFilterGroup(filterAction.value))}
+    />
+  );
+});
+
+CollectionFilterPanel.displayName = 'CollectionFilterPanel';
+
+export default CollectionFilterPanel;

package/src/components/form/filter/__tests__/compileFilterGroup.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { describe, expect, it } from 'vitest';
-import { compileFilterGroup } from '../useFilterActionProps';
+import { compileFilterGroup, decompileFilterGroup } from '../useFilterActionProps';
 
 describe('compileFilterGroup', () => {
   it('returns undefined for an empty group so callers can drop the filter param', () => {
@@ -144,3 +144,78 @@ describe('compileFilterGroup', () => {
     });
   });
 });
+
+describe('decompileFilterGroup', () => {
+  it('returns undefined for an empty compiled filter', () => {
+    expect(decompileFilterGroup(undefined)).toBeUndefined();
+    expect(decompileFilterGroup({})).toBeUndefined();
+  });
+
+  it('restores a compiled condition into an editable filter row', () => {
+    expect(decompileFilterGroup({ $and: [{ lockReason: { $includes: 'abuse' } }] })).toEqual({
+      logic: '$and',
+      items: [{ path: 'lockReason', operator: '$includes', value: 'abuse' }],
+    });
+  });
+
+  it('restores a direct condition object into an editable filter row', () => {
+    expect(decompileFilterGroup({ title: { $includes: 'test' } })).toEqual({
+      logic: '$and',
+      items: [{ path: 'title', operator: '$includes', value: 'test' }],
+    });
+  });
+
+  it('restores legacy direct field values as equality rows', () => {
+    expect(decompileFilterGroup({ createdById: '{{ ctx.state.currentUser.id }}' })).toEqual({
+      logic: '$and',
+      items: [{ path: 'createdById', operator: '$eq', value: '{{ ctx.state.currentUser.id }}' }],
+    });
+  });
+
+  it('restores multiple direct condition fields', () => {
+    expect(
+      decompileFilterGroup({
+        title: { $includes: 'test' },
+        status: 'published',
+      }),
+    ).toEqual({
+      logic: '$and',
+      items: [
+        { path: 'title', operator: '$includes', value: 'test' },
+        { path: 'status', operator: '$eq', value: 'published' },
+      ],
+    });
+  });
+
+  it('restores nested association paths', () => {
+    expect(decompileFilterGroup({ $and: [{ user: { createdBy: { password: { $includes: '123' } } } }] })).toEqual({
+      logic: '$and',
+      items: [{ path: 'user.createdBy.password', operator: '$includes', value: '123' }],
+    });
+  });
+
+  it('restores nested filter groups', () => {
+    expect(
+      decompileFilterGroup({
+        $and: [
+          { lockReason: { $eq: 'abuse' } },
+          {
+            $or: [{ lockedTs: { $dateAfter: '2026-01-01' } }, { lockedTs: { $dateBefore: '2026-12-31' } }],
+          },
+        ],
+      }),
+    ).toEqual({
+      logic: '$and',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        {
+          logic: '$or',
+          items: [
+            { path: 'lockedTs', operator: '$dateAfter', value: '2026-01-01' },
+            { path: 'lockedTs', operator: '$dateBefore', value: '2026-12-31' },
+          ],
+        },
+      ],
+    });
+  });
+});

package/src/components/form/filter/index.ts

@@ -10,4 +10,6 @@
 // Higher-level filter compositions for non-schema surfaces (settings pages, panels, side drawers). The low-level primitives — `FilterContainer`, `FilterGroup`, `FilterItem`, `fieldsToOptions`, `useFilterOptions` — live under `src/flow/components/filter/`; this layer composes them with a `Collection` binding and exposes the hook/component pair callers actually reach for. The dependency direction is form/filter → flow/components/filter only.
 export { CollectionFilter } from './CollectionFilter';
 export type { CollectionFilterProps } from './CollectionFilter';
+export { CollectionFilterPanel } from './CollectionFilterPanel';
+export type { CollectionFilterPanelProps, CollectionFilterPanelRef } from './CollectionFilterPanel';
 export type { CompiledFilter } from './useFilterActionProps';

package/src/components/form/filter/useFilterActionProps.ts

@@ -68,6 +68,68 @@ const nestPath = (path: string, leaf: unknown): Record<string, unknown> => {
   return result as Record<string, unknown>;
 };
 
+const decompileConditions = (value: unknown, path: string[] = []): CollectionFilterItemValue[] => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return path.length ? [{ path: path.join('.'), operator: '$eq', value }] : [];
+  }
+
+  const entries = Object.entries(value as Record<string, unknown>);
+  const operatorEntries = entries.filter(([key]) => key.startsWith('$'));
+  if (operatorEntries.length) {
+    if (!path.length) {
+      return [];
+    }
+    return operatorEntries.map(([operator, operatorValue]) => ({
+      path: path.join('.'),
+      operator,
+      value: operatorValue,
+    }));
+  }
+
+  return entries.flatMap(([fieldName, nextValue]) => decompileConditions(nextValue, [...path, fieldName]));
+};
+
+const getGroupLogic = (record: Record<string, unknown>): FilterGroupValue['logic'] | undefined => {
+  if (Array.isArray(record.$or)) {
+    return '$or';
+  }
+  if (Array.isArray(record.$and)) {
+    return '$and';
+  }
+  return undefined;
+};
+
+const decompileFilterItem = (item: unknown): FilterGroupItem[] => {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) {
+    return [];
+  }
+  const record = item as Record<string, unknown>;
+  if (getGroupLogic(record)) {
+    const group = decompileFilterGroup(record);
+    return group ? [group] : [];
+  }
+  return decompileConditions(record);
+};
+
+export function decompileFilterGroup(filter: CompiledFilter): FilterGroupValue | undefined {
+  if (!filter || typeof filter !== 'object' || Array.isArray(filter)) {
+    return undefined;
+  }
+
+  const record = filter as Record<string, unknown>;
+  const logic = getGroupLogic(record);
+  if (!logic) {
+    const items = decompileConditions(record);
+    return items.length ? { logic: '$and', items } : undefined;
+  }
+  const sourceItems = record[logic] as unknown[];
+  const items = sourceItems
+    .flatMap((item) => decompileFilterItem(item))
+    .filter((item): item is FilterGroupItem => Boolean(item));
+
+  return items.length ? { logic, items } : undefined;
+}
+
 /**
  * Compile a reactive filter group into the `{ $and: [{ path: { op: val } }] }` envelope accepted by NocoBase's resource `list` filter param. Returns `undefined` when the group is empty so callers can drop the param.
  *
@@ -100,6 +162,8 @@ export type FilterApplyAction = 'submit' | 'reset';
 export interface UseFilterActionPropsArgs extends UseFilterOptionsArgs {
   /** Collection whose fields populate the filter row's field picker. */
   collection: Collection | undefined;
+  /** Previously compiled filter param used to seed the editable filter group. */
+  initialValue?: CompiledFilter;
   /**
    * Called when the user submits or resets the filter popover. Receives the compiled filter param (`undefined` when cleared) and which footer button triggered the call. Typical implementation: `(filter, action) => { listRequest.run(filter); if (action === 'submit') closePopover(); }`.
    */
@@ -152,12 +216,12 @@ export interface UseFilterActionPropsResult {
  * ```
  */
 export function useFilterActionProps(args: UseFilterActionPropsArgs): UseFilterActionPropsResult {
-  const { collection, onApply, filterableFieldNames, nonfilterableFieldNames, noIgnore, t } = args;
+  const { collection, initialValue, onApply, filterableFieldNames, nonfilterableFieldNames, noIgnore, t } = args;
 
   // Held in a ref so the group object identity is stable for the lifetime of the host component — `<FilterContent>` mutates this object directly (push/splice on `items`, swap `logic`), and a fresh observable on every render would reset that internal state.
   const valueRef = useRef<FilterGroupValue>();
   if (!valueRef.current) {
-    valueRef.current = observable(createEmptyGroup()) as FilterGroupValue;
+    valueRef.current = observable(decompileFilterGroup(initialValue) || createEmptyGroup()) as FilterGroupValue;
   }
   const value = valueRef.current;
 

package/src/components/form/index.tsx

@@ -16,5 +16,6 @@ export * from './FileSizeInput';
 export * from './JsonTextArea';
 export * from './PasswordInput';
 export * from './RemoteSelect';
+export * from './ScanInput';
 export * from './TypedVariableInput';
 export * from './VariableInput';

package/src/flow/actions/__tests__/actionLinkageRules.race.repro.test.ts

@@ -10,6 +10,9 @@
 import { describe, expect, it, vi } from 'vitest';
 import { actionLinkageRules } from '../linkageRules';
 
+class ActionModel {}
+class PopupSubTableEditActionModel extends ActionModel {}
+
 function createActionModel() {
   const model: any = {
     uid: 'edit-action',
@@ -196,4 +199,46 @@ describe('actionLinkageRules props patch isolation', () => {
 
     expect(model.hidden).toBe(true);
   });
+
+  it('does not sync row action hidden state to the popup subtable field path', async () => {
+    const model = createActionModel();
+    Object.defineProperty(model, 'constructor', {
+      value: PopupSubTableEditActionModel,
+    });
+    model.isFork = true;
+    model.context = {
+      blockModel: { uid: 'form-block' },
+      fieldPathArray: ['org_o2m'],
+    };
+    const fieldModel: any = {
+      uid: 'org-o2m-field',
+      hidden: false,
+      context: {
+        blockModel: { uid: 'form-block' },
+        fieldPathArray: ['org_o2m'],
+      },
+    };
+    const { ctx } = createRuntime(model, { pauseHiddenAction: false });
+    ctx.engine = {
+      forEachModel: (visitor: (m: any) => void) => {
+        visitor(model);
+        visitor(fieldModel);
+      },
+    };
+
+    await actionLinkageRules.handler(
+      ctx,
+      createLinkageParams([
+        {
+          name: 'linkageSetActionProps',
+          params: {
+            value: 'hidden',
+          },
+        },
+      ]),
+    );
+
+    expect(model.hidden).toBe(true);
+    expect(fieldModel.hidden).toBe(false);
+  });
 });

package/src/flow/actions/linkageRules.tsx

@@ -46,7 +46,7 @@ import { useAssociationTitleFieldSync } from '../components/useAssociationTitleF
 import _ from 'lodash';
 import { SubFormFieldModel, SubFormListFieldModel } from '../models';
 import { coerceForToOneField } from '../internal/utils/associationValueCoercion';
-import { enumToOptions } from '../internal/utils/enumOptionsUtils';
+import { enumToOptions, translateOptionLabel } from '../internal/utils/enumOptionsUtils';
 import {
   findFormItemModelByFieldPath,
   getCollectionFromModel,
@@ -106,6 +106,18 @@ const getLinkageScopeDepthFromContext = (ctx: FlowContext): number => {
   return getLinkageScopeDepthFromModel((ctx as any)?.model);
 };
 
+const isActionFlowModel = (model: any): boolean => {
+  if (!model || typeof model !== 'object') return false;
+
+  let proto = model.constructor?.prototype;
+  while (proto) {
+    if (proto.constructor?.name === 'ActionModel') return true;
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return false;
+};
+
 // 获取表单中所有字段的 model 实例的通用函数
 const getFormFields = (ctx: any) => {
   try {
@@ -156,7 +168,7 @@ const getFieldModelOptions = (fieldModel: any, t: (s: string) => string) => {
   if (originalOptions) {
     return originalOptions.map((option: any) =>
       option && typeof option === 'object' && typeof option.label === 'string'
-        ? { ...option, label: t(option.label) }
+        ? { ...option, label: translateOptionLabel(option.label, t) }
         : option,
     );
   }
@@ -2142,12 +2154,12 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
-      model.setHidden(!!newProps.hiddenModel);
+      model.setHidden(nextHidden);
     } else {
       model.hidden = nextHidden;
-      if (prevHidden !== nextHidden) {
-        hiddenStatePatches.push({ model, hidden: nextHidden });
-      }
+    }
+    if (prevHidden !== nextHidden && !isActionFlowModel(model)) {
+      hiddenStatePatches.push({ model, hidden: nextHidden });
     }
 
     if (newProps.required === true) {

package/src/flow/internal/utils/__tests__/enumOptionsUtils.test.ts

@@ -24,27 +24,28 @@ function mockT(input: string) {
 }
 
 describe('enumOptions utils', () => {
-  it('enumToOptions: converts primitive enum and translates labels', () => {
+  it('enumToOptions: converts primitive enum and translates explicit template labels', () => {
     const uiEnum = ['{{t("Yes")}}', '{{t("No")}}'];
-    const options = enumToOptions(uiEnum as any, mockT)!;
-    expect(options).toHaveLength(2);
-    expect(options[0]).toEqual({ label: '是', value: '{{t("Yes")}}' });
-    expect(options[1]).toEqual({ label: '否', value: '{{t("No")}}' });
+    const options = enumToOptions(uiEnum as any, mockT);
+    expect(options).toEqual([
+      { label: '是', value: '{{t("Yes")}}' },
+      { label: '否', value: '{{t("No")}}' },
+    ]);
   });
 
-  it('enumToOptions: keeps object value and translates object label', () => {
+  it('enumToOptions: keeps object value and translates explicit template object label', () => {
     const uiEnum = [
       { label: '{{t("Yes")}}', value: true },
       { label: '{{t("No")}}', value: false },
     ];
-    const options = enumToOptions(uiEnum as any, mockT)!;
+    const options = enumToOptions(uiEnum as any, mockT);
     expect(options).toEqual([
       { label: '是', value: true },
       { label: '否', value: false },
     ]);
   });
 
-  it('translateOptions: maps given options labels through t()', () => {
+  it('translateOptions: maps only explicit template labels through t()', () => {
     const options = [
       { label: '{{t("Draft")}}', value: 'draft' },
       { label: 'No', value: false },
@@ -52,7 +53,7 @@ describe('enumOptions utils', () => {
     const out = translateOptions(options as any, mockT);
     expect(out).toEqual([
       { label: '草稿', value: 'draft' },
-      { label: '否', value: false },
+      { label: 'No', value: false },
     ]);
   });
 

package/src/flow/internal/utils/enumOptionsUtils.ts

@@ -33,13 +33,21 @@ function normalizeUiSchemaEnumToOptions(uiEnum: UiSchemaEnumItem[] = []): Option
   });
 }
 
-// Map option labels through t() (supports {{t('key')}} template and plain strings)
+export function isTranslationTemplate(value: unknown): value is string {
+  return typeof value === 'string' && /\{\{\s*t\s*\(/.test(value);
+}
+
+export function translateOptionLabel(label: any, t: (s: string) => string): any {
+  return isTranslationTemplate(label) ? t(label) : label;
+}
+
+// Map option labels through t() only when labels explicitly use {{t(...)}} templates.
 export function translateOptions(options: Option[] = [], t: (s: string) => string): Option[] {
   if (!Array.isArray(options)) return [] as Option[];
-  return options.map((opt) => (typeof opt?.label === 'string' ? { ...opt, label: t(opt.label) } : opt));
+  return options.map((opt) => ({ ...opt, label: translateOptionLabel(opt?.label, t) }));
 }
 
-// Build options from uiSchema.enum with translated labels
+// Build options from uiSchema.enum with explicitly translated labels
 export function enumToOptions(uiEnum: UiSchemaEnumItem[] | undefined, t: (s: string) => string): Option[] | undefined {
   if (!uiEnum || !Array.isArray(uiEnum) || uiEnum.length === 0) return undefined;
   const normalized = normalizeUiSchemaEnumToOptions(uiEnum);