@instadapp/avocado-base 0.2.2 → 0.2.4

package/utils/formatter.ts

@@ -1,94 +1,88 @@
 export function formatPercent(
   value?: number | string,
   fractionDigits = 2,
-  maxValue = null
+  maxValue = null,
 ) {
-  if (!value || isZero(value)) return "0.00%";
+  if (!value || isZero(value))
+    return '0.00%'
 
-  const valueAsNumber = toBN(value).toNumber();
+  const valueAsNumber = toBN(value).toNumber()
 
-  if (maxValue && gt(times(valueAsNumber, "100"), maxValue))
-    return `>${maxValue}%`;
+  if (maxValue && gt(times(valueAsNumber, '100'), maxValue))
+    return `>${maxValue}%`
 
-  const formatter = new Intl.NumberFormat("en-US", {
-    style: "percent",
+  const formatter = new Intl.NumberFormat('en-US', {
+    style: 'percent',
     minimumFractionDigits: fractionDigits,
     maximumFractionDigits: fractionDigits,
-  });
+  })
 
-  return formatter.format(valueAsNumber);
+  return formatter.format(valueAsNumber)
 }
 
 export function shortenHash(hash: string | `0x${string}`, length: number = 4) {
-  if (!hash) return;
-  if (hash.length < 12) return hash;
-  const beginningChars = hash.startsWith("0x") ? length + 2 : length;
-  const shortened =
-    hash.substr(0, beginningChars) + "..." + hash.substr(-length);
-  return shortened;
+  if (!hash)
+    return
+  if (hash.length < 12)
+    return hash
+  const beginningChars = hash.startsWith('0x') ? length + 2 : length
+  const shortened
+    = `${hash.substr(0, beginningChars)}...${hash.substr(-length)}`
+  return shortened
 }
 
 export function formatUsd(value: any, fractionDigits = 2) {
-  const formatter = new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: "USD",
+  const formatter = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
     minimumFractionDigits: fractionDigits,
     maximumFractionDigits: fractionDigits,
-  });
+  })
 
-  return formatter.format(value);
+  return formatter.format(value)
 }
 
 export function signedNumber(numb: string | number) {
-  return new Intl.NumberFormat("en-US", {
-    signDisplay: "exceptZero",
-  }).format(toBN(numb).toNumber());
-}
-
-function getFractionDigits(value: string | number) {
-  const absoluteValue = toBN(value).abs();
-
-  if (isZero(absoluteValue)) {
-    return 2;
-  } else if (lt(absoluteValue, 0.01)) {
-    return 6;
-  } else if (lt(absoluteValue, 1)) {
-    return 4;
-  } else if (lt(absoluteValue, 10000)) {
-    return 2;
-  } else {
-    return 0;
-  }
+  return new Intl.NumberFormat('en-US', {
+    signDisplay: 'exceptZero',
+  }).format(toBN(numb).toNumber())
 }
 
 export function formatDecimal(value: string | number, fractionDigits?: number) {
   if (!value) {
-    value = "0";
+    value = '0'
+  }
+  if (lt(value, '0.0001') && gt(value, '0')) {
+    return '< 0.0001'
   }
-  if (lt(value, "0.0001") && gt(value, "0")) {
-    return "< 0.0001";
-  } else {
-    const num = toBN(value);
-    let decimals;
+  else {
+    const num = toBN(value)
+    let decimals
 
     if (num.lt(1)) {
-      decimals = 4;
-    } else if (num.lt(10)) {
-      decimals = 6;
-    } else if (num.lt(100)) {
-      decimals = 4;
-    } else if (num.lt(1000)) {
-      decimals = 3;
-    } else if (num.lt(10000)) {
-      decimals = 2;
-    } else if (num.lt(100000)) {
-      decimals = 1;
-    } else {
-      decimals = 0;
+      decimals = 4
+    }
+    else if (num.lt(10)) {
+      decimals = 6
+    }
+    else if (num.lt(100)) {
+      decimals = 4
+    }
+    else if (num.lt(1000)) {
+      decimals = 3
+    }
+    else if (num.lt(10000)) {
+      decimals = 2
+    }
+    else if (num.lt(100000)) {
+      decimals = 1
+    }
+    else {
+      decimals = 0
     }
 
-    const formattedNumber = num.toFixed(fractionDigits || decimals);
+    const formattedNumber = num.toFixed(fractionDigits || decimals)
 
-    return toBN(formattedNumber).toFormat();
+    return toBN(formattedNumber).toFormat()
   }
 }

package/utils/helper.ts

@@ -1,62 +1,65 @@
-export const indexSorter = (aIndex: number, bIndex: number) => {
+export function indexSorter(aIndex: number, bIndex: number) {
   if (aIndex === -1 && bIndex === -1) {
-    return 0; // fallback to other sorting criteria
-  } else if (aIndex === -1) {
-    return 1; // b comes first if a is not in the priority list
-  } else if (bIndex === -1) {
-    return -1; // a comes first if b is not in the priority list
-  } else {
-    return aIndex - bIndex; // sort by the index in the priority list
+    return 0 // fallback to other sorting criteria
   }
-};
+  else if (aIndex === -1) {
+    return 1 // b comes first if a is not in the priority list
+  }
+  else if (bIndex === -1) {
+    return -1 // a comes first if b is not in the priority list
+  }
+  else {
+    return aIndex - bIndex // sort by the index in the priority list
+  }
+}
 
 export function sortByMany<T>(
   items: T[],
-  callback: ((a: T, b: T) => number)[]
+  callback: ((a: T, b: T) => number)[],
 ) {
-  return items.sort(function (a, b) {
-    var result = 0;
-    for (var i = 0; i < callback.length; i++) {
-      var func = callback[i];
-      result = func(a, b);
+  return items.sort((a, b) => {
+    let result = 0
+    for (let i = 0; i < callback.length; i++) {
+      const func = callback[i]
+      result = func(a, b)
       if (result !== 0) {
-        break;
+        break
       }
     }
-    return result;
-  });
+    return result
+  })
 }
 
 export function cloneDeep<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value));
+  return JSON.parse(JSON.stringify(value))
 }
 
 export function filterArray(array: any, filters: any) {
-  const filterKeys = Object.keys(filters);
+  const filterKeys = Object.keys(filters)
   return array.filter((item: any) => {
     // validates all filter criteria
     return filterKeys.every((key) => {
       // ignores non-function predicates
-      if (typeof filters[key] !== "function") return true;
-      return filters[key](item[key], item);
-    });
-  });
+      if (typeof filters[key] !== 'function')
+        return true
+      return filters[key](item[key], item)
+    })
+  })
 }
 
 export function onImageError(this: HTMLImageElement) {
-  const parentElement = this.parentElement;
-  this.onerror = null;
-  this.remove();
+  const parentElement = this.parentElement
+  this.onerror = null
+  this.remove()
 
   if (parentElement) {
-    parentElement.classList.add("bg-gray-300");
+    parentElement.classList.add('bg-gray-300')
   }
 }
 
 export function formatMultipleAddresses(addresses: string[], shorten = true) {
   const formatter = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' })
   const formattedString = formatter.format(addresses.map(i => shorten ? shortenHash(i) || '' : i))
-  
+
   return formattedString
 }
-