@nocobase/client-v2 2.1.6 → 2.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "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.6",
-    "@nocobase/flow-engine": "2.1.6",
-    "@nocobase/sdk": "2.1.6",
-    "@nocobase/shared": "2.1.6",
-    "@nocobase/utils": "2.1.6",
+    "@nocobase/evaluators": "2.1.7",
+    "@nocobase/flow-engine": "2.1.7",
+    "@nocobase/sdk": "2.1.7",
+    "@nocobase/shared": "2.1.7",
+    "@nocobase/utils": "2.1.7",
     "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": "4312d6580cc01378d008072db8285803626dc435"
+  "gitHead": "fc3bc8bf6ef0c185a456cb5241abc4716af8c20c"
 }

package/src/flow/actions/__tests__/linkageRules.hiddenSync.restore.test.ts

@@ -27,12 +27,12 @@ describe('linkageRules hidden state propagation', () => {
     const hostModel: any = {
       uid: 'host',
       hidden: false,
-      context: { blockModel },
+      context: { blockModel, fieldPathArray: ['children'] },
       __allModels: [],
       setProps: vi.fn(),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
-        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        if (stepKey === 'init') return { fieldPath: 'children' };
         return undefined;
       }),
       translate: (s: string) => s,
@@ -41,10 +41,22 @@ describe('linkageRules hidden state propagation', () => {
     const sameTargetModel: any = {
       uid: 'same-target',
       hidden: false,
-      context: { blockModel },
+      context: { blockModel, fieldPathArray: ['children'] },
       setProps: vi.fn(),
       getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
-        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        if (stepKey === 'init') return { fieldPath: 'children' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const nestedColumnModel: any = {
+      uid: 'nested-column',
+      hidden: true,
+      context: { blockModel, fieldPathArray: ['children'] },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'children.children' };
         return undefined;
       }),
       translate: (s: string) => s,
@@ -52,7 +64,7 @@ describe('linkageRules hidden state propagation', () => {
 
     const engine = {
       forEachModel: (visitor: (m: any) => void) => {
-        [hostModel, sameTargetModel].forEach(visitor);
+        [hostModel, sameTargetModel, nestedColumnModel].forEach(visitor);
       },
     };
 
@@ -92,9 +104,11 @@ describe('linkageRules hidden state propagation', () => {
     });
     expect(hostModel.hidden).toBe(true);
     expect(sameTargetModel.hidden).toBe(true);
+    expect(nestedColumnModel.hidden).toBe(true);
 
     await actionLinkageRules.handler(ctx, { value: [] });
     expect(hostModel.hidden).toBe(false);
     expect(sameTargetModel.hidden).toBe(false);
+    expect(nestedColumnModel.hidden).toBe(true);
   });
 });

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

@@ -728,6 +728,98 @@ describe('linkageSetFieldProps action', () => {
     expect(form.setFieldValue).not.toHaveBeenCalled();
   });
 
+  it('should not clear the parent field when a nested same-name field inherits the parent path', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (JSON.stringify(path) === JSON.stringify(['children', 'children'])) {
+          return [{ title: 'nested' }];
+        }
+        if (JSON.stringify(path) === JSON.stringify(['children'])) {
+          return [{ title: 'parent' }];
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'nested-children-field',
+      hidden: false,
+      context: {
+        form,
+        fieldPathArray: ['children'],
+      },
+      props: {
+        label: 'Children',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'children.children' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+    const ctx: any = {
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      model: {
+        context: { form },
+        subModels: {
+          grid: {
+            subModels: {
+              items: [fieldModel],
+            },
+          },
+        },
+      },
+      setFormValues,
+      getAction: (name: string) => (name === 'linkageSetFieldProps' ? linkageSetFieldProps : 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: 'linkageSetFieldProps',
+              params: {
+                value: {
+                  fields: ['nested-children-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['children', 'children'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(setFormValues).not.toHaveBeenCalledWith(
+      [{ path: ['children'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
   it('should keep hidden clear after same-round assignment for the same field', async () => {
     const formValues: { name?: string } = {};
     const setFormValues = vi.fn(async (patches: Array<{ path: Array<string | number>; value: string | undefined }>) => {

package/src/flow/actions/dateTimeFormat.tsx

@@ -11,13 +11,36 @@ import { css } from '@emotion/css';
 import { defineAction, tExpr } from '@nocobase/flow-engine';
 import { getPickerFormat } from '@nocobase/utils/client';
 import { DateFormatCom, ExpiresRadio } from '../components';
+import {
+  getDateTimeFormatCollectionField,
+  isDateOnlyCollectionField,
+  isTimeCollectionField,
+  resolveDateTimeDisplayProps,
+} from '../utils/dateTimeDisplayProps';
+
+const isTableColumnFieldSubModel = (model) => {
+  const parent = model?.parent;
+  return (
+    parent?.subModels?.field === model &&
+    (parent?.use === 'TableColumnModel' || parent?.constructor?.name === 'TableColumnModel')
+  );
+};
+
+const syncTableColumnDateTimeFormatProps = (ctx, props) => {
+  const model = ctx.model;
+  if (!isTableColumnFieldSubModel(model) || !model?.parent?.collectionField?.isAssociationField?.()) {
+    return;
+  }
+
+  model.parent.setProps(props);
+};
 
 export const dateTimeFormat = defineAction({
   title: tExpr('Date display format'),
   name: 'dateDisplayFormat',
   uiSchema: (ctx) => {
-    const { collectionField } = ctx.model.context as any;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
+    const collectionField = getDateTimeFormatCollectionField({ model: ctx.model });
+    const isTimeField = isTimeCollectionField(collectionField);
     const timeFormatField = {
       type: 'string',
       title: '{{t("Time format")}}',
@@ -43,7 +66,7 @@ export const dateTimeFormat = defineAction({
         (field) => {
           if (!isTimeField) {
             const { showTime, picker } = field.form.values || {};
-            field.hidden = !showTime || picker !== 'date';
+            field.hidden = isDateOnlyCollectionField(collectionField) || !showTime || picker !== 'date';
           }
         },
       ],
@@ -146,10 +169,11 @@ export const dateTimeFormat = defineAction({
             },
           },
           (field) => {
-            const { collectionField } = ctx.model.context as any;
+            const collectionField = getDateTimeFormatCollectionField({ model: ctx.model });
             const { picker } = field.form.values || {};
-            field.hidden = collectionField.type === 'dateOnly' || picker !== 'date';
-            if (picker !== 'date') {
+            const isDateOnlyField = isDateOnlyCollectionField(collectionField);
+            field.hidden = isDateOnlyField || picker !== 'date';
+            if (isDateOnlyField || picker !== 'date') {
               field.value = false;
             }
           },
@@ -159,34 +183,24 @@ export const dateTimeFormat = defineAction({
     };
   },
   defaultParams: (ctx: 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';
+    const { showTime, dateFormat, timeFormat, picker } = resolveDateTimeDisplayProps({
+      model: ctx.model,
+      withDefaults: true,
+    });
     return {
       picker: picker || 'date',
       dateFormat: dateFormat || 'YYYY-MM-DD',
-      timeFormat: timeFormat || (isTimeField ? format : undefined) || 'HH:mm:ss',
+      timeFormat: timeFormat || 'HH:mm:ss',
       showTime,
     };
   },
+  async beforeParamsSave(ctx: any, params) {
+    const props = resolveDateTimeDisplayProps({ model: ctx.model, params });
+    ctx.model.setProps(props);
+    syncTableColumnDateTimeFormatProps(ctx, props);
+    await ctx.model.save?.();
+  },
   handler(ctx: any, params) {
-    const { collectionField } = ctx.model.context as any;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
-    if (isTimeField) {
-      const timeFormat = params?.timeFormat || params?.format || 'HH:mm:ss';
-      ctx.model.setProps({
-        ...params,
-        timeFormat,
-        format: timeFormat,
-      });
-    } else {
-      ctx.model.setProps({
-        ...params,
-        format: params?.showTime ? `${params.dateFormat} ${params.timeFormat}` : params.dateFormat,
-      });
-    }
+    ctx.model.setProps(resolveDateTimeDisplayProps({ model: ctx.model, params }));
   },
 });

package/src/flow/actions/linkageRules.tsx

@@ -1948,6 +1948,21 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     >;
     return normalized.length ? normalized : null;
   };
+  const pathKeysEqual = (
+    a: Array<string | number> | null | undefined,
+    b: Array<string | number> | null | undefined,
+  ) => {
+    if (!a || !b) return false;
+    return namePathToPathKey(a) === namePathToPathKey(b);
+  };
+  const namePathEndsWith = (
+    namePath: Array<string | number> | null | undefined,
+    suffix: Array<string | number> | null | undefined,
+  ) => {
+    if (!namePath || !suffix || suffix.length > namePath.length) return false;
+    const offset = namePath.length - suffix.length;
+    return suffix.every((seg, index) => namePath[offset + index] === seg);
+  };
   const getFieldIndexEntries = (fieldIndex: any): Array<{ name: string; index: number }> => {
     if (!Array.isArray(fieldIndex)) return [];
     return fieldIndex
@@ -1996,17 +2011,35 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     return out;
   };
+  const getTrustedFieldPathArray = (
+    fieldPathArray: Array<string | number> | null,
+    targetPath: string | null,
+    fieldIndex: unknown,
+  ): Array<string | number> | null => {
+    if (!fieldPathArray || !targetPath) return null;
+
+    const targetNamePath = normalizeNamePathForKey(
+      parsePathString(targetPath).filter((seg) => typeof seg === 'string' || typeof seg === 'number'),
+    );
+    const resolvedTargetPath = normalizeNamePathForKey(resolveDynamicNamePath(targetPath, fieldIndex));
+    const indexedRelativePath = resolveIndexedRelativePath(targetPath, fieldIndex);
+
+    if (
+      pathKeysEqual(fieldPathArray, resolvedTargetPath) ||
+      pathKeysEqual(fieldPathArray, indexedRelativePath) ||
+      namePathEndsWith(fieldPathArray, targetNamePath)
+    ) {
+      return fieldPathArray;
+    }
+
+    return null;
+  };
   const getModelTargetPathForHiddenClear = (model: any): string | Array<string | number> | null => {
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
     const targetPath = getModelTargetPathForPatch(model);
-    if (fieldPathArray) {
-      const targetPathLastString = targetPath
-        ? ([...parsePathString(targetPath)].reverse().find((seg) => typeof seg === 'string') as string | undefined)
-        : undefined;
-      const fieldPathArrayLastString = [...fieldPathArray].reverse().find((seg) => typeof seg === 'string');
-      if (!targetPathLastString || targetPathLastString === fieldPathArrayLastString) {
-        return fieldPathArray;
-      }
+    const trustedFieldPathArray = getTrustedFieldPathArray(fieldPathArray, targetPath, model?.context?.fieldIndex);
+    if (trustedFieldPathArray) {
+      return trustedFieldPathArray;
     }
 
     if (!targetPath) return null;
@@ -2016,12 +2049,13 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const getModelTargetPathKeys = (model: any): Set<string> => {
     const keys = new Set<string>();
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
-    if (fieldPathArray) {
-      keys.add(namePathToPathKey(fieldPathArray));
+    const targetPath = getModelTargetPathForPatch(model);
+    const trustedFieldPathArray = getTrustedFieldPathArray(fieldPathArray, targetPath, model?.context?.fieldIndex);
+    if (trustedFieldPathArray) {
+      keys.add(namePathToPathKey(trustedFieldPathArray));
       return keys;
     }
 
-    const targetPath = getModelTargetPathForPatch(model);
     if (targetPath) {
       const fieldIndexEntries = getFieldIndexEntries(model?.context?.fieldIndex);
       if (!fieldIndexEntries.length) {

package/src/flow/admin-shell/admin-layout/HelpLite.tsx

@@ -70,9 +70,7 @@ const SettingsMenu: React.FC = () => {
         key: 'userManual',
         label: (
           <a
-            href={
-              isSimplifiedChinese ? 'https://v2.docs.nocobase.com/cn/guide/' : 'https://v2.docs.nocobase.com/guide/'
-            }
+            href={isSimplifiedChinese ? 'https://docs.nocobase.com/cn/guide/' : 'https://docs.nocobase.com/guide/'}
             target="_blank"
             rel="noreferrer"
           >