@nocobase/flow-engine 2.0.0-beta.9 → 2.0.1

package/lib/utils/runjsModuleLoader.js

@@ -0,0 +1,422 @@
+/**
+ * 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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runjsModuleLoader_exports = {};
+__export(runjsModuleLoader_exports, {
+  runjsImportAsync: () => runjsImportAsync,
+  runjsImportModule: () => runjsImportModule,
+  runjsRequireAsync: () => runjsRequireAsync
+});
+module.exports = __toCommonJS(runjsModuleLoader_exports);
+var import_runjsLibs = require("../runjsLibs");
+var import_resolveModuleUrl = require("./resolveModuleUrl");
+var import_safeGlobals = require("./safeGlobals");
+function snapshotOwnKeys(obj) {
+  try {
+    if (!obj || typeof obj !== "object" && typeof obj !== "function") return [];
+    return Object.getOwnPropertyNames(obj);
+  } catch (_) {
+    return [];
+  }
+}
+__name(snapshotOwnKeys, "snapshotOwnKeys");
+function diffAddedKeys(afterKeys, beforeKeys) {
+  if (!afterKeys.length) return [];
+  if (!beforeKeys.length) return [...afterKeys];
+  const beforeSet = new Set(beforeKeys);
+  const added = [];
+  for (const k of afterKeys) {
+    if (!beforeSet.has(k)) added.push(k);
+  }
+  return added;
+}
+__name(diffAddedKeys, "diffAddedKeys");
+async function withRunjsModuleLoadLock(task) {
+  const g = globalThis;
+  g.__nocobaseRunjsModuleLoadLock = (g.__nocobaseRunjsModuleLoadLock || Promise.resolve()).catch(() => {
+  });
+  const prev = g.__nocobaseRunjsModuleLoadLock;
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  g.__nocobaseRunjsModuleLoadLock = prev.then(() => current);
+  await prev;
+  try {
+    return await task();
+  } finally {
+    release == null ? void 0 : release();
+  }
+}
+__name(withRunjsModuleLoadLock, "withRunjsModuleLoadLock");
+function disableAmdDefineTemporarily() {
+  const g = globalThis;
+  const def = g == null ? void 0 : g.define;
+  const amd = def == null ? void 0 : def.amd;
+  if (!def || !amd) return () => {
+  };
+  const desc = Object.getOwnPropertyDescriptor(def, "amd");
+  const hadOwn = !!desc;
+  const prev = amd;
+  try {
+    if (desc == null ? void 0 : desc.writable) {
+      def.amd = void 0;
+    } else if (desc == null ? void 0 : desc.configurable) {
+      delete def.amd;
+    } else {
+      def.amd = void 0;
+    }
+  } catch (_) {
+  }
+  return () => {
+    try {
+      if (hadOwn && desc) {
+        Object.defineProperty(def, "amd", desc);
+        return;
+      }
+      def.amd = prev;
+    } catch (_) {
+    }
+  };
+}
+__name(disableAmdDefineTemporarily, "disableAmdDefineTemporarily");
+function hasPendingRequireJsLoads() {
+  var _a, _b;
+  const g = globalThis;
+  const req = (_a = g == null ? void 0 : g.requirejs) == null ? void 0 : _a.requirejs;
+  const contexts = (_b = req == null ? void 0 : req.s) == null ? void 0 : _b.contexts;
+  if (!contexts || typeof contexts !== "object") return false;
+  for (const ctxName of Object.keys(contexts)) {
+    const ctx = contexts[ctxName];
+    const registry = ctx == null ? void 0 : ctx.registry;
+    if (!registry || typeof registry !== "object") continue;
+    for (const id of Object.keys(registry)) {
+      const mod = registry[id];
+      if (!mod || typeof mod !== "object") continue;
+      if (!mod.enabled) continue;
+      if (mod.error) continue;
+      const map = mod.map;
+      if (!map || typeof map !== "object") continue;
+      if (!mod.inited && mod.fetched && map.isDefine) return true;
+    }
+  }
+  return false;
+}
+__name(hasPendingRequireJsLoads, "hasPendingRequireJsLoads");
+async function waitForRequireJsIdle(options) {
+  const timeoutMs = Math.max(0, (options == null ? void 0 : options.timeoutMs) ?? 1500);
+  const pollMs = Math.max(10, (options == null ? void 0 : options.pollMs) ?? 30);
+  if (timeoutMs === 0) return;
+  const start = Date.now();
+  while (hasPendingRequireJsLoads()) {
+    if (Date.now() - start >= timeoutMs) return;
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+}
+__name(waitForRequireJsIdle, "waitForRequireJsIdle");
+async function prefetchEsmModule(url, options) {
+  const u = typeof url === "string" ? url.trim() : "";
+  if (!u) return;
+  const g = globalThis;
+  g.__nocobaseImportAsyncPrefetchCache = g.__nocobaseImportAsyncPrefetchCache || /* @__PURE__ */ new Map();
+  const cache = g.__nocobaseImportAsyncPrefetchCache;
+  if (cache.has(u)) return await cache.get(u);
+  const timeoutMs = Math.max(0, (options == null ? void 0 : options.timeoutMs) ?? 5e3);
+  const task = (async () => {
+    var _a;
+    try {
+      if (typeof document !== "undefined" && (document == null ? void 0 : document.createElement)) {
+        const href = new URL(u, ((_a = globalThis == null ? void 0 : globalThis.location) == null ? void 0 : _a.href) || void 0).toString();
+        const head = document.head || document.getElementsByTagName("head")[0];
+        if (head) {
+          const selector = `link[rel="modulepreload"][href="${href}"]`;
+          const existing = document.querySelector(selector);
+          if (!existing) {
+            const link = document.createElement("link");
+            link.rel = "modulepreload";
+            link.href = href;
+            link.crossOrigin = "anonymous";
+            const done = await new Promise((resolve) => {
+              let settled = false;
+              const finalize = /* @__PURE__ */ __name(() => {
+                if (settled) return;
+                settled = true;
+                link.onload = null;
+                link.onerror = null;
+                resolve();
+              }, "finalize");
+              const timer = timeoutMs > 0 ? setTimeout(() => {
+                finalize();
+              }, timeoutMs) : void 0;
+              link.onload = () => {
+                if (timer) clearTimeout(timer);
+                finalize();
+              };
+              link.onerror = () => {
+                if (timer) clearTimeout(timer);
+                finalize();
+              };
+              head.appendChild(link);
+            });
+            return done;
+          }
+        }
+      }
+    } catch (_) {
+    }
+    try {
+      if (typeof fetch !== "function") return;
+      const controller = typeof AbortController === "function" ? new AbortController() : void 0;
+      const timer = controller && timeoutMs > 0 ? setTimeout(() => {
+        try {
+          controller.abort();
+        } catch (_) {
+        }
+      }, timeoutMs) : void 0;
+      const res = await fetch(u, {
+        method: "GET",
+        mode: "cors",
+        credentials: "omit",
+        cache: "force-cache",
+        signal: controller == null ? void 0 : controller.signal
+      });
+      if (timer) clearTimeout(timer);
+      if (res && res.ok && typeof res.arrayBuffer === "function") {
+        try {
+          await res.arrayBuffer();
+        } catch (_) {
+        }
+      }
+    } catch (_) {
+    }
+  })();
+  const safeTask = task.catch(() => {
+  });
+  cache.set(u, safeTask);
+  return await safeTask;
+}
+__name(prefetchEsmModule, "prefetchEsmModule");
+async function runjsRequireAsync(requirejs, url) {
+  return await withRunjsModuleLoadLock(async () => {
+    const beforeWinKeys = typeof window !== "undefined" ? snapshotOwnKeys(window) : [];
+    const beforeDocKeys = typeof document !== "undefined" ? snapshotOwnKeys(document) : [];
+    let result;
+    let error;
+    try {
+      result = await new Promise((resolve, reject) => {
+        if (!requirejs) {
+          reject(new Error("requirejs is not available"));
+          return;
+        }
+        requirejs(
+          [url],
+          (...args) => {
+            resolve(args[0]);
+          },
+          reject
+        );
+      });
+    } catch (e) {
+      error = e;
+    } finally {
+      const afterWinKeys = typeof window !== "undefined" ? snapshotOwnKeys(window) : [];
+      const afterDocKeys = typeof document !== "undefined" ? snapshotOwnKeys(document) : [];
+      const addedWinKeys = diffAddedKeys(afterWinKeys, beforeWinKeys);
+      const addedDocKeys = diffAddedKeys(afterDocKeys, beforeDocKeys);
+      (0, import_safeGlobals.registerRunJSSafeWindowGlobals)(addedWinKeys);
+      (0, import_safeGlobals.registerRunJSSafeDocumentGlobals)(addedDocKeys);
+    }
+    if (error) throw error;
+    return result;
+  });
+}
+__name(runjsRequireAsync, "runjsRequireAsync");
+async function runjsImportAsync(url) {
+  var _a;
+  if (!url || typeof url !== "string") {
+    throw new Error("invalid url");
+  }
+  const u = url.trim();
+  const shouldPatchAmd = !!((_a = globalThis == null ? void 0 : globalThis.define) == null ? void 0 : _a.amd);
+  if (shouldPatchAmd) await prefetchEsmModule(u);
+  return await withRunjsModuleLoadLock(async () => {
+    await waitForRequireJsIdle();
+    const restoreAmd = shouldPatchAmd ? disableAmdDefineTemporarily() : () => {
+    };
+    try {
+      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");
+      try {
+        return await nativeImport();
+      } catch (err) {
+        try {
+          return await evalImport();
+        } catch (err2) {
+          throw err2 || err;
+        }
+      }
+    } finally {
+      restoreAmd();
+    }
+  });
+}
+__name(runjsImportAsync, "runjsImportAsync");
+function stripUrlQueryAndHash(input) {
+  const q = input.indexOf("?");
+  const h = input.indexOf("#");
+  const cut = q >= 0 && h >= 0 ? Math.min(q, h) : q >= 0 ? q : h;
+  return cut >= 0 ? input.slice(0, cut) : input;
+}
+__name(stripUrlQueryAndHash, "stripUrlQueryAndHash");
+function parsePackageSpecifier(input) {
+  if (!input || typeof input !== "string") return null;
+  const s = stripUrlQueryAndHash(input).trim();
+  if (!s) return null;
+  if (s.startsWith("http://") || s.startsWith("https://")) return null;
+  const pathPart = s.replace(/^\//, "");
+  if (!pathPart) return null;
+  if (pathPart.startsWith("@")) {
+    const m2 = pathPart.match(/^(@[^/]+\/[^/]+?)(?:@([^/]+))?(?:\/(.*))?$/);
+    if (!m2) return null;
+    return { name: m2[1], version: m2[2], subpath: m2[3] };
+  }
+  const m = pathPart.match(/^([^/]+?)(?:@([^/]+))?(?:\/(.*))?$/);
+  if (!m) return null;
+  return { name: m[1], version: m[2], subpath: m[3] };
+}
+__name(parsePackageSpecifier, "parsePackageSpecifier");
+function appendQueryParams(specifier, params) {
+  if (!specifier || typeof specifier !== "string") return specifier;
+  const s = specifier.trim();
+  const hashIndex = s.indexOf("#");
+  const baseAndQuery = hashIndex >= 0 ? s.slice(0, hashIndex) : s;
+  const hash = hashIndex >= 0 ? s.slice(hashIndex) : "";
+  const qIndex = baseAndQuery.indexOf("?");
+  const base = qIndex >= 0 ? baseAndQuery.slice(0, qIndex) : baseAndQuery;
+  const query = qIndex >= 0 ? baseAndQuery.slice(qIndex + 1) : "";
+  const search = new URLSearchParams(query);
+  for (const [k, v] of Object.entries(params)) {
+    if (!k) continue;
+    if (search.has(k)) continue;
+    search.set(k, v);
+  }
+  const nextQuery = search.toString();
+  return nextQuery ? `${base}?${nextQuery}${hash}` : `${base}${hash}`;
+}
+__name(appendQueryParams, "appendQueryParams");
+function getEsmCdnBaseUrl() {
+  const g = globalThis;
+  if (typeof (g == null ? void 0 : g.__esm_cdn_base_url__) === "string") return g.__esm_cdn_base_url__;
+  const w = typeof window !== "undefined" ? window : g == null ? void 0 : g.window;
+  if (typeof (w == null ? void 0 : w.__esm_cdn_base_url__) === "string") return w.__esm_cdn_base_url__;
+  return "https://esm.sh";
+}
+__name(getEsmCdnBaseUrl, "getEsmCdnBaseUrl");
+function normalizeModule(mod) {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    const keys = Object.keys(mod);
+    if (keys.length === 1 && keys[0] === "default") {
+      return mod.default;
+    }
+  }
+  return mod;
+}
+__name(normalizeModule, "normalizeModule");
+async function runjsImportModule(ctx, specifier, options) {
+  if (!specifier || typeof specifier !== "string") {
+    throw new Error("invalid url");
+  }
+  let finalSpecifier = specifier;
+  const parsedForRewrite = parsePackageSpecifier(specifier);
+  if ((parsedForRewrite == null ? void 0 : parsedForRewrite.name) === "antd" && !parsedForRewrite.subpath) {
+    const baseUrl = getEsmCdnBaseUrl();
+    if (typeof baseUrl === "string") {
+      const params = { bundle: "1" };
+      const reactInfo = ctx == null ? void 0 : ctx.__runjsExternalReact;
+      const reactVersion = reactInfo == null ? void 0 : reactInfo.version;
+      if (reactVersion && typeof reactVersion === "string") {
+        params.deps = `react@${reactVersion},react-dom@${reactVersion}`;
+      }
+      finalSpecifier = appendQueryParams(finalSpecifier, params);
+    }
+  }
+  const resolvedUrl = (0, import_resolveModuleUrl.resolveModuleUrl)(finalSpecifier, { addSuffix: (options == null ? void 0 : options.addSuffix) ?? true });
+  const importer = (options == null ? void 0 : options.importer) || runjsImportAsync;
+  const g = globalThis;
+  g.__nocobaseImportAsyncCache = g.__nocobaseImportAsyncCache || /* @__PURE__ */ new Map();
+  const cache = g.__nocobaseImportAsyncCache;
+  const loadTask = cache.get(resolvedUrl) || (async () => {
+    const mod2 = await importer(resolvedUrl);
+    return normalizeModule(mod2);
+  })();
+  cache.set(resolvedUrl, loadTask);
+  const mod = await loadTask;
+  const libs = ctx == null ? void 0 : ctx.libs;
+  if (!libs || typeof libs !== "object") return mod;
+  const parsed = parsePackageSpecifier(finalSpecifier);
+  if (!parsed) return mod;
+  const subpath = parsed.subpath || "";
+  if (parsed.name === "react" && !subpath) {
+    (0, import_runjsLibs.setRunJSLibOverride)(ctx, "React", mod);
+    ctx.__runjsExternalReact = { specifier, version: parsed.version, url: resolvedUrl };
+    const domSpecifier = parsed.version ? `react-dom@${parsed.version}/client` : "react-dom/client";
+    try {
+      await ctx.importAsync(domSpecifier);
+    } catch (err) {
+      const e = new Error(
+        `External React has been loaded via ctx.importAsync("${specifier}"), but auto-loading "${domSpecifier}" failed.
+Please run: await ctx.importAsync("${domSpecifier}") to ensure ctx.render uses a matching ReactDOM.`
+      );
+      e.cause = err;
+      throw e;
+    }
+  } else if (parsed.name === "react-dom" && (subpath === "client" || subpath.startsWith("client/"))) {
+    (0, import_runjsLibs.setRunJSLibOverride)(ctx, "ReactDOM", mod);
+    ctx.__runjsExternalReactDOM = { specifier, version: parsed.version, url: resolvedUrl };
+  } else if (parsed.name === "antd" && !subpath) {
+    (0, import_runjsLibs.setRunJSLibOverride)(ctx, "antd", mod);
+    ctx.__runjsExternalAntd = { specifier, version: parsed.version, url: resolvedUrl };
+  } else if (parsed.name === "@ant-design/icons" && !subpath) {
+    (0, import_runjsLibs.setRunJSLibOverride)(ctx, "antdIcons", mod, { topLevelKey: false });
+    ctx.__runjsExternalAntdIcons = { specifier, version: parsed.version, url: resolvedUrl };
+  }
+  return mod;
+}
+__name(runjsImportModule, "runjsImportModule");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runjsImportAsync,
+  runjsImportModule,
+  runjsRequireAsync
+});

package/lib/utils/runjsTemplateCompat.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+type PrepareRunJsCodeOptions = {
+    preprocessTemplates?: boolean;
+};
+/**
+ * 预处理 RunJS 源码，兼容旧版 `{{ ... }}` 占位符。
+ *
+ * 注意：这不是“变量解析”（这里不会计算任何值）。
+ * 它会把代码重写为合法的 JS，并在执行期间调用 `ctx.resolveJsonTemplate(...)` 来解析 {{ ... }}。
+ *
+ * 设计说明：
+ * - 为避免出现 “await is only valid in async functions” 之类的语法错误，会把所有模板解析提升到
+ *   RunJS 程序的顶层，再用变量替换各处的出现位置。
+ * - 对于字符串/模板字面量，不在原位置直接包一层 `await ...`。而是保留原字面量表达式，并通过
+ *   一个小 helper 用 `.split().join()` 做替换，以匹配 `resolveJsonTemplate` 对 object/undefined
+ *   的字符串替换行为。
+ */
+export declare function preprocessRunJsTemplates(code: string, options?: {
+    processBarePlaceholders?: boolean;
+    processStringLiterals?: boolean;
+}): string;
+/**
+ * 为执行准备用户的 RunJS 源码。
+ * - 可选：运行时模板兼容重写
+ * - JSX 转换（sucrase），确保 RunJS 可以安全使用 JSX
+ */
+export declare function prepareRunJsCode(code: string, options?: PrepareRunJsCodeOptions): Promise<string>;
+export {};