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

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/dateTimeFormat.tsx

@@ -28,11 +28,11 @@ const isTableColumnFieldSubModel = (model) => {
 
 const syncTableColumnDateTimeFormatProps = (ctx, props) => {
   const model = ctx.model;
-  if (!isTableColumnFieldSubModel(model) || !model?.parent?.collectionField?.isAssociationField?.()) {
+  if (!isTableColumnFieldSubModel(model)) {
     return;
   }
 
-  model.parent.setProps(props);
+  model.parent?.setProps?.(props);
 };
 
 export const dateTimeFormat = defineAction({

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;
       }
     }

package/src/flow/admin-shell/BaseLayoutModel.tsx

@@ -20,6 +20,7 @@ import {
   type BaseLayoutRouteCoordinatorOptions,
   type RoutePageMeta,
 } from './BaseLayoutRouteCoordinator';
+import { NocoBaseDesktopRouteType } from '../../flow-compat';
 import type { LayoutDefinition } from '../../layout-manager/types';
 import { isLayoutContentRouteName } from '../../layout-manager/utils';
 
@@ -72,6 +73,7 @@ export interface LayoutRouteLike {
   id?: string;
   name?: string;
   pathname?: string;
+  state?: unknown;
   params?: Record<string, string | undefined>;
   layoutRouteName?: string;
   layoutBasePathname?: string;
@@ -111,6 +113,15 @@ const getDefaultBasePathnameFromRoutePath = (routePath?: string) => {
 
 const isKnownViewParamName = (segment: string) => ['tab', 'filterbytk', 'sourceid'].includes(segment);
 
+const isLegacyLayoutContentRouteName = (routeName: string, targetRouteName?: string) => {
+  return (
+    !!targetRouteName &&
+    ['page', 'page.tabs', 'page.tabs.popups', 'page.tab', 'page.view', 'page.tab.view'].some(
+      (legacyName) => targetRouteName === `${routeName}.${legacyName}`,
+    )
+  );
+};
+
 const isStandardLayoutRelativePath = (relativePath: string) => {
   if (!relativePath) {
     return true;
@@ -170,6 +181,7 @@ export class BaseLayoutModel<
   currentLayoutRoute: LayoutRouteMatch | null = null;
   protected routeCoordinator?: BaseLayoutRouteCoordinator;
   private activePageUid = '';
+  private currentRouteState?: unknown;
   private layoutContentElement: HTMLElement | null = null;
   private readonly routePageMetaMap = new Map<string, RoutePageMeta>();
   private contextBindingsActive = false;
@@ -184,6 +196,7 @@ export class BaseLayoutModel<
 
   registerRoutePage(pageUid: string, meta: RoutePageMeta) {
     this.routePageMetaMap.set(pageUid, meta);
+    this.restoreCurrentLayoutRouteFromRouterContext(pageUid);
     const routeModel = this.getCoordinator().registerPage(pageUid, meta);
     this.getCoordinator().syncRoute(this.getCurrentCoordinatorRouteLike());
     return routeModel;
@@ -322,6 +335,18 @@ export class BaseLayoutModel<
       };
     }
 
+    const routeRepository = this.flowEngine.context.routeRepository;
+    const schemaRoute = routeRepository?.getRouteBySchemaUid?.(pageUid);
+    const route = schemaRoute ? undefined : routeRepository?.getRouteById?.(pageUid);
+    if (!schemaRoute && route?.type === NocoBaseDesktopRouteType.group) {
+      return {
+        type: 'root',
+        pathname,
+        basePathname,
+        relativePath,
+      };
+    }
+
     return {
       type: 'page',
       pathname,
@@ -345,6 +370,7 @@ export class BaseLayoutModel<
 
     const layoutRoute = this.resolveLayoutRoute(routeLike);
     this.currentLayoutRoute = layoutRoute;
+    this.currentRouteState = routeLike.state;
     this.activePageUid = this.getPageUidFromLayoutRoute(layoutRoute);
     this.getCoordinator().syncRoute({
       ...routeLike,
@@ -364,7 +390,12 @@ export class BaseLayoutModel<
       return;
     }
 
+    if (this.shouldIgnoreStaleLayoutRouteCleanup(routeLike)) {
+      return;
+    }
+
     this.currentLayoutRoute = null;
+    this.currentRouteState = undefined;
     this.activePageUid = '';
     this.routeCoordinator?.syncRoute({});
   }
@@ -434,12 +465,105 @@ export class BaseLayoutModel<
         layoutRouteName: this.layout.routeName,
         pageUid: this.currentLayoutRoute.pageUid,
         pathname: this.currentLayoutRoute.pathname,
+        state: this.currentRouteState,
         layoutBasePathname: this.currentLayoutRoute.basePathname,
         layoutRoute: this.currentLayoutRoute,
       };
     }
     return {};
   }
+
+  private restoreCurrentLayoutRouteFromRouterContext(pageUid: string) {
+    if (this.currentLayoutRoute?.type === 'page') {
+      return;
+    }
+
+    const routeLike = this.getRouterContextRouteLike();
+    if (!routeLike) {
+      return;
+    }
+
+    if (!this.isRouteLikeOwnedByCurrentLayout(routeLike)) {
+      return;
+    }
+
+    const layoutRoute = this.resolveLayoutRoute({
+      ...routeLike,
+      layoutRouteName: routeLike.layoutRouteName || this.layout.routeName,
+    });
+    if (layoutRoute.type !== 'page' || layoutRoute.pageUid !== pageUid) {
+      return;
+    }
+
+    this.currentLayoutRoute = layoutRoute;
+    this.activePageUid = layoutRoute.pageUid;
+  }
+
+  private shouldIgnoreStaleLayoutRouteCleanup(routeLike?: LayoutRouteLike) {
+    if (!routeLike?.pathname || this.currentLayoutRoute?.type !== 'page') {
+      return false;
+    }
+
+    const currentLayoutRoute = this.currentLayoutRoute;
+    if (!this.routePageMetaMap.has(currentLayoutRoute.pageUid)) {
+      return false;
+    }
+
+    const routeLikePathname = normalizePathname(routeLike.pathname);
+    if (routeLikePathname !== currentLayoutRoute.pathname) {
+      return false;
+    }
+
+    const routerRouteLike = this.getRouterContextRouteLike();
+    if (!routerRouteLike) {
+      return false;
+    }
+
+    if (!this.isRouteLikeOwnedByCurrentLayout(routerRouteLike)) {
+      return false;
+    }
+
+    const routerLayoutRoute = this.resolveLayoutRoute({
+      ...routerRouteLike,
+      layoutRouteName: routerRouteLike.layoutRouteName || this.layout.routeName,
+    });
+
+    return (
+      routerLayoutRoute.type === 'page' &&
+      routerLayoutRoute.pageUid === currentLayoutRoute.pageUid &&
+      routerLayoutRoute.pathname === currentLayoutRoute.pathname
+    );
+  }
+
+  private getRouterContextRouteLike(): LayoutRouteLike | null {
+    const route = this.flowEngine.context.route as LayoutRouteLike | undefined;
+    if (!route?.pathname) {
+      return null;
+    }
+
+    return {
+      id: route.id,
+      name: route.name || route.id,
+      pathname: route.pathname,
+      params: route.params,
+      layoutRouteName: route.layoutRouteName,
+      layoutBasePathname: route.layoutBasePathname,
+    };
+  }
+
+  private isRouteLikeOwnedByCurrentLayout(routeLike: LayoutRouteLike) {
+    if (routeLike.layoutRouteName) {
+      return routeLike.layoutRouteName === this.layout.routeName;
+    }
+
+    const layoutBasePathname = getDefaultBasePathnameFromRoutePath(this.layout.routePath);
+    if (routeLike.layoutBasePathname && layoutBasePathname) {
+      return normalizeBasePathname(routeLike.layoutBasePathname) === normalizeBasePathname(layoutBasePathname);
+    }
+
+    const routeName = routeLike.name || routeLike.id;
+    return this.isLayoutContentRoute(routeLike) || isLegacyLayoutContentRouteName(this.layout.routeName, routeName);
+  }
 }
 
 /**