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

package/core/proxy-service.js

@@ -0,0 +1,583 @@
+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 isString from "lodash-es/isString";
+import { isDOMElement, wrapWithNativeDOM } from "./util/dom";
+import {
+  findWidgetElement,
+  widgetElementCallbacks
+} from "./widget-observer";
+import { ServiceVariable } from "../variables/service-variable";
+import LiveVariable from "../variables/live-variable";
+import { ModelVariable } from "../variables/model-variable";
+import CrudVariable from "../variables/crud-variable";
+const proxyMap = /* @__PURE__ */ new WeakMap();
+const pageWidgetProxyCaches = /* @__PURE__ */ new WeakMap();
+function clearPageWidgetProxyCache(widgetsProxy) {
+  var _a;
+  (_a = pageWidgetProxyCaches.get(widgetsProxy)) == null ? void 0 : _a.clear();
+}
+let pendingWidgetContextUpdates = null;
+let batchedSetPageContextForWidgets = null;
+function flushPendingWidgetContextUpdates() {
+  const batch = pendingWidgetContextUpdates;
+  const spc = batchedSetPageContextForWidgets;
+  pendingWidgetContextUpdates = null;
+  batchedSetPageContextForWidgets = null;
+  if (!(batch == null ? void 0 : batch.size) || !spc) {
+    return;
+  }
+  spc((prevContext) => {
+    const newWidgets = __spreadValues({}, prevContext.Widgets);
+    let changed = false;
+    for (const [name, { widget: w, props }] of batch) {
+      const currentWidget = prevContext.Widgets[name];
+      const registryWidgetId = currentWidget == null ? void 0 : currentWidget["data-widget-id"];
+      const widgetId = w["data-widget-id"];
+      if (currentWidget && registryWidgetId && widgetId) {
+        if (registryWidgetId !== widgetId) {
+          continue;
+        }
+      }
+      newWidgets[name] = __spreadValues(__spreadValues({}, currentWidget && typeof currentWidget === "object" ? currentWidget : {}), props);
+      changed = true;
+    }
+    if (!changed) {
+      return prevContext;
+    }
+    return __spreadProps(__spreadValues({}, prevContext), {
+      Widgets: newWidgets
+    });
+  });
+}
+function queueBatchedWidgetContextUpdate(widgetName, widget, prop, value, setPageContext) {
+  if (typeof prop === "symbol") {
+    return;
+  }
+  const key = prop;
+  const isFirstInBatch = !pendingWidgetContextUpdates;
+  if (isFirstInBatch) {
+    pendingWidgetContextUpdates = /* @__PURE__ */ new Map();
+    batchedSetPageContextForWidgets = setPageContext;
+  } else if (batchedSetPageContextForWidgets !== setPageContext) {
+    batchedSetPageContextForWidgets = setPageContext;
+  }
+  const existing = pendingWidgetContextUpdates.get(widgetName);
+  if (existing) {
+    existing.props[key] = value;
+  } else {
+    pendingWidgetContextUpdates.set(widgetName, {
+      widget,
+      props: { [key]: value }
+    });
+  }
+  if (isFirstInBatch) {
+    queueMicrotask(flushPendingWidgetContextUpdates);
+  }
+}
+const originalTargets = /* @__PURE__ */ new WeakMap();
+const MUTATING_ARRAY_METHODS = [
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin",
+  "put"
+];
+const createArrayProxy = (array, widgetName, propName, setPageContext) => {
+  if (proxyMap.has(array)) {
+    return array;
+  }
+  const arrayProxy = new Proxy(array, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && MUTATING_ARRAY_METHODS.includes(prop) && typeof value === "function") {
+        return function(...args) {
+          const result = value.apply(target, args);
+          setPageContext((prevContext) => {
+            return __spreadProps(__spreadValues({}, prevContext), {
+              Widgets: __spreadProps(__spreadValues({}, prevContext.Widgets), {
+                [widgetName]: __spreadProps(__spreadValues({}, prevContext.Widgets[widgetName]), {
+                  [propName]: [...target]
+                  // Create new array reference to trigger re-render
+                })
+              })
+            });
+          });
+          return result;
+        };
+      }
+      return value;
+    },
+    set(target, prop, value, receiver) {
+      const result = Reflect.set(target, prop, value, receiver);
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        setPageContext((prevContext) => {
+          return __spreadProps(__spreadValues({}, prevContext), {
+            Widgets: __spreadProps(__spreadValues({}, prevContext.Widgets), {
+              [widgetName]: __spreadProps(__spreadValues({}, prevContext.Widgets[widgetName]), {
+                [propName]: [...target]
+                // Create new array reference to trigger re-render
+              })
+            })
+          });
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(arrayProxy, true);
+  return arrayProxy;
+};
+const createStateArrayProxy = (array, path, propName, setPageContext) => {
+  if (proxyMap.has(array)) {
+    return array;
+  }
+  const arrayProxy = new Proxy(array, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && MUTATING_ARRAY_METHODS.includes(prop) && typeof value === "function") {
+        return function(...args) {
+          const result = value.apply(target, args);
+          setPageContext((prev) => {
+            const newState = __spreadValues({}, prev);
+            let current = newState;
+            for (let i = 0; i < path.length; i++) {
+              const key = path[i];
+              current[key] = __spreadValues({}, current[key]);
+              current = current[key];
+            }
+            current[propName] = [...target];
+            return newState;
+          });
+          return result;
+        };
+      }
+      return value;
+    },
+    set(target, prop, value, receiver) {
+      const result = Reflect.set(target, prop, value, receiver);
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        setPageContext((prev) => {
+          const newState = __spreadValues({}, prev);
+          let current = newState;
+          for (let i = 0; i < path.length; i++) {
+            const key = path[i];
+            current[key] = __spreadValues({}, current[key]);
+            current = current[key];
+          }
+          current[propName] = [...target];
+          return newState;
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(arrayProxy, true);
+  return arrayProxy;
+};
+const createWidgetProxy = (widget, widgetName, setPageContext, overriddenPropsRegistry) => {
+  if (proxyMap.has(widget) || isDOMElement(widget)) {
+    return widget;
+  }
+  if (!isString(widgetName)) {
+    return widget;
+  }
+  if (widget == null) {
+    return widget;
+  }
+  widget.__isProxy = true;
+  const proxy = new Proxy(widget, {
+    set(target, prop, value, receiver) {
+      if (typeof prop === "symbol" || prop === "prototype") {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      const currentVal = Reflect.get(target, prop, receiver);
+      if (currentVal === value) {
+        return true;
+      }
+      if (typeof prop === "string") {
+        const widgetId = widget["data-widget-id"];
+        if (overriddenPropsRegistry && typeof overriddenPropsRegistry.trackOverriddenProps === "function") {
+          overriddenPropsRegistry.trackOverriddenProps(widgetName, prop, value, widgetId);
+        }
+      }
+      Reflect.set(target, prop, value, receiver);
+      queueBatchedWidgetContextUpdate(widgetName, widget, prop, value, setPageContext);
+      return true;
+    },
+    get(target, prop, receiver) {
+      var _a;
+      if (typeof prop === "symbol" || prop === "prototype") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (prop === "setProperty") {
+        return function(key, value2) {
+          proxy[key] = value2;
+          return this;
+        };
+      }
+      if (prop === "__isProxy") return true;
+      if (prop === "$element") {
+        const rawElement = Reflect.get(target, prop, receiver);
+        if (rawElement) {
+          if (rawElement.length === 1 && isDOMElement(rawElement[0])) {
+            return rawElement;
+          }
+          if (isDOMElement(rawElement)) {
+            return wrapWithNativeDOM(rawElement);
+          }
+        }
+        const widgetId2 = widget["data-widget-id"];
+        const element = findWidgetElement(widgetName, widgetId2);
+        if (element) {
+          const wrappedElement = wrapWithNativeDOM(element);
+          Reflect.defineProperty(target, prop, {
+            value: wrappedElement,
+            writable: true,
+            configurable: true,
+            enumerable: false
+          });
+          return wrappedElement;
+        }
+        if (!target._elementCallbackRegistered) {
+          const key = widgetId2 ? `${widgetName}:${widgetId2}` : widgetName;
+          let callbacks = widgetElementCallbacks.get(key);
+          if (!callbacks) {
+            callbacks = /* @__PURE__ */ new Set();
+            widgetElementCallbacks.set(key, callbacks);
+          }
+          callbacks.add((element2) => {
+            if (element2) {
+              const wrapped = wrapWithNativeDOM(element2);
+              Reflect.defineProperty(target, prop, {
+                value: wrapped,
+                writable: true,
+                configurable: true,
+                enumerable: false
+              });
+            }
+          });
+          Reflect.defineProperty(target, "_elementCallbackRegistered", {
+            value: true,
+            writable: true,
+            configurable: true,
+            enumerable: false
+          });
+        }
+        return null;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+      if (descriptor && !descriptor.configurable && !descriptor.writable) {
+        return value;
+      }
+      const widgetId = widget["data-widget-id"];
+      const widgetOverrides = overriddenPropsRegistry == null ? void 0 : overriddenPropsRegistry.getWidgetOverrides(widgetName, widgetId);
+      if (widgetOverrides && prop in widgetOverrides) {
+        const internalValue = (_a = overriddenPropsRegistry == null ? void 0 : overriddenPropsRegistry.getLastInternalValue) == null ? void 0 : _a.call(
+          overriddenPropsRegistry,
+          widgetName,
+          prop
+        );
+        return internalValue !== void 0 ? internalValue : widgetOverrides[prop];
+      }
+      if (isDOMElement(value)) {
+        return value;
+      }
+      if (Array.isArray(value) && typeof prop === "string") {
+        return createArrayProxy(value, widgetName, prop, setPageContext);
+      }
+      return value;
+    }
+  });
+  proxyMap.set(proxy, true);
+  originalTargets.set(proxy, widget);
+  return proxy;
+};
+const createPageProxy = (target, setPageContext, overriddenPropsRegistry) => {
+  const widgetProxies = /* @__PURE__ */ new Map();
+  const widgetsProxy = new Proxy(target, {
+    get(widgetsTarget, widgetName) {
+      if (widgetName === void 0 || widgetName === "undefined") {
+        return void 0;
+      }
+      if (typeof widgetName !== "string") {
+        return widgetsTarget[widgetName];
+      }
+      if (!(widgetName in widgetsTarget)) {
+        widgetsTarget[widgetName] = { name: widgetName };
+      }
+      const widget = widgetsTarget[widgetName];
+      if (widgetProxies.has(widgetName)) {
+        const proxy2 = widgetProxies.get(widgetName);
+        const originalTarget = originalTargets.get(proxy2);
+        const safeWidget = widget != null && typeof widget === "object" ? widget : null;
+        const safeOriginal = originalTarget != null && typeof originalTarget === "object" ? originalTarget : null;
+        if (safeWidget && safeOriginal && (widget !== originalTarget || Object.keys(safeWidget).length > Object.keys(safeOriginal).length)) {
+          for (const key in safeWidget) {
+            Reflect.defineProperty(safeOriginal, key, {
+              value: safeWidget[key],
+              writable: true,
+              configurable: true,
+              enumerable: true
+            });
+          }
+          widgetsTarget[widgetName] = safeOriginal;
+        }
+        return proxy2;
+      }
+      const proxy = widget ? createWidgetProxy(widget, widgetName, setPageContext, overriddenPropsRegistry) : void 0;
+      widgetProxies.set(widgetName, proxy);
+      return proxy;
+    },
+    set(widgetsTarget, widgetName, widgetValue) {
+      if (widgetsTarget[widgetName] === widgetValue) {
+        return true;
+      }
+      widgetsTarget[widgetName] = widgetValue;
+      if (widgetProxies.has(widgetName)) {
+        const proxy = widgetProxies.get(widgetName);
+        const originalTarget = originalTargets.get(proxy);
+        if (widgetValue && typeof widgetValue === "object") {
+          for (const key in widgetValue) {
+            const newVal = widgetValue[key];
+            const oldVal = originalTarget[key];
+            if (oldVal !== newVal) {
+              Reflect.defineProperty(originalTarget, key, {
+                value: newVal,
+                writable: true,
+                configurable: true,
+                enumerable: true
+              });
+            }
+          }
+        }
+      } else if (widgetValue && typeof widgetValue === "object") {
+        const proxy = createWidgetProxy(
+          widgetValue,
+          widgetName,
+          setPageContext,
+          overriddenPropsRegistry
+        );
+        widgetProxies.set(widgetName, proxy);
+      }
+      return true;
+    }
+  });
+  pageWidgetProxyCaches.set(widgetsProxy, widgetProxies);
+  return widgetsProxy;
+};
+const wrapVariableProxy = (variable, path, varName, setPageContext) => {
+  if (proxyMap.has(variable)) {
+    return variable;
+  }
+  const varProxy = new Proxy(variable, {
+    set(target, prop, value, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      const prevVal = Reflect.get(target, prop, receiver);
+      const result = Reflect.set(target, prop, value, receiver);
+      if (prevVal !== value) {
+        setPageContext((prev) => {
+          const newState = __spreadValues({}, prev);
+          let current = newState;
+          for (let i = 0; i < path.length; i++) {
+            const key = path[i];
+            const existing = current[key];
+            current[key] = existing ? __spreadValues({}, existing) : {};
+            current = current[key];
+          }
+          current[varName] = target;
+          return newState;
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(varProxy, true);
+  return varProxy;
+};
+const createStateProxy = (obj, path = [], setPageContext, overriddenPropsRegistry) => {
+  const nestedProxies = /* @__PURE__ */ new Map();
+  return new Proxy(obj, {
+    get(target, prop, receiver) {
+      if (prop === "eval") {
+        return (fn, failOnError = false) => {
+          try {
+            return fn.call(target);
+          } catch (e) {
+            if (failOnError) throw e;
+            return null;
+          }
+        };
+      }
+      if (prop === "Widgets" && path.length === 0) {
+        if (!nestedProxies.has("Widgets")) {
+          nestedProxies.set(
+            "Widgets",
+            createPageProxy(
+              target.Widgets,
+              setPageContext,
+              overriddenPropsRegistry
+            )
+          );
+        }
+        return nestedProxies.get("Widgets");
+      }
+      if (prop === "Variables" && path.length === 0) {
+        if (!nestedProxies.has("Variables")) {
+          nestedProxies.set(
+            "Variables",
+            createStateProxy(
+              target.Variables,
+              ["Variables"],
+              setPageContext,
+              overriddenPropsRegistry
+            )
+          );
+        }
+        return nestedProxies.get("Variables");
+      }
+      if (!(prop in target)) {
+        return void 0;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "object" || value === null) {
+        return value;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+      if (descriptor && !descriptor.configurable && !descriptor.writable) {
+        return value;
+      }
+      if (value instanceof ServiceVariable || value instanceof LiveVariable || value instanceof ModelVariable || value instanceof CrudVariable) {
+        if (nestedProxies.has(prop)) {
+          return nestedProxies.get(prop);
+        }
+        const varProxy = wrapVariableProxy(
+          value,
+          path,
+          prop,
+          setPageContext
+        );
+        nestedProxies.set(prop, varProxy);
+        return varProxy;
+      }
+      if (isDOMElement(value)) {
+        return value;
+      }
+      if (value instanceof Map || value instanceof Date) {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return createStateArrayProxy(
+          value,
+          path,
+          prop,
+          setPageContext
+        );
+      }
+      if (nestedProxies.has(prop)) {
+        return nestedProxies.get(prop);
+      }
+      if (target == null ? void 0 : target.prefab) {
+        if (nestedProxies.has(target.name)) {
+          return nestedProxies.get(target.name)[prop];
+        }
+      }
+      const nestedProxy = createStateProxy(
+        value,
+        [...path, prop],
+        setPageContext,
+        overriddenPropsRegistry
+      );
+      nestedProxies.set(prop, nestedProxy);
+      return nestedProxy;
+    },
+    set(target, prop, value, receiver) {
+      const currentVal = Reflect.get(target, prop, receiver);
+      if (currentVal === value) {
+        return true;
+      }
+      Reflect.set(target, prop, value, receiver);
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && nestedProxies.has(prop)) {
+        nestedProxies.delete(prop);
+      }
+      if (target == null ? void 0 : target.prefab) {
+        if (nestedProxies.has(target.name)) {
+          const existingProxy = nestedProxies.get(target.name);
+          existingProxy[prop] = value;
+        } else {
+          nestedProxies.set(target.name, createWidgetProxy(target, target.name, setPageContext));
+        }
+      }
+      setPageContext((prev) => {
+        const newState = __spreadValues({}, prev);
+        let current = newState;
+        for (let i = 0; i < path.length; i++) {
+          const key = path[i];
+          const existing = current[key];
+          const isVariableInstance = typeof existing === "object" && (existing instanceof ServiceVariable || existing instanceof LiveVariable || existing instanceof ModelVariable || existing instanceof CrudVariable);
+          const newVal = isVariableInstance ? existing : existing ? __spreadValues({}, existing) : {};
+          current[key] = newVal;
+          current = current[key];
+        }
+        current[prop] = value;
+        return newState;
+      });
+      return true;
+    }
+  });
+};
+const createFormFieldProxy = (formField, setState, overriddenItemsRef, formProxy) => {
+  const fieldProxy = new Proxy(formField, {
+    get: (target, prop) => {
+      return target[prop];
+    },
+    set: (target, prop, value) => {
+      target[prop] = value;
+      overriddenItemsRef.current[prop] = value;
+      setState(__spreadValues({}, target));
+      return true;
+    }
+  });
+  const name = formField.name;
+  const key = formField.formKey;
+  if (key) {
+    formProxy.formfields[key] = fieldProxy;
+    formProxy.formWidgets[key] = fieldProxy;
+  }
+  formProxy.formfields[`${name}_formWidget`] = fieldProxy;
+  formProxy.formWidgets[`${name}_formWidget`] = fieldProxy;
+  formProxy.formfields[`${name}`] = fieldProxy;
+  formProxy.formWidgets[`${name}`] = fieldProxy;
+  return fieldProxy;
+};
+export {
+  clearPageWidgetProxyCache,
+  createFormFieldProxy,
+  createPageProxy,
+  createStateProxy,
+  createWidgetProxy
+};

package/core/script-registry.d.ts

@@ -0,0 +1,23 @@
+export declare class OverriddenPropsRegistry {
+    private overriddenProps;
+    private widgetIdOverriddenProps;
+    private lastInternalValues;
+    private _trackingSuspended;
+    suspendTracking(): void;
+    resumeTracking(): void;
+    isTrackingSuspended(): boolean;
+    trackOverriddenProps(widgetName: string, propName: string, value: any, widgetId?: string): void;
+    isPropOverridden(widgetName: string, propName: string, widgetId: string): boolean;
+    isWidgetOverridden(widgetName: string, widgetId: string): boolean;
+    trackInternalUpdate(widgetName: string, propName: string, value: any): void;
+    getLastInternalValue(widgetName: string, propName: string): any;
+    getWidgetOverrides(widgetName: string, widgetId: string): Record<string, any>;
+    clear(): void;
+    destroy(widgetName: string): void;
+}
+export declare function createOverriddenPropsRegistry(): OverriddenPropsRegistry;
+/**
+ * Utility to execute a callback with tracking suspended.
+ * Ensures tracking is always resumed even if the callback throws.
+ */
+export declare function withSuspendedTracking<T>(registry: OverriddenPropsRegistry | null | undefined, callback: () => T): T;

package/core/script-registry.js

@@ -0,0 +1,102 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const IGNORED_PROPERTIES = ["name", "activePane", "activePaneIndex", "activeTab"];
+class OverriddenPropsRegistry {
+  constructor() {
+    __publicField(this, "overriddenProps", {});
+    __publicField(this, "widgetIdOverriddenProps", {});
+    __publicField(this, "lastInternalValues", {});
+    __publicField(this, "_trackingSuspended", false);
+  }
+  // Suspend tracking (used during internal state updates like updateWidgetState)
+  suspendTracking() {
+    this._trackingSuspended = true;
+  }
+  // Resume tracking
+  resumeTracking() {
+    this._trackingSuspended = false;
+  }
+  // Check if tracking is currently suspended
+  isTrackingSuspended() {
+    return this._trackingSuspended;
+  }
+  // Add a property to the registry
+  trackOverriddenProps(widgetName, propName, value, widgetId) {
+    if (this._trackingSuspended) return;
+    if (IGNORED_PROPERTIES.includes(propName)) return;
+    if (widgetId) {
+      if (!this.widgetIdOverriddenProps[widgetName]) {
+        this.widgetIdOverriddenProps[widgetName] = {};
+      }
+      if (!this.widgetIdOverriddenProps[widgetName][widgetId]) {
+        this.widgetIdOverriddenProps[widgetName][widgetId] = {};
+      }
+      this.widgetIdOverriddenProps[widgetName][widgetId][propName] = value;
+    } else {
+      if (!this.overriddenProps[widgetName]) {
+        this.overriddenProps[widgetName] = {};
+      }
+      this.overriddenProps[widgetName][propName] = value;
+    }
+    if (this.lastInternalValues[widgetName]) {
+      delete this.lastInternalValues[widgetName][propName];
+    }
+  }
+  // Check if a property has been script-modified
+  isPropOverridden(widgetName, propName, widgetId) {
+    var _a, _b, _c, _d;
+    const overriddenItem = ((_b = (_a = this.widgetIdOverriddenProps[widgetName]) == null ? void 0 : _a[widgetId]) == null ? void 0 : _b[propName]) || (((_c = this.overriddenProps[widgetName]) == null ? void 0 : _c[propName]) != void 0 ? (_d = this.overriddenProps[widgetName]) == null ? void 0 : _d[propName] : false);
+    return overriddenItem !== void 0;
+  }
+  isWidgetOverridden(widgetName, widgetId) {
+    var _a;
+    const overriddenItem = ((_a = this.widgetIdOverriddenProps[widgetName]) == null ? void 0 : _a[widgetId]) || this.overriddenProps[widgetName];
+    return overriddenItem !== void 0;
+  }
+  // Record a value set by an internal component update (e.g. user input via listener.onChange).
+  // Only tracked for widgets that have script overrides.
+  trackInternalUpdate(widgetName, propName, value) {
+    if (!this.overriddenProps[widgetName] && !this.widgetIdOverriddenProps[widgetName]) return;
+    if (!this.lastInternalValues[widgetName]) {
+      this.lastInternalValues[widgetName] = {};
+    }
+    this.lastInternalValues[widgetName][propName] = value;
+  }
+  getLastInternalValue(widgetName, propName) {
+    var _a;
+    return (_a = this.lastInternalValues[widgetName]) == null ? void 0 : _a[propName];
+  }
+  // Get widget-id specific overrides
+  getWidgetOverrides(widgetName, widgetId) {
+    var _a;
+    const overriddenItem = ((_a = this.widgetIdOverriddenProps[widgetName]) == null ? void 0 : _a[widgetId]) || this.overriddenProps[widgetName];
+    return overriddenItem || {};
+  }
+  clear() {
+    this.overriddenProps = {};
+    this.widgetIdOverriddenProps = {};
+    this.lastInternalValues = {};
+  }
+  destroy(widgetName) {
+    delete this.overriddenProps[widgetName];
+    delete this.widgetIdOverriddenProps[widgetName];
+    delete this.lastInternalValues[widgetName];
+  }
+}
+function createOverriddenPropsRegistry() {
+  return new OverriddenPropsRegistry();
+}
+function withSuspendedTracking(registry, callback) {
+  registry == null ? void 0 : registry.suspendTracking();
+  try {
+    return callback();
+  } finally {
+    registry == null ? void 0 : registry.resumeTracking();
+  }
+}
+export {
+  OverriddenPropsRegistry,
+  createOverriddenPropsRegistry,
+  withSuspendedTracking
+};