@wavemaker/react-runtime 11.14.1-16.6404

package/core/util/index.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatMessage = exports.deepCopy = exports.checkPublicAccess = exports._get = exports.VALIDATOR = exports.MONTHNAMES = exports.MATCH_MODES = void 0;
+exports.getCurrentMonth = getCurrentMonth;
+exports.isDefined = exports.getValidJSON = exports.getSessionStorageItem = void 0;
+exports.reload = reload;
+exports.toNumber = exports.setSessionStorageItem = exports.replace = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _get2 = _interopRequireDefault(require("lodash-es/get"));
+var _store = require("@wavemaker/react-runtime/store");
+var _lodashEs = require("lodash-es");
+var VALIDATOR = exports.VALIDATOR = {
+  REQUIRED: "required",
+  MAXCHARS: "maxchars",
+  MINVALUE: "minvalue",
+  MAXVALUE: "maxvalue",
+  REGEXP: "regexp",
+  MINDATE: "mindate",
+  MAXDATE: "maxdate",
+  MINTIME: "mintime",
+  MAXTIME: "maxtime",
+  EXCLUDEDATES: "excludedates",
+  EXCLUDEDAYS: "excludedays"
+};
+var MATCH_MODES = exports.MATCH_MODES = {
+  STARTS_WITH_IGNORE_CASE: "startignorecase",
+  STARTS_WITH: "start",
+  ENDS_WITH_IGNORE_CASE: "endignorecase",
+  ENDS_WITH: "end",
+  CONTAINS: "anywhere",
+  CONTAINS_IGNORE_CASE: "anywhereignorecase",
+  IS_EQUAL_WITH_IGNORE_CASE: "exactignorecase",
+  IS_EQUAL: "exact"
+};
+var MONTHNAMES = exports.MONTHNAMES = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var checkPublicAccess = exports.checkPublicAccess = function checkPublicAccess(page) {
+  var _window$location$path, _store$getState$info$;
+  var pageName = page || ((_window$location$path = window.location.pathname) === null || _window$location$path === void 0 ? void 0 : _window$location$path.split("/").at(-1));
+  return ((_store$getState$info$ = _store.store.getState().info.appConfig) === null || _store$getState$info$ === void 0 || (_store$getState$info$ = _store$getState$info$.pages) === null || _store$getState$info$ === void 0 || (_store$getState$info$ = _store$getState$info$.find(function (page) {
+    return page.name === pageName;
+  })) === null || _store$getState$info$ === void 0 ? void 0 : _store$getState$info$.permission) === "PermitAll";
+};
+var setSessionStorageItem = exports.setSessionStorageItem = function setSessionStorageItem(key, value) {
+  var id = _store.store.getState().info.appConfig.appProperties.displayName;
+  var item = window.sessionStorage.getItem(id);
+  if (item) {
+    item = JSON.parse(item);
+  } else {
+    item = {};
+  }
+  item[key] = value;
+  window.sessionStorage.setItem(id, JSON.stringify(item));
+};
+var getSessionStorageItem = exports.getSessionStorageItem = function getSessionStorageItem(key) {
+  var id = _store.store.getState().info.appConfig.appProperties.displayName;
+  var item = window && window.sessionStorage && window.sessionStorage.getItem(id);
+  if (item) {
+    item = JSON.parse(item);
+    return item[key];
+  }
+};
+var formatMessage = exports.formatMessage = function formatMessage(fragment, expression) {
+  return (0, _get2["default"])(fragment, "appLocale.".concat(expression), expression);
+};
+
+// Reload the app
+function reload() {
+  window.location.reload();
+}
+var toNumber = exports.toNumber = function toNumber(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  return Number(value);
+};
+var _get = exports._get = _get2["default"];
+var _deepCopy = function _deepCopy(o1) {
+  for (var _len = arguments.length, o2 = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    o2[_key - 1] = arguments[_key];
+  }
+  o2.forEach(function (o) {
+    if (o) {
+      Object.keys(o).forEach(function (k) {
+        var v = o[k];
+        if (v && !(0, _lodashEs.isString)(v) && !(0, _lodashEs.isArray)(v) && (0, _typeof2["default"])(v) === "object") {
+          o1[k] = _deepCopy(o1[k] || {}, o[k]);
+        } else {
+          o1[k] = _deepCopy(v);
+        }
+      });
+    }
+  });
+  return o1;
+};
+var deepCopy = exports.deepCopy = function deepCopy() {
+  for (var _len2 = arguments.length, objects = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    objects[_key2] = arguments[_key2];
+  }
+  return _deepCopy.apply(void 0, [{}].concat(objects));
+};
+var getValidJSON = exports.getValidJSON = function getValidJSON(content) {
+  if (!content) {
+    return undefined;
+  }
+  try {
+    var parsedIntValue = parseInt(content, 10);
+    return (0, _lodashEs.isObject)(content) || !isNaN(parsedIntValue) ? content : JSON.parse(content);
+  } catch (e) {
+    return undefined;
+  }
+};
+var isDefined = exports.isDefined = function isDefined(v) {
+  return typeof v !== "undefined";
+};
+var replace = exports.replace = function replace(template, map, parseError) {
+  var regEx = /\$\{([^\}]+)\}/g;
+  if (!template) {
+    return;
+  }
+  if (parseError) {
+    regEx = /\{([^\}]+)\}/g;
+  }
+  return template.replace(regEx, function (match, key) {
+    return (0, _get2["default"])(map, key);
+  });
+};
+
+// Get current month function
+function getCurrentMonth() {
+  var currentDate = new Date();
+  return MONTHNAMES[currentDate.getMonth()];
+}

package/core/util/security.js

@@ -0,0 +1,184 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTrustAs = exports.useSafeUrl = exports.useSafeStyle = exports.useSafeResourceUrl = exports.useSafeHtml = exports.securityService = exports.isInsecureContentRequest = exports.SecurityService = exports.SecurityContext = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _dompurify = _interopRequireDefault(require("dompurify"));
+var _startsWith = _interopRequireDefault(require("lodash-es/startsWith"));
+var _react = require("react");
+var _SecurityService;
+/**
+ * Security context types that can be trusted
+ */
+var SecurityContext = exports.SecurityContext = /*#__PURE__*/function (SecurityContext) {
+  SecurityContext["HTML"] = "HTML";
+  SecurityContext["STYLE"] = "STYLE";
+  SecurityContext["SCRIPT"] = "SCRIPT";
+  SecurityContext["URL"] = "URL";
+  SecurityContext["RESOURCE_URL"] = "RESOURCE_URL";
+  return SecurityContext;
+}({});
+/**
+ * Security service for sanitizing and trusting content
+ */
+var SecurityService = exports.SecurityService = /*#__PURE__*/function () {
+  function SecurityService() {
+    (0, _classCallCheck2["default"])(this, SecurityService);
+  } // Private constructor to enforce singleton
+  (0, _createClass2["default"])(SecurityService, [{
+    key: "sanitizeHtml",
+    value:
+    /**
+     * Sanitize HTML content
+     */
+    function sanitizeHtml(content) {
+      if (!content) return "";
+      return _dompurify["default"].sanitize(content, {
+        USE_PROFILES: {
+          html: true
+        }
+      });
+    }
+
+    /**
+     * Sanitize style content
+     */
+  }, {
+    key: "sanitizeStyle",
+    value: function sanitizeStyle(content) {
+      if (!content) return "";
+      return _dompurify["default"].sanitize(content, {
+        USE_PROFILES: {
+          html: true
+        },
+        ALLOWED_TAGS: ["style"],
+        ALLOWED_ATTR: ["type"]
+      });
+    }
+
+    /**
+     * Sanitize script content
+     */
+  }, {
+    key: "sanitizeScript",
+    value: function sanitizeScript(content) {
+      if (!content) return "";
+      // Note: DOMPurify strips scripts by default for security
+      // Only use this for trusted sources
+      return content;
+    }
+
+    /**
+     * Sanitize URL
+     */
+  }, {
+    key: "sanitizeUrl",
+    value: function sanitizeUrl(content) {
+      if (!content) return "";
+      // Basic URL sanitization
+      var url = content.trim().toLowerCase();
+      if (url.startsWith("javascript:") || url.startsWith("data:") || url.startsWith("vbscript:")) {
+        return "";
+      }
+      return content;
+    }
+
+    /**
+     * Sanitize Resource URL
+     */
+  }, {
+    key: "sanitizeResourceUrl",
+    value: function sanitizeResourceUrl(content) {
+      if (!content) return "";
+      // First sanitize as a regular URL, then cast to resource URL
+      var sanitizedUrl = this.sanitizeUrl(content);
+      return sanitizedUrl ? String(sanitizedUrl) : "";
+    }
+
+    /**
+     * Trust content based on security context
+     */
+  }, {
+    key: "trustAs",
+    value: function trustAs(content, context) {
+      if (!content) return "";
+      switch (context) {
+        case SecurityContext.HTML:
+          return this.sanitizeHtml(content);
+        case SecurityContext.STYLE:
+          return this.sanitizeStyle(content);
+        case SecurityContext.SCRIPT:
+          return this.sanitizeScript(content);
+        case SecurityContext.URL:
+          return this.sanitizeUrl(content);
+        case SecurityContext.RESOURCE_URL:
+          return this.sanitizeResourceUrl(content);
+        default:
+          return "";
+      }
+    }
+  }], [{
+    key: "getInstance",
+    value: function getInstance() {
+      if (!SecurityService.instance) {
+        SecurityService.instance = new SecurityService();
+      }
+      return SecurityService.instance;
+    }
+  }]);
+  return SecurityService;
+}(); // Create hooks for easy use in React components
+_SecurityService = SecurityService;
+(0, _defineProperty2["default"])(SecurityService, "instance", void 0);
+var useTrustAs = exports.useTrustAs = function useTrustAs(content, context) {
+  return (0, _react.useMemo)(function () {
+    return SecurityService.getInstance().trustAs(content, context);
+  }, [content, context]);
+};
+var useSafeHtml = exports.useSafeHtml = function useSafeHtml(content) {
+  return (0, _react.useMemo)(function () {
+    return SecurityService.getInstance().sanitizeHtml(content);
+  }, [content]);
+};
+var useSafeStyle = exports.useSafeStyle = function useSafeStyle(content) {
+  return (0, _react.useMemo)(function () {
+    return SecurityService.getInstance().sanitizeStyle(content);
+  }, [content]);
+};
+var useSafeUrl = exports.useSafeUrl = function useSafeUrl(content) {
+  return (0, _react.useMemo)(function () {
+    return SecurityService.getInstance().sanitizeUrl(content);
+  }, [content]);
+};
+var useSafeResourceUrl = exports.useSafeResourceUrl = function useSafeResourceUrl(content) {
+  return (0, _react.useMemo)(function () {
+    return SecurityService.getInstance().sanitizeResourceUrl(content);
+  }, [content]);
+};
+var isInsecureContentRequest = exports.isInsecureContentRequest = function isInsecureContentRequest(url) {
+  var REGEX_DATA_URL = /^\s*data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*)\s*$/i;
+  var parser = document.createElement("a");
+  parser.href = url;
+
+  // for relative urls IE returns the protocol as empty string
+  if (parser.protocol === "") {
+    return false;
+  }
+
+  // If the inputted source is a base64 url, do not throw insecure content error
+  if (REGEX_DATA_URL.test(url)) {
+    return false;
+  }
+  if ((0, _startsWith["default"])(location.href, "https://")) {
+    return parser.protocol !== "https:" && parser.protocol !== "wss:";
+  }
+  return false;
+};
+
+// Export singleton instance
+var securityService = exports.securityService = SecurityService.getInstance();

package/core/util/utils.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.triggerItemAction = exports.openLink = exports.isJQueryError = exports.isInsecureContentRequest = exports.getUrlParams = exports.getRouteNameFromLink = exports.Utils = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _navigationMiddleware = require("@wavemaker/react-runtime/store/middleware/navigationMiddleware");
+var _constants = require("../constants");
+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; }
+var REGEX = {
+  SNAKE_CASE: /[A-Z]/g,
+  ANDROID: /Android/i,
+  IPHONE: /iPhone/i,
+  IPOD: /iPod/i,
+  IPAD: /iPad/i,
+  MAC: /Mac/i,
+  ANDROID_TABLET: /android|android 3.0|xoom|sch-i800|playbook|tablet|kindle/i,
+  MOBILE: /Mobile/i,
+  WINDOWS: /Windows Phone/i,
+  SUPPORTED_IMAGE_FORMAT: /\.(bmp|gif|jpe|jpg|jpeg|tif|tiff|pbm|png|ico)$/i,
+  SUPPORTED_FILE_FORMAT: /\.(txt|js|css|html|script|properties|json|java|xml|smd|xmi|sql|log|wsdl|vm|ftl|jrxml|yml|yaml|md|less|jsp)$/i,
+  SUPPORTED_AUDIO_FORMAT: /\.(mp3|ogg|webm|wma|3gp|wav|m4a)$/i,
+  SUPPORTED_VIDEO_FORMAT: /\.(mp4|ogg|webm|wmv|mpeg|mpg|avi|mov)$/i,
+  PAGE_RESOURCE_PATH: /^\/pages\/.*\.(js|css|html|json)$/,
+  MIN_PAGE_RESOURCE_PATH: /.*(page.min.html)$/,
+  VALID_EMAIL: /^[a-zA-Z][\w.+]+@[a-zA-Z_]+?\.[a-zA-Z.]{1,4}[a-zA-Z]$/,
+  VALID_WEB_URL: /^(http[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9=:?\/\.\-]+(\.[a-zA-Z]{2,5}[\.]{0,1})?/,
+  VALID_WEBSOCKET_URL: /^(ws[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9=:?\/\.\-]+(\.[a-zA-Z]{2,5}[\.]{0,1})?/,
+  VALID_RELATIVE_URL: /^(?!www\.|(?:http|ftp)s?:\/\/|[A-Za-z]:\\|\/\/).*/,
+  REPLACE_PATTERN: /\$\{([^\}]+)\}/g,
+  ZIP_FILE: /\.zip$/i,
+  EXE_FILE: /\.exe$/i,
+  NO_QUOTES_ALLOWED: /^[^'|"]*$/,
+  NO_DOUBLE_QUOTES_ALLOWED: /^[^"]*$/,
+  VALID_HTML: /<[a-z][\s\S]*>/i,
+  VALID_PASSWORD: /^[0-9a-zA-Z-_.@&*!#$%]+$/,
+  SPECIAL_CHARACTERS: /[^A-Z0-9a-z_]+/i,
+  APP_SERVER_URL_FORMAT: /^(http[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9\.\-]+([:]?[0-9]{2,5}|\.[a-zA-Z]{2,5}[\.]{0,1})\/+[^?#&=]+$/,
+  JSON_DATE_FORMAT: /\d{4}-[0-1]\d-[0-3]\d(T[0-2]\d:[0-5]\d:[0-5]\d.\d{1,3}Z$)?/,
+  DATA_URL: /^\s*data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*)\s*$/i,
+  ISO_DATE_FORMAT: /(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(\.\d+)?([+-]\d{2}:?\d{2}|Z)$/
+};
+
+/**
+ * this method checks if a given string starts with the given string
+ */
+var stringStartsWith = function stringStartsWith(str, startsWith, ignoreCase) {
+  if (!str) {
+    return false;
+  }
+  var regEx = new RegExp("^" + startsWith, ignoreCase ? "i" : "");
+  return regEx.test(str);
+};
+var isInsecureContentRequest = exports.isInsecureContentRequest = function isInsecureContentRequest(url) {
+  var parser = document.createElement("a");
+  parser.href = url;
+
+  // for relative urls IE returns the protocol as empty string
+  if (parser.protocol === "") {
+    return false;
+  }
+
+  // If the inputted source is a base64 url, do not throw insecure content error
+  if (REGEX.DATA_URL.test(url)) {
+    return false;
+  }
+  if (stringStartsWith(location.href, "https://")) {
+    return parser.protocol !== "https:" && parser.protocol !== "wss:";
+  }
+  return false;
+};
+var Utils = exports.Utils = {
+  isInsecureContentRequest: isInsecureContentRequest
+};
+var isJQueryError = exports.isJQueryError = function isJQueryError(error) {
+  if (!error.stack) return false;
+  var UnSupportedFunctionality = ["jQuery", "$"];
+
+  // Get the first line of stack that points to your code
+  if (error.message && UnSupportedFunctionality.some(function (func) {
+    return error.message.includes(func);
+  })) {
+    return true;
+  }
+  var stackLines = error.stack.split("\n");
+  var _iterator = _createForOfIteratorHelper(stackLines),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      // Skip internal/node_modules lines, look for your code
+      if (!line.includes("node_modules") && !line.includes("internal")) {
+        // Check if this line contains jQuery access
+        if (line.toLowerCase().includes("jquery") || line.toLowerCase().includes("$")) {
+          return true;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return false;
+};
+
+/**
+ * Extracts query parameters from a URL using URLSearchParams
+ * @param link - URL string (e.g., "#/page?param1=value1&param2=value2")
+ * @returns Object with query parameters (automatically URL-decoded)
+ */
+var getUrlParams = exports.getUrlParams = function getUrlParams(link) {
+  var params = {};
+  var index = link.indexOf("?");
+  if (index !== -1) {
+    var queryString = link.substring(index + 1);
+    var searchParams = new URLSearchParams(queryString);
+    searchParams.forEach(function (value, key) {
+      params[key] = value;
+    });
+  }
+  return params;
+};
+
+/**
+ * Extracts route name from a link
+ * @param link - URL string (e.g., "#/page?param=value")
+ * @returns Route name (e.g., "/page")
+ */
+var getRouteNameFromLink = exports.getRouteNameFromLink = function getRouteNameFromLink(link) {
+  link = link.replace("#/", "/");
+  var index = link.indexOf("?");
+  if (index !== -1) {
+    link = link.substring(0, index);
+  }
+  return link;
+};
+
+/**
+ * Opens a link in browser window
+ * @param link - URL to open
+ * @param target - Target attribute (_blank, _self, etc.)
+ */
+var openLink = exports.openLink = function openLink(link) {
+  var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "_self";
+  window.open(link, target);
+};
+
+/**
+ * Triggers navigation action for menu item
+ * Mimics Angular WaveMaker behavior:
+ * 1. Executes item.action if present
+ * 2. Then navigates to item.link if present
+ */
+var triggerItemAction = exports.triggerItemAction = function triggerItemAction(item) {
+  var router = (0, _navigationMiddleware.getRouterInstance)();
+  var originalLink = item === null || item === void 0 ? void 0 : item.link;
+  var linkTarget = item === null || item === void 0 ? void 0 : item.target;
+  if (!originalLink || originalLink === "#" || originalLink === "javascript:void(0)") {
+    return; // No navigation needed
+  }
+
+  // Check if it's an internal navigation link (starts with # but not external)
+  if (originalLink.startsWith("#") && (!linkTarget || linkTarget === "_self")) {
+    // Internal navigation - handle both "#/page" and "#page" formats
+    var queryParams = getUrlParams(originalLink);
+    var routeName = getRouteNameFromLink(originalLink);
+    routeName = (0, _constants.hyperLinkMofify)(routeName);
+    if (Object.keys(queryParams).length > 0) {
+      var queryString = Object.entries(queryParams).map(function (_ref) {
+        var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+          key = _ref2[0],
+          value = _ref2[1];
+        return "".concat(key, "=").concat(encodeURIComponent(value));
+      }).join("&");
+      router === null || router === void 0 || router.push("".concat(routeName, "?").concat(queryString));
+    } else {
+      router === null || router === void 0 || router.push(routeName);
+    }
+  } else {
+    // External link or link with different target
+    // For external links, use as-is (don't apply hyperLinkMofify)
+    openLink(originalLink, linkTarget);
+  }
+};

package/core/widget-observer.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.widgetElementCallbacks = exports.findWidgetElement = void 0;
+// Global DOM observer for widget element tracking
+var globalObserver = null;
+var widgetElementCallbacks = exports.widgetElementCallbacks = new Map();
+
+// Initialize global observer once
+var initializeGlobalObserver = function initializeGlobalObserver() {
+  if (globalObserver || typeof window === "undefined") return;
+  globalObserver = new MutationObserver(function (mutations) {
+    mutations.forEach(function (mutation) {
+      // Handle added nodes
+      mutation.addedNodes.forEach(function (node) {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+          checkForWidgetElements(node);
+        }
+      });
+    });
+  });
+  globalObserver.observe(document.body, {
+    childList: true,
+    subtree: true
+  });
+};
+
+// Check if element matches any registered widgets
+var checkForWidgetElements = function checkForWidgetElements(element) {
+  var widgetId = element.getAttribute("data-widget-id");
+  var name = element.getAttribute("name");
+  if (name) {
+    var key = widgetId ? "".concat(name, ":").concat(widgetId) : name;
+    var callbacks = widgetElementCallbacks.get(key);
+    if (callbacks) {
+      callbacks.forEach(function (callback) {
+        return callback(element);
+      });
+    }
+  }
+
+  // Check descendants
+  var descendants = element.querySelectorAll("[data-widget-id], [name]");
+  descendants.forEach(function (desc) {
+    var descWidgetId = desc.getAttribute("data-widget-id");
+    var descName = desc.getAttribute("name");
+    if (descName) {
+      var _key = descWidgetId ? "".concat(descName, ":").concat(descWidgetId) : descName;
+      var _callbacks = widgetElementCallbacks.get(_key);
+      if (_callbacks) {
+        _callbacks.forEach(function (callback) {
+          return callback(desc);
+        });
+      }
+    }
+  });
+};
+
+// Helper function to find widget elements
+var findWidgetElement = exports.findWidgetElement = function findWidgetElement(widgetName, widgetId) {
+  // Strategy 1: Find by widget-id (most specific)
+  if (widgetId) {
+    var _element = document.querySelector("[data-widget-id=\"".concat(widgetId, "\"]"));
+    if (_element) return _element;
+  }
+
+  // Strategy 2: Find by name attribute
+  if (widgetName) {
+    var _element2 = document.querySelector("[name=\"".concat(widgetName, "\"]"));
+    if (_element2) return _element2;
+  }
+
+  // Strategy 3: Find by class name
+  if (widgetName) {
+    var _element3 = document.querySelector(".".concat(widgetName));
+    if (_element3) return _element3;
+  }
+
+  // Strategy 4: Find by id
+  if (widgetName) {
+    var _element4 = document.querySelector("#".concat(widgetName));
+    if (_element4) return _element4;
+  }
+  return null;
+};
+
+// Export the widget element callbacks map for use in proxy service
+
+// Auto-initialize observer
+if (typeof window !== "undefined") {
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", initializeGlobalObserver);
+  } else {
+    initializeGlobalObserver();
+  }
+}