@sumaris-net/ngx-components 18.13.0 → 18.14.0

package/src/app/shared/functions.ts

@@ -0,0 +1,694 @@
+import * as cloneImported from 'clone';
+import { KeysEnum, KeyValueType } from './types';
+import { DEFAULT_JOIN_PROPERTIES_SEPARATOR } from './constants';
+import { RegExpUtils } from './regexps';
+import { unwrapESModule } from './modules';
+
+export function isNil<T>(obj: T | null | undefined): boolean {
+  return obj === undefined || obj === null;
+}
+export function isNilOrBlank<T>(obj: T | null | undefined): boolean {
+  return obj === undefined || obj === null || (typeof obj === 'string' && obj.trim() === '');
+}
+export function isNotNil<T>(obj: T | null | undefined): boolean {
+  return obj !== undefined && obj !== null;
+}
+export function isNotNilOrBlank<T>(obj: T | null | undefined): boolean {
+  return obj !== undefined && obj !== null && (typeof obj !== 'string' || obj.trim() !== '');
+}
+export function isNotNilOrNaN<T>(obj: T | null | undefined): boolean {
+  return obj !== undefined && obj !== null && (typeof obj !== 'number' || !isNaN(obj));
+}
+export function isNilOrNaN<T>(obj: T | null | undefined): boolean {
+  return obj === undefined || obj === null || (typeof obj === 'number' && isNaN(obj));
+}
+export function isNotEmptyArray<T>(obj: T[] | null | undefined): boolean {
+  return obj !== undefined && obj !== null && obj.length > 0;
+}
+export function firstArrayValue<T>(obj: T[] | null | undefined): T | undefined {
+  return isNotEmptyArray(obj) ? obj[0] : undefined;
+}
+export function lastArrayValue<T>(obj: T[] | null | undefined): T | undefined {
+  return isNotEmptyArray(obj) ? obj[obj.length - 1] : undefined;
+}
+export function isEmptyArray<T>(obj: T[] | null | undefined): boolean {
+  return obj === undefined || obj === null || !obj.length;
+}
+export function arrayResize<T>(array: T[] | null | undefined, size: number, defaultValue?: T): T[] {
+  if (size < 0) throw new Error("Argument 'size' must be a positive number");
+  if (!array) return newArray(size, defaultValue);
+
+  // Reduce size
+  if (array.length > size) {
+    return array.slice(0, size);
+  }
+  // Increase size
+  else if (array.length < size) {
+    return [...array, ...newArray(size - array.length, defaultValue)];
+  }
+
+  return array;
+}
+export function newArray<T>(size: number, defaultValue?: T): T[] {
+  if (size < 0) throw new Error("Argument 'size' must be a positive number");
+  return new Array(size).fill(defaultValue);
+}
+export function isNotNilBoolean(obj: any | null | undefined): obj is boolean {
+  return (obj !== undefined && obj !== null && typeof obj === 'boolean') || false;
+}
+export function isNotNilString(obj: any | null | undefined): obj is string {
+  return (obj !== undefined && obj !== null && typeof obj === 'string') || false;
+}
+export function isNotNilObject(obj: any | null | undefined): obj is object {
+  return (obj !== undefined && obj !== null && typeof obj === 'object') || false;
+}
+export function isBlankString(obj: any | null | undefined): obj is string {
+  return typeof obj === 'string' && obj.trim().length === 0;
+}
+export function notNilOrDefault<T>(obj: T | null | undefined, defaultValue: T): T {
+  return obj !== undefined && obj !== null ? obj : defaultValue;
+}
+export function arraySize<T>(obj: T[] | null | undefined): number {
+  return (isNotEmptyArray(obj) && obj.length) || 0;
+}
+
+/**
+ * Remove duplicated value, in array. Will compute a unique key (from given properties, or given function).
+ * If propertiesOrKeyFn is nil or undefined, will use all object properties
+ *
+ * @param values
+ * @param propertiesOrKeyFn
+ */
+export function arrayDistinct<T = any>(values: T[], propertiesOrKeyFn?: string | string[] | ((obj: T) => string)): T[] {
+  if (isEmptyArray(values)) return values;
+  const properties: string[] = (!propertiesOrKeyFn && Object.keys(values[0])) || (Array.isArray(propertiesOrKeyFn) && propertiesOrKeyFn);
+  const getKey: (obj: T) => string =
+    (typeof propertiesOrKeyFn === 'function' && propertiesOrKeyFn) ||
+    (typeof propertiesOrKeyFn === 'string' && ((obj) => getPropertyByPathAsString(obj, propertiesOrKeyFn))) ||
+    (isEmptyArray(properties) && ((obj) => obj?.toString())) ||
+    ((obj) => joinPropertiesPath(obj, properties, '|'));
+  const existingIds = new Set<string>();
+  return values.reduce((res, item) => {
+    const uniqueKey = getKey(item);
+    if (existingIds.has(uniqueKey)) return res; // Skip if duplicate
+    existingIds.add(uniqueKey);
+    return res.concat(item);
+  }, []);
+}
+export function nullIfUndefined<T>(obj: T | null | undefined): T | null {
+  return obj === undefined ? null : obj;
+}
+export function nullIfNilOrBlank<T>(obj: T | null | undefined): T | null {
+  return isNilOrBlank(obj) ? null : obj;
+}
+export function undefinedIfNull<T>(obj: T | null | undefined): T | undefined {
+  return obj === null ? undefined : obj;
+}
+export function trimEmptyToNull<T>(str: string | null | undefined): string | null {
+  const value = (str && str.trim()) || undefined;
+  return (value && value.length && value) || null;
+}
+export function toBoolean(obj: boolean | null | undefined | string, defaultValue?: boolean): boolean {
+  return obj !== undefined && obj !== null ? (obj !== 'false' ? !!obj : false) : defaultValue;
+}
+export function toNumber(obj: number | null | undefined | string, defaultValue?: number): number {
+  return isNotNilOrNaN(obj) ? +obj : defaultValue;
+}
+export function toFloat(obj: string | null | undefined, defaultValue?: number): number | null {
+  return obj !== undefined && obj !== null ? parseFloat(obj) : defaultValue;
+}
+export function toInt(obj: string | null | undefined, defaultValue?: number): number | null {
+  return obj !== undefined && obj !== null ? parseInt(obj, 0) : defaultValue;
+}
+export function toNotNil<T = any>(obj: T, defaultValue?: T): any | null {
+  return obj !== undefined && obj !== null ? obj : defaultValue;
+}
+export function removeDuplicatesFromArray<T>(obj: T[] | null | undefined, property?: string): T[] | null | undefined {
+  if (isEmptyArray(obj)) return obj;
+  if (property) {
+    return obj.filter((item, i, array) => array.findIndex((t) => t && item && t[property] === item[property]) === i);
+  }
+  return obj.filter((item, i, array) => array.findIndex((t) => t && item && t === item) === i);
+}
+
+export function startsWithUpperCase(input: string, search: string): boolean {
+  return input?.toUpperCase().startsWith(search) || false;
+}
+
+/**
+ * @deprecated Use Regexps.matchUpperCase instead
+ */
+export const matchUpperCase = RegExpUtils.matchUpperCase;
+
+/**
+ * Remove trailing slash if any. Examples :
+ * - '/test/' -> '/test'
+ * - '/' -> undefined
+ */
+export function noTrailingSlash(path: string): string {
+  if (!path || path.trim() === '/') return undefined;
+  if (path.trim().lastIndexOf('/') === path.length - 1) return path.substring(0, path.length - 1);
+  return path;
+}
+
+export function replaceAll(value: string, searchString: any, replacement): string | undefined {
+  while (value && value.indexOf(searchString) !== -1) {
+    value = value.replace(searchString, replacement);
+  }
+  return value;
+}
+
+export function escapeRegExp(value: string) {
+  // eslint-disable-next-line no-useless-escape
+  return value.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
+export function removeEnd(value: string, end: string): string {
+  return value?.endsWith(end || '') ? value.substr(0, value.length - end.length) : value;
+}
+
+/**
+ * Replace case change by an underscore (.e.g 'myString' becomes 'my_string')
+ *
+ * @param value
+ */
+export function changeCaseToUnderscore(value: string): string {
+  if (isNilOrBlank(value)) return value;
+  return value.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+}
+
+/**
+ * Replace underscore by a change case (.e.g 'MY_STRING' becomes 'MyString')
+ *
+ * @param value
+ */
+export function underscoreToChangeCase(value: string): string {
+  if (isNilOrBlank(value)) return value;
+  return value
+    .toLowerCase()
+    .split('_')
+    .filter(isNotNilOrBlank)
+    .map((str, index) => (index === 0 ? str : capitalizeFirstLetter(str)))
+    .join('');
+}
+
+export function removeDiacritics(text: string): string {
+  return text.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+}
+
+export function suggestFromStringArray(values: string[], searchText: any, opts?: { anySearch?: boolean }): string[] {
+  searchText = (typeof searchText === 'string' && searchText !== '*' && searchText) || undefined;
+  let cleanSearchText = RegExpUtils.cleanSearchText(searchText as string);
+  if (!cleanSearchText?.length) return values;
+
+  // If wildcard, search using regexp
+  if (opts?.anySearch || RegExpUtils.hasWildcardCharacter(cleanSearchText)) {
+    const regexp = RegExpUtils.compileSearchRegexp(cleanSearchText, 'gi');
+    return values.filter((v) => RegExpUtils.match(v, regexp));
+  } else {
+    // If no wildcard, search using startsWith
+    cleanSearchText = cleanSearchText.toUpperCase();
+    return values.filter((v) => startsWithUpperCase(v, cleanSearchText));
+  }
+}
+
+export function joinPropertiesPath<T = any>(obj: T, properties: string[], separator?: string): string | undefined {
+  if (!obj) throw new Error('Could not display an undefined entity.');
+  if (isEmptyArray(properties)) throw new Error("Missing or empty 'properties' argument");
+  return properties
+    .map((path) => getPropertyByPath(obj, path))
+    .filter(isNotNilOrBlank)
+    .join(separator || DEFAULT_JOIN_PROPERTIES_SEPARATOR);
+}
+
+export function joinProperties<T = any, K extends keyof T = any>(obj: T, keys: K[], separator?: string): string | undefined {
+  if (!obj) throw new Error('Could not display an undefined entity.');
+  return keys
+    .map((key) => getProperty(obj, key))
+    .filter(isNotNilOrBlank)
+    .join(separator || DEFAULT_JOIN_PROPERTIES_SEPARATOR);
+}
+
+export function propertyPathComparator<T = any>(path: string | string[]): (a: T, b: T) => number {
+  return (a: T, b: T) => {
+    const valueA = getPropertyByPath(a, path);
+    const valueB = getPropertyByPath(b, path);
+    return valueA === valueB ? 0 : valueA > valueB ? 1 : -1;
+  };
+}
+
+export function propertyComparator<T = any, K extends keyof T = any>(key: K, defaultValue?: any): (a: T, b: T) => number {
+  return (a: T, b: T) => {
+    const valueA = a[key] !== undefined ? a[key] : defaultValue;
+    const valueB = b[key] ? b[key] : defaultValue;
+    return valueA === valueB ? 0 : valueA > valueB ? 1 : -1;
+  };
+}
+
+export function propertiesPathComparator<T = any>(keys: string[], defaultValues?: any[]): (a: T, b: T) => number {
+  if (!keys || !keys.length || (defaultValues && keys.length > defaultValues.length)) {
+    throw new Error("Invalid arguments: missing 'keys' or array 'defaultValues' has a bad length");
+  }
+  return (a: T, b: T) =>
+    keys
+      .map((key, index) => {
+        const valueA = getPropertyByPath(a, key, defaultValues && defaultValues[index]);
+        const valueB = getPropertyByPath(b, key, defaultValues && defaultValues[index]);
+        return valueA === valueB ? 0 : valueA > valueB ? 1 : -1;
+      })
+      // Stop if not equals, otherwise continue with the next key
+      .find((res) => res !== 0) || 0;
+}
+
+export function sort<T>(array: T[], attribute?: string, opts?: Intl.CollatorOptions): T[] {
+  if (isEmptyArray(array)) return array;
+  const compareFn: (a: any, b: any) => number = opts ? new Intl.Collator(undefined, opts).compare : (v1, v2) => (v1 === v2 ? 0 : v1 > v2 ? 1 : -1);
+  return array
+    .slice() // copy
+    .sort(attribute ? (a, b) => compareFn(a[attribute], b[attribute]) : compareFn);
+}
+const INTEGER_REGEXP = /^[-]?\d+$/;
+export function isInt(value: string): boolean {
+  return isNotNil(value) && INTEGER_REGEXP.test(value);
+}
+const NUMBER_REGEXP = /^[-]?\d+(\.\d+)?$/;
+export function isNumber(value: string): boolean {
+  return isNotNil(value) && NUMBER_REGEXP.test(value);
+}
+
+const NUMBER_RANGE_REGEXP = /^(\d+-\d+)|([><=]*\d+)$/;
+export function isNumberRange(value: string): boolean {
+  return isNotNil(value) && NUMBER_RANGE_REGEXP.test(value);
+}
+
+export function getPropertyByPath(obj: any, path: string | Array<string | number>, defaultValue?: any): any {
+  if (isNil(obj)) return defaultValue;
+  // Path is an array: convert path to string
+  if (Array.isArray(path)) {
+    return getPropertyByPath(obj, path.join('.'), defaultValue);
+  }
+  if (isNilOrBlank(path)) return obj;
+  if (path.indexOf('[') !== -1) {
+    path = path.replace(/[.]?\[([^\[\]]*)]([.])?/, '.$1$2');
+  }
+  const i = path.indexOf('.');
+  // Simple property path
+  if (i === -1) {
+    const res = obj[path];
+    return isNotNil(res) || isNil(defaultValue) ? res : defaultValue;
+  }
+  // Complex property path
+  const optional = path.charAt(i - 1) === '?';
+  const key = path.substring(0, optional ? i - 1 : i);
+  if (isNil(obj[key])) return defaultValue;
+  if (typeof obj[key] === 'object') {
+    // Object or Array
+    // Recursive call
+    return getPropertyByPath(obj[key], path.substring(i + 1));
+  }
+  if (optional) return defaultValue;
+  throw new Error(`Invalid property path: '${key}' is not an valid object.`);
+}
+
+export function getProperty<T = any, K extends keyof T = any>(obj: T, key: K): T[K] {
+  if (isNil(obj)) return undefined;
+  return obj[key]; // Inferred type is T[K]
+}
+
+export function getPropertyByPathAsString(obj: any, path: string | string[], defaultValue?: string): string | undefined {
+  const res = getPropertyByPath(obj, path, defaultValue);
+  return typeof res === 'string' ? res : isNil(res) ? res : '' + res;
+}
+
+/**
+ * Update an object's property, using a path (like '<property_1>.<sub_property_1>')
+ * @param obj
+ * @param path
+ * @param value
+ * @return the given obj
+ */
+export function setPropertyByPath<T = any>(obj: T, path: string | string[], value: any): T {
+  // Path is an array: convert path to string
+  if (Array.isArray(path)) {
+    return setPropertyByPath(obj, path.join('.'), value);
+  }
+  if (isNil(obj)) return obj; // Skip
+  const i = path.indexOf('.');
+  // Simple property path
+  if (i === -1) {
+    obj[path] = value;
+    return obj;
+  }
+  const key = path.substring(0, i);
+  if (isNil(obj[key])) return undefined;
+  if (obj[key] && typeof obj[key] === 'object') {
+    return setPropertyByPath(obj[key], path.substring(i + 1), value);
+  }
+  throw new Error(`Invalid form path: '${key}' is not an valid object.`);
+}
+
+export function sleep(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function isPromise<T>(value: T | Promise<T>): value is Promise<T> {
+  return typeof value?.['then'] === 'function' && typeof value?.['catch'] === 'function';
+}
+
+/**
+ * Rounds a numeric value to two decimal places.
+ *
+ * @param {number | undefined | null} value - The value to be rounded. Can be a number, undefined, or null.
+ * @param nbDecimal the number of decimal (default: 2)
+ * @return {number} The rounded value with two decimal places if the input value is a valid number; otherwise, returns the input value.
+ */
+export function round(value: number | undefined | null, nbDecimal?: number): number {
+  if (isNotNilOrNaN(+value)) {
+    nbDecimal = nbDecimal ?? 2;
+    const factor = Math.pow(10, nbDecimal);
+    return Math.round((+value + Number.EPSILON) * factor) / factor;
+  }
+  return value;
+}
+
+export function equalsOrNil(value1: any, value2: any) {
+  return value1 === value2 || (isNil(value1) && isNil(value2));
+}
+
+/**
+ * remove elements from an array
+ *
+ * @return the removed elements
+ * @param array the array on which elements will be removed
+ * @param predicate the selection predicate
+ */
+export function removeAll<T>(array: T[], predicate: (value: T) => boolean): T[] {
+  let nbRemove = 0;
+  return array
+    .slice()
+    .map((value, index) => {
+      if (predicate(value)) {
+        nbRemove++; // glitch counter to avoid index gap
+        return array.splice(index - nbRemove + 1, 1)[0];
+      }
+      return null;
+    })
+    .filter(isNotNil);
+}
+
+/**
+ * remove the first element from an array
+ *
+ * @return the removed element
+ * @param array the array on which the element will be removed
+ * @param predicate the selection predicate
+ */
+export function remove<T>(array: T[], predicate: (value: T) => boolean): T {
+  return array.slice().find((value, index) => {
+    if (predicate(value)) {
+      array.splice(index, 1);
+      return true;
+    }
+    return false;
+  });
+}
+
+export function capitalizeFirstLetter(value: string) {
+  if (!value || value.length === 0) return value;
+  return value.charAt(0).toUpperCase() + value.substring(1);
+}
+export function uncapitalizeFirstLetter(value: string) {
+  if (!value || value.length === 0) return value;
+  return value.charAt(0).toLowerCase() + value.substring(1);
+}
+export function booleanToString(value: any, opts: { yesLabel: string; noLabel: string } = { yesLabel: 'COMMON.YES', noLabel: 'COMMON.NO' }) {
+  if (isNil(value)) return undefined;
+  return value === 1 || value === true || value === 'true' ? opts.yesLabel : opts.noLabel;
+}
+
+export function splitByProperty<T, M extends KeyValueType<T> = KeyValueType<T>>(array: T[] | readonly T[], propertyName: keyof T | string): M {
+  return (array || []).reduce((res, value) => {
+    const key = (value as unknown as any)?.[propertyName];
+    if (isNotNil(key)) {
+      res[key] = value;
+    }
+    return res;
+  }, {}) as M;
+}
+
+export function splitById<T, M extends KeyValueType<T> = KeyValueType<T>>(array: T[] | readonly T[]): M {
+  return (array || []).reduce(
+    (res, value) => {
+      const key = value?.['id'];
+      if (isNotNil(key)) {
+        res[key] = value;
+      }
+      return res;
+    },
+    <M>{}
+  );
+}
+
+/**
+ * Split an array, into a map of array, group by property
+ */
+export function collectByProperty<T>(values: T[], propertyName: keyof T): KeyValueType<T[]> {
+  return (values || []).reduce(
+    (res, item) => {
+      const key = item && item[propertyName];
+      if (typeof key === 'number' || typeof key === 'string') {
+        res[key] = res[key] || [];
+        res[key].push(item);
+      }
+      return res;
+    },
+    <KeyValueType<T[]>>{}
+  );
+}
+
+/**
+ * Split an array into chunks with fixed size
+ */
+export function splitArrayInChunks<T = any>(value: T[], chunkSize: number): T[][] {
+  if (!value?.length) return [];
+  if (chunkSize === -1) return [value]; // Only one page
+  if (!chunkSize || isNaN(chunkSize) || chunkSize < 1) {
+    throw '[splitArrayInChunks] Number of row must be a positive number !';
+  }
+  if (value.length <= chunkSize) {
+    return [value];
+  }
+  let length = Math.round(value.length / chunkSize + 0.5);
+  if (value.length === (length - 1) * chunkSize) {
+    length = length - 1;
+  }
+  const result = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const start = i * chunkSize;
+    const end = Math.min(value.length, start + chunkSize);
+    result[i] = value.slice(start, end);
+  }
+  return result;
+}
+
+/**
+ * Determines if two objects or two values are equivalent.
+ *
+ * Two objects or values are considered equivalent if at least one of the following is true:
+ *
+ * * Both objects or values pass `===` comparison.
+ * * Both objects or values are of the same type and all of their properties are equal by
+ *   comparing them with `equals`.
+ *
+ * @param o1 Object or value to compare.
+ * @param o2 Object or value to compare.
+ * @returns true if arguments are equal.
+ */
+export function equals(o1: any, o2: any): boolean {
+  if (o1 === o2) return true;
+  if (o1 === null || o2 === null) return false;
+  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
+  const t1 = typeof o1;
+  const t2 = typeof o2;
+  let length: number;
+  let key: any;
+  let keySet: any;
+  if (t1 === t2 && t1 === 'object') {
+    if (Array.isArray(o1)) {
+      if (!Array.isArray(o2)) return false;
+      if ((length = o1.length) === o2.length) {
+        for (key = 0; key < length; key++) {
+          if (!equals(o1[key], o2[key])) return false;
+        }
+        return true;
+      }
+    } else {
+      if (Array.isArray(o2)) {
+        return false;
+      }
+      keySet = Object.create(null);
+      // eslint-disable-next-line guard-for-in
+      for (key in o1) {
+        if (!equals(o1[key], o2[key])) {
+          return false;
+        }
+        keySet[key] = true;
+      }
+      for (key in o2) {
+        if (!(key in keySet) && typeof o2[key] !== 'undefined') {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+const _clone = unwrapESModule<typeof cloneImported>(cloneImported);
+
+// @dynamic
+export class Beans {
+  /**
+   * Deep clone.
+   * See https://github.com/pvorb/clone
+   */
+  static clone = _clone;
+
+  /**
+   * Copy a source object, by including only properties of the given dataType.
+   * IMPORTANT: extra properties that are NOT in the targetClass are NOT copied.
+   *
+   * @param source The source object to copy
+   * @param dataType the class to use as target class
+   * @param keys The keys to copy. If empty, will copy only NOT optional properties from the dataType
+   */
+  static copy<T>(source: T, dataType: new () => T, keys?: KeysEnum<T>): T {
+    if (isNil(source)) return source;
+    const target = new dataType();
+    Object.keys(keys || target).forEach((key) => {
+      target[key] = source[key];
+    });
+    return target;
+  }
+
+  /**
+   * Says if an object all all properties to nil
+   */
+  static isEmpty<T>(
+    data: T,
+    keys?: KeysEnum<T> | string[],
+    opts?: {
+      blankStringLikeEmpty?: boolean;
+    }
+  ): boolean {
+    return (
+      isNil(data) ||
+      (Array.isArray(keys) ? keys : Object.keys(keys || data))
+        // Find index of the first NOT nil value
+        .findIndex((key) => {
+          const value = data[key];
+          if (value && typeof value === 'object') return !Beans.isEmpty(value, null, opts); // Loop
+          if (opts && opts.blankStringLikeEmpty === true && typeof value === 'string') return isNotNilOrBlank(value);
+          return isNotNil(value);
+        }) === -1
+    );
+  }
+
+  static collectById<T>(array: T[]): KeyValueType<T[]> {
+    return collectByProperty(array, 'id' as keyof T);
+  }
+
+  static collectByProperty = collectByProperty;
+}
+
+export function findParentWithClass(elem: HTMLElement, className: string): HTMLElement {
+  if (!className) return undefined;
+  let currentElement = elem?.parentElement;
+  while (currentElement) {
+    if (currentElement.classList.contains(className)) return currentElement;
+    currentElement = currentElement.parentElement;
+  }
+  return undefined;
+}
+
+export function intersectArrays<T = any>(values: T[][]): T[] {
+  if (isEmptyArray(values)) return [];
+
+  // Utilise la méthode reduce pour obtenir l'intersection des tableaux
+  return values.reduce((acc, curr) => acc.filter((x) => curr.includes(x)), values[0].slice());
+}
+
+export function noHtml(value: string): string {
+  if (value && typeof value === 'string') {
+    // Use regular expression to remove all HTML tags
+    return value.replace(/<[^>]*>.*?<\/[^>]*>|<[^>]+>/g, '');
+  } else {
+    return value;
+  }
+}
+
+/**
+ * Interpolates a string by replacing placeholders with corresponding values from the provided object.
+ *
+ * @param {string} message - The string containing placeholders enclosed in double curly braces (e.g., {{key}}).
+ * @param {Record<string, any>} interpolateParams - An object containing key-value pairs for interpolation.
+ * @return {string} The interpolated string with placeholders replaced by corresponding values, or the original string if no placeholders are matched.
+ */
+export function interpolateString(message: string, interpolateParams: Record<string, any>): string {
+  if (isNilOrBlank(message)) return message;
+
+  return message.replace(/{{([^}]+)}}/g, (match: string, path: string) => {
+    try {
+      const paramValue = getPropertyByPathAsString(interpolateParams, path.trim());
+      return paramValue || '';
+    } catch (e) {
+      console.error(`Unable to bind an expression:\n\t- message: ${message}\n\t- expression: ${match}`);
+      return match;
+    }
+  });
+}
+
+/**
+ *
+ * Transforms a value (typically a string) to a number.
+ * Intended to be used as a transform function of an input.
+ * Should return n=undefined when for a nil input
+ * @param value Value to be transformed.
+ * @param fallbackValue Value to use if the provided value can't be parsed as a number.
+ *
+ *  @usageNotes
+ *  ```ts
+ *  @Input({ transform: numberAttribute }) id!: number;
+ *  ```
+ *
+ * @publicApi
+ */
+export function numberOrNilAttribute(value: unknown, fallbackValue = NaN): number | undefined | null {
+  if (value === undefined || value === null) return value as undefined | null;
+  // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,
+  // and other non-number values as NaN, where Number just uses 0) but it considers the string
+  // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.
+  const isNumberValue = !isNaN(parseFloat(value as any)) && !isNaN(Number(value));
+  return isNumberValue ? Number(value) : fallbackValue;
+}
+
+/**
+ * Formats a given number according to the specified options.
+ *
+ * @param {number} val - The number to be formatted.
+ * @param {Intl.NumberFormatOptions & { fixedDecimals?: number }} [opts] - An optional object containing formatting options. It can include standard `Intl.NumberFormatOptions` properties and an additional `fixedDecimals` property to specify the number of fixed decimal places.
+ * @return {string} The formatted number as a string, based on the provided options.
+ */
+export function numberToString(val: number, opts?: Intl.NumberFormatOptions & { fixedDecimals?: number }): string {
+  // Format the output to display any way you want here.
+  if (val !== undefined && val !== null && !isNaN(val)) {
+    if (opts?.fixedDecimals) {
+      return val.toFixed(opts.fixedDecimals);
+    }
+    return val.toLocaleString(undefined, opts);
+  } else {
+    return '';
+  }
+}