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

package/core/formatter/number-formatters.d.ts

@@ -0,0 +1,20 @@
+import { Formatter } from "./types";
+export declare class NumberToStringFormatter implements Formatter {
+    format(input: number, fractionSize: number | string): string;
+}
+export declare class CurrencyFormatter implements Formatter {
+    /**
+     * `(amount, currencyCode, display, digitsInfo)`
+     * where `display` is `symbol` | `code` | `symbol-narrow` | `name`.
+     */
+    format(data: number, currencySymbol: string, displayOrFraction?: string | number, digitsInfo?: string | number): string;
+}
+export declare class StringToNumberFormatter implements Formatter {
+    format(input: string): number;
+}
+export declare class ToNumberFormatter implements Formatter {
+    format(data: any, fracSize?: string | number): string;
+}
+export declare class TrailingZeroDecimalFormatter implements Formatter {
+    format(value: number, selectedLocale?: string, numberFilter?: string, localeFilter?: any, trailingZero?: boolean, decimalValue?: string, skipTrailingZeroCheck?: boolean, formattedLocale?: any): string;
+}

package/core/formatter/number-formatters.js

@@ -0,0 +1,137 @@
+import parseInt from "lodash-es/parseInt";
+import CURRENCY_INFO from "../constants/currency-constant";
+import appstore from "../appstore";
+function getIntlFractionDigitOptions(fractionSize) {
+  if (typeof fractionSize === "string" && fractionSize.includes(".")) {
+    const parts = fractionSize.split(".");
+    if (parts[1]) {
+      const fractionParts = parts[1].split("-");
+      let minimumFractionDigits = Math.min(
+        20,
+        Math.max(0, Number.parseInt(fractionParts[0], 10) || 0)
+      );
+      let maximumFractionDigits = Math.min(
+        20,
+        Math.max(
+          minimumFractionDigits,
+          Number.parseInt(fractionParts[1], 10) || minimumFractionDigits
+        )
+      );
+      return { minimumFractionDigits, maximumFractionDigits };
+    }
+  }
+  let n = typeof fractionSize === "number" && Number.isFinite(fractionSize) ? Math.trunc(fractionSize) : Number.parseInt(String(fractionSize).trim(), 10);
+  if (!Number.isFinite(n)) {
+    n = 0;
+  }
+  n = Math.min(20, Math.max(0, n));
+  return { minimumFractionDigits: n, maximumFractionDigits: n };
+}
+const CURRENCY_DISPLAY_MODES = /* @__PURE__ */ new Set(["code", "symbol", "symbol-narrow", "name"]);
+class NumberToStringFormatter {
+  format(input, fractionSize) {
+    const i18nService = appstore.I18nService.get();
+    const selectedLocale = i18nService.getSelectedLocale();
+    const { minimumFractionDigits, maximumFractionDigits } = getIntlFractionDigitOptions(fractionSize);
+    let formatCurrency = new Intl.NumberFormat(selectedLocale, {
+      minimumFractionDigits,
+      maximumFractionDigits
+    });
+    return isNaN(input) ? "" : formatCurrency.format(input);
+  }
+}
+class CurrencyFormatter {
+  /**
+   * `(amount, currencyCode, display, digitsInfo)`
+   * where `display` is `symbol` | `code` | `symbol-narrow` | `name`.
+   */
+  format(data, currencySymbol, displayOrFraction, digitsInfo) {
+    let fractionArg = 0;
+    if (displayOrFraction !== void 0 && displayOrFraction !== null && displayOrFraction !== "" && CURRENCY_DISPLAY_MODES.has(String(displayOrFraction))) {
+      fractionArg = digitsInfo !== void 0 && digitsInfo !== null && digitsInfo !== "" ? digitsInfo : 0;
+    } else if (displayOrFraction !== void 0 && displayOrFraction !== null && displayOrFraction !== "") {
+      fractionArg = displayOrFraction;
+    }
+    const _currencySymbol = (CURRENCY_INFO[currencySymbol] || {}).symbol || currencySymbol || "";
+    let _val = new NumberToStringFormatter().format(data || 0, fractionArg);
+    const isNegativeNumber = _val.startsWith("-");
+    if (isNegativeNumber) {
+      _val = _val.replace("-", "");
+    }
+    return _val ? isNegativeNumber ? "-" + _currencySymbol + _val : _currencySymbol + _val : "";
+  }
+}
+class StringToNumberFormatter {
+  format(input) {
+    return parseInt(input);
+  }
+}
+class ToNumberFormatter {
+  format(data, fracSize) {
+    if (isNaN(+data)) {
+      return "";
+    }
+    let fractionFormat = fracSize;
+    if (fracSize && !String(fracSize).match(/^(\d+)?\.((\d+)(-(\d+))?)?$/)) {
+      fractionFormat = "1." + fracSize + "-" + fracSize;
+    }
+    try {
+      let minimumFractionDigits = 0;
+      let maximumFractionDigits = 3;
+      if (typeof fractionFormat === "string" && fractionFormat.includes(".")) {
+        const parts = fractionFormat.split(".");
+        if (parts[1]) {
+          const fractionParts = parts[1].split("-");
+          minimumFractionDigits = parseInt(fractionParts[0]) || 0;
+          maximumFractionDigits = parseInt(fractionParts[1]) || minimumFractionDigits;
+        }
+      } else if (typeof fractionFormat === "number") {
+        minimumFractionDigits = maximumFractionDigits = fractionFormat;
+      }
+      const i18nService = appstore.I18nService.get();
+      const selectedLocale = i18nService.getSelectedLocale();
+      return new Intl.NumberFormat(selectedLocale, {
+        minimumFractionDigits,
+        maximumFractionDigits
+      }).format(+data);
+    } catch (error) {
+      const num = +data;
+      if (typeof fracSize === "number") {
+        return num.toFixed(fracSize);
+      }
+      return num.toString();
+    }
+  }
+}
+class TrailingZeroDecimalFormatter {
+  format(value, selectedLocale, numberFilter, localeFilter, trailingZero, decimalValue, skipTrailingZeroCheck, formattedLocale) {
+    const finalNumberFilter = trailingZero && !skipTrailingZeroCheck ? `1.${(decimalValue == null ? void 0 : decimalValue.length) || 0}-16` : numberFilter;
+    const locale = formattedLocale ? formattedLocale["number"] : void 0;
+    const finalLocale = localeFilter || locale || selectedLocale || "en";
+    try {
+      let minimumFractionDigits = 0;
+      let maximumFractionDigits = 3;
+      if (finalNumberFilter && typeof finalNumberFilter === "string" && finalNumberFilter.includes(".")) {
+        const parts = finalNumberFilter.split(".");
+        if (parts[1]) {
+          const fractionParts = parts[1].split("-");
+          minimumFractionDigits = parseInt(fractionParts[0]) || 0;
+          maximumFractionDigits = parseInt(fractionParts[1]) || minimumFractionDigits;
+        }
+      }
+      return new Intl.NumberFormat(finalLocale, {
+        minimumFractionDigits,
+        maximumFractionDigits
+      }).format(value);
+    } catch (error) {
+      return value.toString();
+    }
+  }
+}
+export {
+  CurrencyFormatter,
+  NumberToStringFormatter,
+  StringToNumberFormatter,
+  ToNumberFormatter,
+  TrailingZeroDecimalFormatter
+};

package/core/formatter/security-formatters.d.ts

@@ -0,0 +1,25 @@
+import { Formatter, SafeValue, SecurityContext } from "./types";
+export declare class TrustAsFormatter implements Formatter {
+    format(content: string, context?: string | SecurityContext): string;
+    private bypassSecurityTrustHtml;
+    private bypassSecurityTrustStyle;
+    private bypassSecurityTrustScript;
+    private bypassSecurityTrustUrl;
+    private bypassSecurityTrustResourceUrl;
+    static isTrustedValue(value: any): value is SafeValue;
+    static getTrustedValue(value: any): string;
+    static getTrustType(value: any): string | null;
+}
+export declare class SanitizeFormatter implements Formatter {
+    format(input: string | SafeValue, sanitizeType?: "html" | "script" | "style" | "url" | "resourceUrl"): string;
+    private sanitizeHtml;
+    private basicHtmlSanitization;
+    private sanitizeStyle;
+    private sanitizeUrl;
+    private basicUrlSanitization;
+    private isValidUrl;
+}
+export declare const TrustedContent: ({ value, fallback }: {
+    value: any;
+    fallback?: string;
+}) => any;

package/core/formatter/security-formatters.js

@@ -0,0 +1,271 @@
+import DOMPurify from "dompurify";
+import * as React from "react";
+import {
+  SecurityContext
+} from "./types";
+class TrustAsFormatter {
+  format(content, context = "html") {
+    if (content === null || content === void 0) {
+      return "";
+    }
+    let contextStr;
+    switch (context) {
+      case "html":
+      case SecurityContext.HTML:
+        contextStr = "html";
+        break;
+      case "style":
+      case SecurityContext.STYLE:
+        contextStr = "style";
+        break;
+      case "script":
+      case SecurityContext.SCRIPT:
+        contextStr = "script";
+        break;
+      case "url":
+      case SecurityContext.URL:
+        contextStr = "url";
+        break;
+      case "resource":
+      case "resourceUrl":
+      case SecurityContext.RESOURCE_URL:
+        contextStr = "resource";
+        break;
+      default:
+        contextStr = "html";
+    }
+    switch (contextStr) {
+      case "html":
+        return this.bypassSecurityTrustHtml(content);
+      case "style":
+        return this.bypassSecurityTrustStyle(content);
+      case "script":
+        return this.bypassSecurityTrustScript(content);
+      case "url":
+        return this.bypassSecurityTrustUrl(content);
+      case "resource":
+        return this.bypassSecurityTrustResourceUrl(content);
+      default:
+        return content;
+    }
+  }
+  bypassSecurityTrustHtml(value) {
+    return value;
+  }
+  bypassSecurityTrustStyle(value) {
+    return value;
+  }
+  bypassSecurityTrustScript(value) {
+    console.warn("Bypassing script security. Make sure you trust the content.");
+    return value;
+  }
+  bypassSecurityTrustUrl(value) {
+    try {
+      new URL(value, typeof window !== "undefined" ? window.location.origin : "http://localhost");
+      return value;
+    } catch (e) {
+      console.warn("Invalid URL provided to trustAs formatter:", value);
+      return "";
+    }
+  }
+  bypassSecurityTrustResourceUrl(value) {
+    try {
+      new URL(value, typeof window !== "undefined" ? window.location.origin : "http://localhost");
+      return value;
+    } catch (e) {
+      console.warn("Invalid resource URL provided to trustAs formatter:", value);
+      return "";
+    }
+  }
+  // Helper method to check if a value is trusted
+  static isTrustedValue(value) {
+    return value && typeof value === "object" && "__trustAs" in value && "__trustedValue" in value;
+  }
+  // Helper method to extract trusted value
+  static getTrustedValue(value) {
+    if (this.isTrustedValue(value)) {
+      return value.__trustedValue;
+    }
+    return value;
+  }
+  // Helper method to get trust type
+  static getTrustType(value) {
+    if (this.isTrustedValue(value)) {
+      return value.__trustAs;
+    }
+    return null;
+  }
+}
+class SanitizeFormatter {
+  format(input, sanitizeType = "html") {
+    if (!input) return input;
+    if (TrustAsFormatter.isTrustedValue(input)) {
+      return TrustAsFormatter.getTrustedValue(input);
+    }
+    switch (sanitizeType) {
+      case "html":
+        return this.sanitizeHtml(input);
+      case "script":
+        return "";
+      case "style":
+        return this.sanitizeStyle(input);
+      case "url":
+      case "resourceUrl":
+        return this.sanitizeUrl(input);
+      default:
+        return this.sanitizeHtml(input);
+    }
+  }
+  sanitizeHtml(html) {
+    try {
+      if (typeof window !== "undefined" && DOMPurify && typeof DOMPurify.sanitize === "function") {
+        const cleanHtml = DOMPurify.sanitize(html, {
+          ALLOWED_TAGS: [
+            "p",
+            "div",
+            "span",
+            "a",
+            "strong",
+            "em",
+            "u",
+            "b",
+            "i",
+            "ul",
+            "ol",
+            "li",
+            "br",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "blockquote",
+            "pre",
+            "code",
+            "table",
+            "thead",
+            "tbody",
+            "tr",
+            "td",
+            "th",
+            "img",
+            "video",
+            "audio",
+            "source"
+          ],
+          ALLOWED_ATTR: [
+            "href",
+            "title",
+            "alt",
+            "src",
+            "width",
+            "height",
+            "class",
+            "id",
+            "style",
+            "target",
+            "rel",
+            "data-*"
+          ],
+          ALLOW_DATA_ATTR: true,
+          ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp|data):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+        });
+        return cleanHtml;
+      } else {
+        return this.basicHtmlSanitization(html);
+      }
+    } catch (error) {
+      console.error("HTML sanitization failed:", error);
+      return this.basicHtmlSanitization(html);
+    }
+  }
+  basicHtmlSanitization(html) {
+    return html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/\s*on\w+\s*=\s*["'][^"']*["']/gi, "").replace(/\s*javascript:\s*[^"'\s>]*/gi, "").replace(/<iframe\b[^>]*>/gi, "").replace(/<object\b[^>]*>/gi, "").replace(/<embed\b[^>]*>/gi, "");
+  }
+  sanitizeStyle(style) {
+    try {
+      if (typeof window !== "undefined" && DOMPurify && typeof DOMPurify.sanitize === "function") {
+        const cleanStyle = DOMPurify.sanitize(`<div style="${style}"></div>`, {
+          ALLOWED_TAGS: ["div"],
+          ALLOWED_ATTR: ["style"]
+        });
+        const match = cleanStyle.match(/style="([^"]*)"/);
+        return match ? match[1] : "";
+      } else {
+        return style.replace(/expression\s*\(/gi, "").replace(/javascript:/gi, "").replace(/url\s*\(\s*["']?\s*javascript:/gi, "");
+      }
+    } catch (error) {
+      console.error("Style sanitization failed:", error);
+      return style.replace(/expression\s*\(/gi, "").replace(/javascript:/gi, "").replace(/url\s*\(\s*["']?\s*javascript:/gi, "");
+    }
+  }
+  sanitizeUrl(url) {
+    try {
+      if (typeof window !== "undefined" && DOMPurify && typeof DOMPurify.sanitize === "function") {
+        const cleanUrl = DOMPurify.sanitize(`<a href="${url}"></a>`, {
+          ALLOWED_TAGS: ["a"],
+          ALLOWED_ATTR: ["href"]
+        });
+        const match = cleanUrl.match(/href="([^"]*)"/);
+        const sanitizedUrl = match ? match[1] : "";
+        if (sanitizedUrl && this.isValidUrl(sanitizedUrl)) {
+          return sanitizedUrl;
+        }
+        return "";
+      } else {
+        return this.basicUrlSanitization(url);
+      }
+    } catch (error) {
+      console.error("URL sanitization failed:", error);
+      return this.basicUrlSanitization(url);
+    }
+  }
+  basicUrlSanitization(url) {
+    const safeSchemes = /^(https?|ftp|mailto|tel):/i;
+    const dataScheme = /^data:[^;]+;base64,/i;
+    if (safeSchemes.test(url) || dataScheme.test(url) || url.startsWith("/") || url.startsWith("./") || url.startsWith("../")) {
+      return url;
+    }
+    return "";
+  }
+  isValidUrl(url) {
+    try {
+      const urlObj = new URL(
+        url,
+        typeof window !== "undefined" ? window.location.origin : "http://localhost"
+      );
+      const allowedProtocols = ["http:", "https:", "mailto:", "tel:", "ftp:"];
+      return allowedProtocols.includes(urlObj.protocol);
+    } catch (e) {
+      return url.startsWith("/") || url.startsWith("./") || url.startsWith("../");
+    }
+  }
+}
+const TrustedContent = ({ value, fallback = "" }) => {
+  if (TrustAsFormatter.isTrustedValue(value)) {
+    const trustType = TrustAsFormatter.getTrustType(value);
+    const trustedValue = TrustAsFormatter.getTrustedValue(value);
+    switch (trustType) {
+      case "html":
+        return React.createElement("div", {
+          dangerouslySetInnerHTML: { __html: trustedValue }
+        });
+      case "style":
+        return React.createElement("div", {
+          style: trustedValue
+        });
+      case "url":
+      case "resource":
+        return trustedValue;
+      default:
+        return trustedValue || fallback;
+    }
+  }
+  return value || fallback;
+};
+export {
+  SanitizeFormatter,
+  TrustAsFormatter,
+  TrustedContent
+};

package/core/formatter/string-formatters.d.ts

@@ -0,0 +1,10 @@
+import { Formatter } from "./types";
+export declare class PrependFormatter implements Formatter {
+    format(input: any, prefix: string): string;
+}
+export declare class AppendFormatter implements Formatter {
+    format(input: any, suffix: string): string;
+}
+export declare class TemplateReplaceFormatter implements Formatter {
+    format(template: string, replacements: Record<string, any> | any[]): string;
+}

package/core/formatter/string-formatters.js

@@ -0,0 +1,27 @@
+import { replace } from "../util";
+class PrependFormatter {
+  format(input, prefix) {
+    return (prefix || "") + (input !== null || input != void 0 ? input : "");
+  }
+}
+class AppendFormatter {
+  format(input, suffix) {
+    return (input !== null || input != void 0 ? input : "") + (suffix || "");
+  }
+}
+class TemplateReplaceFormatter {
+  format(template, replacements) {
+    if (!template) return template;
+    try {
+      return replace(template, replacements) || "";
+    } catch (error) {
+      console.error("Template replacement failed:", error);
+      return template;
+    }
+  }
+}
+export {
+  AppendFormatter,
+  PrependFormatter,
+  TemplateReplaceFormatter
+};

package/core/formatter/types.d.ts

@@ -0,0 +1,33 @@
+export interface Formatter {
+    format: (input: any, ...params: any) => any;
+}
+export interface SafeValue {
+    __trustAs: string;
+    __trustedValue: string;
+}
+export interface SafeHtml extends SafeValue {
+    __trustAs: "html";
+}
+export interface SafeStyle extends SafeValue {
+    __trustAs: "style";
+}
+export interface SafeScript extends SafeValue {
+    __trustAs: "script";
+}
+export interface SafeUrl extends SafeValue {
+    __trustAs: "url";
+}
+export interface SafeResourceUrl extends SafeValue {
+    __trustAs: "resource";
+}
+export declare enum SecurityContext {
+    NONE = 0,
+    HTML = 1,
+    STYLE = 2,
+    SCRIPT = 3,
+    URL = 4,
+    RESOURCE_URL = 5
+}
+export interface DateFormatter {
+    format: (input: Date | string | number | null | undefined, format?: string | null) => string;
+}

package/core/formatter/types.js

@@ -0,0 +1,12 @@
+var SecurityContext = /* @__PURE__ */ ((SecurityContext2) => {
+  SecurityContext2[SecurityContext2["NONE"] = 0] = "NONE";
+  SecurityContext2[SecurityContext2["HTML"] = 1] = "HTML";
+  SecurityContext2[SecurityContext2["STYLE"] = 2] = "STYLE";
+  SecurityContext2[SecurityContext2["SCRIPT"] = 3] = "SCRIPT";
+  SecurityContext2[SecurityContext2["URL"] = 4] = "URL";
+  SecurityContext2[SecurityContext2["RESOURCE_URL"] = 5] = "RESOURCE_URL";
+  return SecurityContext2;
+})(SecurityContext || {});
+export {
+  SecurityContext
+};

package/core/formatters.d.ts

@@ -0,0 +1,3 @@
+export * from "./formatter";
+import defaultFormatters from "./formatter";
+export default defaultFormatters;

package/core/formatters.js

@@ -0,0 +1,6 @@
+export * from "./formatter";
+import defaultFormatters from "./formatter";
+var formatters_default = defaultFormatters;
+export {
+  formatters_default as default
+};

package/core/proxy-service.d.ts

@@ -0,0 +1,9 @@
+import { PageContextState, ProxyTarget } from "@wavemaker-ai/react-runtime/types";
+import { OverriddenPropsRegistry } from "@wavemaker-ai/react-runtime/core/script-registry";
+import BaseAppProps from "../higherOrder/BaseAppProps";
+import { FormFieldProps } from "../components/data/form/form-field/props";
+export declare function clearPageWidgetProxyCache(widgetsProxy: object | null | undefined): void;
+export declare const createWidgetProxy: (widget: any, widgetName: string, setPageContext: any, overriddenPropsRegistry?: OverriddenPropsRegistry) => any;
+export declare const createPageProxy: (target: ProxyTarget, setPageContext: React.Dispatch<React.SetStateAction<PageContextState>>, overriddenPropsRegistry?: OverriddenPropsRegistry) => ProxyTarget;
+export declare const createStateProxy: (obj: PageContextState | BaseAppProps, path: string[], setPageContext: React.Dispatch<React.SetStateAction<PageContextState>> | React.Dispatch<React.SetStateAction<BaseAppProps>>, overriddenPropsRegistry?: OverriddenPropsRegistry) => ProxyTarget;
+export declare const createFormFieldProxy: (formField: FormFieldProps, setState: React.Dispatch<React.SetStateAction<FormFieldProps>>, overriddenItemsRef: React.MutableRefObject<Record<string, any>>, formProxy: any) => any;