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

package/context/LayoutProvider.js

@@ -0,0 +1,66 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLayout = exports["default"] = exports.LayoutProvider = exports.LayoutContext = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _useDebounce = require("../hooks/useDebounce");
+var _events = require("../core/constants/events");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+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; }
+var LayoutContext = exports.LayoutContext = /*#__PURE__*/(0, _react.createContext)(null);
+var LayoutProvider = exports.LayoutProvider = function LayoutProvider(_ref) {
+  var children = _ref.children;
+  var _useState = (0, _react.useState)({}),
+    layout = _useState[0],
+    setLayout = _useState[1];
+  var layoutProxyRef = (0, _react.useRef)({});
+
+  // Batch state update support: collect layout updates within the debounce window and update state in batch
+  var batchRef = (0, _react.useRef)({});
+  var flushBatch = (0, _react.useCallback)(function () {
+    setLayout(function (prevLayout) {
+      return _objectSpread(_objectSpread({}, prevLayout), batchRef.current);
+    });
+    batchRef.current = {};
+  }, []);
+  var debounceBatchUpdate = (0, _useDebounce.useDebounceCallback)(flushBatch, 100);
+  var batchUpdateLayout = (0, _react.useCallback)(function (layoutName, layoutData) {
+    batchRef.current[layoutName] = layoutData;
+    debounceBatchUpdate();
+  }, [debounceBatchUpdate]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      return debounceBatchUpdate.cancel();
+    };
+  }, [debounceBatchUpdate]);
+  (0, _react.useEffect)(function () {
+    var handleLayoutRefresh = function handleLayoutRefresh(data) {
+      var _data$proxy;
+      layoutProxyRef.current[data.layoutName] = (_data$proxy = data.proxy) !== null && _data$proxy !== void 0 ? _data$proxy : {};
+      batchUpdateLayout(data.layoutName, data.layout);
+    };
+    _events.EVENTEMITTER_METHODS.LAYOUT_STATE_REFRESH_ON(handleLayoutRefresh);
+    return function () {
+      _events.EVENTEMITTER_METHODS.LAYOUT_STATE_REFRESH_OFF(handleLayoutRefresh);
+    };
+  }, [batchUpdateLayout]);
+  return __jsx(LayoutContext.Provider, {
+    value: {
+      layout: layout,
+      proxy: layoutProxyRef.current
+    }
+  }, children);
+};
+var useLayout = exports.useLayout = function useLayout() {
+  var context = (0, _react.useContext)(LayoutContext);
+  return context !== null && context !== void 0 ? context : {};
+};
+var _default = exports["default"] = LayoutProvider;

package/context/LocalizationProvider.d.ts

@@ -0,0 +1,4 @@
+declare const CustomLocalizationProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default CustomLocalizationProvider;

package/context/LocalizationProvider.js

@@ -0,0 +1,80 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _store = require("../store");
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _xDatePickers = require("@mui/x-date-pickers");
+var _AdapterMoment = require("@mui/x-date-pickers/AdapterMoment");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+var loadedLocales = new Set(["en"]);
+var loadMomentLocale = function loadMomentLocale(locale) {
+  if (!locale || locale === "en") {
+    return true;
+  }
+  var normalizedLocale = locale.toLowerCase();
+  if (loadedLocales.has(normalizedLocale)) {
+    return true;
+  }
+  try {
+    require("moment/locale/".concat(normalizedLocale, ".js"));
+    loadedLocales.add(normalizedLocale);
+    return true;
+  } catch (error) {
+    var baseLocale = normalizedLocale.split("-")[0];
+    if (baseLocale !== normalizedLocale && baseLocale !== "en" && !loadedLocales.has(baseLocale)) {
+      try {
+        require("moment/locale/".concat(baseLocale, ".js"));
+        loadedLocales.add(baseLocale);
+        return true;
+      } catch (baseError) {
+        return false;
+      }
+    }
+    return false;
+  }
+};
+var CustomLocalizationProvider = function CustomLocalizationProvider(_ref) {
+  var children = _ref.children;
+  var selectedLocale = (0, _store.useAppSelector)(function (state) {
+    return state.i18n.selectedLocale;
+  });
+  (0, _react.useEffect)(function () {
+    if (!selectedLocale) {
+      return;
+    }
+    var localeLoadSuccess = loadMomentLocale(selectedLocale);
+    _momentTimezone["default"].locale(selectedLocale);
+    if (localeLoadSuccess) {
+      _momentTimezone["default"].updateLocale(selectedLocale, {
+        monthsShort: Array.from({
+          length: 12
+        }, function (_, i) {
+          return (0, _momentTimezone["default"])().month(i).format("MMM");
+        }),
+        months: Array.from({
+          length: 12
+        }, function (_, i) {
+          return (0, _momentTimezone["default"])().month(i).format("MMMM");
+        })
+      });
+    }
+  }, [selectedLocale]);
+  return __jsx(_xDatePickers.LocalizationProvider, {
+    dateAdapter: _AdapterMoment.AdapterMoment,
+    adapterLocale: selectedLocale,
+    localeText: {
+      calendarViewSwitchingButtonAriaLabel: function calendarViewSwitchingButtonAriaLabel(view) {
+        return view === "year" ? "year view is open, switch to calendar view" : "calendar view is open, switch to year view";
+      }
+    }
+  }, children);
+};
+var _default = exports["default"] = CustomLocalizationProvider;

package/context/PrefabContext.d.ts

@@ -0,0 +1,15 @@
+interface PrefabContextProps {
+    inbound: Record<string, any>;
+    outbound: Record<string, any>;
+    prefabName: string;
+    parentForm?: string;
+    isParentList: boolean;
+    formArrayIndex: number;
+    parentListName?: string;
+}
+export declare const PrefabContext: import("react").Context<PrefabContextProps>;
+declare const PrefabProvider: ({ value: Context, children, }: {
+    value: PrefabContextProps;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default PrefabProvider;

package/context/PrefabContext.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.PrefabContext = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _lodash = require("lodash");
+var _events = require("../core/constants/events");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+var PrefabContext = exports.PrefabContext = /*#__PURE__*/(0, _react.createContext)({
+  inbound: {},
+  outbound: {},
+  prefabName: "",
+  parentForm: undefined,
+  isParentList: false,
+  formArrayIndex: -1,
+  parentListName: undefined
+});
+var getChangedKeys = function getChangedKeys(prev, curr) {
+  var changes = [];
+  var keys = new Set([].concat((0, _toConsumableArray2["default"])(Object.keys(prev)), (0, _toConsumableArray2["default"])(Object.keys(curr))));
+  keys.forEach(function (key) {
+    var ignoredKeys = ["name", "prefabname", "data-widget-id", "prefabName"];
+    if (ignoredKeys.includes(key)) {
+      return;
+    }
+    // Handle functions - compare their definitions to avoid unnecessary renders
+    var prevValue = prev[key];
+    var currValue = curr[key];
+    if (typeof prevValue === "function" && typeof currValue === "function") {
+      // Compare function definitions instead of function instances
+      if (prevValue.toString() !== currValue.toString() && prevValue === undefined && currValue !== undefined) {
+        changes.push({
+          key: key,
+          oldValue: prevValue,
+          newValue: currValue
+        });
+      }
+      return;
+    }
+    if (!(0, _lodash.isEqual)(prevValue, currValue) && currValue !== undefined && currValue !== null) {
+      changes.push({
+        key: key,
+        oldValue: prevValue,
+        newValue: currValue
+      });
+    }
+  });
+  return changes;
+};
+var PrefabProvider = function PrefabProvider(_ref) {
+  var Context = _ref.value,
+    children = _ref.children;
+  var prevOutboundRef = (0, _react.useRef)(Context.outbound);
+  var pendingChangesRef = (0, _react.useRef)([]);
+  var retryCountRef = (0, _react.useRef)(0);
+  var isInitialMountRef = (0, _react.useRef)(true);
+  var maxRetries = 20;
+  var initialMountMaxRetries = 30;
+  var rafIdRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(function () {
+    var currInbound = Context.inbound;
+    if ((0, _lodash.isEqual)(prevOutboundRef.current, currInbound)) {
+      return;
+    }
+
+    // Fix: Compare prevInboundRef.current with currInbound, not prevOutboundRef
+    var inboundChanges = getChangedKeys(prevOutboundRef.current, currInbound);
+
+    // Update ref for next comparison
+    prevOutboundRef.current = currInbound;
+    if (inboundChanges.length > 0) {
+      // Merge new changes with pending changes (deduplicate by key)
+      var changeMap = new Map();
+
+      // Add existing pending changes first
+      pendingChangesRef.current.forEach(function (change) {
+        changeMap.set(change.key, change);
+      });
+
+      // Overwrite with new changes (they're more recent)
+      inboundChanges.forEach(function (change) {
+        changeMap.set(change.key, change);
+      });
+      pendingChangesRef.current = Array.from(changeMap.values());
+      retryCountRef.current = 0;
+
+      // Cancel any pending RAF
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+      }
+
+      // Try to emit with retry mechanism
+      var _tryEmit = function tryEmit() {
+        // Convert array to object format that BasePage expects: {0: change1, 1: change2, ...}
+        var changesAsObject = {};
+        pendingChangesRef.current.forEach(function (change, index) {
+          changesAsObject[index] = change;
+        });
+
+        // Emit the event
+        // Note: EventEmitter.emit returns true if there are listeners, false otherwise
+        var hasListeners = _events.EVENTEMITTER_METHODS.PREFAB_STATE_SYNC_EMIT(Context.prefabName, changesAsObject);
+
+        // Determine max retries based on whether this is initial mount
+        var currentMaxRetries = isInitialMountRef.current ? initialMountMaxRetries : maxRetries;
+
+        // If no listeners were registered and we haven't exceeded max retries, retry
+        if (!hasListeners && retryCountRef.current < currentMaxRetries) {
+          retryCountRef.current += 1;
+
+          // On initial mount, use more RAF cycles for slower machines
+          var rafCycles = isInitialMountRef.current ? 10 : 5;
+          var rafChain = _tryEmit;
+          var _loop = function _loop() {
+            var next = rafChain;
+            rafChain = function rafChain() {
+              rafIdRef.current = requestAnimationFrame(function () {
+                next();
+              });
+            };
+          };
+          for (var i = 0; i < rafCycles; i++) {
+            _loop();
+          }
+          rafChain();
+        } else {
+          // Successfully emitted (listeners received it) or max retries reached
+          if (hasListeners) {
+            // Success! Mark as no longer initial mount after first successful emission
+            isInitialMountRef.current = false;
+          } else {
+            // Max retries reached but no listeners found
+            // This could happen if BasePage is taking longer than expected
+            // Reset the flag to allow normal retry behavior for future updates
+            // This prevents being stuck in initial mount mode indefinitely
+            isInitialMountRef.current = false;
+            console.warn("PrefabContext: Max retries reached without finding listeners. " + "BasePage may not be ready yet. Future updates will use normal retry behavior.");
+          }
+          pendingChangesRef.current = [];
+          retryCountRef.current = 0;
+          rafIdRef.current = null;
+        }
+      };
+
+      // Start emission process: wait for React commit, then BasePage initialization
+      // Use more RAF cycles on initial mount (hard reload scenarios)
+      var initialRafCycles = isInitialMountRef.current ? 5 : 3;
+      queueMicrotask(function () {
+        // Build RAF chain: each cycle waits for the next frame
+        var rafChain = _tryEmit;
+        var _loop2 = function _loop2() {
+          var next = rafChain;
+          rafChain = function rafChain() {
+            rafIdRef.current = requestAnimationFrame(function () {
+              next();
+            });
+          };
+        };
+        for (var i = 0; i < initialRafCycles; i++) {
+          _loop2();
+        }
+
+        // Start the chain
+        rafChain();
+      });
+    }
+  }, [Context.inbound]);
+
+  // Cleanup RAF on unmount and reset state on remount
+  (0, _react.useEffect)(function () {
+    return function () {
+      // Cancel any pending RAF operations
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+      // Reset state for clean remount
+      pendingChangesRef.current = [];
+      retryCountRef.current = 0;
+      // Reset initial mount flag on unmount so next mount starts fresh
+      // This ensures proper behavior if component unmounts and remounts
+      isInitialMountRef.current = true;
+    };
+  }, []);
+  return __jsx(PrefabContext.Provider, {
+    value: Context
+  }, children);
+};
+var _default = exports["default"] = PrefabProvider;

package/context/WidgetProvider.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+interface WidgetContextProps {
+    pageContext: any;
+    updateWidgetState: (widgetName: string, props: Record<string, any>) => void;
+    proxy: any;
+    destroy: (widgetName: string[]) => void;
+}
+export declare const WidgetProvider: ({ value: Context, children, }: {
+    value: {
+        value: any;
+        proxy: any;
+    };
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const usePageContext: (standalone?: boolean) => WidgetContextProps;
+export declare const useWidgetProxy: (name?: string, standalone?: boolean) => any;
+export declare const useProxy: (path?: string) => any;
+export declare const useAppState: () => any;
+export {};

package/context/WidgetProvider.js

@@ -0,0 +1,274 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useWidgetProxy = exports.useProxy = exports.usePageContext = exports.useAppState = exports.WidgetProvider = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _get = _interopRequireDefault(require("lodash-es/get"));
+var _debounce = _interopRequireDefault(require("lodash-es/debounce"));
+var _useDebounce = require("../hooks/useDebounce");
+var _useHttp = require("../hooks/useHttp");
+var _formState = require("../utils/form-state.util");
+var _widgetCleanupUtil = require("../utils/widget-cleanup-util");
+var _events = require("../core/constants/events");
+var _proxyService = require("../core/proxy-service");
+var _LayoutProvider = require("./LayoutProvider");
+var _isPlainObject = _interopRequireDefault(require("lodash-es/isPlainObject"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+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; }
+var WidgetContext = /*#__PURE__*/(0, _react.createContext)(undefined);
+
+// WeakMap to store proxy flags without exposing them as props
+var proxyMap = new WeakMap();
+var WidgetProvider = exports.WidgetProvider = function WidgetProvider(_ref) {
+  var _pageContext$componen, _pageContext$componen3;
+  var Context = _ref.value,
+    children = _ref.children;
+  var value = Context.value,
+    proxy = Context.proxy;
+  var pageContextRef = (0, _react.useRef)(proxy);
+  var _useState = (0, _react.useState)(_objectSpread(_objectSpread({}, value), {}, {
+      isLayoutReady: false
+    })),
+    pageContext = _useState[0],
+    setPageContext = _useState[1];
+  var _useLayout = (0, _LayoutProvider.useLayout)(),
+    layout = _useLayout.layout,
+    layoutProxy = _useLayout.proxy;
+  var pendingDestroysRef = (0, _react.useRef)(new Set());
+  var isPage = (pageContext === null || pageContext === void 0 || (_pageContext$componen = pageContext.componentType) === null || _pageContext$componen === void 0 ? void 0 : _pageContext$componen.toUpperCase()) === "PAGE";
+  var flushDestroys = (0, _react.useCallback)(function () {
+    var names = Array.from(pendingDestroysRef.current);
+    pendingDestroysRef.current.clear();
+    if (names.length === 0) return;
+    setPageContext(function (prev) {
+      var newContext = (0, _widgetCleanupUtil.removeWidgetsFromContext)(prev, proxy, names);
+      pageContextRef.current = newContext;
+      return newContext;
+    });
+  }, []);
+  var debouncedFlushDestroys = (0, _useDebounce.useDebounceCallback)(flushDestroys, 100);
+  (0, _react.useEffect)(function () {
+    return function () {
+      return debouncedFlushDestroys.cancel();
+    };
+  }, [debouncedFlushDestroys]);
+  var isAppWidgetRegisterNeeded = (0, _react.useMemo)(function () {
+    var _pageContext$componen2;
+    return isPage || (pageContext === null || pageContext === void 0 || (_pageContext$componen2 = pageContext.componentName) === null || _pageContext$componen2 === void 0 ? void 0 : _pageContext$componen2.toUpperCase()) === "COMMON";
+  }, [isPage, pageContext === null || pageContext === void 0 ? void 0 : pageContext.componentName]);
+  var destroy = (0, _react.useCallback)(function (widgetNames) {
+    if (!(widgetNames !== null && widgetNames !== void 0 && widgetNames.length)) return;
+    widgetNames.forEach(function (name) {
+      return name && pendingDestroysRef.current.add(name);
+    });
+    debouncedFlushDestroys();
+  }, [debouncedFlushDestroys]);
+  (0, _react.useEffect)(function () {
+    setPageContext(function (prevContext) {
+      var newContext = _objectSpread({}, prevContext);
+      function registerMethod(context, newWidget, widgetName) {
+        if (isAppWidgetRegisterNeeded) {
+          pageContextRef.current.App.Widgets[widgetName] = newWidget;
+        }
+        context.Widgets[widgetName] = newWidget;
+      }
+      if (value !== null && value !== void 0 && value.Widgets && newContext !== null && newContext !== void 0 && newContext.Widgets) {
+        Object.keys(value.Widgets).forEach(function (widgetName) {
+          var currentWidget = newContext.Widgets[widgetName];
+          var incomingWidget = value.Widgets[widgetName];
+          if (currentWidget !== null && currentWidget !== void 0 && currentWidget.App) {
+            var _pageContextRef$curre;
+            registerMethod(newContext, (_pageContextRef$curre = pageContextRef.current) === null || _pageContextRef$curre === void 0 ? void 0 : _pageContextRef$curre.Widgets[widgetName], widgetName);
+          } else {
+            if (!isPage && incomingWidget !== null && incomingWidget !== void 0 && incomingWidget.isLayout) return;
+            // Create new proxy if widget doesn't exist or isn't proxied
+            // Get registry from pageContext if available
+            var registry = value === null || value === void 0 ? void 0 : value.overriddenPropsRegistry;
+            var widgetProxy = (0, _proxyService.createWidgetProxy)(incomingWidget, widgetName, setPageContext, registry);
+            (0, _formState.registerFormField)(newContext.Widgets, widgetProxy, incomingWidget, newContext);
+            registerMethod(newContext, widgetProxy, widgetName);
+          }
+        });
+      }
+
+      // Handle other context properties
+      value && Object.keys(value).forEach(function (key) {
+        if (key !== "Widgets") {
+          newContext[key] = value[key];
+        }
+      });
+      pageContextRef.current = newContext;
+      return newContext;
+    });
+  }, [value]);
+  (0, _react.useEffect)(function () {
+    var layoutKeys = Object.keys(layout);
+    if (isPage && (0, _isPlainObject["default"])(layout) && layoutKeys.length > 0) {
+      setPageContext(function (prevContext) {
+        var newContext = prevContext;
+        if (newContext !== null && newContext !== void 0 && newContext.Widgets) {
+          layoutKeys.forEach(function (widgetName) {
+            var currentWidget = newContext.Widgets[widgetName];
+            var incomingWidget = layout[widgetName];
+            if (!currentWidget || !proxyMap.has(currentWidget)) {
+              newContext.Widgets[widgetName] = layoutProxy[widgetName];
+              proxy.Widgets[widgetName] = layoutProxy[widgetName];
+            } else {
+              // Update existing proxy properties - important for widgets that start minimal
+              // Always update all properties to ensure proxy has complete data
+              Object.entries(incomingWidget).forEach(function (_ref2) {
+                var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
+                  key = _ref3[0],
+                  val = _ref3[1];
+                if (typeof key === "string" && !key.startsWith("_")) {
+                  currentWidget[key] = val;
+                  proxy.Widgets[widgetName][key] = val;
+                }
+              });
+            }
+          });
+        }
+
+        // Handle other context properties
+        value && Object.keys(value).forEach(function (key) {
+          if (key !== "Widgets") {
+            newContext[key] = value[key];
+          }
+        });
+        return newContext;
+      });
+      proxy.layoutReady && proxy.layoutReady();
+    }
+  }, [layout]);
+  var updateWidgetState = (0, _react.useMemo)(function () {
+    return function (widgetName, props) {
+      if (!widgetName || !pageContext.Widgets) return;
+      var widget = pageContext.Widgets[widgetName];
+      if (!isPage && widget !== null && widget !== void 0 && widget.isLayout) return;
+      if (widget != props) {
+        pageContextRef.current.Widgets[widgetName] = props;
+        pageContext.Widgets[widgetName] = props;
+        if (isAppWidgetRegisterNeeded) {
+          pageContextRef.current.App.Widgets[widgetName] = props;
+          pageContext.App.Widgets[widgetName] = props;
+        }
+      }
+      // Register form field with safe structure initialization
+      (0, _formState.registerFormFieldSafe)(pageContext.Widgets, props);
+    };
+  }, [isAppWidgetRegisterNeeded]);
+
+  // Stable debounced emitter
+  var debouncedEmitRef = (0, _react.useRef)((0, _debounce["default"])(function (partialName, context) {
+    _events.EVENTEMITTER_METHODS.PARTIAL_STATE_SYNC_EMIT({
+      partialName: partialName,
+      pageContext: context,
+      proxy: pageContextRef.current
+    });
+  }, 100));
+
+  // Extract only what matters to avoid extra renders
+  var partialName = (pageContext === null || pageContext === void 0 ? void 0 : pageContext.partialName) || (pageContext === null || pageContext === void 0 || (_pageContext$componen3 = pageContext.componentType) === null || _pageContext$componen3 === void 0 ? void 0 : _pageContext$componen3.toLowerCase()) === "prefab" && (pageContext === null || pageContext === void 0 ? void 0 : pageContext.name);
+  (0, _react.useEffect)(function () {
+    if (!isPage) return;
+    var handlePartialStateSync = function handlePartialStateSync(data) {
+      var _data$pageContext;
+      if (!data.pageContext) return;
+      if ((_data$pageContext = data.pageContext) !== null && _data$pageContext !== void 0 && _data$pageContext.isLayout) return;
+
+      // If proxy must sync, clone to avoid mutation issues
+      // pageContext.Widgets[data.partialName] = data.pageContext;
+      // pageContext.App.Widgets[data.partialName] = data.pageContext;   // keep for reference for later
+      proxy.Widgets[data.partialName] = data.proxy;
+      if (isAppWidgetRegisterNeeded) proxy.App.Widgets[data.partialName] = data.proxy;
+    };
+    _events.EVENTEMITTER_METHODS.PARTIAL_STATE_SYNC_ON(handlePartialStateSync);
+    return function () {
+      _events.EVENTEMITTER_METHODS.PARTIAL_STATE_SYNC_OFF(handlePartialStateSync);
+      debouncedEmitRef.current.cancel();
+    };
+  }, []);
+
+  /**
+   * Emit partial updates only for partial/prefab types
+   */
+  (0, _react.useEffect)(function () {
+    if (isPage || !partialName) return;
+    debouncedEmitRef.current(partialName, proxy);
+    if (pageContext !== null && pageContext !== void 0 && pageContext.isLayout) {
+      _events.EVENTEMITTER_METHODS.LAYOUT_STATE_REFRESH_EMIT({
+        layoutName: pageContext.partialName,
+        layout: pageContext,
+        proxy: proxy
+      });
+    }
+    return function () {
+      debouncedEmitRef.current.cancel();
+    };
+  }, [partialName, pageContext, isPage]);
+  var contextValue = (0, _react.useMemo)(function () {
+    return {
+      pageContext: pageContext,
+      updateWidgetState: updateWidgetState,
+      proxy: proxy,
+      destroy: destroy
+    };
+  }, [pageContext, updateWidgetState, proxy, destroy]);
+  return __jsx(_useHttp.HttpProvider, null, __jsx(WidgetContext.Provider, {
+    value: contextValue
+  }, children));
+};
+var usePageContext = exports.usePageContext = function usePageContext(standalone) {
+  var context = (0, _react.useContext)(WidgetContext);
+  if (standalone) {
+    return {
+      pageContext: {},
+      updateWidgetState: function updateWidgetState() {},
+      proxy: {},
+      destroy: function destroy() {}
+    };
+  }
+  if (!context) {
+    throw new Error("useWidgetContext must be used within a WidgetProvider");
+  }
+  return context;
+};
+var useWidgetProxy = exports.useWidgetProxy = function useWidgetProxy(name, standalone) {
+  var context = (0, _react.useContext)(WidgetContext);
+  if (standalone) {
+    return {};
+  }
+  if (!context) {
+    throw new Error("useWidgetProxy must be used within a WidgetProvider");
+  }
+  if (!name) {
+    return context.proxy.Widgets;
+  }
+  return (0, _get["default"])(context.proxy, "Widgets.".concat(name), {});
+};
+var useProxy = exports.useProxy = function useProxy(path) {
+  var context = (0, _react.useContext)(WidgetContext);
+  if (!context) {
+    throw new Error("useProxy must be used within a WidgetProvider");
+  }
+  if (!path) {
+    return context.proxy;
+  }
+  return (0, _get["default"])(context.proxy, path, null);
+};
+var useAppState = exports.useAppState = function useAppState() {
+  var context = (0, _react.useContext)(WidgetContext);
+  if (!context) {
+    throw new Error("useAppState must be used within a WidgetProvider");
+  }
+  return context.pageContext;
+};

package/core/app-config.js

@@ -0,0 +1 @@
+"use strict";