@talismn/util 2.0.0 → 2.1.0

package/README.md

@@ -1,3 +1,9 @@
 # @talismn/util
 
-This library hosts non-UI code meant to be shared between Talisman projects
+Non-UI helpers shared by the Talisman packages and apps:
+
+- amounts: `planckToTokens`, `tokensToPlanck`, `formatDecimals`, `formatPrice`, `BigMath`
+- bytes and hex helpers
+- RxJS helpers: `getSharedObservable`, `replaySubjectFrom`, `firstThenDebounce`
+- async helpers: `sleep`, `throwAfter`, `Deferred`
+- type guards (`isNotNil`, `isTruthy`, `isHexString`, ...)

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import BigNumber$1 from "bignumber.js";
 import { Observable, OperatorFunction, ReplaySubject, Subject } from "rxjs";
 //#region src/addTrailingSlash.d.ts
-declare const addTrailingSlash: (url: string) => string;
+export declare const addTrailingSlash: (url: string) => string;
 //#endregion
 //#region src/assert.d.ts
 /**
@@ -10,14 +10,14 @@ declare const addTrailingSlash: (url: string) => string;
  * @example
  * assert(chain, "Chain not found")
  **/
-declare function assert(condition: unknown, message: string | (() => string)): asserts condition;
+export declare function assert(condition: unknown, message: string | (() => string)): asserts condition;
 //#endregion
 //#region src/BigMath.d.ts
 /**
  * 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
  */
-declare const BigMath: {
+export declare const BigMath: {
   abs(x: bigint): bigint;
   sign(x: bigint): 0n | 1n | -1n;
   min(value: bigint, ...values: bigint[]): bigint;
@@ -25,43 +25,43 @@ declare const BigMath: {
 };
 //#endregion
 //#region src/isHexString.d.ts
-type HexString = `0x${string}`;
-declare const REGEX_HEX_STRING: RegExp;
-declare const isHexString: (value: unknown) => value is HexString;
+export type HexString = `0x${string}`;
+export declare const REGEX_HEX_STRING: RegExp;
+export declare const isHexString: (value: unknown) => value is HexString;
 //#endregion
 //#region src/bytes.d.ts
 /**
  * Byte / hex primitives, drop-in equivalents of the `@polkadot/util` helpers we used to depend on.
  * Semantics intentionally match polkadot-js for migration safety.
  */
-declare const hexToU8a: (hex?: string | null) => Uint8Array;
-declare const u8aToHex: (value?: Uint8Array | null) => HexString;
-declare const stringToU8a: (value?: string | null) => Uint8Array;
-declare const u8aToString: (value?: Uint8Array | null) => string;
-declare const hexToString: (hex?: string | null) => string;
-declare const hexToNumber: (hex?: string | null) => number;
-declare const numberToU8a: (value?: number | null) => Uint8Array;
+export declare const hexToU8a: (hex?: string | null) => Uint8Array;
+export declare const u8aToHex: (value?: Uint8Array | null) => HexString;
+export declare const stringToU8a: (value?: string | null) => Uint8Array;
+export declare const u8aToString: (value?: Uint8Array | null) => string;
+export declare const hexToString: (hex?: string | null) => string;
+export declare const hexToNumber: (hex?: string | null) => number;
+export declare const numberToU8a: (value?: number | null) => Uint8Array;
 /** Coerces hex strings, utf-8 strings, number arrays and buffers to Uint8Array (polkadot-js semantics) */
-declare const u8aToU8a: (value?: string | number[] | Uint8Array | null) => Uint8Array;
-declare const u8aConcat: (...items: (string | number[] | Uint8Array)[]) => Uint8Array;
-declare const u8aEq: (a: string | Uint8Array, b: string | Uint8Array) => boolean;
-declare const u8aCmp: (a: string | Uint8Array, b: string | Uint8Array) => number;
+export declare const u8aToU8a: (value?: string | number[] | Uint8Array | null) => Uint8Array;
+export declare const u8aConcat: (...items: (string | number[] | Uint8Array)[]) => Uint8Array;
+export declare const u8aEq: (a: string | Uint8Array, b: string | Uint8Array) => boolean;
+export declare const u8aCmp: (a: string | Uint8Array, b: string | Uint8Array) => number;
 /**
  * Tests if the input is printable ASCII (code points 32-126). Hex strings are decoded to bytes
  * first, other strings are checked character-wise (polkadot-js `isAscii` semantics).
  */
-declare const isAsciiPrintable: (value?: string | Uint8Array | null) => boolean;
+export declare const isAsciiPrintable: (value?: string | Uint8Array | null) => boolean;
 /** Wraps bytes with `<Bytes>...</Bytes>` for raw-message signing, unless already wrapped */
-declare const u8aWrapBytes: (value: string | Uint8Array) => Uint8Array;
-declare const u8aUnwrapBytes: (value: string | Uint8Array) => Uint8Array;
+export declare const u8aWrapBytes: (value: string | Uint8Array) => Uint8Array;
+export declare const u8aUnwrapBytes: (value: string | Uint8Array) => Uint8Array;
 //#endregion
 //#region src/timeSlicer.d.ts
 /**
  * Default CPU budget for a single synchronous slice of chunked work.
  * ~50-60% of a 60fps frame, leaving the rest for the host (user interactions, rendering).
  */
-declare const DEFAULT_TIME_SLICE_BUDGET_MS = 10;
-type TimeSlicerOptions = {
+export declare const DEFAULT_TIME_SLICE_BUDGET_MS = 10;
+export type TimeSlicerOptions = {
   /** max synchronous work per slice, in milliseconds (default: DEFAULT_TIME_SLICE_BUDGET_MS) */
   budgetMs?: number;
   /** aborting this signal makes the slicer throw an AbortError at its next check point */
@@ -71,7 +71,7 @@ type TimeSlicerOptions = {
   /** identifies this slicer in host JS-activity reports (see jsActivityHook) */
   label?: string;
 };
-type TimeSlicer = {
+export type TimeSlicer = {
   readonly signal?: AbortSignal;
   /** true when the current slice has consumed its budget */
   shouldYield(): boolean;
@@ -96,7 +96,7 @@ type TimeSlicer = {
  * Creates an AbortError-style error without relying on DOMException (not available on Hermes).
  * Recognized by `isAbortError` from this package.
  */
-declare const newAbortError: () => Error;
+export declare const newAbortError: () => Error;
 /**
  * Tracks a time budget for cooperative scheduling: run synchronous work until the budget
  * for the current slice is exhausted, then yield the thread back to the host event loop
@@ -104,10 +104,10 @@ declare const newAbortError: () => Error;
  *
  * A single slicer can be shared across multiple phases of work so the budget spans them.
  */
-declare const createTimeSlicer: ({ budgetMs, signal, now, label }?: TimeSlicerOptions) => TimeSlicer;
+export declare const createTimeSlicer: ({ budgetMs, signal, now, label }?: TimeSlicerOptions) => TimeSlicer;
 //#endregion
 //#region src/chunkedArray.d.ts
-type ChunkedOptions = {
+export type ChunkedOptions = {
   /** max synchronous work per slice, in milliseconds (ignored when `slicer` is provided) */
   budgetMs?: number;
   /** abort in-flight work; the returned promise rejects with an AbortError (ignored when `slicer` is provided) */
@@ -124,17 +124,17 @@ type ChunkedOptions = {
  * Errors thrown by `fn` reject the promise; aborting rejects with an AbortError at the
  * next between-items check point.
  */
-declare const forEachWithYield: <T>(items: readonly T[], fn: (item: T, index: number) => void, options?: ChunkedOptions) => Promise<void>;
+export declare const forEachWithYield: <T>(items: readonly T[], fn: (item: T, index: number) => void, options?: ChunkedOptions) => Promise<void>;
 /** `Array.prototype.map`, chunked (see forEachWithYield for semantics) */
-declare const mapWithYield: <T, R>(items: readonly T[], fn: (item: T, index: number) => R, options?: ChunkedOptions) => Promise<R[]>;
+export declare const mapWithYield: <T, R>(items: readonly T[], fn: (item: T, index: number) => R, options?: ChunkedOptions) => Promise<R[]>;
 /** lodash `keyBy`, chunked (see forEachWithYield for semantics) */
-declare const keyByWithYield: <T>(items: readonly T[], keyFn: (item: T, index: number) => string, options?: ChunkedOptions) => Promise<Record<string, T>>;
+export declare const keyByWithYield: <T>(items: readonly T[], keyFn: (item: T, index: number) => string, options?: ChunkedOptions) => Promise<Record<string, T>>;
 /**
  * Chunked equivalent of lodash `isEqual(a, b)` for arrays: `a === b` fast path, length
  * check, then per-item `a[i] === b[i] || isItemEqual(a[i], b[i])` within the time budget.
  * The result is identical to `isEqual(a, b)`.
  */
-declare const arrayItemsEqualWithYield: <T>(a: readonly T[] | undefined, b: readonly T[] | undefined, options?: ChunkedOptions & {
+export declare const arrayItemsEqualWithYield: <T>(a: readonly T[] | undefined, b: readonly T[] | undefined, options?: ChunkedOptions & {
   isItemEqual?: (x: T, y: T) => boolean;
 }) => Promise<boolean>;
 //#endregion
@@ -146,7 +146,7 @@ declare const arrayItemsEqualWithYield: <T>(a: readonly T[] | undefined, b: read
  * 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.
  */
-declare function Deferred<T>(): {
+export declare function Deferred<T>(): {
   promise: Promise<T>;
   resolve: (value: T | PromiseLike<T>) => void;
   reject: (reason?: unknown) => void;
@@ -157,10 +157,10 @@ declare function Deferred<T>(): {
 //#endregion
 //#region src/FunctionPropertyNames.d.ts
 /** biome-ignore-all lint/complexity/noBannedTypes: legacy */
-type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T];
-type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
-type NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T];
-type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T];
+export type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
+export type NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
 //#endregion
 //#region src/firstThenDebounce.d.ts
 /**
@@ -169,10 +169,10 @@ type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
  * 1. Emits the first value it receives from the source observable, then:
  * 2. Debounces any future values by `timeout` ms.
  */
-declare const firstThenDebounce: <T>(timeout: number) => OperatorFunction<T, T>;
+export declare const firstThenDebounce: <T>(timeout: number) => OperatorFunction<T, T>;
 //#endregion
 //#region src/formatDecimals.d.ts
-declare const MAX_DECIMALS_FORMAT = 12;
+export declare 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
@@ -182,17 +182,20 @@ declare const MAX_DECIMALS_FORMAT = 12;
  * @param options formatting options
  * @returns the formatted value
  */
-declare const formatDecimals: (num?: string | number | null | BigNumber$1, digits?: number, options?: Partial<Intl.NumberFormatOptions>, locale?: string) => string;
+export declare const formatDecimals: (num?: string | number | null | BigNumber$1, digits?: number, options?: Partial<Intl.NumberFormatOptions>, locale?: string) => string;
 //#endregion
 //#region src/formatPrice.d.ts
-declare const formatPrice: (price: number, currency: string, compact: boolean) => string;
+export declare const formatPrice: (price: number, currency: string, compact: boolean) => string;
+//#endregion
+//#region src/getErrorMessage.d.ts
+export declare const getErrorMessage: (error: unknown, fallback?: string) => string;
 //#endregion
 //#region src/getLoadable.d.ts
 type LoadableError = {
   name: string;
   message: string;
 };
-type Loadable<T = unknown> = {
+export type Loadable<T = unknown> = {
   status: "loading";
   data?: T;
   error?: undefined;
@@ -205,15 +208,15 @@ type Loadable<T = unknown> = {
   data?: T;
   error: LoadableError;
 };
-type LoadableStatus = Loadable["status"];
-type LoadableOptions = {
+export type LoadableStatus = Loadable["status"];
+export type LoadableOptions = {
   getError?: (error: unknown) => LoadableError;
   refreshInterval?: number;
 };
-declare function getLoadable$<T>(factory: () => Promise<T>, options?: LoadableOptions): Observable<Loadable<T>>;
+export declare function getLoadable$<T>(factory: () => Promise<T>, options?: LoadableOptions): Observable<Loadable<T>>;
 //#endregion
 //#region src/getLoadableQuery.d.ts
-type GetLoadableQueryParams<TArgs extends unknown[], TResult> = {
+export type GetLoadableQueryParams<TArgs extends unknown[], TResult> = {
   namespace: string;
   args: TArgs;
   queryFn: (args: TArgs, signal: AbortSignal) => Promise<TResult>;
@@ -226,11 +229,11 @@ type GetLoadableQueryParams<TArgs extends unknown[], TResult> = {
  *
  * TODO: consolidate with getQuery$
  */
-declare const getLoadableQuery$: <TArgs extends unknown[], TResult>(params: GetLoadableQueryParams<TArgs, TResult>) => Observable<Loadable<TResult>>;
+export declare const getLoadableQuery$: <TArgs extends unknown[], TResult>(params: GetLoadableQueryParams<TArgs, TResult>) => Observable<Loadable<TResult>>;
 //#endregion
 //#region src/getQuery.d.ts
-type QueryStatus = "loading" | "loaded" | "error";
-type QueryResult<T, S extends QueryStatus = "loading" | "loaded" | "error"> = S extends "loading" ? {
+export type QueryStatus = "loading" | "loaded" | "error";
+export type QueryResult<T, S extends QueryStatus = "loading" | "loaded" | "error"> = S extends "loading" ? {
   status: "loading";
   data: T | undefined;
   error: undefined;
@@ -273,7 +276,7 @@ type QueryOptions<Output, Args> = {
  *
  * @deprecated use getLoadableQuery$ instead
  */
-declare const getQuery$: <Output, Args>({ namespace, args, queryFn, defaultValue, refreshInterval, serializer }: QueryOptions<Output, Args>) => Observable<QueryResult<Output>>;
+export declare const getQuery$: <Output, Args>({ namespace, args, queryFn, defaultValue, refreshInterval, serializer }: QueryOptions<Output, Args>) => Observable<QueryResult<Output>>;
 //#endregion
 //#region src/getSharedObservable.d.ts
 /**
@@ -291,25 +294,26 @@ declare const getQuery$: <Output, Args>({ namespace, args, queryFn, defaultValue
  * @param serializer
  * @returns
  */
-declare const getSharedObservable: <Args, Output, ObsOutput = Observable<Output>>(namespace: string, args: Args, createObservable: (args: Args) => ObsOutput, serializer?: (args: Args) => string) => ObsOutput;
+export declare const getSharedObservable: <Args, Output, ObsOutput = Observable<Output>>(namespace: string, args: Args, createObservable: (args: Args) => ObsOutput, serializer?: (args: Args) => string) => ObsOutput;
 //#endregion
 //#region src/hasOwnProperty.d.ts
-declare function hasOwnProperty<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+export declare function hasOwnProperty<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
 //#endregion
 //#region src/isAbortError.d.ts
-declare const isAbortError: (error: unknown) => boolean;
+export declare const isAbortError: (error: unknown) => boolean;
 //#endregion
 //#region src/isArrayOf.d.ts
-declare function isArrayOf<T, P extends Array<unknown>>(array: unknown[], func: new (...args: P) => T): array is T[];
+export declare function isArrayOf<T, P extends Array<unknown>>(array: unknown[], func: new (...args: P) => T): array is T[];
 //#endregion
 //#region src/isAscii.d.ts
-declare const isAscii: (str: string) => boolean;
+export declare const isAscii: (str: string) => boolean;
 //#endregion
 //#region src/isBigInt.d.ts
-declare const isBigInt: (value: unknown) => value is bigint;
+export declare const isBigInt: (value: unknown) => value is bigint;
 //#endregion
 //#region src/isBooleanTrue.d.ts
-declare const isBooleanTrue: <T>(x: T | null | undefined) => x is T;
+/** @deprecated use isTruthy instead */
+export declare const isBooleanTrue: <T>(x: T | null | undefined) => x is T;
 //#endregion
 //#region src/isErrorOfName.d.ts
 /**
@@ -323,7 +327,7 @@ declare const isBooleanTrue: <T>(x: T | null | undefined) => x is T;
  * `super({ name: 'ContractFunctionExecutionError' })`). For classes that don't set `.name`,
  * duck-type the shape instead.
  */
-declare const isErrorOfName: (error: unknown, ...names: string[]) => boolean;
+export declare const isErrorOfName: (error: unknown, ...names: string[]) => boolean;
 //#endregion
 //#region src/isNotNil.d.ts
 /**
@@ -334,19 +338,19 @@ declare const isErrorOfName: (error: unknown, ...names: string[]) => boolean;
  * @param value
  * @returns whether the value is neither null nor undefined
  */
-declare const isNotNil: <T>(value: T | null | undefined) => value is T;
+export declare const isNotNil: <T>(value: T | null | undefined) => value is T;
 //#endregion
 //#region src/isPromise.d.ts
-declare const isPromise: <T = any>(value: any) => value is Promise<T>;
+export declare const isPromise: <T = any>(value: any) => value is Promise<T>;
 //#endregion
 //#region src/isSubject.d.ts
 /**
  * Tests to see if an object is an RxJS {@link Subject}.
  */
-declare function isSubject<T>(object?: Subject<T> | object): object is Subject<T>;
+export declare function isSubject<T>(object?: Subject<T> | object): object is Subject<T>;
 //#endregion
 //#region src/isTruthy.d.ts
-declare const isTruthy: <T>(value: T | null | undefined) => value is T;
+export declare const isTruthy: <T>(value: T | null | undefined) => value is T;
 //#endregion
 //#region src/jsActivityHook.d.ts
 /**
@@ -360,7 +364,7 @@ declare const isTruthy: <T>(value: T | null | undefined) => value is T;
  * When no hook is installed this is a no-op (a single property read), so library code
  * can call it unconditionally from hot paths.
  */
-declare const reportJsActivity: (label: string, durationMs?: number) => void;
+export declare const reportJsActivity: (label: string, durationMs?: number) => void;
 //#endregion
 //#region src/keepAlive.d.ts
 /**
@@ -378,7 +382,7 @@ declare const reportJsActivity: (label: string, durationMs?: number) => void;
  * );
  * ```
  */
-declare const keepAlive: <T>(timeout: number) => OperatorFunction<T, T>;
+export declare const keepAlive: <T>(timeout: number) => OperatorFunction<T, T>;
 //#endregion
 //#region src/lruMap.d.ts
 /**
@@ -388,7 +392,7 @@ declare const keepAlive: <T>(timeout: number) => OperatorFunction<T, T>;
  * least-recently-used entry is evicted. Intended for long-lived in-memory
  * caches that would otherwise grow without bound.
  */
-declare class LruMap<K, V> {
+export declare class LruMap<K, V> {
   #private;
   constructor(maxSize: number);
   get(key: K): V | undefined;
@@ -400,7 +404,7 @@ declare class LruMap<K, V> {
 }
 //#endregion
 //#region src/mapChunked.d.ts
-type ChunkedProjectContext = {
+export type ChunkedProjectContext = {
   /** thread the slicer through chunked helpers (mapWithYield etc.) so the budget spans them */
   slicer: TimeSlicer;
   /** aborted when the work is cancelled (new upstream value or unsubscription) */
@@ -417,7 +421,7 @@ type ChunkedProjectContext = {
  * Note: pipelines using this operator already emit asynchronously (macrotask), so adding
  * `observeOn(asyncScheduler)` downstream is redundant and only adds latency.
  */
-declare const switchMapChunked: <T, R>(project: (value: T, ctx: ChunkedProjectContext, index: number) => Promise<R>, options?: {
+export declare const switchMapChunked: <T, R>(project: (value: T, ctx: ChunkedProjectContext, index: number) => Promise<R>, options?: {
   budgetMs?: number;
   label?: string;
 }) => OperatorFunction<T, R>;
@@ -426,18 +430,18 @@ declare const switchMapChunked: <T, R>(project: (value: T, ctx: ChunkedProjectCo
  * processed one at a time; a new value does NOT cancel in-flight work (unsubscription
  * still aborts it).
  */
-declare const concatMapChunked: <T, R>(project: (value: T, ctx: ChunkedProjectContext, index: number) => Promise<R>, options?: {
+export declare const concatMapChunked: <T, R>(project: (value: T, ctx: ChunkedProjectContext, index: number) => Promise<R>, options?: {
   budgetMs?: number;
   label?: string;
 }) => OperatorFunction<T, R>;
 //#endregion
 //#region src/Prettify.d.ts
-type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+export type Prettify<T> = { [K in keyof T]: T[K]; } & {};
 //#endregion
 //#region src/planckToTokens.d.ts
-declare function planckToTokens(planck: string, tokenDecimals: number): string;
-declare function planckToTokens(planck: string, tokenDecimals?: number): string | undefined;
-declare function planckToTokens(planck?: string, tokenDecimals?: number): string | undefined;
+export declare function planckToTokens(planck: string, tokenDecimals: number): string;
+export declare function planckToTokens(planck: string, tokenDecimals?: number): string | undefined;
+export declare function planckToTokens(planck?: string, tokenDecimals?: number): string | undefined;
 //#endregion
 //#region src/replaySubjectFrom.d.ts
 /**
@@ -450,10 +454,10 @@ declare function planckToTokens(planck?: string, tokenDecimals?: number): string
  *
  * For any other type of value, it will be immediately published into the {@link ReplaySubject}.
  */
-declare const replaySubjectFrom: <T>(initialValue: T | Promise<T> | ReplaySubject<T>) => ReplaySubject<T>;
+export declare const replaySubjectFrom: <T>(initialValue: T | Promise<T> | ReplaySubject<T>) => ReplaySubject<T>;
 //#endregion
 //#region src/sleep.d.ts
-declare const sleep: (ms: number) => Promise<void>;
+export declare const sleep: (ms: number) => Promise<void>;
 //#endregion
 //#region src/splitSubject.d.ts
 /**
@@ -465,7 +469,7 @@ declare const sleep: (ms: number) => Promise<void>;
  * 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.
  */
-declare function splitSubject<T>(subject: Subject<T>): readonly [(value: T) => void, Observable<T>];
+export declare function splitSubject<T>(subject: Subject<T>): readonly [(value: T) => void, Observable<T>];
 //#endregion
 //#region src/stripHexPrefix.d.ts
 /**
@@ -477,25 +481,25 @@ declare function splitSubject<T>(subject: Subject<T>): readonly [(value: T) => v
  * stripHexPrefix("0x1234") // "1234"
  * stripHexPrefix("1234") // "1234"
  **/
-declare const stripHexPrefix: (str: string) => string;
+export declare const stripHexPrefix: (str: string) => string;
 //#endregion
 //#region src/throwAfter.d.ts
-declare const throwAfter: (ms: number, reason: string) => Promise<never>;
+export declare const throwAfter: (ms: number, reason: string) => Promise<never>;
 //#endregion
 //#region src/tokensToPlanck.d.ts
-declare function tokensToPlanck(tokens: string, tokenDecimals: number): string;
-declare function tokensToPlanck(tokens: string, tokenDecimals?: number): string | undefined;
-declare function tokensToPlanck(tokens?: string, tokenDecimals?: number): string | undefined;
+export declare function tokensToPlanck(tokens: string, tokenDecimals: number): string;
+export declare function tokensToPlanck(tokens: string, tokenDecimals?: number): string | undefined;
+export declare function tokensToPlanck(tokens?: string, tokenDecimals?: number): string | undefined;
 //#endregion
 //#region src/validateArrayWithYield.d.ts
-type ItemParseResult<T, E> = {
+export type ItemParseResult<T, E> = {
   success: true;
   data: T;
 } | {
   success: false;
   error: E;
 };
-type ArrayValidationResult<T, E> = {
+export type ArrayValidationResult<T, E> = {
   success: true;
   data: T[];
 } | {
@@ -513,7 +517,7 @@ type ArrayValidationResult<T, E> = {
  * (no fail-fast) — pass e.g. `(item) => SomeSchema.safeParse(item)` as `parseItem`.
  * Zod-agnostic on purpose: this package has no zod dependency.
  */
-declare const validateArrayWithYield: <T, E>(items: readonly unknown[], parseItem: (item: unknown, index: number) => ItemParseResult<T, E>, options?: ChunkedOptions) => Promise<ArrayValidationResult<T, E>>;
+export declare const validateArrayWithYield: <T, E>(items: readonly unknown[], parseItem: (item: unknown, index: number) => ItemParseResult<T, E>, options?: ChunkedOptions) => Promise<ArrayValidationResult<T, E>>;
 //#endregion
 //#region src/validateHexString.d.ts
 /**
@@ -526,10 +530,9 @@ declare const validateArrayWithYield: <T, E>(items: readonly unknown[], parseIte
  * validateHexString("1234") // Error: Expected a hex string
  * validateHexString(1234) // Error: Expected a string
  **/
-declare const validateHexString: (str: string) => `0x${string}`;
+export declare const validateHexString: (str: string) => `0x${string}`;
 //#endregion
 //#region src/yieldToEventLoop.d.ts
-declare const yieldToEventLoop: () => Promise<void>;
+export declare const yieldToEventLoop: () => Promise<void>;
 //#endregion
-export { ArrayValidationResult, BigMath, ChunkedOptions, ChunkedProjectContext, DEFAULT_TIME_SLICE_BUDGET_MS, Deferred, FunctionProperties, FunctionPropertyNames, GetLoadableQueryParams, HexString, ItemParseResult, Loadable, LoadableOptions, LoadableStatus, LruMap, MAX_DECIMALS_FORMAT, NonFunctionProperties, NonFunctionPropertyNames, Prettify, QueryResult, QueryStatus, REGEX_HEX_STRING, TimeSlicer, TimeSlicerOptions, addTrailingSlash, arrayItemsEqualWithYield, assert, concatMapChunked, createTimeSlicer, firstThenDebounce, forEachWithYield, formatDecimals, formatPrice, getLoadable$, getLoadableQuery$, getQuery$, getSharedObservable, hasOwnProperty, hexToNumber, hexToString, hexToU8a, isAbortError, isArrayOf, isAscii, isAsciiPrintable, isBigInt, isBooleanTrue, isErrorOfName, isHexString, isNotNil, isPromise, isSubject, isTruthy, keepAlive, keyByWithYield, mapWithYield, newAbortError, numberToU8a, planckToTokens, replaySubjectFrom, reportJsActivity, sleep, splitSubject, stringToU8a, stripHexPrefix, switchMapChunked, throwAfter, tokensToPlanck, u8aCmp, u8aConcat, u8aEq, u8aToHex, u8aToString, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes, validateArrayWithYield, validateHexString, yieldToEventLoop };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/addTrailingSlash.ts","../src/assert.ts","../src/BigMath.ts","../src/isHexString.ts","../src/bytes.ts","../src/timeSlicer.ts","../src/chunkedArray.ts","../src/deferred.ts","../src/FunctionPropertyNames.ts","../src/firstThenDebounce.ts","../src/formatDecimals.ts","../src/formatPrice.ts","../src/getLoadable.ts","../src/getLoadableQuery.ts","../src/getQuery.ts","../src/getSharedObservable.ts","../src/hasOwnProperty.ts","../src/isAbortError.ts","../src/isArrayOf.ts","../src/isAscii.ts","../src/isBigInt.ts","../src/isBooleanTrue.ts","../src/isErrorOfName.ts","../src/isNotNil.ts","../src/isPromise.ts","../src/isSubject.ts","../src/isTruthy.ts","../src/jsActivityHook.ts","../src/keepAlive.ts","../src/lruMap.ts","../src/mapChunked.ts","../src/Prettify.ts","../src/planckToTokens.ts","../src/replaySubjectFrom.ts","../src/sleep.ts","../src/splitSubject.ts","../src/stripHexPrefix.ts","../src/throwAfter.ts","../src/tokensToPlanck.ts","../src/validateArrayWithYield.ts","../src/validateHexString.ts","../src/yieldToEventLoop.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/addTrailingSlash.ts","../src/assert.ts","../src/BigMath.ts","../src/isHexString.ts","../src/bytes.ts","../src/timeSlicer.ts","../src/chunkedArray.ts","../src/deferred.ts","../src/FunctionPropertyNames.ts","../src/firstThenDebounce.ts","../src/formatDecimals.ts","../src/formatPrice.ts","../src/getErrorMessage.ts","../src/getLoadable.ts","../src/getLoadableQuery.ts","../src/getQuery.ts","../src/getSharedObservable.ts","../src/hasOwnProperty.ts","../src/isAbortError.ts","../src/isArrayOf.ts","../src/isAscii.ts","../src/isBigInt.ts","../src/isBooleanTrue.ts","../src/isErrorOfName.ts","../src/isNotNil.ts","../src/isPromise.ts","../src/isSubject.ts","../src/isTruthy.ts","../src/jsActivityHook.ts","../src/keepAlive.ts","../src/lruMap.ts","../src/mapChunked.ts","../src/Prettify.ts","../src/planckToTokens.ts","../src/replaySubjectFrom.ts","../src/sleep.ts","../src/splitSubject.ts","../src/stripHexPrefix.ts","../src/throwAfter.ts","../src/tokensToPlanck.ts","../src/validateArrayWithYield.ts","../src/validateHexString.ts","../src/yieldToEventLoop.ts"],"mappings":"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"}