@swapkit/helpers 1.0.0-rc.3 → 1.0.0-rc.30

package/src/modules/bigIntArithmetics.ts

@@ -1,3 +1,5 @@
+import { BaseDecimal } from '@swapkit/types';
+
 import type { SwapKitNumber } from './swapKitNumber.ts';
 
 type NumberPrimitivesType = {
@@ -5,7 +7,7 @@ type NumberPrimitivesType = {
   number: number;
   string: string;
 };
-type NumberPrimitives = bigint | number | string;
+export type NumberPrimitives = bigint | number | string;
 type InitialisationValueType = NumberPrimitives | BigIntArithmetics | SwapKitNumber;
 
 type SKBigIntParams = InitialisationValueType | { decimal?: number; value: number | string };
@@ -69,12 +71,12 @@ export class BigIntArithmetics {
     from,
     to,
   }: {
-    value: InitialisationValueType;
+    value: InstanceType<typeof SwapKitNumber>;
     from: number;
     to: number;
   }) {
-    return BigIntArithmetics.fromBigInt(
-      (new BigIntArithmetics(value).bigIntValue * toMultiplier(to)) / toMultiplier(from),
+    return this.fromBigInt(
+      (value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from),
       to,
     );
   }
@@ -85,22 +87,12 @@ export class BigIntArithmetics {
 
     // use the multiplier to keep track of decimal point - defaults to 8 if lower than 8
     this.decimalMultiplier = toMultiplier(
-      Math.max(this.#getFloatDecimals(this.#toSafeValue(value)), this.decimal || 0),
+      Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0),
     );
     this.#setValue(value);
   }
 
-  get baseValue() {
-    return this.getBaseValue('string') as string;
-  }
-  get baseValueNumber() {
-    return this.getBaseValue('number') as number;
-  }
-  get baseValueBigInt() {
-    return this.getBaseValue('bigint') as bigint;
-  }
-
-  set(value: SKBigIntParams) {
+  set(value: SKBigIntParams): this {
     // @ts-expect-error False positive
     return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
   }
@@ -132,7 +124,7 @@ export class BigIntArithmetics {
     return this.bigIntValue === this.getBigIntValue(value);
   }
 
-  getValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T] {
+  getValue<T extends 'number' | 'string'>(type: T): NumberPrimitivesType[T] {
     const value = this.formatBigIntToSafeValue(
       this.bigIntValue,
       this.decimal || decimalFromMultiplier(this.decimalMultiplier),
@@ -147,12 +139,12 @@ export class BigIntArithmetics {
         return value;
       default:
         // @ts-expect-error False positive
-        return this.bigIntValue;
+        return (this.bigIntValue * BigInt(this.decimal || 8n)) / this.decimalMultiplier;
     }
   }
 
   getBaseValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T] {
-    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || 0);
+    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || BaseDecimal.THOR);
     const baseValue = this.bigIntValue / divisor;
 
     switch (type) {
@@ -164,14 +156,18 @@ export class BigIntArithmetics {
         return baseValue.toString();
       default:
         // @ts-expect-error False positive
-        return this.bigIntValue;
+        return baseValue;
     }
   }
 
   getBigIntValue(value: InitialisationValueType, decimal?: number) {
     if (!decimal && typeof value === 'object') return value.bigIntValue;
 
-    return this.#toBigInt(this.#toSafeValue(getStringValue(value)), decimal);
+    const stringValue = getStringValue(value);
+    const safeValue = toSafeValue(stringValue);
+
+    if (safeValue === '0' || safeValue === 'undefined') return 0n;
+    return this.#toBigInt(safeValue, decimal);
   }
 
   formatBigIntToSafeValue(value: bigint, decimal?: number) {
@@ -223,7 +219,7 @@ export class BigIntArithmetics {
 
     if (parseInt(integer)) {
       return `${integer}.${decimal.slice(0, significantDigits - integer.length)}`.padEnd(
-        valueLength - significantDigits,
+        significantDigits - integer.length,
         '0',
       );
     }
@@ -237,6 +233,63 @@ export class BigIntArithmetics {
     )}`;
   }
 
+  toFixed(fixedDigits: number = 6) {
+    const [int, dec] = this.getValue('string').split('.');
+    const integer = int || '';
+    const decimal = dec || '';
+
+    if (parseInt(integer)) {
+      return `${integer}.${decimal.slice(0, fixedDigits)}`.padEnd(fixedDigits, '0');
+    }
+
+    const trimmedDecimal = parseInt(decimal);
+    const slicedDecimal = `${trimmedDecimal}`.slice(0, fixedDigits);
+
+    return `0.${slicedDecimal.padStart(
+      decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
+      '0',
+    )}`;
+  }
+
+  toAbbreviation(digits = 2) {
+    const value = this.getValue('number');
+    const abbreviations = ['', 'K', 'M', 'B', 'T', 'Q', 'Qi', 'S'];
+    const tier = Math.floor(Math.log10(Math.abs(value)) / 3);
+    const suffix = abbreviations[tier];
+
+    if (!suffix) return this.getValue('string');
+
+    const scale = 10 ** (tier * 3);
+    const scaled = value / scale;
+
+    return `${scaled.toFixed(digits)}${suffix}`;
+  }
+
+  toCurrency(
+    currency = '$',
+    {
+      currencyPosition = 'start',
+      decimal = 2,
+      decimalSeparator = '.',
+      thousandSeparator = ',',
+    } = {},
+  ) {
+    const value = this.getValue('number');
+    const [int, dec = ''] = value.toFixed(6).split('.');
+    const integer = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+
+    const parsedValue =
+      !int && !dec
+        ? '0.00'
+        : int === '0'
+        ? `${parseFloat(`0.${dec}`)}`.replace('.', decimalSeparator)
+        : `${integer}${parseInt(dec) ? `${decimalSeparator}${dec.slice(0, decimal)}` : ''}`;
+
+    return `${currencyPosition === 'start' ? currency : ''}${parsedValue}${
+      currencyPosition === 'end' ? currency : ''
+    }`;
+  }
+
   #arithmetics(method: 'add' | 'sub' | 'mul' | 'div', ...args: InitialisationValueType[]): this {
     const precisionDecimal = this.#retrievePrecisionDecimal(this, ...args);
     const precisionDecimalMultiplier = toMultiplier(precisionDecimal);
@@ -283,7 +336,7 @@ export class BigIntArithmetics {
   }
 
   #setValue(value: InitialisationValueType) {
-    const safeValue = this.#toSafeValue(value) || '0';
+    const safeValue = toSafeValue(value) || '0';
     this.bigIntValue = this.#toBigInt(safeValue);
   }
 
@@ -292,7 +345,7 @@ export class BigIntArithmetics {
       .map((arg) =>
         typeof arg === 'object'
           ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier)
-          : this.#getFloatDecimals(this.#toSafeValue(arg)),
+          : getFloatDecimals(toSafeValue(arg)),
       )
       .filter(Boolean) as number[];
     return Math.max(...decimals, DEFAULT_DECIMAL);
@@ -301,37 +354,36 @@ export class BigIntArithmetics {
   #toBigInt(value: string, decimal?: number) {
     const multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
     const padDecimal = decimalFromMultiplier(multiplier);
-    const [integerPart, decimalPart = ''] = value.split('.');
+    const [integerPart = '', decimalPart = ''] = value.split('.');
 
     return BigInt(`${integerPart}${decimalPart.padEnd(padDecimal, '0')}`);
   }
+}
 
-  #toSafeValue(value: InitialisationValueType) {
-    const parsedValue =
-      typeof value === 'number'
-        ? Number(value).toLocaleString('fullwide', {
-            useGrouping: false,
-            maximumFractionDigits: 20,
-          })
-        : getStringValue(value);
-
-    const splitValue = `${parsedValue}`.replaceAll(',', '.').split('.');
-
-    return splitValue.length > 1
-      ? `${splitValue.slice(0, -1).join('')}.${splitValue.at(-1)}`
-      : splitValue[0];
-  }
+const numberFormatter = Intl.NumberFormat('fullwide', {
+  useGrouping: false,
+  maximumFractionDigits: 20,
+});
 
-  #getFloatDecimals(value: string) {
-    const decimals = value.split('.')[1]?.length || 0;
-    return Math.max(decimals, DEFAULT_DECIMAL);
-  }
+function toSafeValue(value: InitialisationValueType) {
+  const parsedValue =
+    typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
+  const splitValue = `${parsedValue}`.replaceAll(',', '.').split('.');
+
+  return splitValue.length > 1
+    ? `${splitValue.slice(0, -1).join('')}.${splitValue.at(-1)}`
+    : splitValue[0];
+}
+
+function getFloatDecimals(value: string) {
+  const decimals = value.split('.')[1]?.length || 0;
+  return Math.max(decimals, DEFAULT_DECIMAL);
 }
 
-function getStringValue(value: SKBigIntParams) {
-  return typeof value === 'object'
-    ? 'getValue' in value
-      ? value.getValue('string')
-      : value.value
-    : value;
+function getStringValue(param: SKBigIntParams) {
+  return typeof param === 'object'
+    ? 'getValue' in param
+      ? param.getValue('string')
+      : param.value
+    : param;
 }

package/src/modules/swapKitNumber.ts

@@ -1,4 +1,4 @@
-import { BigIntArithmetics } from './bigIntArithmetics.ts';
+import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 
 export type SwapKitValueType = BigIntArithmetics | string | number;
 
@@ -6,4 +6,11 @@ export class SwapKitNumber extends BigIntArithmetics {
   eq(value: SwapKitValueType) {
     return this.eqValue(value);
   }
+
+  static fromBigInt(value: bigint, decimal?: number) {
+    return new SwapKitNumber({
+      decimal,
+      value: formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal }),
+    });
+  }
 }