@w3ux/utils 0.2.0 → 0.4.0-alpha.0

package/index.cjs

@@ -0,0 +1,493 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  addedTo: () => addedTo,
+  appendOr: () => appendOr,
+  appendOrEmpty: () => appendOrEmpty,
+  applyWidthAsPadding: () => applyWidthAsPadding,
+  camelize: () => camelize,
+  capitalizeFirstLetter: () => capitalizeFirstLetter,
+  determinePoolDisplay: () => determinePoolDisplay,
+  ellipsisFn: () => ellipsisFn,
+  evalUnits: () => evalUnits,
+  extractUrlValue: () => extractUrlValue,
+  formatAccountSs58: () => formatAccountSs58,
+  greaterThanZero: () => greaterThanZero,
+  inChrome: () => inChrome,
+  isNotZero: () => isNotZero,
+  isValidAddress: () => isValidAddress,
+  isValidHttpUrl: () => isValidHttpUrl,
+  localStorageOrDefault: () => localStorageOrDefault,
+  makeCancelable: () => makeCancelable,
+  matchedProperties: () => matchedProperties,
+  mergeDeep: () => mergeDeep,
+  minDecimalPlaces: () => minDecimalPlaces,
+  pageFromUri: () => pageFromUri,
+  planckToUnit: () => planckToUnit,
+  remToUnit: () => remToUnit,
+  removeHexPrefix: () => removeHexPrefix,
+  removeVarFromUrlHash: () => removeVarFromUrlHash,
+  removedFrom: () => removedFrom,
+  rmCommas: () => rmCommas,
+  setStateWithRef: () => setStateWithRef,
+  shuffle: () => shuffle,
+  snakeToCamel: () => snakeToCamel,
+  sortWithNull: () => sortWithNull,
+  stringToBigNumber: () => stringToBigNumber,
+  transformToBaseUnit: () => transformToBaseUnit,
+  unescape: () => unescape,
+  unimplemented: () => unimplemented,
+  unitToPlanck: () => unitToPlanck,
+  varToUrlHash: () => varToUrlHash,
+  withTimeout: () => withTimeout
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/base.ts
+var import_bignumber = require("bignumber.js");
+var import_keyring = __toESM(require("@polkadot/keyring"), 1);
+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 import_bignumber.BigNumber(rmCommas(val).split(".")[0] || 0);
+  const decimals = val.split(".")[1] || "";
+  const missingDecimals = new import_bignumber.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}`;
+var formatAccountSs58 = (address, ss58) => {
+  try {
+    const keyring = new import_keyring.default();
+    keyring.setSS58Format(ss58);
+    const formatted = keyring.addFromAddress(address).address;
+    if (formatted !== address) {
+      return formatted;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+};
+var removeHexPrefix = (str) => str.replace(/^0x/, "");
+
+// src/unit.ts
+var import_keyring2 = require("@polkadot/keyring");
+var import_util = require("@polkadot/util");
+var import_bignumber2 = require("bignumber.js");
+var remToUnit = (rem) => Number(rem.slice(0, rem.length - 3)) * parseFloat(getComputedStyle(document.documentElement).fontSize);
+var planckToUnit = (val, units) => new import_bignumber2.BigNumber(
+  val.dividedBy(new import_bignumber2.BigNumber(10).exponentiatedBy(units)).toFixed(units)
+);
+var unitToPlanck = (val, units) => {
+  const init = new import_bignumber2.BigNumber(!val.length || !val ? "0" : val);
+  return (!init.isNaN() ? init : new import_bignumber2.BigNumber(0)).multipliedBy(new import_bignumber2.BigNumber(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 {
+    (0, import_keyring2.encodeAddress)((0, import_util.isHex)(address) ? (0, import_util.hexToU8a)(address) : (0, import_keyring2.decodeAddress)(address));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var determinePoolDisplay = (address, batchItem) => {
+  const defaultDisplay = ellipsisFn(address, 6);
+  let display = batchItem ?? defaultDisplay;
+  const displayAsBytes = (0, import_util.u8aToString)((0, import_util.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 import_bignumber2.BigNumber(10).pow(new import_bignumber2.BigNumber(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 import_bignumber2.BigNumber(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 import_bignumber2.BigNumber(0);
+  if (!siVal) {
+    return [null, "Provided symbol is not correct" /* SYMBOL_ERROR */];
+  }
+  const decimalsBn = new import_bignumber2.BigNumber(10).pow(new import_bignumber2.BigNumber(chainDecimals));
+  const containDecimal = numberStr.includes(".");
+  const [decPart, fracPart] = numberStr.split(".");
+  const fracDecimals = fracPart?.length || 0;
+  const fracExp = new import_bignumber2.BigNumber(10).pow(new import_bignumber2.BigNumber(fracDecimals));
+  numeric = containDecimal ? new import_bignumber2.BigNumber(
+    new import_bignumber2.BigNumber(decPart).multipliedBy(fracExp).plus(new import_bignumber2.BigNumber(fracPart))
+  ) : new import_bignumber2.BigNumber(new import_bignumber2.BigNumber(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 import_bignumber2.BigNumber(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);
+};
+var stringToBigNumber = (value) => new import_bignumber2.BigNumber(rmCommas(value));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addedTo,
+  appendOr,
+  appendOrEmpty,
+  applyWidthAsPadding,
+  camelize,
+  capitalizeFirstLetter,
+  determinePoolDisplay,
+  ellipsisFn,
+  evalUnits,
+  extractUrlValue,
+  formatAccountSs58,
+  greaterThanZero,
+  inChrome,
+  isNotZero,
+  isValidAddress,
+  isValidHttpUrl,
+  localStorageOrDefault,
+  makeCancelable,
+  matchedProperties,
+  mergeDeep,
+  minDecimalPlaces,
+  pageFromUri,
+  planckToUnit,
+  remToUnit,
+  removeHexPrefix,
+  removeVarFromUrlHash,
+  removedFrom,
+  rmCommas,
+  setStateWithRef,
+  shuffle,
+  snakeToCamel,
+  sortWithNull,
+  stringToBigNumber,
+  transformToBaseUnit,
+  unescape,
+  unimplemented,
+  unitToPlanck,
+  varToUrlHash,
+  withTimeout
+});
+/* @license Copyright 2024 w3ux authors & contributors
+SPDX-License-Identifier: GPL-3.0-only */

package/index.d.cts

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

package/index.d.ts

@@ -1,5 +1,6 @@
 export { appendOr, appendOrEmpty, camelize, ellipsisFn, formatAccountSs58, greaterThanZero, isNotZero, minDecimalPlaces, pageFromUri, removeHexPrefix, 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, stringToBigNumber, transformToBaseUnit, unescape, unimplemented, unitToPlanck, varToUrlHash } from './unit.js';
 import 'bignumber.js';
-import './types.js';
+import '@w3ux/types';
 import 'react';
+import './types.js';

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@w3ux/utils",
-  "version": "0.2.0",
+  "version": "0.4.0-alpha.0",
   "license": "GPL-3.0-only",
-  "type": "module",
   "dependencies": {
     "@polkadot/keyring": "^12.6.2",
     "@polkadot/util": "^12.6.2",
     "bignumber.js": "^9.1.1"
+  },
+  "main": "index.cjs",
+  "module": "index.js",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
   }
 }

package/types.cjs

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+__export(types_exports, {
+  EvalMessages: () => EvalMessages
+});
+module.exports = __toCommonJS(types_exports);
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvalMessages
+});
+/* @license Copyright 2024 w3ux authors & contributors
+SPDX-License-Identifier: GPL-3.0-only */

package/types.d.cts

@@ -0,0 +1,10 @@
+type AnyObject = 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 AnyObject, EvalMessages };

package/types.d.ts

@@ -1,6 +1,4 @@
-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",
@@ -9,4 +7,4 @@ declare enum EvalMessages {
     GENERAL_ERROR = "Check your input. Something went wrong"
 }
 
-export { type AnyFunction, type AnyJson, type AnyObject, EvalMessages };
+export { type AnyObject, EvalMessages };