@nocobase/flow-engine 2.1.0-beta.9 → 2.2.0-alpha.1

package/lib/data-source/index.js

@@ -42,6 +42,7 @@ __export(data_source_exports, {
   CollectionManager: () => CollectionManager,
   DataSource: () => DataSource,
   DataSourceManager: () => DataSourceManager,
+  getCollectionFieldInterface: () => getCollectionFieldInterface,
   isFieldInterfaceMatch: () => isFieldInterfaceMatch,
   jioToJoiSchema: () => import_jioToJoiSchema.jioToJoiSchema
 });
@@ -53,12 +54,59 @@ 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);
+  }
+  registerFieldFilterOperator(operator) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.registerFieldFilterOperator) == null ? void 0 : _b.call(_a, operator);
+  }
+  registerFieldFilterOperatorGroup(name, operators = []) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.registerFieldFilterOperatorGroup) == null ? void 0 : _b.call(_a, name, operators);
+  }
+  addFieldFilterOperatorsToGroup(name, operators = []) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldFilterOperatorsToGroup) == null ? void 0 : _b.call(_a, name, operators);
+  }
+  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 +123,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,9 +151,169 @@ 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;
+function getCollectionFieldInterface(interfaceName, ...dataSourceManagers) {
+  if (!interfaceName) {
+    return void 0;
+  }
+  for (const dataSourceManager of dataSourceManagers) {
+    const collectionFieldInterfaceManager = dataSourceManager == null ? void 0 : dataSourceManager.collectionFieldInterfaceManager;
+    const getFieldInterface = collectionFieldInterfaceManager == null ? void 0 : collectionFieldInterfaceManager.getFieldInterface;
+    if (typeof getFieldInterface === "function") {
+      return getFieldInterface.call(collectionFieldInterfaceManager, interfaceName);
+    }
+  }
+  return void 0;
+}
+__name(getCollectionFieldInterface, "getCollectionFieldInterface");
+function shouldTranslateOptionLabel(label) {
+  return typeof label === "string" && /\{\{\s*t\s*\(/.test(label);
+}
+__name(shouldTranslateOptionLabel, "shouldTranslateOptionLabel");
+function translateOptionLabel(flowEngine, label, options) {
+  return shouldTranslateOptionLabel(label) ? flowEngine.translate(label, options) : label;
+}
+__name(translateOptionLabel, "translateOptionLabel");
 const _DataSource = class _DataSource {
   dataSourceManager;
   collectionManager;
@@ -126,6 +334,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 +370,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 +383,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 +413,10 @@ const _CollectionManager = class _CollectionManager {
   collections;
   allCollectionsInheritChain;
   childrenCollectionsName = {};
+  resetCaches() {
+    this.childrenCollectionsName = {};
+    this.allCollectionsInheritChain = void 0;
+  }
   get flowEngine() {
     return this.dataSource.flowEngine;
   }
@@ -203,9 +430,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 +442,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 +460,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 +528,7 @@ const _CollectionManager = class _CollectionManager {
   }
   clearCollections() {
     this.collections.clear();
+    this.resetCaches();
   }
   getAssociation(associationName) {
     const [collectionName, fieldName] = associationName.split(".");
@@ -461,6 +697,12 @@ const _Collection = class _Collection {
   }
   get titleCollectionField() {
     const titleFieldName = this.options.titleField || this.filterTargetKey;
+    if (Array.isArray(titleFieldName)) {
+      if (titleFieldName.length !== 1) {
+        return void 0;
+      }
+      return this.getField(titleFieldName[0]);
+    }
     const titleCollectionField = this.getField(titleFieldName);
     return titleCollectionField;
   }
@@ -487,6 +729,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()) {
@@ -711,7 +956,7 @@ const _CollectionField = class _CollectionField {
         }
         return {
           ...v,
-          label: v.label ? this.flowEngine.translate(v.label, { ns: "lm-collections" }) : v.label,
+          label: translateOptionLabel(this.flowEngine, v.label, { ns: "lm-collections" }),
           value: Number(v.value)
         };
       });
@@ -719,7 +964,7 @@ const _CollectionField = class _CollectionField {
     return options.map((v) => {
       return {
         ...v,
-        label: this.flowEngine.translate(v.label, { ns: "lm-collections" })
+        label: translateOptionLabel(this.flowEngine, v.label, { ns: "lm-collections" })
       };
     });
   }
@@ -753,7 +998,7 @@ const _CollectionField = class _CollectionField {
       {
         ...import_lodash.default.omit(((_a = this.options.uiSchema) == null ? void 0 : _a["x-component-props"]) || {}, "fieldNames"),
         options: this.enum.length ? this.enum : void 0,
-        mode: this.type === "array" ? "multiple" : void 0,
+        mode: this.interface === "multipleSelect" ? "multiple" : void 0,
         multiple: target ? ["belongsToMany", "hasMany", "belongsToArray"].includes(type) : void 0,
         maxCount: target && !["belongsToMany", "hasMany", "belongsToArray"].includes(type) ? 1 : void 0,
         target,
@@ -772,7 +1017,17 @@ const _CollectionField = class _CollectionField {
             abortEarly: false
           });
           if (error) {
-            const message = error.details.map((d) => d.message.replace(/"value"/g, `"${label}"`)).join(", ");
+            const message = error.details.map((d) => {
+              const translated = this.flowEngine.translate(d.type, {
+                ...d.context,
+                ns: "data-source-main",
+                label
+              });
+              if (translated && translated !== d.type) {
+                return translated;
+              }
+              return d.message.replace(/"value"/g, `"${label}"`);
+            }).join(", ");
             return Promise.reject(message);
           }
           return Promise.resolve();
@@ -792,8 +1047,14 @@ const _CollectionField = class _CollectionField {
     return this.targetCollection.getFields();
   }
   getInterfaceOptions() {
-    const app = this.flowEngine.context.app;
-    return app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(this.interface);
+    var _a, _b, _c;
+    const ctx = this.flowEngine.context;
+    return getCollectionFieldInterface(
+      this.interface,
+      (_b = (_a = this.collection) == null ? void 0 : _a.dataSource) == null ? void 0 : _b.dataSourceManager,
+      ctx.dataSourceManager,
+      (_c = ctx.app) == null ? void 0 : _c.dataSourceManager
+    );
   }
   getFilterOperators() {
     var _a;
@@ -858,6 +1119,7 @@ __name(isFieldInterfaceMatch, "isFieldInterfaceMatch");
   CollectionManager,
   DataSource,
   DataSourceManager,
+  getCollectionFieldInterface,
   isFieldInterfaceMatch,
   jioToJoiSchema
 });

package/lib/executor/FlowExecutor.js

@@ -153,9 +153,6 @@ const _FlowExecutor = class _FlowExecutor {
         const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, runtimeCtx);
         combinedParams = { ...stepDefaultParams };
       } else {
-        flowContext.logger.error(
-          `BaseModel.applyFlow: Step '${stepKey}' in flow '${flowKey}' has neither 'use' nor 'handler'. Skipping.`
-        );
         continue;
       }
       const modelStepParams = model.getStepParams(flowKey, stepKey);
@@ -459,6 +456,12 @@ const _FlowExecutor = class _FlowExecutor {
         result,
         ...abortedByExitAll ? { aborted: true } : {}
       });
+      if (result && typeof result === "object") {
+        Object.defineProperty(result, "__abortedByExitAll", {
+          value: abortedByExitAll,
+          configurable: true
+        });
+      }
       return result;
     } catch (error) {
       try {

package/lib/flow-registry/DetachedFlowRegistry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { FlowDefinition } from '../FlowDefinition';
+import { FlowDefinitionOptions } from '../types';
+import { BaseFlowRegistry, IFlowRepository } from './BaseFlowRegistry';
+export type FlowRegistryData = Record<string, Omit<FlowDefinitionOptions, 'key'> & {
+    key?: string;
+}>;
+export declare class DetachedFlowRegistry extends BaseFlowRegistry {
+    constructor(flows?: FlowRegistryData);
+    saveFlow(_flow: FlowDefinition): void;
+    destroyFlow(flowKey: string): void;
+}
+export declare function serializeFlowRegistry(registry: Pick<IFlowRepository, 'getFlows'>): FlowRegistryData;
+export declare function replaceFlowRegistry(registry: Pick<IFlowRepository, 'getFlows' | 'removeFlow' | 'addFlows'>, flows: FlowRegistryData): void;

package/lib/flow-registry/DetachedFlowRegistry.js

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DetachedFlowRegistry_exports = {};
+__export(DetachedFlowRegistry_exports, {
+  DetachedFlowRegistry: () => DetachedFlowRegistry,
+  replaceFlowRegistry: () => replaceFlowRegistry,
+  serializeFlowRegistry: () => serializeFlowRegistry
+});
+module.exports = __toCommonJS(DetachedFlowRegistry_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_BaseFlowRegistry = require("./BaseFlowRegistry");
+const _DetachedFlowRegistry = class _DetachedFlowRegistry extends import_BaseFlowRegistry.BaseFlowRegistry {
+  constructor(flows = {}) {
+    super();
+    this.addFlows(import_lodash.default.cloneDeep(flows));
+  }
+  saveFlow(_flow) {
+  }
+  destroyFlow(flowKey) {
+    this.removeFlow(flowKey);
+  }
+};
+__name(_DetachedFlowRegistry, "DetachedFlowRegistry");
+let DetachedFlowRegistry = _DetachedFlowRegistry;
+function serializeFlowRegistry(registry) {
+  const flows = {};
+  for (const [key, flow] of registry.getFlows()) {
+    flows[key] = import_lodash.default.cloneDeep(flow.toData());
+  }
+  return flows;
+}
+__name(serializeFlowRegistry, "serializeFlowRegistry");
+function replaceFlowRegistry(registry, flows) {
+  for (const key of Array.from(registry.getFlows().keys())) {
+    registry.removeFlow(key);
+  }
+  registry.addFlows(import_lodash.default.cloneDeep(flows));
+}
+__name(replaceFlowRegistry, "replaceFlowRegistry");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DetachedFlowRegistry,
+  replaceFlowRegistry,
+  serializeFlowRegistry
+});

package/lib/flow-registry/index.d.ts

@@ -9,3 +9,4 @@
 export * from './BaseFlowRegistry';
 export * from './InstanceFlowRegistry';
 export * from './GlobalFlowRegistry';
+export * from './DetachedFlowRegistry';

package/lib/flow-registry/index.js

@@ -26,9 +26,11 @@ module.exports = __toCommonJS(flow_registry_exports);
 __reExport(flow_registry_exports, require("./BaseFlowRegistry"), module.exports);
 __reExport(flow_registry_exports, require("./InstanceFlowRegistry"), module.exports);
 __reExport(flow_registry_exports, require("./GlobalFlowRegistry"), module.exports);
+__reExport(flow_registry_exports, require("./DetachedFlowRegistry"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./BaseFlowRegistry"),
   ...require("./InstanceFlowRegistry"),
-  ...require("./GlobalFlowRegistry")
+  ...require("./GlobalFlowRegistry"),
+  ...require("./DetachedFlowRegistry")
 });

package/lib/flowContext.d.ts

@@ -222,6 +222,10 @@ export type FlowContextGetApiInfosOptions = {
      * RunJS 文档版本（默认 v1）。
      */
     version?: RunJSVersion;
+    /**
+     * Include editor completion metadata. Defaults to false so API-doc callers keep the compact public shape.
+     */
+    includeCompletion?: boolean;
 };
 export type FlowContextGetVarInfosOptions = {
     /**
@@ -293,7 +297,7 @@ export declare class FlowContext {
      * - 输出仅来自 RunJS doc 与 defineProperty/defineMethod 的 info
      * - 不读取/展开 PropertyMeta（变量结构）
      * - 不自动展开深层 properties
-     * - 不返回自动补全字段（例如 completion）
+     * - 默认不返回自动补全字段（例如 completion），传入 includeCompletion=true 时返回
      */
     getApiInfos(options?: FlowContextGetApiInfosOptions): Promise<Record<string, FlowContextApiInfo>>;
     /**
@@ -325,8 +329,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>;
@@ -347,6 +353,7 @@ declare class BaseFlowEngineContext extends FlowContext {
     runAction: (actionName: string, params?: Record<string, any>) => Promise<any> | any;
     engine: FlowEngine;
     api: APIClient;
+    locale: string;
     viewer: FlowViewer;
     view: FlowView;
     modal: HookAPI;
@@ -420,6 +427,7 @@ export declare class FlowRuntimeContext<TModel extends FlowModel = FlowModel, TM
 export type FlowSettingsContext<TModel extends FlowModel = FlowModel> = FlowRuntimeContext<TModel, 'settings'>;
 export type RunJSDocCompletionDoc = {
     insertText?: string;
+    requires?: Array<'element'>;
 };
 export type RunJSDocHiddenDoc = boolean | ((ctx: any) => boolean | Promise<boolean>);
 export type RunJSDocHiddenOrPathsDoc = boolean | string[] | ((ctx: any) => boolean | string[] | Promise<boolean | string[]>);