@wavemaker-ai/react-runtime 1.0.0-next.27766

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,71 @@
+import endsWith from "lodash-es/endsWith";
+import { appendStylesheetLink } from "../utils";
+import { resolvePreviewFetchUrl } from "../preview-resource-base";
+import { getPrefabBaseUrl } from "./fragment-url";
+const PREFAB_MAIN_PAGE_CSS_SUFFIX = "/pages/Main/Main.css";
+const prefabResourcesLoaded = /* @__PURE__ */ new Set();
+function clearPrefabResourcesLoaded() {
+  prefabResourcesLoaded.clear();
+}
+function isAbsoluteResourcePath(path) {
+  return /^https?:\/\//i.test(path) || path.startsWith("//");
+}
+function getPrefabResourceUrl(resourcePath, resourceBasePath) {
+  if (isAbsoluteResourcePath(resourcePath)) {
+    return resourcePath;
+  }
+  return `${resourceBasePath}${resourcePath}`;
+}
+function loadStyleSheetOnce(href) {
+  const resolved = resolvePreviewFetchUrl(href);
+  if (resolved) {
+    appendStylesheetLink(resolved);
+  }
+}
+function isScriptLoaded(src) {
+  const scripts = document.getElementsByTagName("script");
+  for (let i = 0; i < scripts.length; i++) {
+    if (scripts[i].getAttribute("src") === src) return true;
+  }
+  return false;
+}
+function loadScriptOnce(src) {
+  const trimmed = resolvePreviewFetchUrl(src.trim());
+  if (!trimmed || isScriptLoaded(trimmed)) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.async = false;
+    script.src = trimmed;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error(`Failed to load script: ${trimmed}`));
+    document.head.appendChild(script);
+  });
+}
+async function loadPrefabResourcesFromConfig(prefabName, config) {
+  var _a, _b, _c, _d;
+  if (prefabResourcesLoaded.has(prefabName)) {
+    return;
+  }
+  const styles = (_b = (_a = config.resources) == null ? void 0 : _a.styles) != null ? _b : [];
+  const scripts = ((_d = (_c = config.resources) == null ? void 0 : _c.scripts) != null ? _d : []).filter((s) => !s.startsWith("npm://"));
+  const basePath = getPrefabBaseUrl(prefabName);
+  const styleUrls = styles.map((url) => getPrefabResourceUrl(url, basePath)).filter((url) => !!url && !endsWith(url, PREFAB_MAIN_PAGE_CSS_SUFFIX));
+  const scriptUrls = scripts.map((url) => getPrefabResourceUrl(url, basePath));
+  styleUrls.forEach(loadStyleSheetOnce);
+  for (const src of scriptUrls) {
+    try {
+      await loadScriptOnce(src);
+    } catch (e) {
+      console.warn("[prefab-resources] Optional script failed:", src, e);
+    }
+  }
+  prefabResourcesLoaded.add(prefabName);
+}
+export {
+  clearPrefabResourcesLoaded,
+  getPrefabResourceUrl,
+  loadPrefabResourcesFromConfig
+};

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

@@ -0,0 +1,2 @@
+export declare function fetchResource<T = unknown>(url: string, optional?: false): Promise<T>;
+export declare function fetchResource<T = unknown>(url: string, optional: true): Promise<T | null>;

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

@@ -0,0 +1,31 @@
+import axios from "axios";
+import { resolvePreviewFetchUrl } from "../preview-resource-base";
+import { handle401 } from "../../core/app.service";
+import { store } from "../../store";
+async function fetchResource(url, optional = false) {
+  var _a, _b;
+  const resolvedUrl = resolvePreviewFetchUrl(url);
+  try {
+    const response = await axios.get(resolvedUrl);
+    return response.data;
+  } catch (error) {
+    if (optional) {
+      return null;
+    }
+    const status = (_a = error == null ? void 0 : error.response) == null ? void 0 : _a.status;
+    if (status === 401) {
+      handle401();
+      throw error;
+    }
+    const appLocale = (_b = store.getState().i18n) == null ? void 0 : _b.appLocale;
+    const errorMessages = {
+      404: (appLocale == null ? void 0 : appLocale.MESSAGE_PAGE_NOT_FOUND) || "Page not available",
+      403: (appLocale == null ? void 0 : appLocale.LABEL_ACCESS_DENIED) || "Access Denied"
+    };
+    const errorMessage = errorMessages[status] || "An error occurred";
+    throw errorMessage || "Unknown error loading component";
+  }
+}
+export {
+  fetchResource
+};

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,76 @@
+import * as lodash from "lodash-es";
+import moment from "moment";
+import { Utils } from "../../core/util/utils";
+var ScriptScope = /* @__PURE__ */ ((ScriptScope2) => {
+  ScriptScope2["PAGE"] = "Page";
+  ScriptScope2["PARTIAL"] = "Partial";
+  ScriptScope2["PREFAB"] = "Prefab";
+  return ScriptScope2;
+})(ScriptScope || {});
+const IMPORT_LINE_RE = /^\s*import\s+.*?["'];?\s*$/gm;
+const EXPORTED_FN_HEADER_RE = /^\s*export\s+default\s+function\s+\w+\s*\([^)]*\)\s*\{/m;
+function safeStructuredClone(value) {
+  try {
+    return structuredClone(value);
+  } catch (e) {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (e2) {
+      return value;
+    }
+  }
+}
+const SCRIPT_GLOBALS = {
+  _: lodash,
+  moment,
+  Utils,
+  structuredClone: safeStructuredClone
+};
+const DEFERRED_GLOBALS = ["QRCode"];
+function prepareScript(raw) {
+  let code = raw.replace(IMPORT_LINE_RE, "");
+  const headerMatch = code.match(EXPORTED_FN_HEADER_RE);
+  if (headerMatch) {
+    const headerEnd = code.indexOf(headerMatch[0]) + headerMatch[0].length;
+    const body = code.slice(headerEnd);
+    const 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 () => {
+  };
+  try {
+    const cleanScript = prepareScript(script);
+    const allNames = [...Object.keys(SCRIPT_GLOBALS), ...DEFERRED_GLOBALS];
+    const wrappedScript = `{
+${cleanScript}
+}`;
+    const compiledFn = new Function("App", scopeKind, ...allNames, wrappedScript);
+    const staticValues = Object.keys(SCRIPT_GLOBALS).map((k) => SCRIPT_GLOBALS[k]);
+    return (app, page) => {
+      try {
+        const deferredValues = DEFERRED_GLOBALS.map((k) => window[k]);
+        compiledFn(app, page, ...staticValues, ...deferredValues);
+      } catch (runtimeError) {
+        console.error(
+          `[script-executor] Runtime error in ${scopeKind} script "${componentName}":`,
+          runtimeError
+        );
+      }
+    };
+  } catch (compileError) {
+    console.error(
+      `[script-executor] Compilation error in ${scopeKind} script "${componentName}":`,
+      compileError
+    );
+    return () => {
+    };
+  }
+}
+export {
+  ScriptScope,
+  buildAddPageScript
+};

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;

package/runtime-dynamic/services/variable-factory.js

@@ -0,0 +1,217 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import {
+  CATEGORY_TO_CONSTRUCTOR,
+  ACTION_CATEGORIES,
+  EMPTY_RESULT,
+  createLazyPartial
+} from "./variable-registry";
+const EVENT_HANDLER_REGEX = /^(\w+)\(([^)]*)\)$/;
+const RETURN_VALUE_HANDLERS = /* @__PURE__ */ new Set([
+  "onBeforeUpdate",
+  "onBeforeDatasetReady",
+  "onOnline",
+  "onOffline"
+]);
+const EVENT_HANDLER_KEYS = /* @__PURE__ */ new Set([
+  "onSuccess",
+  "onError",
+  "onBeforeUpdate",
+  "onCanUpdate",
+  "onResult",
+  "onBeforeDatasetReady",
+  "onOnline",
+  "onOffline",
+  "onTimerFire"
+]);
+function wireEventHandlers(config, scopeProxy) {
+  for (const key of EVENT_HANDLER_KEYS) {
+    const value = config[key];
+    if (typeof value !== "string") continue;
+    const match = value.match(EVENT_HANDLER_REGEX);
+    if (!match) {
+      delete config[key];
+      continue;
+    }
+    const methodName = match[1];
+    const shouldReturn = RETURN_VALUE_HANDLERS.has(key);
+    config[key] = (...args) => {
+      const fn = scopeProxy == null ? void 0 : scopeProxy[methodName];
+      if (typeof fn === "function") {
+        const result = fn.call(scopeProxy, ...args);
+        if (shouldReturn) return result;
+      }
+    };
+  }
+}
+function isStaticParams(variable) {
+  const db = variable.dataBinding;
+  if (!db) return true;
+  const entryIsStatic = (entry) => {
+    const v = Array.isArray(entry.value) ? entry.value[0] : entry.value;
+    return !v || !(typeof v === "string" && v.startsWith("bind:"));
+  };
+  if (Array.isArray(db)) return db.every(entryIsStatic);
+  if (db && typeof db === "object") {
+    return Object.values(db).every(
+      (opBindings) => Array.isArray(opBindings) ? opBindings.every(entryIsStatic) : true
+    );
+  }
+  return true;
+}
+function buildParamProvider(variable) {
+  const dataSet = variable.dataSet;
+  if (variable.isList && Array.isArray(dataSet)) {
+    return () => [...dataSet];
+  }
+  const params = {};
+  const dataBinding = variable.dataBinding;
+  if (Array.isArray(dataBinding)) {
+    for (const binding of dataBinding) {
+      if (binding.target) params[binding.target] = binding.value;
+    }
+  }
+  if (dataSet && !Array.isArray(dataSet) && typeof dataSet === "object") {
+    for (const [key, value] of Object.entries(dataSet)) {
+      if (!(key in params)) params[key] = value;
+    }
+  }
+  if (variable.pageName && !params["pageName"]) {
+    params["pageName"] = variable.pageName;
+  }
+  return () => __spreadValues({}, params);
+}
+const NAVIGATION_CATEGORIES = /* @__PURE__ */ new Set(["wm.NavigationAction", "wm.NavigationVariable"]);
+const NOTIFICATION_CATEGORIES = /* @__PURE__ */ new Set(["wm.NotificationAction", "wm.NotificationVariable"]);
+const AUTH_CATEGORIES = /* @__PURE__ */ new Set([
+  "wm.LoginAction",
+  "wm.LoginVariable",
+  "wm.LogoutAction",
+  "wm.LogoutVariable"
+]);
+const enhanceNavigation = (config, _variable, scopeProxy) => {
+  config.appConfig = scopeProxy.appConfig;
+};
+const enhanceNotification = (config, variable, scopeProxy) => {
+  config.toasterService = () => scopeProxy.toaster;
+  config.onOk = config.onOk || (() => {
+  });
+  config.onClose = config.onClose || (() => {
+  });
+  const operation = variable.operation;
+  if (operation === "alert" || operation === "confirm") {
+    const widgetName = `Common${operation.charAt(0).toUpperCase() + operation.slice(1)}Dialog`;
+    config.showDialog = (options) => {
+      var _a, _b;
+      (_b = (_a = scopeProxy == null ? void 0 : scopeProxy.App) == null ? void 0 : _a.openActionDialog) == null ? void 0 : _b.call(_a, options, widgetName);
+    };
+  }
+  const dataBindings = variable.dataBinding;
+  const pageBinding = dataBindings == null ? void 0 : dataBindings.find((b) => b.target === "page");
+  if (pageBinding == null ? void 0 : pageBinding.value) {
+    const partialName = pageBinding.value.charAt(0).toUpperCase() + pageBinding.value.slice(1);
+    config.partialContent = { component: createLazyPartial(partialName) };
+  }
+};
+const enhanceAuth = (config, variable, scopeProxy) => {
+  var _a, _b;
+  config.baseURL = (_a = scopeProxy.appConfig) == null ? void 0 : _a.url;
+  config.securityService = () => {
+    var _a2;
+    return (_a2 = scopeProxy.appConfig) == null ? void 0 : _a2.SecurityService;
+  };
+  config.useDefaultSuccessHandler = (_b = variable.useDefaultSuccessHandler) != null ? _b : true;
+};
+const enhanceServiceVariable = (config, variable, scopeProxy) => {
+  var _a;
+  config.baseUrl = scopeProxy.baseUrl + "/services";
+  config.getServiceInfo = () => {
+    var _a2, _b;
+    return (_b = (_a2 = scopeProxy.serviceDefinitions) == null ? void 0 : _a2[variable.operationId]) == null ? void 0 : _b.wmServiceOperationInfo;
+  };
+  (_a = config.isStaticParams) != null ? _a : config.isStaticParams = isStaticParams(variable);
+};
+const enhanceLiveVariable = (config, variable, scopeProxy) => {
+  var _a;
+  if (!config.operation) config.operation = "read";
+  if (!config.propertiesMap) config.propertiesMap = { columns: [] };
+  if (!config.relatedTables) config.relatedTables = [];
+  config.baseUrl = scopeProxy.baseUrl;
+  (_a = config.isStaticParams) != null ? _a : config.isStaticParams = isStaticParams(variable);
+};
+const enhanceCrudVariable = (config, variable, scopeProxy) => {
+  var _a;
+  config.baseUrl = scopeProxy.baseUrl;
+  (_a = config.isStaticParams) != null ? _a : config.isStaticParams = isStaticParams(variable);
+};
+function getEnhancer(category) {
+  if (NAVIGATION_CATEGORIES.has(category)) return enhanceNavigation;
+  if (NOTIFICATION_CATEGORIES.has(category)) return enhanceNotification;
+  if (AUTH_CATEGORIES.has(category)) return enhanceAuth;
+  switch (category) {
+    case "wm.ServiceVariable":
+      return enhanceServiceVariable;
+    case "wm.LiveVariable":
+      return enhanceLiveVariable;
+    case "wm.CrudVariable":
+      return enhanceCrudVariable;
+    default:
+      return null;
+  }
+}
+function buildInstanceConfig(variable, scopeProxy) {
+  const config = __spreadProps(__spreadValues({}, variable), {
+    _context: scopeProxy,
+    paramProvider: variable.name === "loggedInUser" ? () => {
+      var _a;
+      return (_a = scopeProxy.appConfig) == null ? void 0 : _a.loggedInUser;
+    } : buildParamProvider(variable)
+  });
+  wireEventHandlers(config, scopeProxy);
+  const enhancer = getEnhancer(variable.category);
+  if (enhancer) enhancer(config, variable, scopeProxy);
+  return config;
+}
+function createVariablesFromJson(rawVariables, scopeProxy) {
+  if (!rawVariables || Object.keys(rawVariables).length === 0) return EMPTY_RESULT;
+  const Variables = {};
+  const Actions = {};
+  for (const [key, value] of Object.entries(rawVariables)) {
+    const variable = value;
+    const category = variable.category;
+    const Ctor = CATEGORY_TO_CONSTRUCTOR[category];
+    if (!Ctor) continue;
+    try {
+      const config = buildInstanceConfig(variable, scopeProxy);
+      const instance = new Ctor(config);
+      if (ACTION_CATEGORIES.has(category)) {
+        Actions[key] = instance;
+      } else {
+        Variables[key] = instance;
+      }
+    } catch (err) {
+      console.error(`[variable-factory] Failed to create "${key}" (${category}):`, err);
+    }
+  }
+  return { Variables, Actions };
+}
+export {
+  createVariablesFromJson
+};

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

@@ -0,0 +1,12 @@
+import React from "react";
+type ConstructorClass = new (config: any) => any;
+export declare const CATEGORY_TO_CONSTRUCTOR: Record<string, ConstructorClass>;
+export declare const ACTION_CATEGORIES: Set<string>;
+export declare const SCOPE_MAP: Record<string, unknown>;
+export interface VariablesResult {
+    Variables: Record<string, unknown>;
+    Actions: Record<string, unknown>;
+}
+export declare const EMPTY_RESULT: VariablesResult;
+export declare function createLazyPartial(partialName: string): React.LazyExoticComponent<React.ComponentType<any>>;
+export {};

package/runtime-dynamic/services/variable-registry.js

@@ -0,0 +1,71 @@
+import React, { lazy } from "react";
+import { ModelVariable } from "../../variables/model-variable";
+import { ServiceVariable } from "../../variables/service-variable";
+import LiveVariable from "../../variables/live-variable";
+import CrudVariable from "../../variables/crud-variable";
+import { NavigationAction } from "../../actions/navigation-action";
+import { NotificationAction } from "../../actions/notification-action";
+import { TimerAction } from "../../actions/timer-action";
+import { LoginAction } from "../../actions/login-action";
+import { LogoutAction } from "../../actions/logout-action";
+const CATEGORY_TO_CONSTRUCTOR = {
+  "wm.Variable": ModelVariable,
+  "wm.ServiceVariable": ServiceVariable,
+  "wm.LiveVariable": LiveVariable,
+  "wm.CrudVariable": CrudVariable,
+  "wm.NavigationAction": NavigationAction,
+  "wm.NavigationVariable": NavigationAction,
+  "wm.NotificationAction": NotificationAction,
+  "wm.NotificationVariable": NotificationAction,
+  "wm.TimerAction": TimerAction,
+  "wm.TimerVariable": TimerAction,
+  "wm.LoginAction": LoginAction,
+  "wm.LoginVariable": LoginAction,
+  "wm.LogoutAction": LogoutAction,
+  "wm.LogoutVariable": LogoutAction
+};
+const ACTION_CATEGORIES = /* @__PURE__ */ new Set([
+  "wm.NavigationAction",
+  "wm.NavigationVariable",
+  "wm.NotificationAction",
+  "wm.NotificationVariable",
+  "wm.TimerAction",
+  "wm.TimerVariable",
+  "wm.LoginAction",
+  "wm.LoginVariable",
+  "wm.LogoutAction",
+  "wm.LogoutVariable"
+]);
+const SCOPE_MAP = {
+  React,
+  ModelVariable,
+  ServiceVariable,
+  LiveVariable,
+  CrudVariable,
+  NavigationAction,
+  NotificationAction,
+  TimerAction,
+  LoginAction,
+  LogoutAction
+};
+const EMPTY_RESULT = { Variables: {}, Actions: {} };
+function createLazyPartial(partialName) {
+  return lazy(async () => {
+    const { ComponentType: FType } = await import("./fragment-url");
+    const { getComponentRef } = await import("./component-ref-provider");
+    const { buildBasePageLikeComponent } = await import("../factories/build-base-page-like-component");
+    const fragment = await getComponentRef(partialName, FType.PARTIAL);
+    if (!fragment) {
+      return { default: () => null };
+    }
+    const Built = await buildBasePageLikeComponent("partial", partialName, fragment);
+    return { default: Built };
+  });
+}
+export {
+  ACTION_CATEGORIES,
+  CATEGORY_TO_CONSTRUCTOR,
+  EMPTY_RESULT,
+  SCOPE_MAP,
+  createLazyPartial
+};

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

@@ -0,0 +1,5 @@
+import { type VariablesResult } from "./variable-registry";
+type GetVariablesFn = (pageProxy: unknown) => VariablesResult;
+export declare function clearVariablesCache(): void;
+export declare function transpileAndBuildGetVariables(variablesCodeString: string, rawVariables: Record<string, unknown>): GetVariablesFn;
+export {};

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

@@ -0,0 +1,129 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { transform } from "sucrase";
+import {
+  SCOPE_MAP,
+  EMPTY_RESULT,
+  createLazyPartial
+} from "./variable-registry";
+function buildEntityProviderShims(rawVariables) {
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const config of Object.values(rawVariables || {})) {
+    const v = config;
+    if (!v.liveSource || !v.type || !v.propertiesMap) continue;
+    const key = `${v.liveSource}::${v.type}`;
+    if (!entityMap.has(key)) {
+      entityMap.set(key, {
+        propertiesMap: v.propertiesMap,
+        relatedTables: v.relatedTables || []
+      });
+    }
+  }
+  return {
+    getEntityPropertyMap: (liveSource, entityName) => {
+      var _a;
+      return (_a = entityMap.get(`${liveSource}::${entityName}`)) == null ? void 0 : _a.propertiesMap;
+    },
+    getEntityRelatedTables: (liveSource, entityName) => {
+      var _a;
+      return (_a = entityMap.get(`${liveSource}::${entityName}`)) == null ? void 0 : _a.relatedTables;
+    }
+  };
+}
+const IMPORT_STATEMENT_REGEX = /import\s+[\s\S]*?\s+from\s+['"][^'"]+['"];?/g;
+const EXPORT_DEFAULT_REGEX = /^\s*export\s+default\s+/m;
+const PARTIAL_IMPORT_REGEX = /import\s+(\w+)\s+from\s+['"]@\/app\/components\/[^'"]+['"];?/g;
+function extractPartialImports(code) {
+  const names = [];
+  let match;
+  while ((match = PARTIAL_IMPORT_REGEX.exec(code)) !== null) {
+    names.push(match[1]);
+  }
+  PARTIAL_IMPORT_REGEX.lastIndex = 0;
+  return names;
+}
+function preprocessVariablesCode(code) {
+  return code.replace(IMPORT_STATEMENT_REGEX, "").replace(EXPORT_DEFAULT_REGEX, "return ");
+}
+function compileTypeScript(code) {
+  const wrapped = `function __variableFactory__() {
+${code}
+}`;
+  const result = transform(wrapped, { transforms: ["typescript"] });
+  return `${result.code}
+return __variableFactory__();`;
+}
+function tryCompileVariableFactory(preprocessed) {
+  try {
+    return compileTypeScript(preprocessed);
+  } catch (err) {
+    console.error("[variable-transpiler] Compilation failed:", err);
+    return null;
+  }
+}
+function tryConstructVariableFactory(scopeNames, compiled) {
+  try {
+    return new Function(...scopeNames, compiled);
+  } catch (err) {
+    console.error("[variable-transpiler] Function construction failed:", err);
+    return null;
+  }
+}
+const variablesCache = /* @__PURE__ */ new Map();
+function clearVariablesCache() {
+  variablesCache.clear();
+}
+function transpileAndBuildGetVariables(variablesCodeString, rawVariables) {
+  if (!(variablesCodeString == null ? void 0 : variablesCodeString.trim())) return () => EMPTY_RESULT;
+  const cached = variablesCache.get(variablesCodeString);
+  if (cached) return cached;
+  const { getEntityPropertyMap, getEntityRelatedTables } = buildEntityProviderShims(rawVariables);
+  const scopeWithShims = __spreadProps(__spreadValues({}, SCOPE_MAP), {
+    getEntityPropertyMap,
+    getEntityRelatedTables
+  });
+  for (const name of extractPartialImports(variablesCodeString)) {
+    scopeWithShims[name] = createLazyPartial(name);
+  }
+  const scopeNames = Object.keys(scopeWithShims);
+  const scopeValues = Object.values(scopeWithShims);
+  const preprocessed = preprocessVariablesCode(variablesCodeString);
+  const compiled = tryCompileVariableFactory(preprocessed);
+  if (!compiled) return () => EMPTY_RESULT;
+  const factoryBuilder = tryConstructVariableFactory(scopeNames, compiled);
+  if (!factoryBuilder) return () => EMPTY_RESULT;
+  let getVariablesFn;
+  try {
+    getVariablesFn = factoryBuilder(...scopeValues);
+  } catch (err) {
+    console.error("[variable-transpiler] Factory execution failed:", err);
+    return () => EMPTY_RESULT;
+  }
+  if (typeof getVariablesFn !== "function") {
+    console.error("[variable-transpiler] Expected a function, got:", typeof getVariablesFn);
+    return () => EMPTY_RESULT;
+  }
+  variablesCache.set(variablesCodeString, getVariablesFn);
+  return getVariablesFn;
+}
+export {
+  clearVariablesCache,
+  transpileAndBuildGetVariables
+};