@talismn/util 0.5.6 → 0.5.8

package/dist/talismn-util.esm.js

@@ -1,463 +0,0 @@
-import { twMerge } from 'tailwind-merge';
-import { concat, take, skip, debounceTime, shareReplay, Subject, tap, ReplaySubject, timer, switchMap, from, startWith, map, catchError, of, Observable, BehaviorSubject, distinctUntilChanged } from 'rxjs';
-import BigNumber from 'bignumber.js';
-import { isEqual } from 'lodash-es';
-
-const addTrailingSlash = url => {
-  if (url.endsWith("/")) {
-    return url;
-  }
-  return `${url}/`;
-};
-
-/**
- * Javascript's `Math` library for `BigInt`.
- * Taken from https://stackoverflow.com/questions/51867270/is-there-a-library-similar-to-math-that-supports-javascript-bigint/64953280#64953280
- */
-const BigMath = {
-  abs(x) {
-    return x < 0n ? -x : x;
-  },
-  sign(x) {
-    if (x === 0n) return 0n;
-    return x < 0n ? -1n : 1n;
-  },
-  // TODO: Improve our babel/tsc config to let us use the `**` operator on bigint values.
-  // Error thrown: Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later. ts(2791)
-  // pow(base: bigint, exponent: bigint) {
-  //   return base ** exponent
-  // },
-  min(value, ...values) {
-    for (const v of values) if (v < value) value = v;
-    return value;
-  },
-  max(value, ...values) {
-    for (const v of values) if (v > value) value = v;
-    return value;
-  }
-};
-
-const classNames = twMerge;
-const cn = twMerge;
-
-/**
- * In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
- * resolved or rejected at a later point in time, typically by code outside of the current function scope.
- *
- * This pattern is often used when dealing with asynchronous operations that involve multiple steps or when
- * the result of an operation cannot be immediately determined.
- */
-function Deferred() {
-  let resolve;
-  let reject;
-  let isPending = true;
-  let isResolved = false;
-  let isRejected = false;
-  const promise = new Promise((innerResolve, innerReject) => {
-    resolve = value => {
-      isPending = false;
-      isResolved = true;
-      innerResolve(value);
-    };
-    reject = reason => {
-      isPending = false;
-      isRejected = true;
-      innerReject(reason);
-    };
-  });
-  return {
-    promise,
-    resolve,
-    reject,
-    isPending: () => isPending,
-    isResolved: () => isResolved,
-    isRejected: () => isRejected
-  };
-}
-
-/**
- * An rxjs operator which:
- *
- * 1. Emits the first value it receives from the source observable, then:
- * 2. Debounces any future values by `timeout` ms.
- */
-const firstThenDebounce = timeout => source => concat(source.pipe(take(1)), source.pipe(skip(1)).pipe(debounceTime(timeout)));
-
-const MIN_DIGITS = 4; // less truncates more than what compact formating is
-const MAX_DECIMALS_FORMAT = 12;
-
-/**
- * Custom decimal number formatting for Talisman
- * note that the NumberFormat().format() call is the ressource heavy part, it's not worth trying to optimize other parts
- * @param num input number
- * @param digits number of significant digits to display
- * @param locale locale used to format the number
- * @param options formatting options
- * @returns the formatted value
- */
-const formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
-  if (num === null || num === undefined) return "";
-  if (digits < MIN_DIGITS) digits = MIN_DIGITS;
-  const value = new BigNumber(num);
-  // very small numbers should display "< 0.0001"
-  const minDisplayVal = 1 / Math.pow(10, digits);
-  if (value.gt(0) && value.lt(minDisplayVal)) return `< ${formatDecimals(minDisplayVal)}`;
-
-  // count digits
-  const flooredValue = value.integerValue();
-  const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
-
-  // we never want to display a rounded up value
-  // to prevent JS default rounding, we will remove/truncate insignificant digits ourselves before formatting
-  let truncatedValue = value;
-  //remove insignificant fraction digits
-  const excessFractionDigitsPow10 = new BigNumber(10).pow(digits > intDigits ? digits - intDigits : 0);
-  truncatedValue = truncatedValue.multipliedBy(excessFractionDigitsPow10).integerValue().dividedBy(excessFractionDigitsPow10);
-
-  //remove insignificant integer digits
-  const excessIntegerDigits = new BigNumber(intDigits > digits ? intDigits - digits : 0);
-  const excessIntegerDigitsPow10 = new BigNumber(10).pow(excessIntegerDigits);
-  if (excessIntegerDigits.gt(0)) truncatedValue = truncatedValue.dividedBy(excessIntegerDigitsPow10).integerValue().multipliedBy(excessIntegerDigitsPow10);
-
-  // format
-
-  return Intl.NumberFormat(locale, {
-    // compact notation (K, M, B) if above 9999
-    notation: truncatedValue.gt(9999) ? "compact" : "standard",
-    // NOTE: possible values are from `0` to `21`
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#maximumsignificantdigits
-    maximumSignificantDigits: Math.max(1, Math.min(digits + (truncatedValue.lt(1) ? 1 : 0), 21)),
-    ...options
-  }).format(truncatedValue.toNumber());
-};
-
-const formatPrice = (price, currency, compact) => {
-  return Intl.NumberFormat(undefined, {
-    style: "currency",
-    currency,
-    currencyDisplay: currency === "usd" ? "narrowSymbol" : "symbol",
-    minimumSignificantDigits: 3,
-    maximumSignificantDigits: compact ? price < 1 ? 3 : 4 : undefined,
-    roundingPriority: compact ? "auto" : "morePrecision",
-    notation: compact ? "compact" : "standard"
-  }).format(price);
-};
-
-const CACHE = new Map();
-
-/**
- * When using react-rxjs hooks and state observables, the options are used as weak map keys.
- * This means that if the options object is recreated on each render, the observable will be recreated as well.
- * This utility function allows you to create a shared observable based on a namespace and arguments that, so react-rxjs can reuse the same observables
- *
- * @param namespace
- * @param args
- * @param createObservable
- * @param serializer
- * @returns
- */
-const getSharedObservable = (namespace, args, createObservable, serializer = args => JSON.stringify(args)) => {
-  const cacheKey = `${namespace}:${serializer(args)}`;
-  if (CACHE.has(cacheKey)) return CACHE.get(cacheKey);
-  const obs = createObservable(args);
-  const sharedObs = obs.pipe(shareReplay({
-    bufferSize: 1,
-    refCount: true
-  }));
-  CACHE.set(cacheKey, sharedObs);
-  return sharedObs;
-};
-
-function hasOwnProperty(obj, prop) {
-  if (typeof obj !== "object") return false;
-  if (obj === null) return false;
-  return prop in obj;
-}
-
-const isAbortError = error => {
-  return error instanceof Error && error.name === "AbortError";
-};
-
-function isArrayOf(array, func) {
-  if (array.length > 0 && array[0] instanceof func) return true;
-  return false;
-}
-
-const isAscii = str => {
-  return [...str].every(char => char.charCodeAt(0) <= 127);
-};
-
-const isBigInt = value => typeof value === "bigint";
-
-const isBooleanTrue = x => !!x;
-
-const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
-const isHexString = value => {
-  return typeof value === "string" && REGEX_HEX_STRING.test(value);
-};
-
-/**
- * WARNING: This function only checks against null or undefined, it does not coerce the value.
- * ie: false and 0 are considered not nil
- * Use isTruthy instead for a regular coercion check.
- *
- * @param value
- * @returns whether the value is neither null nor undefined
- */
-const isNotNil = value => value !== null && value !== undefined;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isPromise = value => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-
-/**
- * Tests to see if an object is an RxJS {@link Subject}.
- */
-function isSubject(object) {
-  if (!object) return false;
-  if (object instanceof Subject) return true;
-  return "asObservable" in object && isFn(object.asObservable) && "complete" in object && isFn(object.complete) && "error" in object && isFn(object.error) && "forEach" in object && isFn(object.forEach) && "next" in object && isFn(object.next) && "pipe" in object && isFn(object.pipe) && "subscribe" in object && isFn(object.subscribe) && "unsubscribe" in object && isFn(object.unsubscribe) && "closed" in object && isBool(object.closed) && "observed" in object && isBool(object.observed);
-}
-
-/**
- * Returns `true` if `value` is a function.
- */
-function isFn(value) {
-  return typeof value === "function";
-}
-
-/**
- * Returns `true` if `value` is a boolean.
- */
-function isBool(value) {
-  return typeof value === "boolean";
-}
-
-const isTruthy = value => Boolean(value);
-
-/**
- * An RxJS operator that keeps the source observable alive for a specified duration
- * after all subscribers have unsubscribed. This prevents expensive re-subscriptions
- * when subscribers come and go frequently.
- *
- * @param keepAliveMs - Duration in milliseconds to keep the source alive after last unsubscription
- * @returns MonoTypeOperatorFunction that can be used in pipe()
- *
- * @example
- * ```typescript
- * const data$ = expensive_api_call$.pipe(
- *   keepAlive(3000) // Keep alive for 3 seconds
- * );
- * ```
- */
-const keepAlive = timeout => {
-  let release;
-  return source => source.pipe(tap({
-    subscribe: () => {
-      release = keepSourceSubscribed(source, timeout);
-    },
-    unsubscribe: () => {
-      release?.();
-    }
-  }), shareReplay({
-    refCount: true,
-    bufferSize: 1
-  }));
-};
-const keepSourceSubscribed = (observable, ms) => {
-  const sub = observable.subscribe();
-  return () => setTimeout(() => sub.unsubscribe(), ms);
-};
-
-function planckToTokens(planck, tokenDecimals) {
-  if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
-  const base = 10;
-  const exponent = -1 * tokenDecimals;
-  const multiplier = base ** exponent;
-  return new BigNumber(planck).multipliedBy(multiplier).toString(10);
-}
-
-/**
- * Turns a value into a {@link ReplaySubject} of size 1.
- *
- * If the value is already a {@link ReplaySubject}, it will be returned as-is.
- *
- * If the value is a {@link Promise}, it will be awaited,
- * and the awaited value will be published into the {@link ReplaySubject} when it becomes available.
- *
- * For any other type of value, it will be immediately published into the {@link ReplaySubject}.
- */
-const replaySubjectFrom = initialValue => {
-  if (initialValue instanceof ReplaySubject) return initialValue;
-  const subject = new ReplaySubject(1);
-
-  // if initialValue is a promise, await it and then call `subject.next()` with the awaited value
-  if (isPromise(initialValue)) {
-    initialValue.then(value => subject.next(value), error => subject.error(error));
-    return subject;
-  }
-
-  // if initialValue is not a promise, immediately call `subject.next()` with the value
-  subject.next(initialValue);
-  return subject;
-};
-
-const sleep = ms => new Promise(resolve => {
-  if (process.env.NODE_ENV === "test") resolve();else setTimeout(resolve, ms);
-});
-
-/**
- * Takes a subject and splits it into two parts:
- *
- * 1. A function to submit new values into the subject.
- * 2. An observable for subscribing to new values from the subject.
- *
- * This can be helpful when, to avoid bugs, you want to expose only one
- * of these parts to external code and keep the other part private.
- */
-function splitSubject(subject) {
-  const next = value => subject.next(value);
-  const observable = subject.asObservable();
-  return [next, observable];
-}
-
-const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(new Error(reason)), ms));
-
-function tokensToPlanck(tokens, tokenDecimals) {
-  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
-  const base = 10;
-  const exponent = tokenDecimals;
-  const multiplier = base ** exponent;
-  return new BigNumber(tokens).multipliedBy(multiplier).toString(10);
-}
-
-/**
- * @name validateHexString
- * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
- * @param {string} str - string to check
- * @returns {`0x${string}`} - boolean
- * @example
- * validateHexString("0x1234") // "0x1234"
- * validateHexString("1234") // Error: Expected a hex string
- * validateHexString(1234) // Error: Expected a string
- **/
-const validateHexString = str => {
-  if (typeof str !== "string") {
-    throw new Error("Expected a string");
-  }
-  if (str.startsWith("0x")) {
-    return str;
-  }
-  throw new Error("Expected a hex string");
-};
-
-// Designed to be serializable as it can be sent to the frontend
-
-function getLoadable$(factory, options = {}) {
-  const {
-    getError,
-    refreshInterval
-  } = options;
-  const createLoadableStream = () => from(factory()).pipe(map(data => ({
-    status: "success",
-    data
-  })), catchError(error => of({
-    status: "error",
-    error: getError ? getError(error) : getGenericError(error)
-  })));
-  const source$ = refreshInterval ? timer(0, refreshInterval).pipe(switchMap(() => createLoadableStream())) : createLoadableStream();
-  return source$.pipe(startWith({
-    status: "loading"
-  }));
-}
-const getGenericError = error => ({
-  name: "Error",
-  message: getGenericErrorMessage(error)
-});
-const getGenericErrorMessage = error => {
-  if (typeof error === "string") {
-    return error;
-  } else if (error instanceof Error) {
-    return error.message;
-  } else if (error && typeof error === "object" && "message" in error) {
-    return error.message;
-  }
-  return String(error) || "Unknown error";
-};
-
-/**
- * Creates a shared observable for executing queries with caching, loading states, and automatic refresh capabilities.
- *
- * @example
- * ```typescript
- * const userQuery$ = getQuery$({
- *   namespace: 'users',
- *   args: { userId: 123 },
- *   queryFn: async ({ userId }) => fetchUser(userId),
- *   defaultValue: null,
- *   refreshInterval: 30000
- * });
- *
- * userQuery$.subscribe(result => {
- *   if (result.status === 'loaded') {
- *     console.log(result.data);
- *   }
- * });
- * ```
- */
-const getQuery$ = ({
-  namespace,
-  args,
-  queryFn,
-  defaultValue,
-  refreshInterval,
-  serializer = args => JSON.stringify(args)
-}) => {
-  return getSharedObservable(namespace, args, () => new Observable(subscriber => {
-    const controller = new AbortController();
-    const result = new BehaviorSubject({
-      status: "loading",
-      data: defaultValue,
-      error: undefined
-    });
-
-    // result subscription
-    const sub = result.pipe(distinctUntilChanged(isEqual)).subscribe(subscriber);
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let timeout = null;
-
-    // fetch result subscription
-    const run = () => {
-      if (controller.signal.aborted) return;
-      queryFn(args, controller.signal).then(data => {
-        if (controller.signal.aborted) return;
-        result.next({
-          status: "loaded",
-          data,
-          error: undefined
-        });
-      }).catch(error => {
-        if (controller.signal.aborted) return;
-        result.next({
-          status: "error",
-          data: undefined,
-          error
-        });
-      }).finally(() => {
-        if (controller.signal.aborted) return;
-        if (refreshInterval) timeout = setTimeout(run, refreshInterval);
-      });
-    };
-    run();
-    return () => {
-      sub.unsubscribe();
-      if (timeout) clearTimeout(timeout);
-      controller.abort(new Error("getQuery$ unsubscribed"));
-    };
-  }).pipe(shareReplay({
-    refCount: true,
-    bufferSize: 1
-  })), serializer);
-};
-
-export { BigMath, Deferred, MAX_DECIMALS_FORMAT, REGEX_HEX_STRING, addTrailingSlash, classNames, cn, firstThenDebounce, formatDecimals, formatPrice, getLoadable$, getQuery$, getSharedObservable, hasOwnProperty, isAbortError, isArrayOf, isAscii, isBigInt, isBooleanTrue, isHexString, isNotNil, isPromise, isSubject, isTruthy, keepAlive, planckToTokens, replaySubjectFrom, sleep, splitSubject, throwAfter, tokensToPlanck, validateHexString };