@nocobase/client-v2 2.2.0-alpha.3 → 2.2.0-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.2.0-alpha.3",
+  "version": "2.2.0-alpha.4",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.2.0-alpha.3",
-    "@nocobase/flow-engine": "2.2.0-alpha.3",
-    "@nocobase/sdk": "2.2.0-alpha.3",
-    "@nocobase/shared": "2.2.0-alpha.3",
-    "@nocobase/utils": "2.2.0-alpha.3",
+    "@nocobase/evaluators": "2.2.0-alpha.4",
+    "@nocobase/flow-engine": "2.2.0-alpha.4",
+    "@nocobase/sdk": "2.2.0-alpha.4",
+    "@nocobase/shared": "2.2.0-alpha.4",
+    "@nocobase/utils": "2.2.0-alpha.4",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -46,5 +46,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "e3ec19361fd7981af9fe2a7f24ad335025cbefcd"
+  "gitHead": "81bf8733db4bccf08a6bc5e6d97f274bce349161"
 }

package/src/RouteRepository.ts

@@ -268,6 +268,16 @@ export class RouteRepository {
     return this.findRoute(this.listAccessible(), schemaUid);
   }
 
+  /**
+   * 通过路由 id 反查对应路由节点。
+   *
+   * @param routeId 桌面路由主键
+   * @returns 匹配到的路由节点
+   */
+  getRouteById(routeId: string | number): NocoBaseDesktopRoute | undefined {
+    return this.findRouteById(this.listAccessible(), routeId);
+  }
+
   protected getAPIClient(): APIClient {
     if (!this.ctx?.api) {
       throw new Error('[NocoBase] RouteRepository requires context.api.');
@@ -346,4 +356,19 @@ export class RouteRepository {
     }
     return undefined;
   }
+
+  private findRouteById(routes: NocoBaseDesktopRoute[], routeId: string | number): NocoBaseDesktopRoute | undefined {
+    for (const route of routes) {
+      if (route.id != null && String(route.id) === String(routeId)) {
+        return route;
+      }
+      if (route.children) {
+        const found = this.findRouteById(route.children, routeId);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return undefined;
+  }
 }

package/src/__tests__/RouteRepository.test.ts

@@ -140,6 +140,29 @@ describe('RouteRepository', () => {
     expect(repository.getRouteBySchemaUid('custom-page')).toBeUndefined();
   });
 
+  it('should find nested routes by id', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([
+      {
+        id: 1,
+        schemaUid: 'group-1',
+        children: [
+          {
+            id: 11,
+            schemaUid: 'page-1',
+          },
+        ],
+      },
+    ] as NocoBaseDesktopRoute[]);
+
+    expect(repository.getRouteById('11')).toMatchObject({
+      id: 11,
+      schemaUid: 'page-1',
+    });
+    expect(repository.getRouteById('missing')).toBeUndefined();
+  });
+
   it('should notify only subscribers for the changed layout cache', () => {
     const { repository } = createRouteRepository();
     const adminEvents: string[][] = [];

package/src/__tests__/authRedirect.test.ts

@@ -10,6 +10,7 @@
 import {
   buildV2SigninHref,
   getCurrentV2RedirectPath,
+  normalizeV2RedirectPath,
   redirectToV2Signin,
   resolveV2SigninRedirect,
 } from '../authRedirect';
@@ -133,6 +134,22 @@ describe('auth redirect helpers', () => {
   });
 
   describe('v2 sub-app context (router basename contains /apps/<id>/)', () => {
+    it('should normalize signin redirect fallback under the current sub-app basename', () => {
+      const app = {
+        getPublicPath: () => '/v/',
+        router: {
+          getBasename: () => '/v/apps/test-app/',
+        },
+      } as any;
+
+      expect(normalizeV2RedirectPath(app, '')).toBe('/v/apps/test-app/admin/');
+      expect(normalizeV2RedirectPath(app, '/admin/?tab=overview#panel')).toBe(
+        '/v/apps/test-app/admin/?tab=overview#panel',
+      );
+      expect(normalizeV2RedirectPath(app, '/v/apps/test-app/admin/')).toBe('/v/apps/test-app/admin/');
+      expect(normalizeV2RedirectPath(app, '/v/admin/')).toBe('/v/apps/test-app/admin/');
+    });
+
     it('should preserve sub-app segment when building current redirect path under simple public path', () => {
       const app = {
         getPublicPath: () => '/v2/',

package/src/__tests__/getRouteRuntimeVersion.test.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 { afterEach, describe, expect, it } from 'vitest';
+import { getRouteRuntimeVersion } from '../utils/getRouteRuntimeVersion';
+
+function replacePathname(pathname: string) {
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: {
+      ...window.location,
+      pathname,
+    },
+  });
+}
+
+describe('getRouteRuntimeVersion', () => {
+  afterEach(() => {
+    delete window.__nocobase_modern_client_prefix__;
+    delete window.__nocobase_public_path__;
+    replacePathname('/');
+  });
+
+  it('returns modern when the current pathname is inside the modern client prefix', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/nocobase/v/';
+    replacePathname('/nocobase/v/admin/settings/workflow');
+
+    expect(getRouteRuntimeVersion()).toBe('modern');
+  });
+
+  it('returns legacy when reused v2 components run under the v1 settings page', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/nocobase/';
+    replacePathname('/nocobase/admin/settings/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('legacy');
+  });
+
+  it('returns legacy when root public path is "/"', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/';
+    replacePathname('/admin/settings/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('legacy');
+  });
+
+  it('returns modern when root public path is "/v/"', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/v/';
+    replacePathname('/v/admin/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('modern');
+  });
+
+  it('falls back to pathname matching when public path is unavailable', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    replacePathname('/v/admin/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('modern');
+  });
+});

package/src/authRedirect.ts

@@ -204,6 +204,44 @@ function getDefaultV2AdminRedirectPath(app: AppLike) {
   return joinRootRelativePath(getV2EffectiveBasePath(app), '/admin');
 }
 
+function isSafeRootRelativePath(value?: string | null) {
+  return !!value && value.startsWith('/') && !value.startsWith('//') && !value.startsWith('/\\');
+}
+
+function preserveTrailingSlash(originalPathname: string, value: string) {
+  if (originalPathname !== '/' && originalPathname.endsWith('/') && !value.endsWith('/')) {
+    return `${value}/`;
+  }
+  return value;
+}
+
+export function normalizeV2RedirectPath(app: AppLike, target?: string | null, fallbackPath = '/admin/') {
+  // In a v2 sub-app, publicPath can be `/v/` while the active router
+  // basename is `/v/apps/a/`. Redirects must resolve under the basename.
+  const basePath = trimTrailingSlashes(getV2EffectiveBasePath(app)) || '/';
+  const fallbackTarget = isSafeRootRelativePath(fallbackPath) ? fallbackPath : '/admin/';
+  const rawTarget = isSafeRootRelativePath(target) ? target : fallbackTarget;
+  let { pathname, search, hash } = splitPathLike(rawTarget);
+  let normalizedPathname = normalizePathname(pathname);
+
+  // Already under the current v2 runtime, e.g. `/v/apps/a/admin/`.
+  if (basePath === '/' || normalizedPathname === basePath || normalizedPathname.startsWith(`${basePath}/`)) {
+    return `${preserveTrailingSlash(pathname, normalizedPathname)}${normalizeSearch(search)}${normalizeHash(hash)}`;
+  }
+
+  const publicPath = trimTrailingSlashes(getV2PublicPath(app)) || '/';
+  // Under v2 publicPath but outside the current basename, e.g. `/v/admin/`
+  // inside `/v/apps/a/`; use fallback so it lands on `/v/apps/a/admin/`.
+  if (publicPath !== '/' && (normalizedPathname === publicPath || normalizedPathname.startsWith(`${publicPath}/`))) {
+    ({ pathname, search, hash } = splitPathLike(fallbackTarget));
+    normalizedPathname = normalizePathname(pathname);
+  }
+
+  // Basename-relative target, e.g. `/admin/`, becomes `/v/apps/a/admin/`.
+  const joinedPathname = preserveTrailingSlash(pathname, joinRootRelativePath(basePath, normalizedPathname));
+  return `${joinedPathname}${normalizeSearch(search)}${normalizeHash(hash)}`;
+}
+
 /**
  * 将当前 v2 页面地址转换为根相对 redirect 路径。
  *

package/src/components/form/JsonTextArea.tsx

@@ -117,6 +117,10 @@ const JsonTextAreaComponent = React.forwardRef<TextAreaRef, JsonTextAreaProps>((
   return (
     <>
       <Input.TextArea
+        autoSize={{
+          minRows: 5,
+          maxRows: 10,
+        }}
         {...textAreaProps}
         ref={ref}
         value={text}

package/src/components/form/TypedVariableInput.tsx

@@ -52,7 +52,9 @@ export interface TypedVariableInputProps {
    * Allowed constant types. The `Constant` switcher entry always exposes a
    * typed submenu (matching v1 `Variable.Input`) so users can see what type
    * the constant is, even when only one type is permitted. Default: all four
-   * supported types.
+   * supported types. Passing `[]` switches the component into a variable-only
+   * mode: constants/null are hidden, the empty state becomes a readonly
+   * placeholder, and clearing a selected variable resets to `null`.
    */
   types?: TypedConstantSpec[];
   /**
@@ -89,6 +91,12 @@ export interface TypedVariableInputProps {
   defaultToFirstConstantTypeWhenUndefined?: boolean;
   /** Variable-token delimiters. Default `['{{', '}}']` — see `VariableInput`. */
   delimiters?: VariableDelimiters;
+  /**
+   * Hide variable choices from the switcher. In variable-only mode this hides
+   * the selector button entirely; in mixed constant/variable mode it keeps the
+   * null/constant choices but removes variable entries.
+   */
+  hideVariable?: boolean;
   disabled?: boolean;
   placeholder?: string;
   style?: React.CSSProperties;
@@ -400,6 +408,7 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
     nullable = true,
     defaultToFirstConstantTypeWhenUndefined = true,
     delimiters,
+    hideVariable = false,
     disabled,
     placeholder,
     style,
@@ -418,13 +427,14 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
   const formatVariablePath = useMemo(() => makeFormatVariablePath(delimiters), [delimiters]);
 
   const normalizedTypes = useMemo(() => normalizeTypes(types), [types]);
+  const variableOnly = normalizedTypes.length === 0;
   const defaultedValue = useMemo(() => {
-    if (!defaultToFirstConstantTypeWhenUndefined || value !== undefined) {
+    if (variableOnly || !defaultToFirstConstantTypeWhenUndefined || value !== undefined) {
       return undefined;
     }
     const firstType = normalizedTypes[0];
     return firstType ? defaultValueFor(firstType.type) : undefined;
-  }, [defaultToFirstConstantTypeWhenUndefined, normalizedTypes, value]);
+  }, [defaultToFirstConstantTypeWhenUndefined, normalizedTypes, value, variableOnly]);
   const effectiveValue = value === undefined && defaultedValue !== undefined ? defaultedValue : value;
   const detected = useMemo(() => detectMode(effectiveValue, parseVariablePath), [effectiveValue, parseVariablePath]);
 
@@ -481,13 +491,13 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
     // `updateFlag` is read so this recomputes (with fresh option references) after a lazy load mutates the meta tree.
     void updateFlag;
     const items: SwitcherOption[] = [];
-    if (nullable) {
+    if (!variableOnly && nullable) {
       items.push({ value: NULL_KEY, label: t('Null'), isLeaf: true });
     }
     // Always render Constant with a typed submenu — even when only one type is
     // allowed. Matches v1 `Variable.Input`, where clicking 常量 reveals 数字 /
     // 逻辑值 / etc. so the user can see what type the constant actually is.
-    if (normalizedTypes.length > 0) {
+    if (!variableOnly && normalizedTypes.length > 0) {
       items.push({
         value: CONST_KEY,
         label: t('Constant'),
@@ -498,9 +508,11 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
         })),
       });
     }
-    items.push(...buildContextSelectorItems(metaTree).map(fromContextItem));
+    if (!hideVariable) {
+      items.push(...buildContextSelectorItems(metaTree).map(fromContextItem));
+    }
     return items;
-  }, [nullable, normalizedTypes, metaTree, updateFlag, t]);
+  }, [hideVariable, metaTree, normalizedTypes, nullable, t, updateFlag, variableOnly]);
 
   const onSwitcherChange = useCallback<NonNullable<CascaderProps<SwitcherOption>['onChange']>>(
     (path, selectedOptions) => {
@@ -530,6 +542,10 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
   );
 
   const onClearVariable = useCallback(() => {
+    if (variableOnly) {
+      onChange?.(null);
+      return;
+    }
     const first = normalizedTypes[0];
     if (first) {
       onChange?.(defaultValueFor(first.type));
@@ -538,7 +554,7 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
     if (nullable) {
       onChange?.(null);
     }
-  }, [nullable, normalizedTypes, onChange]);
+  }, [nullable, normalizedTypes, onChange, variableOnly]);
 
   const constantTypeForRendering: TypedConstantType = useMemo(() => {
     const m = detected.mode;
@@ -553,6 +569,7 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
 
   const isVariable = detected.mode === 'variable';
   const isNull = detected.mode === 'null';
+  const showSwitcher = switcherOptions.length > 0 && !(hideVariable && isVariable);
 
   const variableLabels = useMemo(() => {
     // `updateFlag` is read so this recomputes after the preload effect below resolves a lazy level in the tree (same
@@ -565,11 +582,14 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
     if (isVariable && detected.variablePath?.length) {
       return detected.variablePath;
     }
+    if (variableOnly) {
+      return undefined;
+    }
     if (isNull) {
       return [NULL_KEY];
     }
     return [CONST_KEY, constantTypeForRendering];
-  }, [constantTypeForRendering, detected.variablePath, isNull, isVariable]);
+  }, [constantTypeForRendering, detected.variablePath, isNull, isVariable, variableOnly]);
 
   // Preload a saved variable's label path across lazy levels. `resolveVariableLabels` can only read already-loaded
   // `children`; when a saved reference points below a node whose children are still a lazy thunk (e.g. a relation field
@@ -678,8 +698,8 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
                 minHeight: token.controlHeight,
                 border: `1px solid ${token.colorBorder}`,
                 borderRadius: token.borderRadius,
-                borderTopRightRadius: 0,
-                borderBottomRightRadius: 0,
+                borderTopRightRadius: showSwitcher ? 0 : token.borderRadius,
+                borderBottomRightRadius: showSwitcher ? 0 : token.borderRadius,
                 background: disabled ? token.colorBgContainerDisabled : token.colorBgContainer,
                 overflow: 'hidden',
               }}
@@ -712,6 +732,8 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
                 />
               ) : null}
             </div>
+          ) : variableOnly ? (
+            <Input placeholder={placeholder} readOnly disabled={disabled} style={{ width: '100%' }} />
           ) : isNull ? (
             // v1 used the `placeholder` slot (not `value`) so the antd default placeholder colour applies — keeps the
             // field looking visibly empty/inactive rather than holding a real text value.
@@ -726,31 +748,33 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
             })
           )}
         </div>
-        <Cascader<SwitcherOption>
-          options={switcherOptions}
-          value={switcherValue}
-          onChange={onSwitcherChange}
-          loadData={loadData}
-          disabled={disabled}
-          changeOnSelect
-        >
-          <Button
-            aria-label="variable-switcher"
+        {showSwitcher ? (
+          <Cascader<SwitcherOption>
+            options={switcherOptions}
+            value={switcherValue}
+            onChange={onSwitcherChange}
+            loadData={loadData}
             disabled={disabled}
-            type={isVariable ? 'primary' : 'default'}
-            style={{
-              flexShrink: 0,
-              // `height: auto` (instead of antd's fixed control height) lets the button stretch to the value
-              // component's height under the compact row's default `align-items: stretch` — so it stays joined to a
-              // tall JSON textarea. Mirrors v1's `.ant-btn { height: auto }`.
-              height: 'auto',
-              fontStyle: 'italic',
-              fontFamily: '"New York", "Times New Roman", Times, serif',
-            }}
+            changeOnSelect
           >
-            x
-          </Button>
-        </Cascader>
+            <Button
+              aria-label="variable-switcher"
+              disabled={disabled}
+              type={isVariable ? 'primary' : 'default'}
+              style={{
+                flexShrink: 0,
+                // `height: auto` (instead of antd's fixed control height) lets the button stretch to the value
+                // component's height under the compact row's default `align-items: stretch` — so it stays joined to a
+                // tall JSON textarea. Mirrors v1's `.ant-btn { height: auto }`.
+                height: 'auto',
+                fontStyle: 'italic',
+                fontFamily: '"New York", "Times New Roman", Times, serif',
+              }}
+            >
+              x
+            </Button>
+          </Cascader>
+        ) : null}
       </Space.Compact>
       {jsonError ? (
         <div style={{ marginTop: token.marginXXS, color: token.colorError, fontSize: token.fontSizeSM }}>

package/src/components/form/__tests__/TypedVariableInput.test.tsx

@@ -201,6 +201,58 @@ describe('TypedVariableInput - variable rendering', () => {
     fireEvent.click(clear as HTMLButtonElement);
     expect(handleChange).toHaveBeenCalledWith(0);
   });
+
+  it('treats types=[] as variable-only mode with a readonly placeholder before selection', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value={undefined}
+        types={[]}
+        namespaces={['$env']}
+        placeholder="Select variable"
+        onChange={() => undefined}
+      />,
+    );
+
+    const input = await screen.findByPlaceholderText('Select variable');
+    expect(input).toBeInTheDocument();
+    expect(input).toHaveAttribute('readonly');
+    expect(screen.queryByRole('button', { name: 'variable-switcher' })).toBeInTheDocument();
+  });
+
+  it('clears a variable-only selection back to null', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    const { container } = renderWithCtx(
+      ctx,
+      <TypedVariableInput value="{{$env.SMTP_PORT}}" types={[]} namespaces={['$env']} onChange={handleChange} />,
+    );
+
+    const clear = container.querySelector('button.clear-button') as HTMLButtonElement | null;
+    expect(clear).not.toBeNull();
+    fireEvent.click(clear as HTMLButtonElement);
+    expect(handleChange).toHaveBeenCalledWith(null);
+  });
+
+  it('hides the variable switcher when hideVariable=true in variable-only mode', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={[]}
+        namespaces={['$env']}
+        hideVariable
+        onChange={() => undefined}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: 'variable-tag' })).toBeInTheDocument();
+    });
+    expect(screen.queryByRole('button', { name: 'variable-switcher' })).toBeNull();
+  });
 });
 
 describe('TypedVariableInput - object / JSON constant', () => {

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

@@ -21,6 +21,8 @@ export interface CollectionFilterProps {
   collection: Collection | undefined;
   /** Previously compiled filter param used to seed the editable filter group. */
   initialValue?: CompiledFilter;
+  /** Default compiled filter used both for initial empty state and Reset. */
+  defaultValue?: CompiledFilter;
   /** Called on Submit or Reset with the compiled NocoBase filter param (`undefined` when cleared). */
   onChange: (filter: CompiledFilter) => void;
   /** Translator. Defaults to identity. */
@@ -58,6 +60,7 @@ export const CollectionFilter: FC<CollectionFilterProps> = (props) => {
   const {
     collection,
     initialValue,
+    defaultValue,
     onChange,
     t = identity,
     filterableFieldNames,
@@ -75,6 +78,7 @@ export const CollectionFilter: FC<CollectionFilterProps> = (props) => {
   const filterAction = useFilterActionProps({
     collection,
     initialValue,
+    defaultValue,
     filterableFieldNames,
     nonfilterableFieldNames,
     noIgnore,

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

@@ -30,6 +30,8 @@ export interface CollectionFilterPanelProps {
   collection: Collection | undefined;
   /** Previously compiled filter param used to seed the editable filter group. */
   initialValue?: CompiledFilter;
+  /** Default compiled filter used both for initial empty state and Reset. */
+  defaultValue?: CompiledFilter;
   /** Called when the condition group structure changes or `reset()` is invoked. */
   onChange?: (filter: CompiledFilter) => void;
   /** Translator. Defaults to identity. */
@@ -51,6 +53,7 @@ export const CollectionFilterPanel = forwardRef<CollectionFilterPanelRef, Collec
   const {
     collection,
     initialValue,
+    defaultValue,
     onChange,
     t = identity,
     filterableFieldNames,
@@ -61,6 +64,7 @@ export const CollectionFilterPanel = forwardRef<CollectionFilterPanelRef, Collec
   const filterAction = useFilterActionProps({
     collection,
     initialValue,
+    defaultValue,
     filterableFieldNames,
     nonfilterableFieldNames,
     noIgnore,

package/src/components/form/filter/__tests__/useFilterActionProps.test.tsx

@@ -0,0 +1,95 @@
+/**
+ * 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 { FlowEngine, FlowEngineProvider, type Collection } from '@nocobase/flow-engine';
+import { renderHook } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { useFilterActionProps } from '../useFilterActionProps';
+
+vi.mock('../../../flow/components/filter/useFilterOptions', () => ({
+  useFilterOptions: () => [],
+}));
+
+vi.mock('../CollectionFilterItem', () => ({
+  createCollectionFilterItem: () => undefined,
+}));
+
+function makeCollection(): Collection {
+  return {
+    getFields: () => [{ name: 'title' }, { name: 'type' }],
+  } as unknown as Collection;
+}
+
+function makeWrapper() {
+  const engine = new FlowEngine();
+  const Wrapper: React.FC = ({ children }) => <FlowEngineProvider engine={engine}>{children}</FlowEngineProvider>;
+  return Wrapper;
+}
+
+describe('useFilterActionProps', () => {
+  it('seeds the editable group from defaultValue when initialValue is missing', () => {
+    const { result } = renderHook(
+      () =>
+        useFilterActionProps({
+          collection: makeCollection(),
+          defaultValue: { $and: [{ title: { $includes: '' } }, { type: { $eq: undefined } }] },
+          onApply: () => undefined,
+        }),
+      { wrapper: makeWrapper() },
+    );
+
+    expect(result.current.value).toMatchObject({
+      logic: '$and',
+      items: [
+        { path: 'title', operator: '$includes', value: '' },
+        { path: 'type', operator: '$eq', value: undefined },
+      ],
+    });
+  });
+
+  it('reset restores defaultValue and emits its compiled filter', () => {
+    const onApply = vi.fn();
+    const { result } = renderHook(
+      () =>
+        useFilterActionProps({
+          collection: makeCollection(),
+          defaultValue: { $and: [{ title: { $includes: '' } }, { type: { $eq: undefined } }] },
+          initialValue: { $and: [{ title: { $includes: 'abc' } }] },
+          onApply,
+        }),
+      { wrapper: makeWrapper() },
+    );
+
+    result.current.onReset();
+
+    expect(result.current.value).toMatchObject({
+      logic: '$and',
+      items: [
+        { path: 'title', operator: '$includes', value: '' },
+        { path: 'type', operator: '$eq', value: undefined },
+      ],
+    });
+    expect(onApply).toHaveBeenCalledWith(undefined, 'reset');
+  });
+
+  it('counts only effective compiled conditions, so empty default rows do not highlight the button', () => {
+    const { result } = renderHook(
+      () =>
+        useFilterActionProps({
+          collection: makeCollection(),
+          defaultValue: { $and: [{ title: { $includes: '' } }, { type: { $eq: undefined } }] },
+          onApply: () => undefined,
+        }),
+      { wrapper: makeWrapper() },
+    );
+
+    expect(result.current.conditionCount).toBe(0);
+  });
+});