@wavemaker-ai/react-runtime 1.0.0-next.27766

package/core/util/security.js

@@ -0,0 +1,144 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import DOMPurify from "dompurify";
+import startsWith from "lodash-es/startsWith";
+var SecurityContext = /* @__PURE__ */ ((SecurityContext2) => {
+  SecurityContext2["HTML"] = "HTML";
+  SecurityContext2["STYLE"] = "STYLE";
+  SecurityContext2["SCRIPT"] = "SCRIPT";
+  SecurityContext2["URL"] = "URL";
+  SecurityContext2["RESOURCE_URL"] = "RESOURCE_URL";
+  return SecurityContext2;
+})(SecurityContext || {});
+const _SecurityService = class _SecurityService {
+  constructor() {
+  }
+  static getInstance() {
+    if (!_SecurityService.instance) {
+      _SecurityService.instance = new _SecurityService();
+    }
+    return _SecurityService.instance;
+  }
+  /**
+   * Sanitize HTML content
+   */
+  sanitizeHtml(content) {
+    if (!content) return "";
+    return DOMPurify.sanitize(content, {
+      USE_PROFILES: { html: true }
+    });
+  }
+  /**
+   * Sanitize style content
+   */
+  sanitizeStyle(content) {
+    if (!content) return "";
+    return DOMPurify.sanitize(content, {
+      USE_PROFILES: { html: true },
+      ALLOWED_TAGS: ["style"],
+      ALLOWED_ATTR: ["type"]
+    });
+  }
+  /**
+   * Sanitize script content
+   */
+  sanitizeScript(content) {
+    if (!content) return "";
+    return content;
+  }
+  /**
+   * Sanitize URL
+   */
+  sanitizeUrl(content) {
+    if (!content) return "";
+    const url = content.trim().toLowerCase();
+    if (url.startsWith("javascript:") || url.startsWith("data:") || url.startsWith("vbscript:")) {
+      return "";
+    }
+    return content;
+  }
+  /**
+   * Sanitize Resource URL
+   */
+  sanitizeResourceUrl(content) {
+    if (!content) return "";
+    const sanitizedUrl = this.sanitizeUrl(content);
+    return sanitizedUrl ? String(sanitizedUrl) : "";
+  }
+  /**
+   * Trust content based on security context
+   */
+  trustAs(content, context) {
+    if (!content) return "";
+    switch (context) {
+      case "HTML" /* HTML */:
+        return this.sanitizeHtml(content);
+      case "STYLE" /* STYLE */:
+        return this.sanitizeStyle(content);
+      case "SCRIPT" /* SCRIPT */:
+        return this.sanitizeScript(content);
+      case "URL" /* URL */:
+        return this.sanitizeUrl(content);
+      case "RESOURCE_URL" /* RESOURCE_URL */:
+        return this.sanitizeResourceUrl(content);
+      default:
+        return "";
+    }
+  }
+};
+__publicField(_SecurityService, "instance");
+let SecurityService = _SecurityService;
+import { useMemo } from "react";
+const useTrustAs = (content, context) => {
+  return useMemo(() => {
+    return SecurityService.getInstance().trustAs(content, context);
+  }, [content, context]);
+};
+const useSafeHtml = (content) => {
+  return useMemo(() => {
+    return SecurityService.getInstance().sanitizeHtml(content);
+  }, [content]);
+};
+const useSafeStyle = (content) => {
+  return useMemo(() => {
+    return SecurityService.getInstance().sanitizeStyle(content);
+  }, [content]);
+};
+const useSafeUrl = (content) => {
+  return useMemo(() => {
+    return SecurityService.getInstance().sanitizeUrl(content);
+  }, [content]);
+};
+const useSafeResourceUrl = (content) => {
+  return useMemo(() => {
+    return SecurityService.getInstance().sanitizeResourceUrl(content);
+  }, [content]);
+};
+const isInsecureContentRequest = (url) => {
+  const REGEX_DATA_URL = /^\s*data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*)\s*$/i;
+  const parser = document.createElement("a");
+  parser.href = url;
+  if (parser.protocol === "") {
+    return false;
+  }
+  if (REGEX_DATA_URL.test(url)) {
+    return false;
+  }
+  if (startsWith(location.href, "https://")) {
+    return parser.protocol !== "https:" && parser.protocol !== "wss:";
+  }
+  return false;
+};
+const securityService = SecurityService.getInstance();
+export {
+  SecurityContext,
+  SecurityService,
+  isInsecureContentRequest,
+  securityService,
+  useSafeHtml,
+  useSafeResourceUrl,
+  useSafeStyle,
+  useSafeUrl,
+  useTrustAs
+};

package/core/util/utils.d.ts

@@ -0,0 +1,41 @@
+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;
+/**
+ * Target page from a WaveMaker goToPage_* onClick handler (source or preview _optionalChain bundle).
+ */
+export declare function getGoToPageNameFromClickHandler(onClick: unknown): string | null;
+/**
+ * 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 getModesFromLocalStorage: () => Record<string, string>;
+export declare function setMode(modes: Record<string, string>, shouldPersist?: boolean): void;
+export declare function initAppModes(): void;
+export declare function teardownAppModes(): void;

package/core/util/utils.js

@@ -0,0 +1,220 @@
+import { getRouterInstance } from "../../store/middleware/navigationMiddleware";
+import { hyperLinkMofify } from "../constants";
+import { usePathname } from "next/navigation";
+import isObject from "lodash-es/isObject";
+import { MODE_CONSTANTS } from "./index";
+const 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)$/
+};
+const stringStartsWith = (str, startsWith, ignoreCase) => {
+  if (!str) {
+    return false;
+  }
+  const regEx = new RegExp("^" + startsWith, ignoreCase ? "i" : "");
+  return regEx.test(str);
+};
+const isInsecureContentRequest = (url) => {
+  const parser = document.createElement("a");
+  parser.href = url;
+  if (parser.protocol === "") {
+    return false;
+  }
+  if (REGEX.DATA_URL.test(url)) {
+    return false;
+  }
+  if (stringStartsWith(location.href, "https://")) {
+    return parser.protocol !== "https:" && parser.protocol !== "wss:";
+  }
+  return false;
+};
+const Utils = {
+  isInsecureContentRequest
+};
+const isJQueryError = (error) => {
+  if (!error.stack) return false;
+  const UnSupportedFunctionality = ["jQuery", "$"];
+  if (error.message && UnSupportedFunctionality.some((func) => error.message.includes(func))) {
+    return true;
+  }
+  const stackLines = error.stack.split("\n");
+  for (let line of stackLines) {
+    if (!line.includes("node_modules") && !line.includes("internal")) {
+      if (line.toLowerCase().includes("jquery") || line.toLowerCase().includes("$")) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const getUrlParams = (link) => {
+  const params = {};
+  const index = link.indexOf("?");
+  if (index !== -1) {
+    const queryString = link.substring(index + 1);
+    const searchParams = new URLSearchParams(queryString);
+    searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+  }
+  return params;
+};
+const getRouteNameFromLink = (link) => {
+  link = link.replace("#/", "/");
+  const index = link.indexOf("?");
+  if (index !== -1) {
+    link = link.substring(0, index);
+  }
+  return link;
+};
+function getGoToPageNameFromClickHandler(onClick) {
+  var _a;
+  if (typeof onClick !== "function") {
+    return null;
+  }
+  const fnStr = onClick.toString();
+  if (!/invoke/.test(fnStr)) {
+    return null;
+  }
+  const match = /goToPage_([A-Za-z0-9_]+)/.exec(fnStr);
+  return (_a = match == null ? void 0 : match[1]) != null ? _a : null;
+}
+const openLink = (link, target = "_self") => {
+  window.open(link, target);
+};
+const triggerItemAction = (item) => {
+  const router = getRouterInstance();
+  let originalLink = item == null ? void 0 : item.link;
+  const linkTarget = item == null ? void 0 : item.target;
+  if (typeof originalLink === "function" || !originalLink || originalLink === "#" || originalLink === "javascript:void(0)") {
+    return;
+  }
+  if ((originalLink == null ? void 0 : originalLink.startsWith("#")) && (!linkTarget || linkTarget === "_self")) {
+    const queryParams = getUrlParams(originalLink);
+    let routeName = getRouteNameFromLink(originalLink);
+    routeName = hyperLinkMofify(routeName);
+    if (Object.keys(queryParams).length > 0) {
+      const queryString = Object.entries(queryParams).filter(([_, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+      if (queryString) {
+        router == null ? void 0 : router.push(`${routeName}?${queryString}`);
+      } else {
+        router == null ? void 0 : router.push(routeName);
+      }
+    } else {
+      router == null ? void 0 : router.push(routeName);
+    }
+  } else if (linkTarget || originalLink) {
+    openLink(originalLink, linkTarget || "");
+  }
+};
+const getCurrentPath = () => {
+  const path = usePathname();
+  return path;
+};
+const getItemLink = (item, props) => {
+  const 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);
+}
+const getModesFromLocalStorage = () => {
+  let storedValue = localStorage.getItem("wm-app-modes") || "{}";
+  try {
+    storedValue = JSON.parse(storedValue);
+  } catch (error) {
+    console.error("Error parsing modes", error == null ? void 0 : error.message);
+    storedValue = {};
+  }
+  return isObject(storedValue) ? storedValue : {};
+};
+function setMode(modes, shouldPersist = false) {
+  const htmlEl = document.getElementsByTagName("html")[0];
+  if (!htmlEl) return;
+  if (!isObject(modes)) {
+    modes = {};
+  }
+  const modesArr = Object.entries(modes);
+  if (!modesArr.length) return;
+  modesArr.forEach(([modeKey, modeValue]) => {
+    const isDefault = modeValue === MODE_CONSTANTS.LIGHT || modeValue === MODE_CONSTANTS.DEFAULT;
+    if (isDefault) {
+      htmlEl.removeAttribute(modeKey);
+    } else {
+      htmlEl.setAttribute(modeKey, modeValue);
+    }
+  });
+  if (shouldPersist) {
+    localStorage.setItem("wm-app-modes", JSON.stringify(modes));
+  }
+}
+let windowMessageListener = null;
+function initAppModes() {
+  setMode(getModesFromLocalStorage());
+  if (windowMessageListener) {
+    window.removeEventListener("message", windowMessageListener);
+  }
+  windowMessageListener = (event) => {
+    const { key, modes, shouldPersist } = event.data || {};
+    if (key === "switch-mode" && modes) {
+      setMode(modes, !shouldPersist);
+    }
+  };
+  window.addEventListener("message", windowMessageListener);
+}
+function teardownAppModes() {
+  if (windowMessageListener) {
+    window.removeEventListener("message", windowMessageListener);
+    windowMessageListener = null;
+  }
+}
+export {
+  Utils,
+  getCurrentPath,
+  getGoToPageNameFromClickHandler,
+  getItemLink,
+  getModesFromLocalStorage,
+  getRouteNameFromLink,
+  getUrlParams,
+  hasOwnObjectProperty,
+  initAppModes,
+  isInsecureContentRequest,
+  isJQueryError,
+  openLink,
+  setMode,
+  teardownAppModes,
+  triggerItemAction
+};

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 };

package/core/widget-observer.js

@@ -0,0 +1,71 @@
+let globalObserver = null;
+const widgetElementCallbacks = /* @__PURE__ */ new Map();
+const initializeGlobalObserver = () => {
+  if (globalObserver || typeof window === "undefined") return;
+  globalObserver = new MutationObserver((mutations) => {
+    mutations.forEach((mutation) => {
+      mutation.addedNodes.forEach((node) => {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+          checkForWidgetElements(node);
+        }
+      });
+    });
+  });
+  globalObserver.observe(document.body, {
+    childList: true,
+    subtree: true
+  });
+};
+const checkForWidgetElements = (element) => {
+  const widgetId = element.getAttribute("data-widget-id");
+  const name = element.getAttribute("name");
+  if (name) {
+    const key = widgetId ? `${name}:${widgetId}` : name;
+    const callbacks = widgetElementCallbacks.get(key);
+    if (callbacks) {
+      callbacks.forEach((callback) => callback(element));
+    }
+  }
+  const descendants = element.querySelectorAll("[data-widget-id], [name]");
+  descendants.forEach((desc) => {
+    const descWidgetId = desc.getAttribute("data-widget-id");
+    const descName = desc.getAttribute("name");
+    if (descName) {
+      const key = descWidgetId ? `${descName}:${descWidgetId}` : descName;
+      const callbacks = widgetElementCallbacks.get(key);
+      if (callbacks) {
+        callbacks.forEach((callback) => callback(desc));
+      }
+    }
+  });
+};
+const findWidgetElement = (widgetName, widgetId) => {
+  if (widgetId) {
+    const element = document.querySelector(`[data-widget-id="${widgetId}"]`);
+    if (element) return element;
+  }
+  if (widgetName) {
+    const element = document.querySelector(`[name="${widgetName}"]`);
+    if (element) return element;
+  }
+  if (widgetName) {
+    const element = document.querySelector(`.${widgetName}`);
+    if (element) return element;
+  }
+  if (widgetName) {
+    const element = document.querySelector(`#${widgetName}`);
+    if (element) return element;
+  }
+  return null;
+};
+if (typeof window !== "undefined") {
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", initializeGlobalObserver);
+  } else {
+    initializeGlobalObserver();
+  }
+}
+export {
+  findWidgetElement,
+  widgetElementCallbacks
+};

package/higherOrder/BaseApp.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { ProxyTarget } from "@/types";
+declare global {
+    var wm: ProxyTarget;
+}
+export declare const BaseApp: <P extends object>(WrappedComponent: React.ComponentType<P>, addAppScript: (app: any) => void, getAppVariables: (appProxy: any) => {
+    Variables: Record<string, any>;
+    Actions: Record<string, any>;
+}, appInfo?: any) => {
+    (props: P): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default BaseApp;