@nocobase/flow-engine 2.0.0-beta.8 → 2.0.0

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
+});

package/lib/scheduler/ModelOperationScheduler.d.ts

@@ -22,6 +22,8 @@ export interface LifecycleEvent {
     error?: any;
     inputArgs?: Record<string, any>;
     result?: any;
+    flowKey?: string;
+    stepKey?: string;
 }
 export declare class ModelOperationScheduler {
     private engine;

package/lib/scheduler/ModelOperationScheduler.js

@@ -32,6 +32,7 @@ __export(ModelOperationScheduler_exports, {
 });
 module.exports = __toCommonJS(ModelOperationScheduler_exports);
 var import_secure = require("uid/secure");
+var import_exceptions = require("../utils/exceptions");
 const _ModelOperationScheduler = class _ModelOperationScheduler {
   constructor(engine) {
     this.engine = engine;
@@ -125,32 +126,32 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
   bindEngineLifecycle() {
     const emitter = this.engine.emitter;
     if (!emitter || typeof emitter.on !== "function") return;
-    const onCreated = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "created" });
+    const onCreated = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "created" });
     }, "onCreated");
     emitter.on("model:created", onCreated);
     this.unbindHandlers.push(() => emitter.off("model:created", onCreated));
-    const onMounted = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "mounted" });
+    const onMounted = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "mounted" });
     }, "onMounted");
     emitter.on("model:mounted", onMounted);
     this.unbindHandlers.push(() => emitter.off("model:mounted", onMounted));
-    const onGenericBeforeStart = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:start" });
+    const onGenericBeforeStart = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:start" });
     }, "onGenericBeforeStart");
     emitter.on("model:event:beforeRender:start", onGenericBeforeStart);
     this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:start", onGenericBeforeStart));
-    const onGenericBeforeEnd = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:end" });
+    const onGenericBeforeEnd = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:end" });
     }, "onGenericBeforeEnd");
     emitter.on("model:event:beforeRender:end", onGenericBeforeEnd);
     this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:end", onGenericBeforeEnd));
-    const onUnmounted = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "unmounted" });
+    const onUnmounted = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "unmounted" });
     }, "onUnmounted");
     emitter.on("model:unmounted", onUnmounted);
     this.unbindHandlers.push(() => emitter.off("model:unmounted", onUnmounted));
-    const onDestroyed = /* @__PURE__ */ __name((e) => {
+    const onDestroyed = /* @__PURE__ */ __name(async (e) => {
       const targetBucket = this.itemsByTargetUid.get(e.uid);
       const event = { ...e, type: "destroyed" };
       if (targetBucket && targetBucket.size) {
@@ -159,7 +160,7 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
           const it = this.itemsById.get(id);
           if (!it) continue;
           if (this.shouldTrigger(it.options.when, event)) {
-            void this.tryExecuteOnce(id, event);
+            await this.tryExecuteOnce(id, event);
           } else {
             this.internalCancel(id);
           }
@@ -177,14 +178,14 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
     if (this.subscribedEventNames.has(name)) return;
     this.subscribedEventNames.add(name);
     const emitter = this.engine.emitter;
-    const onStart = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` });
+    const onStart = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` });
     }, "onStart");
-    const onEnd = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` });
+    const onEnd = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` });
     }, "onEnd");
-    const onError = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` });
+    const onError = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` });
     }, "onError");
     emitter.on(`model:event:${name}:start`, onStart);
     emitter.on(`model:event:${name}:end`, onEnd);
@@ -195,11 +196,11 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
   }
   parseEventWhen(when) {
     if (!when || typeof when !== "string") return null;
-    const m = /^event:([^:]+):(start|end|error)$/.exec(when);
+    const m = /^event:(.+):(start|end|error)$/.exec(when);
     if (!m) return null;
     return { name: m[1], phase: m[2] };
   }
-  processLifecycleEvent(targetUid, event) {
+  async processLifecycleEvent(targetUid, event) {
     const targetBucket = this.itemsByTargetUid.get(targetUid);
     if (!targetBucket || targetBucket.size === 0) return;
     const ids = Array.from(targetBucket.keys());
@@ -208,7 +209,7 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
       if (!item) continue;
       const should = this.shouldTrigger(item.options.when, event);
       if (!should) continue;
-      void this.tryExecuteOnce(id, event);
+      await this.tryExecuteOnce(id, event);
     }
   }
   shouldTrigger(when, event) {
@@ -225,6 +226,9 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
       if (!model) return;
       await Promise.resolve(item.fn(model));
     } catch (err) {
+      if (err instanceof import_exceptions.FlowExitAllException) {
+        throw err;
+      }
       (_b = (_a = this.engine.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
         _a,
         { err, id, fromUid: item.fromUid, toUid: item.toUid, when: item.options.when },