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

package/core/constants/events.d.ts

@@ -0,0 +1,27 @@
+import EventEmitter from "events";
+export declare const EVENTEMITTER_METHODS: {
+    PREFAB_STATE_SYNC_ON: (name: string, callback: (data: any) => void) => EventEmitter<[never]>;
+    PREFAB_STATE_SYNC_OFF: (name: string, callback: (data: any) => void) => EventEmitter<[never]>;
+    PREFAB_STATE_SYNC_EMIT: (name: string, data: any) => boolean;
+    PARTIAL_STATE_SYNC_ON: (callback: (data: any) => void) => EventEmitter<[never]>;
+    PARTIAL_STATE_SYNC_OFF: (callback: (data: any) => void) => EventEmitter<[never]>;
+    PARTIAL_STATE_SYNC_EMIT: (data: any) => boolean;
+    LAYOUT_STATE_REFRESH_ON: (callback: (data: {
+        layoutName: string;
+        layout: Record<string, any>;
+        proxy: any;
+    }) => void) => EventEmitter<[never]>;
+    LAYOUT_STATE_REFRESH_OFF: (callback: (data: {
+        layoutName: string;
+        layout: Record<string, any>;
+        proxy: any;
+    }) => void) => EventEmitter<[never]>;
+    LAYOUT_STATE_REFRESH_EMIT: (data: {
+        layoutName: string;
+        layout: Record<string, any>;
+        proxy: any;
+    }) => boolean;
+    ACTIVE_PAGE_SYNC_ON: (callback: () => void) => EventEmitter<[never]>;
+    ACTIVE_PAGE_SYNC_OFF: (callback: () => void) => EventEmitter<[never]>;
+    ACTIVE_PAGE_SYNC_EMIT: () => boolean;
+};

package/core/constants/events.js

@@ -0,0 +1,65 @@
+import EventEmitter from "events";
+const partialStateSyncEmitter = new EventEmitter();
+const prefabStateSyncEmitter = new EventEmitter();
+const layoutSyncEmitter = new EventEmitter();
+const activePageSyncEmitter = new EventEmitter();
+partialStateSyncEmitter.setMaxListeners(50);
+prefabStateSyncEmitter.setMaxListeners(50);
+layoutSyncEmitter.setMaxListeners(50);
+activePageSyncEmitter.setMaxListeners(50);
+const EVENTEMITTER = {
+  LAYOUT_STATE_REFRESH: "layout-state-refresh",
+  PARTIAL_STATE_SYNC: "partial-state-sync",
+  PREFAB_STATE_SYNC: "prefab-state-sync",
+  ACTIVE_PAGE_SYNC: "active-page-sync"
+};
+const EVENTEMITTER_METHODS = {
+  PREFAB_STATE_SYNC_ON: (name = "", callback) => {
+    return prefabStateSyncEmitter.on(
+      EVENTEMITTER.PREFAB_STATE_SYNC + (name ? "_" + name : ""),
+      callback
+    );
+  },
+  PREFAB_STATE_SYNC_OFF: (name = "", callback) => {
+    return prefabStateSyncEmitter.off(
+      EVENTEMITTER.PREFAB_STATE_SYNC + (name ? "_" + name : ""),
+      callback
+    );
+  },
+  PREFAB_STATE_SYNC_EMIT: (name = "", data) => {
+    return prefabStateSyncEmitter.emit(
+      EVENTEMITTER.PREFAB_STATE_SYNC + (name ? "_" + name : ""),
+      data
+    );
+  },
+  PARTIAL_STATE_SYNC_ON: (callback) => {
+    return partialStateSyncEmitter.on(EVENTEMITTER.PARTIAL_STATE_SYNC, callback);
+  },
+  PARTIAL_STATE_SYNC_OFF: (callback) => {
+    return partialStateSyncEmitter.off(EVENTEMITTER.PARTIAL_STATE_SYNC, callback);
+  },
+  PARTIAL_STATE_SYNC_EMIT: (data) => {
+    return partialStateSyncEmitter.emit(EVENTEMITTER.PARTIAL_STATE_SYNC, data);
+  },
+  LAYOUT_STATE_REFRESH_ON: (callback) => {
+    return layoutSyncEmitter.on(EVENTEMITTER.LAYOUT_STATE_REFRESH, callback);
+  },
+  LAYOUT_STATE_REFRESH_OFF: (callback) => {
+    return layoutSyncEmitter.off(EVENTEMITTER.LAYOUT_STATE_REFRESH, callback);
+  },
+  LAYOUT_STATE_REFRESH_EMIT: (data) => {
+    return layoutSyncEmitter.emit(EVENTEMITTER.LAYOUT_STATE_REFRESH, data);
+  },
+  ACTIVE_PAGE_SYNC_ON: (callback) => {
+    return activePageSyncEmitter.on(EVENTEMITTER.ACTIVE_PAGE_SYNC, callback);
+  },
+  ACTIVE_PAGE_SYNC_OFF: (callback) => {
+    return activePageSyncEmitter.off(EVENTEMITTER.ACTIVE_PAGE_SYNC, callback);
+  },
+  ACTIVE_PAGE_SYNC_EMIT: () => {
+    return activePageSyncEmitter.emit(EVENTEMITTER.ACTIVE_PAGE_SYNC);
+  }
+};
+export {
+  EVENTEMITTER_METHODS
+};

package/core/constants/index.d.ts

@@ -0,0 +1,10 @@
+/** Production / default SPA URL segment (embedded apps, classic deploy). */
+export declare const ROUTING_BASEPATH_PRODUCTION = "react-pages";
+/** Studio / dynamic preview uses this segment in the browser URL (runtime-dynamic). */
+export declare const PREVIEW_ROUTING_BASEPATH = "react-preview";
+/**
+ * SPA routing segment for the current window (`react-pages` vs `react-preview`).
+ * Call when building navigation targets — not a one-time module-load constant.
+ */
+export declare function getActiveRoutingBasePath(): string;
+export declare const hyperLinkMofify: (link: string) => string;

package/core/constants/index.js

@@ -0,0 +1,39 @@
+const ROUTING_BASEPATH_PRODUCTION = "react-pages";
+const PREVIEW_ROUTING_BASEPATH = "react-preview";
+function getActiveRoutingBasePath() {
+  if (typeof window === "undefined") {
+    return ROUTING_BASEPATH_PRODUCTION;
+  }
+  const pathname = window.location.pathname;
+  const preview = `/${PREVIEW_ROUTING_BASEPATH}`;
+  const prod = `/${ROUTING_BASEPATH_PRODUCTION}`;
+  if (pathname.includes(`${preview}/`) || pathname.endsWith(preview)) {
+    return PREVIEW_ROUTING_BASEPATH;
+  }
+  if (pathname.includes(`${prod}/`) || pathname.endsWith(prod)) {
+    return ROUTING_BASEPATH_PRODUCTION;
+  }
+  return ROUTING_BASEPATH_PRODUCTION;
+}
+const hyperLinkMofify = (link) => {
+  let hrefLink = "#";
+  if (link) {
+    const segment = getActiveRoutingBasePath();
+    if (/^#/.test(link)) {
+      const suffix = link.replace(/^#/, "");
+      hrefLink = /^\/.*/.test(suffix) ? `/${segment}${suffix}` : `/${segment}/${suffix}`;
+    } else if (/^\//.test(link)) {
+      const normalized = link.replace(new RegExp(`^/${ROUTING_BASEPATH_PRODUCTION}(?=/|$)`), `/${segment}`).replace(new RegExp(`^/${PREVIEW_ROUTING_BASEPATH}(?=/|$)`), `/${segment}`);
+      hrefLink = normalized.match(new RegExp(`^/${segment}(/|$)`)) ? normalized : `/${segment}${link}`;
+    } else {
+      hrefLink = link;
+    }
+  }
+  return hrefLink;
+};
+export {
+  PREVIEW_ROUTING_BASEPATH,
+  ROUTING_BASEPATH_PRODUCTION,
+  getActiveRoutingBasePath,
+  hyperLinkMofify
+};

package/core/dialog.service.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+interface DialogInstance {
+    open: () => void;
+    close: (event?: React.SyntheticEvent) => void;
+    isOpen: boolean;
+    component: React.ComponentType<any>;
+}
+interface DialogServiceInterface {
+    registerDialog(name: string, dialogInstance: DialogInstance): void;
+    unregisterDialog(name: string): void;
+    open(dialogName: string): void;
+    close(dialogName: string): void;
+    getDialog(dialogName: string): DialogInstance | null;
+    getAllDialogs(): Record<string, DialogInstance>;
+    isDialogOpen(dialogName: string): boolean;
+}
+declare class DialogService implements DialogServiceInterface {
+    private dialogs;
+    registerDialog(name: string, dialogInstance: DialogInstance): void;
+    unregisterDialog(name: string): void;
+    open(dialogName: string): void;
+    close(dialogName: string): void;
+    getDialog(dialogName: string): DialogInstance | null;
+    getAllDialogs(): Record<string, DialogInstance>;
+    isDialogOpen(dialogName: string): boolean;
+    getDialogNames(): string[];
+    clear(): void;
+}
+declare const dialogService: DialogService;
+export default dialogService;
+export type { DialogInstance, DialogServiceInterface };

package/core/dialog.service.js

@@ -0,0 +1,55 @@
+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);
+class DialogService {
+  constructor() {
+    __publicField(this, "dialogs", /* @__PURE__ */ new Map());
+  }
+  registerDialog(name, dialogInstance) {
+    this.dialogs.set(name, dialogInstance);
+  }
+  unregisterDialog(name) {
+    this.dialogs.delete(name);
+  }
+  open(dialogName) {
+    const dialog = this.dialogs.get(dialogName);
+    if (dialog) {
+      dialog.open();
+    } else {
+      console.error(
+        `Dialog "${dialogName}" not found. Available dialogs: ${Array.from(this.dialogs.keys()).join(", ")}`
+      );
+    }
+  }
+  close(dialogName) {
+    const dialog = this.dialogs.get(dialogName);
+    if (dialog) {
+      dialog.close();
+    } else {
+      console.error(
+        `Dialog "${dialogName}" not found. Available dialogs: ${Array.from(this.dialogs.keys()).join(", ")}`
+      );
+    }
+  }
+  getDialog(dialogName) {
+    return this.dialogs.get(dialogName) || null;
+  }
+  getAllDialogs() {
+    return Object.fromEntries(this.dialogs.entries());
+  }
+  isDialogOpen(dialogName) {
+    const dialog = this.dialogs.get(dialogName);
+    return dialog ? dialog.isOpen : false;
+  }
+  getDialogNames() {
+    return Array.from(this.dialogs.keys());
+  }
+  clear() {
+    this.dialogs.clear();
+  }
+}
+const dialogService = new DialogService();
+var dialog_service_default = dialogService;
+export {
+  dialog_service_default as default
+};

package/core/event-notifier.d.ts

@@ -0,0 +1,20 @@
+export default class EventNotifier {
+    static ROOT: EventNotifier;
+    name: string;
+    id: number;
+    private listeners;
+    private parent;
+    private children;
+    setParent(parent: EventNotifier): void;
+    notifyApp(event: string, ...data: any[]): void;
+    notify(event: string, args: any[], emitToParent?: boolean): void;
+    subscribe(event: string, fn: Function): () => void;
+    unsubscribe(event: string, fn: Function): void;
+    private removeFromParent;
+    destroy(): void;
+}
+export declare function eventObserver(): {
+    subscribe(callback: any): () => void;
+    next(value: any): void;
+    unsubscribe(callback: any): void;
+};

package/core/event-notifier.js

@@ -0,0 +1,113 @@
+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);
+let i = 1;
+const _EventNotifier = class _EventNotifier {
+  constructor() {
+    __publicField(this, "name", "");
+    __publicField(this, "id", i++);
+    __publicField(this, "listeners", {});
+    __publicField(this, "parent", _EventNotifier.ROOT);
+    __publicField(this, "children", []);
+  }
+  setParent(parent) {
+    if (parent !== this.parent) {
+      this.removeFromParent();
+      this.parent = parent;
+      this.parent.children.push(this);
+    }
+  }
+  notifyApp(event, ...data) {
+    let args = data;
+    if (data.length > 0 && typeof data[data.length - 1] === "boolean") {
+      args = data;
+    }
+    let propagate = true;
+    if (this.listeners[event]) {
+      propagate = !this.listeners[event].find((l) => {
+        try {
+          return (l && l.apply(null, args)) === false;
+        } catch (e) {
+          console.error(e);
+        }
+        return true;
+      });
+    }
+  }
+  notify(event, args, emitToParent = false) {
+    var _a;
+    let propagate = true;
+    if (this.listeners[event]) {
+      propagate = !this.listeners[event].find((l) => {
+        try {
+          return (l && l.apply(null, args)) === false;
+        } catch (e) {
+          console.error(e);
+        }
+        return true;
+      });
+    }
+    if (propagate) {
+      if (emitToParent) {
+        (_a = this.parent) == null ? void 0 : _a.notify(event, args, true);
+      } else {
+        this.children.forEach((c) => {
+          c.notify(event, args);
+        });
+      }
+    }
+  }
+  subscribe(event, fn) {
+    this.listeners[event] = this.listeners[event] || [];
+    this.listeners[event].push(fn);
+    return () => {
+      this.unsubscribe(event, fn);
+    };
+  }
+  unsubscribe(event, fn) {
+    if (!this.listeners[event]) return;
+    const index = this.listeners[event].findIndex((listener) => listener === fn);
+    if (index !== -1) {
+      this.listeners[event].splice(index, 1);
+      if (this.listeners[event].length === 0) {
+        delete this.listeners[event];
+      }
+    }
+  }
+  removeFromParent() {
+    if (this.parent) {
+      const i2 = this.parent.children.indexOf(this) || -1;
+      if (i2 >= 0) {
+        this.parent.children.splice(i2, 1);
+      }
+      this.parent = null;
+    }
+  }
+  destroy() {
+    this.removeFromParent();
+    this.listeners = {};
+  }
+};
+__publicField(_EventNotifier, "ROOT", new _EventNotifier());
+let EventNotifier = _EventNotifier;
+function eventObserver() {
+  let observers = [];
+  return {
+    subscribe(callback) {
+      observers.push(callback);
+      return () => {
+        observers = observers.filter((obs) => obs !== callback);
+      };
+    },
+    next(value) {
+      observers.forEach((callback) => callback(value));
+    },
+    unsubscribe(callback) {
+      observers = observers.filter((obs) => obs !== callback);
+    }
+  };
+}
+export {
+  EventNotifier as default,
+  eventObserver
+};

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

@@ -0,0 +1,4 @@
+import { Formatter } from "./types";
+export declare class FilterFormatter implements Formatter {
+    format(data: any[], field: string | Record<string, any>, value?: any): any[];
+}

package/core/formatter/array-formatters.js

@@ -0,0 +1,19 @@
+import isObject from "lodash-es/isObject";
+import includes from "lodash-es/includes";
+import filter from "lodash-es/filter";
+class FilterFormatter {
+  format(data, field, value) {
+    if (!data) {
+      return [];
+    }
+    if (isObject(field)) {
+      return filter(data, field);
+    }
+    return filter(data, (item) => {
+      return includes(item[field], value);
+    });
+  }
+}
+export {
+  FilterFormatter
+};

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

@@ -0,0 +1,9 @@
+import { DateFormatter } from "@wavemaker-ai/variables/src/types/date-formatter";
+import { Formatter } from "./types";
+export declare class DateToStringFormatter implements DateFormatter {
+    format(input: Date | string | number | null | undefined, format?: string | null): string;
+    private tryReconstructDateFromDecimal;
+}
+export declare class TimeFromNowFormatter implements Formatter {
+    format(timestamp: Date | string | number | null | undefined): string;
+}

package/core/formatter/date-formatters.js

@@ -0,0 +1,181 @@
+import * as momentLib from "moment-timezone/moment-timezone";
+import appstore from "../appstore";
+import { store } from "../../store";
+const moment = momentLib.default || window["moment"];
+function resolveDateFormattingLocale() {
+  var _a, _b, _c, _d, _e, _f;
+  try {
+    const fromI18n = (_b = (_a = appstore.I18nService.get()) == null ? void 0 : _a.getSelectedLocale) == null ? void 0 : _b.call(_a);
+    if (fromI18n != null && String(fromI18n).trim() !== "") {
+      return String(fromI18n).replace(/_/g, "-");
+    }
+  } catch (e) {
+  }
+  try {
+    const lang = ((_f = (_e = (_d = (_c = store.getState()) == null ? void 0 : _c.info) == null ? void 0 : _d.appConfig) == null ? void 0 : _e.appProperties) == null ? void 0 : _f.defaultLanguage) || "en";
+    return String(lang).replace(/_/g, "-");
+  } catch (e) {
+    return "en";
+  }
+}
+function formatMediumDateDefault(_moment, localeTag) {
+  try {
+    return new Intl.DateTimeFormat(localeTag || "en", { dateStyle: "medium" }).format(
+      _moment.toDate()
+    );
+  } catch (e) {
+    return _moment.isValid() ? _moment.locale(localeTag.split("-")[0] || "en").format("LL") : "";
+  }
+}
+class DateToStringFormatter {
+  format(input, format) {
+    if (!input && input !== 0) return "";
+    let _moment;
+    if (typeof input === "number") {
+      if (input < 1e3 && input > -1e3 && input !== 0) {
+        const reconstructedDate = this.tryReconstructDateFromDecimal(input);
+        if (reconstructedDate) {
+          _moment = moment(reconstructedDate);
+        } else {
+          return "";
+        }
+      } else if (input === 0) {
+        _moment = moment(0);
+      } else {
+        if (input < 1e10) {
+          _moment = moment(input * 1e3);
+        } else {
+          _moment = moment(input);
+        }
+      }
+    } else if (typeof input === "string") {
+      _moment = moment(
+        input,
+        [
+          moment.ISO_8601,
+          "YYYY",
+          "YYYY-MM",
+          "YYYYMMDD",
+          "YYYY-MM-DD",
+          "YYYY-MM-DDTHH",
+          "YYYY-MM-DDTHH:mm",
+          "YYYY-MM-DDTHH:mm:ss",
+          "YYYY-MM-DDTHH:mm:ss.SSS",
+          "YYYY-MM-DD HH:mm:ss",
+          "MM/DD/YYYY",
+          "MM-DD-YYYY",
+          "YYYY/MM/DD",
+          "YYYY/MM",
+          "D MMM YYYY",
+          "MMM D YYYY",
+          "MMMM D YYYY",
+          "D MMMM YYYY",
+          "D-MMM-YYYY",
+          "D/MMM/YYYY",
+          "YYYY-WWW",
+          "YYYY-WWW-E",
+          "YYYY-DDD",
+          "YYYY-DDDTHH",
+          "YYYY-DDDTHH:mm",
+          "YYYY-DDDTHH:mm:ss",
+          "YYYY-DDDTHH:mm:ss.SSS",
+          "YYYY-DDD HH:mm:ss",
+          "YYYY-MM-DDTHH:mm:ssZ",
+          "YYYY-MM-DDTHH:mm:ss+00:00",
+          "YYYY-MM-DDTHH:mm:ss-00:00",
+          "YYYY-MM-DDTHH:mm:ss.SSSZ",
+          "YYYY-MM-DDTHH:mm:ss.SSS+00:00",
+          "YYYY-MM-DDTHH:mm:ss.SSS-00:00",
+          "ddd, DD MMM YYYY HH:mm:ss ZZ",
+          "DD MMM YYYY HH:mm:ss ZZ",
+          "x"
+        ],
+        true
+      );
+    } else if (input instanceof Date) {
+      _moment = moment(input);
+    } else {
+      _moment = moment(input);
+    }
+    if (format === "timestamp") {
+      return _moment.isValid() ? Math.floor(_moment.valueOf() / 1e3).toString() : "";
+    }
+    if (format === "UTC") {
+      return _moment.isValid() ? moment.utc(_moment).toString() : "";
+    }
+    const localeTag = resolveDateFormattingLocale();
+    if (format == null || String(format).trim() === "") {
+      return _moment.isValid() ? formatMediumDateDefault(_moment, localeTag) : "";
+    }
+    const pattern = String(format).replaceAll("y", "Y").replaceAll("d", "D").replaceAll("E", "d").replace("a", "A");
+    const primaryLang = localeTag.split("-")[0] || "en";
+    return _moment.isValid() ? _moment.locale(primaryLang).format(pattern) : "";
+  }
+  tryReconstructDateFromDecimal(decimal) {
+    const patterns = [
+      // MM/DD/YY patterns
+      { month: 12, day: 5, year: 26 },
+      // 12/5/26
+      { month: 1, day: 2, year: 26 },
+      // 1/2/26
+      { month: 11, day: 5, year: 26 },
+      // 11/5/26
+      { month: 10, day: 5, year: 26 },
+      // 10/5/26
+      { month: 9, day: 5, year: 26 },
+      // 9/5/26
+      { month: 8, day: 5, year: 26 },
+      // 8/5/26
+      { month: 7, day: 5, year: 26 },
+      // 7/5/26
+      { month: 6, day: 5, year: 26 },
+      // 6/5/26
+      { month: 5, day: 5, year: 26 },
+      // 5/5/26
+      { month: 4, day: 5, year: 26 },
+      // 4/5/26
+      { month: 3, day: 5, year: 26 },
+      // 3/5/26
+      { month: 2, day: 5, year: 26 }
+      // 2/5/26
+    ];
+    for (const pattern of patterns) {
+      const calculatedDecimal = pattern.month / pattern.day / pattern.year;
+      if (Math.abs(calculatedDecimal - decimal) < 1e-6) {
+        const fullYear = pattern.year < 50 ? 2e3 + pattern.year : 1900 + pattern.year;
+        return `${pattern.month}/${pattern.day}/${fullYear}`;
+      }
+    }
+    for (let month = 1; month <= 12; month++) {
+      for (let day = 1; day <= 31; day++) {
+        for (let year = 0; year <= 99; year++) {
+          const calculatedDecimal = month / day / year;
+          if (Math.abs(calculatedDecimal - decimal) < 1e-6) {
+            const fullYear = year < 50 ? 2e3 + year : 1900 + year;
+            if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+              return `${month}/${day}/${fullYear}`;
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+}
+class TimeFromNowFormatter {
+  format(timestamp) {
+    if (!timestamp && timestamp !== 0) return "";
+    let _moment;
+    if (typeof timestamp === "string" && /^\d{1,2}:\d{2}(:\d{2})?$/.test(timestamp)) {
+      const today = moment().format("YYYY-MM-DD");
+      _moment = moment(`${today} ${timestamp}`, ["YYYY-MM-DD HH:mm:ss", "YYYY-MM-DD HH:mm"]);
+    } else {
+      _moment = moment(timestamp);
+    }
+    return _moment.isValid() ? _moment.fromNow() : "";
+  }
+}
+export {
+  DateToStringFormatter,
+  TimeFromNowFormatter
+};

package/core/formatter/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./types";
+export * from "./date-formatters";
+export * from "./number-formatters";
+export * from "./string-formatters";
+export * from "./security-formatters";
+import { Formatter } from "./types";
+export declare const createFormatter: (name: string, formatter: Formatter) => {
+    name: string;
+    formatter: Formatter;
+    format: (...args: any[]) => any;
+};
+declare const formatters: Map<string, Formatter>;
+export default formatters;
+export declare const getFormatter: (name: string) => Formatter | undefined;
+export declare const hasFormatter: (name: string) => boolean;
+export declare const registerFormatter: (name: string, formatter: Formatter) => void;
+export declare const unregisterFormatter: (name: string) => boolean;
+export declare const getAllFormatterNames: () => string[];
+export declare const formatValue: (value: any, formatterName: string, ...args: any[]) => any;

package/core/formatter/index.js

@@ -0,0 +1,80 @@
+export * from "./types";
+export * from "./date-formatters";
+export * from "./number-formatters";
+export * from "./string-formatters";
+export * from "./security-formatters";
+import { DateToStringFormatter, TimeFromNowFormatter } from "./date-formatters";
+import {
+  NumberToStringFormatter,
+  CurrencyFormatter,
+  StringToNumberFormatter,
+  ToNumberFormatter,
+  TrailingZeroDecimalFormatter
+} from "./number-formatters";
+import { PrependFormatter, AppendFormatter, TemplateReplaceFormatter } from "./string-formatters";
+import { TrustAsFormatter, SanitizeFormatter } from "./security-formatters";
+import { FilterFormatter } from "./array-formatters";
+const createFormatter = (name, formatter) => {
+  return {
+    name,
+    formatter,
+    // @ts-expect-error ...args is a rest parameter
+    format: (...args) => formatter.format(...args)
+  };
+};
+const formatters = /* @__PURE__ */ new Map([
+  // Date formatters
+  ["toDate", createFormatter("toDate", new DateToStringFormatter())],
+  ["timeFromNow", createFormatter("timeFromNow", new TimeFromNowFormatter())],
+  // Number formatters
+  ["numberToString", createFormatter("numberToString", new NumberToStringFormatter())],
+  ["toCurrency", createFormatter("toCurrency", new CurrencyFormatter())],
+  ["stringToNumber", createFormatter("stringToNumber", new StringToNumberFormatter())],
+  ["toNumber", createFormatter("toNumber", new ToNumberFormatter())],
+  [
+    "trailingZeroDecimal",
+    createFormatter("trailingZeroDecimal", new TrailingZeroDecimalFormatter())
+  ],
+  // String formatters
+  ["prefix", createFormatter("prefix", new PrependFormatter())],
+  ["suffix", createFormatter("suffix", new AppendFormatter())],
+  ["templateReplace", createFormatter("templateReplace", new TemplateReplaceFormatter())],
+  // Security formatters
+  ["trustAs", createFormatter("trustAs", new TrustAsFormatter())],
+  ["sanitize", createFormatter("sanitize", new SanitizeFormatter())],
+  ["filter", createFormatter("filter", new FilterFormatter())]
+]);
+var formatter_default = formatters;
+const getFormatter = (name) => {
+  return formatters.get(name);
+};
+const hasFormatter = (name) => {
+  return formatters.has(name);
+};
+const registerFormatter = (name, formatter) => {
+  formatters.set(name, createFormatter(name, formatter));
+};
+const unregisterFormatter = (name) => {
+  return formatters.delete(name);
+};
+const getAllFormatterNames = () => {
+  return Array.from(formatters.keys());
+};
+const formatValue = (value, formatterName, ...args) => {
+  const formatter = getFormatter(formatterName);
+  if (formatter) {
+    return formatter.format(value, ...args);
+  }
+  console.warn(`Formatter "${formatterName}" not found`);
+  return value;
+};
+export {
+  createFormatter,
+  formatter_default as default,
+  formatValue,
+  getAllFormatterNames,
+  getFormatter,
+  hasFormatter,
+  registerFormatter,
+  unregisterFormatter
+};