@nocobase/client-v2 2.1.0-beta.24 → 2.1.0-beta.26

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -314,7 +314,14 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
                   onSuccess: (values) => {
                     const collectionField = this.collection.getField(dataIndex);
                     record[dataIndex] = values[dataIndex];
-                    setNestedValue(this.resource.getData(), recordIndex, record);
+                    if (typeof recordIndex === 'number') {
+                      this.resource.setItem(recordIndex, record);
+                    } else {
+                      const nextData = _.cloneDeep(this.resource.getData());
+                      setNestedValue(nextData, recordIndex, record);
+                      this.resource.setData(nextData);
+                    }
+                    this.resource.emit('refresh');
                     // 仅重渲染单元格
                     const fork: ForkFlowModel = model.subModels.field.createFork({}, `${recordIndex}`);
                     // Provide expandable meta for current row record based on the collection in context

package/src/flow/models/blocks/table/TableColumnModel.tsx

@@ -313,6 +313,7 @@ export class TableColumnModel extends DisplayItemModel {
             ? this.fieldPath.replace(`${this.context.prefixFieldPath}.`, '')
             : this.fieldPath;
           const value = get(record, namePath);
+          fork.setProps({ value });
           return (
             <FormItem key={field.uid} {...omit(this.props, 'title')} value={value} noStyle={true}>
               <FieldModelRenderer model={fork} />

package/src/flow/models/blocks/table/__tests__/JSColumnModel.test.tsx

@@ -0,0 +1,51 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { FlowEngine } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+import { JSColumnModel } from '../JSColumnModel';
+
+describe('JSColumnModel row refresh', () => {
+  it('changes renderer key and invalidates beforeRender cache when row content changes', () => {
+    const engine = new FlowEngine();
+    const model = new JSColumnModel({
+      uid: 'js-column-row-refresh',
+      flowEngine: engine,
+      props: {
+        width: 200,
+        title: 'JS column',
+      },
+    } as any);
+
+    engine.context.dataSourceManager.getDataSource('main').addCollection({
+      name: 'users',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'age', type: 'integer', interface: 'integer' },
+        { name: 'workyears', type: 'float', interface: 'number' },
+      ],
+    });
+
+    const collection = engine.context.dataSourceManager.getCollection('main', 'users');
+    model.context.defineProperty('collection', {
+      value: collection,
+    });
+
+    const column = model.getColumnProps();
+    const first = column.render(null, { id: 1, age: 3, workyears: 39.2 }, 0) as any;
+    const fork = model.getFork('1') as any;
+    const invalidateFlowCache = vi.fn();
+    fork.invalidateFlowCache = invalidateFlowCache;
+    const second = column.render(null, { id: 1, age: 37, workyears: 39.2 }, 0) as any;
+
+    expect(first.key).not.toBe(second.key);
+    expect(invalidateFlowCache).toHaveBeenCalledWith('beforeRender');
+  });
+});

package/src/flow/models/blocks/table/__tests__/TableBlockModel.quickEditRefresh.test.ts

@@ -0,0 +1,49 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+
+describe('TableBlockModel quick edit refresh', () => {
+  it('updates table data through a new array reference after quick editing a flat row', () => {
+    const engine = new FlowEngine();
+    const resource = engine.context.createResource(MultiRecordResource);
+    const original = [
+      { id: 1, title: 'old title', status: 'draft' },
+      { id: 2, title: 'other title', status: 'published' },
+    ];
+
+    resource.setData(original);
+    const before = resource.getData();
+    const editedRecord = { ...before[0], title: 'new title' };
+
+    resource.setItem(0, editedRecord);
+
+    expect(resource.getData()).not.toBe(before);
+    expect(resource.getData()[0]).toEqual(editedRecord);
+    expect(resource.getData()[1]).toEqual(original[1]);
+  });
+
+  it('notifies mounted JS fields after quick editing local table data', () => {
+    const engine = new FlowEngine();
+    const resource = engine.context.createResource(MultiRecordResource);
+    const original = [{ id: 1, title: 'old title', status: 'draft' }];
+    let refreshCount = 0;
+    resource.on('refresh', () => {
+      refreshCount += 1;
+    });
+
+    resource.setData(original);
+    const editedRecord = { ...resource.getData()[0], title: 'new title' };
+    resource.setItem(0, editedRecord);
+    resource.emit('refresh');
+
+    expect(refreshCount).toBe(1);
+  });
+});

package/src/flow/models/fields/AssociationFieldModel/RecordSelectFieldModel.tsx

@@ -38,7 +38,8 @@ import {
 import { MobileLazySelect } from '../mobile-components/MobileLazySelect';
 import { BlockSceneEnum } from '../../base/BlockModel';
 import { ActionWithoutPermission } from '../../base/ActionModel';
-import { EditFormModel } from '../../blocks/form/EditFormModel';
+import { EditFormModel } from '../../blocks';
+import { hasAncestorModel } from './recordSelectSettingsUtils';
 
 function isPlainObject(val: unknown): val is Record<string, any> {
   return !!val && typeof val === 'object' && !Array.isArray(val);
@@ -818,6 +819,9 @@ RecordSelectFieldModel.registerFlow({
         if (ctx?.blockModel?.constructor?.scene === BlockSceneEnum.filter) {
           return true;
         }
+        if (hasAncestorModel(ctx?.model, ['SubTableColumnModel', 'SubTableFieldModel'])) {
+          return true;
+        }
         return false;
       },
       defaultParams: {

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableColumnModel.tsx

@@ -194,7 +194,7 @@ function shouldCommitImmediately(value: any) {
 }
 
 const FieldModelRendererOptimize = React.memo((props: any) => {
-  const { model, onChange, value, ...rest } = props;
+  const { model, onChange, value, commitOnChange, ...rest } = props;
   const pendingValueRef = React.useRef<any>(props?.value);
 
   useEffect(() => {
@@ -204,11 +204,11 @@ const FieldModelRendererOptimize = React.memo((props: any) => {
   const handleChange = React.useCallback(
     (value: any) => {
       pendingValueRef.current = value;
-      if (shouldCommitImmediately(value)) {
+      if (commitOnChange || shouldCommitImmediately(value)) {
         onChange?.(value);
       }
     },
-    [onChange],
+    [commitOnChange, onChange],
   );
 
   const handleCommit = React.useCallback(() => {
@@ -241,10 +241,11 @@ interface CellProps {
   rowFork?: any;
   memoKey?: string;
   width?: number;
+  commitOnChange?: boolean;
 }
 
 const MemoCell: React.FC<CellProps> = React.memo(
-  ({ value, record, rowIdx, id, parent, parentFieldIndex, rowFork, width }) => {
+  ({ value, record, rowIdx, id, parent, parentFieldIndex, rowFork, width, commitOnChange }) => {
     const isNew = record?.__is_new__;
     return (
       <div
@@ -346,7 +347,11 @@ const MemoCell: React.FC<CellProps> = React.memo(
                   }
                 />
               ) : (
-                <FieldModelRendererOptimize model={fork} id={[(parent as any).context.fieldPath, rowIdx]} />
+                <FieldModelRendererOptimize
+                  model={fork}
+                  id={[(parent as any).context.fieldPath, rowIdx]}
+                  commitOnChange={commitOnChange}
+                />
               )}
             </FormItem>
           );
@@ -360,6 +365,7 @@ const MemoCell: React.FC<CellProps> = React.memo(
       prev.id === next.id &&
       prev.memoKey === next.memoKey &&
       prev.width === next.width &&
+      prev.commitOnChange === next.commitOnChange &&
       prev.rowIdx === next.rowIdx
     );
   },
@@ -428,6 +434,15 @@ export class SubTableColumnModel<
     return this.parent.collection;
   }
 
+  get hasFormulaColumn() {
+    return (
+      this.parent?.mapSubModels('columns', (column: SubTableColumnModel) => {
+        const field = column.collectionField;
+        return field?.interface === 'formula' || field?.type === 'formula';
+      }) || []
+    ).some(Boolean);
+  }
+
   onInit(options: any): void {
     super.onInit(options);
     this.context.defineProperty('resourceName', {
@@ -607,6 +622,7 @@ export class SubTableColumnModel<
           rowFork={rowFork}
           memoKey={rowForkKey}
           width={this.props.width}
+          commitOnChange={this.hasFormulaColumn}
         />
       );
     };

package/src/flow/models/fields/AssociationFieldModel/recordSelectSettingsUtils.ts

@@ -0,0 +1,20 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export function hasAncestorModel(model: any, modelNames: string[]) {
+  let cursor = model;
+  while (cursor) {
+    const modelName = cursor?.constructor?.name;
+    if (modelName && modelNames.includes(modelName)) {
+      return true;
+    }
+    cursor = cursor?.parent;
+  }
+  return false;
+}

package/src/flow/models/fields/JSFieldModel.tsx

@@ -8,7 +8,7 @@
  */
 
 import { ElementProxy, tExpr, createSafeWindow, createSafeDocument, createSafeNavigator } from '@nocobase/flow-engine';
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect } from 'react';
 import { FieldModel } from '../base/FieldModel';
 import { resolveRunJsParams } from '../utils/resolveRunJsParams';
 import { CodeEditor } from '../../components/code-editor';
@@ -41,6 +41,10 @@ ctx.render(<JsReadonlyField />);
  */
 export class JSFieldModel extends FieldModel {
   private _mountedOnce = false; // prevent first-mount double-run
+  private _lastRenderedElement?: HTMLSpanElement | null;
+  private _pendingRenderedElement?: HTMLSpanElement | null;
+  private _lastRunJs?: { code: string; value: any; element: HTMLSpanElement | null };
+
   getInputArgs() {
     const field = this.context.collectionField;
     if (field?.isAssociationField?.()) {
@@ -75,19 +79,10 @@ export class JSFieldModel extends FieldModel {
    * 说明：fork 实例在表格逐行渲染时会复用该逻辑，确保按值更新。
    */
   useHooksBeforeRender() {
-    // 单一副作用：当 code 或 value 变化，且二者都已就绪时执行一次
-    // 通过记忆上次运行的输入，避免相同输入导致的重复执行
     const codeParam = this.getStepParams('jsSettings', 'runJs')?.code as string | undefined;
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    const lastRunRef = useRef<{ code: string; value: any } | null>(null);
-    // eslint-disable-next-line react-hooks/rules-of-hooks
     useEffect(() => {
-      const valueNow = this.props.value;
-      const codeNow = (typeof codeParam === 'string' && codeParam.trim().length ? codeParam : DEFAULT_CODE).trim();
-      const last = lastRunRef.current;
-      if (last && last.code === codeNow && last.value === valueNow) return;
-      lastRunRef.current = { code: codeNow, value: valueNow };
-      this.applyFlow('jsSettings');
+      this.refreshRenderedElement(this.context.ref?.current as HTMLSpanElement | null);
       // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [codeParam, this.props.value]);
   }
@@ -95,8 +90,52 @@ export class JSFieldModel extends FieldModel {
   /**
    * 渲染一个占位容器，供 JS 脚本写入内容
    */
+  private getRunJsCode() {
+    const codeParam = this.getStepParams('jsSettings', 'runJs')?.code as string | undefined;
+    return (typeof codeParam === 'string' && codeParam.trim().length ? codeParam : DEFAULT_CODE).trim();
+  }
+
+  private refreshRenderedElement(element: HTMLSpanElement | null) {
+    if (!element || this._pendingRenderedElement === element) {
+      return;
+    }
+
+    this._pendingRenderedElement = element;
+    const ref = this.context.ref as React.MutableRefObject<HTMLSpanElement | null>;
+
+    queueMicrotask(() => {
+      if (this._pendingRenderedElement === element) {
+        this._pendingRenderedElement = null;
+      }
+      if (ref.current !== element) {
+        return;
+      }
+      const code = this.getRunJsCode();
+      const value = this.props.value;
+      const last = this._lastRunJs;
+      if (last && last.element === element && last.code === code && Object.is(last.value, value)) {
+        return;
+      }
+      this._lastRunJs = { code, value, element };
+      void this.applyFlow('jsSettings');
+    });
+  }
+
   render() {
-    return <span ref={this.context.ref} style={{ display: 'inline-block', maxWidth: '100%' }} />;
+    const ref = this.context.ref as React.MutableRefObject<HTMLSpanElement | null>;
+    const assignRef = (element: HTMLSpanElement | null) => {
+      ref.current = element;
+      if (!element) {
+        return;
+      }
+
+      const elementChanged = this._lastRenderedElement && this._lastRenderedElement !== element;
+      this._lastRenderedElement = element;
+      if (elementChanged || !this._mountedOnce) {
+        this.refreshRenderedElement(element);
+      }
+    };
+    return <span ref={assignRef} style={{ display: 'inline-block', maxWidth: '100%' }} />;
   }
 
   /**
@@ -106,7 +145,7 @@ export class JSFieldModel extends FieldModel {
   protected onMount() {
     if (this._mountedOnce) {
       if (this.context.ref?.current) {
-        this.rerender();
+        this.refreshRenderedElement(this.context.ref.current as HTMLSpanElement);
       }
     }
     this._mountedOnce = true;
@@ -165,7 +204,8 @@ JSFieldModel.registerFlow({
         // 暴露 element 与 value 到运行上下文
         ctx.onRefReady(ctx.ref, async (element) => {
           ctx.defineProperty('element', {
-            get: () => new ElementProxy(element),
+            get: () => new ElementProxy((ctx.ref?.current as HTMLElement | null) || element),
+            cache: false,
           });
           ctx.defineProperty('value', {
             get: () => ctx.model.props?.value,

package/src/flow/models/fields/mobile-components/MobileSelect.tsx

@@ -13,7 +13,7 @@ import { Button, CheckList, Popup, SearchBar } from 'antd-mobile';
 import React, { useEffect, useMemo, useState } from 'react';
 
 export function MobileSelect(props) {
-  const { value, onChange, disabled, options = [], mode } = props;
+  const { value, onChange, onChangeComplete, disabled, options = [], mode } = props;
   const ctx = useFlowModelContext();
   const t = ctx.t;
   const [visible, setVisible] = useState(false);
@@ -28,6 +28,7 @@ export function MobileSelect(props) {
 
   const handleConfirm = () => {
     onChange(selected);
+    onChangeComplete?.();
     setVisible(false);
   };
   useEffect(() => {
@@ -36,12 +37,18 @@ export function MobileSelect(props) {
     } else {
       setSearchText(null);
     }
-  }, [visible]);
+  }, [visible, value]);
 
   return (
     <>
       <div onClick={() => !disabled && setVisible(true)}>
-        <Select {...props} dropdownStyle={{ display: 'none' }} showSearch={false} />
+        <Select
+          {...props}
+          open={false}
+          dropdownStyle={{ display: 'none' }}
+          showSearch={false}
+          style={{ pointerEvents: 'none', width: '100%' }}
+        />
       </div>
       <Popup
         visible={visible}
@@ -71,6 +78,7 @@ export function MobileSelect(props) {
               } else {
                 setSelected(val[0]);
                 onChange(val[0]);
+                onChangeComplete?.();
                 setVisible(false);
               }
             }}

package/src/flow/models/fields/mobile-components/__tests__/MobileSelect.test.tsx

@@ -0,0 +1,235 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import React from 'react';
+import { beforeEach, describe, it, expect, vi } from 'vitest';
+import { act, fireEvent, render, screen } from '@nocobase/test/client';
+import { MobileSelect } from '../MobileSelect';
+
+const DEFAULT_OPTIONS = [
+  { label: 'Option A', value: 'a' },
+  { label: 'Option B', value: 'b' },
+];
+
+const mockState = vi.hoisted(() => ({
+  selectProps: undefined as any,
+  popupProps: undefined as any,
+  checklistProps: undefined as any,
+  confirmButtonProps: undefined as any,
+}));
+
+function resetMockState() {
+  mockState.selectProps = undefined;
+  mockState.popupProps = undefined;
+  mockState.checklistProps = undefined;
+  mockState.confirmButtonProps = undefined;
+}
+
+function clickTrigger() {
+  const trigger = screen.getByTestId('antd-select').parentElement as HTMLElement | null;
+  expect(trigger).toBeTruthy();
+  act(() => {
+    fireEvent.click(trigger as HTMLElement);
+  });
+}
+
+function openPopup() {
+  clickTrigger();
+  expect(screen.getByTestId('popup')).toBeInTheDocument();
+}
+
+function selectValues(values: string[]) {
+  act(() => {
+    mockState.checklistProps?.onChange?.(values);
+  });
+}
+
+function confirmSelection() {
+  act(() => {
+    mockState.confirmButtonProps?.onClick?.();
+  });
+}
+
+function renderMobileSelect(props: Record<string, any> = {}) {
+  const onChange = props.onChange ?? vi.fn();
+  const onChangeComplete = props.onChangeComplete ?? vi.fn();
+
+  render(
+    <MobileSelect
+      value={undefined}
+      options={DEFAULT_OPTIONS}
+      onChange={onChange}
+      onChangeComplete={onChangeComplete}
+      {...props}
+    />,
+  );
+
+  return { onChange, onChangeComplete };
+}
+
+vi.mock('@nocobase/flow-engine', async () => {
+  const actual = await vi.importActual<any>('@nocobase/flow-engine');
+  return {
+    ...actual,
+    useFlowModelContext: () => ({
+      t: (value: string) => value,
+    }),
+  };
+});
+
+vi.mock('antd', async () => {
+  const actual = await vi.importActual<any>('antd');
+  return {
+    ...actual,
+    Select: (props: any) => {
+      mockState.selectProps = props;
+      return <div data-testid="antd-select" />;
+    },
+  };
+});
+
+vi.mock('antd-mobile', () => {
+  const MockCheckList: any = (props: any) => {
+    mockState.checklistProps = props;
+    return <div data-testid="checklist">{props.children}</div>;
+  };
+
+  MockCheckList.Item = ({ value, children }: any) => <div data-testid={`item-${value}`}>{children}</div>;
+
+  return {
+    Button: (props: any) => {
+      mockState.confirmButtonProps = props;
+      return (
+        <button type="button" data-testid="confirm" onClick={props.onClick}>
+          {props.children}
+        </button>
+      );
+    },
+    Popup: (props: any) => {
+      mockState.popupProps = props;
+      return props.visible ? <div data-testid="popup">{props.children}</div> : null;
+    },
+    SearchBar: ({ value, onChange }: any) => (
+      <input data-testid="search" value={value ?? ''} onChange={(e) => onChange?.(e.target.value)} />
+    ),
+    CheckList: MockCheckList,
+  };
+});
+
+describe('MobileSelect', () => {
+  beforeEach(() => {
+    resetMockState();
+  });
+
+  it('commits the selected value immediately in single mode', () => {
+    const { onChange, onChangeComplete } = renderMobileSelect();
+
+    openPopup();
+    selectValues(['a']);
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith('a');
+    expect(onChangeComplete).toHaveBeenCalledTimes(1);
+    expect(screen.queryByTestId('popup')).not.toBeInTheDocument();
+  });
+
+  it('renders filtered options based on search text', () => {
+    const { onChange, onChangeComplete } = renderMobileSelect();
+    openPopup();
+    act(() => {
+      fireEvent.change(screen.getByTestId('search'), { target: { value: 'Option A' } });
+    });
+
+    expect(screen.getByTestId('item-a')).toBeInTheDocument();
+    expect(screen.queryByTestId('item-b')).not.toBeInTheDocument();
+
+    selectValues(['a']);
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith('a');
+    expect(onChangeComplete).toHaveBeenCalledTimes(1);
+  });
+
+  it('defers commit until confirm in multiple mode', () => {
+    const { onChange, onChangeComplete } = renderMobileSelect({ value: [], mode: 'multiple' });
+    openPopup();
+
+    selectValues(['a', 'b']);
+    expect(onChange).not.toHaveBeenCalled();
+    expect(onChangeComplete).not.toHaveBeenCalled();
+
+    confirmSelection();
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith(['a', 'b']);
+    expect(onChangeComplete).toHaveBeenCalledTimes(1);
+    expect(screen.queryByTestId('popup')).not.toBeInTheDocument();
+  });
+
+  it('does not open popup when disabled', () => {
+    renderMobileSelect({ disabled: true });
+
+    clickTrigger();
+    expect(screen.queryByTestId('popup')).not.toBeInTheDocument();
+  });
+});
+
+function SubTableCellHarness({ value, onCommit, mode }: { value: any; onCommit: (value: any) => void; mode?: string }) {
+  const pendingValueRef = React.useRef<any>(value);
+  return (
+    <div>
+      <MobileSelect
+        value={value}
+        mode={mode}
+        options={DEFAULT_OPTIONS}
+        onChange={(next) => {
+          pendingValueRef.current = next;
+          if (Array.isArray(next)) {
+            onCommit(next);
+          }
+        }}
+        onChangeComplete={() => {
+          onCommit(pendingValueRef.current);
+        }}
+      />
+    </div>
+  );
+}
+
+describe('MobileSelect in SubForm/SubTable containers', () => {
+  beforeEach(() => {
+    resetMockState();
+  });
+
+  it('SubTable: single selection commits final value via onChangeComplete', () => {
+    const onCommit = vi.fn();
+
+    render(<SubTableCellHarness value={undefined} onCommit={onCommit} />);
+
+    openPopup();
+    selectValues(['b']);
+
+    expect(onCommit).toHaveBeenCalledTimes(1);
+    expect(onCommit).toHaveBeenCalledWith('b');
+  });
+
+  it('SubTable: multiple mode only commits after confirm, and commit receives the full array', () => {
+    const onCommit = vi.fn();
+
+    render(<SubTableCellHarness value={[]} onCommit={onCommit} mode="multiple" />);
+
+    openPopup();
+    selectValues(['a', 'b']);
+    confirmSelection();
+
+    expect(onCommit).toHaveBeenCalledTimes(2);
+    expect(onCommit).toHaveBeenNthCalledWith(1, ['a', 'b']);
+    expect(onCommit).toHaveBeenNthCalledWith(2, ['a', 'b']);
+  });
+});

package/src/index.ts

@@ -32,4 +32,5 @@ export * from './collection-field-interface/CollectionFieldInterface';
 export * from './collection-field-interface/CollectionFieldInterfaceManager';
 export * from './collection-manager/interfaces';
 export * from './flow';
+export { DEFAULT_DATA_SOURCE_KEY, isTitleField } from './flow-compat';
 export { default as AntdAppProvider } from './theme/AntdAppProvider';

package/src/utils/globalDeps.ts

@@ -9,14 +9,18 @@
 
 import * as antdCssinjs from '@ant-design/cssinjs';
 import * as antdIcons from '@ant-design/icons';
+import * as emotionCss from '@emotion/css';
 import * as formilyCore from '@formily/core';
 import * as formilyReact from '@formily/react';
 import * as formilyReactive from '@formily/reactive';
 import * as formilyShared from '@formily/shared';
 import * as nocobaseClientUtils from '@nocobase/utils/client';
+import { dayjs } from '@nocobase/utils/client';
 import * as nocobaseFlowEngine from '@nocobase/flow-engine';
+import * as ahooks from 'ahooks';
 import * as antd from 'antd';
 import * as i18next from 'i18next';
+import lodash from 'lodash';
 import React from 'react';
 import ReactDOM from 'react-dom';
 import * as reactI18next from 'react-i18next';
@@ -61,4 +65,10 @@ export function defineGlobalDeps(requirejs: RequireJS) {
   requirejs.define('@nocobase/client-v2', () => nocobaseClientV2);
   requirejs.define('@nocobase/client-v2/client-v2', () => nocobaseClientV2);
   requirejs.define('@nocobase/flow-engine', () => nocobaseFlowEngine);
+
+  // utils
+  requirejs.define('ahooks', () => ahooks);
+  requirejs.define('dayjs', () => dayjs);
+  requirejs.define('lodash', () => lodash);
+  requirejs.define('@emotion/css', () => emotionCss);
 }