@nocobase/flow-engine 2.1.0-beta.22 → 2.1.0-beta.23

package/lib/data-source/index.js

@@ -53,12 +53,47 @@ var import_sortCollectionsByInherits = require("./sortCollectionsByInherits");
 const _DataSourceManager = class _DataSourceManager {
   dataSources;
   flowEngine;
+  requester;
+  collectionFieldInterfaceManager;
+  loaders = /* @__PURE__ */ new Map();
+  loadedKeys = /* @__PURE__ */ new Set();
+  loadingKeys = /* @__PURE__ */ new Set();
+  loadErrors = /* @__PURE__ */ new Map();
+  loadingPromise = null;
   constructor() {
     this.dataSources = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
   }
   setFlowEngine(flowEngine) {
     this.flowEngine = flowEngine;
   }
+  setRequester(requester) {
+    this.requester = requester;
+  }
+  setCollectionFieldInterfaceManager(manager) {
+    this.collectionFieldInterfaceManager = manager;
+  }
+  addFieldInterfaces(fieldInterfaceClasses = []) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaces) == null ? void 0 : _b.call(_a, fieldInterfaceClasses);
+  }
+  addFieldInterfaceGroups(groups) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceGroups) == null ? void 0 : _b.call(_a, groups);
+  }
+  addFieldInterfaceComponentOption(name, option) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceComponentOption) == null ? void 0 : _b.call(_a, name, option);
+  }
+  addFieldInterfaceOperator(name, operator) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceOperator) == null ? void 0 : _b.call(_a, name, operator);
+  }
+  registerLoader(key, loader) {
+    this.loaders.set(key, loader);
+  }
+  removeLoader(key) {
+    this.loaders.delete(key);
+  }
   addDataSource(ds) {
     if (this.dataSources.has(ds.key)) {
       throw new Error(`DataSource with name ${ds.key} already exists`);
@@ -75,7 +110,7 @@ const _DataSourceManager = class _DataSourceManager {
   upsertDataSource(ds) {
     var _a;
     if (this.dataSources.has(ds.key)) {
-      (_a = this.dataSources.get(ds.key)) == null ? void 0 : _a.setOptions(ds);
+      (_a = this.dataSources.get(ds.key)) == null ? void 0 : _a.patchOptions(ds);
     } else {
       this.addDataSource(ds);
     }
@@ -103,6 +138,144 @@ const _DataSourceManager = class _DataSourceManager {
     if (!ds) return void 0;
     return ds.getCollectionField(otherKeys.join("."));
   }
+  async ensureLoaded(options = {}) {
+    const { force = false } = options;
+    const keys = this.resolveLoadKeys(options.keys);
+    const pendingKeys = force ? keys : keys.filter((key) => !this.loadedKeys.has(key));
+    if (!pendingKeys.length) {
+      return;
+    }
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    this.loadingPromise = (async () => {
+      try {
+        for (const key of pendingKeys) {
+          await this.loadKey(key, { initial: !this.loadedKeys.has(key), force });
+        }
+      } finally {
+        this.loadingPromise = null;
+      }
+    })();
+    return this.loadingPromise;
+  }
+  async reload(options = {}) {
+    const keys = this.resolveLoadKeys(options.keys);
+    if (!keys.length) {
+      return;
+    }
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    this.loadingPromise = (async () => {
+      try {
+        for (const key of keys) {
+          await this.loadKey(key, { initial: false, force: true });
+        }
+      } finally {
+        this.loadingPromise = null;
+      }
+    })();
+    return this.loadingPromise;
+  }
+  async reloadDataSource(key) {
+    if (this.loadingKeys.has(key) && this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    if (!this.loaders.has(key) && this.loaders.has("*")) {
+      return this.reload({ keys: ["*"] });
+    }
+    return this.reload({ keys: [key] });
+  }
+  resolveLoadKeys(requestedKeys) {
+    const normalizedKeys = (requestedKeys == null ? void 0 : requestedKeys.length) ? requestedKeys : ["main"];
+    const explicitKeys = normalizedKeys.filter((key) => this.loaders.has(key));
+    if (this.loaders.has("*")) {
+      return import_lodash.default.uniq(["*", ...explicitKeys]);
+    }
+    return explicitKeys.length ? explicitKeys : normalizedKeys;
+  }
+  getApp() {
+    var _a, _b;
+    return (_b = (_a = this.flowEngine) == null ? void 0 : _a.context) == null ? void 0 : _b.app;
+  }
+  dispatchDataSourceEvent(type, detail) {
+    var _a, _b;
+    (_b = (_a = this.getApp()) == null ? void 0 : _a.eventBus) == null ? void 0 : _b.dispatchEvent(new CustomEvent(type, { detail }));
+  }
+  setDataSourceState(key, options) {
+    const dataSource = this.getDataSource(key);
+    if (!dataSource) {
+      return;
+    }
+    dataSource.patchOptions(options);
+  }
+  applyDataSourceLoadResult(key, result) {
+    if (key === "*") {
+      const dataSources = (result == null ? void 0 : result.dataSources) || [];
+      dataSources.forEach((dataSourceOptions) => {
+        var _a;
+        const { collections, ...dataSource2 } = dataSourceOptions;
+        this.upsertDataSource(dataSource2);
+        if (collections) {
+          (_a = this.getDataSource(dataSource2.key)) == null ? void 0 : _a.setCollections(collections, { clearFields: true });
+        }
+      });
+      return;
+    }
+    const dataSource = this.getDataSource(key);
+    if (!dataSource) {
+      return;
+    }
+    dataSource.setCollections((result == null ? void 0 : result.collections) || [], { clearFields: true });
+  }
+  async loadKey(key, options) {
+    const loader = this.loaders.get(key);
+    if (!loader) {
+      return;
+    }
+    if (!this.getDataSource(key) && key !== "*") {
+      this.addDataSource({ key });
+    }
+    const { initial } = options;
+    this.loadingKeys.add(key);
+    if (key !== "*") {
+      this.setDataSourceState(key, {
+        status: initial ? "loading" : "reloading",
+        errorMessage: void 0
+      });
+    }
+    this.loadErrors.set(key, null);
+    try {
+      const result = await loader({ key, manager: this }) || {};
+      this.applyDataSourceLoadResult(key, result);
+      this.loadedKeys.add(key);
+      if (key !== "*") {
+        this.setDataSourceState(key, {
+          status: "loaded",
+          errorMessage: void 0
+        });
+      }
+      this.dispatchDataSourceEvent("dataSource:loaded", { dataSourceKey: key, initial });
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      this.loadErrors.set(key, normalizedError);
+      if (key !== "*") {
+        this.setDataSourceState(key, {
+          status: initial ? "loading-failed" : "reloading-failed",
+          errorMessage: normalizedError.message
+        });
+      }
+      this.dispatchDataSourceEvent("dataSource:loadFailed", {
+        dataSourceKey: key,
+        initial,
+        error: normalizedError
+      });
+      throw normalizedError;
+    } finally {
+      this.loadingKeys.delete(key);
+    }
+  }
 };
 __name(_DataSourceManager, "DataSourceManager");
 let DataSourceManager = _DataSourceManager;
@@ -126,6 +299,12 @@ const _DataSource = class _DataSource {
   get name() {
     return this.options.key;
   }
+  get status() {
+    return this.options.status;
+  }
+  get errorMessage() {
+    return this.options.errorMessage;
+  }
   setDataSourceManager(dataSourceManager) {
     this.dataSourceManager = dataSourceManager;
   }
@@ -156,6 +335,9 @@ const _DataSource = class _DataSource {
   upsertCollections(collections, options = {}) {
     return this.collectionManager.upsertCollections(collections, options);
   }
+  setCollections(collections, options = {}) {
+    return this.collectionManager.setCollections(collections, options);
+  }
   removeCollection(name) {
     return this.collectionManager.removeCollection(name);
   }
@@ -166,6 +348,12 @@ const _DataSource = class _DataSource {
     Object.keys(this.options).forEach((key) => delete this.options[key]);
     Object.assign(this.options, newOptions);
   }
+  patchOptions(newOptions = {}) {
+    Object.assign(this.options, newOptions);
+  }
+  reload() {
+    return this.dataSourceManager.reloadDataSource(this.key);
+  }
   getCollectionField(fieldPath) {
     const [collectionName, ...otherKeys] = fieldPath.split(".");
     const fieldName = otherKeys.join(".");
@@ -190,6 +378,10 @@ const _CollectionManager = class _CollectionManager {
   collections;
   allCollectionsInheritChain;
   childrenCollectionsName = {};
+  resetCaches() {
+    this.childrenCollectionsName = {};
+    this.allCollectionsInheritChain = void 0;
+  }
   get flowEngine() {
     return this.dataSource.flowEngine;
   }
@@ -203,9 +395,11 @@ const _CollectionManager = class _CollectionManager {
     col.setDataSource(this.dataSource);
     col.initInherits();
     this.collections.set(col.name, col);
+    this.resetCaches();
   }
   removeCollection(name) {
     this.collections.delete(name);
+    this.resetCaches();
   }
   updateCollection(newOptions, options = {}) {
     const collection = this.getCollection(newOptions.name);
@@ -213,6 +407,7 @@ const _CollectionManager = class _CollectionManager {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
     collection.setOptions(newOptions, options);
+    this.resetCaches();
   }
   upsertCollection(options) {
     if (this.collections.has(options.name)) {
@@ -230,6 +425,11 @@ const _CollectionManager = class _CollectionManager {
         this.addCollection(collection);
       }
     }
+    this.resetCaches();
+  }
+  setCollections(collections, options = {}) {
+    this.clearCollections();
+    this.upsertCollections(collections, options);
   }
   sortCollectionsByInherits(collections) {
     const map = /* @__PURE__ */ new Map();
@@ -293,6 +493,7 @@ const _CollectionManager = class _CollectionManager {
   }
   clearCollections() {
     this.collections.clear();
+    this.resetCaches();
   }
   getAssociation(associationName) {
     const [collectionName, fieldName] = associationName.split(".");
@@ -493,6 +694,9 @@ const _Collection = class _Collection {
     }
     this.upsertFields(this.options.fields || []);
   }
+  setOption(key, value) {
+    this.options[key] = value;
+  }
   getFields() {
     const fieldMap = /* @__PURE__ */ new Map();
     for (const inherit of this.inherits.values()) {

package/lib/flowContext.d.ts

@@ -325,8 +325,10 @@ export declare class FlowContext {
     getPropertyOptions(key: string): PropertyOptions | undefined;
 }
 declare class BaseFlowEngineContext extends FlowContext {
+    t: (key: any, options?: any) => string;
     router: Router;
     dataSourceManager: DataSourceManager;
+    isDarkTheme: boolean;
     requireAsync: (url: string) => Promise<any>;
     importAsync: (url: string) => Promise<any>;
     createJSRunner: (options?: JSRunnerOptions) => Promise<JSRunner>;

package/lib/flowI18n.js

@@ -71,7 +71,8 @@ const _FlowI18n = class _FlowI18n {
   translateKey(key, options) {
     var _a, _b;
     if ((_b = (_a = this.context) == null ? void 0 : _a.i18n) == null ? void 0 : _b.t) {
-      return this.context.i18n.t(key, options);
+      const translated = this.context.i18n.t(key, options);
+      return translated == null || translated === "" ? key : translated;
     }
     return key;
   }

package/lib/models/DisplayItemModel.d.ts

@@ -6,7 +6,7 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
+import type { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 export declare class DisplayItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {
 }

package/lib/models/EditableItemModel.d.ts

@@ -6,7 +6,7 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
+import type { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 export declare class EditableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {
 }

package/lib/models/FilterableItemModel.d.ts

@@ -6,7 +6,7 @@
  * 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 { DefaultStructure } from '@nocobase/flow-engine';
+import type { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 export declare class FilterableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {
 }

package/lib/models/flowModel.d.ts

@@ -23,17 +23,19 @@ import type { ScheduleOptions } from '../scheduler/ModelOperationScheduler';
 import type { DispatchEventOptions, EventDefinition } from '../types';
 import { ForkFlowModel } from './forkFlowModel';
 type BaseMenuItem = NonNullable<MenuProps['items']>[number];
-type MenuLeafItem = Exclude<BaseMenuItem, {
-    children: MenuProps['items'];
-}>;
-export type FlowModelExtraMenuItem = Omit<MenuLeafItem, 'key'> & {
+type MenuBaseItem = Omit<Exclude<BaseMenuItem, null>, 'key' | 'children'>;
+export type FlowModelExtraMenuItem = MenuBaseItem & {
     key: React.Key;
     group?: string;
     sort?: number;
+    label?: React.ReactNode;
+    disabled?: boolean;
     onClick?: () => void;
+    children?: FlowModelExtraMenuItem[];
 };
-type FlowModelExtraMenuItemInput = Omit<FlowModelExtraMenuItem, 'key'> & {
+type FlowModelExtraMenuItemInput = Omit<FlowModelExtraMenuItem, 'key' | 'children'> & {
     key?: React.Key;
+    children?: FlowModelExtraMenuItemInput[];
 };
 type ExtraMenuItemEntry = {
     group?: string;
@@ -298,10 +300,10 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     removeParentDelegate(): void;
     addSubModel<T extends FlowModel>(subKey: string, options: CreateModelOptions | T): T;
     setSubModel(subKey: string, options: CreateModelOptions | FlowModel): FlowModel<DefaultStructure>;
-    filterSubModels<K extends keyof Structure['subModels'], R>(subKey: K, callback: (model: ArrayElementType<Structure['subModels'][K]>, index: number) => boolean): ArrayElementType<Structure['subModels'][K]>[];
-    mapSubModels<K extends keyof Structure['subModels'], R>(subKey: K, callback: (model: ArrayElementType<Structure['subModels'][K]>, index: number) => R): R[];
-    hasSubModel<K extends keyof Structure['subModels']>(subKey: K): boolean;
-    findSubModel<K extends keyof Structure['subModels'], R>(subKey: K, callback: (model: ArrayElementType<Structure['subModels'][K]>) => R): ArrayElementType<Structure['subModels'][K]> | null;
+    filterSubModels<K extends keyof NonNullable<Structure['subModels']>, R>(subKey: K, callback: (model: ArrayElementType<NonNullable<Structure['subModels']>[K]>, index: number) => boolean): ArrayElementType<NonNullable<Structure['subModels']>[K]>[];
+    mapSubModels<K extends keyof NonNullable<Structure['subModels']>, R>(subKey: K, callback: (model: ArrayElementType<NonNullable<Structure['subModels']>[K]>, index: number) => R): R[];
+    hasSubModel<K extends keyof NonNullable<Structure['subModels']>>(subKey: K): boolean;
+    findSubModel<K extends keyof NonNullable<Structure['subModels']>, R>(subKey: K, callback: (model: ArrayElementType<NonNullable<Structure['subModels']>[K]>) => R): ArrayElementType<NonNullable<Structure['subModels']>[K]> | null;
     createRootModel(options: any): FlowModel<DefaultStructure>;
     /**
      * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。

package/lib/models/flowModel.js

@@ -73,6 +73,41 @@ const classEventRegistries = /* @__PURE__ */ new WeakMap();
 const modelMetas = /* @__PURE__ */ new WeakMap();
 const modelGlobalRegistries = /* @__PURE__ */ new WeakMap();
 const classMenuExtensions = /* @__PURE__ */ new WeakMap();
+const sortExtraMenuItems = /* @__PURE__ */ __name((items) => {
+  return [...items].sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0));
+}, "sortExtraMenuItems");
+const isFlowModelExtraMenuItem = /* @__PURE__ */ __name((item) => {
+  return item !== null;
+}, "isFlowModelExtraMenuItem");
+const normalizeExtraMenuItem = /* @__PURE__ */ __name((item, {
+  group,
+  sort,
+  prefix,
+  path
+}) => {
+  if (!item) {
+    return null;
+  }
+  const normalizedGroup = item.group || group;
+  const normalizedSort = typeof item.sort === "number" ? item.sort : sort;
+  const normalizedChildren = sortExtraMenuItems(
+    (item.children || []).map(
+      (child, index) => normalizeExtraMenuItem(child, {
+        group: normalizedGroup,
+        sort: normalizedSort,
+        prefix,
+        path: `${path}-${index}`
+      })
+    ).filter(isFlowModelExtraMenuItem)
+  );
+  return {
+    ...item,
+    key: item.key ?? `${prefix}-${normalizedGroup}-${path}`,
+    group: normalizedGroup,
+    sort: normalizedSort,
+    children: normalizedChildren.length ? normalizedChildren : void 0
+  };
+}, "normalizeExtraMenuItem");
 async function loadOpenStepSettingsDialog() {
   const mod = await import("../components/settings/wrappers/contextual/StepSettingsDialog");
   return mod.openStepSettingsDialog;
@@ -1240,22 +1275,26 @@ const _FlowModel = class _FlowModel {
       seen.add(Cls);
       const reg = classMenuExtensions.get(Cls);
       if (reg) {
+        let entryIndex = 0;
         for (const entry of reg) {
           if (entry.matcher && !entry.matcher(model)) continue;
           const items = typeof entry.items === "function" ? await entry.items(model, t) : await Promise.resolve(entry.items || []);
           const group = entry.group || "common-actions";
           const sort = entry.sort ?? 0;
           const prefix = entry.keyPrefix || Cls.name || "extra";
-          (items || []).forEach((it, idx) => {
-            if (!it) return;
-            const key = it.key ?? `${prefix}-${group}-${idx}-${Math.random().toString(36).slice(2, 6)}`;
-            collected.push({
-              ...it,
-              key,
-              group: it.group || group,
-              sort: typeof it.sort === "number" ? it.sort : sort
-            });
+          sortExtraMenuItems(
+            (items || []).map(
+              (it, idx) => normalizeExtraMenuItem(it, {
+                group,
+                sort,
+                prefix,
+                path: `${entryIndex}-${idx}`
+              })
+            ).filter(isFlowModelExtraMenuItem)
+          ).forEach((it) => {
+            collected.push(it);
           });
+          entryIndex += 1;
         }
       }
       const ParentClass = Object.getPrototypeOf(Cls);

package/lib/provider.js

@@ -67,31 +67,46 @@ const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) =
   const engine = useFlowEngine();
   const config = (0, import_react.useContext)(import_antd.ConfigProvider.ConfigContext);
   const { token } = import_antd.theme.useToken();
-  (0, import_react.useEffect)(() => {
-    const context = {
-      antdConfig: config,
-      // themeToken 改为可观察的 getter，在下方单独 define
-      modal,
-      message,
-      notification
-    };
-    engine.context.defineProperty("viewer", {
-      cache: false,
-      get: /* @__PURE__ */ __name((ctx) => new import_FlowView.FlowViewer(ctx, { drawer, embed, popover, dialog }), "get")
-    });
-    for (const item of Object.entries(context)) {
-      const [key, value] = item;
-      if (value) {
-        engine.context.defineProperty(key, { value });
-      }
+  const isDarkTheme = import_react.default.useMemo(() => {
+    var _a2;
+    const algorithm = (_a2 = config == null ? void 0 : config.theme) == null ? void 0 : _a2.algorithm;
+    if (Array.isArray(algorithm)) {
+      return algorithm.includes(import_antd.theme.darkAlgorithm);
+    }
+    return algorithm === import_antd.theme.darkAlgorithm;
+  }, [config]);
+  engine.context.defineProperty("viewer", {
+    cache: false,
+    get: /* @__PURE__ */ __name((ctx) => new import_FlowView.FlowViewer(ctx, { drawer, embed, popover, dialog }), "get")
+  });
+  for (const item of Object.entries({
+    antdConfig: config,
+    modal,
+    message,
+    notification
+  })) {
+    const [key, value] = item;
+    if (value) {
+      engine.context.defineProperty(key, { value });
     }
-    engine.context.defineProperty("themeToken", {
-      get: /* @__PURE__ */ __name(() => token, "get"),
-      observable: true,
-      cache: true
-    });
+  }
+  engine.context.defineProperty("themeToken", {
+    get: /* @__PURE__ */ __name(() => token, "get"),
+    observable: true,
+    cache: true
+  });
+  engine.context.defineProperty("isDarkTheme", {
+    get: /* @__PURE__ */ __name(() => isDarkTheme, "get"),
+    observable: true,
+    cache: true,
+    info: {
+      description: "Whether current theme algorithm is dark mode.",
+      detail: "boolean"
+    }
+  });
+  (0, import_react.useEffect)(() => {
     engine.reactView.refresh();
-  }, [engine, drawer, modal, message, notification, config, popover, token, dialog, embed]);
+  }, [engine, drawer, modal, message, notification, config, popover, token, dialog, embed, isDarkTheme]);
   return /* @__PURE__ */ import_react.default.createElement(import_antd.ConfigProvider, { ...config, locale: (_a = engine.context.locales) == null ? void 0 : _a.antd, popupMatchSelectWidth: false }, children, contextHolder, popoverContextHolder, pageContextHolder, dialogContextHolder);
 }, "FlowEngineGlobalsContextProvider");
 const useFlowEngine = /* @__PURE__ */ __name(({ throwError = true } = {}) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.1.0-beta.22",
+  "version": "2.1.0-beta.23",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.1.0-beta.22",
-    "@nocobase/shared": "2.1.0-beta.22",
+    "@nocobase/sdk": "2.1.0-beta.23",
+    "@nocobase/shared": "2.1.0-beta.23",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "53ad02861ed8e813103f59659804417118c85b4c"
+  "gitHead": "bb4c0d3551bf9eff505b63756dd24a0813231f16"
 }

package/src/__tests__/provider.test.tsx

@@ -9,9 +9,10 @@
 
 import React from 'react';
 import { describe, expect, it } from 'vitest';
-import { renderHook } from '@testing-library/react';
+import { render, renderHook } from '@testing-library/react';
+import { App, ConfigProvider, theme } from 'antd';
 import { FlowEngine } from '../flowEngine';
-import { FlowEngineProvider, useFlowEngine } from '../provider';
+import { FlowEngineGlobalsContextProvider, FlowEngineProvider, useFlowEngine } from '../provider';
 
 describe('FlowEngineProvider/useFlowEngine', () => {
   it('returns engine within provider', () => {
@@ -20,4 +21,25 @@ describe('FlowEngineProvider/useFlowEngine', () => {
     const { result } = renderHook(() => useFlowEngine(), { wrapper });
     expect(result.current).toBe(engine);
   });
+
+  it('registers isDarkTheme within globals provider before first child render', () => {
+    const engine = new FlowEngine();
+    const reads: boolean[] = [];
+    const Reader = () => {
+      reads.push(engine.context.isDarkTheme);
+      return null;
+    };
+    const wrapper = ({ children }: any) => (
+      <ConfigProvider theme={{ algorithm: theme.darkAlgorithm }}>
+        <App>
+          <FlowEngineProvider engine={engine}>
+            <FlowEngineGlobalsContextProvider>{children}</FlowEngineGlobalsContextProvider>
+          </FlowEngineProvider>
+        </App>
+      </ConfigProvider>
+    );
+    render(<Reader />, { wrapper });
+    expect(reads[0]).toBe(true);
+    expect(engine.context.isDarkTheme).toBe(true);
+  });
 });

package/src/components/FieldModelRenderer.tsx

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { FlowModelRenderer, FlowModelRendererProps } from '@nocobase/flow-engine';
+import type { FlowModelRendererProps } from './FlowModelRenderer';
+import { FlowModelRenderer } from './FlowModelRenderer';
 import _ from 'lodash';
 import React, { useEffect, useMemo, useRef } from 'react';
 

package/src/components/FlowModelRenderer.tsx

@@ -69,6 +69,8 @@ export interface FlowModelRendererProps {
         showBackground?: boolean;
         showBorder?: boolean;
         showDragHandle?: boolean;
+        /** 是否显示事件流入口，默认 true */
+        showDynamicFlowsEditor?: boolean;
         /** 自定义工具栏样式，`top/left/right/bottom` 会作为 portal overlay 的 inset 使用 */
         style?: React.CSSProperties;
         /**
@@ -112,6 +114,7 @@ const FlowModelRendererWithAutoFlows: React.FC<{
         showBackground?: boolean;
         showBorder?: boolean;
         showDragHandle?: boolean;
+        showDynamicFlowsEditor?: boolean;
         /** `top/left/right/bottom` 会作为 portal overlay 的 inset 使用 */
         style?: React.CSSProperties;
         /**
@@ -184,6 +187,7 @@ const FlowModelRendererCore: React.FC<{
         showBackground?: boolean;
         showBorder?: boolean;
         showDragHandle?: boolean;
+        showDynamicFlowsEditor?: boolean;
         /** `top/left/right/bottom` 会作为 portal overlay 的 inset 使用 */
         style?: React.CSSProperties;
         /**
@@ -254,6 +258,7 @@ const FlowModelRendererCore: React.FC<{
             showBackground={_.isObject(showFlowSettings) ? showFlowSettings.showBackground : undefined}
             showBorder={_.isObject(showFlowSettings) ? showFlowSettings.showBorder : undefined}
             showDragHandle={_.isObject(showFlowSettings) ? showFlowSettings.showDragHandle : undefined}
+            showDynamicFlowsEditor={_.isObject(showFlowSettings) ? showFlowSettings.showDynamicFlowsEditor : undefined}
             settingsMenuLevel={settingsMenuLevel}
             extraToolbarItems={extraToolbarItems}
             toolbarStyle={_.isObject(showFlowSettings) ? showFlowSettings.style : undefined}
@@ -300,6 +305,7 @@ const FlowModelRendererCore: React.FC<{
             showBackground={_.isObject(showFlowSettings) ? showFlowSettings.showBackground : undefined}
             showBorder={_.isObject(showFlowSettings) ? showFlowSettings.showBorder : undefined}
             showDragHandle={_.isObject(showFlowSettings) ? showFlowSettings.showDragHandle : undefined}
+            showDynamicFlowsEditor={_.isObject(showFlowSettings) ? showFlowSettings.showDynamicFlowsEditor : undefined}
             settingsMenuLevel={settingsMenuLevel}
             extraToolbarItems={extraToolbarItems}
             toolbarStyle={_.isObject(showFlowSettings) ? showFlowSettings.style : undefined}