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

package/utils/lib-error-skipper.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapWithThirdPartyErrorGuard = exports.isJQueryError = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+/**
+ * Wraps page/prefab script methods with error handling that detects
+ * unsupported library usage (e.g. jQuery) and surfaces all other errors
+ * with full context instead of swallowing them.
+ */
+
+var UNSUPPORTED_LIBRARIES = {
+  jquery: {
+    identifiers: ["jQuery", "$(", "$."],
+    errorMessage: "jQuery is not supported in React App",
+    notificationMessage: "jQuery functionality is not supported. Check console for details."
+  }
+};
+function detectUnsupportedLibrary(error) {
+  if (!(error !== null && error !== void 0 && error.stack)) return null;
+  var haystack = "".concat(error.message || "", "\n").concat(error.stack);
+  for (var _i = 0, _Object$entries = Object.entries(UNSUPPORTED_LIBRARIES); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+      name = _Object$entries$_i[0],
+      config = _Object$entries$_i[1];
+    if (config.identifiers.some(function (id) {
+      return haystack.includes(id);
+    })) {
+      return {
+        library: name,
+        config: config
+      };
+    }
+  }
+  return null;
+}
+var isJQueryError = exports.isJQueryError = function isJQueryError(error) {
+  var _detectUnsupportedLib;
+  return ((_detectUnsupportedLib = detectUnsupportedLibrary(error)) === null || _detectUnsupportedLib === void 0 ? void 0 : _detectUnsupportedLib.library) === "jquery";
+};
+var SKIP_PROPERTIES = new Set(["Variables", "Actions", "Widgets", "App", "pageParams", "serviceDefinitions", "baseUrl", "appConfig", "notification", "toaster", "onContentReady", "onChange", "cleanup", "eval", "appLocale", "executeStartup", "formatters", "type", "componentName", "componentType", "prefabname", "onPropertyChange"]);
+var wrapWithThirdPartyErrorGuard = exports.wrapWithThirdPartyErrorGuard = function wrapWithThirdPartyErrorGuard(pageProxy, appContext, componentName) {
+  var _loop = function _loop() {
+    var methodName = _Object$keys[_i2];
+    if (typeof pageProxy[methodName] !== "function" || SKIP_PROPERTIES.has(methodName)) return 1; // continue
+    var originalMethod = pageProxy[methodName];
+    pageProxy[methodName] = function () {
+      try {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return originalMethod.apply(this, args);
+      } catch (error) {
+        var detection = detectUnsupportedLibrary(error);
+        if (detection) {
+          var _appContext$notifyApp;
+          console.error("[".concat(detection.library.toUpperCase(), "] ").concat(componentName, ".").concat(methodName, "(): ").concat(detection.config.errorMessage), error);
+          appContext === null || appContext === void 0 || (_appContext$notifyApp = appContext.notifyApp) === null || _appContext$notifyApp === void 0 || _appContext$notifyApp.call(appContext, detection.config.notificationMessage, "Error");
+          return undefined;
+        }
+        console.error("[script] ".concat(componentName, ".").concat(methodName, "():"), error);
+      }
+    };
+    Object.defineProperty(pageProxy[methodName], "name", {
+      value: "wrapped_".concat(methodName),
+      writable: false
+    });
+  };
+  for (var _i2 = 0, _Object$keys = Object.keys(pageProxy); _i2 < _Object$keys.length; _i2++) {
+    if (_loop()) continue;
+  }
+};

package/utils/page-params-util.d.ts

@@ -0,0 +1,20 @@
+export declare const computeMergedPageParams: (urlParams: Record<string, any>, options?: {
+    componentType?: string;
+    props?: Record<string, any>;
+}) => Record<string, any>;
+/**
+ * Extracts param values from props (excluding functions) for partial components
+ * @param params - Array of param keys to extract (e.g., ['toPageName', 'userId'])
+ * @param props - Props object containing the param values
+ * @returns Object with param keys and their non-function values
+ */
+export declare const extractPartialParamValues: (params: string[], props: Record<string, any>) => Record<string, any>;
+/**
+ * Computes a stable serialized key from partial param values
+ * Used as a dependency for effects that need to react to param changes
+ * @param componentType - Type of component ('PARTIAL', 'PAGE', etc.)
+ * @param params - Array of param keys to watch
+ * @param props - Props object containing the param values
+ * @returns JSON string of param values or null for non-partial components
+ */
+export declare const computePartialParamKey: (componentType: string | undefined, params: string[] | undefined, props: Record<string, any>) => string | null;

package/utils/page-params-util.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPartialParamValues = exports.computePartialParamKey = exports.computeMergedPageParams = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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 computeMergedPageParams = exports.computeMergedPageParams = function computeMergedPageParams(urlParams, options) {
+  var _ref = options || {},
+    componentType = _ref.componentType,
+    props = _ref.props;
+  if (componentType === "PARTIAL") {
+    var partialParams = {};
+    Object.keys(props || {}).forEach(function (k) {
+      // Including all incoming props as partial params
+      partialParams[k] = props[k];
+    });
+    return _objectSpread(_objectSpread({}, urlParams), partialParams);
+  }
+  return urlParams;
+};
+
+/**
+ * Extracts param values from props (excluding functions) for partial components
+ * @param params - Array of param keys to extract (e.g., ['toPageName', 'userId'])
+ * @param props - Props object containing the param values
+ * @returns Object with param keys and their non-function values
+ */
+var extractPartialParamValues = exports.extractPartialParamValues = function extractPartialParamValues(params, props) {
+  return (params || []).reduce(function (acc, key) {
+    var val = props[key];
+    // Exclude functions - they get new references on every render
+    if (typeof val !== "function") {
+      acc[key] = val;
+    }
+    return acc;
+  }, {});
+};
+
+/**
+ * Computes a stable serialized key from partial param values
+ * Used as a dependency for effects that need to react to param changes
+ * @param componentType - Type of component ('PARTIAL', 'PAGE', etc.)
+ * @param params - Array of param keys to watch
+ * @param props - Props object containing the param values
+ * @returns JSON string of param values or null for non-partial components
+ */
+var computePartialParamKey = exports.computePartialParamKey = function computePartialParamKey(componentType, params, props) {
+  if (componentType !== "PARTIAL") {
+    return null;
+  }
+  return JSON.stringify(extractPartialParamValues(params || [], props));
+};

package/utils/pending-tab-navigation-intent.d.ts

@@ -0,0 +1,4 @@
+export declare function applyPendingTabNavigationIntent(value: string | null): void;
+export declare function clearPendingTabNavigationIntent(): void;
+/** Tab pane `name` to select after navigation, or null if none. */
+export declare function getPendingTabNavigationIntent(): string | null;

package/utils/pending-tab-navigation-intent.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyPendingTabNavigationIntent = applyPendingTabNavigationIntent;
+exports.clearPendingTabNavigationIntent = clearPendingTabNavigationIntent;
+exports.getPendingTabNavigationIntent = getPendingTabNavigationIntent;
+/**
+ * Holds the pending tab pane name for cross-page "go to tab" navigation.
+ * Kept in sync with navigation.pendingTabSelection via store middleware so
+ * components (e.g. WmTabs) can read it without react-redux Provider.
+ */
+var intent = null;
+function applyPendingTabNavigationIntent(value) {
+  intent = value;
+}
+function clearPendingTabNavigationIntent() {
+  intent = null;
+}
+
+/** Tab pane `name` to select after navigation, or null if none. */
+function getPendingTabNavigationIntent() {
+  return intent;
+}

package/utils/resource-url.d.ts

@@ -0,0 +1 @@
+export declare function prefixPrefabResourceUrl(source: string | undefined, prefabName?: string): string;

package/utils/resource-url.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prefixPrefabResourceUrl = prefixPrefabResourceUrl;
+function prefixPrefabResourceUrl(source, prefabName) {
+  if (!source) return source || "";
+  var trimmed = source.trim();
+
+  // Skip if absolute http(s) URL or starts with data: or blob:
+  var lower = trimmed.toLowerCase();
+  if (lower.startsWith("http://") || lower.startsWith("https://") || lower.startsWith("data:") || lower.startsWith("blob:")) {
+    return source;
+  }
+
+  // Only process if starts with resources/ and prefabName exists
+  if (!prefabName) return source;
+  if (!trimmed.startsWith("resources/")) return source;
+
+  // If already prefixed with prefabName/, avoid double prefixing
+  var prefabPrefix = "".concat(prefabName, "/");
+  if (trimmed.startsWith(prefabPrefix)) return source;
+
+  // concadinating the prefabName with scr path like  Port_In_PreCheck + /resources/images/imagelists/bring_your_phone.png
+  return "".concat(prefabName, "/").concat(trimmed);
+}

package/utils/state-persistance.d.ts

@@ -0,0 +1,27 @@
+export type StorageType = "localStorage" | "sessionStorage" | "URL" | "none";
+type WidgetType = "accordion" | "tabs" | "list" | "table";
+interface StateConfig {
+    name: string;
+    type: WidgetType;
+    storage: StorageType;
+}
+/**
+ * Marks that a page navigation (router.push) is about to occur.
+ * This prevents URL state persistence (router.replace) from overwriting the navigation.
+ * Must be called SYNCHRONOUSLY before router.push() is invoked.
+ * Auto-clears after 2 seconds to prevent getting stuck.
+ */
+export declare const markPageNavigationPending: () => void;
+/**
+ * Clears the page navigation pending flag.
+ * Called after navigation completes or is cancelled.
+ */
+export declare const clearPageNavigationPending: () => void;
+/**
+ * Checks if page navigation is currently pending.
+ */
+export declare const isPageNavigationPending: () => boolean;
+export declare const getWidgetState: (config: StateConfig) => any;
+export declare const setWidgetState: (config: StateConfig, value: any) => void;
+export declare const clearWidgetState: (config: StateConfig) => void;
+export {};

package/utils/state-persistance.js

@@ -0,0 +1,411 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setWidgetState = exports.markPageNavigationPending = exports.isPageNavigationPending = exports.getWidgetState = exports.clearWidgetState = exports.clearPageNavigationPending = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _lodashEs = require("lodash-es");
+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; }
+// Storage keys
+var WM_STATE_KEY = "wm_state";
+var WM_STATE_URL_PARAM = "wm_state";
+// Default workspace name
+var DEFAULT_WORKSPACE = "ws";
+
+// Page navigation tracking - prevents router.replace() from overwriting router.push()
+// when both are called during the same event (e.g., click on container inside list)
+var pageNavigationPending = false;
+var navigationClearTimeout = null;
+
+/**
+ * Marks that a page navigation (router.push) is about to occur.
+ * This prevents URL state persistence (router.replace) from overwriting the navigation.
+ * Must be called SYNCHRONOUSLY before router.push() is invoked.
+ * Auto-clears after 2 seconds to prevent getting stuck.
+ */
+var markPageNavigationPending = exports.markPageNavigationPending = function markPageNavigationPending() {
+  pageNavigationPending = true;
+
+  // Clear any existing timeout
+  if (navigationClearTimeout) {
+    clearTimeout(navigationClearTimeout);
+  }
+
+  // Auto-clear after 2 seconds to prevent getting stuck
+  // (navigation should complete well before this)
+  navigationClearTimeout = setTimeout(function () {
+    pageNavigationPending = false;
+    navigationClearTimeout = null;
+  }, 2000);
+};
+
+/**
+ * Clears the page navigation pending flag.
+ * Called after navigation completes or is cancelled.
+ */
+var clearPageNavigationPending = exports.clearPageNavigationPending = function clearPageNavigationPending() {
+  pageNavigationPending = false;
+  if (navigationClearTimeout) {
+    clearTimeout(navigationClearTimeout);
+    navigationClearTimeout = null;
+  }
+};
+
+/**
+ * Checks if page navigation is currently pending.
+ */
+var isPageNavigationPending = exports.isPageNavigationPending = function isPageNavigationPending() {
+  return pageNavigationPending;
+};
+
+// Generate storage key for localStorage/sessionStorage (page-specific)
+var getStorageKey = function getStorageKey() {
+  if (typeof window === "undefined") return WM_STATE_KEY;
+  return window.location.pathname.replace(/\//g, "").replace("react-pages/", "") + "_" + WM_STATE_KEY;
+};
+
+// Get current page name from pathname
+var getCurrentPageName = function getCurrentPageName() {
+  if (typeof window === "undefined") return "";
+  var segments = window.location.pathname.split("/").filter(Boolean);
+  return segments[segments.length - 1] || "Main";
+};
+
+// Convert JSON to URL-friendly encoded format (no quotes needed)
+var jsonToUri = function jsonToUri(jsonObj) {
+  // Custom stringify that doesn't use quotes
+  var _customStringify = function customStringify(obj) {
+    if (obj === null) return "null";
+    if (obj === undefined) return "undefined";
+    if (typeof obj === "string") return obj;
+    if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
+    if (Array.isArray(obj)) {
+      if (obj.length === 0) return "!*";
+      return "!" + obj.map(_customStringify).join("_") + "*";
+    }
+    if ((0, _typeof2["default"])(obj) === "object") {
+      var pairs = [];
+      for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+          key = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        pairs.push(key + "~" + _customStringify(value));
+      }
+      if (pairs.length === 0) return "()";
+      return "(" + pairs.join("_") + ")";
+    }
+    return String(obj);
+  };
+  return _customStringify(jsonObj);
+};
+
+// Decode URL-encoded format back to object
+var uriToJson = function uriToJson(encodedObj) {
+  try {
+    // First decode any URL encoding
+    var decoded = decodeURIComponent(encodedObj);
+
+    // Custom parser for our format
+    var _parse3 = function parse(str) {
+      var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (str[startIndex] === "(") {
+        // Parse object
+        var obj = {};
+        var i = startIndex + 1;
+        while (i < str.length && str[i] !== ")") {
+          // Check for empty object
+          if (str[i] === ")") break;
+
+          // Parse key
+          var key = "";
+          while (i < str.length && str[i] !== "~") {
+            key += str[i];
+            i++;
+          }
+          i++; // skip '~'
+
+          // Parse value
+          var _parse = _parse3(str, i),
+            _value = _parse.value,
+            endIndex = _parse.endIndex;
+          obj[key] = _value;
+          i = endIndex;
+          if (str[i] === "_") {
+            i++; // skip '_' separator
+          }
+        }
+        return {
+          value: obj,
+          endIndex: i + 1
+        }; // skip ')'
+      } else if (str[startIndex] === "!") {
+        // Parse array
+        var arr = [];
+        var _i2 = startIndex + 1;
+        while (_i2 < str.length && str[_i2] !== "*") {
+          var _parse2 = _parse3(str, _i2),
+            _value2 = _parse2.value,
+            _endIndex = _parse2.endIndex;
+          arr.push(_value2);
+          _i2 = _endIndex;
+          if (str[_i2] === "_") {
+            _i2++; // skip '_' separator
+          }
+        }
+        return {
+          value: arr,
+          endIndex: _i2 + 1
+        }; // skip '*'
+      } else {
+        // Parse primitive
+        var _value3 = "";
+        var _i3 = startIndex;
+        while (_i3 < str.length && str[_i3] !== "_" && str[_i3] !== ")" && str[_i3] !== "*") {
+          _value3 += str[_i3];
+          _i3++;
+        }
+
+        // Convert to appropriate type
+        if (_value3 === "null") return {
+          value: null,
+          endIndex: _i3
+        };
+        if (_value3 === "undefined") return {
+          value: undefined,
+          endIndex: _i3
+        };
+        if (_value3 === "true") return {
+          value: true,
+          endIndex: _i3
+        };
+        if (_value3 === "false") return {
+          value: false,
+          endIndex: _i3
+        };
+
+        // Check if it's a number
+        var num = Number(_value3);
+        if (!isNaN(num) && _value3 !== "") {
+          return {
+            value: num,
+            endIndex: _i3
+          };
+        }
+        return {
+          value: _value3,
+          endIndex: _i3
+        };
+      }
+    };
+    var _parse4 = _parse3(decoded),
+      value = _parse4.value;
+    return value;
+  } catch (e) {
+    console.warn("Failed to parse state from URL:", e);
+    return {};
+  }
+};
+
+// URL state update batching - prevents Chrome IPC flooding (crbug.com/1038223) when many
+// widgets call replaceState during the same React commit phase (e.g., multiple tables mounting)
+var pendingUrlStates = null;
+var urlStateRafId = null;
+var flushPendingUrlState = function flushPendingUrlState() {
+  urlStateRafId = null;
+  if (pendingUrlStates === null) return;
+  var states = pendingUrlStates;
+  pendingUrlStates = null;
+  var currentUrl = window.location.href;
+  var url = new URL(window.location.href);
+  var urlParams = new URLSearchParams(url.search);
+  if ((0, _lodashEs.keys)(states).length > 0) {
+    var encodedState = jsonToUri(states);
+    urlParams["delete"](WM_STATE_URL_PARAM);
+    var newSearch = urlParams.toString();
+    if (newSearch) newSearch += "&";
+    newSearch += "".concat(WM_STATE_URL_PARAM, "=").concat(encodedState);
+    url.search = newSearch ? "?" + newSearch : "";
+  } else {
+    urlParams["delete"](WM_STATE_URL_PARAM);
+    url.search = urlParams.toString();
+  }
+  if (currentUrl !== url.toString() && !pageNavigationPending) {
+    var newPath = url.pathname + url.search;
+    window.history.replaceState(_objectSpread({}, window.history.state), "", newPath);
+  }
+};
+var scheduleUrlStateUpdate = function scheduleUrlStateUpdate(states) {
+  pendingUrlStates = states;
+  if (urlStateRafId === null) {
+    urlStateRafId = requestAnimationFrame(flushPendingUrlState);
+  }
+};
+
+// Get all widget states from storage
+var getAllStates = function getAllStates(storage) {
+  switch (storage) {
+    case "localStorage":
+      var localData = localStorage.getItem(getStorageKey());
+      try {
+        return localData ? JSON.parse(localData) : {};
+      } catch (_unused) {
+        return {};
+      }
+    case "sessionStorage":
+      var sessionData = sessionStorage.getItem(getStorageKey());
+      try {
+        return sessionData ? JSON.parse(sessionData) : {};
+      } catch (_unused2) {
+        return {};
+      }
+    case "URL":
+      // Use pending state when available - ensures consistency when URL updates are batched
+      if (pendingUrlStates !== null) {
+        return _objectSpread({}, pendingUrlStates);
+      }
+      // Get the raw URL parameter value
+      var searchParams = window.location.search;
+      var match = searchParams.match(new RegExp("[?&]".concat(WM_STATE_URL_PARAM, "=([^&]+)")));
+      if (!match || !match[1]) return {};
+
+      // Use Angular's decoding approach
+      return uriToJson(match[1]);
+    default:
+      return {};
+  }
+};
+
+// Set all widget states to storage
+var setAllStates = function setAllStates(storage, states) {
+  switch (storage) {
+    case "localStorage":
+      localStorage.setItem(getStorageKey(), JSON.stringify(states));
+      break;
+    case "sessionStorage":
+      sessionStorage.setItem(getStorageKey(), JSON.stringify(states));
+      break;
+    case "URL":
+      // Batch URL updates via requestAnimationFrame to prevent Chrome IPC flooding
+      // when many widgets (tables, lists, etc.) update state during the same commit phase
+      scheduleUrlStateUpdate(states);
+      break;
+  }
+};
+var getWidgetState = exports.getWidgetState = function getWidgetState(config) {
+  var name = config.name,
+    type = config.type,
+    storage = config.storage;
+  var allStates = getAllStates(storage);
+
+  // For URL storage, use flat structure (Angular style)
+  // For localStorage/sessionStorage, use page-specific structure
+  if (storage === "URL") {
+    var _allStates$DEFAULT_WO;
+    var widgetData = (_allStates$DEFAULT_WO = allStates[DEFAULT_WORKSPACE]) === null || _allStates$DEFAULT_WO === void 0 ? void 0 : _allStates$DEFAULT_WO[name];
+    return widgetData || null;
+  } else {
+    var _allStates$currentPag;
+    var currentPageName = getCurrentPageName();
+    var _widgetData = (_allStates$currentPag = allStates[currentPageName]) === null || _allStates$currentPag === void 0 || (_allStates$currentPag = _allStates$currentPag[DEFAULT_WORKSPACE]) === null || _allStates$currentPag === void 0 ? void 0 : _allStates$currentPag[name];
+    return _widgetData || null;
+  }
+};
+var setWidgetState = exports.setWidgetState = function setWidgetState(config, value) {
+  var name = config.name,
+    type = config.type,
+    storage = config.storage;
+  if (storage === "none") {
+    return;
+  }
+  var allStates = getAllStates(storage);
+
+  // For URL storage, use flat structure (Angular style)
+  if (storage === "URL") {
+    // Ensure the workspace exists
+    if (!allStates[DEFAULT_WORKSPACE]) {
+      allStates[DEFAULT_WORKSPACE] = {};
+    }
+
+    // Update the specific widget state
+    if ((0, _lodashEs.isObject)(value) && !(0, _lodashEs.isArray)(value) && allStates[DEFAULT_WORKSPACE][name]) {
+      var existingValue = allStates[DEFAULT_WORKSPACE][name];
+      if ((0, _lodashEs.isObject)(existingValue) && !(0, _lodashEs.isArray)(existingValue)) {
+        (0, _lodashEs.merge)(existingValue, value);
+      } else {
+        allStates[DEFAULT_WORKSPACE][name] = value;
+      }
+    } else {
+      allStates[DEFAULT_WORKSPACE][name] = value;
+    }
+  } else {
+    // For localStorage/sessionStorage, use page-specific structure
+    var currentPageName = getCurrentPageName();
+
+    // Ensure the hierarchy exists: Page -> workspace -> widget
+    if (!allStates[currentPageName]) {
+      allStates[currentPageName] = {};
+    }
+    if (!allStates[currentPageName][DEFAULT_WORKSPACE]) {
+      allStates[currentPageName][DEFAULT_WORKSPACE] = {};
+    }
+
+    // Update the specific widget state
+    if ((0, _lodashEs.isObject)(value) && !(0, _lodashEs.isArray)(value) && allStates[currentPageName][DEFAULT_WORKSPACE][name]) {
+      var _existingValue = allStates[currentPageName][DEFAULT_WORKSPACE][name];
+      if ((0, _lodashEs.isObject)(_existingValue) && !(0, _lodashEs.isArray)(_existingValue)) {
+        (0, _lodashEs.merge)(_existingValue, value);
+      } else {
+        allStates[currentPageName][DEFAULT_WORKSPACE][name] = value;
+      }
+    } else {
+      allStates[currentPageName][DEFAULT_WORKSPACE][name] = value;
+    }
+  }
+
+  // Save the updated state hierarchy
+  setAllStates(storage, allStates);
+};
+var clearWidgetState = exports.clearWidgetState = function clearWidgetState(config) {
+  var name = config.name,
+    type = config.type,
+    storage = config.storage;
+  if (storage === "none") {
+    return;
+  }
+  var allStates = getAllStates(storage);
+
+  // For URL storage, use flat structure
+  if (storage === "URL") {
+    if (allStates[DEFAULT_WORKSPACE]) {
+      delete allStates[DEFAULT_WORKSPACE][name];
+
+      // Clean up empty workspace
+      if ((0, _lodashEs.keys)(allStates[DEFAULT_WORKSPACE]).length === 0) {
+        delete allStates[DEFAULT_WORKSPACE];
+      }
+    }
+  } else {
+    var _allStates$currentPag2;
+    // For localStorage/sessionStorage, use page-specific structure
+    var currentPageName = getCurrentPageName();
+    if ((_allStates$currentPag2 = allStates[currentPageName]) !== null && _allStates$currentPag2 !== void 0 && _allStates$currentPag2[DEFAULT_WORKSPACE]) {
+      delete allStates[currentPageName][DEFAULT_WORKSPACE][name];
+
+      // Clean up empty objects
+      if ((0, _lodashEs.keys)(allStates[currentPageName][DEFAULT_WORKSPACE]).length === 0) {
+        delete allStates[currentPageName][DEFAULT_WORKSPACE];
+      }
+      if ((0, _lodashEs.keys)(allStates[currentPageName]).length === 0) {
+        delete allStates[currentPageName];
+      }
+    }
+  }
+
+  // Save the updated state hierarchy
+  setAllStates(storage, allStates);
+};

package/utils/style-utils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Utility functions for CSS style handling and validation
+ */
+/**
+ * Validates and sanitizes a style object to ensure it contains only valid CSS properties
+ * @param styleObj - The style object to sanitize
+ * @returns A sanitized style object with only valid CSS properties
+ */
+export declare const sanitizeStyleObject: (styleObj: any) => Record<string, any>;
+/**
+ * Merges multiple style objects safely, sanitizing each one
+ * @param styleObjects - Array of style objects to merge
+ * @returns A merged and sanitized style object
+ */
+export declare const mergeStyleObjects: (...styleObjects: any[]) => Record<string, any>;
+/**
+ * Validates if a value is a valid CSS style object
+ * @param value - The value to check
+ * @returns True if the value is a valid style object
+ */
+export declare const isValidStyleObject: (value: any) => boolean;
+export declare const filterAutoLayoutClasses: (layoutClassName: string | undefined, prefixesToGet: string[], mode?: "include" | "exclude") => string;
+/**
+ * Normalizes a React style length (width, height, margin, etc.): numbers become pixel
+ * values (`${n}px`), matching common React `style` behavior; strings pass through
+ * (e.g. `100%`, `2rem`, `10px`).
+ */
+export declare const toCssLength: (value: string | number) => string;