@wavemaker-ai/react-runtime 1.0.0-rc.647469 → 1.0.0-rc.647502

package/runtime-dynamic/services/markup-transpiler.js

@@ -0,0 +1,250 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearTranspileCache = clearTranspileCache;
+exports.renderTranspiledMarkup = renderTranspiledMarkup;
+exports.transpileAndRender = transpileAndRender;
+exports.transpileFragment = transpileFragment;
+var _construct2 = _interopRequireDefault(require("@babel/runtime/helpers/construct"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _react = _interopRequireDefault(require("react"));
+var _transpiler = require("@wavemaker-ai/react-codegen/transpiler");
+var _sucrase = require("sucrase");
+var _componentRegistry = require("../registry/component-registry");
+var _util = require("@wavemaker-ai/react-runtime/core/util");
+var _appInitializer = require("../app-initializer");
+var _variableRegistry = require("./variable-registry");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var compiledCache = new Map();
+var transpiledCache = new Map();
+var componentNameCache = new Map();
+var AUTOLAYOUT_SCOPE = "autolayout-dynamic";
+var injectedAutoLayoutRules = new Set();
+function injectAutolayoutCss(rules) {
+  var newRules = rules.filter(function (r) {
+    return !injectedAutoLayoutRules.has(r);
+  });
+  if (newRules.length === 0) return;
+  newRules.forEach(function (r) {
+    return injectedAutoLayoutRules.add(r);
+  });
+  var styleEl = document.querySelector("style[data-wm-scope=\"".concat(AUTOLAYOUT_SCOPE, "\"]"));
+  if (!styleEl) {
+    styleEl = document.createElement("style");
+    styleEl.setAttribute("data-wm-scope", AUTOLAYOUT_SCOPE);
+    document.head.appendChild(styleEl);
+  }
+  styleEl.textContent += "\n" + newRules.join("\n\n") + "\n";
+}
+var UTIL_SCOPE = {
+  formatMessage: _util.formatMessage,
+  _get: _util._get,
+  toNumber: _util.toNumber
+};
+var lazyPartialCache = new Map();
+function markupErrorNode(className, message) {
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: className
+  }, message);
+}
+function extractMarkupComponents(markup) {
+  var cached = componentNameCache.get(markup);
+  if (cached) return cached;
+  var matches = markup.match(/\bWm[A-Z]\w*/g);
+  var result = matches ? (0, _toConsumableArray2["default"])(new Set(matches)) : [];
+  componentNameCache.set(markup, result);
+  return result;
+}
+function resolveScope(imports, appState, markup) {
+  var fragment = appState;
+  var names = ["React", "fragment", "Widgets", "Variables"];
+  var values = [_react["default"], appState, fragment === null || fragment === void 0 ? void 0 : fragment.Widgets, fragment === null || fragment === void 0 ? void 0 : fragment.Variables];
+  var seen = new Set(["React", "fragment", "Widgets", "Variables"]);
+  var knownPartials = new Set((0, _appInitializer.getPartialNames)());
+  var _iterator = _createForOfIteratorHelper(imports),
+    _step;
+  try {
+    var _loop = function _loop() {
+        var importDef = _step.value;
+        var name = importDef.as || importDef.name;
+        if (seen.has(name)) return 0; // continue
+        var component = (0, _componentRegistry.getComponent)(name);
+        if (component) {
+          seen.add(name);
+          names.push(name);
+          values.push(component);
+          return 0; // continue
+        }
+        var partialName = (0, _toConsumableArray2["default"])(knownPartials).find(function (p) {
+          return p.toLowerCase() === name.toLowerCase();
+        });
+        if (partialName) {
+          if (!lazyPartialCache.has(partialName)) {
+            lazyPartialCache.set(partialName, (0, _variableRegistry.createLazyPartial)(partialName));
+          }
+          seen.add(name);
+          names.push(name);
+          values.push(lazyPartialCache.get(partialName));
+        }
+      },
+      _ret;
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _ret = _loop();
+      if (_ret === 0) continue;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (markup) {
+    var _iterator2 = _createForOfIteratorHelper(extractMarkupComponents(markup)),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var name = _step2.value;
+        if (seen.has(name)) continue;
+        var component = (0, _componentRegistry.getComponent)(name);
+        if (component) {
+          seen.add(name);
+          names.push(name);
+          values.push(component);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  for (var _i = 0, _Object$entries = Object.entries(UTIL_SCOPE); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+      _name = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (!seen.has(_name)) {
+      seen.add(_name);
+      names.push(_name);
+      values.push(value);
+    }
+  }
+  return {
+    names: names,
+    values: values
+  };
+}
+function compileJsx(jsxCode) {
+  var result = (0, _sucrase.transform)(jsxCode, {
+    transforms: ["typescript", "jsx"],
+    jsxRuntime: "classic",
+    production: true
+  });
+  return result.code;
+}
+function transpileFragment(markup, variablesOrOptions) {
+  var _transpiled$autolayou;
+  if (!(markup !== null && markup !== void 0 && markup.trim())) return null;
+  var variables;
+  var isPartOfPrefab = false;
+  var prefabName;
+  if (variablesOrOptions && ("isPartOfPrefab" in variablesOrOptions || "prefabName" in variablesOrOptions)) {
+    var _opts$isPartOfPrefab;
+    var opts = variablesOrOptions;
+    variables = opts.variables;
+    isPartOfPrefab = (_opts$isPartOfPrefab = opts.isPartOfPrefab) !== null && _opts$isPartOfPrefab !== void 0 ? _opts$isPartOfPrefab : false;
+    prefabName = opts.prefabName;
+  } else {
+    variables = variablesOrOptions;
+  }
+  var cacheKey = prefabName ? "prefab:".concat(prefabName, ":").concat(markup) : markup;
+  var cached = transpiledCache.get(cacheKey);
+  if (cached) return cached;
+  var config = (0, _appInitializer.getProjectConfig)();
+  var appUrl = config.deployUrl || "./";
+  var transpiled = (0, _transpiler.transformMarkup)(markup, {
+    variables: variables,
+    appUrl: appUrl,
+    isPartOfPrefab: isPartOfPrefab,
+    prefabName: prefabName
+  });
+  if ((_transpiled$autolayou = transpiled.autolayoutCss) !== null && _transpiled$autolayou !== void 0 && _transpiled$autolayou.length) {
+    injectAutolayoutCss(transpiled.autolayoutCss);
+  }
+  transpiledCache.set(cacheKey, transpiled);
+  return transpiled;
+}
+function renderTranspiledMarkup(transpiled, appState) {
+  var cacheKey = transpiled.markup;
+  var cached = compiledCache.get(cacheKey);
+  if (!cached) {
+    var jsxString = transpiled.markup;
+    var jsxWrapped = "function __render__() { return (<React.Fragment>".concat(jsxString.trim() || "null", "</React.Fragment>); }");
+    var compiledCode;
+    try {
+      var compiled = compileJsx(jsxWrapped);
+      compiledCode = "".concat(compiled, "\nreturn __render__();");
+    } catch (compileError) {
+      console.error("[markup-transpiler] Compilation failed:", compileError);
+      console.error("[markup-transpiler] JSX input:", jsxWrapped);
+      return markupErrorNode("wm-transpile-error", "Transpilation error");
+    }
+    var _resolveScope = resolveScope(transpiled.imports, appState, jsxWrapped),
+      names = _resolveScope.names,
+      values = _resolveScope.values;
+    var renderFn;
+    try {
+      renderFn = (0, _construct2["default"])(Function, (0, _toConsumableArray2["default"])(names).concat([compiledCode]));
+    } catch (constructionError) {
+      console.error("[markup-transpiler] Function compilation failed:", constructionError);
+      console.error("[markup-transpiler] Compiled code:", compiledCode);
+      return markupErrorNode("wm-transpile-error", "Compilation error");
+    }
+    var reactIdx = names.indexOf("React");
+    var fragmentIdx = names.indexOf("fragment");
+    var widgetsIdx = names.indexOf("Widgets");
+    var variablesIdx = names.indexOf("Variables");
+    cached = {
+      renderFn: renderFn,
+      scopeNames: names,
+      runtimeValues: values,
+      reactIdx: reactIdx,
+      fragmentIdx: fragmentIdx,
+      widgetsIdx: widgetsIdx,
+      variablesIdx: variablesIdx
+    };
+    compiledCache.set(cacheKey, cached);
+  }
+
+  // Mutate the 4 dynamic slots in-place — avoids a per-render array allocation.
+  var runtimeFragment = appState;
+  cached.runtimeValues[cached.reactIdx] = _react["default"];
+  cached.runtimeValues[cached.fragmentIdx] = appState;
+  cached.runtimeValues[cached.widgetsIdx] = runtimeFragment === null || runtimeFragment === void 0 ? void 0 : runtimeFragment.Widgets;
+  cached.runtimeValues[cached.variablesIdx] = runtimeFragment === null || runtimeFragment === void 0 ? void 0 : runtimeFragment.Variables;
+  try {
+    var _cached;
+    return (_cached = cached).renderFn.apply(_cached, (0, _toConsumableArray2["default"])(cached.runtimeValues));
+  } catch (renderError) {
+    console.error("[markup-transpiler] Render failed:", renderError);
+    return markupErrorNode("wm-render-error", "Render error");
+  }
+}
+function transpileAndRender(markup, appState, variables) {
+  var transpiled = transpileFragment(markup, variables);
+  if (!transpiled) return null;
+  return renderTranspiledMarkup(transpiled, appState);
+}
+function clearTranspileCache() {
+  compiledCache.clear();
+  transpiledCache.clear();
+  componentNameCache.clear();
+  lazyPartialCache.clear();
+  injectedAutoLayoutRules.clear();
+  var styleEl = document.querySelector("style[data-wm-scope=\"".concat(AUTOLAYOUT_SCOPE, "\"]"));
+  if (styleEl) styleEl.remove();
+}

package/runtime-dynamic/services/prefab-resources.d.ts

@@ -0,0 +1,18 @@
+/** Cleared with `clearComponentRefCache` so a new preview session can reload scripts/styles. */
+export declare function clearPrefabResourcesLoaded(): void;
+/**
+ * Mirrors Angular `getPrefabResourceUrl` in `runtime-base` `prefab-manager.service.ts`.
+ */
+export declare function getPrefabResourceUrl(resourcePath: string, resourceBasePath: string): string;
+export type PrefabConfigResources = {
+    resources?: {
+        styles?: string[];
+        scripts?: string[];
+    };
+};
+/**
+ * Loads `resources.styles` / `resources.scripts` from prefab `config.json` like Angular
+ * `PrefabManagerService.loadDependencies` (`loadStyleSheets` / `loadScripts` from `@wm/core`).
+ * Runs at most once per `prefabName` per page session.
+ */
+export declare function loadPrefabResourcesFromConfig(prefabName: string, config: PrefabConfigResources): Promise<void>;

package/runtime-dynamic/services/prefab-resources.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearPrefabResourcesLoaded = clearPrefabResourcesLoaded;
+exports.getPrefabResourceUrl = getPrefabResourceUrl;
+exports.loadPrefabResourcesFromConfig = loadPrefabResourcesFromConfig;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _endsWith = _interopRequireDefault(require("lodash-es/endsWith"));
+var _previewResourceBase = require("../preview-resource-base");
+var _fragmentUrl = require("./fragment-url");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/** Do not inject Main page CSS from prefab config — same as Angular `PrefabManagerService.loadStyles`. */
+var PREFAB_MAIN_PAGE_CSS_SUFFIX = "/pages/Main/Main.css";
+var prefabResourcesLoaded = new Set();
+
+/** Cleared with `clearComponentRefCache` so a new preview session can reload scripts/styles. */
+function clearPrefabResourcesLoaded() {
+  prefabResourcesLoaded.clear();
+}
+function isAbsoluteResourcePath(path) {
+  return /^https?:\/\//i.test(path) || path.startsWith("//");
+}
+
+/**
+ * Mirrors Angular `getPrefabResourceUrl` in `runtime-base` `prefab-manager.service.ts`.
+ */
+function getPrefabResourceUrl(resourcePath, resourceBasePath) {
+  if (isAbsoluteResourcePath(resourcePath)) {
+    return resourcePath;
+  }
+  return "".concat(resourceBasePath).concat(resourcePath);
+}
+function isStylesheetLoaded(href) {
+  var links = document.getElementsByTagName("link");
+  for (var i = 0; i < links.length; i++) {
+    var el = links[i];
+    if (el.rel === "stylesheet" && el.getAttribute("href") === href) return true;
+  }
+  return false;
+}
+function loadStyleSheetOnce(href) {
+  var resolved = (0, _previewResourceBase.resolvePreviewFetchUrl)(href);
+  if (!resolved || isStylesheetLoaded(resolved)) return;
+  var link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.type = "text/css";
+  link.href = resolved;
+  document.head.appendChild(link);
+}
+function isScriptLoaded(src) {
+  var scripts = document.getElementsByTagName("script");
+  for (var i = 0; i < scripts.length; i++) {
+    if (scripts[i].getAttribute("src") === src) return true;
+  }
+  return false;
+}
+function loadScriptOnce(src) {
+  var trimmed = (0, _previewResourceBase.resolvePreviewFetchUrl)(src.trim());
+  if (!trimmed || isScriptLoaded(trimmed)) {
+    return Promise.resolve();
+  }
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.async = false;
+    script.src = trimmed;
+    script.onload = function () {
+      return resolve();
+    };
+    script.onerror = function () {
+      return reject(new Error("Failed to load script: ".concat(trimmed)));
+    };
+    document.head.appendChild(script);
+  });
+}
+/**
+ * Loads `resources.styles` / `resources.scripts` from prefab `config.json` like Angular
+ * `PrefabManagerService.loadDependencies` (`loadStyleSheets` / `loadScripts` from `@wm/core`).
+ * Runs at most once per `prefabName` per page session.
+ */
+function loadPrefabResourcesFromConfig(_x, _x2) {
+  return _loadPrefabResourcesFromConfig.apply(this, arguments);
+}
+function _loadPrefabResourcesFromConfig() {
+  _loadPrefabResourcesFromConfig = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(prefabName, config) {
+    var _config$resources$sty, _config$resources, _config$resources$scr, _config$resources2;
+    var styles, scripts, basePath, styleUrls, scriptUrls, _iterator, _step, src;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (!prefabResourcesLoaded.has(prefabName)) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return");
+        case 2:
+          styles = (_config$resources$sty = (_config$resources = config.resources) === null || _config$resources === void 0 ? void 0 : _config$resources.styles) !== null && _config$resources$sty !== void 0 ? _config$resources$sty : [];
+          scripts = ((_config$resources$scr = (_config$resources2 = config.resources) === null || _config$resources2 === void 0 ? void 0 : _config$resources2.scripts) !== null && _config$resources$scr !== void 0 ? _config$resources$scr : []).filter(function (s) {
+            return !s.startsWith("npm://");
+          });
+          basePath = (0, _fragmentUrl.getPrefabBaseUrl)(prefabName);
+          styleUrls = styles.map(function (url) {
+            return getPrefabResourceUrl(url, basePath);
+          }).filter(function (url) {
+            return !!url && !(0, _endsWith["default"])(url, PREFAB_MAIN_PAGE_CSS_SUFFIX);
+          });
+          scriptUrls = scripts.map(function (url) {
+            return getPrefabResourceUrl(url, basePath);
+          });
+          styleUrls.forEach(loadStyleSheetOnce);
+          _iterator = _createForOfIteratorHelper(scriptUrls);
+          _context.prev = 9;
+          _iterator.s();
+        case 11:
+          if ((_step = _iterator.n()).done) {
+            _context.next = 23;
+            break;
+          }
+          src = _step.value;
+          _context.prev = 13;
+          _context.next = 16;
+          return loadScriptOnce(src);
+        case 16:
+          _context.next = 21;
+          break;
+        case 18:
+          _context.prev = 18;
+          _context.t0 = _context["catch"](13);
+          console.warn("[prefab-resources] Optional script failed:", src, _context.t0);
+        case 21:
+          _context.next = 11;
+          break;
+        case 23:
+          _context.next = 28;
+          break;
+        case 25:
+          _context.prev = 25;
+          _context.t1 = _context["catch"](9);
+          _iterator.e(_context.t1);
+        case 28:
+          _context.prev = 28;
+          _iterator.f();
+          return _context.finish(28);
+        case 31:
+          prefabResourcesLoaded.add(prefabName);
+        case 32:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[9, 25, 28, 31], [13, 18]]);
+  }));
+  return _loadPrefabResourcesFromConfig.apply(this, arguments);
+}

package/runtime-dynamic/services/resource-manager.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchResource<T = unknown>(url: string, useCache?: boolean): Promise<T>;
+export declare function clearResourceCache(): void;

package/runtime-dynamic/services/resource-manager.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearResourceCache = clearResourceCache;
+exports.fetchResource = fetchResource;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _axios = _interopRequireDefault(require("axios"));
+var _previewResourceBase = require("../preview-resource-base");
+var _app = require("@wavemaker-ai/react-runtime/core/app.service");
+var cache = new Map();
+function fetchResource(_x) {
+  return _fetchResource.apply(this, arguments);
+}
+function _fetchResource() {
+  _fetchResource = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(url) {
+    var useCache,
+      resolvedUrl,
+      response,
+      data,
+      _error$response,
+      status,
+      _args = arguments;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          useCache = _args.length > 1 && _args[1] !== undefined ? _args[1] : true;
+          resolvedUrl = (0, _previewResourceBase.resolvePreviewFetchUrl)(url);
+          if (!(useCache && cache.has(resolvedUrl))) {
+            _context.next = 4;
+            break;
+          }
+          return _context.abrupt("return", cache.get(resolvedUrl));
+        case 4:
+          _context.prev = 4;
+          _context.next = 7;
+          return _axios["default"].get(resolvedUrl);
+        case 7:
+          response = _context.sent;
+          data = response.data;
+          if (useCache) {
+            cache.set(resolvedUrl, data);
+          }
+          return _context.abrupt("return", data);
+        case 13:
+          _context.prev = 13;
+          _context.t0 = _context["catch"](4);
+          status = _context.t0 === null || _context.t0 === void 0 || (_error$response = _context.t0.response) === null || _error$response === void 0 ? void 0 : _error$response.status;
+          if (status === 401 || status === 403) {
+            (0, _app.handle401)();
+          }
+          throw _context.t0;
+        case 18:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[4, 13]]);
+  }));
+  return _fetchResource.apply(this, arguments);
+}
+function clearResourceCache() {
+  cache.clear();
+}

package/runtime-dynamic/services/script-executor.d.ts

@@ -0,0 +1,8 @@
+type ScriptFn = (app: unknown, page: unknown) => void;
+export declare enum ScriptScope {
+    PAGE = "Page",
+    PARTIAL = "Partial",
+    PREFAB = "Prefab"
+}
+export declare function buildAddPageScript(script: string, scopeKind: ScriptScope, componentName: string): ScriptFn;
+export {};

package/runtime-dynamic/services/script-executor.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScriptScope = void 0;
+exports.buildAddPageScript = buildAddPageScript;
+var _construct2 = _interopRequireDefault(require("@babel/runtime/helpers/construct"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var lodash = _interopRequireWildcard(require("lodash-es"));
+var _moment = _interopRequireDefault(require("moment"));
+var _utils = require("@wavemaker-ai/react-runtime/core/util/utils");
+var _cache = require("./cache");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var ScriptScope = exports.ScriptScope = /*#__PURE__*/function (ScriptScope) {
+  ScriptScope["PAGE"] = "Page";
+  ScriptScope["PARTIAL"] = "Partial";
+  ScriptScope["PREFAB"] = "Prefab";
+  return ScriptScope;
+}({});
+var IMPORT_LINE_RE = /^\s*import\s+.*?["'];?\s*$/gm;
+var EXPORTED_FN_HEADER_RE = /^\s*export\s+default\s+function\s+\w+\s*\([^)]*\)\s*\{/m;
+
+// Proxy-safe structuredClone: the reactive proxy system wraps variable dataSets
+// in Proxy objects, which native structuredClone cannot handle. This shim
+// unwraps proxies via JSON round-trip before cloning.
+function safeStructuredClone(value) {
+  try {
+    return structuredClone(value);
+  } catch (_unused) {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_unused2) {
+      return value;
+    }
+  }
+}
+var SCRIPT_GLOBALS = {
+  _: lodash,
+  moment: _moment["default"],
+  Utils: _utils.Utils,
+  structuredClone: safeStructuredClone
+};
+
+// Globals loaded asynchronously (e.g. via dynamic import in app-initializer).
+// Resolved from window at script execution time, not at compile time.
+var DEFERRED_GLOBALS = ["QRCode"];
+function prepareScript(raw) {
+  var code = raw.replace(IMPORT_LINE_RE, "");
+  var headerMatch = code.match(EXPORTED_FN_HEADER_RE);
+  if (headerMatch) {
+    var headerEnd = code.indexOf(headerMatch[0]) + headerMatch[0].length;
+    var body = code.slice(headerEnd);
+    var lastBrace = body.lastIndexOf("}");
+    return lastBrace >= 0 ? body.slice(0, lastBrace) : body;
+  }
+  code = code.replace(/^\s*export\s+default\s+/m, "");
+  return code;
+}
+function buildAddPageScript(script, scopeKind, componentName) {
+  if (!script) return function () {};
+  var cacheKey = "".concat(scopeKind, ":").concat(componentName);
+  var cached = (0, _cache.getScriptFromCache)(cacheKey);
+  if (cached) return cached;
+  try {
+    var cleanScript = prepareScript(script);
+    var allNames = [].concat((0, _toConsumableArray2["default"])(Object.keys(SCRIPT_GLOBALS)), DEFERRED_GLOBALS);
+    var compiledFn = (0, _construct2["default"])(Function, ["App", scopeKind].concat((0, _toConsumableArray2["default"])(allNames), [cleanScript]));
+    var staticValues = Object.keys(SCRIPT_GLOBALS).map(function (k) {
+      return SCRIPT_GLOBALS[k];
+    });
+    var boundFn = function boundFn(app, page) {
+      try {
+        var deferredValues = DEFERRED_GLOBALS.map(function (k) {
+          return window[k];
+        });
+        compiledFn.apply(void 0, [app, page].concat((0, _toConsumableArray2["default"])(staticValues), (0, _toConsumableArray2["default"])(deferredValues)));
+      } catch (runtimeError) {
+        console.error("[script-executor] Runtime error in ".concat(scopeKind, " script \"").concat(componentName, "\":"), runtimeError);
+      }
+    };
+    (0, _cache.setScriptInCache)(cacheKey, boundFn);
+    return boundFn;
+  } catch (compileError) {
+    console.error("[script-executor] Compilation error in ".concat(scopeKind, " script \"").concat(componentName, "\":"), compileError);
+    return function () {};
+  }
+}

package/runtime-dynamic/services/variable-factory.d.ts

@@ -0,0 +1,2 @@
+import { type VariablesResult } from "./variable-registry";
+export declare function createVariablesFromJson(rawVariables: Record<string, unknown>, scopeProxy: any): VariablesResult;