@wavemaker-ai/react-runtime 1.0.0-rc.312 → 1.0.0-rc.317

package/core/proxy-service.js

@@ -1,130 +1,122 @@
-"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;
+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();
+let pendingWidgetContextUpdates = null;
+let batchedSetPageContextForWidgets = null;
 function flushPendingWidgetContextUpdates() {
-  var batch = pendingWidgetContextUpdates;
-  var spc = batchedSetPageContextForWidgets;
+  const batch = pendingWidgetContextUpdates;
+  const spc = batchedSetPageContextForWidgets;
   pendingWidgetContextUpdates = null;
   batchedSetPageContextForWidgets = null;
-  if (!(batch !== null && batch !== void 0 && batch.size) || !spc) {
+  if (!(batch == null ? 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;
-          }
+  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] = _objectSpread(_objectSpread({}, currentWidget && (0, _typeof2["default"])(currentWidget) === "object" ? currentWidget : {}), props);
-        changed = true;
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+      newWidgets[name] = __spreadValues(__spreadValues({}, currentWidget && typeof currentWidget === "object" ? currentWidget : {}), props);
+      changed = true;
     }
     if (!changed) {
       return prevContext;
     }
-    return _objectSpread(_objectSpread({}, prevContext), {}, {
+    return __spreadProps(__spreadValues({}, prevContext), {
       Widgets: newWidgets
     });
   });
 }
 function queueBatchedWidgetContextUpdate(widgetName, widget, prop, value, setPageContext) {
-  if ((0, _typeof2["default"])(prop) === "symbol") {
+  if (typeof prop === "symbol") {
     return;
   }
-  var key = prop;
-  var isFirstInBatch = !pendingWidgetContextUpdates;
+  const key = prop;
+  const isFirstInBatch = !pendingWidgetContextUpdates;
   if (isFirstInBatch) {
-    pendingWidgetContextUpdates = new Map();
+    pendingWidgetContextUpdates = /* @__PURE__ */ new Map();
     batchedSetPageContextForWidgets = setPageContext;
   } else if (batchedSetPageContextForWidgets !== setPageContext) {
     batchedSetPageContextForWidgets = setPageContext;
   }
-  var existing = pendingWidgetContextUpdates.get(widgetName);
+  const existing = pendingWidgetContextUpdates.get(widgetName);
   if (existing) {
     existing.props[key] = value;
   } else {
     pendingWidgetContextUpdates.set(widgetName, {
-      widget: widget,
-      props: (0, _defineProperty2["default"])({}, key, value)
+      widget,
+      props: { [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) {
+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;
   }
-  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
+  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 () {
-          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 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;
@@ -132,14 +124,17 @@ var createArrayProxy = function createArrayProxy(array, widgetName, propName, se
       }
       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)
+    set(target, prop, value, receiver) {
+      const result = Reflect.set(target, prop, value, receiver);
       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)))))
+        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
+              })
+            })
           });
         });
       }
@@ -149,36 +144,25 @@ var createArrayProxy = function createArrayProxy(array, widgetName, propName, se
   proxyMap.set(arrayProxy, true);
   return arrayProxy;
 };
-
-// Create array proxy for state context
-var createStateArrayProxy = function createStateArrayProxy(array, path, propName, setPageContext) {
+const 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
+  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 () {
-          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]);
+        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];
             }
-
-            // Set the new array reference to trigger re-render
-            current[propName] = (0, _toConsumableArray2["default"])(target);
+            current[propName] = [...target];
             return newState;
           });
           return result;
@@ -186,22 +170,18 @@ var createStateArrayProxy = function createStateArrayProxy(array, path, propName
       }
       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)
+    set(target, prop, value, receiver) {
+      const result = Reflect.set(target, prop, value, receiver);
       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]);
+        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];
           }
-
-          // Set the new array reference to trigger re-render
-          current[propName] = (0, _toConsumableArray2["default"])(target);
+          current[propName] = [...target];
           return newState;
         });
       }
@@ -211,34 +191,27 @@ var createStateArrayProxy = function createStateArrayProxy(array, path, propName
   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)) {
+const createWidgetProxy = (widget, widgetName, setPageContext, overriddenPropsRegistry) => {
+  if (proxyMap.has(widget) || isDOMElement(widget)) {
     return widget;
   }
-  if (!(0, _isString["default"])(widgetName)) {
+  if (!isString(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") {
+  const proxy = new Proxy(widget, {
+    set(target, prop, value, receiver) {
+      if (typeof prop === "symbol" || prop === "prototype") {
         return Reflect.set(target, prop, value, receiver);
       }
-
-      // Skip if value hasn't changed
-      var currentVal = Reflect.get(target, prop, receiver);
+      const 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
+        const widgetId = widget["data-widget-id"];
         if (overriddenPropsRegistry && typeof overriddenPropsRegistry.trackOverriddenProps === "function") {
           overriddenPropsRegistry.trackOverriddenProps(widgetName, prop, value, widgetId);
         }
@@ -247,38 +220,31 @@ var createWidgetProxy = exports.createWidgetProxy = function createWidgetProxy(w
       queueBatchedWidgetContextUpdate(widgetName, widget, prop, value, setPageContext);
       return true;
     },
-    get: function get(target, prop, receiver) {
-      if ((0, _typeof2["default"])(prop) === "symbol" || prop === "prototype") {
+    get(target, prop, receiver) {
+      var _a;
+      if (typeof 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 function(key, value2) {
+          proxy[key] = value2;
           return this;
         };
       }
-
-      // Special getter for $element - return jQuery-like wrapped element
       if (prop === "$element") {
-        var rawElement = Reflect.get(target, prop, receiver);
+        const rawElement = Reflect.get(target, prop, receiver);
         if (rawElement) {
-          // If already wrapped, return as-is
-          if (rawElement.length === 1 && (0, _dom.isDOMElement)(rawElement[0])) {
+          if (rawElement.length === 1 && isDOMElement(rawElement[0])) {
             return rawElement;
           }
-          // If raw DOM element, wrap it
-          if ((0, _dom.isDOMElement)(rawElement)) {
-            return (0, _dom.wrapWithNativeDOM)(rawElement);
+          if (isDOMElement(rawElement)) {
+            return wrapWithNativeDOM(rawElement);
           }
         }
-
-        // Try to find element in DOM directly
-        var _widgetId = widget["data-widget-id"];
-        var element = (0, _widgetObserver.findWidgetElement)(widgetName, _widgetId);
+        const widgetId2 = widget["data-widget-id"];
+        const element = findWidgetElement(widgetName, widgetId2);
         if (element) {
-          var wrappedElement = (0, _dom.wrapWithNativeDOM)(element);
+          const wrappedElement = wrapWithNativeDOM(element);
           Reflect.defineProperty(target, prop, {
             value: wrappedElement,
             writable: true,
@@ -287,18 +253,16 @@ var createWidgetProxy = exports.createWidgetProxy = function createWidgetProxy(w
           });
           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);
+          const key = widgetId2 ? `${widgetName}:${widgetId2}` : widgetName;
+          let callbacks = widgetElementCallbacks.get(key);
           if (!callbacks) {
-            callbacks = new Set();
-            _widgetObserver.widgetElementCallbacks.set(key, callbacks);
+            callbacks = /* @__PURE__ */ new Set();
+            widgetElementCallbacks.set(key, callbacks);
           }
-          callbacks.add(function (element) {
-            if (element) {
-              var wrapped = (0, _dom.wrapWithNativeDOM)(element);
+          callbacks.add((element2) => {
+            if (element2) {
+              const wrapped = wrapWithNativeDOM(element2);
               Reflect.defineProperty(target, prop, {
                 value: wrapped,
                 writable: true,
@@ -316,75 +280,55 @@ var createWidgetProxy = exports.createWidgetProxy = function createWidgetProxy(w
         }
         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);
+      const value = Reflect.get(target, prop, receiver);
+      const 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);
+      const widgetId = widget["data-widget-id"];
+      const widgetOverrides = overriddenPropsRegistry == null ? 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)) {
+        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;
       }
-
-      // 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();
+const createPageProxy = (target, setPageContext, overriddenPropsRegistry) => {
+  const widgetProxies = /* @__PURE__ */ new Map();
   return new Proxy(target, {
-    get: function get(widgetsTarget, widgetName) {
-      // Handle non-string properties
-      if (widgetName === undefined || widgetName === "undefined") {
-        return undefined;
+    get(widgetsTarget, widgetName) {
+      if (widgetName === void 0 || widgetName === "undefined") {
+        return void 0;
       }
       if (typeof widgetName !== "string") {
         return widgetsTarget[widgetName];
       }
-
-      // Initialize widget if it doesn't exist
       if (!(widgetName in widgetsTarget)) {
-        widgetsTarget[widgetName] = {
-          name: widgetName
-        };
+        widgetsTarget[widgetName] = { name: widgetName };
       }
-      var widget = widgetsTarget[widgetName];
-
-      // Return cached proxy if available
+      const widget = widgetsTarget[widgetName];
       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
+        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)) {
-          // Copy all properties from widget to originalTarget
-          for (var key in safeWidget) {
+          for (const key in safeWidget) {
             Reflect.defineProperty(safeOriginal, key, {
               value: safeWidget[key],
               writable: true,
@@ -392,39 +336,26 @@ var createPageProxy = exports.createPageProxy = function createPageProxy(target,
               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;
+        return proxy2;
       }
-
-      // Create and cache a new proxy
-      var proxy = widget ? createWidgetProxy(widget, widgetName, setPageContext, overriddenPropsRegistry) : undefined;
+      const proxy = widget ? createWidgetProxy(widget, widgetName, setPageContext, overriddenPropsRegistry) : void 0;
       widgetProxies.set(widgetName, proxy);
       return proxy;
     },
-    set: function set(widgetsTarget, widgetName, widgetValue) {
-      // Skip if nothing changed
+    set(widgetsTarget, widgetName, widgetValue) {
       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];
+        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,
@@ -435,26 +366,25 @@ var createPageProxy = exports.createPageProxy = function createPageProxy(target,
             }
           }
         }
-      } else if (widgetValue && (0, _typeof2["default"])(widgetValue) === "object") {
-        // Create a new proxy
-        var _proxy2 = createWidgetProxy(widgetValue, widgetName, setPageContext, overriddenPropsRegistry);
-        widgetProxies.set(widgetName, _proxy2);
+      } else if (widgetValue && typeof widgetValue === "object") {
+        const proxy = createWidgetProxy(
+          widgetValue,
+          widgetName,
+          setPageContext,
+          overriddenPropsRegistry
+        );
+        widgetProxies.set(widgetName, proxy);
       }
       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();
+const createStateProxy = (obj, path = [], setPageContext, overriddenPropsRegistry) => {
+  const nestedProxies = /* @__PURE__ */ new Map();
   return new Proxy(obj, {
-    get: function get(target, prop, receiver) {
+    get(target, prop, receiver) {
       if (prop === "eval") {
-        return function (fn) {
-          var failOnError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        return (fn, failOnError = false) => {
           try {
             return fn.call(target);
           } catch (e) {
@@ -465,107 +395,113 @@ var _createStateProxy = exports.createStateProxy = function createStateProxy(obj
       }
       if (prop === "Widgets" && path.length === 0) {
         if (!nestedProxies.has("Widgets")) {
-          nestedProxies.set("Widgets", createPageProxy(target.Widgets, setPageContext, overriddenPropsRegistry));
+          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));
+          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;
+        return void 0;
       }
-      var value = Reflect.get(target, prop, receiver);
-
-      // Return primitives directly
-      if ((0, _typeof2["default"])(value) !== "object" || value === null) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof 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);
+      const descriptor = Object.getOwnPropertyDescriptor(target, prop);
       if (descriptor && !descriptor.configurable && !descriptor.writable) {
         return value;
       }
-      if (value instanceof _serviceVariable.ServiceVariable || value instanceof _liveVariable["default"]) {
+      if (value instanceof ServiceVariable || value instanceof LiveVariable) {
         return value;
       }
-
-      // Return DOM elements directly without proxying
-      if ((0, _dom.isDOMElement)(value)) {
+      if (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);
+        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 (target == null ? 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);
+      const nestedProxy = createStateProxy(
+        value,
+        [...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);
+    set(target, prop, value, receiver) {
+      const 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 (typeof value === "object" && value !== null && !Array.isArray(value) && nestedProxies.has(prop)) {
+        nestedProxies.delete(prop);
       }
-      if (target !== null && target !== void 0 && target.prefab) {
+      if (target == null ? void 0 : target.prefab) {
         if (nestedProxies.has(target.name)) {
-          var existingProxy = nestedProxies.get(target.name);
+          const 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) : {};
+      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];
         }
-
-        // Set the value
         current[prop] = value;
         return newState;
       });
       return true;
     }
   });
-};
+};
+export {
+  createPageProxy,
+  createStateProxy,
+  createWidgetProxy
+};