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

package/core/proxy-service.js

@@ -0,0 +1,571 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWidgetProxy = exports.createStateProxy = exports.createPageProxy = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _isString = _interopRequireDefault(require("lodash-es/isString"));
+var _dom = require("@wavemaker-ai/react-runtime/core/util/dom");
+var _widgetObserver = require("@wavemaker-ai/react-runtime/core/widget-observer");
+var _serviceVariable = require("../variables/service-variable");
+var _liveVariable = _interopRequireDefault(require("../variables/live-variable"));
+var _modelVariable = require("../variables/model-variable");
+var _crudVariable = _interopRequireDefault(require("../variables/crud-variable"));
+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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// WeakMap to store proxy flags without exposing them as props
+var proxyMap = new WeakMap();
+
+/** Batches widget proxy React updates so many property writes in one turn → one setPageContext. */
+
+var pendingWidgetContextUpdates = null;
+var batchedSetPageContextForWidgets = null;
+function flushPendingWidgetContextUpdates() {
+  var batch = pendingWidgetContextUpdates;
+  var spc = batchedSetPageContextForWidgets;
+  pendingWidgetContextUpdates = null;
+  batchedSetPageContextForWidgets = null;
+  if (!(batch !== null && batch !== void 0 && batch.size) || !spc) {
+    return;
+  }
+  spc(function (prevContext) {
+    var newWidgets = _objectSpread({}, prevContext.Widgets);
+    var changed = false;
+    var _iterator = _createForOfIteratorHelper(batch),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = (0, _slicedToArray2["default"])(_step.value, 2),
+          name = _step$value[0],
+          _step$value$ = _step$value[1],
+          w = _step$value$.widget,
+          props = _step$value$.props;
+        var currentWidget = prevContext.Widgets[name];
+        var registryWidgetId = currentWidget === null || currentWidget === void 0 ? void 0 : currentWidget["data-widget-id"];
+        var widgetId = w["data-widget-id"];
+        if (currentWidget && registryWidgetId && widgetId) {
+          if (registryWidgetId !== widgetId) {
+            continue;
+          }
+        }
+        newWidgets[name] = _objectSpread(_objectSpread({}, currentWidget && (0, _typeof2["default"])(currentWidget) === "object" ? currentWidget : {}), props);
+        changed = true;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    if (!changed) {
+      return prevContext;
+    }
+    return _objectSpread(_objectSpread({}, prevContext), {}, {
+      Widgets: newWidgets
+    });
+  });
+}
+function queueBatchedWidgetContextUpdate(widgetName, widget, prop, value, setPageContext) {
+  if ((0, _typeof2["default"])(prop) === "symbol") {
+    return;
+  }
+  var key = prop;
+  var isFirstInBatch = !pendingWidgetContextUpdates;
+  if (isFirstInBatch) {
+    pendingWidgetContextUpdates = new Map();
+    batchedSetPageContextForWidgets = setPageContext;
+  } else if (batchedSetPageContextForWidgets !== setPageContext) {
+    batchedSetPageContextForWidgets = setPageContext;
+  }
+  var existing = pendingWidgetContextUpdates.get(widgetName);
+  if (existing) {
+    existing.props[key] = value;
+  } else {
+    pendingWidgetContextUpdates.set(widgetName, {
+      widget: widget,
+      props: (0, _defineProperty2["default"])({}, key, value)
+    });
+  }
+  if (isFirstInBatch) {
+    queueMicrotask(flushPendingWidgetContextUpdates);
+  }
+}
+
+// Store the original target for each proxy
+var originalTargets = new WeakMap();
+
+// Array methods that mutate the array and should trigger updates
+var MUTATING_ARRAY_METHODS = ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin", "put"];
+
+// Create a special proxy for arrays that preserves native behavior but triggers updates
+var createArrayProxy = function createArrayProxy(array, widgetName, propName, setPageContext) {
+  if (proxyMap.has(array)) {
+    return array;
+  }
+  var arrayProxy = new Proxy(array, {
+    get: function get(target, prop, receiver) {
+      var value = Reflect.get(target, prop, receiver);
+
+      // If it's a mutating method, wrap it to trigger updates
+      if (typeof prop === "string" && MUTATING_ARRAY_METHODS.includes(prop) && typeof value === "function") {
+        return function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          var result = value.apply(target, args);
+
+          // Trigger page context update after mutation
+          setPageContext(function (prevContext) {
+            return _objectSpread(_objectSpread({}, prevContext), {}, {
+              Widgets: _objectSpread(_objectSpread({}, prevContext.Widgets), {}, (0, _defineProperty2["default"])({}, widgetName, _objectSpread(_objectSpread({}, prevContext.Widgets[widgetName]), {}, (0, _defineProperty2["default"])({}, propName, (0, _toConsumableArray2["default"])(target)))))
+            });
+          });
+          return result;
+        };
+      }
+      return value;
+    },
+    set: function set(target, prop, value, receiver) {
+      var result = Reflect.set(target, prop, value, receiver);
+
+      // Trigger update for index assignments (arr[0] = value)
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        setPageContext(function (prevContext) {
+          return _objectSpread(_objectSpread({}, prevContext), {}, {
+            Widgets: _objectSpread(_objectSpread({}, prevContext.Widgets), {}, (0, _defineProperty2["default"])({}, widgetName, _objectSpread(_objectSpread({}, prevContext.Widgets[widgetName]), {}, (0, _defineProperty2["default"])({}, propName, (0, _toConsumableArray2["default"])(target)))))
+          });
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(arrayProxy, true);
+  return arrayProxy;
+};
+
+// Create array proxy for state context
+var createStateArrayProxy = function createStateArrayProxy(array, path, propName, setPageContext) {
+  if (proxyMap.has(array)) {
+    return array;
+  }
+  var arrayProxy = new Proxy(array, {
+    get: function get(target, prop, receiver) {
+      var value = Reflect.get(target, prop, receiver);
+
+      // If it's a mutating method, wrap it to trigger updates
+      if (typeof prop === "string" && MUTATING_ARRAY_METHODS.includes(prop) && typeof value === "function") {
+        return function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          var result = value.apply(target, args);
+
+          // Trigger state context update after mutation
+          setPageContext(function (prev) {
+            var newState = _objectSpread({}, prev);
+            var current = newState;
+            for (var i = 0; i < path.length; i++) {
+              var key = path[i];
+              current[key] = _objectSpread({}, current[key]);
+              current = current[key];
+            }
+
+            // Set the new array reference to trigger re-render
+            current[propName] = (0, _toConsumableArray2["default"])(target);
+            return newState;
+          });
+          return result;
+        };
+      }
+      return value;
+    },
+    set: function set(target, prop, value, receiver) {
+      var result = Reflect.set(target, prop, value, receiver);
+
+      // Trigger update for index assignments (arr[0] = value)
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        setPageContext(function (prev) {
+          var newState = _objectSpread({}, prev);
+          var current = newState;
+          for (var i = 0; i < path.length; i++) {
+            var key = path[i];
+            current[key] = _objectSpread({}, current[key]);
+            current = current[key];
+          }
+
+          // Set the new array reference to trigger re-render
+          current[propName] = (0, _toConsumableArray2["default"])(target);
+          return newState;
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(arrayProxy, true);
+  return arrayProxy;
+};
+var createWidgetProxy = exports.createWidgetProxy = function createWidgetProxy(widget, widgetName, setPageContext, overriddenPropsRegistry) {
+  // If widget is already a proxy or is a DOM element, return it directly
+  if (proxyMap.has(widget) || (0, _dom.isDOMElement)(widget)) {
+    return widget;
+  }
+  if (!(0, _isString["default"])(widgetName)) {
+    return widget;
+  }
+  if (widget == null) {
+    return widget;
+  }
+  var proxy = new Proxy(widget, {
+    set: function set(target, prop, value, receiver) {
+      // Ignore internal properties
+      if ((0, _typeof2["default"])(prop) === "symbol" || prop === "prototype") {
+        return Reflect.set(target, prop, value, receiver);
+      }
+
+      // Skip if value hasn't changed
+      var currentVal = Reflect.get(target, prop, receiver);
+      if (currentVal === value) {
+        return true;
+      }
+
+      // track script-modified properties
+      if (typeof prop === "string") {
+        var widgetId = widget["data-widget-id"];
+        // Use page-specific registry if provided, otherwise fallback to global
+        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: function get(target, prop, receiver) {
+      if ((0, _typeof2["default"])(prop) === "symbol" || prop === "prototype") {
+        return Reflect.get(target, prop, receiver);
+      }
+
+      //  setProperty method to set properties dynamically
+      if (prop === "setProperty") {
+        return function (key, value) {
+          proxy[key] = value;
+          return this;
+        };
+      }
+
+      // Special getter for $element - return jQuery-like wrapped element
+      if (prop === "$element") {
+        var rawElement = Reflect.get(target, prop, receiver);
+        if (rawElement) {
+          // If already wrapped, return as-is
+          if (rawElement.length === 1 && (0, _dom.isDOMElement)(rawElement[0])) {
+            return rawElement;
+          }
+          // If raw DOM element, wrap it
+          if ((0, _dom.isDOMElement)(rawElement)) {
+            return (0, _dom.wrapWithNativeDOM)(rawElement);
+          }
+        }
+
+        // Try to find element in DOM directly
+        var _widgetId = widget["data-widget-id"];
+        var element = (0, _widgetObserver.findWidgetElement)(widgetName, _widgetId);
+        if (element) {
+          var wrappedElement = (0, _dom.wrapWithNativeDOM)(element);
+          Reflect.defineProperty(target, prop, {
+            value: wrappedElement,
+            writable: true,
+            configurable: true,
+            enumerable: false
+          });
+          return wrappedElement;
+        }
+
+        // Register for future element updates if not found
+        if (!target._elementCallbackRegistered) {
+          var key = _widgetId ? "".concat(widgetName, ":").concat(_widgetId) : widgetName;
+          var callbacks = _widgetObserver.widgetElementCallbacks.get(key);
+          if (!callbacks) {
+            callbacks = new Set();
+            _widgetObserver.widgetElementCallbacks.set(key, callbacks);
+          }
+          callbacks.add(function (element) {
+            if (element) {
+              var wrapped = (0, _dom.wrapWithNativeDOM)(element);
+              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;
+      }
+      var value = Reflect.get(target, prop, receiver);
+
+      // Check for non-configurable, non-writable properties - must return actual value
+      // to satisfy JavaScript Proxy invariants (prevents "get on proxy" errors)
+      var descriptor = Object.getOwnPropertyDescriptor(target, prop);
+      if (descriptor && !descriptor.configurable && !descriptor.writable) {
+        return value;
+      }
+      var widgetId = widget["data-widget-id"];
+      // Use page-specific registry if provided, otherwise fallback to global
+      var widgetOverrides = overriddenPropsRegistry === null || overriddenPropsRegistry === void 0 ? void 0 : overriddenPropsRegistry.getWidgetOverrides(widgetName, widgetId);
+      if (widgetOverrides && prop in widgetOverrides) {
+        var _overriddenPropsRegis;
+        var internalValue = overriddenPropsRegistry === null || overriddenPropsRegistry === void 0 || (_overriddenPropsRegis = overriddenPropsRegistry.getLastInternalValue) === null || _overriddenPropsRegis === void 0 ? void 0 : _overriddenPropsRegis.call(overriddenPropsRegistry, widgetName, prop);
+        return internalValue !== undefined ? internalValue : widgetOverrides[prop];
+      }
+
+      // Return DOM elements directly to preserve their context
+      if ((0, _dom.isDOMElement)(value)) {
+        return value;
+      }
+
+      // Return array proxy to preserve native array behavior while enabling reactivity
+      if (Array.isArray(value) && typeof prop === "string") {
+        return createArrayProxy(value, widgetName, prop, setPageContext);
+      }
+      return value;
+    }
+  });
+
+  // Store proxy flag in WeakMap
+  proxyMap.set(proxy, true);
+  // Store original target reference
+  originalTargets.set(proxy, widget);
+  return proxy;
+};
+var createPageProxy = exports.createPageProxy = function createPageProxy(target, setPageContext, overriddenPropsRegistry) {
+  // Cache for widget proxies
+  var widgetProxies = new Map();
+  return new Proxy(target, {
+    get: function get(widgetsTarget, widgetName) {
+      // Handle non-string properties
+      if (widgetName === undefined || widgetName === "undefined") {
+        return undefined;
+      }
+      if (typeof widgetName !== "string") {
+        return widgetsTarget[widgetName];
+      }
+
+      // Initialize widget if it doesn't exist
+      if (!(widgetName in widgetsTarget)) {
+        widgetsTarget[widgetName] = {
+          name: widgetName
+        };
+      }
+      var widget = widgetsTarget[widgetName];
+
+      // Return cached proxy if available
+      if (widgetProxies.has(widgetName)) {
+        var _proxy = widgetProxies.get(widgetName);
+        var originalTarget = originalTargets.get(_proxy);
+        var safeWidget = widget != null && (0, _typeof2["default"])(widget) === "object" ? widget : null;
+        var safeOriginal = originalTarget != null && (0, _typeof2["default"])(originalTarget) === "object" ? originalTarget : null;
+
+        // Always sync properties to ensure proxy has latest data
+        // This is important when widget was initially created with minimal data
+        if (safeWidget && safeOriginal && (widget !== originalTarget || Object.keys(safeWidget).length > Object.keys(safeOriginal).length)) {
+          // Copy all properties from widget to originalTarget
+          for (var key in safeWidget) {
+            Reflect.defineProperty(safeOriginal, key, {
+              value: safeWidget[key],
+              writable: true,
+              configurable: true,
+              enumerable: true
+            });
+          }
+          // Pin widgetsTarget back to originalTarget so that subsequent GETs within the
+          // same synchronous call stack see widget === originalTarget (no re-sync).
+          // This prevents the sync from overwriting proxy mutations (e.g. selectedItems
+          // set via createWidgetProxy.set) with stale values from widgetsTarget.
+          widgetsTarget[widgetName] = safeOriginal;
+        }
+        return _proxy;
+      }
+
+      // Create and cache a new proxy
+      var proxy = widget ? createWidgetProxy(widget, widgetName, setPageContext, overriddenPropsRegistry) : undefined;
+      widgetProxies.set(widgetName, proxy);
+      return proxy;
+    },
+    set: function set(widgetsTarget, widgetName, widgetValue) {
+      // Skip if nothing changed
+      if (widgetsTarget[widgetName] === widgetValue) {
+        return true;
+      }
+
+      // Update the widget in the target
+      widgetsTarget[widgetName] = widgetValue;
+
+      // Update existing proxy or create a new one
+      if (widgetProxies.has(widgetName)) {
+        var proxy = widgetProxies.get(widgetName);
+        var originalTarget = originalTargets.get(proxy);
+
+        // Only copy changed properties
+        if (widgetValue && (0, _typeof2["default"])(widgetValue) === "object") {
+          for (var key in widgetValue) {
+            var newVal = widgetValue[key];
+            var oldVal = originalTarget[key];
+            if (oldVal !== newVal) {
+              Reflect.defineProperty(originalTarget, key, {
+                value: newVal,
+                writable: true,
+                configurable: true,
+                enumerable: true
+              });
+            }
+          }
+        }
+      } else if (widgetValue && (0, _typeof2["default"])(widgetValue) === "object") {
+        // Create a new proxy
+        var _proxy2 = createWidgetProxy(widgetValue, widgetName, setPageContext, overriddenPropsRegistry);
+        widgetProxies.set(widgetName, _proxy2);
+      }
+      return true;
+    }
+  });
+};
+var _createStateProxy = exports.createStateProxy = function createStateProxy(obj) {
+  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var setPageContext = arguments.length > 2 ? arguments[2] : undefined;
+  var overriddenPropsRegistry = arguments.length > 3 ? arguments[3] : undefined;
+  // Cache for nested proxies
+  var nestedProxies = new Map();
+  return new Proxy(obj, {
+    get: function get(target, prop, receiver) {
+      if (prop === "eval") {
+        return function (fn) {
+          var failOnError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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");
+      }
+
+      // Do not auto-create missing properties; just return undefined
+      if (!(prop in target)) {
+        return undefined;
+      }
+      var value = Reflect.get(target, prop, receiver);
+
+      // Return primitives directly
+      if ((0, _typeof2["default"])(value) !== "object" || value === null) {
+        return value;
+      }
+
+      // Check for non-configurable, non-writable properties - must return actual value
+      // to satisfy JavaScript Proxy invariants (prevents "get on proxy" errors)
+      var descriptor = Object.getOwnPropertyDescriptor(target, prop);
+      if (descriptor && !descriptor.configurable && !descriptor.writable) {
+        return value;
+      }
+      if (value instanceof _serviceVariable.ServiceVariable || value instanceof _liveVariable["default"]) {
+        return value;
+      }
+
+      // Return DOM elements directly without proxying
+      if ((0, _dom.isDOMElement)(value)) {
+        return value;
+      }
+      if (value instanceof Map || value instanceof Date) {
+        return value;
+      }
+
+      // Return array proxy to preserve native array behavior while enabling reactivity
+      if (Array.isArray(value)) {
+        return createStateArrayProxy(value, path, prop, setPageContext);
+      }
+
+      // Use cached proxy if available
+      if (nestedProxies.has(prop)) {
+        return nestedProxies.get(prop);
+      }
+      if (target !== null && target !== void 0 && target.prefab) {
+        if (nestedProxies.has(target.name)) {
+          return nestedProxies.get(target.name)[prop];
+        }
+      }
+
+      // Create and cache a new nested proxy
+      var nestedProxy = _createStateProxy(value, [].concat((0, _toConsumableArray2["default"])(path), [prop]), setPageContext, overriddenPropsRegistry);
+      nestedProxies.set(prop, nestedProxy);
+      return nestedProxy;
+    },
+    set: function set(target, prop, value, receiver) {
+      // Skip if value hasn't changed
+      var currentVal = Reflect.get(target, prop, receiver);
+      if (currentVal === value) {
+        return true;
+      }
+
+      // Update target directly
+      Reflect.set(target, prop, value, receiver);
+
+      // Clear cached proxy if value is an object (but not an array)
+      if ((0, _typeof2["default"])(value) === "object" && value !== null && !Array.isArray(value) && nestedProxies.has(prop)) {
+        nestedProxies["delete"](prop);
+      }
+      if (target !== null && target !== void 0 && target.prefab) {
+        if (nestedProxies.has(target.name)) {
+          var existingProxy = nestedProxies.get(target.name);
+          existingProxy[prop] = value;
+        } else {
+          nestedProxies.set(target.name, createWidgetProxy(target, target.name, setPageContext));
+        }
+      }
+      setPageContext(function (prev) {
+        // Create minimal copies along path
+        var newState = _objectSpread({}, prev);
+        var current = newState;
+        for (var i = 0; i < path.length; i++) {
+          var key = path[i];
+          // for variables not spreading to hold the instance reference
+          var existing = current[key];
+          var isVariableInstance = (0, _typeof2["default"])(existing) === "object" && (existing instanceof _serviceVariable.ServiceVariable || existing instanceof _liveVariable["default"] || existing instanceof _modelVariable.ModelVariable || existing instanceof _crudVariable["default"]);
+          var newVal = isVariableInstance ? existing : existing ? _objectSpread({}, existing) : {};
+          current[key] = newVal;
+          current = current[key];
+        }
+
+        // Set the value
+        current[prop] = value;
+        return newState;
+      });
+      return true;
+    }
+  });
+};

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;