@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.11

package/src/flow/actions/openView.tsx

@@ -7,11 +7,20 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { defineAction, tExpr, FlowModelContext, FlowModel, FlowExitAllException } from '@nocobase/flow-engine';
+import {
+  defineAction,
+  tExpr,
+  FlowModelContext,
+  FlowModel,
+  FlowExitAllException,
+  createOpenViewRouteState,
+  RUNJS_OPEN_VIEW_ROUTE_STATE,
+} from '@nocobase/flow-engine';
 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;
@@ -23,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 [];
@@ -291,8 +309,32 @@ export const openView = defineAction({
         ? (inputArgs as any).associationName
         : (params as any)?.associationName;
     const mergedTabUid = typeof inputArgs.tabUid !== 'undefined' ? inputArgs.tabUid : params.tabUid;
-    // 移动端中只需要显示子页面
-    const openMode = ctx.inputArgs?.isMobileLayout ? 'embed' : ctx.inputArgs?.mode || params.mode || 'drawer';
+    const hasRunJSOpenViewRouteState = Object.prototype.hasOwnProperty.call(inputArgs, RUNJS_OPEN_VIEW_ROUTE_STATE);
+    const runJSOpenViewRouteStateInput = (inputArgs as Record<PropertyKey, unknown>)[RUNJS_OPEN_VIEW_ROUTE_STATE];
+    const runJSOpenViewRouteState = hasRunJSOpenViewRouteState
+      ? createOpenViewRouteState(
+          runJSOpenViewRouteStateInput && typeof runJSOpenViewRouteStateInput === 'object'
+            ? (runJSOpenViewRouteStateInput as { mode?: unknown; size?: unknown })
+            : {
+                mode: inputArgs.mode,
+                size: inputArgs.size,
+              },
+        )
+      : undefined;
+    const replayOpenViewRouteStateInput = (inputArgs as { openViewRouteState?: unknown }).openViewRouteState;
+    const replayOpenViewRouteState =
+      replayOpenViewRouteStateInput && typeof replayOpenViewRouteStateInput === 'object'
+        ? createOpenViewRouteState(replayOpenViewRouteStateInput as { mode?: unknown; size?: unknown })
+        : undefined;
+    const runtimeOpenViewRouteState = runJSOpenViewRouteState || replayOpenViewRouteState;
+    // 移动端中只需要显示子页面。本次 dispatch 参数优先于持久化默认值。
+    const openMode = ctx.inputArgs?.isMobileLayout
+      ? 'embed'
+      : runtimeOpenViewRouteState?.mode || ctx.inputArgs?.mode || params.mode || 'drawer';
+    const effectiveRunJSOpenViewRouteState =
+      runJSOpenViewRouteState && ctx.inputArgs?.isMobileLayout
+        ? createOpenViewRouteState({ ...runJSOpenViewRouteState, mode: openMode })
+        : runJSOpenViewRouteState;
     let navigation = typeof inputArgs.navigation !== 'undefined' ? inputArgs.navigation : params.navigation;
 
     // 传递了上下文就必须禁用路由，否则下次路由打开会缺少上下文
@@ -313,6 +355,7 @@ export const openView = defineAction({
           sourceId: mergedSourceId,
           tabUid: mergedTabUid,
           viewUid: ctx.model.context?.inputArgs?.viewUid || ctx.model.uid,
+          ...(effectiveRunJSOpenViewRouteState ? { openViewRouteState: effectiveRunJSOpenViewRouteState } : {}),
         } as Record<string, unknown>;
         const pendingView = {
           type: pendingType,
@@ -328,8 +371,19 @@ export const openView = defineAction({
           filterByTk: mergedFilterByTk,
           sourceId: mergedSourceId,
           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;
       }
     }
@@ -373,7 +427,7 @@ export const openView = defineAction({
 
     const pageModelClass =
       ctx.inputArgs.pageModelClass || params.pageModelClass || ctx.layout?.childPageModelClass || 'ChildPageModel';
-    const size = ctx.inputArgs.size || params.size || 'medium';
+    const size = runtimeOpenViewRouteState?.size || ctx.inputArgs.size || params.size || 'medium';
     let pageModelUid: string | null = null;
     let pageModelRef: FlowModel | null = null;
 

package/src/flow/actions/runjs.tsx

@@ -7,14 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import {
-  ActionScene,
-  defineAction,
-  tExpr,
-  createSafeWindow,
-  createSafeDocument,
-  createSafeNavigator,
-} from '@nocobase/flow-engine';
+import { ActionScene, defineAction, tExpr } from '@nocobase/flow-engine';
 import { CodeEditor } from '../components/code-editor';
 
 export const runjs = defineAction({
@@ -38,11 +31,6 @@ export const runjs = defineAction({
     // 如果是 URL 触发的，则不执行代码
     if (ctx.inputArgs?.navigation) return;
 
-    const navigator = createSafeNavigator();
-    return ctx.runjs(params.code, {
-      window: createSafeWindow({ navigator }),
-      document: createSafeDocument(),
-      navigator,
-    });
+    return ctx.runjs(params.code);
   },
 });

package/src/flow/actions/validation.tsx

@@ -10,6 +10,56 @@
 import { defineAction, jioToJoiSchema, tExpr } from '@nocobase/flow-engine';
 import { FieldValidation } from '../../flow-compat';
 
+type ValidationType = 'string' | 'number' | 'array' | 'boolean' | 'any';
+
+interface ValidationRule {
+  name: string;
+  args?: any;
+}
+
+interface ValidationData {
+  type: ValidationType;
+  rules?: ValidationRule[];
+}
+
+interface ValidationContext {
+  model: {
+    props: {
+      label?: string;
+    };
+  };
+  t: (key: string, options?: Record<string, unknown>) => string;
+}
+
+function buildValidationRules(ctx: ValidationContext, validation: ValidationData) {
+  const rules = [];
+  const schema = jioToJoiSchema(validation);
+  const label = ctx.model.props.label;
+  rules.push({
+    validator: (_: unknown, value: unknown) => {
+      const { error } = schema.validate(value, {
+        abortEarly: false,
+      });
+
+      if (error) {
+        const messages = error.details.map((d: { type: string; context?: Record<string, unknown> }) => {
+          return ctx.t(`${d.type}`, {
+            ...d.context,
+            ns: 'data-source-main',
+            label,
+          });
+        });
+        const div = document.createElement('div');
+        div.innerHTML = messages.join('; ');
+        return Promise.reject(div.textContent);
+      }
+
+      return Promise.resolve();
+    },
+  });
+  return rules;
+}
+
 export const validation = defineAction({
   title: tExpr('Validation'),
   name: 'validation',
@@ -29,6 +79,7 @@ export const validation = defineAction({
           type: targetInterface.validationType,
           availableValidationOptions: [...new Set(targetInterface.availableValidationOptions)],
           excludeValidationOptions: [...new Set(targetInterface.excludeValidationOptions)],
+          inheritedValue: ctx.model.collectionField.validation,
           isAssociation: targetInterface.isAssociation,
         },
       },
@@ -36,40 +87,21 @@ export const validation = defineAction({
   },
   handler(ctx, params) {
     if (params.validation) {
-      const rules = [];
-      const schema = jioToJoiSchema(params.validation);
-      const label = ctx.model.props.label;
-      rules.push({
-        validator: (_, value) => {
-          const { error } = schema.validate(value, {
-            abortEarly: false,
-          });
-
-          if (error) {
-            const messages = error.details.map((d) => {
-              return ctx.t(`${d.type}`, {
-                ...d.context,
-                ns: 'data-source-main',
-                label,
-              });
-            });
-            const div = document.createElement('div');
-            div.innerHTML = messages.join('; ');
-            return Promise.reject(div.textContent);
-          }
-
-          return Promise.resolve();
-        },
-      });
-      const hasRequiredInCollection = params.validation.rules.some((rule) => rule.name === 'required');
-      if (hasRequiredInCollection) {
+      const collectionValidation = ctx.model.collectionField?.validation;
+      const collectionRules = ctx.model.collectionField?.getComponentProps?.().rules || [];
+      const uiRules = params.validation.rules?.length
+        ? buildValidationRules(ctx as unknown as ValidationContext, params.validation)
+        : [];
+      const hasRequiredInValidation = [collectionValidation, params.validation].some(
+        (validation) => validation?.rules?.some((rule) => rule.name === 'required'),
+      );
+      if (hasRequiredInValidation) {
         ctx.model.setProps({
-          required: hasRequiredInCollection,
+          required: hasRequiredInValidation,
         });
       }
-      console.log(rules);
       ctx.model.setProps({
-        rules,
+        rules: [...collectionRules, ...uiRules],
         validation: params.validation,
       });
     }

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

@@ -8,12 +8,19 @@
  */
 
 import { define, observable } from '@formily/reactive';
-import { parsePathnameToViewParams, type FlowEngine, FlowModel, type ViewParam } from '@nocobase/flow-engine';
+import {
+  decodeOpenViewRouteState,
+  parsePathnameToViewParams,
+  type FlowEngine,
+  FlowModel,
+  type ViewParam,
+} from '@nocobase/flow-engine';
 import {
   BaseLayoutRouteCoordinator,
   type BaseLayoutRouteCoordinatorOptions,
   type RoutePageMeta,
 } from './BaseLayoutRouteCoordinator';
+import { NocoBaseDesktopRouteType } from '../../flow-compat';
 import type { LayoutDefinition } from '../../layout-manager/types';
 import { isLayoutContentRouteName } from '../../layout-manager/utils';
 
@@ -66,6 +73,7 @@ export interface LayoutRouteLike {
   id?: string;
   name?: string;
   pathname?: string;
+  state?: unknown;
   params?: Record<string, string | undefined>;
   layoutRouteName?: string;
   layoutBasePathname?: string;
@@ -105,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;
@@ -116,20 +133,36 @@ const isStandardLayoutRelativePath = (relativePath: string) => {
   }
 
   let i = 1;
+  let currentViewUid = segments[0];
   while (i < segments.length) {
     const segment = segments[i];
+
     if (segment === 'view') {
       if (!segments[i + 1]) {
         return false;
       }
+      currentViewUid = segments[i + 1];
+      i += 2;
+      continue;
+    }
+
+    if (segment === 'opts') {
+      if (!segments[i + 1] || !decodeOpenViewRouteState(currentViewUid, segments[i + 1])) {
+        return false;
+      }
       i += 2;
       continue;
     }
 
-    if (!isKnownViewParamName(segment) || !segments[i + 1]) {
+    if (isKnownViewParamName(segment) && segments[i + 1]) {
+      i += 2;
+      continue;
+    }
+
+    if (!segments[i + 1]) {
       return false;
     }
-    i += 2;
+    return false;
   }
 
   return true;
@@ -148,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;
@@ -162,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;
@@ -300,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,
@@ -323,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,
@@ -342,7 +390,12 @@ export class BaseLayoutModel<
       return;
     }
 
+    if (this.shouldIgnoreStaleLayoutRouteCleanup(routeLike)) {
+      return;
+    }
+
     this.currentLayoutRoute = null;
+    this.currentRouteState = undefined;
     this.activePageUid = '';
     this.routeCoordinator?.syncRoute({});
   }
@@ -412,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);
+  }
 }
 
 /**