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

package/core/security.service.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export interface SecurityOptions {
+}
+export interface SecurityService {
+    isLoggedIn: Boolean;
+    loggedInUser: any;
+    login: (options: SecurityOptions, success?: any, failure?: any) => any;
+    logout: (options: any, success?: any, failure?: any) => any;
+    navigateToLandingPage: (data: any) => any;
+}
+export declare const SecurityProvider: React.Provider<SecurityService>;
+export declare const SecurityConsumer: React.Consumer<SecurityService>;

package/core/security.service.js

@@ -0,0 +1,8 @@
+import React from "react";
+const SecurityContext = React.createContext(null);
+const SecurityProvider = SecurityContext.Provider;
+const SecurityConsumer = SecurityContext.Consumer;
+export {
+  SecurityConsumer,
+  SecurityProvider
+};

package/core/util/compare.d.ts

@@ -0,0 +1 @@
+export default function compare<T extends Record<string, unknown>>(prev: T | undefined | null, next: T | undefined | null): boolean;

package/core/util/compare.js

@@ -0,0 +1,24 @@
+import isEqual from "lodash-es/isEqual";
+function compare(prev, next) {
+  if (prev === next) {
+    return true;
+  }
+  if (!prev || !next) {
+    return false;
+  }
+  if (typeof prev !== "object" || typeof next !== "object") {
+    return isEqual(prev, next);
+  }
+  const keys = Object.keys(next);
+  return keys.every((key) => {
+    const prevValue = prev[key];
+    const nextValue = next[key];
+    if (!(key in prev) && nextValue !== void 0) {
+      return false;
+    }
+    return isEqual(prevValue, nextValue);
+  });
+}
+export {
+  compare as default
+};

package/core/util/dom.d.ts

@@ -0,0 +1,4 @@
+export declare const setCSS: (node: HTMLElement, cssName: string, val?: string | number, sync?: boolean) => void;
+export declare const isDOMElement: (obj: any) => boolean;
+export declare const wrapWithNativeDOM: (element: HTMLElement | null) => any;
+export declare const wrapWithJQuery: (element: HTMLElement | null) => any;

package/core/util/dom.js

@@ -0,0 +1,76 @@
+"use client";
+let $RAF;
+let $RAFQueue = [];
+if (typeof window !== "undefined") {
+  $RAF = window.requestAnimationFrame;
+} else {
+  $RAF = (callback) => setTimeout(callback, 0);
+}
+const invokeLater = (fn) => {
+  if (!$RAFQueue.length) {
+    $RAF(() => {
+      $RAFQueue.forEach((f) => f());
+      $RAFQueue.length = 0;
+    });
+  }
+  $RAFQueue.push(fn);
+};
+const setCSS = (node, cssName, val, sync) => {
+  if (typeof window === "undefined") return;
+  const task = () => node.style[cssName] = val;
+  sync ? task() : invokeLater(task);
+};
+const isDOMElement = (obj) => {
+  if (!obj || typeof obj !== "object") return false;
+  if (typeof window !== "undefined") {
+    return obj instanceof Element || obj instanceof Node || obj.nodeType && typeof obj.nodeName === "string";
+  }
+  return false;
+};
+const createEmptyWrapper = () => {
+  return {
+    0: null,
+    length: 0,
+    // Empty wrapper methods that do nothing (jQuery-like behavior)
+    find: () => createEmptyWrapper(),
+    attr: () => createEmptyWrapper(),
+    removeAttr: () => createEmptyWrapper(),
+    get: () => null
+  };
+};
+const wrapWithNativeDOM = (element) => {
+  if (!element || !isDOMElement(element)) {
+    return createEmptyWrapper();
+  }
+  const wrapper = {
+    // Array-like properties for jQuery compatibility
+    0: element,
+    length: 1,
+    // Essential jQuery methods using native DOM
+    find: (selector) => {
+      const found = element.querySelector(selector);
+      return found ? wrapWithNativeDOM(found) : createEmptyWrapper();
+    },
+    attr: (name, value) => {
+      if (value === void 0) {
+        return element.getAttribute(name);
+      }
+      element.setAttribute(name, value);
+      return wrapper;
+    },
+    removeAttr: (name) => {
+      element.removeAttribute(name);
+      return wrapper;
+    },
+    // Direct access to native element
+    get: () => element
+  };
+  return wrapper;
+};
+const wrapWithJQuery = wrapWithNativeDOM;
+export {
+  isDOMElement,
+  setCSS,
+  wrapWithJQuery,
+  wrapWithNativeDOM
+};

package/core/util/index.d.ts

@@ -0,0 +1,72 @@
+export declare const VALIDATOR: {
+    REQUIRED: string;
+    MAXCHARS: string;
+    MINVALUE: string;
+    MAXVALUE: string;
+    REGEXP: string;
+    MINDATE: string;
+    MAXDATE: string;
+    MINTIME: string;
+    MAXTIME: string;
+    EXCLUDEDATES: string;
+    EXCLUDEDAYS: string;
+};
+export declare const MATCH_MODES: {
+    STARTS_WITH_IGNORE_CASE: string;
+    STARTS_WITH: string;
+    ENDS_WITH_IGNORE_CASE: string;
+    ENDS_WITH: string;
+    CONTAINS: string;
+    CONTAINS_IGNORE_CASE: string;
+    IS_EQUAL_WITH_IGNORE_CASE: string;
+    IS_EQUAL: string;
+};
+/** Prism / app theme mode attribute values (parity with Angular `@wm/variables`). */
+export declare const MODE_CONSTANTS: {
+    LIGHT: string;
+    DEFAULT: string;
+};
+export declare const MONTHNAMES: string[];
+export declare const checkPublicAccess: (page?: string) => boolean;
+export declare const setSessionStorageItem: (key: string, value: string) => void;
+export declare const getSessionStorageItem: (key: string) => any;
+/**
+ * Safely reads selectedLocale from app-scoped sessionStorage.
+ * Storage format: sessionStorage[displayName] = JSON.stringify({ selectedLocale: "en" }).
+ * Returns undefined if store not ready, sessionStorage unavailable, or parse error.
+ */
+export declare const getSessionLocaleSafe: () => string | undefined;
+export declare const getTimezone: () => string;
+export declare const formatMessage: (fragment: any, expression: string) => any;
+/** Angular parity: same appLocale object, swap message keys in place so bindings stay valid. */
+export declare function syncLocaleMessages(target: Record<string, any> | undefined, messages: Record<string, any>): boolean;
+export declare function reload(): void;
+export declare const toNumber: (value: any) => number;
+export declare const _get: {
+    <TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
+    <TObject extends object, TKey extends keyof TObject>(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined;
+    <TObject extends object, TKey extends keyof TObject, TDefault>(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude<TObject[TKey], undefined> | TDefault;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable<TObject[TKey1]>[TKey2] | undefined;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude<NonNullable<TObject[TKey1]>[TKey2], undefined> | TDefault;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3] | undefined;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3], undefined> | TDefault;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TKey4 extends keyof NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4]): NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>[TKey4] | undefined;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TKey4 extends keyof NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4], defaultValue: TDefault): Exclude<NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>[TKey4], undefined> | TDefault;
+    <T>(object: import("lodash").NumericDictionary<T>, path: number): T;
+    <T>(object: import("lodash").NumericDictionary<T> | null | undefined, path: number): T | undefined;
+    <T, TDefault>(object: import("lodash").NumericDictionary<T> | null | undefined, path: number, defaultValue: TDefault): T | TDefault;
+    <TDefault>(object: null | undefined, path: import("lodash").PropertyPath, defaultValue: TDefault): TDefault;
+    (object: null | undefined, path: import("lodash").PropertyPath): undefined;
+    <TObject, TPath extends string>(data: TObject, path: TPath): string extends TPath ? any : import("lodash").GetFieldType<TObject, TPath>;
+    <TObject, TPath extends string, TDefault = import("lodash").GetFieldType<TObject, TPath, "Path">>(data: TObject, path: TPath, defaultValue: TDefault): Exclude<import("lodash").GetFieldType<TObject, TPath>, null | undefined> | TDefault;
+    (object: any, path: import("lodash").PropertyPath, defaultValue?: any): any;
+};
+export declare const deepCopy: (...objects: any) => any;
+export declare const getValidJSON: (content: any) => any;
+export declare const isDefined: (v: unknown) => boolean;
+export declare const toBoolean: (v: unknown) => boolean;
+export declare const replace: (template: string, map: Record<string, any>, parseError?: boolean) => string;
+export declare function getCurrentMonth(): string;

package/core/util/index.js

@@ -0,0 +1,222 @@
+import get from "lodash-es/get";
+import has from "lodash-es/has";
+import { store } from "../../store";
+import { isArray, isObject, isString } from "lodash-es";
+const VALIDATOR = {
+  REQUIRED: "required",
+  MAXCHARS: "maxchars",
+  MINVALUE: "minvalue",
+  MAXVALUE: "maxvalue",
+  REGEXP: "regexp",
+  MINDATE: "mindate",
+  MAXDATE: "maxdate",
+  MINTIME: "mintime",
+  MAXTIME: "maxtime",
+  EXCLUDEDATES: "excludedates",
+  EXCLUDEDAYS: "excludedays"
+};
+const 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"
+};
+const MODE_CONSTANTS = {
+  LIGHT: "light",
+  DEFAULT: "default"
+};
+const MONTHNAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+const checkPublicAccess = (page) => {
+  var _a, _b, _c, _d;
+  const pageName = page || ((_a = window.location.pathname) == null ? void 0 : _a.split("/").at(-1));
+  if (!pageName) return false;
+  return ((_d = (_c = (_b = store.getState().info.appConfig) == null ? void 0 : _b.pages) == null ? void 0 : _c.find((p) => p.name === pageName)) == null ? void 0 : _d.permission) === "PermitAll";
+};
+const setSessionStorageItem = (key, value) => {
+  const id = store.getState().info.appConfig.appProperties.displayName;
+  let item = window.sessionStorage.getItem(id);
+  if (item) {
+    item = JSON.parse(item);
+  } else {
+    item = {};
+  }
+  item[key] = value;
+  window.sessionStorage.setItem(id, JSON.stringify(item));
+};
+const getSessionStorageItem = (key) => {
+  const id = store.getState().info.appConfig.appProperties.displayName;
+  let item = window && window.sessionStorage && window.sessionStorage.getItem(id);
+  if (item) {
+    item = JSON.parse(item);
+    return item[key];
+  }
+};
+const getSessionLocaleSafe = () => {
+  var _a, _b, _c, _d;
+  try {
+    if (typeof window === "undefined") return "en";
+    const displayName = (_c = (_b = (_a = store.getState().info) == null ? void 0 : _a.appConfig) == null ? void 0 : _b.appProperties) == null ? void 0 : _c.displayName;
+    if (!displayName) return void 0;
+    const raw = (_d = window.sessionStorage) == null ? void 0 : _d.getItem(displayName);
+    if (!raw) return void 0;
+    const parsed = JSON.parse(raw);
+    return parsed == null ? void 0 : parsed.selectedLocale;
+  } catch (e) {
+    return void 0;
+  }
+};
+const getTimezone = () => {
+  const timezone = store.getState().i18n.timezone;
+  if (typeof timezone === "object" && timezone !== null && "timezone" in timezone) {
+    return timezone["timezone"];
+  }
+  return timezone || "UTC";
+};
+const formatMessage = (fragment, expression) => {
+  const path = `appLocale.${expression}`;
+  return has(fragment, path) ? get(fragment, path) : void 0;
+};
+function syncLocaleMessages(target, messages) {
+  if (!target || typeof target !== "object") {
+    return false;
+  }
+  let synced = true;
+  Object.keys(target).forEach((key) => {
+    if (!(key in messages)) {
+      try {
+        delete target[key];
+      } catch (e) {
+        synced = false;
+      }
+    }
+  });
+  Object.keys(messages).forEach((key) => {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(target, key);
+      if (descriptor && !descriptor.configurable && !descriptor.writable) {
+        synced = false;
+        return;
+      }
+      target[key] = messages[key];
+    } catch (e) {
+      synced = false;
+    }
+  });
+  return synced;
+}
+function reload() {
+  window.location.reload();
+}
+const toNumber = (value) => {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return Number(value);
+};
+const _get = get;
+const isDeepCopyByReference = (v) => {
+  if (!v || typeof v !== "object") {
+    return false;
+  }
+  if (typeof Blob !== "undefined" && v instanceof Blob) {
+    return true;
+  }
+  if (v instanceof ArrayBuffer) {
+    return true;
+  }
+  if (ArrayBuffer.isView(v)) {
+    return true;
+  }
+  if (typeof FormData !== "undefined" && v instanceof FormData) {
+    return true;
+  }
+  return false;
+};
+const _deepCopy = (o1, ...o2) => {
+  o2.forEach((o) => {
+    if (o) {
+      Object.keys(o).forEach((k) => {
+        const v = o[k];
+        if (v && !isString(v) && !isArray(v) && typeof v === "object") {
+          if (isDeepCopyByReference(v)) {
+            o1[k] = v;
+          } else {
+            o1[k] = _deepCopy(o1[k] || {}, o[k]);
+          }
+        } else {
+          o1[k] = _deepCopy(v);
+        }
+      });
+    }
+  });
+  return o1;
+};
+const deepCopy = (...objects) => _deepCopy({}, ...objects);
+const getValidJSON = (content) => {
+  if (!content) {
+    return void 0;
+  }
+  try {
+    const parsedIntValue = parseInt(content, 10);
+    return isObject(content) || !isNaN(parsedIntValue) ? content : JSON.parse(content);
+  } catch (e) {
+    return void 0;
+  }
+};
+const isDefined = (v) => typeof v !== "undefined";
+const toBoolean = (v) => v === true || v === "true";
+const replace = (template, map, parseError) => {
+  let regEx = /\$\{([^\}]+)\}/g;
+  if (!template) {
+    return;
+  }
+  if (parseError) {
+    regEx = /\{([^\}]+)\}/g;
+  }
+  return template.replace(regEx, function(match, key) {
+    return get(map, key);
+  });
+};
+function getCurrentMonth() {
+  const currentDate = /* @__PURE__ */ new Date();
+  return MONTHNAMES[currentDate.getMonth()];
+}
+export {
+  MATCH_MODES,
+  MODE_CONSTANTS,
+  MONTHNAMES,
+  VALIDATOR,
+  _get,
+  checkPublicAccess,
+  deepCopy,
+  formatMessage,
+  getCurrentMonth,
+  getSessionLocaleSafe,
+  getSessionStorageItem,
+  getTimezone,
+  getValidJSON,
+  isDefined,
+  reload,
+  replace,
+  setSessionStorageItem,
+  syncLocaleMessages,
+  toBoolean,
+  toNumber
+};

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

@@ -0,0 +1,104 @@
+const isObjectLike = (value) => typeof value === "object" && value !== null;
+const getComparableKeys = (value, ignored) => Object.keys(value).filter((key) => !ignored.has(key));
+const safeIsEqual = (value1, value2, depth = 5, ignoreKeys = ["listener"]) => {
+  const ignoredKeys = new Set(ignoreKeys);
+  const visited = /* @__PURE__ */ new WeakMap();
+  const hasVisitedPair = (a, b) => {
+    var _a, _b;
+    return !!((_a = visited.get(a)) == null ? void 0 : _a.get(b)) || !!((_b = visited.get(b)) == null ? void 0 : _b.get(a));
+  };
+  const markVisitedPair = (a, b) => {
+    if (!visited.has(a)) {
+      visited.set(a, /* @__PURE__ */ new WeakMap());
+    }
+    if (!visited.has(b)) {
+      visited.set(b, /* @__PURE__ */ new WeakMap());
+    }
+    visited.get(a).set(b, true);
+    visited.get(b).set(a, true);
+  };
+  const 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);
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+    if (aIsArray || bIsArray) {
+      if (!(aIsArray && bIsArray)) {
+        return false;
+      }
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let 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;
+      }
+      for (const [key, val] of a.entries()) {
+        if (!b.has(key)) {
+          return false;
+        }
+        if (!compare(val, b.get(key), currentDepth - 1)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const val of a.values()) {
+        if (![...b].some((item) => compare(val, item, currentDepth - 1))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const keysA = getComparableKeys(a, ignoredKeys);
+    const keysB = getComparableKeys(b, ignoredKeys);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) {
+        return false;
+      }
+      if (!compare(
+        a[key],
+        b[key],
+        currentDepth - 1
+      )) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return compare(value1, value2, Math.max(0, depth));
+};
+export {
+  safeIsEqual
+};

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;