react-native-chatbot-ai 0.1.2 → 0.1.4

package/src/utils/prototype.ts

@@ -0,0 +1,185 @@
+class Prototype {
+  private static _instance: Prototype | null = null;
+
+  public static get instance() {
+    if (!Prototype._instance) {
+      Prototype._instance = new Prototype();
+    }
+
+    return Prototype._instance;
+  }
+
+  private constructor() {}
+
+  number = {
+    isNumeric: (n: any) => {
+      return !isNaN(parseFloat(n)) && isFinite(n);
+    },
+    isInteger: (i: any) => {
+      return this.number.isNumeric(i) && i % 1 === 0;
+    },
+    random: (min: number, max: number) =>
+      Math.floor(Math.random() * (max - min + 1) + min),
+    formatCurrency: (
+      value: string | number = 0,
+      options?: {
+        ignoreUnit?: boolean;
+        locale?: string;
+        comma?: string;
+        revert?: boolean;
+        unit?: string;
+        withSign?: boolean;
+        postfix?: string;
+        fixed?: number;
+      }
+    ) => {
+      const mValue =
+        typeof value === 'string' ? parseInt(value, 10) : value || 0;
+      const {
+        comma = ',',
+        ignoreUnit = false,
+        revert = false,
+        unit = '₫',
+        withSign = false,
+        postfix = '',
+        fixed = 0,
+      } = options || {};
+      const pattern = ignoreUnit ? '' : `${unit}`;
+      let withComma: string | number = Math.abs(mValue);
+      if (fixed >= 0) {
+        withComma = withComma.toFixed(fixed).replace('.', comma);
+      } else {
+        withComma = withComma.toString();
+      }
+      withComma = withComma?.replace?.(/\B(?=(\d{3})+(?!\d))/g, comma);
+      const sign = mValue === 0 ? '' : mValue < 0 ? '-' : withSign ? '+' : '';
+      const result = revert
+        ? `${withComma}${pattern}`
+        : `${pattern}${withComma}`;
+      return `${sign}${result}${postfix}`;
+    },
+    formatShortenedCurrency: (
+      amount: number | undefined,
+      isFullUnit = false,
+      fixed?: number
+    ) => {
+      if (!amount) {
+        return '0';
+      }
+      if (amount < 1e6) {
+        return this.number.formatCurrency(amount);
+      } else {
+        const billion = Math.floor((1e1 * amount) / 1e9) / 10;
+        const millionAmount = amount % 1e9;
+        const million = Math.round((1e2 * millionAmount) / 1e6) / 100;
+        return billion && billion >= 1
+          ? this.number.formatCurrency(billion, {
+              unit: ' ' + (!isFullUnit ? 'tỷ' : 'tỷ đồng'),
+              revert: true,
+              fixed,
+            })
+          : million
+            ? this.number.formatCurrency(million, {
+                unit: ' ' + (!isFullUnit ? 'triệu' : 'triệu đồng'),
+                revert: true,
+                fixed,
+              })
+            : '';
+      }
+    },
+    numberWithCommas(x: number | string = '', placeholder = '0') {
+      if (x === null || x === undefined) {
+        return placeholder;
+      }
+      const result = x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+      return result?.length > 0 ? result : placeholder;
+    },
+    clamp(num: number, min: number, max: number) {
+      return Math.min(Math.max(num, min), max);
+    },
+
+    stringToNumber(str: string, fallback: number = 0) {
+      const converted = str === '' ? fallback : Number(str);
+      // Remove all chars that not a number
+      const result = Number.isNaN(converted)
+        ? str.replace(/\D/g, '')
+        : converted;
+      const number = result === '' ? fallback : Number(result);
+      if (Number.isNaN(number)) {
+        return fallback;
+      }
+      return number;
+    },
+
+    formatShortened(
+      value: number | undefined,
+      roundingStrategy: 'floor' | 'round' = 'floor',
+      options?: {
+        ignoreUnit?: boolean;
+        unit?: string;
+        precisionValue?: number;
+        decimalSeparators?: '.' | ',';
+      }
+    ) {
+      const {
+        ignoreUnit = true,
+        unit = '₫',
+        precisionValue = 1,
+        decimalSeparators = '.',
+      } = options || {};
+
+      const BILLION = 1e9;
+      const MILLION = 1e6;
+      const THOUSAND = 1e3;
+
+      const format = (_value: number, precision = 0) => {
+        const multiplier = Math.pow(10, precision || 0);
+        const result = (
+          Math[roundingStrategy](_value * multiplier) / multiplier
+        )
+          .toString()
+          .replace(/\./g, decimalSeparators);
+        return !ignoreUnit ? `${unit}${result}` : result;
+      };
+
+      if (typeof value === 'number') {
+        if (value / BILLION >= 1) {
+          return `${format(value / BILLION, precisionValue)}B`;
+        }
+        if (value / MILLION >= 1) {
+          return `${format(value / MILLION, precisionValue)}M`;
+        }
+        if (value / THOUSAND >= 1) {
+          return `${format(value / THOUSAND, precisionValue)}K`;
+        }
+
+        return !ignoreUnit ? `${unit}${value}` : `${value}`;
+      }
+
+      return !ignoreUnit ? `${unit}${0}` : '0';
+    },
+    formatShortenedVN(value: number | undefined) {
+      const MILLION = 1e6;
+      const THOUSAND = 1e3;
+
+      if (typeof value === 'number') {
+        if (value / MILLION >= 1) {
+          return this.formatCurrency(Number((value / MILLION).toFixed(2)), {
+            postfix: 'tr',
+            fixed: -1,
+          });
+        }
+        if (value / THOUSAND >= 1) {
+          return this.formatCurrency(Number((value / THOUSAND).toFixed(1)), {
+            postfix: 'K',
+            fixed: -1,
+          });
+        }
+        return this.formatCurrency(value);
+      }
+      return 0;
+    },
+  };
+}
+
+export const PTManager = Prototype.instance;