@talismn/util 0.4.2 → 0.5.1

package/dist/declarations/src/Prettify.d.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/declarations/src/classNames.d.ts

@@ -1 +1,2 @@
 export declare const classNames: (...classLists: import("tailwind-merge").ClassNameValue[]) => string;
+export declare const cn: (...classLists: import("tailwind-merge").ClassNameValue[]) => string;

package/dist/declarations/src/getLoadable.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from "rxjs";
+type LoadableError = {
+    name: string;
+    message: string;
+};
+export type Loadable<T = unknown> = {
+    status: "loading";
+    data?: T;
+    error?: undefined;
+} | {
+    status: "success";
+    data: T;
+    error?: undefined;
+} | {
+    status: "error";
+    data?: T;
+    error: LoadableError;
+};
+export type LoadableStatus = Loadable["status"];
+export type LoadableOptions = {
+    getError?: (error: unknown) => LoadableError;
+    refreshInterval?: number;
+};
+export declare function getLoadable$<T>(factory: () => Promise<T>, options?: LoadableOptions): Observable<Loadable<T>>;
+export {};

package/dist/declarations/src/getSharedObservable.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from "rxjs";
+/**
+ * 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
+ */
+export declare const getSharedObservable: <Args, Output, ObsOutput = Observable<Output>>(namespace: string, args: Args, createObservable: (args: Args) => ObsOutput, serializer?: (args: Args) => string) => ObsOutput;

package/dist/declarations/src/index.d.ts

@@ -1,30 +1,30 @@
 export * from "./addTrailingSlash";
 export * from "./BigMath";
-export * from "./blake2Concat";
 export * from "./classNames";
-export * from "./convertAddress";
-export * from "./decodeAnyAddress";
-export * from "./decodeSs58Format";
 export * from "./deferred";
-export * from "./encodeAnyAddress";
 export * from "./firstThenDebounce";
 export * from "./formatDecimals";
 export * from "./formatPrice";
 export * from "./FunctionPropertyNames";
+export * from "./getSharedObservable";
 export * from "./hasOwnProperty";
+export * from "./isAbortError";
 export * from "./isArrayOf";
+export * from "./isAscii";
 export * from "./isBigInt";
 export * from "./isBooleanTrue";
-export * from "./isEthereumAddress";
-export * from "./isValidSubstrateAddress";
+export * from "./isHexString";
+export * from "./isNotNil";
+export * from "./isPromise";
+export * from "./isSubject";
+export * from "./isTruthy";
+export * from "./keepAlive";
 export * from "./planckToTokens";
+export * from "./Prettify";
+export * from "./replaySubjectFrom";
 export * from "./sleep";
+export * from "./splitSubject";
 export * from "./throwAfter";
 export * from "./tokensToPlanck";
-export * from "./twox64Concat";
 export * from "./validateHexString";
-export * from "./normalizeAddress";
-export * from "./isAddressEqual";
-export * from "./isAscii";
-export * from "./isNotNil";
-export * from "./isTruthy";
+export * from "./getLoadable";

package/dist/declarations/src/isAbortError.d.ts

@@ -0,0 +1 @@
+export declare const isAbortError: (error: unknown) => boolean;

package/dist/declarations/src/isHexString.d.ts

@@ -0,0 +1,3 @@
+export type HexString = `0x${string}`;
+export declare const REGEX_HEX_STRING: RegExp;
+export declare const isHexString: (value: unknown) => value is HexString;

package/dist/declarations/src/isPromise.d.ts

@@ -0,0 +1 @@
+export declare const isPromise: <T = any>(value: any) => value is Promise<T>;

package/dist/declarations/src/isSubject.d.ts

@@ -0,0 +1,5 @@
+import { Subject } from "rxjs";
+/**
+ * Tests to see if an object is an RxJS {@link Subject}.
+ */
+export declare function isSubject<T>(object?: Subject<T> | object): object is Subject<T>;

package/dist/declarations/src/keepAlive.d.ts

@@ -0,0 +1,17 @@
+import type { OperatorFunction } from "rxjs";
+/**
+ * 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
+ * );
+ * ```
+ */
+export declare const keepAlive: <T>(timeout: number) => OperatorFunction<T, T>;

package/dist/declarations/src/replaySubjectFrom.d.ts

@@ -0,0 +1,12 @@
+import { ReplaySubject } from "rxjs";
+/**
+ * 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}.
+ */
+export declare const replaySubjectFrom: <T>(initialValue: T | Promise<T> | ReplaySubject<T>) => ReplaySubject<T>;

package/dist/declarations/src/splitSubject.d.ts

@@ -0,0 +1,11 @@
+import { Observable, Subject } from "rxjs";
+/**
+ * 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.
+ */
+export declare function splitSubject<T>(subject: Subject<T>): readonly [(value: T) => void, Observable<T>];

package/dist/declarations/src/validateHexString.d.ts

@@ -1,12 +1,11 @@
-import { HexString } from "@polkadot/util/types";
 /**
  * @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 {HexString} - boolean
+ * @returns {`0x${string}`} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
  * validateHexString(1234) // Error: Expected a string
  **/
-export declare const validateHexString: (str: string) => HexString;
+export declare const validateHexString: (str: string) => `0x${string}`;

package/dist/talismn-util.cjs.dev.js

@@ -1,9 +1,6 @@
 'use strict';
 
-var util = require('@polkadot/util');
-var utilCrypto = require('@polkadot/util-crypto');
 var tailwindMerge = require('tailwind-merge');
-var keyring = require('@polkadot/keyring');
 var rxjs = require('rxjs');
 var BigNumber = require('bignumber.js');
 
@@ -45,54 +42,8 @@ const BigMath = {
   }
 };
 
-const bitLength$1 = 128;
-function blake2Concat(input) {
-  return util.u8aToHex(util.u8aConcat(utilCrypto.blake2AsU8a(input, bitLength$1), util.u8aToU8a(input)));
-}
-
 const classNames = tailwindMerge.twMerge;
-
-function encodeAnyAddress(key, ss58Format) {
-  try {
-    return keyring.encodeAddress(key, ss58Format);
-  } catch (error) {
-    if (typeof key !== "string") throw error;
-    if (!utilCrypto.isEthereumAddress(key)) throw error;
-    return utilCrypto.ethereumEncode(key);
-  }
-}
-
-/**
- *
- * @param address substrate SS58 address
- * @param prefix prefix used to format the address
- * @returns address encoded with supplied prefix
- */
-const convertAddress = (address, prefix) => {
-  return encodeAnyAddress(address, prefix ?? undefined);
-};
-
-function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
-  try {
-    return keyring.decodeAddress(encoded, ignoreChecksum, ss58Format);
-  } catch (error) {
-    if (typeof encoded !== "string") throw error;
-    if (!utilCrypto.isEthereumAddress(encoded)) throw error;
-    return util.hexToU8a(encoded.slice("0x".length));
-  }
-}
-
-const decodeSs58Format = address => {
-  if (!address) return;
-  try {
-    utilCrypto.decodeAddress(address);
-    const decoded = utilCrypto.base58Decode(address);
-    const [,,, ss58Format] = utilCrypto.checkAddressChecksum(decoded);
-    return ss58Format;
-  } catch {
-    return; // invalid address
-  }
-};
+const cn = tailwindMerge.twMerge;
 
 /**
  * In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
@@ -195,43 +146,129 @@ const formatPrice = (price, currency, compact) => {
   }).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(rxjs.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 isEthereumAddress = address => !!address && address.startsWith("0x") && address.length === 42;
+const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
+const isHexString = value => {
+  return typeof value === "string" && REGEX_HEX_STRING.test(value);
+};
 
 /**
- * Similar to isValidAddress but will not call isEthereumAddress under the hood
- * @param address
- * @param prefix if supplied, the method will also check the prefix
- * @returns true if valid substrate (SS58) address, false otherwise
+ * 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 isValidSubstrateAddress = (address, prefix) => {
-  try {
-    // attempt to encode, it will throw an error if address is invalid
-    const encoded = keyring.encodeAddress(address, prefix ?? undefined);
-
-    //if a prefix is supplied, check that reencoding using this prefix matches the input address
-    if (prefix !== undefined) return address === encoded;
-
-    //if no prefix supplied, the fact that decoding + encoding succeded indicates that the address is valid
-    return true;
-  } catch (error) {
-    // input is not a substrate (SS58) address
-    return false;
-  }
+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 rxjs.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(rxjs.tap({
+    subscribe: () => {
+      release = keepSourceSubscribed(source, timeout);
+    },
+    unsubscribe: () => {
+      release?.();
+    }
+  }), rxjs.shareReplay({
+    refCount: true,
+    bufferSize: 1
+  }));
+};
+const keepSourceSubscribed = (observable, ms) => {
+  const sub = observable.subscribe();
+  return () => setTimeout(() => sub.unsubscribe(), ms);
 };
 
 function planckToTokens(planck, tokenDecimals) {
@@ -242,10 +279,50 @@ function planckToTokens(planck, tokenDecimals) {
   return new BigNumber__default.default(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 rxjs.ReplaySubject) return initialValue;
+  const subject = new rxjs.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) {
@@ -256,17 +333,11 @@ function tokensToPlanck(tokens, tokenDecimals) {
   return new BigNumber__default.default(tokens).multipliedBy(multiplier).toString(10);
 }
 
-const bitLength = 64;
-function twox64Concat(input) {
-  const inputAsU8a = typeof input === "string" ? input : new Uint8Array(input);
-  return util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a(inputAsU8a, bitLength), util.u8aToU8a(inputAsU8a)));
-}
-
 /**
  * @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 {HexString} - boolean
+ * @returns {`0x${string}`} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
@@ -282,67 +353,68 @@ const validateHexString = str => {
   throw new Error("Expected a hex string");
 };
 
-const CACHE = new Map();
-
-// Normalize an address in a way that it can be compared to other addresses that have also been normalized
-const normalizeAddress = address => {
-  try {
-    if (!CACHE.has(address)) CACHE.set(address, encodeAnyAddress(address));
-    return CACHE.get(address);
-  } catch (cause) {
-    throw new Error(`Unable to normalize address: ${address}`, {
-      cause
-    });
+// Designed to be serializable as it can be sent to the frontend
+
+function getLoadable$(factory, options = {}) {
+  const {
+    getError,
+    refreshInterval
+  } = options;
+  const createLoadableStream = () => rxjs.from(factory()).pipe(rxjs.map(data => ({
+    status: "success",
+    data
+  })), rxjs.catchError(error => rxjs.of({
+    status: "error",
+    error: getError ? getError(error) : getGenericError(error)
+  })));
+  const source$ = refreshInterval ? rxjs.timer(0, refreshInterval).pipe(rxjs.switchMap(() => createLoadableStream())) : createLoadableStream();
+  return source$.pipe(rxjs.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";
 };
 
-const isAddressEqual = (address1, address2) => {
-  return normalizeAddress(address1) === normalizeAddress(address2);
-};
-
-const isAscii = str => {
-  return [...str].every(char => char.charCodeAt(0) <= 127);
-};
-
-/**
- * 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;
-
-const isTruthy = value => Boolean(value);
-
 exports.BigMath = BigMath;
 exports.Deferred = Deferred;
 exports.MAX_DECIMALS_FORMAT = MAX_DECIMALS_FORMAT;
+exports.REGEX_HEX_STRING = REGEX_HEX_STRING;
 exports.addTrailingSlash = addTrailingSlash;
-exports.blake2Concat = blake2Concat;
 exports.classNames = classNames;
-exports.convertAddress = convertAddress;
-exports.decodeAnyAddress = decodeAnyAddress;
-exports.decodeSs58Format = decodeSs58Format;
-exports.encodeAnyAddress = encodeAnyAddress;
+exports.cn = cn;
 exports.firstThenDebounce = firstThenDebounce;
 exports.formatDecimals = formatDecimals;
 exports.formatPrice = formatPrice;
+exports.getLoadable$ = getLoadable$;
+exports.getSharedObservable = getSharedObservable;
 exports.hasOwnProperty = hasOwnProperty;
-exports.isAddressEqual = isAddressEqual;
+exports.isAbortError = isAbortError;
 exports.isArrayOf = isArrayOf;
 exports.isAscii = isAscii;
 exports.isBigInt = isBigInt;
 exports.isBooleanTrue = isBooleanTrue;
-exports.isEthereumAddress = isEthereumAddress;
+exports.isHexString = isHexString;
 exports.isNotNil = isNotNil;
+exports.isPromise = isPromise;
+exports.isSubject = isSubject;
 exports.isTruthy = isTruthy;
-exports.isValidSubstrateAddress = isValidSubstrateAddress;
-exports.normalizeAddress = normalizeAddress;
+exports.keepAlive = keepAlive;
 exports.planckToTokens = planckToTokens;
+exports.replaySubjectFrom = replaySubjectFrom;
 exports.sleep = sleep;
+exports.splitSubject = splitSubject;
 exports.throwAfter = throwAfter;
 exports.tokensToPlanck = tokensToPlanck;
-exports.twox64Concat = twox64Concat;
 exports.validateHexString = validateHexString;