@nocobase/flow-engine 2.0.0-beta.17 → 2.0.0-beta.19

package/lib/flowContext.js

@@ -78,6 +78,7 @@ var import_registry = require("./runjs-context/registry");
 var import_createEphemeralContext = require("./utils/createEphemeralContext");
 var import_dayjs = __toESM(require("dayjs"));
 var import_runjsLibs = require("./runjsLibs");
+var import_runjsModuleLoader = require("./utils/runjsModuleLoader");
 var _proxy, _FlowContext_instances, createChildNodes_fn, findMetaByPath_fn, findMetaInDelegatesDeep_fn, findMetaInProperty_fn, resolvePathInMeta_fn, resolvePathInMetaAsync_fn, buildParentTitles_fn, toTreeNode_fn;
 function isRecordRefLike(val) {
   return !!(val && typeof val === "object" && "collection" in val && "filterByTk" in val);
@@ -1003,7 +1004,8 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
         user: this.user
       }), "get")
     });
-    this.defineMethod("loadCSS", async (url) => {
+    this.defineMethod("loadCSS", async (href) => {
+      const url = (0, import_utils.resolveModuleUrl)(href);
       return new Promise((resolve, reject) => {
         const existingLink = document.querySelector(`link[href="${url}"]`);
         if (existingLink) {
@@ -1019,51 +1021,14 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
       });
     });
     this.defineMethod("requireAsync", async (url) => {
-      return new Promise((resolve, reject) => {
-        if (!this.requirejs) {
-          reject(new Error("requirejs is not available"));
-          return;
-        }
-        this.requirejs(
-          [url],
-          (...args) => {
-            resolve(args[0]);
-          },
-          reject
-        );
-      });
+      const u = (0, import_utils.resolveModuleUrl)(url, { raw: true });
+      return await (0, import_runjsModuleLoader.runjsRequireAsync)(this.requirejs, u);
     });
-    this.defineMethod("importAsync", async (url) => {
-      if (!url || typeof url !== "string") {
-        throw new Error("invalid url");
+    this.defineMethod("importAsync", async function(url) {
+      if ((0, import_utils.isCssFile)(url)) {
+        return this.loadCSS(url);
       }
-      const u = url.trim();
-      const g = globalThis;
-      g.__nocobaseImportAsyncCache = g.__nocobaseImportAsyncCache || /* @__PURE__ */ new Map();
-      const cache = g.__nocobaseImportAsyncCache;
-      if (cache.has(u)) return cache.get(u);
-      const nativeImport = /* @__PURE__ */ __name(() => import(
-        /* @vite-ignore */
-        /* webpackIgnore: true */
-        u
-      ), "nativeImport");
-      const evalImport = /* @__PURE__ */ __name(() => {
-        const importer = (0, eval)("u => import(u)");
-        return importer(u);
-      }, "evalImport");
-      const p = (async () => {
-        try {
-          return await nativeImport();
-        } catch (err) {
-          try {
-            return await evalImport();
-          } catch (err2) {
-            throw err2 || err;
-          }
-        }
-      })();
-      cache.set(u, p);
-      return p;
+      return await (0, import_runjsModuleLoader.runjsImportModule)(this, url, { importer: import_runjsModuleLoader.runjsImportAsync });
     });
     this.defineMethod("createJSRunner", async function(options) {
       try {
@@ -1392,6 +1357,7 @@ const _FlowRunJSContext = class _FlowRunJSContext extends FlowContext {
         return this.engine.reactView.createRoot(realContainer, options);
       }, "createRoot")
     };
+    ReactDOMShim.__nbRunjsInternalShim = true;
     this.defineProperty("ReactDOM", { value: ReactDOMShim });
     (0, import_runjsLibs.setupRunJSLibs)(this);
     this.defineMethod(
@@ -1403,39 +1369,64 @@ const _FlowRunJSContext = class _FlowRunJSContext extends FlowContext {
         const globalRef = globalThis;
         globalRef.__nbRunjsRoots = globalRef.__nbRunjsRoots || /* @__PURE__ */ new WeakMap();
         const rootMap = globalRef.__nbRunjsRoots;
-        if (typeof vnode === "string") {
-          const existingRoot = rootMap.get(containerEl);
-          if (existingRoot && typeof existingRoot.unmount === "function") {
+        const disposeEntry = /* @__PURE__ */ __name((entry2) => {
+          if (!entry2) return;
+          if (entry2.disposeTheme && typeof entry2.disposeTheme === "function") {
             try {
-              existingRoot.unmount();
-            } finally {
-              rootMap.delete(containerEl);
+              entry2.disposeTheme();
+            } catch (_2) {
             }
+            entry2.disposeTheme = void 0;
           }
+          const root = entry2.root || entry2;
+          if (root && typeof root.unmount === "function") {
+            try {
+              root.unmount();
+            } catch (_2) {
+            }
+          }
+        }, "disposeEntry");
+        const unmountContainerRoot = /* @__PURE__ */ __name(() => {
+          const existing = rootMap.get(containerEl);
+          if (existing) {
+            disposeEntry(existing);
+            rootMap.delete(containerEl);
+          }
+        }, "unmountContainerRoot");
+        if (typeof vnode === "string") {
+          unmountContainerRoot();
           const proxy = new import_ElementProxy.ElementProxy(containerEl);
           proxy.innerHTML = String(vnode ?? "");
           return null;
         }
         if (vnode && vnode.nodeType && (vnode.nodeType === 1 || vnode.nodeType === 3 || vnode.nodeType === 11)) {
-          const existingRoot = rootMap.get(containerEl);
-          if (existingRoot && typeof existingRoot.unmount === "function") {
-            try {
-              existingRoot.unmount();
-            } finally {
-              rootMap.delete(containerEl);
-            }
-          }
+          unmountContainerRoot();
           while (containerEl.firstChild) containerEl.removeChild(containerEl.firstChild);
           containerEl.appendChild(vnode);
           return null;
         }
-        let root = rootMap.get(containerEl);
-        if (!root) {
-          root = this.ReactDOM.createRoot(containerEl);
-          rootMap.set(containerEl, root);
+        const rendererKey = this.ReactDOM;
+        const ownerKey = this;
+        let entry = rootMap.get(containerEl);
+        if (!entry || entry.rendererKey !== rendererKey || entry.ownerKey !== ownerKey) {
+          if (entry) {
+            disposeEntry(entry);
+            rootMap.delete(containerEl);
+          }
+          const root = this.ReactDOM.createRoot(containerEl);
+          entry = { rendererKey, ownerKey, root, disposeTheme: void 0, lastVnode: void 0 };
+          rootMap.set(containerEl, entry);
         }
-        root.render(vnode);
-        return root;
+        return (0, import_runjsLibs.externalReactRender)({
+          ctx: this,
+          entry,
+          vnode,
+          containerEl,
+          rootMap,
+          unmountContainerRoot,
+          internalReact: import_react.default,
+          internalAntd: antd
+        });
       }
     );
   }

package/lib/provider.js

@@ -79,17 +79,17 @@ const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) =
       cache: false,
       get: /* @__PURE__ */ __name((ctx) => new import_FlowView.FlowViewer(ctx, { drawer, embed, popover, dialog }), "get")
     });
-    engine.context.defineProperty("themeToken", {
-      get: /* @__PURE__ */ __name(() => token, "get"),
-      observable: true,
-      cache: true
-    });
     for (const item of Object.entries(context)) {
       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.reactView.refresh();
   }, [engine, drawer, modal, message, notification, config, popover, token, dialog, embed]);
   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);

package/lib/runjsLibs.d.ts

@@ -13,3 +13,16 @@ export declare function registerRunJSLib(name: string, loader: RunJSLibLoader, o
     cache?: RunJSLibCache;
 }): void;
 export declare function setupRunJSLibs(ctx: FlowContext): void;
+export declare function setRunJSLibOverride(ctx: FlowContext, name: string, value: unknown, options?: {
+    topLevelKey?: string | false;
+}): void;
+export declare function externalReactRender(options: {
+    ctx: any;
+    entry: any;
+    vnode: any;
+    containerEl: any;
+    rootMap: WeakMap<any, any>;
+    unmountContainerRoot: () => void;
+    internalReact: any;
+    internalAntd: any;
+}): any;

package/lib/runjsLibs.js

@@ -37,15 +37,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runjsLibs_exports = {};
 __export(runjsLibs_exports, {
+  externalReactRender: () => externalReactRender,
   registerRunJSLib: () => registerRunJSLib,
+  setRunJSLibOverride: () => setRunJSLibOverride,
   setupRunJSLibs: () => setupRunJSLibs
 });
 module.exports = __toCommonJS(runjsLibs_exports);
 var antdIcons = __toESM(require("@ant-design/icons"));
+var import_reactive = require("@formily/reactive");
 const __runjsLibRegistry = /* @__PURE__ */ new Map();
 const __runjsLibResolvedCache = /* @__PURE__ */ new Map();
 const __runjsLibPendingCache = /* @__PURE__ */ new Map();
 const __runjsLibPendingByCtx = /* @__PURE__ */ new WeakMap();
+const __runjsErrorBoundaryByReact = /* @__PURE__ */ new WeakMap();
 function __runjsGetPendingMapForCtx(ctx) {
   let m = __runjsLibPendingByCtx.get(ctx);
   if (!m) {
@@ -216,8 +220,313 @@ function setupRunJSLibs(ctx) {
   setupRunJSLibAPIs(ctx);
 }
 __name(setupRunJSLibs, "setupRunJSLibs");
+function setRunJSLibOverride(ctx, name, value, options) {
+  const topLevelKey = (options == null ? void 0 : options.topLevelKey) === false ? null : (options == null ? void 0 : options.topLevelKey) || name;
+  if (topLevelKey) {
+    ctx.defineProperty(topLevelKey, { value });
+  }
+  const libs = ctx.libs;
+  Object.defineProperty(libs, name, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+}
+__name(setRunJSLibOverride, "setRunJSLibOverride");
+function buildMixedReactHint(options) {
+  var _a;
+  const { ctx, internalReact, internalAntd } = options;
+  const lines = [];
+  const externalReact = ctx.React && ctx.React !== internalReact;
+  const internalReactDOM = !!((_a = ctx.ReactDOM) == null ? void 0 : _a.__nbRunjsInternalShim);
+  const usingInternalAntd = ctx.antd === internalAntd;
+  const externalAntd = ctx.antd && ctx.antd !== internalAntd;
+  if (externalReact && internalReactDOM) {
+    const reactInfo = ctx.__runjsExternalReact;
+    const v = reactInfo == null ? void 0 : reactInfo.version;
+    const domHint = v ? `react-dom@${v}/client` : "react-dom/client";
+    lines.push(
+      `- You have imported external React, but you're still using the built-in ReactDOM Root; please also run: await ctx.importAsync("${domHint}")`
+    );
+  }
+  if (externalAntd && !externalReact) {
+    lines.push(
+      `- You have imported external antd, but you're still using the built-in React; please run: await ctx.importAsync("react@18.x")`
+    );
+    lines.push(`- And make sure ReactDOM matches: await ctx.importAsync("react-dom@18.x/client")`);
+  }
+  if (externalReact && usingInternalAntd) {
+    lines.push(
+      `- You have imported external React, but you're still using the built-in antd; please switch to: await ctx.importAsync("antd@5.x")`
+    );
+    lines.push(`- If you use icon components, also import: await ctx.importAsync("@ant-design/icons@5.x")`);
+  }
+  return lines.length ? `
+
+[RunJS Hint]
+${lines.join("\n")}` : "";
+}
+__name(buildMixedReactHint, "buildMixedReactHint");
+function isReactHooksDispatcherNullError(err) {
+  const msg = String((err == null ? void 0 : err.message) || "");
+  if (!msg) return false;
+  if (!/Cannot read (?:properties|property) of (?:null|undefined) \(reading 'use[A-Za-z]+'\)/.test(msg)) return false;
+  const stack = String((err == null ? void 0 : err.stack) || "");
+  if (!stack) return false;
+  return /(?:^|\W)react@[^/\s)]+/i.test(stack) || /react\.mjs/i.test(stack) || /react\.(?:development|production)/i.test(stack);
+}
+__name(isReactHooksDispatcherNullError, "isReactHooksDispatcherNullError");
+function extractReactVersionFromStack(err) {
+  var _a;
+  const stack = String((err == null ? void 0 : err.stack) || "");
+  if (!stack) return void 0;
+  const m = stack.match(/(?:^|\W)react@([^/\s)]+)/i);
+  const v = (_a = m == null ? void 0 : m[1]) == null ? void 0 : _a.trim();
+  return v || void 0;
+}
+__name(extractReactVersionFromStack, "extractReactVersionFromStack");
+function buildReactDispatcherNullHint(options) {
+  const { ctx, internalReact, internalAntd, err } = options;
+  if (!isReactHooksDispatcherNullError(err)) return "";
+  const v = extractReactVersionFromStack(err);
+  const lines = [];
+  lines.push(`- This looks like a React Hooks crash caused by multiple React instances (hook dispatcher is null).`);
+  if (v) {
+    lines.push(`- Your stack trace includes external React: react@${v}.`);
+    lines.push(
+      `- Fix: import the same React BEFORE you read ctx.libs.React / call hooks / import React-based libs: await ctx.importAsync("react@${v}")`
+    );
+  } else {
+    lines.push(
+      `- Fix: import external React BEFORE you read ctx.libs.React / call hooks / import React-based libs (use the same version shown in the stack trace).`
+    );
+  }
+  const usingInternalAntd = ctx.antd === internalAntd;
+  if (usingInternalAntd) {
+    lines.push(`- If you use antd components, also switch to external antd: await ctx.importAsync("antd@5.x")`);
+    lines.push(`- If you use icon components, also import: await ctx.importAsync("@ant-design/icons@5.x")`);
+  }
+  return lines.length ? `
+
+[RunJS Hint]
+${lines.join("\n")}` : "";
+}
+__name(buildReactDispatcherNullHint, "buildReactDispatcherNullHint");
+function wrapErrorWithHint(err, messageWithHint) {
+  const e = new Error(messageWithHint);
+  e.cause = err;
+  try {
+    const name = typeof (err == null ? void 0 : err.name) === "string" ? err.name : "";
+    if (name) e.name = name;
+  } catch (_) {
+  }
+  try {
+    const stack = typeof (err == null ? void 0 : err.stack) === "string" ? err.stack : "";
+    if (stack) {
+      const lines = String(stack).split("\n");
+      if (lines.length) {
+        lines[0] = `${e.name}: ${messageWithHint}`;
+        e.stack = lines.join("\n");
+      }
+    }
+  } catch (_) {
+  }
+  return e;
+}
+__name(wrapErrorWithHint, "wrapErrorWithHint");
+function getRunjsErrorBoundary(ReactLike) {
+  if (!ReactLike) return null;
+  const cached = __runjsErrorBoundaryByReact.get(ReactLike);
+  if (cached) return cached;
+  if (typeof ReactLike.createElement !== "function") return null;
+  const Base = ReactLike.Component;
+  if (typeof Base !== "function") return null;
+  const _RunjsErrorBoundary = class _RunjsErrorBoundary extends Base {
+    static getDerivedStateFromError(error) {
+      return { error };
+    }
+    state = {};
+    componentDidCatch(error) {
+      var _a, _b, _c;
+      try {
+        const enhance = (_a = this.props) == null ? void 0 : _a.enhanceReactError;
+        const enhanced = typeof enhance === "function" ? enhance(error) : error;
+        const msg = String((enhanced == null ? void 0 : enhanced.message) || "");
+        if (msg && /\[RunJS Hint\]/.test(msg)) {
+          console.error(msg);
+          const logger = (_c = (_b = this.props) == null ? void 0 : _b.ctx) == null ? void 0 : _c.logger;
+          if (logger && typeof logger.error === "function") {
+            logger.error(msg);
+          }
+        }
+      } catch (_) {
+      }
+    }
+    componentDidUpdate(prevProps) {
+      var _a, _b;
+      if ((prevProps == null ? void 0 : prevProps.resetKey) !== ((_a = this.props) == null ? void 0 : _a.resetKey) && ((_b = this.state) == null ? void 0 : _b.error)) {
+        this.setState({ error: void 0 });
+      }
+    }
+    render() {
+      var _a, _b;
+      const error = (_a = this.state) == null ? void 0 : _a.error;
+      if (!error) return this.props.children;
+      let msg = "";
+      try {
+        const enhance = (_b = this.props) == null ? void 0 : _b.enhanceReactError;
+        const enhanced = typeof enhance === "function" ? enhance(error) : error;
+        msg = String((enhanced == null ? void 0 : enhanced.message) || enhanced || (error == null ? void 0 : error.message) || error || "");
+      } catch (_) {
+        msg = String((error == null ? void 0 : error.message) || error || "");
+      }
+      const containerStyle = {
+        boxSizing: "border-box",
+        padding: 12,
+        borderRadius: 6,
+        border: "1px solid #ffccc7",
+        background: "#fff2f0",
+        color: "#a8071a",
+        fontSize: 12,
+        lineHeight: 1.5,
+        maxWidth: "100%",
+        overflow: "auto"
+      };
+      const preStyle = {
+        margin: 0,
+        whiteSpace: "pre-wrap",
+        wordBreak: "break-word",
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'
+      };
+      const titleStyle = { fontWeight: 600, marginBottom: 8 };
+      return ReactLike.createElement(
+        "div",
+        { style: containerStyle },
+        ReactLike.createElement("div", { style: titleStyle }, "RunJS render error"),
+        ReactLike.createElement("pre", { style: preStyle }, msg)
+      );
+    }
+  };
+  __name(_RunjsErrorBoundary, "RunjsErrorBoundary");
+  let RunjsErrorBoundary = _RunjsErrorBoundary;
+  __runjsErrorBoundaryByReact.set(ReactLike, RunjsErrorBoundary);
+  return RunjsErrorBoundary;
+}
+__name(getRunjsErrorBoundary, "getRunjsErrorBoundary");
+function wrapVnodeWithRunjsErrorBoundary(options) {
+  const { ctx, vnode, enhanceReactError, resetKey } = options;
+  const ReactLike = ctx == null ? void 0 : ctx.React;
+  const Boundary = getRunjsErrorBoundary(ReactLike);
+  if (!Boundary) return vnode;
+  return ReactLike.createElement(Boundary, { ctx, enhanceReactError, resetKey }, vnode);
+}
+__name(wrapVnodeWithRunjsErrorBoundary, "wrapVnodeWithRunjsErrorBoundary");
+function tryRenderWithExternalAntdTheme(options) {
+  var _a;
+  const { ctx, entry, containerEl, rootMap, unmountContainerRoot, enhanceReactError, internalReact, internalAntd } = options;
+  const canUseExternalAntd = !((_a = ctx.ReactDOM) == null ? void 0 : _a.__nbRunjsInternalShim) && ctx.React && ctx.React !== internalReact && ctx.antd && ctx.antd !== internalAntd && typeof ctx.antd.ConfigProvider !== "undefined";
+  if (!canUseExternalAntd) {
+    if (entry.disposeTheme) {
+      try {
+        entry.disposeTheme();
+      } catch (_) {
+      }
+      entry.disposeTheme = void 0;
+    }
+    return false;
+  }
+  const renderWithExternalAntdTheme = /* @__PURE__ */ __name(() => {
+    var _a2, _b, _c, _d, _e, _f, _g;
+    const themeToken = (_b = (_a2 = ctx == null ? void 0 : ctx.engine) == null ? void 0 : _a2.context) == null ? void 0 : _b.themeToken;
+    const appConfig = (_d = (_c = ctx == null ? void 0 : ctx.engine) == null ? void 0 : _c.context) == null ? void 0 : _d.antdConfig;
+    const locale = ((_g = (_f = (_e = ctx == null ? void 0 : ctx.engine) == null ? void 0 : _e.context) == null ? void 0 : _f.locales) == null ? void 0 : _g.antd) || (appConfig == null ? void 0 : appConfig.locale);
+    const ConfigProvider = ctx.antd.ConfigProvider;
+    const App = ctx.antd.App;
+    const configProps = {
+      popupMatchSelectWidth: false,
+      locale: locale || {}
+    };
+    if (appConfig && typeof appConfig === "object") {
+      if (typeof appConfig.direction !== "undefined") configProps.direction = appConfig.direction;
+      if (typeof appConfig.prefixCls === "string") configProps.prefixCls = appConfig.prefixCls;
+      if (typeof appConfig.iconPrefixCls === "string") configProps.iconPrefixCls = appConfig.iconPrefixCls;
+      if (typeof appConfig.getPopupContainer === "function")
+        configProps.getPopupContainer = appConfig.getPopupContainer;
+      if (appConfig.theme && typeof appConfig.theme === "object") configProps.theme = appConfig.theme;
+    }
+    const child = entry.lastVnode;
+    const wrapped = App ? ctx.React.createElement(ConfigProvider, configProps, ctx.React.createElement(App, null, child)) : ctx.React.createElement(ConfigProvider, configProps, child);
+    entry.root.render(wrapped);
+  }, "renderWithExternalAntdTheme");
+  if (!entry.disposeTheme) {
+    entry.disposeTheme = (0, import_reactive.autorun)(() => {
+      try {
+        if (containerEl && containerEl.nodeType === 1 && typeof containerEl.isConnected === "boolean" && !containerEl.isConnected && entry.wasConnected) {
+          queueMicrotask(() => {
+            const cur = rootMap.get(containerEl);
+            if (cur === entry) unmountContainerRoot();
+          });
+          return;
+        }
+        if (containerEl && containerEl.nodeType === 1 && typeof containerEl.isConnected === "boolean" && containerEl.isConnected) {
+          entry.wasConnected = true;
+        }
+        renderWithExternalAntdTheme();
+      } catch (e) {
+        throw enhanceReactError(e);
+      }
+    });
+  } else {
+    renderWithExternalAntdTheme();
+  }
+  return true;
+}
+__name(tryRenderWithExternalAntdTheme, "tryRenderWithExternalAntdTheme");
+function externalReactRender(options) {
+  const { ctx, entry, vnode, containerEl, rootMap, unmountContainerRoot, internalReact, internalAntd } = options;
+  const enhanceReactError = /* @__PURE__ */ __name((err) => {
+    const msg = String((err == null ? void 0 : err.message) || err || "");
+    if (!msg) return err;
+    if (/\[RunJS Hint\]/.test(msg)) return err;
+    const invalidHookCall = /invalid hook call/i.test(msg);
+    const dispatcherNull = isReactHooksDispatcherNullError(err);
+    if (!invalidHookCall && !dispatcherNull) return err;
+    const hint = buildMixedReactHint({ ctx, internalReact, internalAntd }) || buildReactDispatcherNullHint({ ctx, internalReact, internalAntd, err });
+    if (!hint) return err;
+    return wrapErrorWithHint(err, `${msg}${hint}`);
+  }, "enhanceReactError");
+  try {
+    entry.__nbRunjsRenderSeq = (entry.__nbRunjsRenderSeq || 0) + 1;
+    entry.lastVnode = wrapVnodeWithRunjsErrorBoundary({
+      ctx,
+      vnode,
+      enhanceReactError,
+      resetKey: entry.__nbRunjsRenderSeq
+    });
+    const renderedWithExternalAntdTheme = tryRenderWithExternalAntdTheme({
+      ctx,
+      entry,
+      containerEl,
+      rootMap,
+      unmountContainerRoot,
+      enhanceReactError,
+      internalReact,
+      internalAntd
+    });
+    if (!renderedWithExternalAntdTheme) {
+      entry.root.render(entry.lastVnode);
+    }
+    return entry.root;
+  } catch (e) {
+    throw enhanceReactError(e);
+  }
+}
+__name(externalReactRender, "externalReactRender");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  externalReactRender,
   registerRunJSLib,
+  setRunJSLibOverride,
   setupRunJSLibs
 });

package/lib/utils/index.d.ts

@@ -25,3 +25,4 @@ export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompa
 export { createEphemeralContext } from './createEphemeralContext';
 export { pruneFilter } from './pruneFilter';
 export { isBeforeRenderFlow } from './flows';
+export { resolveModuleUrl, isCssFile } from './resolveModuleUrl';

package/lib/utils/index.js

@@ -55,6 +55,7 @@ __export(utils_exports, {
   getT: () => import_translation.getT,
   inferRecordRef: () => import_variablesParams.inferRecordRef,
   isBeforeRenderFlow: () => import_flows.isBeforeRenderFlow,
+  isCssFile: () => import_resolveModuleUrl.isCssFile,
   isInheritedFrom: () => import_inheritance.isInheritedFrom,
   isVariableExpression: () => import_context.isVariableExpression,
   parsePathnameToViewParams: () => import_parsePathnameToViewParams.parsePathnameToViewParams,
@@ -64,6 +65,7 @@ __export(utils_exports, {
   resolveCreateModelOptions: () => import_params_resolvers.resolveCreateModelOptions,
   resolveDefaultParams: () => import_params_resolvers.resolveDefaultParams,
   resolveExpressions: () => import_params_resolvers.resolveExpressions,
+  resolveModuleUrl: () => import_resolveModuleUrl.resolveModuleUrl,
   resolveStepUiSchema: () => import_schema_utils.resolveStepUiSchema,
   resolveUiMode: () => import_schema_utils.resolveUiMode,
   setAutoFlowError: () => import_autoFlowError.setAutoFlowError,
@@ -91,6 +93,7 @@ var import_runjsTemplateCompat = require("./runjsTemplateCompat");
 var import_createEphemeralContext = require("./createEphemeralContext");
 var import_pruneFilter = require("./pruneFilter");
 var import_flows = require("./flows");
+var import_resolveModuleUrl = require("./resolveModuleUrl");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOCK_GROUP_CONFIGS,
@@ -122,6 +125,7 @@ var import_flows = require("./flows");
   getT,
   inferRecordRef,
   isBeforeRenderFlow,
+  isCssFile,
   isInheritedFrom,
   isVariableExpression,
   parsePathnameToViewParams,
@@ -131,6 +135,7 @@ var import_flows = require("./flows");
   resolveCreateModelOptions,
   resolveDefaultParams,
   resolveExpressions,
+  resolveModuleUrl,
   resolveStepUiSchema,
   resolveUiMode,
   setAutoFlowError,

package/lib/utils/resolveModuleUrl.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+/**
+ * 解析模块 URL，将相对路径转换为完整的 CDN URL
+ *
+ * @param url - 模块地址（支持相对路径或完整 URL）
+ * @param options - 可选配置
+ * @param options.addSuffix - 是否添加 ESM_CDN_SUFFIX 后缀（如 `+esm`），默认为 `true`
+ * @returns 解析后的完整 URL
+ *
+ * @example
+ * ```ts
+ * // 相对路径会被拼接上 CDN 前缀和后缀（默认添加）
+ * // 如果使用 esm.sh（默认），不需要后缀
+ * resolveModuleUrl('vue@3.4.0')
+ * // => 'https://esm.sh/vue@3.4.0'
+ *
+ * // 如果使用 jsdelivr，需要配置 ESM_CDN_SUFFIX='/+esm'
+ * // resolveModuleUrl('vue@3.4.0') => 'https://cdn.jsdelivr.net/npm/vue@3.4.0/+esm'
+ *
+ * // 不添加后缀（适用于 UMD 库或 CSS 文件）
+ * resolveModuleUrl('vue@3.4.0', { addSuffix: false })
+ * // => 'https://esm.sh/vue@3.4.0' (即使配置了 suffix 也不会添加)
+ *
+ * // 原始 URL（适用于 UMD 库）
+ * resolveModuleUrl('lodash@4.17.21/lodash.js', { raw: true })
+ * // => 'https://esm.sh/lodash@4.17.21/lodash.js?raw' (即使配置了 suffix 也不会添加)
+ *
+ * // 完整 URL 保持不变
+ * resolveModuleUrl('https://cdn.jsdelivr.net/npm/vue@3.4.0')
+ * // => 'https://cdn.jsdelivr.net/npm/vue@3.4.0'
+ * ```
+ */
+export declare function resolveModuleUrl(url: string, options?: {
+    addSuffix?: boolean;
+    raw?: boolean;
+}): string;
+/**
+ * 判断 URL 是否为 CSS 文件
+ *
+ * @param url - 文件 URL（支持带 query 和 hash，如 `example.css?v=123`）
+ * @returns 如果是 CSS 文件返回 `true`，否则返回 `false`
+ *
+ * @example
+ * ```ts
+ * isCssFile('style.css') // => true
+ * isCssFile('style.css?v=123') // => true
+ * isCssFile('style.css#section') // => true
+ * isCssFile('script.js') // => false
+ * ```
+ */
+export declare function isCssFile(url: string): boolean;