@wavemaker-ai/react-runtime 1.0.0-rc.309

package/runtime-dynamic/services/cache.d.ts

@@ -0,0 +1,29 @@
+import type React from "react";
+import { ComponentType } from "./fragment-url";
+export interface PageMinJSON {
+    markup: string;
+    script: string;
+    styles: string;
+    variables: string;
+    config?: string;
+}
+export interface DecodedFragment {
+    markup: string;
+    script: string;
+    styles: string;
+    variables: Record<string, unknown>;
+    config?: Record<string, unknown>;
+}
+type ScriptFn = (...args: unknown[]) => void;
+export declare const getPrefabConfigFromCache: (url: string) => Promise<Record<string, unknown>> | undefined;
+export declare function setPrefabConfigInCache(url: string, config: Promise<Record<string, unknown>>): void;
+export declare function deletePrefabConfigFromCache(url: string): void;
+export declare const getFragmentFromCache: (url: string) => Promise<DecodedFragment> | undefined;
+export declare function setFragmentInCache(url: string, fragment: Promise<DecodedFragment>): void;
+export declare function deleteFragmentFromCache(url: string): void;
+export declare const getComponentFromCache: (componentType: ComponentType, componentName: string) => React.ComponentType<any> | undefined;
+export declare function setComponentInCache(componentType: ComponentType, componentName: string, component: React.ComponentType<any>): void;
+export declare const getScriptFromCache: (identifier: string) => ScriptFn | undefined;
+export declare function setScriptInCache(identifier: string, scriptFn: ScriptFn): void;
+export declare function clearAllCaches(): void;
+export {};

package/runtime-dynamic/services/cache.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearAllCaches = clearAllCaches;
+exports.deleteFragmentFromCache = deleteFragmentFromCache;
+exports.deletePrefabConfigFromCache = deletePrefabConfigFromCache;
+exports.getScriptFromCache = exports.getPrefabConfigFromCache = exports.getFragmentFromCache = exports.getComponentFromCache = void 0;
+exports.setComponentInCache = setComponentInCache;
+exports.setFragmentInCache = setFragmentInCache;
+exports.setPrefabConfigInCache = setPrefabConfigInCache;
+exports.setScriptInCache = setScriptInCache;
+var fragmentCache = new Map();
+var componentCache = new Map();
+var scriptCache = new Map();
+var prefabConfigCache = new Map();
+var getPrefabConfigFromCache = exports.getPrefabConfigFromCache = function getPrefabConfigFromCache(url) {
+  return prefabConfigCache.get(url);
+};
+function setPrefabConfigInCache(url, config) {
+  prefabConfigCache.set(url, config);
+}
+function deletePrefabConfigFromCache(url) {
+  prefabConfigCache["delete"](url);
+}
+var getFragmentFromCache = exports.getFragmentFromCache = function getFragmentFromCache(url) {
+  return fragmentCache.get(url);
+};
+function setFragmentInCache(url, fragment) {
+  fragmentCache.set(url, fragment);
+}
+function deleteFragmentFromCache(url) {
+  fragmentCache["delete"](url);
+}
+var getComponentFromCache = exports.getComponentFromCache = function getComponentFromCache(componentType, componentName) {
+  var _componentCache$get;
+  return (_componentCache$get = componentCache.get(componentType)) === null || _componentCache$get === void 0 ? void 0 : _componentCache$get.get(componentName);
+};
+function setComponentInCache(componentType, componentName, component) {
+  if (!componentCache.has(componentType)) {
+    componentCache.set(componentType, new Map());
+  }
+  componentCache.get(componentType).set(componentName, component);
+}
+var getScriptFromCache = exports.getScriptFromCache = function getScriptFromCache(identifier) {
+  return scriptCache.get(identifier);
+};
+function setScriptInCache(identifier, scriptFn) {
+  scriptCache.set(identifier, scriptFn);
+}
+function clearAllCaches() {
+  fragmentCache.clear();
+  componentCache.clear();
+  scriptCache.clear();
+  prefabConfigCache.clear();
+}

package/runtime-dynamic/services/component-ref-provider.d.ts

@@ -0,0 +1,12 @@
+import { ComponentType } from "./fragment-url";
+import type { DecodedFragment } from "./cache";
+export interface GetComponentOptions {
+    prefabName?: string;
+}
+export declare function getComponentRef(componentName: string, componentType: ComponentType, options?: GetComponentOptions): Promise<DecodedFragment>;
+export declare function getPrefabConfig(prefabName: string): Promise<Record<string, unknown>>;
+/**
+ * Clears fetched fragments, built components, resource HTTP cache, prefab injected assets,
+ * transpiled markup cache, and compiled variable factories so the next load rebuilds from disk.
+ */
+export declare function clearComponentRefCache(): void;

package/runtime-dynamic/services/component-ref-provider.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearComponentRefCache = clearComponentRefCache;
+exports.getComponentRef = getComponentRef;
+exports.getPrefabConfig = getPrefabConfig;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _isString = _interopRequireDefault(require("lodash-es/isString"));
+var _transpiler = require("@wavemaker-ai/react-codegen/transpiler");
+var _resourceManager = require("./resource-manager");
+var _fragmentUrl = require("./fragment-url");
+var _cache = require("./cache");
+var _utils = require("../utils");
+var _prefabResources = require("./prefab-resources");
+var _markupTranspiler = require("./markup-transpiler");
+var _variableTranspiler = require("./variable-transpiler");
+/** Deduplicate in-flight loads for the same cache key (fragment JSON, prefab config, etc.). */
+function getOrCreateCachedPromise(get, set, del, key, create) {
+  var existing = get(key);
+  if (existing) return existing;
+  var pending = create();
+  set(key, pending);
+  pending["catch"](function () {
+    return del(key);
+  });
+  return pending;
+}
+function decodeFragment(raw) {
+  return {
+    markup: (0, _utils.decodeURIComponentSafe)(raw.markup || ""),
+    script: (0, _utils.decodeURIComponentSafe)(raw.script || ""),
+    styles: (0, _utils.decodeURIComponentSafe)(raw.styles || ""),
+    variables: (0, _utils.parseJsonSafe)((0, _utils.decodeURIComponentSafe)(raw.variables || "{}")),
+    config: raw.config ? (0, _utils.parseJsonSafe)((0, _utils.decodeURIComponentSafe)(raw.config)) : undefined
+  };
+}
+function loadFragment(_x, _x2, _x3) {
+  return _loadFragment.apply(this, arguments);
+}
+function _loadFragment() {
+  _loadFragment = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(componentName, componentType, prefabName) {
+    var url;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          url = (0, _fragmentUrl.getFragmentUrl)(componentName, componentType, prefabName);
+          return _context.abrupt("return", getOrCreateCachedPromise(_cache.getFragmentFromCache, _cache.setFragmentInCache, _cache.deleteFragmentFromCache, url, function () {
+            return (0, _resourceManager.fetchResource)(url, true).then(decodeFragment);
+          }));
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _loadFragment.apply(this, arguments);
+}
+function getComponentRef(_x4, _x5, _x6) {
+  return _getComponentRef.apply(this, arguments);
+}
+function _getComponentRef() {
+  _getComponentRef = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(componentName, componentType, options) {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          return _context2.abrupt("return", loadFragment(componentName, componentType, options === null || options === void 0 ? void 0 : options.prefabName));
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _getComponentRef.apply(this, arguments);
+}
+function buildDynamicPrefabProps(result) {
+  var _result$properties;
+  var dynamicProps = {};
+  var props = (_result$properties = result.properties) !== null && _result$properties !== void 0 ? _result$properties : {};
+  for (var _i = 0, _Object$keys = Object.keys(props); _i < _Object$keys.length; _i++) {
+    var k = _Object$keys[_i];
+    var value = props[k].value;
+    var type = props[k].type;
+    if (type === "number" || type === "integer") {
+      value = Number(value);
+    }
+    if (type === "boolean") {
+      value = Boolean(value);
+    }
+    if ((0, _isString["default"])(value) && value.startsWith("bind:")) {
+      var exStr = decodeURIComponent(value.substring(5));
+      dynamicProps[k] = "".concat((0, _transpiler.transformEx)(exStr, "fragment", "attr"));
+    } else {
+      dynamicProps[k] = value === undefined ? null : value;
+    }
+  }
+  return dynamicProps;
+}
+function getPrefabConfig(_x7) {
+  return _getPrefabConfig.apply(this, arguments);
+}
+/**
+ * Clears fetched fragments, built components, resource HTTP cache, prefab injected assets,
+ * transpiled markup cache, and compiled variable factories so the next load rebuilds from disk.
+ */
+function _getPrefabConfig() {
+  _getPrefabConfig = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(prefabName) {
+    var url;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          url = (0, _fragmentUrl.getPrefabConfigUrl)(prefabName);
+          return _context4.abrupt("return", getOrCreateCachedPromise(_cache.getPrefabConfigFromCache, _cache.setPrefabConfigInCache, _cache.deletePrefabConfigFromCache, url, /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+            var raw;
+            return _regenerator["default"].wrap(function _callee3$(_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 2;
+                  return (0, _resourceManager.fetchResource)(url, true);
+                case 2:
+                  raw = _context3.sent;
+                  _context3.next = 5;
+                  return (0, _prefabResources.loadPrefabResourcesFromConfig)(prefabName, raw);
+                case 5:
+                  return _context3.abrupt("return", buildDynamicPrefabProps(raw));
+                case 6:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          }))));
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _getPrefabConfig.apply(this, arguments);
+}
+function clearComponentRefCache() {
+  (0, _resourceManager.clearResourceCache)();
+  (0, _cache.clearAllCaches)();
+  (0, _prefabResources.clearPrefabResourcesLoaded)();
+  (0, _markupTranspiler.clearTranspileCache)();
+  (0, _variableTranspiler.clearVariablesCache)();
+}

package/runtime-dynamic/services/css-scoping.d.ts

@@ -0,0 +1,2 @@
+export declare function scopeComponentStyles(componentName: string, componentType: string, styles: string): string;
+export declare function removeComponentStyles(componentName: string, componentType: string): void;

package/runtime-dynamic/services/css-scoping.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeComponentStyles = removeComponentStyles;
+exports.scopeComponentStyles = scopeComponentStyles;
+// Cache scoped CSS strings keyed by `${scopeSelector}::${rawStyles}` to avoid
+// re-running the regex on every component mount for the same styles.
+var scopedCssCache = new Map();
+function prefixSelectors(css, scope) {
+  return css.replace(/([^{}@]+)\{/g, function (match, selectorsStr) {
+    if (selectorsStr.trim().startsWith("@")) return match;
+    var selectors = selectorsStr.split(",");
+    var prefixed = selectors.map(function (selector) {
+      var trimmed = selector.trim();
+      if (!trimmed) return selector;
+      if (trimmed.startsWith(":root") || trimmed.startsWith("html") || trimmed.startsWith("body")) {
+        return selector;
+      }
+      return "".concat(scope, " ").concat(trimmed);
+    });
+    return "".concat(prefixed.join(", "), " {");
+  });
+}
+function scopeComponentStyles(componentName, componentType, styles) {
+  var _styleElement$textCon;
+  if (!styles) return "";
+  var scopeSelector = ".wm-app";
+  var scopeAttribute = "".concat(componentType, "-").concat(componentName);
+  var cacheKey = "".concat(scopeSelector, "::").concat(styles);
+  var scopedCss = scopedCssCache.get(cacheKey);
+  if (!scopedCss) {
+    scopedCss = prefixSelectors(styles, scopeSelector);
+    scopedCssCache.set(cacheKey, scopedCss);
+  }
+  var styleElement = document.createElement("style");
+  styleElement.setAttribute("data-wm-scope", scopeAttribute);
+  styleElement.textContent = scopedCss;
+  var existing = document.querySelector("style[data-wm-scope=\"".concat(scopeAttribute, "\"]"));
+  if (existing) {
+    existing.remove();
+  }
+  document.head.appendChild(styleElement);
+  return (_styleElement$textCon = styleElement.textContent) !== null && _styleElement$textCon !== void 0 ? _styleElement$textCon : "";
+}
+function removeComponentStyles(componentName, componentType) {
+  var scopeAttribute = "".concat(componentType, "-").concat(componentName);
+  var existing = document.querySelector("style[data-wm-scope=\"".concat(scopeAttribute, "\"]"));
+  if (existing) {
+    existing.remove();
+  }
+}

package/runtime-dynamic/services/fragment-url.d.ts

@@ -0,0 +1,16 @@
+export declare enum ComponentType {
+    PAGE = "PAGE",
+    PARTIAL = "PARTIAL",
+    PREFAB = "PREFAB",
+    WIDGET = "WIDGET"
+}
+/** Same as Angular `isPrefabInPreview` (runtime-base `util/utils.ts`). */
+export declare function isPrefabSelfPreview(prefabName: string): boolean;
+/**
+ * Same rules as Angular `getPrefabBaseUrl` (runtime-base `util/utils.ts`):
+ * preview + `__self__` → `.`; preview + named prefab → `app/prefabs/{name}`;
+ * non-preview → `{cdnUrl}resources/{name}`.
+ */
+export declare function getPrefabBaseUrl(prefabName: string): string;
+export declare function getFragmentUrl(componentName: string, componentType: ComponentType, prefabName?: string): string;
+export declare const getPrefabConfigUrl: (prefabName: string) => string;

package/runtime-dynamic/services/fragment-url.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ComponentType = void 0;
+exports.getFragmentUrl = getFragmentUrl;
+exports.getPrefabBaseUrl = getPrefabBaseUrl;
+exports.getPrefabConfigUrl = void 0;
+exports.isPrefabSelfPreview = isPrefabSelfPreview;
+var _appInitializer = require("../app-initializer");
+var ComponentType = exports.ComponentType = /*#__PURE__*/function (ComponentType) {
+  ComponentType["PAGE"] = "PAGE";
+  ComponentType["PARTIAL"] = "PARTIAL";
+  ComponentType["PREFAB"] = "PREFAB";
+  ComponentType["WIDGET"] = "WIDGET";
+  return ComponentType;
+}({});
+/** Same as Angular `isPrefabInPreview` (runtime-base `util/utils.ts`). */
+function isPrefabSelfPreview(prefabName) {
+  return prefabName === "__self__";
+}
+
+/**
+ * Same rules as Angular `getPrefabBaseUrl` (runtime-base `util/utils.ts`):
+ * preview + `__self__` → `.`; preview + named prefab → `app/prefabs/{name}`;
+ * non-preview → `{cdnUrl}resources/{name}`.
+ */
+function getPrefabBaseUrl(prefabName) {
+  if (isPrefabSelfPreview(prefabName)) {
+    return ".";
+  }
+  var isPreview = (0, _appInitializer.getProjectConfig)().isPreview;
+  var cdn = ((0, _appInitializer.getProjectConfig)().cdnUrl || "").replace(/\/+$/, "");
+  if (isPreview) {
+    return "app/prefabs/".concat(prefabName);
+  }
+  return "".concat(cdn, "resources/").concat(prefabName);
+}
+
+/** Join deployUrl with prefab-relative path; handles `getPrefabBaseUrl` === `.` like Angular. */
+function deployPlusPrefabPath(prefabName, pathUnderPrefab) {
+  var deployRaw = (0, _appInitializer.getProjectConfig)().deployUrl || "./";
+  var deploy = deployRaw.replace(/\/+$/, "");
+  var pb = getPrefabBaseUrl(prefabName);
+  if (pb === ".") {
+    if (deploy === "." || deploy === "") {
+      return "./".concat(pathUnderPrefab);
+    }
+    return "".concat(deploy, "/").concat(pathUnderPrefab);
+  }
+  if (deploy === "." || deploy === "") {
+    return "".concat(pb, "/").concat(pathUnderPrefab);
+  }
+  return "".concat(deploy, "/").concat(pb, "/").concat(pathUnderPrefab);
+}
+function getFragmentUrl(componentName, componentType, prefabName) {
+  var baseUrl = (0, _appInitializer.getProjectConfig)().deployUrl || "./";
+  var pageJsonPath = "pages/".concat(componentName, "/page.min.json");
+  switch (componentType) {
+    case ComponentType.PAGE:
+    case ComponentType.PARTIAL:
+      return prefabName ? deployPlusPrefabPath(prefabName, pageJsonPath) : "".concat(baseUrl).concat(pageJsonPath);
+    case ComponentType.PREFAB:
+      return deployPlusPrefabPath(componentName, "pages/Main/page.min.json");
+    case ComponentType.WIDGET:
+      return "".concat(baseUrl, "custom-widgets/").concat(componentName, "/page.min.json");
+    default:
+      return "".concat(baseUrl).concat(pageJsonPath);
+  }
+}
+var getPrefabConfigUrl = exports.getPrefabConfigUrl = function getPrefabConfigUrl(prefabName) {
+  return deployPlusPrefabPath(prefabName, "config.json");
+};

package/runtime-dynamic/services/index.d.ts

@@ -0,0 +1,10 @@
+export { fetchResource, clearResourceCache } from "./resource-manager";
+export { ComponentType, getFragmentUrl, getPrefabBaseUrl, getPrefabConfigUrl, isPrefabSelfPreview, } from "./fragment-url";
+export { getComponentRef, clearComponentRefCache } from "./component-ref-provider";
+export { getPrefabResourceUrl } from "./prefab-resources";
+export { buildAddPageScript } from "./script-executor";
+export { transpileAndBuildGetVariables, clearVariablesCache } from "./variable-transpiler";
+export { scopeComponentStyles, removeComponentStyles } from "./css-scoping";
+export { loadAppExtensions } from "./app-extension-provider";
+export type { PageMinJSON, DecodedFragment } from "./cache";
+export { getFragmentFromCache, setFragmentInCache, getComponentFromCache, setComponentInCache, getScriptFromCache, setScriptInCache, clearAllCaches, } from "./cache";

package/runtime-dynamic/services/index.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ComponentType", {
+  enumerable: true,
+  get: function get() {
+    return _fragmentUrl.ComponentType;
+  }
+});
+Object.defineProperty(exports, "buildAddPageScript", {
+  enumerable: true,
+  get: function get() {
+    return _scriptExecutor.buildAddPageScript;
+  }
+});
+Object.defineProperty(exports, "clearAllCaches", {
+  enumerable: true,
+  get: function get() {
+    return _cache.clearAllCaches;
+  }
+});
+Object.defineProperty(exports, "clearComponentRefCache", {
+  enumerable: true,
+  get: function get() {
+    return _componentRefProvider.clearComponentRefCache;
+  }
+});
+Object.defineProperty(exports, "clearResourceCache", {
+  enumerable: true,
+  get: function get() {
+    return _resourceManager.clearResourceCache;
+  }
+});
+Object.defineProperty(exports, "clearVariablesCache", {
+  enumerable: true,
+  get: function get() {
+    return _variableTranspiler.clearVariablesCache;
+  }
+});
+Object.defineProperty(exports, "fetchResource", {
+  enumerable: true,
+  get: function get() {
+    return _resourceManager.fetchResource;
+  }
+});
+Object.defineProperty(exports, "getComponentFromCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.getComponentFromCache;
+  }
+});
+Object.defineProperty(exports, "getComponentRef", {
+  enumerable: true,
+  get: function get() {
+    return _componentRefProvider.getComponentRef;
+  }
+});
+Object.defineProperty(exports, "getFragmentFromCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.getFragmentFromCache;
+  }
+});
+Object.defineProperty(exports, "getFragmentUrl", {
+  enumerable: true,
+  get: function get() {
+    return _fragmentUrl.getFragmentUrl;
+  }
+});
+Object.defineProperty(exports, "getPrefabBaseUrl", {
+  enumerable: true,
+  get: function get() {
+    return _fragmentUrl.getPrefabBaseUrl;
+  }
+});
+Object.defineProperty(exports, "getPrefabConfigUrl", {
+  enumerable: true,
+  get: function get() {
+    return _fragmentUrl.getPrefabConfigUrl;
+  }
+});
+Object.defineProperty(exports, "getPrefabResourceUrl", {
+  enumerable: true,
+  get: function get() {
+    return _prefabResources.getPrefabResourceUrl;
+  }
+});
+Object.defineProperty(exports, "getScriptFromCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.getScriptFromCache;
+  }
+});
+Object.defineProperty(exports, "isPrefabSelfPreview", {
+  enumerable: true,
+  get: function get() {
+    return _fragmentUrl.isPrefabSelfPreview;
+  }
+});
+Object.defineProperty(exports, "loadAppExtensions", {
+  enumerable: true,
+  get: function get() {
+    return _appExtensionProvider.loadAppExtensions;
+  }
+});
+Object.defineProperty(exports, "removeComponentStyles", {
+  enumerable: true,
+  get: function get() {
+    return _cssScoping.removeComponentStyles;
+  }
+});
+Object.defineProperty(exports, "scopeComponentStyles", {
+  enumerable: true,
+  get: function get() {
+    return _cssScoping.scopeComponentStyles;
+  }
+});
+Object.defineProperty(exports, "setComponentInCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.setComponentInCache;
+  }
+});
+Object.defineProperty(exports, "setFragmentInCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.setFragmentInCache;
+  }
+});
+Object.defineProperty(exports, "setScriptInCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.setScriptInCache;
+  }
+});
+Object.defineProperty(exports, "transpileAndBuildGetVariables", {
+  enumerable: true,
+  get: function get() {
+    return _variableTranspiler.transpileAndBuildGetVariables;
+  }
+});
+var _resourceManager = require("./resource-manager");
+var _fragmentUrl = require("./fragment-url");
+var _componentRefProvider = require("./component-ref-provider");
+var _prefabResources = require("./prefab-resources");
+var _scriptExecutor = require("./script-executor");
+var _variableTranspiler = require("./variable-transpiler");
+var _cssScoping = require("./css-scoping");
+var _appExtensionProvider = require("./app-extension-provider");
+var _cache = require("./cache");

package/runtime-dynamic/services/markup-transpiler.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { TranspiledOutput } from "@wavemaker-ai/react-codegen/transpiler";
+export type { TranspiledOutput } from "@wavemaker-ai/react-codegen/transpiler";
+export interface TranspileOptions {
+    variables?: Record<string, unknown>;
+    isPartOfPrefab?: boolean;
+    prefabName?: string;
+}
+export declare function transpileFragment(markup: string, variablesOrOptions?: Record<string, unknown> | TranspileOptions): TranspiledOutput | null;
+export declare function renderTranspiledMarkup(transpiled: TranspiledOutput, appState: unknown): React.ReactNode;
+export declare function transpileAndRender(markup: string, appState: unknown, variables?: Record<string, unknown>): React.ReactNode;
+export declare function clearTranspileCache(): void;