@fleet-sdk/common 0.2.2 → 0.3.0

package/src/utils/array.ts

@@ -1,196 +0,0 @@
-import { SortingDirection, SortingSelector } from "../types";
-import { assert, isEmpty } from "./assertions";
-
-type ObjectSelector<T> = (item: T) => T[keyof T];
-
-export function first(array: undefined): undefined;
-export function first<T>(array: ArrayLike<T>): T;
-export function first<T>(array: ArrayLike<T> | undefined): T | number | undefined {
-  if (!array) return undefined;
-  assert(array.length > 0, "Empty array.");
-
-  return array[0];
-}
-
-export function last(array: undefined): undefined;
-export function last<T>(array: ArrayLike<T>): T;
-export function last<T>(array: ArrayLike<T> | undefined): T | undefined {
-  if (!array) return undefined;
-  assert(array.length > 0, "Empty array.");
-
-  return at(array, -1);
-}
-
-export function at(array: undefined, index: number): undefined;
-export function at<T>(array: ArrayLike<T>, index: number): T;
-export function at<T>(array: ArrayLike<T> | undefined, index: number): T | undefined {
-  const len = array?.length;
-  if (!len) return undefined;
-
-  if (index < 0) {
-    index += len;
-  }
-
-  return array[index];
-}
-
-/**
- * Check for duplicate elements using the equality operator
- */
-export function hasDuplicates<T>(array: T[]): boolean {
-  return array.some((item, index) => {
-    return array.indexOf(item) !== index;
-  });
-}
-
-/**
- * Check for duplicate keys in complex elements
- */
-export function hasDuplicatesBy<T>(array: T[], selector: ObjectSelector<T>): boolean {
-  return array.some((item, index) => {
-    return array.findIndex((x) => selector(x) === selector(item)) !== index;
-  });
-}
-
-export function chunk<T>(array: T[], size: number): T[][] {
-  if (array.length <= size) {
-    return [array];
-  }
-
-  const chunks: T[][] = [];
-  for (let i = 0; i < array.length; i += size) {
-    chunks.push(array.slice(i, i + size));
-  }
-
-  return chunks;
-}
-
-export function orderBy<T>(
-  array: T[],
-  iteratee: SortingSelector<T>,
-  order: SortingDirection = "asc"
-): T[] {
-  return [...array].sort((a: T, b: T) => {
-    if (iteratee(a) > iteratee(b)) {
-      return order === "asc" ? 1 : -1;
-    } else if (iteratee(a) < iteratee(b)) {
-      return order === "asc" ? -1 : 1;
-    } else {
-      return 0;
-    }
-  });
-}
-
-export function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean {
-  if (array1 === array2) {
-    return true;
-  }
-
-  if (array1.length != array2.length) {
-    return false;
-  }
-
-  for (let i = 0; i < array1.length; i++) {
-    if (array1[i] !== array2[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function areEqualBy<T>(
-  array1: ArrayLike<T>,
-  array2: ArrayLike<T>,
-  selector: ObjectSelector<T>
-): boolean {
-  if (array1 === array2) {
-    return true;
-  }
-
-  if (array1.length != array2.length) {
-    return false;
-  }
-
-  for (let i = 0; i < array1.length; i++) {
-    if (selector(array1[i]) !== selector(array2[i])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function startsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
-  if (array === target) {
-    return true;
-  }
-
-  if (target.length > array.length) {
-    return false;
-  }
-
-  for (let i = 0; i < target.length; i++) {
-    if (target[i] !== array[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function endsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
-  if (array === target) {
-    return true;
-  }
-
-  if (target.length > array.length) {
-    return false;
-  }
-
-  const offset = array.length - target.length;
-
-  for (let i = target.length - 1; i >= 0; i--) {
-    if (target[i] !== array[i + offset]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function uniq<T>(array: Array<T>): Array<T> {
-  if (isEmpty(array)) {
-    return array;
-  }
-
-  return Array.from(new Set(array));
-}
-
-export function uniqBy<T>(
-  array: Array<T>,
-  selector: ObjectSelector<T>,
-  selection: "keep-first" | "keep-last" = "keep-first"
-): Array<T> {
-  if (isEmpty(array)) {
-    return array;
-  }
-
-  return Array.from(
-    array
-      .reduce((map, e) => {
-        const key = selector(e);
-
-        if (selection === "keep-first" && map.has(key)) {
-          return map;
-        }
-
-        return map.set(key, e);
-      }, new Map())
-      .values()
-  );
-}
-
-export function depthOf(array: unknown | unknown[]): number {
-  return Array.isArray(array) ? 1 + Math.max(0, ...array.map(depthOf)) : 0;
-}

package/src/utils/assertions.ts

@@ -1,90 +0,0 @@
-export type AssertErrorMessageInput = string | Error | (() => string);
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-type Constructable = Function;
-
-type JSPrimitiveTypes =
-  | "string"
-  | "number"
-  | "bigint"
-  | "boolean"
-  | "symbol"
-  | "undefined"
-  | "object"
-  | "function";
-
-export function assert(condition: boolean, error: AssertErrorMessageInput): asserts condition {
-  if (condition) return;
-
-  let err: Error | undefined = undefined;
-  switch (typeof error) {
-    case "string":
-      err = new Error(error);
-      break;
-    case "function":
-      err = new Error(error());
-      break;
-    default:
-      err = error;
-  }
-
-  throw err;
-}
-
-export function assertTypeOf<T>(obj: T, expected: JSPrimitiveTypes): asserts obj {
-  const type = typeof obj;
-
-  if (type !== expected) {
-    throw new Error(`Expected an object of type '${expected}', got '${type}'.`);
-  }
-}
-
-const toString = (value: unknown) => Object.prototype.toString.call(value);
-function getTypeName(value: unknown): string {
-  if (value === null) return "null";
-  const type = typeof value;
-
-  return type === "object" || type === "function" ? toString(value).slice(8, -1) : type;
-}
-
-export function assertInstanceOf<T>(obj: T, expected: Constructable): asserts obj {
-  const condition = obj instanceof expected;
-
-  if (!condition) {
-    throw new Error(`Expected an instance of '${expected.name}', got '${getTypeName(obj)}'.`);
-  }
-}
-
-export function isEmpty<T extends object>(obj?: T): obj is undefined;
-export function isEmpty<T>(array?: T[]): array is undefined;
-export function isEmpty<T>(obj?: T[] | object): obj is undefined {
-  if (!obj) return true;
-
-  return Array.isArray(obj) ? obj.length === 0 : Object.keys(obj).length === 0;
-}
-
-export function some<T extends object>(obj?: T): obj is T;
-export function some<T>(array?: T[]): array is T[];
-export function some<T>(obj?: T[] | object): boolean {
-  return !isEmpty(obj);
-}
-
-export function isTruthy<T>(value?: T): value is NonNullable<T> {
-  return !!value;
-}
-
-export function isFalsy<T>(value?: T): value is undefined {
-  return !value;
-}
-
-export function isUndefined(v: unknown): v is undefined {
-  return v === undefined || v === null || Number.isNaN(v);
-}
-
-export function isDefined<T>(v: T | undefined): v is T {
-  return !isUndefined(v);
-}
-
-export function hasKey(o: unknown, key: PropertyKey): boolean {
-  return Object.prototype.hasOwnProperty.call(o, key);
-}

package/src/utils/bigInt.ts

@@ -1,186 +0,0 @@
-import { Amount } from "../types";
-import { first } from "./array";
-import { isEmpty, isUndefined } from "./assertions";
-
-type NumberLike = string | number | bigint | boolean;
-
-export const _0n = BigInt(0);
-export const _1n = BigInt(1);
-export const _7n = BigInt(7);
-export const _10n = BigInt(10);
-export const _63n = BigInt(63);
-export const _127n = BigInt(127);
-export const _128n = BigInt(128);
-
-export function ensureBigInt(number: NumberLike): bigint {
-  return typeof number === "bigint" ? number : BigInt(number);
-}
-
-type ParsingOptions = {
-  /**
-   * Number of decimals.
-   */
-  decimals?: number;
-
-  /**
-   * Thousand mark char.
-   * Default: `.`
-   */
-  decimalMark?: string;
-};
-
-export function undecimalize(decimalStr: string, options?: ParsingOptions | number): bigint {
-  if (!decimalStr) {
-    return _0n;
-  }
-
-  options = typeof options == "number" ? { decimals: options } : options;
-  if (isUndefined(options)) {
-    options = {};
-  }
-
-  options.decimals = options.decimals || 0;
-  options.decimalMark = options.decimalMark || ".";
-
-  const fragments = decimalStr.split(options.decimalMark);
-  if (fragments.length > 2) {
-    throw new Error("Invalid numeric string.");
-  }
-
-  let [integer, decimal] = fragments;
-  integer = _removeLeadingZeros(integer);
-  const negative = integer.startsWith("-") ? "-" : "";
-
-  if (!decimal) {
-    decimal = "0".repeat(options.decimals);
-  } else if (decimal.length < options.decimals) {
-    decimal = decimal.padEnd(options.decimals, "0");
-  }
-
-  return BigInt(negative + _stripNonDigits(integer + decimal));
-}
-
-function _stripNonDigits(value: string): string {
-  return value.replace(/\D/g, "");
-}
-
-type FormattingOptions = {
-  /**
-   * Number of decimals.
-   */
-  decimals: number;
-
-  /**
-   * Thousand mark char.
-   */
-  thousandMark?: string;
-
-  /**
-   * Decimal mark char.
-   * Default: `.`
-   */
-  decimalMark?: string;
-};
-
-export function decimalize(value: Amount, options?: FormattingOptions | number): string {
-  value = ensureBigInt(value);
-  if (!options) {
-    return value.toString();
-  }
-
-  options = typeof options == "number" ? { decimals: options } : options;
-  options.decimals = options.decimals || 0;
-  options.decimalMark = options.decimalMark || ".";
-
-  const pow = _10n ** BigInt(options.decimals);
-  const integer = value / pow;
-  const decimal = value - integer * pow;
-
-  return _buildFormattedDecimal(integer.toString(10), decimal.toString(10), options);
-}
-
-export function percent(value: bigint, percentage: bigint, precision = 2n) {
-  return (value * percentage) / 10n ** precision;
-}
-
-function _buildFormattedDecimal(
-  integer: string,
-  decimal: string,
-  options: FormattingOptions
-): string {
-  const integerPart = _addThousandMarks(integer, options.thousandMark);
-  const decimalPart = _stripTrailingZeros(decimal.padStart(options.decimals, "0"));
-
-  if (decimalPart) {
-    return `${integerPart}${options.decimalMark}${decimalPart}`;
-  } else {
-    return integerPart;
-  }
-}
-
-function _addThousandMarks(value: string, mark?: string): string {
-  if (!mark) {
-    return value;
-  }
-
-  return value.replace(/\B(?=(\d{3})+(?!\d))/g, mark);
-}
-
-function _stripTrailingZeros(value: string): string {
-  if (!value.endsWith("0")) {
-    return value;
-  }
-
-  return value.replace(/\.?0+$/, "");
-}
-
-function _removeLeadingZeros(value: string): string {
-  if (!value.startsWith("0")) {
-    return value;
-  }
-
-  return value.replace(/^0+\.?/, "");
-}
-
-export function sumBy<T>(
-  collection: readonly T[],
-  iteratee: (value: T) => bigint,
-  condition?: (value: T) => boolean
-): bigint {
-  let acc = _0n;
-  if (isEmpty(collection)) {
-    return acc;
-  }
-
-  for (const item of collection) {
-    if (isUndefined(condition) || condition(item)) {
-      acc += iteratee(item);
-    }
-  }
-
-  return acc;
-}
-
-export function min<T extends bigint | number>(...numbers: T[]): T {
-  let min = first(numbers);
-
-  for (const num of numbers) {
-    if (num < min) {
-      min = num;
-    }
-  }
-
-  return min;
-}
-
-export function max<T extends bigint | number>(...numbers: T[]): T {
-  let max = first(numbers);
-
-  for (const num of numbers) {
-    if (num > max) {
-      max = num;
-    }
-  }
-
-  return max;
-}

package/src/utils/bytes.bench.ts

@@ -1,43 +0,0 @@
-import { bench, describe } from "vitest";
-import { isHex } from "./bytes";
-
-const HEX_PATTERN = /^[0-9A-Fa-f]+$/s;
-export function isHexRegex(value?: string) {
-  if (!value || value.length % 2) return false;
-
-  return HEX_PATTERN.test(value);
-}
-
-const HEX_CHARSET = new Set("0123456789abcdefABCDEF");
-function isHexChar(value: string) {
-  if (!value || value.length % 2) return false;
-
-  const valueSet = new Set(Array.from(value));
-  for (const c of valueSet) {
-    if (!HEX_CHARSET.has(c)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-describe("Hex string checking", () => {
-  const validHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7";
-  const invalidHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7tt";
-
-  bench("Using charset", () => {
-    isHexChar(validHex);
-    isHexChar(invalidHex);
-  });
-
-  bench("Using regex", () => {
-    isHexRegex(validHex);
-    isHexRegex(invalidHex);
-  });
-
-  bench("Using number constructor", () => {
-    isHex(validHex);
-    isHex(invalidHex);
-  });
-});

package/src/utils/bytes.ts

@@ -1,34 +0,0 @@
-import { assertInstanceOf } from ".";
-
-export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-
-  let pad = 0;
-  for (const bytes of arrays) {
-    assertInstanceOf(bytes, Uint8Array);
-
-    r.set(bytes, pad);
-    pad += bytes.length;
-  }
-
-  return r;
-}
-
-export function isHex(value?: string) {
-  if (!value || value.length % 2) return false;
-
-  if (!value.startsWith("0x")) {
-    value = "0x" + value;
-  }
-
-  return !isNaN(Number(value));
-}
-
-/**
- * Get hex string size in bytes
- * @param hex
- * @returns the byte size if the hex string
- */
-export function byteSizeOf(hex: string): number {
-  return hex.length / 2;
-}

package/src/utils/index.ts

@@ -1,6 +0,0 @@
-export * from "./array";
-export * from "./bigInt";
-export * from "./utxo";
-export * from "./object";
-export * from "./assertions";
-export * from "./bytes";

package/src/utils/object.ts

@@ -1,28 +0,0 @@
-import { isEmpty, isUndefined } from "./assertions";
-
-export function clearUndefined(value: Record<string, unknown>) {
-  const result: Record<string, unknown> = {};
-  for (const key in value) {
-    const val = value[key];
-    if (!isUndefined(val)) {
-      result[key] = val;
-    }
-  }
-
-  return result;
-}
-
-export function ensureDefaults<T extends Partial<R>, R extends object = Required<T>>(
-  options: T | undefined,
-  defaults: R
-): R & T {
-  if (isEmpty(options)) return defaults as R & T;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const newObj: any = { ...defaults, ...options };
-  for (const key in newObj) {
-    newObj[key as keyof object] = options[key as keyof R] ?? defaults[key as keyof R];
-  }
-
-  return newObj;
-}