@nocobase/client-v2 2.1.0-beta.29 → 2.1.0-beta.32

package/src/flow/admin-shell/admin-layout/resolveAdminRouteRuntimeTarget.ts

@@ -8,15 +8,21 @@
  */
 
 import type { BaseApplication } from '../../../BaseApplication';
-import { convertV2AdminPathToLegacy } from '../../../authRedirect';
 import { NocoBaseDesktopRouteType, type NocoBaseDesktopRoute } from '../../../flow-compat';
 
 export type AdminRouteNavigationMode = 'spa' | 'document';
+export type AdminRouteRuntimeTargetReason =
+  | 'ok'
+  | 'missingSchemaUid'
+  | 'unsupportedV2Runtime'
+  | 'emptyGroup'
+  | 'unsupportedRouteType';
 
 export type AdminRouteRuntimeTarget = {
   runtimePath: string | null;
   navigationMode: AdminRouteNavigationMode;
   isLegacy: boolean;
+  reason: AdminRouteRuntimeTargetReason;
 };
 
 const V2_PUBLIC_PATH_SUFFIX = '/v2/';
@@ -45,6 +51,7 @@ const EMPTY_TARGET: AdminRouteRuntimeTarget = {
   runtimePath: null,
   navigationMode: 'spa',
   isLegacy: false,
+  reason: 'unsupportedRouteType',
 };
 
 function normalizeRootRelativePath(pathname: string) {
@@ -60,14 +67,8 @@ function normalizePublicPath(value = '/') {
   return normalized.endsWith('/') ? normalized : `${normalized}/`;
 }
 
-/**
- * 判断当前应用是否运行在需要兼容跳回 v1 的 `/v2/` 路径下。
- *
- * @param {ResolveAdminRouteRuntimeTargetOptions['app']} app 当前应用实例
- * @returns {boolean} 是否启用 v2 到 v1 的经典页跳转
- */
-function shouldUseLegacyDocumentNavigation(app: ResolveAdminRouteRuntimeTargetOptions['app']) {
-  return normalizePublicPath(app.getPublicPath()).endsWith(V2_PUBLIC_PATH_SUFFIX);
+export function isV2AdminRuntime(app?: ResolveAdminRouteRuntimeTargetOptions['app']) {
+  return !!app?.getPublicPath && normalizePublicPath(app.getPublicPath()).endsWith(V2_PUBLIC_PATH_SUFFIX);
 }
 
 export function toRouterNavigationPath(pathname: string, basename?: string) {
@@ -114,12 +115,6 @@ function appendLocationState(pathname: string, location?: LocationLike) {
   return `${pathname}${search}${hash}`;
 }
 
-function isSameOrDescendantPath(pathname: string, basePath: string) {
-  const normalizedPathname = normalizeRootRelativePath(pathname);
-  const normalizedBasePath = normalizeRootRelativePath(basePath);
-  return normalizedPathname === normalizedBasePath || normalizedPathname.startsWith(`${normalizedBasePath}/`);
-}
-
 function logInvalidTarget(
   logger: ResolveAdminRouteRuntimeTargetOptions['log'],
   reason: string,
@@ -134,6 +129,47 @@ function isSkippableRoute(route: NocoBaseDesktopRoute | undefined) {
   );
 }
 
+export function isV2MenuRoute(route: NocoBaseDesktopRoute | undefined): boolean {
+  if (!route || route.hidden === true || route.hideInMenu === true) {
+    return false;
+  }
+
+  if (route.type === NocoBaseDesktopRouteType.flowPage || route.type === NocoBaseDesktopRouteType.link) {
+    return true;
+  }
+
+  if (route.type === NocoBaseDesktopRouteType.group) {
+    return Array.isArray(route.children) && route.children.some((child) => isV2MenuRoute(child));
+  }
+
+  return false;
+}
+
+export function findFirstV2LandingRoute(routes: NocoBaseDesktopRoute[] | undefined): NocoBaseDesktopRoute | undefined {
+  if (!Array.isArray(routes)) {
+    return undefined;
+  }
+
+  for (const route of routes) {
+    if (!route || route.hidden === true || route.hideInMenu === true || route.type === NocoBaseDesktopRouteType.tabs) {
+      continue;
+    }
+
+    if (route.type === NocoBaseDesktopRouteType.flowPage) {
+      return route;
+    }
+
+    if (route.type === NocoBaseDesktopRouteType.group) {
+      const nested = findFirstV2LandingRoute(route.children);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+
+  return undefined;
+}
+
 export function findFirstAccessiblePageRoute(
   routes: NocoBaseDesktopRoute[] | undefined,
 ): NocoBaseDesktopRoute | undefined {
@@ -161,64 +197,44 @@ export function findFirstAccessiblePageRoute(
   return undefined;
 }
 
-function resolvePageRuntimeTarget(options: ResolveAdminRouteRuntimeTargetOptions, route: NocoBaseDesktopRoute) {
+function resolvePageRuntimeTarget(
+  options: ResolveAdminRouteRuntimeTargetOptions,
+  route: NocoBaseDesktopRoute,
+): AdminRouteRuntimeTarget {
   const { app, preserveLocationState, location, log = console.warn } = options;
 
   if (!route.schemaUid) {
     logInvalidTarget(log, 'Missing schemaUid.', route);
-    return EMPTY_TARGET;
-  }
-
-  if (route.type === NocoBaseDesktopRouteType.flowPage) {
     return {
-      runtimePath: getV2AdminPath(app, route.schemaUid),
-      navigationMode: 'spa' as const,
-      isLegacy: false,
+      ...EMPTY_TARGET,
+      reason: 'missingSchemaUid',
     };
   }
 
-  if (!shouldUseLegacyDocumentNavigation(app)) {
+  if (route.type === NocoBaseDesktopRouteType.flowPage) {
     return {
-      runtimePath:
-        preserveLocationState && location
-          ? appendLocationState(getV2AdminPath(app, route.schemaUid), location)
-          : getV2AdminPath(app, route.schemaUid),
+      runtimePath: getV2AdminPath(app, route.schemaUid),
       navigationMode: 'spa' as const,
       isLegacy: false,
+      reason: 'ok' as const,
     };
   }
 
-  const v2RuntimePath = getV2AdminPath(app, route.schemaUid);
-  const legacyPath = convertV2AdminPathToLegacy(app, v2RuntimePath);
-
-  if (!legacyPath) {
-    logInvalidTarget(log, 'Failed to resolve legacy runtimePath.', route);
-    return EMPTY_TARGET;
-  }
-
-  if (preserveLocationState && location) {
-    if (isSameOrDescendantPath(location.pathname, v2RuntimePath)) {
-      const correctedCurrentPath = convertV2AdminPathToLegacy(app, location);
-      if (correctedCurrentPath) {
-        return {
-          runtimePath: correctedCurrentPath,
-          navigationMode: 'document' as const,
-          isLegacy: true,
-        };
-      }
-    }
-
+  if (isV2AdminRuntime(app)) {
     return {
-      runtimePath: appendLocationState(legacyPath, location),
-      navigationMode: 'document' as const,
-      isLegacy: true,
+      ...EMPTY_TARGET,
+      reason: 'unsupportedV2Runtime',
     };
   }
 
   return {
-    runtimePath: legacyPath,
-    navigationMode: 'document' as const,
-    isLegacy: true,
+    runtimePath:
+      preserveLocationState && location
+        ? appendLocationState(getV2AdminPath(app, route.schemaUid), location)
+        : getV2AdminPath(app, route.schemaUid),
+    navigationMode: 'spa' as const,
+    isLegacy: false,
+    reason: 'ok' as const,
   };
 }
 
@@ -242,9 +258,14 @@ export function resolveAdminRouteRuntimeTarget(
   }
 
   if (route.type === NocoBaseDesktopRouteType.group) {
-    const firstAccessibleRoute = findFirstAccessiblePageRoute(route.children);
+    const firstAccessibleRoute = isV2AdminRuntime(options.app)
+      ? findFirstV2LandingRoute(route.children)
+      : findFirstAccessiblePageRoute(route.children);
     if (!firstAccessibleRoute) {
-      return EMPTY_TARGET;
+      return {
+        ...EMPTY_TARGET,
+        reason: 'emptyGroup',
+      };
     }
     return resolveAdminRouteRuntimeTarget({
       ...options,

package/src/flow/components/AdminLayout.tsx

@@ -14,7 +14,7 @@ import { useApp } from '../../hooks/useApp';
 import { useLocation, useNavigate, useParams } from 'react-router-dom';
 import { NocoBaseDesktopRouteType } from '../../flow-compat';
 import {
-  findFirstAccessiblePageRoute,
+  findFirstV2LandingRoute,
   resolveAdminRouteRuntimeTarget,
   toRouterNavigationPath,
 } from '../admin-shell/admin-layout/resolveAdminRouteRuntimeTarget';
@@ -92,7 +92,7 @@ const AdminLayoutEntryGuard: FC<{ children: React.ReactNode }> = ({ children })
         return;
       }
 
-      const firstAccessibleRoute = findFirstAccessiblePageRoute(routeRepository?.listAccessible?.() || []);
+      const firstAccessibleRoute = findFirstV2LandingRoute(routeRepository?.listAccessible?.() || []);
       if (!firstAccessibleRoute) {
         if (active) {
           setReady(true);

package/src/flow/components/FieldAssignRulesEditor.tsx

@@ -35,6 +35,7 @@ type CollectionFieldLike = {
   title?: unknown;
   type?: unknown;
   interface?: unknown;
+  uiSchema?: unknown;
   targetKey?: unknown;
   targetCollectionTitleFieldName?: unknown;
   targetCollection?: any;
@@ -194,6 +195,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
           title,
           type: String(f.type || 'string'),
           interface: fieldInterface,
+          uiSchema: (f as any).uiSchema,
           paths: [...basePaths, name],
         };
 

package/src/flow/components/FlowRoute.tsx

@@ -15,10 +15,12 @@ import { useParams } from 'react-router-dom';
 import { useApp } from '../../hooks/useApp';
 import { NocoBaseDesktopRouteType } from '../../flow-compat';
 import { resolveAdminRouteRuntimeTarget } from '../admin-shell/admin-layout/resolveAdminRouteRuntimeTarget';
+import { AppNotFound } from '../../components';
 
 type FlowRouteGuardState = {
   pending: boolean;
   allowBridge: boolean;
+  notFound: boolean;
 };
 
 const BridgeFlowRoute = ({ pageUid }: { pageUid: string }) => {
@@ -91,6 +93,7 @@ const FlowRoute = () => {
   const [guardState, setGuardState] = useState<FlowRouteGuardState>({
     pending: true,
     allowBridge: false,
+    notFound: false,
   });
   const replaceTriggeredRef = useRef(false);
   const requestIdRef = useRef(0);
@@ -104,14 +107,14 @@ const FlowRoute = () => {
     const requestId = ++requestIdRef.current;
 
     const run = async () => {
-      setGuardState({ pending: true, allowBridge: false });
+      setGuardState({ pending: true, allowBridge: false, notFound: false });
 
       if (!routeRepository?.isAccessibleLoaded?.()) {
         try {
           await routeRepository?.ensureAccessibleLoaded?.();
         } catch (_error) {
           if (active && requestId === requestIdRef.current) {
-            setGuardState({ pending: false, allowBridge: true });
+            setGuardState({ pending: false, allowBridge: true, notFound: false });
           }
           return;
         }
@@ -139,10 +142,17 @@ const FlowRoute = () => {
           window.location.replace(target.runtimePath);
           return;
         }
+
+        if (target.reason === 'unsupportedV2Runtime') {
+          if (active && requestId === requestIdRef.current) {
+            setGuardState({ pending: false, allowBridge: false, notFound: true });
+          }
+          return;
+        }
       }
 
       if (active && requestId === requestIdRef.current) {
-        setGuardState({ pending: false, allowBridge: true });
+        setGuardState({ pending: false, allowBridge: true, notFound: false });
       }
     };
 
@@ -159,11 +169,14 @@ const FlowRoute = () => {
     }
 
     if (!guardState.allowBridge) {
+      if (guardState.notFound) {
+        return <AppNotFound />;
+      }
       return null;
     }
 
     return <BridgeFlowRoute pageUid={pageUid} />;
-  }, [guardState.allowBridge, guardState.pending, pageUid]);
+  }, [guardState.allowBridge, guardState.notFound, guardState.pending, pageUid]);
 
   return content;
 };

package/src/flow/components/__tests__/FieldAssignRulesEditor.test.tsx

@@ -15,7 +15,7 @@ import type { MetaTreeNode } from '@nocobase/flow-engine';
 import { FieldAssignRulesEditor, type FieldAssignRuleItem } from '../FieldAssignRulesEditor';
 import { mergeItemMetaTreeForAssignValue } from '../FieldAssignValueInput';
 
-const { mockFieldAssignValueInput } = vi.hoisted(() => ({
+const { mockFieldAssignValueInput, mockConditionBuilder } = vi.hoisted(() => ({
   mockFieldAssignValueInput: vi.fn((props: any) => (
     <div
       data-testid="mock-value-input"
@@ -25,6 +25,9 @@ const { mockFieldAssignValueInput } = vi.hoisted(() => ({
       data-date-constant={props?.enableDateVariableAsConstant ? 'yes' : 'no'}
     />
   )),
+  mockConditionBuilder: vi.fn((props: any) => (
+    <div data-testid="mock-condition-builder" data-extra={props?.extraMetaTree ? 'yes' : 'no'} />
+  )),
 }));
 
 vi.mock('../FieldAssignValueInput', async () => {
@@ -39,9 +42,7 @@ vi.mock('../ConditionBuilder', async () => {
   const actual = await vi.importActual<typeof import('../ConditionBuilder')>('../ConditionBuilder');
   return {
     ...actual,
-    ConditionBuilder: (props: any) => (
-      <div data-testid="mock-condition-builder" data-extra={props?.extraMetaTree ? 'yes' : 'no'} />
-    ),
+    ConditionBuilder: mockConditionBuilder,
   };
 });
 
@@ -55,6 +56,7 @@ describe('FieldAssignRulesEditor', () => {
 
   beforeEach(() => {
     mockFieldAssignValueInput.mockClear();
+    mockConditionBuilder.mockClear();
   });
 
   const createAssociationFixture = () => {
@@ -574,6 +576,81 @@ describe('FieldAssignRulesEditor', () => {
     expect(getByTestId('mock-condition-builder').getAttribute('data-extra')).toBe('yes');
   });
 
+  it('preserves uiSchema enum for current item attributes in condition extra tree', async () => {
+    const aaaField: any = {
+      name: 'AAA',
+      title: 'AAA',
+      type: 'array',
+      interface: 'multipleSelect',
+      isAssociationField: () => false,
+      uiSchema: {
+        enum: [
+          { label: 'Test1', value: 'Test1' },
+          { label: 'Test2', value: 'Test2' },
+        ],
+      },
+    };
+    const roleNameField: any = {
+      name: 'name',
+      title: 'Role name',
+      type: 'string',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const rolesCollection = {
+      getField: (name: string) => (name === 'AAA' ? aaaField : name === 'name' ? roleNameField : null),
+      getFields: () => [roleNameField, aaaField],
+    };
+    const rolesField: any = {
+      name: 'roles',
+      title: 'Roles',
+      type: 'belongsToMany',
+      interface: 'm2m',
+      isAssociationField: () => true,
+      targetCollection: rolesCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'roles' ? rolesField : null),
+      getFields: () => [rolesField],
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-roles-name',
+        enable: true,
+        targetPath: 'roles.name',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor t={t} fieldOptions={[]} rootCollection={rootCollection} value={value} showCondition />,
+      ),
+    );
+
+    const conditionProps = mockConditionBuilder.mock.calls[mockConditionBuilder.mock.calls.length - 1]?.[0];
+    const extraMetaTree = conditionProps?.extraMetaTree as MetaTreeNode[] | undefined;
+    expect(Array.isArray(extraMetaTree)).toBe(true);
+
+    const itemNode = extraMetaTree?.find((node) => node.name === 'item') as MetaTreeNode | undefined;
+    expect(itemNode).toBeTruthy();
+
+    const itemChildren = (Array.isArray(itemNode?.children) ? itemNode.children : []) as MetaTreeNode[];
+    const attributesNode = itemChildren.find((node) => node.name === 'value') as MetaTreeNode | undefined;
+    expect(attributesNode).toBeTruthy();
+
+    const attributeChildren =
+      typeof attributesNode?.children === 'function' ? await attributesNode.children() : attributesNode?.children ?? [];
+    const aaaNode = (attributeChildren as MetaTreeNode[]).find((node) => node.name === 'AAA') as any;
+
+    expect(aaaNode?.interface).toBe('multipleSelect');
+    expect(aaaNode?.uiSchema?.enum).toEqual([
+      { label: 'Test1', value: 'Test1' },
+      { label: 'Test2', value: 'Test2' },
+    ]);
+  });
+
   it('renders empty state when no items', () => {
     const { container } = render(
       wrap(<FieldAssignRulesEditor t={t} fieldOptions={[]} value={[]} showCondition={false} />),

package/src/flow/components/filter/LinkageFilterItem.tsx

@@ -22,7 +22,12 @@ import {
   observer,
 } from '@nocobase/flow-engine';
 import { NumberPicker } from '@formily/antd-v5';
-import { enumToOptions, translateOptions, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
+import {
+  enumToOptions,
+  normalizeSelectRenderValue,
+  translateOptions,
+  UiSchemaEnumItem,
+} from '../../internal/utils/enumOptionsUtils';
 import { mergeItemMetaTreeForAssignValue } from '../FieldAssignValueInput';
 import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
 
@@ -82,7 +87,9 @@ function createStaticInputRenderer(
       } else if (optionsFromEnum) {
         finalProps = { ...finalProps, options: optionsFromEnum };
       }
-      return <Select {...finalProps} {...rest} value={value} onChange={onChange} />;
+      return (
+        <Select {...finalProps} {...rest} value={normalizeSelectRenderValue(value, finalProps)} onChange={onChange} />
+      );
     }
     if (xComponent === 'DateFilterDynamicComponent')
       return <DateFilterDynamicComponentLazy {...commonProps} {...rest} value={value} onChange={onChange} />;

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -25,7 +25,7 @@ import {
 } from '@nocobase/flow-engine';
 import _ from 'lodash';
 import { NumberPicker } from '@formily/antd-v5';
-import { enumToOptions, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
+import { enumToOptions, normalizeSelectRenderValue, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
 import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
 
 const { DateFilterDynamicComponent: DateFilterDynamicComponentLazy } = lazy(
@@ -155,11 +155,7 @@ function createStaticInputRenderer(
           options={selectOptions}
           {...commonProps}
           {...rest}
-          value={
-            Array.isArray(value) || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
-              ? (value as unknown)
-              : undefined
-          }
+          value={normalizeSelectRenderValue(value, commonProps) as any}
           onChange={(v) => onChange?.(v as unknown as VariableFilterItemValue['value'])}
         />
       );

package/src/flow/components/filter/__tests__/LinkageFilterItem.test.tsx

@@ -67,6 +67,9 @@ function createModel() {
   return { model, app };
 }
 
+const getRenderedSelectTexts = (container: HTMLElement) =>
+  Array.from(container.querySelectorAll('.ant-select-selection-item')).map((node) => (node.textContent || '').trim());
+
 describe('LinkageFilterItem', () => {
   beforeEach(() => {
     document.body.innerHTML = '';
@@ -201,6 +204,74 @@ describe('LinkageFilterItem', () => {
     });
   });
 
+  it('does not render an empty selected option for constant single select', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const { model } = createModel();
+
+    (globalThis as any).__TEST_META__ = {
+      interface: 'select',
+      uiSchema: {
+        'x-component': 'Select',
+        enum: [{ label: 'Published', value: 'published' }],
+        'x-filter-operators': [
+          {
+            value: '$eq',
+            label: 'is',
+            selected: true,
+            schema: { 'x-component': 'Select' },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    const view = render(<LinkageFilterItem value={value} model={model} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+    });
+
+    expect(getRenderedSelectTexts(view.container).filter((text) => text === '')).toHaveLength(0);
+  });
+
+  it('does not render an empty selected tag for constant multi select', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const { model } = createModel();
+
+    (globalThis as any).__TEST_META__ = {
+      interface: 'select',
+      uiSchema: {
+        'x-component': 'Select',
+        enum: [{ label: 'Published', value: 'published' }],
+        'x-filter-operators': [
+          {
+            value: '$in',
+            label: 'is any of',
+            selected: true,
+            schema: { 'x-component': 'Select', 'x-component-props': { mode: 'tags' } },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    const view = render(<LinkageFilterItem value={value} model={model} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$in');
+    });
+
+    expect(getRenderedSelectTexts(view.container).filter((text) => text === '')).toHaveLength(0);
+  });
+
   it('passes enum options to single select multi-value operators', async () => {
     const value = observable({ path: '', operator: '', value: ['draft'] }) as any;
     const { model, app } = createModel();

package/src/flow/components/filter/__tests__/VariableFilterItem.test.tsx

@@ -47,6 +47,9 @@ vi.mock('@nocobase/flow-engine', async () => {
   return { ...actual, VariableInput: MockVariableInput };
 });
 
+const getRenderedSelectTexts = (root: ParentNode = document.body) =>
+  Array.from(root.querySelectorAll('.ant-select-selection-item')).map((node) => (node.textContent || '').trim());
+
 function CreateModel() {
   const engine = new FlowEngine();
   const model = new FlowModel({ uid: 'm-variable-filter', flowEngine: engine });
@@ -262,6 +265,51 @@ describe('VariableFilterItem', () => {
     delete (globalThis as any).__TEST_META__;
   });
 
+  it('does not render an empty selected option for right constant select', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const model = CreateModel();
+
+    const prevMeta = (globalThis as any).__TEST_META__;
+    const prevPath = (globalThis as any).__TEST_PATH__;
+    (globalThis as any).__TEST_PATH__ = 'status';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'select',
+      uiSchema: {
+        'x-component': 'Select',
+        enum: [{ label: 'Draft', value: 'draft' }],
+        'x-filter-operators': [
+          {
+            value: '$eq',
+            label: 'Equals',
+            selected: true,
+            schema: { 'x-component': 'Select' },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable />);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+    });
+
+    const rightVariableInputProps = (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    const Renderer = rightVariableInputProps?.converters?.renderInputComponent?.({ paths: ['constant'] });
+    expect(Renderer).toBeTruthy();
+
+    const rendered = render(<Renderer value="" onChange={vi.fn()} />);
+    expect(getRenderedSelectTexts(rendered.container).filter((text) => text === '')).toHaveLength(0);
+
+    (globalThis as any).__TEST_META__ = prevMeta;
+    (globalThis as any).__TEST_PATH__ = prevPath;
+  });
+
   it('renders right VariableInput when rightAsVariable=true and hides it for noValue operator', async () => {
     const value = observable({ path: '', operator: '', value: '' }) as any;
     const model = CreateModel();

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

@@ -8,7 +8,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { enumToOptions, translateOptions } from '../enumOptionsUtils';
+import { enumToOptions, getSelectedEnumLabels, translateOptions } from '../enumOptionsUtils';
 
 // 一个极简的 t：
 // - 直接返回传入 key；
@@ -55,4 +55,13 @@ describe('enumOptions utils', () => {
       { label: '否', value: false },
     ]);
   });
+
+  it('getSelectedEnumLabels: keeps label for selected value missing from limited options', () => {
+    const labels = getSelectedEnumLabels('published', [
+      { label: 'Draft', value: 'draft' },
+      { label: 'Published', value: 'published' },
+    ]);
+
+    expect(labels).toEqual([{ label: 'Published', value: 'published' }]);
+  });
 });