@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.45

package/src/flow/actions/__tests__/linkageRules.subFormSetFieldProps.test.ts

@@ -13,6 +13,113 @@ import { FlowSettingsContextProvider } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
 import { fieldLinkageRules, linkageSetFieldProps, subFormLinkageSetFieldProps } from '../linkageRules';
 
+const createSubFormFieldModel = ({
+  uid,
+  fieldPath,
+  hidden,
+  blockUid = 'block-1',
+  fieldIndex,
+  fieldPathArray,
+}: {
+  uid: string;
+  fieldPath: string;
+  hidden: boolean;
+  blockUid?: string;
+  fieldIndex?: string[];
+  fieldPathArray?: Array<string | number>;
+}) => ({
+  uid,
+  hidden,
+  props: {},
+  context: {
+    blockModel: { uid: blockUid },
+    ...(fieldIndex ? { fieldIndex } : {}),
+    ...(fieldPathArray ? { fieldPathArray } : {}),
+  },
+  forks: new Set(),
+  getStepParams: (flowKey: string, stepKey: string) => {
+    if (flowKey === 'fieldSettings' && stepKey === 'init') {
+      return { fieldPath };
+    }
+  },
+  setProps(key: any, value?: any) {
+    if (typeof key === 'string') {
+      this.props[key] = value;
+    } else {
+      this.props = { ...this.props, ...key };
+    }
+  },
+});
+
+const runSubFormFieldStateRule = async ({
+  state,
+  fieldUid,
+  fieldKey,
+  targetModel,
+  models,
+}: {
+  state: 'visible' | 'hidden';
+  fieldUid: string;
+  fieldKey: string[];
+  targetModel: any;
+  models: any[];
+}) => {
+  const formItemModel: any = {
+    uid: fieldUid,
+    forks: new Set([targetModel]),
+    getFork: vi.fn((key: string) => (key === `${fieldKey}:${fieldUid}` ? targetModel : undefined)),
+  };
+  const allModels = [formItemModel, ...models];
+  const ctx: any = {
+    app: {
+      jsonLogic: {
+        apply: vi.fn(() => true),
+      },
+    },
+    model: {
+      context: {
+        blockModel: { uid: 'block-1' },
+        fieldKey,
+      },
+      flowEngine: {
+        forEachModel: (visitor: (model: any) => void) => {
+          allModels.forEach(visitor);
+        },
+      },
+    },
+    engine: {
+      getModel: vi.fn((uid: string) => (uid === fieldUid ? formItemModel : undefined)),
+      forEachModel: (visitor: (model: any) => void) => {
+        allModels.forEach(visitor);
+      },
+    },
+    getAction: (name: string) => (name === 'subFormLinkageSetFieldProps' ? subFormLinkageSetFieldProps : null),
+    resolveJsonTemplate: vi.fn(async (value) => value),
+  };
+
+  await fieldLinkageRules.handler(ctx, {
+    value: [
+      {
+        key: 'rule-1',
+        enable: true,
+        condition: { logic: '$and', items: [] },
+        actions: [
+          {
+            key: 'action-1',
+            name: 'subFormLinkageSetFieldProps',
+            params: {
+              value: {
+                fields: [fieldUid],
+                state,
+              },
+            },
+          },
+        ],
+      },
+    ],
+  });
+};
+
 describe('subFormLinkageSetFieldProps action', () => {
   it('should not throw when engine.getModel returns undefined', () => {
     const setProps = vi.fn();
@@ -144,6 +251,90 @@ describe('subFormLinkageSetFieldProps action', () => {
 
     expect(setProps).toHaveBeenCalledWith(forkModel, { options: selectedOptions });
   });
+
+  it('should sync hidden state when a subform field changes from hidden to visible', async () => {
+    const targetModel = createSubFormFieldModel({
+      uid: 'field-a',
+      fieldPath: 'a',
+      hidden: true,
+      fieldIndex: ['items:0'],
+    });
+    const collectedModel = createSubFormFieldModel({
+      uid: 'field-a-collected',
+      fieldPath: 'a',
+      hidden: true,
+      fieldPathArray: ['items', 0, 'a'],
+    });
+
+    await runSubFormFieldStateRule({
+      state: 'visible',
+      fieldUid: 'field-a',
+      fieldKey: ['items:0'],
+      targetModel,
+      models: [collectedModel],
+    });
+
+    expect(targetModel.hidden).toBe(false);
+    expect(collectedModel.hidden).toBe(false);
+  });
+
+  it('should sync hidden state when a subform field changes from visible to hidden', async () => {
+    const targetModel = createSubFormFieldModel({
+      uid: 'field-a',
+      fieldPath: 'a',
+      hidden: false,
+      fieldIndex: ['items:0'],
+    });
+    const collectedModel = createSubFormFieldModel({
+      uid: 'field-a-collected',
+      fieldPath: 'a',
+      hidden: false,
+      fieldPathArray: ['items', 0, 'a'],
+    });
+
+    await runSubFormFieldStateRule({
+      state: 'hidden',
+      fieldUid: 'field-a',
+      fieldKey: ['items:0'],
+      targetModel,
+      models: [collectedModel],
+    });
+
+    expect(targetModel.hidden).toBe(true);
+    expect(collectedModel.hidden).toBe(true);
+  });
+
+  it('should only sync hidden state for the current subform row', async () => {
+    const targetModel = createSubFormFieldModel({
+      uid: 'field-a',
+      fieldPath: 'a',
+      hidden: true,
+      fieldIndex: ['items:0'],
+    });
+    const row0CollectedModel = createSubFormFieldModel({
+      uid: 'field-a-row-0',
+      fieldPath: 'a',
+      hidden: true,
+      fieldPathArray: ['items', 0, 'a'],
+    });
+    const row1CollectedModel = createSubFormFieldModel({
+      uid: 'field-a-row-1',
+      fieldPath: 'a',
+      hidden: true,
+      fieldPathArray: ['items', 1, 'a'],
+    });
+
+    await runSubFormFieldStateRule({
+      state: 'visible',
+      fieldUid: 'field-a',
+      fieldKey: ['items:0'],
+      targetModel,
+      models: [row0CollectedModel, row1CollectedModel],
+    });
+
+    expect(row0CollectedModel.hidden).toBe(false);
+    expect(row1CollectedModel.hidden).toBe(true);
+  });
 });
 
 describe('linkageSetFieldProps action', () => {

package/src/flow/actions/__tests__/openView.subModelKey.test.tsx

@@ -28,6 +28,7 @@ describe('openView action - subModelKey behavior', () => {
         flowEngine: { context: { themeToken: { colorBgLayout: '#fff' } } },
       },
       layoutContentElement: {},
+      layoutContext: { source: 'layout-context' },
       view: {},
       viewer: {
         open: vi.fn(async (_opts: any) => undefined),
@@ -90,6 +91,38 @@ describe('openView action - subModelKey behavior', () => {
     // FlowPage should receive parent model uid
     expect(capturedElement?.type).toBe(FlowPage);
     expect(capturedElement?.props?.parentId).toBe('parent-model-uid');
+    expect(capturedElement?.props).not.toHaveProperty('layoutContext');
     expect(capturedElement?.props?.pageModelClass).toBe('ChildPageModel');
   });
+
+  it('uses current layout child page model as default pageModelClass', async () => {
+    const { ctx } = createCtx();
+    ctx.layout = {
+      childPageModelClass: 'MobileChildPageModel',
+    };
+
+    let capturedElement: any;
+    (ctx.viewer.open as any).mockImplementation(async (opts) => {
+      const currentView = { close: vi.fn(), update: vi.fn() };
+      capturedElement = opts.content(currentView);
+      return undefined;
+    });
+
+    await openView.handler(ctx, { navigation: false });
+
+    expect(capturedElement?.type).toBe(FlowPage);
+    expect(capturedElement?.props?.pageModelClass).toBe('MobileChildPageModel');
+  });
+
+  it('uses current layout child page model in default params', async () => {
+    const { ctx } = createCtx();
+    ctx.layout = {
+      childPageModelClass: 'MobileChildPageModel',
+    };
+    ctx.getPropertyMetaTree = vi.fn(() => []);
+
+    await expect(openView.defaultParams(ctx)).resolves.toMatchObject({
+      pageModelClass: 'MobileChildPageModel',
+    });
+  });
 });

package/src/flow/actions/aclCheck.tsx

@@ -24,6 +24,10 @@ const getRecordPkValue = (value: any) => {
 export const aclCheck = defineAction({
   name: 'aclCheck',
   async handler(ctx, params) {
+    if (ctx.skipAclCheck) {
+      return;
+    }
+
     const result = await ctx.aclCheck({
       dataSourceKey: ctx.dataSource?.key,
       resourceName: ctx.collectionField?.collectionName || ctx.resourceName,

package/src/flow/actions/aclCheckRefresh.tsx

@@ -158,6 +158,10 @@ export const aclCheckRefresh = defineAction({
     // 先清理旧状态，避免翻页/fork 复用造成污染
     resetAclDerivedState(ctx);
 
+    if (ctx.skipAclCheck) {
+      return;
+    }
+
     if (strategy === 'formItem') {
       await runFormItemAclCheck(ctx);
       return;

package/src/flow/actions/dateTimeFormat.tsx

@@ -17,7 +17,7 @@ export const dateTimeFormat = defineAction({
   name: 'dateDisplayFormat',
   uiSchema: (ctx) => {
     const { collectionField } = ctx.model.context as any;
-    const type = collectionField.type;
+    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
     const timeFormatField = {
       type: 'string',
       title: '{{t("Time format")}}',
@@ -41,7 +41,7 @@ export const dateTimeFormat = defineAction({
       ],
       'x-reactions': [
         (field) => {
-          if (type !== 'time') {
+          if (!isTimeField) {
             const { showTime, picker } = field.form.values || {};
             field.hidden = !showTime || picker !== 'date';
           }
@@ -49,7 +49,7 @@ export const dateTimeFormat = defineAction({
       ],
     };
 
-    if (type === 'time') {
+    if (isTimeField) {
       return {
         timeFormat: timeFormatField,
       };
@@ -159,24 +159,28 @@ export const dateTimeFormat = defineAction({
     };
   },
   defaultParams: (ctx: any) => {
-    const { showTime, dateFormat, timeFormat, picker }: any = {
+    const { showTime, dateFormat, format, timeFormat, picker }: any = {
       ...ctx.model.context.collectionField.getComponentProps(),
       ...ctx.model.props,
     };
+    const collectionField = ctx.model.context.collectionField;
+    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
     return {
       picker: picker || 'date',
       dateFormat: dateFormat || 'YYYY-MM-DD',
-      timeFormat: timeFormat || 'HH:mm:ss',
+      timeFormat: timeFormat || (isTimeField ? format : undefined) || 'HH:mm:ss',
       showTime,
     };
   },
   handler(ctx: any, params) {
     const { collectionField } = ctx.model.context as any;
-    const type = collectionField.type;
-    if (type === 'time') {
+    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
+    if (isTimeField) {
+      const timeFormat = params?.timeFormat || params?.format || 'HH:mm:ss';
       ctx.model.setProps({
         ...params,
-        format: params?.timeFormat,
+        timeFormat,
+        format: timeFormat,
       });
     } else {
       ctx.model.setProps({

package/src/flow/actions/linkageRules.tsx

@@ -1916,6 +1916,120 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     return null;
   };
+  const normalizeNamePathForKey = (namePath: any): Array<string | number> | null => {
+    if (!Array.isArray(namePath) || !namePath.length) return null;
+    const normalized = namePath.filter((seg) => typeof seg === 'string' || typeof seg === 'number') as Array<
+      string | number
+    >;
+    return normalized.length ? normalized : null;
+  };
+  const getFieldIndexEntries = (fieldIndex: any): Array<{ name: string; index: number }> => {
+    if (!Array.isArray(fieldIndex)) return [];
+    return fieldIndex
+      .map((entry) => {
+        if (typeof entry !== 'string') return null;
+        const [name, indexText] = entry.split(':');
+        const index = Number(indexText);
+        if (!name || !Number.isFinite(index)) return null;
+        return { name, index };
+      })
+      .filter(Boolean) as Array<{ name: string; index: number }>;
+  };
+  const resolveIndexedRelativePath = (path: string, fieldIndex: any): Array<string | number> | null => {
+    const pathSegs = parsePathString(path).filter((seg) => typeof seg === 'string' || typeof seg === 'number') as Array<
+      string | number
+    >;
+    if (!pathSegs.length) return null;
+
+    const entries = getFieldIndexEntries(fieldIndex);
+    if (!entries.length) return null;
+
+    const firstSeg = typeof pathSegs[0] === 'string' ? pathSegs[0] : '';
+    const matchedEntryIndex = firstSeg ? entries.findIndex((entry) => entry.name === firstSeg) : -1;
+    const prefixEntries = matchedEntryIndex >= 0 ? entries.slice(0, matchedEntryIndex) : entries;
+    const remainingEntries = matchedEntryIndex >= 0 ? entries.slice(matchedEntryIndex) : [];
+    const out: Array<string | number> = [];
+
+    prefixEntries.forEach((entry) => {
+      out.push(entry.name, entry.index);
+    });
+
+    let entryIndex = 0;
+    pathSegs.forEach((seg, index) => {
+      out.push(seg);
+      const entry = remainingEntries[entryIndex];
+      if (typeof seg !== 'string' || !entry || entry.name !== seg) return;
+
+      const nextSeg = pathSegs[index + 1];
+      if (typeof nextSeg === 'number') {
+        entryIndex += 1;
+        return;
+      }
+      out.push(entry.index);
+      entryIndex += 1;
+    });
+
+    return out;
+  };
+  const getModelTargetPathKeys = (model: any): Set<string> => {
+    const keys = new Set<string>();
+    const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
+    if (fieldPathArray) {
+      keys.add(namePathToPathKey(fieldPathArray));
+      return keys;
+    }
+
+    const targetPath = getModelTargetPathForPatch(model);
+    if (targetPath) {
+      const fieldIndexEntries = getFieldIndexEntries(model?.context?.fieldIndex);
+      if (!fieldIndexEntries.length) {
+        keys.add(`raw:${targetPath}`);
+      }
+
+      const resolved = normalizeNamePathForKey(resolveDynamicNamePath(targetPath, model?.context?.fieldIndex));
+      if (resolved) {
+        keys.add(namePathToPathKey(resolved));
+      }
+
+      const indexedRelativePath = resolveIndexedRelativePath(targetPath, model?.context?.fieldIndex);
+      if (indexedRelativePath) {
+        keys.add(namePathToPathKey(indexedRelativePath));
+      }
+    }
+
+    return keys;
+  };
+  const forEachModelIncludingForks = (visitor: (model: any) => void) => {
+    const engine = (ctx as any)?.engine || ctx.model?.flowEngine;
+    if (!engine?.forEachModel) return;
+    engine.forEachModel((model: any) => {
+      visitor(model);
+
+      const forks: any = model?.forks;
+      if (forks && typeof forks.forEach === 'function') {
+        forks.forEach((fork: any) => {
+          if (!fork || fork.disposed) return;
+          visitor(fork);
+        });
+      }
+    });
+  };
+  const syncHiddenStateByTargetPath = (targetModel: any, hidden: boolean) => {
+    const targetPathKeys = getModelTargetPathKeys(targetModel);
+    if (!targetPathKeys.size) return;
+
+    const targetBlockUid = targetModel?.context?.blockModel?.uid;
+    if (!targetBlockUid) return;
+    forEachModelIncludingForks((model: any) => {
+      if (!model || typeof model !== 'object') return;
+      const modelBlockUid = model?.context?.blockModel?.uid;
+      if (String(modelBlockUid) !== String(targetBlockUid)) return;
+      const modelPathKeys = getModelTargetPathKeys(model);
+      if (!Array.from(modelPathKeys).some((key) => targetPathKeys.has(key))) return;
+
+      model.hidden = hidden;
+    });
+  };
 
   // 1. 运行所有的联动规则
   for (const rule of linkageRules.filter((r) => r.enable)) {
@@ -1981,9 +2095,11 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     }
   });
 
+  const hiddenStatePatches: Array<{ model: any; hidden: boolean }> = [];
   mergedByUid.forEach((model: any, uid) => {
     const patchProps = mergedPropsByUid.get(uid) || {};
     const newProps = { ...model.__originalProps, ...patchProps };
+    const hasHiddenModelPatch = Object.prototype.hasOwnProperty.call(patchProps, 'hiddenModel');
 
     model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
     syncFieldOptionsToForks(model, patchProps);
@@ -1991,6 +2107,9 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       model.setHidden(!!newProps.hiddenModel);
     } else {
       model.hidden = !!newProps.hiddenModel;
+      if (hasHiddenModelPatch) {
+        hiddenStatePatches.push({ model, hidden: model.hidden });
+      }
     }
 
     if (newProps.required === true) {
@@ -2027,6 +2146,9 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     model.__props = null;
   });
+  hiddenStatePatches.forEach(({ model, hidden }) => {
+    syncHiddenStateByTargetPath(model, hidden);
+  });
 
   const allPatches = [...directValuePatches];
   if (!allPatches.length) return;

package/src/flow/actions/openView.tsx

@@ -10,7 +10,7 @@
 import { defineAction, tExpr, FlowModelContext, FlowModel, FlowExitAllException } from '@nocobase/flow-engine';
 import React from 'react';
 import { FlowPage } from '../FlowPage';
-import { RootPageModel } from '../models';
+import { PageModel, RootPageModel } from '../models';
 import _ from 'lodash';
 
 type DirtyAwareFlowModel = FlowModel & {
@@ -230,7 +230,7 @@ export const openView = defineAction({
     return {
       mode: 'drawer',
       size: 'medium',
-      pageModelClass: 'ChildPageModel',
+      pageModelClass: ctx.layout?.childPageModelClass || 'ChildPageModel',
       uid: ctx.model?.uid,
       ...(filterByTkExpr ? { filterByTk: filterByTkExpr } : {}),
       ...(sourceIdExpr ? { sourceId: sourceIdExpr } : {}),
@@ -371,7 +371,8 @@ export const openView = defineAction({
       embed: {},
     };
 
-    const pageModelClass = ctx.inputArgs.pageModelClass || params.pageModelClass || 'ChildPageModel';
+    const pageModelClass =
+      ctx.inputArgs.pageModelClass || params.pageModelClass || ctx.layout?.childPageModelClass || 'ChildPageModel';
     const size = ctx.inputArgs.size || params.size || 'medium';
     let pageModelUid: string | null = null;
     let pageModelRef: FlowModel | null = null;
@@ -414,7 +415,12 @@ export const openView = defineAction({
       associationName: runtimeAssociationName,
       tabUid: mergedTabUid,
       openerUids,
-      pageActive: true, // 打开一个弹窗时，页面肯定是激活的
+      pageActive:
+        typeof inputArgs.pageActive === 'boolean'
+          ? inputArgs.pageActive
+          : typeof ctx.inputArgs.pageActive === 'boolean'
+            ? ctx.inputArgs.pageActive
+            : true,
     };
     // Ensure runtime keys propagate to view.inputArgs
     finalInputArgs.filterByTk = mergedFilterByTk;
@@ -477,6 +483,24 @@ export const openView = defineAction({
                 });
               }
 
+              if (ctx.inputArgs.activateRef) {
+                ctx.inputArgs.activateRef.current = (forceRefresh = false) => {
+                  currentView.inputArgs.pageActive = true;
+                  if (pageModel instanceof PageModel) {
+                    pageModel.activateCurrentTab(forceRefresh);
+                  }
+                };
+              }
+
+              if (ctx.inputArgs.deactivateRef) {
+                ctx.inputArgs.deactivateRef.current = () => {
+                  currentView.inputArgs.pageActive = false;
+                  if (pageModel instanceof PageModel) {
+                    pageModel.deactivateCurrentTab();
+                  }
+                };
+              }
+
               Object.entries(defineProperties as Record<string, any>).forEach(([key, p]) => {
                 pageModel.context.defineProperty(key, p);
               });