@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/runjs-context/snippets/scene/table/export-selected-json.snippet.js

@@ -0,0 +1,64 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var export_selected_json_snippet_exports = {};
+__export(export_selected_json_snippet_exports, {
+  default: () => export_selected_json_snippet_default
+});
+module.exports = __toCommonJS(export_selected_json_snippet_exports);
+var import_JSCollectionActionRunJSContext = require("../../../contexts/JSCollectionActionRunJSContext");
+const snippet = {
+  contexts: [import_JSCollectionActionRunJSContext.JSCollectionActionRunJSContext],
+  prefix: "sn-act-export",
+  label: "Export selected rows as JSON",
+  description: "Download selected rows as a JSON file",
+  locales: {
+    "zh-CN": {
+      label: "\u5BFC\u51FA\u9009\u4E2D\u884C\u4E3A JSON",
+      description: "\u5C06\u9009\u4E2D\u7684\u884C\u5BFC\u51FA\u4E3A JSON \u6587\u4EF6\u4E0B\u8F7D"
+    }
+  },
+  content: `
+const rows = ctx.resource?.getSelectedRows?.() || [];
+if (!rows.length) {
+  ctx.message.warning(ctx.t('Please select at least one row'));
+  return;
+}
+
+// Create JSON file and download
+const jsonStr = JSON.stringify(rows, null, 2);
+const blob = new Blob([jsonStr], { type: 'application/json' });
+const url = URL.createObjectURL(blob);
+const link = document.createElement('a');
+link.href = url;
+link.download = \`export-\${new Date().toISOString().split('T')[0]}.json\`;
+link.click();
+URL.revokeObjectURL(url);
+
+ctx.message.success(ctx.t('Exported {{count}} records', { count: rows.length }));
+`
+};
+var export_selected_json_snippet_default = snippet;

package/lib/runjs-context/snippets/scene/table/iterate-selected-rows.snippet.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 type { SnippetModule } from '../../types';
+declare const snippet: SnippetModule;
+export default snippet;

package/lib/runjs-context/snippets/scene/{actions → table}/iterate-selected-rows.snippet.js

@@ -29,10 +29,18 @@ __export(iterate_selected_rows_snippet_exports, {
   default: () => iterate_selected_rows_snippet_default
 });
 module.exports = __toCommonJS(iterate_selected_rows_snippet_exports);
-var iterate_selected_rows_snippet_default = {
-  contexts: ["JSCollectionActionRunJSContext"],
+var import_JSCollectionActionRunJSContext = require("../../../contexts/JSCollectionActionRunJSContext");
+const snippet = {
+  contexts: [import_JSCollectionActionRunJSContext.JSCollectionActionRunJSContext],
   prefix: "sn-act-iterate",
   label: "Iterate selected rows",
+  description: "Loop through selected rows and process each record",
+  locales: {
+    "zh-CN": {
+      label: "\u904D\u5386\u9009\u4E2D\u884C",
+      description: "\u904D\u5386\u9009\u4E2D\u884C\u5E76\u5904\u7406\u6BCF\u6761\u8BB0\u5F55"
+    }
+  },
   content: `
 const rows = ctx.resource?.getSelectedRows?.() || [];
 for (const row of rows) {
@@ -41,3 +49,4 @@ for (const row of rows) {
 ctx.message.success(ctx.t('Processed {{count}} rows', { count: rows.length }));
 `
 };
+var iterate_selected_rows_snippet_default = snippet;

package/lib/runjs-context/snippets/types.d.ts

@@ -6,11 +6,19 @@
  * 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 type SnippetContextSpecifier = string | {
+    name: string;
+} | (new (...args: any[]) => any);
 export type SnippetModule = {
     content: string;
-    contexts?: string[];
+    contexts?: SnippetContextSpecifier[];
     versions?: string[];
+    scenes?: string[];
     prefix?: string;
     label?: string;
     description?: string;
+    locales?: Record<string, {
+        label?: string;
+        description?: string;
+    }>;
 };

package/lib/runjsLibs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 type { FlowContext } from './flowContext';
+export type RunJSLibCache = 'global' | 'context';
+export type RunJSLibLoader<T = any> = (ctx: FlowContext) => T | Promise<T>;
+export declare function registerRunJSLib(name: string, loader: RunJSLibLoader, options?: {
+    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

@@ -0,0 +1,532 @@
+/**
+ * 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 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) {
+    m = /* @__PURE__ */ new Map();
+    __runjsLibPendingByCtx.set(ctx, m);
+  }
+  return m;
+}
+__name(__runjsGetPendingMapForCtx, "__runjsGetPendingMapForCtx");
+function registerRunJSLib(name, loader, options) {
+  if (typeof name !== "string" || !name) return;
+  if (typeof loader !== "function") return;
+  __runjsLibRegistry.set(name, { loader, cache: (options == null ? void 0 : options.cache) || "global" });
+  __runjsLibResolvedCache.delete(name);
+  __runjsLibPendingCache.delete(name);
+}
+__name(registerRunJSLib, "registerRunJSLib");
+function __runjsIsObject(val) {
+  return !!val && typeof val === "object";
+}
+__name(__runjsIsObject, "__runjsIsObject");
+function __runjsHasOwn(obj, key) {
+  return __runjsIsObject(obj) && Object.prototype.hasOwnProperty.call(obj, key);
+}
+__name(__runjsHasOwn, "__runjsHasOwn");
+function __runjsIsPromiseLike(val) {
+  if (!__runjsIsObject(val)) return false;
+  const then = val.then;
+  return typeof then === "function";
+}
+__name(__runjsIsPromiseLike, "__runjsIsPromiseLike");
+function __runjsGetCtxValue(ctx, key) {
+  return ctx[key];
+}
+__name(__runjsGetCtxValue, "__runjsGetCtxValue");
+async function __runjsEnsureLib(ctx, name) {
+  const libs = ctx == null ? void 0 : ctx.libs;
+  if (__runjsHasOwn(libs, name)) {
+    const existing = libs[name];
+    if (typeof existing !== "undefined") return existing;
+  }
+  const entry = __runjsLibRegistry.get(name);
+  if (!entry) return __runjsIsObject(libs) ? libs[name] : void 0;
+  const setLib = /* @__PURE__ */ __name((v2) => {
+    if (__runjsIsObject(libs)) libs[name] = v2;
+  }, "setLib");
+  if (entry.cache === "context") {
+    const pendingMap = __runjsGetPendingMapForCtx(ctx);
+    const existingPending2 = pendingMap.get(name);
+    if (existingPending2) {
+      const v3 = await existingPending2;
+      setLib(v3);
+      return v3;
+    }
+    const task2 = Promise.resolve().then(() => entry.loader(ctx)).then(
+      (v3) => {
+        pendingMap.delete(name);
+        return v3;
+      },
+      (err) => {
+        pendingMap.delete(name);
+        throw err;
+      }
+    );
+    pendingMap.set(name, task2);
+    const v2 = await task2;
+    setLib(v2);
+    return v2;
+  }
+  if (__runjsLibResolvedCache.has(name)) {
+    const v2 = __runjsLibResolvedCache.get(name);
+    setLib(v2);
+    return v2;
+  }
+  const existingPending = __runjsLibPendingCache.get(name);
+  if (existingPending) {
+    const v2 = await existingPending;
+    setLib(v2);
+    return v2;
+  }
+  const task = Promise.resolve().then(() => entry.loader(ctx)).then(
+    (v2) => {
+      __runjsLibResolvedCache.set(name, v2);
+      __runjsLibPendingCache.delete(name);
+      return v2;
+    },
+    (err) => {
+      __runjsLibPendingCache.delete(name);
+      throw err;
+    }
+  );
+  __runjsLibPendingCache.set(name, task);
+  const v = await task;
+  setLib(v);
+  return v;
+}
+__name(__runjsEnsureLib, "__runjsEnsureLib");
+function setupRunJSLibAPIs(ctx) {
+  if (!ctx || typeof ctx !== "object") return;
+  if (typeof ctx.defineMethod !== "function") return;
+  ctx.defineMethod("__ensureLib", async function(name) {
+    if (typeof name !== "string" || !name) return void 0;
+    return await __runjsEnsureLib(this, name);
+  });
+  ctx.defineMethod("__ensureLibs", async function(names) {
+    if (!Array.isArray(names)) return;
+    for (const n of names) {
+      if (typeof n !== "string" || !n) continue;
+      await __runjsEnsureLib(this, n);
+    }
+  });
+}
+__name(setupRunJSLibAPIs, "setupRunJSLibAPIs");
+const DEFAULT_RUNJS_LIBS = [
+  { name: "React", cache: "context", loader: /* @__PURE__ */ __name((ctx) => __runjsGetCtxValue(ctx, "React"), "loader") },
+  { name: "ReactDOM", cache: "context", loader: /* @__PURE__ */ __name((ctx) => __runjsGetCtxValue(ctx, "ReactDOM"), "loader") },
+  { name: "antd", cache: "context", loader: /* @__PURE__ */ __name((ctx) => __runjsGetCtxValue(ctx, "antd"), "loader") },
+  { name: "dayjs", cache: "context", loader: /* @__PURE__ */ __name((ctx) => __runjsGetCtxValue(ctx, "dayjs"), "loader") },
+  { name: "antdIcons", cache: "global", loader: /* @__PURE__ */ __name(() => antdIcons, "loader") },
+  { name: "lodash", cache: "global", loader: /* @__PURE__ */ __name(() => import("lodash").then((m) => m.default || m), "loader") },
+  { name: "formula", cache: "global", loader: /* @__PURE__ */ __name(() => import("@formulajs/formulajs").then((m) => m.default || m), "loader") },
+  { name: "math", cache: "global", loader: /* @__PURE__ */ __name(() => import("mathjs").then((m) => m), "loader") }
+];
+let __defaultRunJSLibsRegistered = false;
+function ensureDefaultRunJSLibsRegistered() {
+  if (__defaultRunJSLibsRegistered) return;
+  __defaultRunJSLibsRegistered = true;
+  for (const { name, loader, cache } of DEFAULT_RUNJS_LIBS) {
+    if (__runjsLibRegistry.has(name)) continue;
+    registerRunJSLib(name, loader, { cache });
+  }
+}
+__name(ensureDefaultRunJSLibsRegistered, "ensureDefaultRunJSLibsRegistered");
+function resolveRegisteredLibSync(ctx, name) {
+  const entry = __runjsLibRegistry.get(name);
+  if (!entry) return void 0;
+  if (entry.cache === "global" && __runjsLibResolvedCache.has(name)) {
+    return __runjsLibResolvedCache.get(name);
+  }
+  const v = entry.loader(ctx);
+  if (__runjsIsPromiseLike(v)) return void 0;
+  if (entry.cache === "global") __runjsLibResolvedCache.set(name, v);
+  return v;
+}
+__name(resolveRegisteredLibSync, "resolveRegisteredLibSync");
+function setupRunJSLibs(ctx) {
+  if (!ctx || typeof ctx !== "object") return;
+  if (typeof ctx.defineProperty !== "function") return;
+  ensureDefaultRunJSLibsRegistered();
+  const libs = {};
+  for (const { name } of DEFAULT_RUNJS_LIBS) {
+    Object.defineProperty(libs, name, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        const v = resolveRegisteredLibSync(ctx, name);
+        Object.defineProperty(libs, name, {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value: v
+        });
+        return v;
+      }
+    });
+  }
+  ctx.defineProperty("libs", { value: libs });
+  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
+});