@wavemaker-ai/react-runtime 1.0.0-rc.309

package/core/formatter/date-formatters.js

@@ -0,0 +1,245 @@
+"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 _appstore = _interopRequireDefault(require("../appstore"));
+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"];
+function resolveDateFormattingLocale() {
+  try {
+    var _appstore$I18nService, _appstore$I18nService2;
+    var fromI18n = (_appstore$I18nService = _appstore["default"].I18nService.get()) === null || _appstore$I18nService === void 0 || (_appstore$I18nService2 = _appstore$I18nService.getSelectedLocale) === null || _appstore$I18nService2 === void 0 ? void 0 : _appstore$I18nService2.call(_appstore$I18nService);
+    if (fromI18n != null && String(fromI18n).trim() !== "") {
+      return String(fromI18n).replace(/_/g, "-");
+    }
+  } catch (_unused) {
+    /* ignore */
+  }
+  try {
+    var _store$getState;
+    var lang = ((_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";
+    return String(lang).replace(/_/g, "-");
+  } catch (_unused2) {
+    return "en";
+  }
+}
+
+/** Mirrors Angular DatePipe when format is omitted: default medium date (`DATE_PIPE_DEFAULT_OPTIONS` or `mediumDate`). */
+function formatMediumDateDefault(_moment, localeTag) {
+  try {
+    return new Intl.DateTimeFormat(localeTag || "en", {
+      dateStyle: "medium"
+    }).format(_moment.toDate());
+  } catch (_unused3) {
+    return _moment.isValid() ? _moment.locale(localeTag.split("-")[0] || "en").format("LL") : "";
+  }
+}
+var DateToStringFormatter = exports.DateToStringFormatter = /*#__PURE__*/function () {
+  function DateToStringFormatter() {
+    (0, _classCallCheck2["default"])(this, DateToStringFormatter);
+  }
+  return (0, _createClass2["default"])(DateToStringFormatter, [{
+    key: "format",
+    value: function format(input, _format) {
+      if (!input && input !== 0) return "";
+      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() : "";
+      }
+      var localeTag = resolveDateFormattingLocale();
+
+      // Align with Angular ToDatePipe + DatePipe: omitted format → mediumDate-style output (no throw).
+      if (_format == null || String(_format).trim() === "") {
+        return _moment.isValid() ? formatMediumDateDefault(_moment, localeTag) : "";
+      }
+
+      // Normalize pattern tokens (moment + Angular-style lowercase tokens); match ng ToDatePipe `replace('a','A')` for am/pm.
+      var pattern = String(_format).replaceAll("y", "Y").replaceAll("d", "D").replaceAll("E", "d").replace("a", "A");
+      var primaryLang = localeTag.split("-")[0] || "en";
+      return _moment.isValid() ? _moment.locale(primaryLang).format(pattern) : "";
+    }
+  }, {
+    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
+    }
+  }]);
+}();
+var TimeFromNowFormatter = exports.TimeFromNowFormatter = /*#__PURE__*/function () {
+  function TimeFromNowFormatter() {
+    (0, _classCallCheck2["default"])(this, TimeFromNowFormatter);
+  }
+  return (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() : "";
+    }
+  }]);
+}();

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,133 @@
+"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];
+    }
+  });
+});
+var _arrayFormatters = require("./array-formatters");
+// 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,
+    // @ts-expect-error ...args is a rest parameter
+    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())], ["filter", createFormatter("filter", new _arrayFormatters.FilterFormatter())]]);
+
+// 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;
+};

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,181 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TrailingZeroDecimalFormatter = exports.ToNumberFormatter = exports.StringToNumberFormatter = exports.NumberToStringFormatter = exports.CurrencyFormatter = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _parseInt = _interopRequireDefault(require("lodash-es/parseInt"));
+var _currencyConstant = _interopRequireDefault(require("../constants/currency-constant"));
+var _appstore = _interopRequireDefault(require("../appstore"));
+/**
+ * Intl fraction digits must be integers in [0, 20]. which would
+ * otherwise throw RangeError from Intl.NumberFormat.
+ */
+function getIntlFractionDigitOptions(fractionSize) {
+  if (typeof fractionSize === "string" && fractionSize.includes(".")) {
+    var parts = fractionSize.split(".");
+    if (parts[1]) {
+      var fractionParts = parts[1].split("-");
+      var minimumFractionDigits = Math.min(20, Math.max(0, Number.parseInt(fractionParts[0], 10) || 0));
+      var maximumFractionDigits = Math.min(20, Math.max(minimumFractionDigits, Number.parseInt(fractionParts[1], 10) || minimumFractionDigits));
+      return {
+        minimumFractionDigits: minimumFractionDigits,
+        maximumFractionDigits: maximumFractionDigits
+      };
+    }
+  }
+  var 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
+  };
+}
+
+/** CurrencyPipe display parameter values (third argument). */
+var CURRENCY_DISPLAY_MODES = new Set(["code", "symbol", "symbol-narrow", "name"]);
+var NumberToStringFormatter = exports.NumberToStringFormatter = /*#__PURE__*/function () {
+  function NumberToStringFormatter() {
+    (0, _classCallCheck2["default"])(this, NumberToStringFormatter);
+  }
+  return (0, _createClass2["default"])(NumberToStringFormatter, [{
+    key: "format",
+    value: function format(input, fractionSize) {
+      var i18nService = _appstore["default"].I18nService.get();
+      var selectedLocale = i18nService.getSelectedLocale();
+      var _getIntlFractionDigit = getIntlFractionDigitOptions(fractionSize),
+        minimumFractionDigits = _getIntlFractionDigit.minimumFractionDigits,
+        maximumFractionDigits = _getIntlFractionDigit.maximumFractionDigits;
+      var formatCurrency = new Intl.NumberFormat(selectedLocale, {
+        minimumFractionDigits: minimumFractionDigits,
+        maximumFractionDigits: maximumFractionDigits
+      });
+      return isNaN(input) ? "" : formatCurrency.format(input);
+    }
+  }]);
+}();
+var CurrencyFormatter = exports.CurrencyFormatter = /*#__PURE__*/function () {
+  function CurrencyFormatter() {
+    (0, _classCallCheck2["default"])(this, CurrencyFormatter);
+  }
+  return (0, _createClass2["default"])(CurrencyFormatter, [{
+    key: "format",
+    value:
+    /**
+     * `(amount, currencyCode, display, digitsInfo)`
+     * where `display` is `symbol` | `code` | `symbol-narrow` | `name`.
+     */
+    function format(data, currencySymbol, displayOrFraction, digitsInfo) {
+      var fractionArg = 2;
+      if (displayOrFraction !== undefined && displayOrFraction !== null && displayOrFraction !== "" && CURRENCY_DISPLAY_MODES.has(String(displayOrFraction))) {
+        fractionArg = digitsInfo !== undefined && digitsInfo !== null && digitsInfo !== "" ? digitsInfo : 2;
+      } else if (displayOrFraction !== undefined && displayOrFraction !== null && displayOrFraction !== "") {
+        fractionArg = displayOrFraction;
+      }
+      var _currencySymbol = (_currencyConstant["default"][currencySymbol] || {}).symbol || currencySymbol || "";
+      var _val = new NumberToStringFormatter().format(data || 0, fractionArg);
+      var isNegativeNumber = _val.startsWith("-");
+      if (isNegativeNumber) {
+        _val = _val.replace("-", "");
+      }
+      return _val ? isNegativeNumber ? "-" + _currencySymbol + _val : _currencySymbol + _val : "";
+    }
+  }]);
+}();
+var StringToNumberFormatter = exports.StringToNumberFormatter = /*#__PURE__*/function () {
+  function StringToNumberFormatter() {
+    (0, _classCallCheck2["default"])(this, StringToNumberFormatter);
+  }
+  return (0, _createClass2["default"])(StringToNumberFormatter, [{
+    key: "format",
+    value: function format(input) {
+      return (0, _parseInt["default"])(input);
+    }
+  }]);
+}();
+var ToNumberFormatter = exports.ToNumberFormatter = /*#__PURE__*/function () {
+  function ToNumberFormatter() {
+    (0, _classCallCheck2["default"])(this, ToNumberFormatter);
+  }
+  return (0, _createClass2["default"])(ToNumberFormatter, [{
+    key: "format",
+    value: function format(data, fracSize) {
+      if (isNaN(+data)) {
+        return "";
+      }
+      var fractionFormat = fracSize;
+
+      // Handle fraction size format conversion
+      if (fracSize && !String(fracSize).match(/^(\d+)?\.((\d+)(-(\d+))?)?$/)) {
+        fractionFormat = "1." + fracSize + "-" + fracSize;
+      }
+      try {
+        // Parse fraction format if it's a string like "1.2-4"
+        var minimumFractionDigits = 0;
+        var maximumFractionDigits = 3;
+        if (typeof fractionFormat === "string" && fractionFormat.includes(".")) {
+          var parts = fractionFormat.split(".");
+          if (parts[1]) {
+            var fractionParts = parts[1].split("-");
+            minimumFractionDigits = (0, _parseInt["default"])(fractionParts[0]) || 0;
+            maximumFractionDigits = (0, _parseInt["default"])(fractionParts[1]) || minimumFractionDigits;
+          }
+        } else if (typeof fractionFormat === "number") {
+          minimumFractionDigits = maximumFractionDigits = fractionFormat;
+        }
+        var i18nService = _appstore["default"].I18nService.get();
+        var selectedLocale = i18nService.getSelectedLocale();
+        return new Intl.NumberFormat(selectedLocale, {
+          minimumFractionDigits: minimumFractionDigits,
+          maximumFractionDigits: maximumFractionDigits
+        }).format(+data);
+      } catch (error) {
+        // Fallback to simple number formatting
+        var num = +data;
+        if (typeof fracSize === "number") {
+          return num.toFixed(fracSize);
+        }
+        return num.toString();
+      }
+    }
+  }]);
+}();
+var TrailingZeroDecimalFormatter = exports.TrailingZeroDecimalFormatter = /*#__PURE__*/function () {
+  function TrailingZeroDecimalFormatter() {
+    (0, _classCallCheck2["default"])(this, TrailingZeroDecimalFormatter);
+  }
+  return (0, _createClass2["default"])(TrailingZeroDecimalFormatter, [{
+    key: "format",
+    value: function format(value, selectedLocale, numberFilter, localeFilter, trailingZero, decimalValue, skipTrailingZeroCheck, formattedLocale) {
+      var finalNumberFilter = trailingZero && !skipTrailingZeroCheck ? "1.".concat((decimalValue === null || decimalValue === void 0 ? void 0 : decimalValue.length) || 0, "-16") : numberFilter;
+      var locale = formattedLocale ? formattedLocale["number"] : undefined;
+      var finalLocale = localeFilter || locale || selectedLocale || "en";
+      try {
+        // Parse the number filter format
+        var minimumFractionDigits = 0;
+        var maximumFractionDigits = 3;
+        if (finalNumberFilter && typeof finalNumberFilter === "string" && finalNumberFilter.includes(".")) {
+          var parts = finalNumberFilter.split(".");
+          if (parts[1]) {
+            var fractionParts = parts[1].split("-");
+            minimumFractionDigits = (0, _parseInt["default"])(fractionParts[0]) || 0;
+            maximumFractionDigits = (0, _parseInt["default"])(fractionParts[1]) || minimumFractionDigits;
+          }
+        }
+        return new Intl.NumberFormat(finalLocale, {
+          minimumFractionDigits: minimumFractionDigits,
+          maximumFractionDigits: maximumFractionDigits
+        }).format(value);
+      } catch (error) {
+        // Fallback formatting
+        return value.toString();
+      }
+    }
+  }]);
+}();

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;