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

package/core/util/safe-is-equal.js

@@ -0,0 +1,156 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.safeIsEqual = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+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 isObjectLike = function isObjectLike(value) {
+  return (0, _typeof2["default"])(value) === "object" && value !== null;
+};
+var getComparableKeys = function getComparableKeys(value, ignored) {
+  return Object.keys(value).filter(function (key) {
+    return !ignored.has(key);
+  });
+};
+var safeIsEqual = exports.safeIsEqual = function safeIsEqual(value1, value2) {
+  var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;
+  var ignoreKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ["listener"];
+  var ignoredKeys = new Set(ignoreKeys);
+  var visited = new WeakMap();
+  var hasVisitedPair = function hasVisitedPair(a, b) {
+    var _visited$get, _visited$get2;
+    return !!((_visited$get = visited.get(a)) !== null && _visited$get !== void 0 && _visited$get.get(b)) || !!((_visited$get2 = visited.get(b)) !== null && _visited$get2 !== void 0 && _visited$get2.get(a));
+  };
+  var markVisitedPair = function markVisitedPair(a, b) {
+    if (!visited.has(a)) {
+      visited.set(a, new WeakMap());
+    }
+    if (!visited.has(b)) {
+      visited.set(b, new WeakMap());
+    }
+    visited.get(a).set(b, true);
+    visited.get(b).set(a, true);
+  };
+  var _compare = function compare(a, b, currentDepth) {
+    if (Object.is(a, b)) {
+      return true;
+    }
+    if (currentDepth <= 0) {
+      return false;
+    }
+    if (!isObjectLike(a) || !isObjectLike(b)) {
+      return false;
+    }
+    if (hasVisitedPair(a, b)) {
+      return true;
+    }
+    markVisitedPair(a, b);
+    var aIsArray = Array.isArray(a);
+    var bIsArray = Array.isArray(b);
+    if (aIsArray || bIsArray) {
+      if (!(aIsArray && bIsArray)) {
+        return false;
+      }
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (var i = 0; i < a.length; i += 1) {
+        if (!_compare(a[i], b[i], currentDepth - 1)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() === b.getTime();
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      var _iterator = _createForOfIteratorHelper(a.entries()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = (0, _slicedToArray2["default"])(_step.value, 2),
+            key = _step$value[0],
+            val = _step$value[1];
+          if (!b.has(key)) {
+            return false;
+          }
+          if (!_compare(val, b.get(key), currentDepth - 1)) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      var _iterator2 = _createForOfIteratorHelper(a.values()),
+        _step2;
+      try {
+        var _loop = function _loop() {
+            var val = _step2.value;
+            if (!(0, _toConsumableArray2["default"])(b).some(function (item) {
+              return _compare(val, item, currentDepth - 1);
+            })) {
+              return {
+                v: false
+              };
+            }
+          },
+          _ret;
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          _ret = _loop();
+          if (_ret) return _ret.v;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return true;
+    }
+    var keysA = getComparableKeys(a, ignoredKeys);
+    var keysB = getComparableKeys(b, ignoredKeys);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    var _iterator3 = _createForOfIteratorHelper(keysA),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _key = _step3.value;
+        if (!Object.prototype.hasOwnProperty.call(b, _key)) {
+          return false;
+        }
+        if (!_compare(a[_key], b[_key], currentDepth - 1)) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    return true;
+  };
+  return _compare(value1, value2, Math.max(0, depth));
+};

package/core/util/security.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Security context types that can be trusted
+ */
+export declare enum SecurityContext {
+    HTML = "HTML",
+    STYLE = "STYLE",
+    SCRIPT = "SCRIPT",
+    URL = "URL",
+    RESOURCE_URL = "RESOURCE_URL"
+}
+export type SafeHtml = string & {
+    __safeHtml: never;
+};
+export type SafeStyle = string & {
+    __safeStyle: never;
+};
+export type SafeScript = string & {
+    __safeScript: never;
+};
+export type SafeUrl = string & {
+    __safeUrl: never;
+};
+export type SafeResourceUrl = string & {
+    __safeResourceUrl: never;
+};
+/**
+ * Security service for sanitizing and trusting content
+ */
+export declare class SecurityService {
+    private static instance;
+    private constructor();
+    static getInstance(): SecurityService;
+    /**
+     * Sanitize HTML content
+     */
+    sanitizeHtml(content: string): SafeHtml;
+    /**
+     * Sanitize style content
+     */
+    sanitizeStyle(content: string): SafeStyle;
+    /**
+     * Sanitize script content
+     */
+    sanitizeScript(content: string): SafeScript;
+    /**
+     * Sanitize URL
+     */
+    sanitizeUrl(content: string): SafeUrl;
+    /**
+     * Sanitize Resource URL
+     */
+    sanitizeResourceUrl(content: string): SafeResourceUrl;
+    /**
+     * Trust content based on security context
+     */
+    trustAs(content: string, context: SecurityContext): string;
+}
+export declare const useTrustAs: (content: string, context: SecurityContext) => string;
+export declare const useSafeHtml: (content: string) => SafeHtml;
+export declare const useSafeStyle: (content: string) => SafeStyle;
+export declare const useSafeUrl: (content: string) => SafeUrl;
+export declare const useSafeResourceUrl: (content: string) => SafeResourceUrl;
+export declare const isInsecureContentRequest: (url: string) => boolean;
+export declare const securityService: SecurityService;

package/core/util/security.js

@@ -0,0 +1,183 @@
+"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
+  return (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;
+    }
+  }]);
+}(); // 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.d.ts

@@ -0,0 +1,34 @@
+export declare const isInsecureContentRequest: (url: string) => boolean;
+export declare const Utils: {
+    isInsecureContentRequest: (url: string) => boolean;
+};
+export declare const isJQueryError: (error: any) => boolean;
+/**
+ * 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)
+ */
+export declare const getUrlParams: (link: string) => Record<string, string>;
+/**
+ * Extracts route name from a link
+ * @param link - URL string (e.g., "#/page?param=value")
+ * @returns Route name (e.g., "/page")
+ */
+export declare const getRouteNameFromLink: (link: string) => string;
+/**
+ * Opens a link in browser window
+ * @param link - URL to open
+ * @param target - Target attribute (_blank, _self, etc.)
+ */
+export declare const openLink: (link: string, target?: string) => void;
+/**
+ * Triggers navigation action for menu item
+ * Mimics Angular WaveMaker behavior:
+ * 1. Executes item.action if present
+ * 2. Then navigates to item.link if present
+ */
+export declare const triggerItemAction: (item: any) => void;
+export declare const getCurrentPath: () => string;
+export declare const getItemLink: (item: any, props: any) => string | undefined;
+export declare function hasOwnObjectProperty(obj: any, prop: string): any;
+export declare const mergeProxies: (firstProxy: any, secondProxy: any) => any;

package/core/util/utils.js

@@ -0,0 +1,228 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUrlParams = exports.getRouteNameFromLink = exports.getItemLink = exports.getCurrentPath = exports.Utils = void 0;
+exports.hasOwnObjectProperty = hasOwnObjectProperty;
+exports.triggerItemAction = exports.openLink = exports.mergeProxies = exports.isJQueryError = exports.isInsecureContentRequest = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _navigationMiddleware = require("@wavemaker-ai/react-runtime/store/middleware/navigationMiddleware");
+var _constants = require("../constants");
+var _navigation = require("next/navigation");
+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 (typeof originalLink === "function" || !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 !== null && originalLink !== void 0 && 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) {
+      // Filter out undefined/null/empty values like Angular router does
+      var queryString = Object.entries(queryParams).filter(function (_ref) {
+        var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+          _ = _ref2[0],
+          value = _ref2[1];
+        return value !== undefined && value !== null && value !== "";
+      }).map(function (_ref3) {
+        var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+          key = _ref4[0],
+          value = _ref4[1];
+        return "".concat(key, "=").concat(encodeURIComponent(value));
+      }).join("&");
+      if (queryString) {
+        router === null || router === void 0 || router.push("".concat(routeName, "?").concat(queryString));
+      } else {
+        router === null || router === void 0 || router.push(routeName);
+      }
+    } else {
+      router === null || router === void 0 || router.push(routeName);
+    }
+  } else if (linkTarget || originalLink) {
+    // External link or link with different target
+    // For external links, use as-is (don't apply hyperLinkMofify)
+    openLink(originalLink, linkTarget || "");
+  }
+};
+var getCurrentPath = exports.getCurrentPath = function getCurrentPath() {
+  var path = (0, _navigation.usePathname)();
+  return path;
+};
+var getItemLink = exports.getItemLink = function getItemLink(item, props) {
+  var linkProperty = props.itemlink || "link";
+  if (typeof item[linkProperty] === "function") {
+    return item[linkProperty]();
+  } else {
+    return item[linkProperty];
+  }
+};
+function hasOwnObjectProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+var mergeProxies = exports.mergeProxies = function mergeProxies(firstProxy, secondProxy) {
+  return new Proxy(firstProxy, {
+    get: function get(target, key) {
+      return key in target ? target[key] : secondProxy[key];
+    },
+    set: function set(target, key, value) {
+      target[key] = value; // delegates back to pageProxy.widgets
+      return true;
+    }
+  });
+};

package/core/widget-observer.d.ts

@@ -0,0 +1,3 @@
+declare const widgetElementCallbacks: Map<string, Set<(element: HTMLElement | null) => void>>;
+export declare const findWidgetElement: (widgetName: string, widgetId?: string) => HTMLElement | null;
+export { widgetElementCallbacks };