@leather.io/utils 0.9.0

package/src/index.ts

@@ -0,0 +1,160 @@
+import { BigNumber } from 'bignumber.js';
+
+import { KEBAB_REGEX } from '@leather.io/constants';
+import type { NetworkModes } from '@leather.io/models';
+
+export { createCounter } from './counter';
+export * from './math';
+export * from './money';
+export * from './sort-assets';
+export * from './truncate-middle';
+export { spamFilter } from './spam-filter/spam-filter';
+export { extractPhraseFromString } from './extract-phrase-from-string/extract-phrase-from-string';
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number';
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+export function isBigInt(value: unknown): value is bigint {
+  return typeof value === 'bigint';
+}
+
+export function isUndefined(value: unknown): value is undefined {
+  return typeof value === 'undefined';
+}
+
+export function isFunction(value: unknown): value is () => void {
+  return typeof value === 'function';
+}
+
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}
+
+export function isObject(value: unknown): value is object {
+  return typeof value === 'object';
+}
+
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+export function isEmpty(value: object) {
+  return Object.keys(value).length === 0;
+}
+
+export function isDefined<T>(argument: T | undefined): argument is T {
+  return !isUndefined(argument);
+}
+
+export function isTypedArray(val: unknown): val is Uint8Array {
+  const TypedArray = Object.getPrototypeOf(Uint8Array);
+  return val instanceof TypedArray;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop() {}
+
+export function ensureArray<T>(value: T | T[]): T[] {
+  return Array.isArray(value) ? value : [value];
+}
+
+export function undefinedIfLengthZero<T extends any[]>(arr: T) {
+  return arr.length ? arr : undefined;
+}
+
+type NetworkMap<T> = Record<NetworkModes, T>;
+
+export function whenNetwork(mode: NetworkModes) {
+  return <T extends NetworkMap<unknown>>(networkMap: T) => networkMap[mode] as T[NetworkModes];
+}
+
+export function isEmptyArray(data: unknown[]) {
+  return data.length === 0;
+}
+
+export const defaultWalletKeyId = 'default' as const;
+
+export function reverseBytes(bytes: Buffer): Buffer;
+export function reverseBytes(bytes: Uint8Array): Uint8Array;
+export function reverseBytes(bytes: Buffer | Uint8Array) {
+  if (Buffer.isBuffer(bytes)) return Buffer.from(bytes).reverse();
+  return new Uint8Array(bytes.slice().reverse());
+}
+
+export function makeNumberRange(num: number) {
+  return [...Array(num).keys()];
+}
+
+export function createNumArrayOfRange(fromIndex: number, toIndex: number) {
+  const result = [];
+  for (let i = fromIndex; i <= toIndex; i++) {
+    result.push(i);
+  }
+  return result;
+}
+
+export async function delay(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export function sumNumbers(nums: number[]) {
+  return nums.reduce((acc, num) => acc.plus(num), new BigNumber(0));
+}
+
+export function isFulfilled<T>(p: PromiseSettledResult<T>): p is PromiseFulfilledResult<T> {
+  return p.status === 'fulfilled';
+}
+
+export function isRejected<T>(p: PromiseSettledResult<T>): p is PromiseRejectedResult {
+  return p.status === 'rejected';
+}
+
+export function getPrincipalFromContractId(identifier: string) {
+  return identifier.split('::')[0];
+}
+
+export function formatContractId(address: string, name: string) {
+  return `${address}.${name}`;
+}
+
+export function createNullArrayOfLength(length: number) {
+  return new Array(length).fill(null);
+}
+
+export function safelyFormatHexTxid(id: string) {
+  const prefix = '0x';
+  if (id.startsWith(prefix)) return id;
+  return prefix + id;
+}
+
+function kebabCase(str: string) {
+  return str.replace(KEBAB_REGEX, match => '-' + match.toLowerCase());
+}
+
+function getLetters(string: string, offset = 1) {
+  return string.slice(0, offset);
+}
+
+export function getTicker(value: string) {
+  let name = kebabCase(value);
+  if (name.includes('-')) {
+    const words = name.split('-');
+    if (words.length >= 3) {
+      name = `${getLetters(words[0])}${getLetters(words[1])}${getLetters(words[2])}`;
+    } else {
+      name = `${getLetters(words[0])}${getLetters(words[1], 2)}`;
+    }
+  } else if (name.length >= 3) {
+    name = `${getLetters(name, 3)}`;
+  }
+  return name.toUpperCase();
+}
+
+export function propIfDefined(prop: string, value: any) {
+  return isBoolean(value) ? { [prop]: value } : {};
+}

package/src/math/calculate-averages.spec.ts

@@ -0,0 +1,16 @@
+import BigNumber from 'bignumber.js';
+
+import { calculateMeanAverage } from './calculate-averages';
+
+describe(calculateMeanAverage.name, () => {
+  test('it calculates average of 0', () =>
+    expect(calculateMeanAverage([]).toString()).toEqual('0'));
+
+  test('it calculates averages of 1', () =>
+    expect(calculateMeanAverage([new BigNumber(1)]).toString()).toEqual('1'));
+
+  test('it calculates average of many numbers', () =>
+    expect(
+      calculateMeanAverage([new BigNumber(1), new BigNumber(2), new BigNumber(3)]).toString()
+    ).toEqual('2'));
+});

package/src/math/calculate-averages.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+
+import { initBigNumber } from './helpers';
+
+export function calculateMeanAverage(numbers: BigNumber[] | number[]) {
+  if (numbers.length === 0) return new BigNumber(0);
+  return numbers
+    .map(initBigNumber)
+    .reduce((acc, price) => acc.plus(price), new BigNumber(0))
+    .dividedBy(numbers.length);
+}

package/src/math/fibonacci.ts

@@ -0,0 +1,11 @@
+function fibonacci(n = 0): number {
+  if (n < 0) throw 'Cannot calculate from negative number';
+  if (n < 2) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+export function* fibonacciGenerator(startIndex = 0): IterableIterator<number> {
+  let index = startIndex;
+  while (index < Infinity) yield fibonacci(index++);
+  return Infinity;
+}

package/src/math/helpers.spec.ts

@@ -0,0 +1,26 @@
+import BigNumber from 'bignumber.js';
+
+import { sumNumbers } from './helpers';
+
+const cases = [
+  {
+    sums: [1, 2, 3],
+    expectedResult: new BigNumber(6),
+  },
+  {
+    sums: [0.1, 0.2],
+    expectedResult: new BigNumber(0.3),
+  },
+  {
+    sums: [Number.MAX_SAFE_INTEGER, 1],
+    expectedResult: new BigNumber('9007199254740992'),
+  },
+];
+
+describe(sumNumbers.name, () => {
+  describe.each(cases)('Sum example', ({ sums, expectedResult }) => {
+    test('sum of ' + sums.toString(), () => {
+      expect(sumNumbers(sums).toString()).toEqual(expectedResult.toString());
+    });
+  });
+});

package/src/math/helpers.ts

@@ -0,0 +1,32 @@
+import BigNumber from 'bignumber.js';
+
+import { isBigInt } from '..';
+
+export function initBigNumber(num: string | number | BigNumber | bigint) {
+  if (BigNumber.isBigNumber(num)) return num;
+  return isBigInt(num) ? new BigNumber(num.toString()) : new BigNumber(num);
+}
+
+export function sumNumbers(nums: number[]) {
+  return nums.reduce((acc, num) => acc.plus(num), new BigNumber(0));
+}
+
+function isMultipleOf(multiple: number) {
+  return (num: number) => num % multiple === 0;
+}
+
+export function isEven(num: number) {
+  return isMultipleOf(2)(num);
+}
+
+export function countDecimals(num: string | number | BigNumber) {
+  const LARGE_NUMBER_OF_DECIMALS = 100;
+  BigNumber.config({ DECIMAL_PLACES: LARGE_NUMBER_OF_DECIMALS });
+  const amount = initBigNumber(num);
+  const decimals = amount.toString(10).split('.')[1];
+  return decimals ? decimals.length : 0;
+}
+
+export function increaseValueByOneMicroStx(value: string | number | BigNumber) {
+  return new BigNumber(value).plus(0.000001).toNumber();
+}

package/src/math/index.ts

@@ -0,0 +1,3 @@
+export * from './calculate-averages';
+export * from './fibonacci';
+export * from './helpers';

package/src/money/calculate-money.spec.ts

@@ -0,0 +1,71 @@
+import BigNumber from 'bignumber.js';
+
+import { MarketData, createMarketData, createMarketPair } from '@leather.io/models';
+
+import {
+  baseCurrencyAmountInQuote,
+  convertAmountToFractionalUnit,
+  subtractMoney,
+  sumMoney,
+} from './calculate-money';
+import { createMoney, createMoneyFromDecimal } from './format-money';
+
+const tenMicroStx = createMoney(10, 'STX');
+const tenStx = createMoneyFromDecimal(10, 'STX');
+
+const tenBtc = createMoneyFromDecimal(10, 'BTC');
+
+const mockWrongMarketData = {
+  pair: createMarketPair('BTC' as any, 'USD'),
+  price: createMoneyFromDecimal(1, 'EUR' as any, 2),
+} as MarketData;
+
+const mockAccurateStxMarketData = createMarketData(
+  createMarketPair('STX', 'USD'),
+  createMoneyFromDecimal(0.3, 'USD')
+);
+
+describe(baseCurrencyAmountInQuote.name, () => {
+  test('it throw when passed mismatching currencies', () =>
+    expect(() => baseCurrencyAmountInQuote(tenMicroStx, mockWrongMarketData)).toThrowError());
+
+  test('it converts currency small amounts accurately', () => {
+    const result = baseCurrencyAmountInQuote(tenMicroStx, mockAccurateStxMarketData);
+    expect(result.amount.toString()).toEqual('0.0003');
+  });
+
+  test('it converts currency amounts accurately', () => {
+    const result = baseCurrencyAmountInQuote(tenStx, mockAccurateStxMarketData);
+    expect(result.amount.toString()).toEqual('300');
+  });
+});
+
+describe(convertAmountToFractionalUnit.name, () => {
+  test('it converts a small decimal amount to a fractional unit', () =>
+    expect(convertAmountToFractionalUnit(new BigNumber(1), 2).toNumber()).toEqual(100));
+
+  test('it converts 99 as decimal amount to a fractional unit', () =>
+    expect(convertAmountToFractionalUnit(new BigNumber(99), 6).toNumber()).toEqual(99000000));
+});
+
+describe(sumMoney.name, () => {
+  test('it sums two money objects', () => {
+    const result = sumMoney([tenMicroStx, tenMicroStx]);
+    expect(result.amount.toString()).toEqual('20');
+    expect(result.symbol).toEqual(tenMicroStx.symbol);
+  });
+  test('it throws error when summing different currencies', () => {
+    expect(() => sumMoney([tenMicroStx, tenBtc])).toThrowError();
+  });
+});
+
+describe(subtractMoney.name, () => {
+  test('it subtracts two money objects', () => {
+    const result = subtractMoney(tenMicroStx, tenMicroStx);
+    expect(result.amount.toString()).toEqual('0');
+    expect(result.symbol).toEqual(tenMicroStx.symbol);
+  });
+  test('it throws error when subtracting different currencies', () => {
+    expect(() => subtractMoney(tenMicroStx, tenBtc)).toThrowError();
+  });
+});

package/src/money/calculate-money.ts

@@ -0,0 +1,60 @@
+import { BigNumber } from 'bignumber.js';
+
+import type { MarketData, Money, NumType } from '@leather.io/models';
+import { formatMarketPair } from '@leather.io/models';
+
+import { isNumber } from '..';
+import { initBigNumber, sumNumbers } from '../math/helpers';
+import { createMoney, formatMoney } from './format-money';
+import { isMoney } from './is-money';
+
+export function baseCurrencyAmountInQuote(quantity: Money, { pair, price }: MarketData) {
+  if (quantity.symbol !== pair.base)
+    throw new Error(
+      `Cannot calculate value of ${formatMoney(quantity)} with market pair of ${formatMarketPair(
+        pair
+      )}`
+    );
+
+  return createMoney(
+    convertAmountToFractionalUnit(
+      convertAmountToBaseUnit(quantity).times(convertAmountToBaseUnit(price)),
+      price.decimals
+    ),
+    pair.quote
+  );
+}
+
+export function convertAmountToFractionalUnit(num: Money | BigNumber, decimals?: number) {
+  if (isMoney(num)) return num.amount.shiftedBy(num.decimals);
+  if (!isNumber(decimals)) throw new Error('Must define decimal of given currency');
+  return num.shiftedBy(decimals);
+}
+
+export function convertToMoneyTypeWithDefaultOfZero(
+  symbol: string,
+  num?: NumType,
+  decimals?: number
+) {
+  return createMoney(initBigNumber(num ?? 0), symbol.toUpperCase(), decimals);
+}
+
+// ts-unused-exports:disable-next-line
+export function convertAmountToBaseUnit(num: Money | BigNumber, decimals?: number) {
+  if (isMoney(num)) return num.amount.shiftedBy(-num.decimals);
+  if (!isNumber(decimals)) throw new Error('Must define decimal of given currency');
+  return num.shiftedBy(-decimals);
+}
+
+export function subtractMoney(xAmount: Money, yAmount: Money) {
+  if (xAmount.symbol !== yAmount.symbol) throw new Error('Cannot subtract different currencies');
+  return createMoney(xAmount.amount.minus(yAmount.amount), xAmount.symbol, xAmount.decimals);
+}
+
+export function sumMoney(moneysArr: Money[]) {
+  if (moneysArr.some(item => item.symbol !== moneysArr[0].symbol))
+    throw new Error('Cannot sum different currencies');
+
+  const sum = sumNumbers(moneysArr.map(item => item.amount.toNumber()));
+  return createMoney(sum, moneysArr[0].symbol, moneysArr[0].decimals);
+}

package/src/money/format-money.ts

@@ -0,0 +1,89 @@
+import BigNumber from 'bignumber.js';
+
+import { currencyDecimalsMap } from '@leather.io/constants';
+import type { Currencies, Money, NumType } from '@leather.io/models';
+
+import { isBigInt, isUndefined } from '..';
+
+type KnownCurrencyDecimals = keyof typeof currencyDecimalsMap;
+
+function isResolutionOfCurrencyKnown(symbol: Currencies): symbol is KnownCurrencyDecimals {
+  return symbol in currencyDecimalsMap;
+}
+
+function getDecimalsOfSymbolIfKnown(symbol: Currencies) {
+  if (isResolutionOfCurrencyKnown(symbol)) return currencyDecimalsMap[symbol];
+  return null;
+}
+
+function throwWhenDecimalUnknown(
+  symbol: Currencies,
+  decimals?: number
+): asserts decimals is number {
+  if (isUndefined(decimals) && isUndefined(getDecimalsOfSymbolIfKnown(symbol)))
+    throw new Error(`Resolution of currency ${symbol} is unknown, must be described`);
+}
+
+/**
+ * @param value Amount described in currency's primary unit
+ * @param symbol Identifying letter code, e.g. EUR
+ * @param resolution Optional, required if value not known at build-time
+ */
+export function createMoneyFromDecimal(
+  value: NumType,
+  symbol: Currencies,
+  resolution?: number
+): Money {
+  throwWhenDecimalUnknown(symbol, resolution);
+  const decimals = getDecimalsOfSymbolIfKnown(symbol) ?? resolution;
+  const amount = new BigNumber(isBigInt(value) ? value.toString() : value).shiftedBy(decimals);
+  return Object.freeze({ amount, symbol, decimals });
+}
+
+/**
+ * @param value Amount described in currency's fractional base unit, e.g. cents for USD amounts
+ * @param symbol Identifying letter code, e.g. EUR
+ * @param resolution Optional, required if value not known at build-time
+ */
+export function createMoney(value: NumType, symbol: Currencies, resolution?: number): Money {
+  throwWhenDecimalUnknown(symbol, resolution);
+  const decimals = getDecimalsOfSymbolIfKnown(symbol) ?? resolution;
+  const amount = new BigNumber(isBigInt(value) ? value.toString() : value);
+  return Object.freeze({ amount, symbol, decimals });
+}
+
+const thinSpace = ' ';
+
+export function formatMoney({ amount, symbol, decimals }: Money) {
+  return `${amount.shiftedBy(-decimals).toString()} ${symbol}`;
+}
+
+export function formatMoneyWithoutSymbol({ amount, decimals }: Money) {
+  return `${amount.shiftedBy(-decimals).toString()}`;
+}
+
+export function formatMoneyPadded({ amount, symbol, decimals }: Money) {
+  return `${amount.shiftedBy(-decimals).toFormat(decimals)} ${symbol}`;
+}
+
+export function i18nFormatCurrency(quantity: Money, decimals: number = 2) {
+  if (quantity.symbol !== 'USD') throw new Error('Cannot format non-USD amounts');
+  const currencyFormatter = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    maximumFractionDigits: decimals,
+  });
+
+  const formatted = currencyFormatter.format(
+    quantity.amount.shiftedBy(-quantity.decimals).toNumber()
+  );
+
+  if (quantity.amount.isGreaterThan(0) && formatted === '$0.00')
+    return '<' + thinSpace + formatted.replace('0.00', '0.01');
+
+  return formatted;
+}
+
+export function formatDustUsdAmounts(value: string) {
+  return value.endsWith('0.00') ? '<' + thinSpace + value.replace('0.00', '0.01') : value;
+}

package/src/money/index.ts

@@ -0,0 +1,4 @@
+export * from './calculate-money';
+export * from './format-money';
+export * from './is-money';
+export * from './unit-conversion';

package/src/money/is-money.ts

@@ -0,0 +1,15 @@
+import BigNumber from 'bignumber.js';
+
+import { Money } from '@leather.io/models';
+
+import { isObject } from '..';
+
+export function isMoney(val: unknown): val is Money {
+  if (!isObject(val)) return false;
+  return 'amount' in val && 'symbol' in val && 'decimals' in val;
+}
+
+export function isMoneyGreaterThanZero(money: Money) {
+  if (!BigNumber.isBigNumber(money.amount)) return;
+  return !(money.amount.isNaN() || money.amount.isZero());
+}

package/src/money/unit-conversion.ts

@@ -0,0 +1,30 @@
+import BigNumber from 'bignumber.js';
+
+import { BTC_DECIMALS, STX_DECIMALS } from '@leather.io/constants';
+import { Money } from '@leather.io/models';
+
+import { initBigNumber } from '../math/helpers';
+
+function fractionalUnitToUnit(decimals: number) {
+  return (unit: number | string | BigNumber) => {
+    const unitBigNumber = initBigNumber(unit);
+    return unitBigNumber.shiftedBy(-decimals);
+  };
+}
+
+export function unitToFractionalUnit(decimals: number) {
+  return (unit: number | string | BigNumber) => {
+    const unitBigNumber = initBigNumber(unit);
+    return unitBigNumber.shiftedBy(decimals);
+  };
+}
+
+export const satToBtc = fractionalUnitToUnit(BTC_DECIMALS);
+export const btcToSat = unitToFractionalUnit(BTC_DECIMALS);
+
+export const microStxToStx = fractionalUnitToUnit(STX_DECIMALS);
+export const stxToMicroStx = unitToFractionalUnit(STX_DECIMALS);
+
+export function moneyToBaseUnit(sum: Money) {
+  return fractionalUnitToUnit(sum.decimals)(sum.amount);
+}

package/src/sort-assets.ts

@@ -0,0 +1,26 @@
+import type { Money } from '@leather.io/models';
+
+export function sortAssetsByName<T extends { name: string }[]>(assets: T) {
+  return assets
+    .sort((a, b) => {
+      if (a.name < b.name) return -1;
+      if (a.name > b.name) return 1;
+      return 0;
+    })
+    .sort((a, b) => {
+      if (a.name === 'STX') return -1;
+      if (b.name !== 'STX') return 1;
+      return 0;
+    })
+    .sort((a, b) => {
+      if (a.name === 'BTC') return -1;
+      if (b.name !== 'BTC') return 1;
+      return 0;
+    });
+}
+
+export function migratePositiveAssetBalancesToTop<T extends { balance: Money }[]>(assets: T) {
+  const assetsWithPositiveBalance = assets.filter(asset => asset.balance.amount.isGreaterThan(0));
+  const assetsWithZeroBalance = assets.filter(asset => asset.balance.amount.isEqualTo(0));
+  return [...assetsWithPositiveBalance, ...assetsWithZeroBalance] as T;
+}

package/src/spam-filter/spam-filter.spec.ts

@@ -0,0 +1,26 @@
+import { spamFilter, spamReplacement } from './spam-filter';
+
+describe('Spam filter', () => {
+  it('should allow valid tokens', () => {
+    expect(spamFilter('This token name is OK')).not.toEqual(spamReplacement);
+  });
+  it('should detect spam urls in strings and replace content', () => {
+    expect(spamFilter('www.fake')).toEqual(spamReplacement);
+    expect(spamFilter('https://www.fake.com')).toEqual(spamReplacement);
+    expect(spamFilter('fake.com')).toEqual(spamReplacement);
+    expect(spamFilter('https://www.fake')).toEqual(spamReplacement);
+    expect(spamFilter('http://www.fake')).toEqual(spamReplacement);
+    expect(spamFilter('ftp://fake.com')).toEqual(spamReplacement);
+    expect(spamFilter('https://fake.com')).toEqual(spamReplacement);
+    expect(spamFilter('http://fake.com')).toEqual(spamReplacement);
+    expect(spamFilter('https://fake')).toEqual(spamReplacement);
+    expect(spamFilter('http://fake')).toEqual(spamReplacement);
+  });
+  it('should detect spam words in strings and replace content', () => {
+    expect(spamFilter('You won some stx')).toEqual(spamReplacement);
+    expect(spamFilter('You Win some stx')).toEqual(spamReplacement);
+    expect(spamFilter('You Won some stx')).toEqual(spamReplacement);
+    expect(spamFilter('click here for some stx')).toEqual(spamReplacement);
+    expect(spamFilter('Click here for some stx')).toEqual(spamReplacement);
+  });
+});

package/src/spam-filter/spam-filter.ts

@@ -0,0 +1,24 @@
+const urlRegex =
+  /(http|https|ftp)|(((http|ftp|https):\/\/)?(((http|ftp|https):\/\/)?(([\w.-]*)\.([\w]*))))/g;
+const spamWords = ['won', 'win', 'click'];
+export const spamReplacement = 'Unknown token';
+
+function spamUrlFilter(input: string) {
+  return input.match(urlRegex);
+}
+
+function spamWordFilter(input: string): boolean {
+  const containsSpam = (element: string) => input.toLowerCase().includes(element);
+  return spamWords.some(containsSpam);
+}
+
+export function spamFilter(input: string): string {
+  const urlFound = spamUrlFilter(input);
+  const spamWordsFound = spamWordFilter(input);
+
+  if (urlFound || spamWordsFound) {
+    return spamReplacement;
+  }
+
+  return input;
+}

package/src/truncate-middle.ts

@@ -0,0 +1,23 @@
+function truncateHex(hex: string, offset = 5): string {
+  return `${hex.substring(0, offset + 2)}…${hex.substring(hex.length - offset)}`;
+}
+
+export function truncateMiddle(input: string, offset = 5): string {
+  if (!input) return '';
+  // Hex
+  if (input.startsWith('0x')) {
+    return truncateHex(input, offset);
+  }
+  // For contracts
+  if (input.includes('.')) {
+    const parts = input.split('.');
+    const start = parts[0]?.substring(0, offset);
+    const end = parts[0]?.substring(parts[0].length - offset, parts[0].length);
+    return `${start}…${end}.${parts[1]}`;
+  } else {
+    // Everything else
+    const start = input?.substring(0, offset);
+    const end = input?.substring(input.length - offset, input.length);
+    return `${start}…${end}`;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": ["@leather.io/tsconfig-config/tsconfig.base.json"],
+  "include": ["**/*", ".*.ts"],
+  "exclude": ["./dist/"],
+  "compilerOptions": {
+    "baseUrl": "src",
+    "types": ["vitest/globals"],
+    "outDir": "./dist"
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  sourcemap: true,
+  clean: true,
+  dts: true,
+  format: 'esm',
+});

package/vitest.config.js

@@ -0,0 +1,5 @@
+import { defineConfig } from 'vitest/config';
+
+import { defaultVitestUnitTestingConfig } from '../../config/vitest-configs';
+
+export default defineConfig({ ...defaultVitestUnitTestingConfig });