@nocobase/client-v2 2.2.0-beta.2 → 2.2.0-beta.5

package/src/flow/actions/__tests__/subFormFieldLinkageRules.inputArgs.test.ts

@@ -13,7 +13,7 @@ import { subFormFieldLinkageRules } from '../linkageRules';
 import { SubFormFieldModel, SubFormListFieldModel } from '../../models/fields/AssociationFieldModel/SubFormFieldModel';
 
 describe('subFormFieldLinkageRules action', () => {
-  it('passes inputArgs to fork runtime context', async () => {
+  it('passes inputArgs to fork runtime context when grid forks are stored in a Set', async () => {
     const linkageAssignHandler = vi.fn();
     const engine = new FlowEngine();
     const forkModel = new FlowModel({ uid: 'fork-model', flowEngine: engine }) as any;
@@ -38,7 +38,7 @@ describe('subFormFieldLinkageRules action', () => {
         hidden: false,
         subModels: {
           grid: {
-            forks: [forkModel],
+            forks: new Set([forkModel]),
           },
         },
       },

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

@@ -2842,7 +2842,7 @@ export const subFormFieldLinkageRules = defineAction({
       }
     } else {
       await Promise.all(
-        (grid.forks || []).map(async (forkModel: FlowModel) => {
+        Array.from(grid.forks || []).map(async (forkModel: FlowModel) => {
           if (forkModel.hidden) {
             return;
           }

package/src/flow/actions/linkageRulesFormValueRefresh.ts

@@ -15,17 +15,29 @@ import {
   isRunJSValue,
 } from '@nocobase/flow-engine';
 import _ from 'lodash';
-import { namePathToPathKey, parsePathString, pathKeyToNamePath } from '../models/blocks/form/value-runtime/path';
+import { namePathToPathKey } from '../models/blocks/form/value-runtime/path';
 import {
   collectStaticDepsFromRunJSValue,
   collectStaticDepsFromTemplateValue,
   recordDep,
   type DepCollector,
 } from '../models/blocks/form/value-runtime/deps';
+import {
+  buildItemListRootPath,
+  buildItemRowPath,
+  dedupeNamePaths,
+  findFormValueChangeSource,
+  getChangedPathsFromPayload,
+  getFieldIndexEntriesFromContext,
+  isNamePathPrefix,
+  isSameNamePath,
+  minimizeNamePaths,
+  parseDependencyPath,
+  parsePathKey,
+  type NamePath,
+} from '../utils/formValueDeps';
 import { linkageRulesRefresh } from './linkageRulesRefresh';
 
-type NamePath = Array<string | number>;
-
 type LinkageRefreshDeps = {
   wildcard: boolean;
   valuePaths: NamePath[];
@@ -40,75 +52,11 @@ type LinkageRefreshBinding = {
   dispose: () => void;
 };
 
-type FieldIndexEntry = {
-  name: string;
-  index: number;
-};
-
 const FORM_VALUES_CHANGE_EVENT = 'formValuesChange';
 const LINKAGE_REFRESH_BINDINGS_KEY = '__formValueDrivenLinkageRefreshBindings';
 
-function isSameNamePath(a: NamePath, b: NamePath) {
-  return a.length === b.length && a.every((seg, index) => seg === b[index]);
-}
-
-function isNamePathPrefix(prefix: NamePath, path: NamePath) {
-  if (prefix.length > path.length) return false;
-  return prefix.every((seg, index) => seg === path[index]);
-}
-
-function dedupeNamePaths(paths: NamePath[]) {
-  const byKey = new Map<string, NamePath>();
-  for (const path of paths) {
-    if (!path?.length) continue;
-    byKey.set(namePathToPathKey(path), path);
-  }
-  return Array.from(byKey.values());
-}
-
-function minimizeValueNamePaths(paths: NamePath[]) {
-  const deduped = dedupeNamePaths(paths);
-  return deduped.filter((path, index) => {
-    return !deduped.some((other, otherIndex) => otherIndex !== index && isNamePathPrefix(path, other));
-  });
-}
-
-function parseFieldIndexEntries(fieldIndex: unknown): FieldIndexEntry[] {
-  const arr = Array.isArray(fieldIndex) ? fieldIndex : [];
-  const entries: FieldIndexEntry[] = [];
-  for (const it of arr) {
-    if (typeof it !== 'string') continue;
-    const [name, indexStr] = it.split(':');
-    const index = Number(indexStr);
-    if (!name || Number.isNaN(index)) continue;
-    entries.push({ name, index });
-  }
-  return entries;
-}
-
-function getFieldIndexEntriesFromContext(ctx: any): FieldIndexEntry[] {
-  return parseFieldIndexEntries(ctx?.model?.context?.fieldIndex ?? ctx?.fieldIndex);
-}
-
-function buildItemRowPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
-  const targetIndex = entries.length - 1 - parentDepth;
-  if (targetIndex < 0) return null;
-
-  const out: NamePath = [];
-  for (let i = 0; i <= targetIndex; i++) {
-    out.push(entries[i].name, entries[i].index);
-  }
-  return out;
-}
-
-function buildItemListRootPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
-  const rowPath = buildItemRowPath(entries, parentDepth);
-  if (!rowPath?.length) return null;
-  return rowPath.slice(0, -1);
-}
-
 function resolveItemDependencyPath(ctx: FlowContext, depPath: NamePath): LinkageRefreshDeps {
-  const entries = getFieldIndexEntriesFromContext(ctx as any);
+  const entries = getFieldIndexEntriesFromContext(ctx);
   if (!entries.length) {
     return { wildcard: true, valuePaths: [], structuralPaths: [] };
   }
@@ -171,8 +119,7 @@ function addRunjsUsageToCollector(script: string, collector: DepCollector) {
           collector.wildcard = true;
           continue;
         }
-        const segs = parsePathString(String(subPath)).filter((seg) => typeof seg !== 'object') as NamePath;
-        recordDep(segs, collector);
+        recordDep(parseDependencyPath(String(subPath)), collector);
         continue;
       }
       if (varName === 'item') {
@@ -233,13 +180,13 @@ function collectLinkageRefreshDeps(ctx: FlowContext, params: any): LinkageRefres
         wildcard = true;
         continue;
       }
-      valuePaths.push(pathKeyToNamePath(inner));
+      valuePaths.push(parsePathKey(inner));
       continue;
     }
 
     if (depKey === 'ctx:item' || depKey.startsWith('ctx:item:')) {
       const subPath = depKey === 'ctx:item' ? '' : depKey.slice('ctx:item:'.length);
-      const depPath = subPath ? (parsePathString(subPath).filter((seg) => typeof seg !== 'object') as NamePath) : [];
+      const depPath = subPath ? parseDependencyPath(subPath) : [];
       const resolved = resolveItemDependencyPath(ctx, depPath);
       wildcard ||= resolved.wildcard;
       valuePaths.push(...resolved.valuePaths);
@@ -249,7 +196,7 @@ function collectLinkageRefreshDeps(ctx: FlowContext, params: any): LinkageRefres
 
   return {
     wildcard,
-    valuePaths: minimizeValueNamePaths(valuePaths),
+    valuePaths: minimizeNamePaths(valuePaths),
     structuralPaths: dedupeNamePaths(structuralPaths),
   };
 }
@@ -258,44 +205,9 @@ function hasLinkageRefreshDeps(deps: LinkageRefreshDeps) {
   return deps.wildcard || deps.valuePaths.length > 0 || deps.structuralPaths.length > 0;
 }
 
-function getChangedPathsFromPayload(payload: any): NamePath[] {
-  const rawChangedPaths = Array.isArray(payload?.changedPaths) ? payload.changedPaths : [];
-  const out: NamePath[] = [];
-
-  for (const path of rawChangedPaths) {
-    if (Array.isArray(path)) {
-      if (path.length === 1 && typeof path[0] === 'string') {
-        const namePath = pathKeyToNamePath(path[0]);
-        if (namePath.length) out.push(namePath);
-        continue;
-      }
-      const segs = path.filter((seg) => typeof seg === 'string' || typeof seg === 'number') as NamePath;
-      if (segs.length) out.push(segs);
-      continue;
-    }
-    if (typeof path === 'string' && path) {
-      out.push(pathKeyToNamePath(path));
-    }
-  }
-
-  if (out.length) {
-    return out;
-  }
-
-  const changedValues = payload?.changedValues;
-  if (changedValues && typeof changedValues === 'object') {
-    for (const key of Object.keys(changedValues)) {
-      const namePath = pathKeyToNamePath(key);
-      if (namePath.length) out.push(namePath);
-    }
-  }
-
-  return out;
-}
-
 function linkageRefreshDepsMatchPayload(deps: LinkageRefreshDeps, payload: any) {
   if (!hasLinkageRefreshDeps(deps)) return false;
-  const changedPaths = getChangedPathsFromPayload(payload);
+  const changedPaths = getChangedPathsFromPayload(payload, { includeArrayChangedValues: true });
   if (deps.wildcard) return true;
   if (!changedPaths.length) return true;
 
@@ -330,28 +242,8 @@ function getLinkageRefreshBindings(model: any): Map<string, LinkageRefreshBindin
   return (model[LINKAGE_REFRESH_BINDINGS_KEY] ||= new Map<string, LinkageRefreshBinding>());
 }
 
-function isFormBlockForLinkageRefresh(model: any) {
-  if (!model || typeof model !== 'object') return false;
-  if (!model.emitter || typeof model.emitter.on !== 'function' || typeof model.emitter.off !== 'function') return false;
-  return !!model.formValueRuntime || !!model.context?.form || typeof model.context?.setFormValues === 'function';
-}
-
 function findFormBlockForLinkageRefresh(ctx: FlowContext): any | null {
-  const candidates: any[] = [];
-  const push = (model: any) => {
-    if (model && !candidates.includes(model)) candidates.push(model);
-  };
-
-  push((ctx.model as any)?.context?.blockModel);
-  push(ctx.model);
-
-  let cursor: any = (ctx.model as any)?.parent;
-  while (cursor) {
-    push(cursor);
-    cursor = cursor?.parent;
-  }
-
-  return candidates.find(isFormBlockForLinkageRefresh) || null;
+  return findFormValueChangeSource(ctx) as any;
 }
 
 function disposeLinkageRefreshBinding(model: any, key: string) {

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"
           >