@nocobase/client-v2 2.1.17 → 2.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.17",
+  "version": "2.1.19",
   "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.1.17",
-    "@nocobase/flow-engine": "2.1.17",
-    "@nocobase/sdk": "2.1.17",
-    "@nocobase/shared": "2.1.17",
-    "@nocobase/utils": "2.1.17",
+    "@nocobase/evaluators": "2.1.19",
+    "@nocobase/flow-engine": "2.1.19",
+    "@nocobase/sdk": "2.1.19",
+    "@nocobase/shared": "2.1.19",
+    "@nocobase/utils": "2.1.19",
     "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": "9f8515d8a236f6584ce8a52e6b86082173a02bf4"
+  "gitHead": "c316683666cfb478cb355b971c8f067a4f925fcb"
 }

package/src/flow/FlowPage.tsx

@@ -14,7 +14,7 @@ import {
   useFlowModelById,
   useFlowViewContext,
 } from '@nocobase/flow-engine';
-import type { FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
+import type { FlowEngineContext, FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
 import { useRequest } from 'ahooks';
 import React from 'react';
 import FlowRoute from './components/FlowRoute';
@@ -57,10 +57,36 @@ type FlowPageProps = {
   showFlowSettings?: FlowModelRendererProps['showFlowSettings'];
 };
 
+type FlowPageViewContext = FlowEngineContext & {
+  view?: {
+    inputArgs?: {
+      isMobileLayout?: unknown;
+    };
+  };
+};
+
+const bindViewLayoutState = (model: FlowModel, ctx?: FlowPageViewContext | null) => {
+  const hasViewMobileLayout = typeof ctx?.view?.inputArgs?.isMobileLayout === 'boolean';
+  const hasContextMobileLayout = typeof ctx?.isMobileLayout === 'boolean';
+  if (!hasViewMobileLayout && !hasContextMobileLayout) {
+    return;
+  }
+
+  model.context.defineProperty('isMobileLayout', {
+    get: () => {
+      if (typeof ctx?.isMobileLayout === 'boolean') {
+        return ctx.isMobileLayout;
+      }
+      return !!ctx?.view?.inputArgs?.isMobileLayout;
+    },
+    cache: false,
+  });
+};
+
 export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknown>) => {
   const { pageModelClass = 'ChildPageModel', parentId, onModelLoaded, defaultTabTitle, ...rest } = props;
   const flowEngine = useFlowEngine();
-  const ctx = useFlowViewContext();
+  const ctx = useFlowViewContext<FlowPageViewContext>();
   const { loading, data, error } = useRequest(
     async () => {
       const ModelClass = await flowEngine.getModelClassAsync(pageModelClass);
@@ -105,6 +131,7 @@ export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknow
       const data = await flowEngine.loadOrCreateModel(options, { skipSave: !flowEngine.context.flowSettingsEnabled });
       if (data?.uid && onModelLoaded) {
         data.context.addDelegate(ctx);
+        bindViewLayoutState(data, ctx);
         data.removeParentDelegate();
         onModelLoaded(data.uid, data);
       }

package/src/flow/__tests__/FlowPage.test.tsx

@@ -7,44 +7,105 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { render } from '@testing-library/react';
+import { render, waitFor } from '@testing-library/react';
 import React from 'react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { FlowPage } from '../FlowPage';
 
-const mocks = vi.hoisted(() => ({
-  rendererProps: undefined as any,
-  model: {
+type TestContextProperty = {
+  value?: unknown;
+  get?: () => unknown;
+};
+
+type TestModelContext = {
+  isMobileLayout: boolean;
+  themeToken: {
+    marginBlock: number;
+  };
+  addDelegate: ReturnType<typeof vi.fn>;
+  defineProperty: ReturnType<typeof vi.fn>;
+};
+
+type TestPageModel = {
+  uid: string;
+  props: {
+    showFlowSettings: boolean;
+  };
+  context: TestModelContext;
+  removeParentDelegate: ReturnType<typeof vi.fn>;
+};
+
+type RendererProps = {
+  model?: TestPageModel;
+  showFlowSettings?: boolean;
+} & Record<string, unknown>;
+
+const defineContextProperty = (context: TestModelContext, key: string, property: TestContextProperty) => {
+  Object.defineProperty(context, key, {
+    configurable: true,
+    enumerable: true,
+    get: property.get || (() => property.value),
+  });
+};
+
+const createPageModel = (): TestPageModel => {
+  const context = {
+    isMobileLayout: false,
+    themeToken: {
+      marginBlock: 16,
+    },
+    addDelegate: vi.fn(),
+    defineProperty: vi.fn((key: string, property: TestContextProperty) => {
+      defineContextProperty(context, key, property);
+    }),
+  };
+
+  return {
     uid: 'public-form-page',
     props: {
       showFlowSettings: false,
     },
-    context: {
-      isMobileLayout: false,
-      themeToken: {
-        marginBlock: 16,
-      },
-    },
-  },
+    context,
+    removeParentDelegate: vi.fn(),
+  };
+};
+
+const mocks = vi.hoisted(() => ({
+  rendererMobileStates: [] as boolean[],
+  rendererProps: undefined as RendererProps | undefined,
+  model: undefined as TestPageModel | undefined,
+  viewInputMobileLayout: true as boolean | undefined,
+  contextMobileLayout: undefined as boolean | undefined,
 }));
 
 vi.mock('@nocobase/flow-engine', async () => {
-  const actual = await vi.importActual<any>('@nocobase/flow-engine');
+  const actual = await vi.importActual<typeof import('@nocobase/flow-engine')>('@nocobase/flow-engine');
   const ReactModule = await import('react');
+  class TestPageModelClass {}
 
   return {
     ...actual,
-    FlowModelRenderer: vi.fn((props: any) => {
+    FlowModelRenderer: vi.fn((props: RendererProps) => {
       mocks.rendererProps = props;
+      if (typeof props.model?.context.isMobileLayout === 'boolean') {
+        mocks.rendererMobileStates.push(props.model.context.isMobileLayout);
+      }
       return ReactModule.createElement('div', { 'data-testid': 'flow-model-renderer' });
     }),
     useFlowEngine: vi.fn(() => ({
-      getModelClassAsync: vi.fn(),
-      loadOrCreateModel: vi.fn(),
+      getModelClassAsync: vi.fn(async () => TestPageModelClass),
+      loadOrCreateModel: vi.fn(async () => mocks.model),
       context: {},
+      translate: vi.fn((value: string) => value),
     })),
     useFlowModelById: vi.fn(() => mocks.model),
     useFlowViewContext: vi.fn(() => ({
+      view: {
+        inputArgs: {
+          ...(typeof mocks.viewInputMobileLayout === 'boolean' ? { isMobileLayout: mocks.viewInputMobileLayout } : {}),
+        },
+      },
+      ...(typeof mocks.contextMobileLayout === 'boolean' ? { isMobileLayout: mocks.contextMobileLayout } : {}),
       themeToken: {
         marginBlock: 16,
       },
@@ -53,27 +114,93 @@ vi.mock('@nocobase/flow-engine', async () => {
 });
 
 vi.mock('ahooks', async () => {
-  const actual = await vi.importActual<any>('ahooks');
+  const actual = await vi.importActual<typeof import('ahooks')>('ahooks');
+  const ReactModule = await import('react');
   return {
     ...actual,
-    useRequest: vi.fn(() => ({
-      loading: false,
-      data: {
-        uid: 'public-form-page',
-      },
-      error: null,
-    })),
+    useRequest: vi.fn((service: () => Promise<unknown>) => {
+      const serviceRef = ReactModule.useRef(service);
+      const [state, setState] = ReactModule.useState<{
+        loading: boolean;
+        data?: unknown;
+        error?: unknown;
+      }>({
+        loading: true,
+      });
+
+      ReactModule.useEffect(() => {
+        let active = true;
+        serviceRef
+          .current()
+          .then((data) => {
+            if (active) {
+              setState({ loading: false, data, error: null });
+            }
+          })
+          .catch((error) => {
+            if (active) {
+              setState({ loading: false, data: undefined, error });
+            }
+          });
+
+        return () => {
+          active = false;
+        };
+      }, []);
+
+      return state;
+    }),
   };
 });
 
 describe('FlowPage', () => {
   afterEach(() => {
+    mocks.rendererMobileStates = [];
     mocks.rendererProps = undefined;
+    mocks.model = undefined;
+    mocks.viewInputMobileLayout = true;
+    mocks.contextMobileLayout = undefined;
   });
 
-  it('uses showFlowSettings from page model props', () => {
+  it('uses showFlowSettings from page model props', async () => {
+    mocks.model = createPageModel();
     render(<FlowPage />);
 
-    expect(mocks.rendererProps?.showFlowSettings).toBe(false);
+    await waitFor(() => {
+      expect((mocks.rendererProps as { showFlowSettings?: boolean } | undefined)?.showFlowSettings).toBe(false);
+    });
+  });
+
+  it('exposes mobile layout state from route-managed view inputArgs before first render', async () => {
+    mocks.model = createPageModel();
+    render(<FlowPage onModelLoaded={vi.fn()} />);
+
+    await waitFor(() => {
+      expect(mocks.rendererMobileStates.length).toBeGreaterThan(0);
+    });
+    expect(mocks.rendererMobileStates[0]).toBe(true);
   });
+
+  it.each([
+    { viewInputMobileLayout: true, contextMobileLayout: false, expected: false },
+    { viewInputMobileLayout: false, contextMobileLayout: true, expected: true },
+    { viewInputMobileLayout: undefined, contextMobileLayout: true, expected: true },
+    { viewInputMobileLayout: undefined, contextMobileLayout: false, expected: false },
+    { viewInputMobileLayout: true, contextMobileLayout: undefined, expected: true },
+    { viewInputMobileLayout: false, contextMobileLayout: undefined, expected: false },
+  ])(
+    'resolves mobile layout state from view input args and layout context %#',
+    async ({ viewInputMobileLayout, contextMobileLayout, expected }) => {
+      mocks.viewInputMobileLayout = viewInputMobileLayout;
+      mocks.contextMobileLayout = contextMobileLayout;
+      mocks.model = createPageModel();
+
+      render(<FlowPage onModelLoaded={vi.fn()} />);
+
+      await waitFor(() => {
+        expect(mocks.rendererMobileStates.length).toBeGreaterThan(0);
+      });
+      expect(mocks.rendererMobileStates[0]).toBe(expected);
+    },
+  );
 });

package/src/flow/actions/__tests__/dataScopeFilter.test.ts

@@ -64,6 +64,40 @@ describe('normalizeDataScopeFilter', () => {
     });
   });
 
+  it('prunes a missing URL search param variable', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toBeUndefined();
+  });
+
+  it('only prunes the missing URL search param condition from mixed filters', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        { path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' },
+      ],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        { path: 'departmentId', operator: '$eq', value: undefined },
+      ],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ status: { $eq: 'active' } }],
+    });
+  });
+
   it('still prunes empty constant values', () => {
     const filter = {
       logic: '$and',
@@ -139,6 +173,34 @@ describe('normalizeDataScopeFilter', () => {
     expect(resource.removeFilterGroup).not.toHaveBeenCalled();
   });
 
+  it('dataScope handler removes data scope when a URL search param is missing', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = {
+      model: {
+        uid: 'field-1',
+        resource,
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        items: [{ ...template.items[0], value: undefined }],
+      })),
+    };
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' }],
+      },
+    };
+
+    await (dataScope as any).handler(ctx, params);
+
+    expect(resource.removeFilterGroup).toHaveBeenCalledWith('field-1');
+    expect(resource.addFilterGroup).not.toHaveBeenCalled();
+  });
+
   it('dataScope handler preserves current role as server-side variable', async () => {
     const engine = new FlowEngine();
     const resource = {

package/src/flow/actions/__tests__/openView.defineProps.route.test.tsx

@@ -12,6 +12,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { RUNJS_OPEN_VIEW_ROUTE_STATE } from '@nocobase/flow-engine';
 import { openView } from '../openView';
 import { FlowPage } from '../../FlowPage';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../../routeTransientInputArgs';
 
 describe('openView action - route mode defineProperties/defineMethods', () => {
   const createRouteManagedCtx = () => {
@@ -172,6 +173,56 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
     expect(defineMethodCalls).toContain('pong');
   });
 
+  it('passes formData through route navigation state', async () => {
+    const navigateTo = vi.fn();
+    const ctx: any = {
+      inputArgs: {
+        formData: {
+          start: '2026-06-24 08:00:00',
+          end: '2026-06-24 09:00:00',
+        },
+      },
+      engine: {
+        context: {},
+      },
+      model: {
+        uid: 'popup-uid',
+        context: {
+          defineProperty: vi.fn(),
+        },
+      },
+      view: {
+        navigation: {
+          navigateTo,
+        },
+      },
+      isNavigationEnabled: true,
+    };
+
+    await openView.handler(ctx, { navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      {
+        state: {
+          [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+            'popup-uid': {
+              formData: {
+                start: '2026-06-24 08:00:00',
+                end: '2026-06-24 09:00:00',
+              },
+            },
+          },
+        },
+      },
+    );
+  });
+
   it('adds route state to first-stage navigation only for RunJS ctx.openView calls', async () => {
     const { ctx, navigateTo } = createFirstStageCtx({
       mode: 'dialog',
@@ -181,13 +232,16 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-      openViewRouteState: { mode: 'dialog', size: 'large' },
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'dialog', size: 'large' },
+      },
+      undefined,
+    );
   });
 
   it('normalizes first-stage RunJS route state mode on mobile layout', async () => {
@@ -200,13 +254,16 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-      openViewRouteState: { mode: 'embed', size: 'large' },
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'embed', size: 'large' },
+      },
+      undefined,
+    );
   });
 
   it('uses route replay mode and size before persisted openView defaults', async () => {
@@ -246,11 +303,14 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      undefined,
+    );
   });
 });

package/src/flow/actions/dataScopeFilter.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
+import { extractPropertyPath, isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
 import { transformFilter } from '@nocobase/utils/client';
 import _ from 'lodash';
 
@@ -45,6 +45,14 @@ function restorePreservedNull(value: any): any {
   return value;
 }
 
+function isUrlSearchParamsExpression(value: any) {
+  if (!isVariableExpression(value)) {
+    return false;
+  }
+
+  return extractPropertyPath(value)?.[0] === 'urlSearchParams';
+}
+
 function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
   if (!rawNode || !resolvedNode || typeof rawNode !== 'object' || typeof resolvedNode !== 'object') {
     return;
@@ -57,6 +65,7 @@ function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
     }
     if (
       isVariableExpression(rawNode.value) &&
+      !isUrlSearchParamsExpression(rawNode.value) &&
       (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')
     ) {
       resolvedNode.value = PRESERVE_NULL;

package/src/flow/actions/openView.tsx

@@ -20,6 +20,7 @@ import React from 'react';
 import { FlowPage } from '../FlowPage';
 import { PageModel, RootPageModel } from '../models';
 import _ from 'lodash';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../routeTransientInputArgs';
 
 type DirtyAwareFlowModel = FlowModel & {
   getUserModifiedFields?: () => Set<string> | undefined;
@@ -31,6 +32,15 @@ type BeforeCloseDirtyState = {
   formModelUids: string[];
 };
 
+const pickRouteTransientInputArgs = (inputArgs: Record<string, unknown>) => {
+  return _.pickBy(
+    {
+      formData: inputArgs.formData,
+    },
+    (value) => typeof value !== 'undefined',
+  );
+};
+
 function collectDirtyFormModelUids(model?: FlowModel | null, ignoredDirtyFormModelUids: string[] = []): string[] {
   if (!model) {
     return [];
@@ -363,7 +373,17 @@ export const openView = defineAction({
           tabUid: mergedTabUid,
           ...(effectiveRunJSOpenViewRouteState ? { openViewRouteState: effectiveRunJSOpenViewRouteState } : {}),
         };
-        ctx.view.navigation.navigateTo(nextView);
+        const transientInputArgs = pickRouteTransientInputArgs(inputArgs);
+        const navigationOptions = Object.keys(transientInputArgs).length
+          ? {
+              state: {
+                [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+                  [nextView.viewUid]: transientInputArgs,
+                },
+              },
+            }
+          : undefined;
+        ctx.view.navigation.navigateTo(nextView, navigationOptions);
         return;
       }
     }