@w3ux/utils 0.0.1

package/base.d.ts

@@ -0,0 +1,66 @@
+import { BigNumber } from 'bignumber.js';
+import { AnyFunction } from './types.js';
+
+/**
+ * @name camelize
+ * @summary Converts a string of text to camelCase.
+ */
+declare const camelize: (str: string) => string;
+/**
+ * @name ellipsisFn
+ * @summary Receives an address and creates ellipsis on the given string, based on parameters.
+ * @param str  - The string to apply the ellipsis on
+ * @param amount  - The amount of characters that the ellipsis will be
+ * @param position - where the ellipsis will apply; if center the amount of character is the
+ * same for beginning and end; if "start" or "end" then its only once the amount; defaults to "start"
+ */
+declare const ellipsisFn: (str: string, amount?: number, position?: "start" | "end" | "center") => string;
+/**
+ * @name greaterThanZero
+ * @summary Returns whether a BigNumber is greater than zero.
+ */
+declare const greaterThanZero: (val: BigNumber) => boolean;
+/**
+ * @name isNotZero
+ * @summary Returns whether a BigNumber is zero.
+ */
+declare const isNotZero: (val: BigNumber) => boolean;
+/**
+ * @name minDecimalPlaces
+ * @summary Forces a number to have at least the provided decimal places.
+ */
+declare const minDecimalPlaces: (val: string, minDecimals: number) => string;
+/**
+ * @name pageFromUri
+ * @summary Use url variables to load the default components upon the first page visit.
+ */
+declare const pageFromUri: (pathname: string, fallback: string) => string;
+/**
+ * @name rmCommas
+ * @summary Removes the commas from a string.
+ */
+declare const rmCommas: (val: string) => string;
+/**
+ * @name shuffle
+ * @summary Shuffle a set of objects.
+ */
+declare const shuffle: <T>(array: T[]) => T[];
+/**
+ * @name withTimeout
+ * @summary Timeout a promise after a specified number of milliseconds.
+ */
+declare const withTimeout: (ms: number, promise: AnyFunction, options?: {
+    onTimeout?: AnyFunction;
+}) => Promise<any>;
+/**
+ * @name appendOrEmpty
+ * @summary Returns ` value` if a condition is truthy, or an empty string otherwise.
+ */
+declare const appendOrEmpty: (condition: boolean | string | undefined, value: string) => string;
+/**
+ * @name appendOr
+ * @summary Returns ` value` if condition is truthy, or ` fallback` otherwise.
+ */
+declare const appendOr: (condition: boolean | string | undefined, value: string, fallback: string) => string;
+
+export { appendOr, appendOrEmpty, camelize, ellipsisFn, greaterThanZero, isNotZero, minDecimalPlaces, pageFromUri, rmCommas, shuffle, withTimeout };

package/base.js

@@ -0,0 +1,113 @@
+// src/base.ts
+import { BigNumber } from "bignumber.js";
+var camelize = (str) => {
+  const convertToString = (string) => {
+    if (string) {
+      if (typeof string === "string") {
+        return string;
+      }
+      return String(string);
+    }
+    return "";
+  };
+  const toWords = (inp) => convertToString(inp).match(
+    /[A-Z\xC0-\xD6\xD8-\xDE]?[a-z\xDF-\xF6\xF8-\xFF]+|[A-Z\xC0-\xD6\xD8-\xDE]+(?![a-z\xDF-\xF6\xF8-\xFF])|\d+/g
+  );
+  const simpleCamelCase = (inp) => {
+    let result = "";
+    for (let i = 0; i < inp?.length; i++) {
+      const currString = inp[i];
+      let tmpStr = currString.toLowerCase();
+      if (i != 0) {
+        tmpStr = tmpStr.slice(0, 1).toUpperCase() + tmpStr.slice(1, tmpStr.length);
+      }
+      result += tmpStr;
+    }
+    return result;
+  };
+  const w = toWords(str)?.map((a) => a.toLowerCase());
+  return simpleCamelCase(w);
+};
+var ellipsisFn = (str, amount = 6, position = "center") => {
+  const half = str.length / 2;
+  if (amount <= 4) {
+    if (position === "center") {
+      return str.slice(0, 4) + "..." + str.slice(-4);
+    }
+    if (position === "end") {
+      return str.slice(0, 4) + "...";
+    }
+    return "..." + str.slice(-4);
+  }
+  if (position === "center") {
+    return amount >= (str.length - 2) / 2 ? str.slice(0, half - 3) + "..." + str.slice(-(half - 3)) : str.slice(0, amount) + "..." + str.slice(-amount);
+  }
+  if (amount >= str.length) {
+    if (position === "end") {
+      return str.slice(0, str.length - 3) + "...";
+    }
+    return "..." + str.slice(-(str.length - 3));
+  } else {
+    if (position === "end") {
+      return str.slice(0, amount) + "...";
+    }
+    return "..." + str.slice(amount);
+  }
+};
+var greaterThanZero = (val) => val.isGreaterThan(0);
+var isNotZero = (val) => !val.isZero();
+var minDecimalPlaces = (val, minDecimals) => {
+  const whole = new BigNumber(rmCommas(val).split(".")[0] || 0);
+  const decimals = val.split(".")[1] || "";
+  const missingDecimals = new BigNumber(minDecimals).minus(decimals.length);
+  return missingDecimals.isGreaterThan(0) ? `${whole.toFormat(0)}.${decimals.toString()}${"0".repeat(
+    missingDecimals.toNumber()
+  )}` : val;
+};
+var pageFromUri = (pathname, fallback) => {
+  const lastUriItem = pathname.substring(pathname.lastIndexOf("/") + 1);
+  const page = lastUriItem.trim() === "" ? fallback : lastUriItem;
+  return page.trim();
+};
+var rmCommas = (val) => val.replace(/,/g, "");
+var shuffle = (array) => {
+  let currentIndex = array.length;
+  let randomIndex;
+  while (currentIndex !== 0) {
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+    [array[currentIndex], array[randomIndex]] = [
+      array[randomIndex],
+      array[currentIndex]
+    ];
+  }
+  return array;
+};
+var withTimeout = (ms, promise, options) => {
+  const timeout = new Promise(
+    (resolve) => setTimeout(async () => {
+      if (typeof options?.onTimeout === "function") {
+        options.onTimeout();
+      }
+      resolve(void 0);
+    }, ms)
+  );
+  return Promise.race([promise, timeout]);
+};
+var appendOrEmpty = (condition, value) => condition ? ` ${value}` : "";
+var appendOr = (condition, value, fallback) => condition ? ` ${value}` : ` ${fallback}`;
+export {
+  appendOr,
+  appendOrEmpty,
+  camelize,
+  ellipsisFn,
+  greaterThanZero,
+  isNotZero,
+  minDecimalPlaces,
+  pageFromUri,
+  rmCommas,
+  shuffle,
+  withTimeout
+};
+/* @license Copyright 2024 w3ux authors & contributors
+SPDX-License-Identifier: GPL-3.0-only */

package/index.d.ts

@@ -0,0 +1,5 @@
+export { appendOr, appendOrEmpty, camelize, ellipsisFn, greaterThanZero, isNotZero, minDecimalPlaces, pageFromUri, rmCommas, shuffle, withTimeout } from './base.js';
+export { addedTo, applyWidthAsPadding, capitalizeFirstLetter, determinePoolDisplay, evalUnits, extractUrlValue, inChrome, isValidAddress, isValidHttpUrl, localStorageOrDefault, makeCancelable, matchedProperties, mergeDeep, planckToUnit, remToUnit, removeVarFromUrlHash, removedFrom, setStateWithRef, snakeToCamel, sortWithNull, transformToBaseUnit, unescape, unimplemented, unitToPlanck, varToUrlHash } from './unit.js';
+import 'bignumber.js';
+import './types.js';
+import 'react';

package/index.js

@@ -0,0 +1,400 @@
+// src/base.ts
+import { BigNumber } from "bignumber.js";
+var camelize = (str) => {
+  const convertToString = (string) => {
+    if (string) {
+      if (typeof string === "string") {
+        return string;
+      }
+      return String(string);
+    }
+    return "";
+  };
+  const toWords = (inp) => convertToString(inp).match(
+    /[A-Z\xC0-\xD6\xD8-\xDE]?[a-z\xDF-\xF6\xF8-\xFF]+|[A-Z\xC0-\xD6\xD8-\xDE]+(?![a-z\xDF-\xF6\xF8-\xFF])|\d+/g
+  );
+  const simpleCamelCase = (inp) => {
+    let result = "";
+    for (let i = 0; i < inp?.length; i++) {
+      const currString = inp[i];
+      let tmpStr = currString.toLowerCase();
+      if (i != 0) {
+        tmpStr = tmpStr.slice(0, 1).toUpperCase() + tmpStr.slice(1, tmpStr.length);
+      }
+      result += tmpStr;
+    }
+    return result;
+  };
+  const w = toWords(str)?.map((a) => a.toLowerCase());
+  return simpleCamelCase(w);
+};
+var ellipsisFn = (str, amount = 6, position = "center") => {
+  const half = str.length / 2;
+  if (amount <= 4) {
+    if (position === "center") {
+      return str.slice(0, 4) + "..." + str.slice(-4);
+    }
+    if (position === "end") {
+      return str.slice(0, 4) + "...";
+    }
+    return "..." + str.slice(-4);
+  }
+  if (position === "center") {
+    return amount >= (str.length - 2) / 2 ? str.slice(0, half - 3) + "..." + str.slice(-(half - 3)) : str.slice(0, amount) + "..." + str.slice(-amount);
+  }
+  if (amount >= str.length) {
+    if (position === "end") {
+      return str.slice(0, str.length - 3) + "...";
+    }
+    return "..." + str.slice(-(str.length - 3));
+  } else {
+    if (position === "end") {
+      return str.slice(0, amount) + "...";
+    }
+    return "..." + str.slice(amount);
+  }
+};
+var greaterThanZero = (val) => val.isGreaterThan(0);
+var isNotZero = (val) => !val.isZero();
+var minDecimalPlaces = (val, minDecimals) => {
+  const whole = new BigNumber(rmCommas(val).split(".")[0] || 0);
+  const decimals = val.split(".")[1] || "";
+  const missingDecimals = new BigNumber(minDecimals).minus(decimals.length);
+  return missingDecimals.isGreaterThan(0) ? `${whole.toFormat(0)}.${decimals.toString()}${"0".repeat(
+    missingDecimals.toNumber()
+  )}` : val;
+};
+var pageFromUri = (pathname, fallback) => {
+  const lastUriItem = pathname.substring(pathname.lastIndexOf("/") + 1);
+  const page = lastUriItem.trim() === "" ? fallback : lastUriItem;
+  return page.trim();
+};
+var rmCommas = (val) => val.replace(/,/g, "");
+var shuffle = (array) => {
+  let currentIndex = array.length;
+  let randomIndex;
+  while (currentIndex !== 0) {
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+    [array[currentIndex], array[randomIndex]] = [
+      array[randomIndex],
+      array[currentIndex]
+    ];
+  }
+  return array;
+};
+var withTimeout = (ms, promise, options) => {
+  const timeout = new Promise(
+    (resolve) => setTimeout(async () => {
+      if (typeof options?.onTimeout === "function") {
+        options.onTimeout();
+      }
+      resolve(void 0);
+    }, ms)
+  );
+  return Promise.race([promise, timeout]);
+};
+var appendOrEmpty = (condition, value) => condition ? ` ${value}` : "";
+var appendOr = (condition, value, fallback) => condition ? ` ${value}` : ` ${fallback}`;
+
+// src/unit.ts
+import { decodeAddress, encodeAddress } from "@polkadot/keyring";
+import { hexToU8a, isHex, u8aToString, u8aUnwrapBytes } from "@polkadot/util";
+import { BigNumber as BigNumber2 } from "bignumber.js";
+var remToUnit = (rem) => Number(rem.slice(0, rem.length - 3)) * parseFloat(getComputedStyle(document.documentElement).fontSize);
+var planckToUnit = (val, units) => new BigNumber2(
+  val.dividedBy(new BigNumber2(10).exponentiatedBy(units)).toFixed(units)
+);
+var unitToPlanck = (val, units) => {
+  const init = new BigNumber2(!val.length || !val ? "0" : val);
+  return (!init.isNaN() ? init : new BigNumber2(0)).multipliedBy(new BigNumber2(10).exponentiatedBy(units)).integerValue();
+};
+var capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
+var snakeToCamel = (str) => str.toLowerCase().replace(
+  /([-_][a-z])/g,
+  (group) => group.toUpperCase().replace("-", "").replace("_", "")
+);
+var setStateWithRef = (value, setState, ref) => {
+  setState(value);
+  ref.current = value;
+};
+var localStorageOrDefault = (key, _default, parse = false) => {
+  const val = localStorage.getItem(key);
+  if (val === null) {
+    return _default;
+  }
+  if (parse) {
+    return JSON.parse(val);
+  }
+  return val;
+};
+var isValidAddress = (address) => {
+  try {
+    encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var determinePoolDisplay = (address, batchItem) => {
+  const defaultDisplay = ellipsisFn(address, 6);
+  let display = batchItem ?? defaultDisplay;
+  const displayAsBytes = u8aToString(u8aUnwrapBytes(display));
+  if (displayAsBytes !== "") {
+    display = displayAsBytes;
+  }
+  if (display === "") {
+    display = defaultDisplay;
+  }
+  return display;
+};
+var extractUrlValue = (key, url) => {
+  if (typeof url === "undefined") {
+    url = window.location.href;
+  }
+  const match = url.match(`[?&]${key}=([^&]+)`);
+  return match ? match[1] : null;
+};
+var varToUrlHash = (key, val, addIfMissing) => {
+  const hash = window.location.hash;
+  const [page, params] = hash.split("?");
+  const searchParams = new URLSearchParams(params);
+  if (searchParams.get(key) === null && !addIfMissing) {
+    return;
+  }
+  searchParams.set(key, val);
+  window.location.hash = `${page}?${searchParams.toString()}`;
+};
+var removeVarFromUrlHash = (key) => {
+  const hash = window.location.hash;
+  const [page, params] = hash.split("?");
+  const searchParams = new URLSearchParams(params);
+  if (searchParams.get(key) === null) {
+    return;
+  }
+  searchParams.delete(key);
+  const paramsAsStr = searchParams.toString();
+  window.location.hash = `${page}${paramsAsStr ? `?${paramsAsStr}` : ``}`;
+};
+var sortWithNull = (ascending) => (a, b) => {
+  if (a === b) {
+    return 0;
+  }
+  if (a === null) {
+    return 1;
+  }
+  if (b === null) {
+    return -1;
+  }
+  if (ascending) {
+    return a < b ? -1 : 1;
+  }
+  return a < b ? 1 : -1;
+};
+var applyWidthAsPadding = (subjectRef, containerRef) => {
+  if (containerRef.current && subjectRef.current) {
+    containerRef.current.style.paddingRight = `${subjectRef.current.offsetWidth + remToUnit("1rem")}px`;
+  }
+};
+var unescape = (val) => val.replace(/\\"/g, '"');
+var inChrome = () => {
+  const isChromium = window?.chrome || null;
+  const winNav = window?.navigator || null;
+  const isOpera = typeof window?.opr !== "undefined";
+  const isIEedge = winNav?.userAgent.indexOf("Edg") > -1 || false;
+  const isIOSChrome = winNav?.userAgent.match("CriOS") || false;
+  if (isIOSChrome) {
+    return true;
+  }
+  if (isChromium !== null && typeof isChromium !== "undefined" && isOpera === false && isIEedge === false) {
+    return true;
+  }
+  return false;
+};
+var addedTo = (fresh, stale, keys) => typeof fresh !== "object" || typeof stale !== "object" || !keys.length ? [] : fresh.filter(
+  (freshItem) => !stale.find(
+    (staleItem) => keys.every(
+      (key) => !(key in staleItem) || !(key in freshItem) ? false : staleItem[key] === freshItem[key]
+    )
+  )
+);
+var removedFrom = (fresh, stale, keys) => typeof fresh !== "object" || typeof stale !== "object" || !keys.length ? [] : stale.filter(
+  (staleItem) => !fresh.find(
+    (freshItem) => keys.every(
+      (key) => !(key in staleItem) || !(key in freshItem) ? false : freshItem[key] === staleItem[key]
+    )
+  )
+);
+var matchedProperties = (objX, objY, keys) => typeof objX !== "object" || typeof objY !== "object" || !keys.length ? [] : objY.filter(
+  (x) => objX.find(
+    (y) => keys.every(
+      (key) => !(key in x) || !(key in y) ? false : y[key] === x[key]
+    )
+  )
+);
+var isValidHttpUrl = (string) => {
+  let url;
+  try {
+    url = new URL(string);
+  } catch (_) {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+};
+var makeCancelable = (promise) => {
+  let hasCanceled = false;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    promise.then(
+      (val) => hasCanceled ? reject(Error("Cancelled")) : resolve(val)
+    );
+    promise.catch(
+      (error) => hasCanceled ? reject(Error("Cancelled")) : reject(error)
+    );
+  });
+  return {
+    promise: wrappedPromise,
+    cancel: () => {
+      hasCanceled = true;
+    }
+  };
+};
+var getSiValue = (si2) => new BigNumber2(10).pow(new BigNumber2(si2));
+var si = [
+  { value: getSiValue(24), symbol: "y", isMil: true },
+  { value: getSiValue(21), symbol: "z", isMil: true },
+  { value: getSiValue(18), symbol: "a", isMil: true },
+  { value: getSiValue(15), symbol: "f", isMil: true },
+  { value: getSiValue(12), symbol: "p", isMil: true },
+  { value: getSiValue(9), symbol: "n", isMil: true },
+  { value: getSiValue(6), symbol: "\u03BC", isMil: true },
+  { value: getSiValue(3), symbol: "m", isMil: true },
+  { value: new BigNumber2(1), symbol: "" },
+  { value: getSiValue(3), symbol: "k" },
+  { value: getSiValue(6), symbol: "M" },
+  { value: getSiValue(9), symbol: "G" },
+  { value: getSiValue(12), symbol: "T" },
+  { value: getSiValue(15), symbol: "P" },
+  { value: getSiValue(18), symbol: "E" },
+  { value: getSiValue(21), symbol: "Y" },
+  { value: getSiValue(24), symbol: "Z" }
+];
+var allowedSymbols = si.map((s) => s.symbol).join(", ").replace(", ,", ",");
+var floats = new RegExp("^[+]?[0-9]*[.,]{1}[0-9]*$");
+var ints = new RegExp("^[+]?[0-9]+$");
+var alphaFloats = new RegExp(
+  "^[+]?[0-9]*[.,]{1}[0-9]*[" + allowedSymbols + "]{1}$"
+);
+var alphaInts = new RegExp("^[+]?[0-9]*[" + allowedSymbols + "]{1}$");
+var evalUnits = (input, chainDecimals) => {
+  input = input && input.replace("+", "");
+  if (!floats.test(input) && !ints.test(input) && !alphaInts.test(input) && !alphaFloats.test(input)) {
+    return [null, "Input is not correct. Use numbers, floats or expression (e.g. 1k, 1.3m)" /* GIBBERISH */];
+  }
+  const symbol = input.replace(/[0-9.,]/g, "");
+  const siVal = si.find((s) => s.symbol === symbol);
+  const numberStr = input.replace(symbol, "").replace(",", ".");
+  let numeric = new BigNumber2(0);
+  if (!siVal) {
+    return [null, "Provided symbol is not correct" /* SYMBOL_ERROR */];
+  }
+  const decimalsBn = new BigNumber2(10).pow(new BigNumber2(chainDecimals));
+  const containDecimal = numberStr.includes(".");
+  const [decPart, fracPart] = numberStr.split(".");
+  const fracDecimals = fracPart?.length || 0;
+  const fracExp = new BigNumber2(10).pow(new BigNumber2(fracDecimals));
+  numeric = containDecimal ? new BigNumber2(
+    new BigNumber2(decPart).multipliedBy(fracExp).plus(new BigNumber2(fracPart))
+  ) : new BigNumber2(new BigNumber2(numberStr));
+  numeric = numeric.multipliedBy(decimalsBn);
+  if (containDecimal) {
+    numeric = siVal.isMil ? numeric.dividedBy(siVal.value).dividedBy(fracExp) : numeric.multipliedBy(siVal.value).dividedBy(fracExp);
+  } else {
+    numeric = siVal.isMil ? numeric.dividedBy(siVal.value) : numeric.multipliedBy(siVal.value);
+  }
+  if (numeric.eq(new BigNumber2(0))) {
+    return [null, "You cannot send 0 funds" /* ZERO */];
+  }
+  return [numeric, "" /* SUCCESS */];
+};
+var transformToBaseUnit = (estFee, chainDecimals) => {
+  const t = estFee.length - chainDecimals;
+  let s = "";
+  if (t < 0) {
+    for (let i = 0; i < Math.abs(t) - 1; i++) {
+      s += "0";
+    }
+    s = s + estFee;
+    for (let i = 0; i < s.length; i++) {
+      if (s.slice(s.length - 1) !== "0") {
+        break;
+      }
+      s = s.substring(0, s.length - 1);
+    }
+    s = "0." + s;
+  } else {
+    s = (parseInt(estFee) / 10 ** chainDecimals).toString();
+  }
+  return parseFloat(s) !== 0 ? s : "0";
+};
+var unimplemented = ({ ...props }) => {
+};
+var mergeDeep = (target, ...sources) => {
+  if (!sources.length) {
+    return target;
+  }
+  const isObject = (item) => item && typeof item === "object" && !Array.isArray(item);
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) {
+          Object.assign(target, { [key]: {} });
+        }
+        mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return mergeDeep(target, ...sources);
+};
+export {
+  addedTo,
+  appendOr,
+  appendOrEmpty,
+  applyWidthAsPadding,
+  camelize,
+  capitalizeFirstLetter,
+  determinePoolDisplay,
+  ellipsisFn,
+  evalUnits,
+  extractUrlValue,
+  greaterThanZero,
+  inChrome,
+  isNotZero,
+  isValidAddress,
+  isValidHttpUrl,
+  localStorageOrDefault,
+  makeCancelable,
+  matchedProperties,
+  mergeDeep,
+  minDecimalPlaces,
+  pageFromUri,
+  planckToUnit,
+  remToUnit,
+  removeVarFromUrlHash,
+  removedFrom,
+  rmCommas,
+  setStateWithRef,
+  shuffle,
+  snakeToCamel,
+  sortWithNull,
+  transformToBaseUnit,
+  unescape,
+  unimplemented,
+  unitToPlanck,
+  varToUrlHash,
+  withTimeout
+};
+/* @license Copyright 2024 w3ux authors & contributors
+SPDX-License-Identifier: GPL-3.0-only */

package/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@w3ux/utils",
+  "version": "0.0.1",
+  "license": "GPL-3.0-only",
+  "type": "module"
+}

package/types.d.ts

@@ -0,0 +1,12 @@
+type AnyJson = any;
+type AnyObject = any;
+type AnyFunction = any;
+declare enum EvalMessages {
+    GIBBERISH = "Input is not correct. Use numbers, floats or expression (e.g. 1k, 1.3m)",
+    ZERO = "You cannot send 0 funds",
+    SUCCESS = "",
+    SYMBOL_ERROR = "Provided symbol is not correct",
+    GENERAL_ERROR = "Check your input. Something went wrong"
+}
+
+export { type AnyFunction, type AnyJson, type AnyObject, EvalMessages };

package/types.js

@@ -0,0 +1,14 @@
+// src/types.ts
+var EvalMessages = /* @__PURE__ */ ((EvalMessages2) => {
+  EvalMessages2["GIBBERISH"] = "Input is not correct. Use numbers, floats or expression (e.g. 1k, 1.3m)";
+  EvalMessages2["ZERO"] = "You cannot send 0 funds";
+  EvalMessages2["SUCCESS"] = "";
+  EvalMessages2["SYMBOL_ERROR"] = "Provided symbol is not correct";
+  EvalMessages2["GENERAL_ERROR"] = "Check your input. Something went wrong";
+  return EvalMessages2;
+})(EvalMessages || {});
+export {
+  EvalMessages
+};
+/* @license Copyright 2024 w3ux authors & contributors
+SPDX-License-Identifier: GPL-3.0-only */

package/unit.d.ts

@@ -0,0 +1,165 @@
+import { BigNumber } from 'bignumber.js';
+import { MutableRefObject, RefObject } from 'react';
+import { AnyJson, AnyObject } from './types.js';
+
+/**
+ * @name remToUnit
+ * @summary Converts a rem string to a number.
+ */
+declare const remToUnit: (rem: string) => number;
+/**
+ * @name planckToUnit
+ * @summary convert planck to the token unit.
+ * @description
+ * Converts an on chain balance value in BigNumber planck to a decimal value in token unit. (1 token
+ * = 10^units planck).
+ */
+declare const planckToUnit: (val: BigNumber, units: number) => BigNumber;
+/**
+ * @name unitToPlanck
+ * @summary Convert the token unit to planck.
+ * @description
+ * Converts a balance in token unit to an equivalent value in planck by applying the chain decimals
+ * point. (1 token = 10^units planck).
+ */
+declare const unitToPlanck: (val: string, units: number) => BigNumber;
+/**
+ * @name capitalizeFirstLetter
+ * @summary Capitalize the first letter of a string.
+ */
+declare const capitalizeFirstLetter: (string: string) => string;
+/**
+ * @name snakeToCamel
+ * @summary converts a string from snake / kebab-case to camel-case.
+ */
+declare const snakeToCamel: (str: string) => string;
+/**
+ * @name setStateWithRef
+ * @summary Synchronize React state and its reference with the provided value.
+ */
+declare const setStateWithRef: <T>(value: T, setState: (_state: T) => void, ref: MutableRefObject<T>) => void;
+/**
+ * @name localStorageOrDefault
+ * @summary Retrieve the local stroage value with the key, return defult value if it is not
+ * found.
+ */
+declare const localStorageOrDefault: <T>(key: string, _default: T, parse?: boolean) => string | T;
+/**
+ * @name isValidAddress
+ * @summary Return whether an address is valid Substrate address.
+ */
+declare const isValidAddress: (address: string) => boolean;
+/**
+ * @name determinePoolDisplay
+ * @summary A pool will be displayed with either its set metadata or its address.
+ */
+declare const determinePoolDisplay: (address: string, batchItem: AnyJson) => any;
+/**
+ * @name extractUrlValue
+ * @summary Extracts a URL value from a URL string.
+ */
+declare const extractUrlValue: (key: string, url?: string) => string;
+/**
+ * @name varToUrlHash
+ * @summary Puts a variable into the URL hash as a param.
+ * @description
+ * Since url variables are added to the hash and are not treated as URL params, the params are split
+ * and parsed into a `URLSearchParams`.
+ */
+declare const varToUrlHash: (key: string, val: string, addIfMissing: boolean) => void;
+/**
+ * @name removeVarFromUrlHash
+ * @summary
+ * Removes a variable `key` from the URL hash if it exists. Removes dangling `?` if no URL variables
+ * exist.
+ */
+declare const removeVarFromUrlHash: (key: string) => void;
+/**
+ * @name sortWithNull
+ * @summary Sorts an array with nulls last.
+ */
+declare const sortWithNull: (ascending: boolean) => (a: AnyJson, b: AnyJson) => 0 | 1 | -1;
+/**
+ * @name applyWidthAsPadding
+ * @summary Applies width of subject to paddingRight of container.
+ */
+declare const applyWidthAsPadding: (subjectRef: RefObject<HTMLDivElement>, containerRef: RefObject<HTMLDivElement>) => void;
+/**
+ * @name unescape
+ * @summary Replaces \” with “
+ */
+declare const unescape: (val: string) => string;
+/**
+ * @name inChrome
+ * @summary Whether the application is rendering in Chrome.
+ */
+declare const inChrome: () => boolean;
+/**
+ * @name addedTo
+ * @summary Given 2 objects and some keys, return items in the fresh object that do not exist in the
+ * stale object by matching the given common key values of both objects.
+ */
+declare const addedTo: (fresh: AnyObject[], stale: AnyObject[], keys: string[]) => AnyObject[];
+/**
+ * @name removedFrom
+ * @summary Given 2 objects and some keys, return items in the stale object that do not exist in the
+ * fresh object by matching the given common key values of both objects.
+ */
+declare const removedFrom: (fresh: AnyObject[], stale: AnyObject[], keys: string[]) => AnyObject[];
+/**
+ * @name matchedProperties
+ * @summary Given 2 objects and some keys, return items in object 1 that also exist in object 2 by
+ * matching the given common key values of both objects.
+ */
+declare const matchedProperties: (objX: AnyObject[], objY: AnyObject[], keys: string[]) => AnyObject[];
+/**
+ * @name isValidHttpUrl
+ * @summary Give a string, return whether it is a valid http URL.
+ * @param string  - The string to check.
+ */
+declare const isValidHttpUrl: (string: string) => boolean;
+/**
+ * @name makeCancelable
+ * @summary Makes a promise cancellable.
+ * @param promise  - The promise to make cancellable.
+ */
+declare const makeCancelable: (promise: Promise<AnyObject>) => {
+    promise: Promise<unknown>;
+    cancel: () => void;
+};
+/**
+ * A function that identifes integer/float(comma or dot)/expressions (such as 1k)
+ * and converts to actual value (or reports an error).
+ * @param {string} input
+ * @returns {[number | null, string]} an array of 2 items
+ * the first is the actual calculated number (or null if none) while
+ * the second is the message that should appear in case of error
+ */
+declare const evalUnits: (input: string, chainDecimals: number) => [BigNumber | null, string];
+/**
+ * The transformToBaseUnit function is used to transform a given estimated
+ * fee value from its current representation to its base unit representation,
+ * considering the provided chain decimals. The function is designed to handle
+ * cases where the chain decimals are either greater or less than the length
+ * of the estimated fee.
+ * @param {string} estFee : The estimated fee value that needs to be transformed
+ * to its base unit representation.
+ * @param {number} chainDecimals: The number of decimal places used by the blockchain.
+ */
+declare const transformToBaseUnit: (estFee: string, chainDecimals: number) => string;
+/**
+ * @name unimplemented
+ * @summary A placeholder function to signal a deliberate unimplementation.
+ * Consumes an arbitrary number of props.
+ */
+declare const unimplemented: ({ ...props }: {
+    [x: string]: any;
+}) => void;
+/**
+ * Deep merge two objects.
+ * @param target
+ * @param ...sources
+ */
+declare const mergeDeep: (target: AnyObject, ...sources: AnyObject[]) => AnyObject;
+
+export { addedTo, applyWidthAsPadding, capitalizeFirstLetter, determinePoolDisplay, evalUnits, extractUrlValue, inChrome, isValidAddress, isValidHttpUrl, localStorageOrDefault, makeCancelable, matchedProperties, mergeDeep, planckToUnit, remToUnit, removeVarFromUrlHash, removedFrom, setStateWithRef, snakeToCamel, sortWithNull, transformToBaseUnit, unescape, unimplemented, unitToPlanck, varToUrlHash };

package/unit.js

@@ -0,0 +1,321 @@
+// src/unit.ts
+import { decodeAddress, encodeAddress } from "@polkadot/keyring";
+import { hexToU8a, isHex, u8aToString, u8aUnwrapBytes } from "@polkadot/util";
+import { BigNumber as BigNumber2 } from "bignumber.js";
+
+// src/base.ts
+import { BigNumber } from "bignumber.js";
+var ellipsisFn = (str, amount = 6, position = "center") => {
+  const half = str.length / 2;
+  if (amount <= 4) {
+    if (position === "center") {
+      return str.slice(0, 4) + "..." + str.slice(-4);
+    }
+    if (position === "end") {
+      return str.slice(0, 4) + "...";
+    }
+    return "..." + str.slice(-4);
+  }
+  if (position === "center") {
+    return amount >= (str.length - 2) / 2 ? str.slice(0, half - 3) + "..." + str.slice(-(half - 3)) : str.slice(0, amount) + "..." + str.slice(-amount);
+  }
+  if (amount >= str.length) {
+    if (position === "end") {
+      return str.slice(0, str.length - 3) + "...";
+    }
+    return "..." + str.slice(-(str.length - 3));
+  } else {
+    if (position === "end") {
+      return str.slice(0, amount) + "...";
+    }
+    return "..." + str.slice(amount);
+  }
+};
+
+// src/unit.ts
+var remToUnit = (rem) => Number(rem.slice(0, rem.length - 3)) * parseFloat(getComputedStyle(document.documentElement).fontSize);
+var planckToUnit = (val, units) => new BigNumber2(
+  val.dividedBy(new BigNumber2(10).exponentiatedBy(units)).toFixed(units)
+);
+var unitToPlanck = (val, units) => {
+  const init = new BigNumber2(!val.length || !val ? "0" : val);
+  return (!init.isNaN() ? init : new BigNumber2(0)).multipliedBy(new BigNumber2(10).exponentiatedBy(units)).integerValue();
+};
+var capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
+var snakeToCamel = (str) => str.toLowerCase().replace(
+  /([-_][a-z])/g,
+  (group) => group.toUpperCase().replace("-", "").replace("_", "")
+);
+var setStateWithRef = (value, setState, ref) => {
+  setState(value);
+  ref.current = value;
+};
+var localStorageOrDefault = (key, _default, parse = false) => {
+  const val = localStorage.getItem(key);
+  if (val === null) {
+    return _default;
+  }
+  if (parse) {
+    return JSON.parse(val);
+  }
+  return val;
+};
+var isValidAddress = (address) => {
+  try {
+    encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var determinePoolDisplay = (address, batchItem) => {
+  const defaultDisplay = ellipsisFn(address, 6);
+  let display = batchItem ?? defaultDisplay;
+  const displayAsBytes = u8aToString(u8aUnwrapBytes(display));
+  if (displayAsBytes !== "") {
+    display = displayAsBytes;
+  }
+  if (display === "") {
+    display = defaultDisplay;
+  }
+  return display;
+};
+var extractUrlValue = (key, url) => {
+  if (typeof url === "undefined") {
+    url = window.location.href;
+  }
+  const match = url.match(`[?&]${key}=([^&]+)`);
+  return match ? match[1] : null;
+};
+var varToUrlHash = (key, val, addIfMissing) => {
+  const hash = window.location.hash;
+  const [page, params] = hash.split("?");
+  const searchParams = new URLSearchParams(params);
+  if (searchParams.get(key) === null && !addIfMissing) {
+    return;
+  }
+  searchParams.set(key, val);
+  window.location.hash = `${page}?${searchParams.toString()}`;
+};
+var removeVarFromUrlHash = (key) => {
+  const hash = window.location.hash;
+  const [page, params] = hash.split("?");
+  const searchParams = new URLSearchParams(params);
+  if (searchParams.get(key) === null) {
+    return;
+  }
+  searchParams.delete(key);
+  const paramsAsStr = searchParams.toString();
+  window.location.hash = `${page}${paramsAsStr ? `?${paramsAsStr}` : ``}`;
+};
+var sortWithNull = (ascending) => (a, b) => {
+  if (a === b) {
+    return 0;
+  }
+  if (a === null) {
+    return 1;
+  }
+  if (b === null) {
+    return -1;
+  }
+  if (ascending) {
+    return a < b ? -1 : 1;
+  }
+  return a < b ? 1 : -1;
+};
+var applyWidthAsPadding = (subjectRef, containerRef) => {
+  if (containerRef.current && subjectRef.current) {
+    containerRef.current.style.paddingRight = `${subjectRef.current.offsetWidth + remToUnit("1rem")}px`;
+  }
+};
+var unescape = (val) => val.replace(/\\"/g, '"');
+var inChrome = () => {
+  const isChromium = window?.chrome || null;
+  const winNav = window?.navigator || null;
+  const isOpera = typeof window?.opr !== "undefined";
+  const isIEedge = winNav?.userAgent.indexOf("Edg") > -1 || false;
+  const isIOSChrome = winNav?.userAgent.match("CriOS") || false;
+  if (isIOSChrome) {
+    return true;
+  }
+  if (isChromium !== null && typeof isChromium !== "undefined" && isOpera === false && isIEedge === false) {
+    return true;
+  }
+  return false;
+};
+var addedTo = (fresh, stale, keys) => typeof fresh !== "object" || typeof stale !== "object" || !keys.length ? [] : fresh.filter(
+  (freshItem) => !stale.find(
+    (staleItem) => keys.every(
+      (key) => !(key in staleItem) || !(key in freshItem) ? false : staleItem[key] === freshItem[key]
+    )
+  )
+);
+var removedFrom = (fresh, stale, keys) => typeof fresh !== "object" || typeof stale !== "object" || !keys.length ? [] : stale.filter(
+  (staleItem) => !fresh.find(
+    (freshItem) => keys.every(
+      (key) => !(key in staleItem) || !(key in freshItem) ? false : freshItem[key] === staleItem[key]
+    )
+  )
+);
+var matchedProperties = (objX, objY, keys) => typeof objX !== "object" || typeof objY !== "object" || !keys.length ? [] : objY.filter(
+  (x) => objX.find(
+    (y) => keys.every(
+      (key) => !(key in x) || !(key in y) ? false : y[key] === x[key]
+    )
+  )
+);
+var isValidHttpUrl = (string) => {
+  let url;
+  try {
+    url = new URL(string);
+  } catch (_) {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+};
+var makeCancelable = (promise) => {
+  let hasCanceled = false;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    promise.then(
+      (val) => hasCanceled ? reject(Error("Cancelled")) : resolve(val)
+    );
+    promise.catch(
+      (error) => hasCanceled ? reject(Error("Cancelled")) : reject(error)
+    );
+  });
+  return {
+    promise: wrappedPromise,
+    cancel: () => {
+      hasCanceled = true;
+    }
+  };
+};
+var getSiValue = (si2) => new BigNumber2(10).pow(new BigNumber2(si2));
+var si = [
+  { value: getSiValue(24), symbol: "y", isMil: true },
+  { value: getSiValue(21), symbol: "z", isMil: true },
+  { value: getSiValue(18), symbol: "a", isMil: true },
+  { value: getSiValue(15), symbol: "f", isMil: true },
+  { value: getSiValue(12), symbol: "p", isMil: true },
+  { value: getSiValue(9), symbol: "n", isMil: true },
+  { value: getSiValue(6), symbol: "\u03BC", isMil: true },
+  { value: getSiValue(3), symbol: "m", isMil: true },
+  { value: new BigNumber2(1), symbol: "" },
+  { value: getSiValue(3), symbol: "k" },
+  { value: getSiValue(6), symbol: "M" },
+  { value: getSiValue(9), symbol: "G" },
+  { value: getSiValue(12), symbol: "T" },
+  { value: getSiValue(15), symbol: "P" },
+  { value: getSiValue(18), symbol: "E" },
+  { value: getSiValue(21), symbol: "Y" },
+  { value: getSiValue(24), symbol: "Z" }
+];
+var allowedSymbols = si.map((s) => s.symbol).join(", ").replace(", ,", ",");
+var floats = new RegExp("^[+]?[0-9]*[.,]{1}[0-9]*$");
+var ints = new RegExp("^[+]?[0-9]+$");
+var alphaFloats = new RegExp(
+  "^[+]?[0-9]*[.,]{1}[0-9]*[" + allowedSymbols + "]{1}$"
+);
+var alphaInts = new RegExp("^[+]?[0-9]*[" + allowedSymbols + "]{1}$");
+var evalUnits = (input, chainDecimals) => {
+  input = input && input.replace("+", "");
+  if (!floats.test(input) && !ints.test(input) && !alphaInts.test(input) && !alphaFloats.test(input)) {
+    return [null, "Input is not correct. Use numbers, floats or expression (e.g. 1k, 1.3m)" /* GIBBERISH */];
+  }
+  const symbol = input.replace(/[0-9.,]/g, "");
+  const siVal = si.find((s) => s.symbol === symbol);
+  const numberStr = input.replace(symbol, "").replace(",", ".");
+  let numeric = new BigNumber2(0);
+  if (!siVal) {
+    return [null, "Provided symbol is not correct" /* SYMBOL_ERROR */];
+  }
+  const decimalsBn = new BigNumber2(10).pow(new BigNumber2(chainDecimals));
+  const containDecimal = numberStr.includes(".");
+  const [decPart, fracPart] = numberStr.split(".");
+  const fracDecimals = fracPart?.length || 0;
+  const fracExp = new BigNumber2(10).pow(new BigNumber2(fracDecimals));
+  numeric = containDecimal ? new BigNumber2(
+    new BigNumber2(decPart).multipliedBy(fracExp).plus(new BigNumber2(fracPart))
+  ) : new BigNumber2(new BigNumber2(numberStr));
+  numeric = numeric.multipliedBy(decimalsBn);
+  if (containDecimal) {
+    numeric = siVal.isMil ? numeric.dividedBy(siVal.value).dividedBy(fracExp) : numeric.multipliedBy(siVal.value).dividedBy(fracExp);
+  } else {
+    numeric = siVal.isMil ? numeric.dividedBy(siVal.value) : numeric.multipliedBy(siVal.value);
+  }
+  if (numeric.eq(new BigNumber2(0))) {
+    return [null, "You cannot send 0 funds" /* ZERO */];
+  }
+  return [numeric, "" /* SUCCESS */];
+};
+var transformToBaseUnit = (estFee, chainDecimals) => {
+  const t = estFee.length - chainDecimals;
+  let s = "";
+  if (t < 0) {
+    for (let i = 0; i < Math.abs(t) - 1; i++) {
+      s += "0";
+    }
+    s = s + estFee;
+    for (let i = 0; i < s.length; i++) {
+      if (s.slice(s.length - 1) !== "0") {
+        break;
+      }
+      s = s.substring(0, s.length - 1);
+    }
+    s = "0." + s;
+  } else {
+    s = (parseInt(estFee) / 10 ** chainDecimals).toString();
+  }
+  return parseFloat(s) !== 0 ? s : "0";
+};
+var unimplemented = ({ ...props }) => {
+};
+var mergeDeep = (target, ...sources) => {
+  if (!sources.length) {
+    return target;
+  }
+  const isObject = (item) => item && typeof item === "object" && !Array.isArray(item);
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) {
+          Object.assign(target, { [key]: {} });
+        }
+        mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return mergeDeep(target, ...sources);
+};
+export {
+  addedTo,
+  applyWidthAsPadding,
+  capitalizeFirstLetter,
+  determinePoolDisplay,
+  evalUnits,
+  extractUrlValue,
+  inChrome,
+  isValidAddress,
+  isValidHttpUrl,
+  localStorageOrDefault,
+  makeCancelable,
+  matchedProperties,
+  mergeDeep,
+  planckToUnit,
+  remToUnit,
+  removeVarFromUrlHash,
+  removedFrom,
+  setStateWithRef,
+  snakeToCamel,
+  sortWithNull,
+  transformToBaseUnit,
+  unescape,
+  unimplemented,
+  unitToPlanck,
+  varToUrlHash
+};
+/* @license Copyright 2024 w3ux authors & contributors
+SPDX-License-Identifier: GPL-3.0-only */