@wavemaker/react-runtime 11.14.1-16.6404

package/core/constants/events.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EVENTEMITTER_METHODS = void 0;
+var _events = _interopRequireDefault(require("events"));
+var partialStateSyncEmitter = new _events["default"]();
+var prefabStateSyncEmitter = new _events["default"]();
+var EVENTEMITTER = {
+  PARTIAL_STATE_SYNC: "partial-state-sync",
+  PREFAB_STATE_SYNC: "prefab-state-sync"
+};
+var EVENTEMITTER_METHODS = exports.EVENTEMITTER_METHODS = {
+  PREFAB_STATE_SYNC_ON: function PREFAB_STATE_SYNC_ON(callback) {
+    return prefabStateSyncEmitter.on(EVENTEMITTER.PREFAB_STATE_SYNC, callback);
+  },
+  PREFAB_STATE_SYNC_OFF: function PREFAB_STATE_SYNC_OFF(callback) {
+    return prefabStateSyncEmitter.off(EVENTEMITTER.PREFAB_STATE_SYNC, callback);
+  },
+  PREFAB_STATE_SYNC_EMIT: function PREFAB_STATE_SYNC_EMIT(data) {
+    return prefabStateSyncEmitter.emit(EVENTEMITTER.PREFAB_STATE_SYNC, data);
+  },
+  PARTIAL_STATE_SYNC_ON: function PARTIAL_STATE_SYNC_ON(callback) {
+    return partialStateSyncEmitter.on(EVENTEMITTER.PARTIAL_STATE_SYNC, callback);
+  },
+  PARTIAL_STATE_SYNC_OFF: function PARTIAL_STATE_SYNC_OFF(callback) {
+    return partialStateSyncEmitter.off(EVENTEMITTER.PARTIAL_STATE_SYNC, callback);
+  },
+  PARTIAL_STATE_SYNC_EMIT: function PARTIAL_STATE_SYNC_EMIT(data) {
+    return partialStateSyncEmitter.emit(EVENTEMITTER.PARTIAL_STATE_SYNC, data);
+  }
+};

package/core/constants/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hyperLinkMofify = exports.ROUTING_BASEPATH = void 0;
+var ROUTING_BASEPATH = exports.ROUTING_BASEPATH = "react-pages";
+var hyperLinkMofify = exports.hyperLinkMofify = function hyperLinkMofify(link) {
+  var hrefLink = "#";
+  if (link) {
+    if (link.startsWith("#")) {
+      hrefLink = "/".concat(ROUTING_BASEPATH, "/") + link.substring(1);
+    } else if (link.startsWith("/")) {
+      // Check if basepath is already included to avoid duplication
+      if (link.startsWith("/".concat(ROUTING_BASEPATH))) {
+        hrefLink = link;
+      } else {
+        // Add basepath to relative URLs
+        hrefLink = "/".concat(ROUTING_BASEPATH).concat(link);
+      }
+    } else {
+      // Use link as is for absolute URLs
+      hrefLink = link;
+    }
+  }
+  return hrefLink;
+};

package/core/dialog.service.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = 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 DialogService = /*#__PURE__*/function () {
+  function DialogService() {
+    (0, _classCallCheck2["default"])(this, DialogService);
+    (0, _defineProperty2["default"])(this, "dialogs", new Map());
+  }
+  (0, _createClass2["default"])(DialogService, [{
+    key: "registerDialog",
+    value: function registerDialog(name, dialogInstance) {
+      this.dialogs.set(name, dialogInstance);
+    }
+  }, {
+    key: "unregisterDialog",
+    value: function unregisterDialog(name) {
+      this.dialogs["delete"](name);
+    }
+  }, {
+    key: "open",
+    value: function open(dialogName) {
+      var dialog = this.dialogs.get(dialogName);
+      if (dialog) {
+        dialog.open();
+      } else {
+        console.error("Dialog \"".concat(dialogName, "\" not found. Available dialogs: ").concat(Array.from(this.dialogs.keys()).join(", ")));
+      }
+    }
+  }, {
+    key: "close",
+    value: function close(dialogName) {
+      var dialog = this.dialogs.get(dialogName);
+      if (dialog) {
+        dialog.close();
+      } else {
+        console.error("Dialog \"".concat(dialogName, "\" not found. Available dialogs: ").concat(Array.from(this.dialogs.keys()).join(", ")));
+      }
+    }
+  }, {
+    key: "getDialog",
+    value: function getDialog(dialogName) {
+      return this.dialogs.get(dialogName) || null;
+    }
+  }, {
+    key: "getAllDialogs",
+    value: function getAllDialogs() {
+      return Object.fromEntries(this.dialogs.entries());
+    }
+  }, {
+    key: "isDialogOpen",
+    value: function isDialogOpen(dialogName) {
+      var dialog = this.dialogs.get(dialogName);
+      return dialog ? dialog.isOpen : false;
+    }
+  }, {
+    key: "getDialogNames",
+    value: function getDialogNames() {
+      return Array.from(this.dialogs.keys());
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.dialogs.clear();
+    }
+  }]);
+  return DialogService;
+}(); // Create a singleton instance
+var dialogService = new DialogService();
+var _default = exports["default"] = dialogService;

package/core/event-notifier.js

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.eventObserver = eventObserver;
+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 _EventNotifier;
+var i = 1;
+var EventNotifier = exports["default"] = /*#__PURE__*/function () {
+  function EventNotifier() {
+    (0, _classCallCheck2["default"])(this, EventNotifier);
+    (0, _defineProperty2["default"])(this, "name", "");
+    (0, _defineProperty2["default"])(this, "id", i++);
+    (0, _defineProperty2["default"])(this, "listeners", {});
+    (0, _defineProperty2["default"])(this, "parent", EventNotifier.ROOT);
+    (0, _defineProperty2["default"])(this, "children", []);
+  }
+  (0, _createClass2["default"])(EventNotifier, [{
+    key: "setParent",
+    value: function setParent(parent) {
+      if (parent !== this.parent) {
+        this.removeFromParent();
+        this.parent = parent;
+        this.parent.children.push(this);
+      }
+    }
+  }, {
+    key: "notifyApp",
+    value: function notifyApp(event) {
+      for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        data[_key - 1] = arguments[_key];
+      }
+      // Extract the last argument if it's a boolean for emitToParent
+      var args = data;
+
+      // Check if the last argument is a boolean (for backward compatibility)
+      if (data.length > 0 && typeof data[data.length - 1] === "boolean") {
+        args = data;
+      }
+      var propagate = true;
+      if (this.listeners[event]) {
+        propagate = !this.listeners[event].find(function (l) {
+          try {
+            return (l && l.apply(null, args)) === false;
+          } catch (e) {
+            console.error(e);
+          }
+          return true;
+        });
+      }
+    }
+  }, {
+    key: "notify",
+    value: function notify(event, args) {
+      var emitToParent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var propagate = true;
+      if (this.listeners[event]) {
+        propagate = !this.listeners[event].find(function (l) {
+          try {
+            return (l && l.apply(null, args)) === false;
+          } catch (e) {
+            console.error(e);
+          }
+          return true;
+        });
+      }
+      if (propagate) {
+        if (emitToParent) {
+          var _this$parent;
+          (_this$parent = this.parent) === null || _this$parent === void 0 || _this$parent.notify(event, args, true);
+        } else {
+          this.children.forEach(function (c) {
+            c.notify(event, args);
+          });
+        }
+      }
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(event, fn) {
+      var _this = this;
+      this.listeners[event] = this.listeners[event] || [];
+      this.listeners[event].push(fn);
+      return function () {
+        _this.unsubscribe(event, fn);
+      };
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(event, fn) {
+      if (!this.listeners[event]) return;
+      var index = this.listeners[event].findIndex(function (listener) {
+        return listener === fn;
+      });
+      if (index !== -1) {
+        this.listeners[event].splice(index, 1);
+        if (this.listeners[event].length === 0) {
+          delete this.listeners[event];
+        }
+      }
+    }
+  }, {
+    key: "removeFromParent",
+    value: function removeFromParent() {
+      if (this.parent) {
+        var _i = this.parent.children.indexOf(this) || -1;
+        if (_i >= 0) {
+          this.parent.children.splice(_i, 1);
+        }
+        this.parent = null;
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.removeFromParent();
+      this.listeners = {};
+    }
+  }]);
+  return EventNotifier;
+}();
+_EventNotifier = EventNotifier;
+(0, _defineProperty2["default"])(EventNotifier, "ROOT", new _EventNotifier());
+function eventObserver() {
+  var observers = [];
+  return {
+    subscribe: function subscribe(callback) {
+      observers.push(callback);
+      return function () {
+        observers = observers.filter(function (obs) {
+          return obs !== callback;
+        });
+      };
+    },
+    next: function next(value) {
+      observers.forEach(function (callback) {
+        return callback(value);
+      });
+    },
+    unsubscribe: function unsubscribe(callback) {
+      observers = observers.filter(function (obs) {
+        return obs !== callback;
+      });
+    }
+  };
+}

package/core/formatter/date-formatters.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimeFromNowFormatter = exports.DateToStringFormatter = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var momentLib = _interopRequireWildcard(require("moment-timezone/moment-timezone"));
+var _store = require("../../store");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+// @ts-ignore
+
+var moment = momentLib["default"] || window["moment"];
+var DateToStringFormatter = exports.DateToStringFormatter = /*#__PURE__*/function () {
+  function DateToStringFormatter() {
+    (0, _classCallCheck2["default"])(this, DateToStringFormatter);
+  }
+  (0, _createClass2["default"])(DateToStringFormatter, [{
+    key: "format",
+    value: function format(input, _format) {
+      if (!input && input !== 0) return "";
+
+      // Normalize format string
+      _format = _format.replaceAll("y", "Y").replaceAll("d", "D").replaceAll("E", "d");
+      var _moment;
+
+      // Handle different input types
+      if (typeof input === "number") {
+        // Check if it's a small decimal that might be from a date expression like 12/5/26
+        if (input < 1000 && input > -1000 && input !== 0) {
+          // Try to reconstruct the original date expression
+          // This is a heuristic approach for expressions like 12/5/26
+          var reconstructedDate = this.tryReconstructDateFromDecimal(input);
+          if (reconstructedDate) {
+            _moment = moment(reconstructedDate);
+          } else {
+            return "";
+          }
+        } else if (input === 0) {
+          // Handle zero as epoch
+          _moment = moment(0);
+        } else {
+          // For larger numbers, treat as timestamp (milliseconds or seconds)
+          if (input < 10000000000) {
+            // Likely seconds, convert to milliseconds
+            _moment = moment(input * 1000);
+          } else {
+            // Likely milliseconds
+            _moment = moment(input);
+          }
+        }
+      } else if (typeof input === "string") {
+        // Handle string inputs with various formats
+        _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) {
+        // Handle Date objects
+        _moment = moment(input);
+      } else {
+        // Try to parse whatever it is
+        _moment = moment(input);
+      }
+
+      // Handle special format cases
+      if (_format === "timestamp") {
+        return _moment.isValid() ? Math.floor(_moment.valueOf() / 1000).toString() : "";
+      }
+      if (_format === "UTC") {
+        return _moment.isValid() ? moment.utc(_moment).toString() : "";
+      }
+
+      // Get default language from store (with fallback)
+      var defaultLanguage = "en";
+      try {
+        var _store$getState;
+        defaultLanguage = ((_store$getState = _store.store.getState()) === null || _store$getState === void 0 || (_store$getState = _store$getState.info) === null || _store$getState === void 0 || (_store$getState = _store$getState.appConfig) === null || _store$getState === void 0 || (_store$getState = _store$getState.appProperties) === null || _store$getState === void 0 ? void 0 : _store$getState.defaultLanguage) || "en";
+      } catch (error) {
+        // Fallback to "en" if store is not available or not properly initialized
+        defaultLanguage = "en";
+      }
+
+      // Return formatted date or empty string if invalid
+      return _moment.isValid() ? _moment.locale(defaultLanguage).format(_format) : "";
+    }
+  }, {
+    key: "tryReconstructDateFromDecimal",
+    value: function tryReconstructDateFromDecimal(decimal) {
+      // This method attempts to reconstruct date expressions like 12/5/26 from their decimal result
+      // 12/5/26 = 0.0923076923076923
+
+      // Common date patterns to try
+      var 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
+      ];
+
+      // Check if the decimal matches any of these patterns
+      for (var _i = 0, _patterns = patterns; _i < _patterns.length; _i++) {
+        var pattern = _patterns[_i];
+        var calculatedDecimal = pattern.month / pattern.day / pattern.year;
+        if (Math.abs(calculatedDecimal - decimal) < 0.000001) {
+          // Close enough match
+          // Convert 2-digit year to 4-digit year (assume 20xx for years < 50, 19xx for >= 50)
+          var fullYear = pattern.year < 50 ? 2000 + pattern.year : 1900 + pattern.year;
+          return "".concat(pattern.month, "/").concat(pattern.day, "/").concat(fullYear);
+        }
+      }
+
+      // Try some other common patterns with different day values
+      for (var month = 1; month <= 12; month++) {
+        for (var day = 1; day <= 31; day++) {
+          for (var year = 0; year <= 99; year++) {
+            var _calculatedDecimal = month / day / year;
+            if (Math.abs(_calculatedDecimal - decimal) < 0.000001) {
+              var _fullYear = year < 50 ? 2000 + year : 1900 + year;
+              // Validate the date makes sense
+              if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+                return "".concat(month, "/").concat(day, "/").concat(_fullYear);
+              }
+            }
+          }
+        }
+      }
+      return null; // Couldn't reconstruct a valid date
+    }
+  }]);
+  return DateToStringFormatter;
+}();
+var TimeFromNowFormatter = exports.TimeFromNowFormatter = /*#__PURE__*/function () {
+  function TimeFromNowFormatter() {
+    (0, _classCallCheck2["default"])(this, TimeFromNowFormatter);
+  }
+  (0, _createClass2["default"])(TimeFromNowFormatter, [{
+    key: "format",
+    value: function format(timestamp) {
+      if (!timestamp && timestamp !== 0) return "";
+      var _moment;
+
+      // Handle time-only strings
+      if (typeof timestamp === "string" && /^\d{1,2}:\d{2}(:\d{2})?$/.test(timestamp)) {
+        var today = moment().format("YYYY-MM-DD");
+        _moment = moment("".concat(today, " ").concat(timestamp), ["YYYY-MM-DD HH:mm:ss", "YYYY-MM-DD HH:mm"]);
+      } else {
+        _moment = moment(timestamp);
+      }
+      return _moment.isValid() ? _moment.fromNow() : "";
+    }
+  }]);
+  return TimeFromNowFormatter;
+}();

package/core/formatter/index.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  createFormatter: true,
+  getFormatter: true,
+  hasFormatter: true,
+  registerFormatter: true,
+  unregisterFormatter: true,
+  getAllFormatterNames: true,
+  formatValue: true
+};
+exports.unregisterFormatter = exports.registerFormatter = exports.hasFormatter = exports.getFormatter = exports.getAllFormatterNames = exports.formatValue = exports["default"] = exports.createFormatter = void 0;
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+var _dateFormatters = require("./date-formatters");
+Object.keys(_dateFormatters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _dateFormatters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dateFormatters[key];
+    }
+  });
+});
+var _numberFormatters = require("./number-formatters");
+Object.keys(_numberFormatters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _numberFormatters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _numberFormatters[key];
+    }
+  });
+});
+var _stringFormatters = require("./string-formatters");
+Object.keys(_stringFormatters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _stringFormatters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _stringFormatters[key];
+    }
+  });
+});
+var _securityFormatters = require("./security-formatters");
+Object.keys(_securityFormatters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _securityFormatters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _securityFormatters[key];
+    }
+  });
+});
+// Export all types
+
+// Export all formatters
+
+// Import all formatter classes for registry
+
+// Formatter creation helper
+var createFormatter = exports.createFormatter = function createFormatter(name, formatter) {
+  return {
+    name: name,
+    formatter: formatter,
+    format: function format() {
+      return formatter.format.apply(formatter, arguments);
+    }
+  };
+};
+
+// Create formatter instances and registry
+var formatters = new Map([
+// Date formatters
+["toDate", createFormatter("toDate", new _dateFormatters.DateToStringFormatter())], ["timeFromNow", createFormatter("timeFromNow", new _dateFormatters.TimeFromNowFormatter())],
+// Number formatters
+["numberToString", createFormatter("numberToString", new _numberFormatters.NumberToStringFormatter())], ["toCurrency", createFormatter("toCurrency", new _numberFormatters.CurrencyFormatter())], ["stringToNumber", createFormatter("stringToNumber", new _numberFormatters.StringToNumberFormatter())], ["toNumber", createFormatter("toNumber", new _numberFormatters.ToNumberFormatter())], ["trailingZeroDecimal", createFormatter("trailingZeroDecimal", new _numberFormatters.TrailingZeroDecimalFormatter())],
+// String formatters
+["prefix", createFormatter("prefix", new _stringFormatters.PrependFormatter())], ["suffix", createFormatter("suffix", new _stringFormatters.AppendFormatter())], ["templateReplace", createFormatter("templateReplace", new _stringFormatters.TemplateReplaceFormatter())],
+// Security formatters
+["trustAs", createFormatter("trustAs", new _securityFormatters.TrustAsFormatter())], ["sanitize", createFormatter("sanitize", new _securityFormatters.SanitizeFormatter())]]);
+
+// Export the formatters registry
+var _default = exports["default"] = formatters; // Export utility functions
+var getFormatter = exports.getFormatter = function getFormatter(name) {
+  return formatters.get(name);
+};
+var hasFormatter = exports.hasFormatter = function hasFormatter(name) {
+  return formatters.has(name);
+};
+var registerFormatter = exports.registerFormatter = function registerFormatter(name, formatter) {
+  formatters.set(name, createFormatter(name, formatter));
+};
+var unregisterFormatter = exports.unregisterFormatter = function unregisterFormatter(name) {
+  return formatters["delete"](name);
+};
+var getAllFormatterNames = exports.getAllFormatterNames = function getAllFormatterNames() {
+  return Array.from(formatters.keys());
+};
+var formatValue = exports.formatValue = function formatValue(value, formatterName) {
+  var formatter = getFormatter(formatterName);
+  if (formatter) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    return formatter.format.apply(formatter, [value].concat(args));
+  }
+  console.warn("Formatter \"".concat(formatterName, "\" not found"));
+  return value;
+};