@talismn/util 1.1.0 → 2.0.1

package/dist/index.d.ts

@@ -1,19 +1,144 @@
-import { OperatorFunction, Observable, Subject, ReplaySubject } from 'rxjs';
-import BigNumber from 'bignumber.js';
-
-declare const addTrailingSlash: (url: string) => string;
-
+import BigNumber from "bignumber.js";
+import { Observable, OperatorFunction, ReplaySubject, Subject } from "rxjs";
+//#region src/addTrailingSlash.d.ts
+export declare const addTrailingSlash: (url: string) => string;
+//#endregion
+//#region src/assert.d.ts
+/**
+ * @name assert
+ * @description Throws an Error with the given message if the condition is falsy.
+ * @example
+ * assert(chain, "Chain not found")
+ **/
+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: {
-    abs(x: bigint): bigint;
-    sign(x: bigint): 0n | 1n | -1n;
-    min(value: bigint, ...values: bigint[]): bigint;
-    max(value: bigint, ...values: bigint[]): bigint;
+export declare const BigMath: {
+  abs(x: bigint): bigint;
+  sign(x: bigint): 0n | 1n | -1n;
+  min(value: bigint, ...values: bigint[]): bigint;
+  max(value: bigint, ...values: bigint[]): bigint;
+};
+//#endregion
+//#region src/isHexString.d.ts
+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.
+ */
+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) */
+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).
+ */
+export declare const isAsciiPrintable: (value?: string | Uint8Array | null) => boolean;
+/** Wraps bytes with `<Bytes>...</Bytes>` for raw-message signing, unless already wrapped */
+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).
+ */
+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 */
+  signal?: AbortSignal;
+  /** injectable clock for tests; defaults to performance.now, falling back to Date.now */
+  now?: () => number;
+  /** identifies this slicer in host JS-activity reports (see jsActivityHook) */
+  label?: string;
+};
+export type TimeSlicer = {
+  readonly signal?: AbortSignal;
+  /** true when the current slice has consumed its budget */
+  shouldYield(): boolean;
+  /** unconditionally macrotask-yield, reset the slice, then throw if aborted */
+  yield(): Promise<void>;
+  /**
+   * Call between work items. Returns `undefined` (no promise, no microtask) while within
+   * budget, so hot loops stay cheap:
+   *
+   * ```ts
+   * const yielded = slicer.yieldIfNeeded()
+   * if (yielded) await yielded
+   * ```
+   *
+   * Throws synchronously if the signal is aborted.
+   */
+  yieldIfNeeded(): Promise<void> | undefined;
+  /** throws an Error with name "AbortError" (recognized by isAbortError) if the signal is aborted */
+  throwIfAborted(): void;
+};
+/**
+ * Creates an AbortError-style error without relying on DOMException (not available on Hermes).
+ * Recognized by `isAbortError` from this package.
+ */
+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
+ * before continuing.
+ *
+ * A single slicer can be shared across multiple phases of work so the budget spans them.
+ */
+export declare const createTimeSlicer: ({ budgetMs, signal, now, label }?: TimeSlicerOptions) => TimeSlicer;
+//#endregion
+//#region src/chunkedArray.d.ts
+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) */
+  signal?: AbortSignal;
+  /** share one slicer across multiple phases of work so the time budget spans them */
+  slicer?: TimeSlicer;
+  /** identifies this work in host JS-activity reports (ignored when `slicer` is provided) */
+  label?: string;
 };
-
+/**
+ * `Array.prototype.forEach`, chunked: iterates synchronously until the time budget is
+ * exhausted, then yields the thread to the host event loop before continuing.
+ *
+ * Errors thrown by `fn` reject the promise; aborting rejects with an AbortError at the
+ * next between-items check point.
+ */
+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) */
+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) */
+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)`.
+ */
+export declare const arrayItemsEqualWithYield: <T>(a: readonly T[] | undefined, b: readonly T[] | undefined, options?: ChunkedOptions & {
+  isItemEqual?: (x: T, y: T) => boolean;
+}) => Promise<boolean>;
+//#endregion
+//#region src/deferred.d.ts
 /**
  * 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.
@@ -21,34 +146,33 @@ declare const BigMath: {
  * 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>(): {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: unknown) => void;
-    isPending: () => boolean;
-    isResolved: () => boolean;
-    isRejected: () => boolean;
+export declare function Deferred<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: unknown) => void;
+  isPending: () => boolean;
+  isResolved: () => boolean;
+  isRejected: () => boolean;
 };
-
+//#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
 /**
  * An rxjs operator which:
  *
  * 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>;
-
-declare const MAX_DECIMALS_FORMAT = 12;
+export declare const firstThenDebounce: <T>(timeout: number) => OperatorFunction<T, T>;
+//#endregion
+//#region src/formatDecimals.d.ts
+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
@@ -58,40 +182,43 @@ declare const MAX_DECIMALS_FORMAT = 12;
  * @param options formatting options
  * @returns the formatted value
  */
-declare const formatDecimals: (num?: string | number | null | BigNumber, digits?: number, options?: Partial<Intl.NumberFormatOptions>, locale?: string) => string;
-
-declare const formatPrice: (price: number, currency: string, compact: boolean) => string;
-
+export declare const formatDecimals: (num?: string | number | null | BigNumber, digits?: number, options?: Partial<Intl.NumberFormatOptions>, locale?: string) => string;
+//#endregion
+//#region src/formatPrice.d.ts
+export declare const formatPrice: (price: number, currency: string, compact: boolean) => string;
+//#endregion
+//#region src/getLoadable.d.ts
 type LoadableError = {
-    name: string;
-    message: string;
+  name: string;
+  message: string;
 };
-type Loadable<T = unknown> = {
-    status: "loading";
-    data?: T;
-    error?: undefined;
+export type Loadable<T = unknown> = {
+  status: "loading";
+  data?: T;
+  error?: undefined;
 } | {
-    status: "success";
-    data: T;
-    error?: undefined;
+  status: "success";
+  data: T;
+  error?: undefined;
 } | {
-    status: "error";
-    data?: T;
-    error: LoadableError;
+  status: "error";
+  data?: T;
+  error: LoadableError;
 };
-type LoadableStatus = Loadable["status"];
-type LoadableOptions = {
-    getError?: (error: unknown) => LoadableError;
-    refreshInterval?: number;
+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>>;
-
-type GetLoadableQueryParams<TArgs extends unknown[], TResult> = {
-    namespace: string;
-    args: TArgs;
-    queryFn: (args: TArgs, signal: AbortSignal) => Promise<TResult>;
-    refreshInterval?: number;
-    defaultValue?: TResult;
+export declare function getLoadable$<T>(factory: () => Promise<T>, options?: LoadableOptions): Observable<Loadable<T>>;
+//#endregion
+//#region src/getLoadableQuery.d.ts
+export type GetLoadableQueryParams<TArgs extends unknown[], TResult> = {
+  namespace: string;
+  args: TArgs;
+  queryFn: (args: TArgs, signal: AbortSignal) => Promise<TResult>;
+  refreshInterval?: number;
+  defaultValue?: TResult;
 };
 /**
  * Thin wrapper around getQuery$ that returns Loadable<T> and optionally
@@ -99,29 +226,30 @@ type GetLoadableQueryParams<TArgs extends unknown[], TResult> = {
  *
  * TODO: consolidate with getQuery$
  */
-declare const getLoadableQuery$: <TArgs extends unknown[], TResult>(params: GetLoadableQueryParams<TArgs, TResult>) => Observable<Loadable<TResult>>;
-
-type QueryStatus = "loading" | "loaded" | "error";
-type QueryResult<T, S extends QueryStatus = "loading" | "loaded" | "error"> = S extends "loading" ? {
-    status: "loading";
-    data: T | undefined;
-    error: undefined;
+export declare const getLoadableQuery$: <TArgs extends unknown[], TResult>(params: GetLoadableQueryParams<TArgs, TResult>) => Observable<Loadable<TResult>>;
+//#endregion
+//#region src/getQuery.d.ts
+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;
 } : S extends "loaded" ? {
-    status: "loaded";
-    data: T;
-    error: undefined;
+  status: "loaded";
+  data: T;
+  error: undefined;
 } : {
-    status: "error";
-    data: undefined;
-    error: unknown;
+  status: "error";
+  data: undefined;
+  error: unknown;
 };
 type QueryOptions<Output, Args> = {
-    namespace: string;
-    args: Args;
-    queryFn: (args: Args, signal: AbortSignal) => Promise<Output>;
-    defaultValue?: Output;
-    refreshInterval?: number;
-    serializer?: (args: Args) => string;
+  namespace: string;
+  args: Args;
+  queryFn: (args: Args, signal: AbortSignal) => Promise<Output>;
+  defaultValue?: Output;
+  refreshInterval?: number;
+  serializer?: (args: Args) => string;
 };
 /**
  * Creates a shared observable for executing queries with caching, loading states, and automatic refresh capabilities.
@@ -145,33 +273,45 @@ 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
 /**
  * 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
  *
+ * Entries are reference-counted: an entry with no subscribers for CLEANUP_DELAY_MS is
+ * removed from the cache (its shareReplay source is already torn down by refCount at
+ * that point — only the replay buffer and the entry itself are dropped).
+ *
  * @param namespace
  * @param args
  * @param createObservable
  * @param serializer
  * @returns
  */
-declare const getSharedObservable: <Args, Output, ObsOutput = Observable<Output>>(namespace: string, args: Args, createObservable: (args: Args) => ObsOutput, serializer?: (args: Args) => string) => ObsOutput;
-
-declare function hasOwnProperty<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
-
-declare const isAbortError: (error: unknown) => boolean;
-
-declare function isArrayOf<T, P extends Array<unknown>>(array: unknown[], func: new (...args: P) => T): array is T[];
-
-declare const isAscii: (str: string) => boolean;
-
-declare const isBigInt: (value: unknown) => value is bigint;
-
-declare const isBooleanTrue: <T>(x: T | null | undefined) => x is T;
-
+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
+export declare function hasOwnProperty<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+//#endregion
+//#region src/isAbortError.d.ts
+export declare const isAbortError: (error: unknown) => boolean;
+//#endregion
+//#region src/isArrayOf.d.ts
+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
+export declare const isAscii: (str: string) => boolean;
+//#endregion
+//#region src/isBigInt.d.ts
+export declare const isBigInt: (value: unknown) => value is bigint;
+//#endregion
+//#region src/isBooleanTrue.d.ts
+export declare const isBooleanTrue: <T>(x: T | null | undefined) => x is T;
+//#endregion
+//#region src/isErrorOfName.d.ts
 /**
  * Robust replacement for `error instanceof SomeErrorClass` when the class comes from a
  * package that gets bundled into multiple chunks/contexts (e.g. viem, @solana/web3.js).
@@ -183,12 +323,9 @@ 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;
-
-type HexString = `0x${string}`;
-declare const REGEX_HEX_STRING: RegExp;
-declare const isHexString: (value: unknown) => value is HexString;
-
+export declare const isErrorOfName: (error: unknown, ...names: string[]) => boolean;
+//#endregion
+//#region src/isNotNil.d.ts
 /**
  * WARNING: This function only checks against null or undefined, it does not coerce the value.
  * ie: false and 0 are considered not nil
@@ -197,17 +334,35 @@ declare const isHexString: (value: unknown) => value is HexString;
  * @param value
  * @returns whether the value is neither null nor undefined
  */
-declare const isNotNil: <T>(value: T | null | undefined) => value is T;
-
-declare const isPromise: <T = any>(value: any) => value is Promise<T>;
-
+export declare const isNotNil: <T>(value: T | null | undefined) => value is T;
+//#endregion
+//#region src/isPromise.d.ts
+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>;
-
-declare const isTruthy: <T>(value: T | null | undefined) => value is T;
-
+export declare function isSubject<T>(object?: Subject<T> | object): object is Subject<T>;
+//#endregion
+//#region src/isTruthy.d.ts
+export declare const isTruthy: <T>(value: T | null | undefined) => value is T;
+//#endregion
+//#region src/jsActivityHook.d.ts
+/**
+ * Optional host-provided JS-activity hook.
+ *
+ * Host apps that run a JS-thread stall watchdog (e.g. talisapp's jsThreadWatchdog) can
+ * install `globalThis.__recordJsActivity` to receive lightweight "this just ran on the
+ * JS thread" markers from library code. When a stall is detected, the watchdog can then
+ * attribute the blocked time to whatever activity was recorded during the stall window.
+ *
+ * When no hook is installed this is a no-op (a single property read), so library code
+ * can call it unconditionally from hot paths.
+ */
+export declare const reportJsActivity: (label: string, durationMs?: number) => void;
+//#endregion
+//#region src/keepAlive.d.ts
 /**
  * An RxJS operator that keeps the source observable alive for a specified duration
  * after all subscribers have unsubscribed. This prevents expensive re-subscriptions
@@ -223,16 +378,68 @@ declare const isTruthy: <T>(value: T | null | undefined) => value is T;
  * );
  * ```
  */
-declare const keepAlive: <T>(timeout: number) => OperatorFunction<T, T>;
-
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
-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 const keepAlive: <T>(timeout: number) => OperatorFunction<T, T>;
+//#endregion
+//#region src/lruMap.d.ts
+/**
+ * A Map with a maximum size and least-recently-used eviction.
+ *
+ * Reads refresh recency; when an insert would exceed `maxSize`, the
+ * least-recently-used entry is evicted. Intended for long-lived in-memory
+ * caches that would otherwise grow without bound.
+ */
+export declare class LruMap<K, V> {
+  #private;
+  constructor(maxSize: number);
+  get(key: K): V | undefined;
+  set(key: K, value: V): this;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+  clear(): void;
+  get size(): number;
+}
+//#endregion
+//#region src/mapChunked.d.ts
+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) */
+  signal: AbortSignal;
+};
+/**
+ * `switchMap` for time-sliced (chunked) async work — latest-wins: a new upstream value or
+ * an unsubscription aborts the in-flight `project` via `ctx.signal` / the shared slicer,
+ * so cancelled work stops burning CPU at its next yield check point and its result is
+ * never emitted.
+ *
+ * Non-abort errors thrown by `project` error the stream (same as a throwing sync `map`).
+ *
+ * Note: pipelines using this operator already emit asynchronously (macrotask), so adding
+ * `observeOn(asyncScheduler)` downstream is redundant and only adds latency.
+ */
+export declare const switchMapChunked: <T, R>(project: (value: T, ctx: ChunkedProjectContext, index: number) => Promise<R>, options?: {
+  budgetMs?: number;
+  label?: string;
+}) => OperatorFunction<T, R>;
+/**
+ * `concatMap` variant of switchMapChunked — ordered: upstream values queue and are
+ * processed one at a time; a new value does NOT cancel in-flight work (unsubscription
+ * still aborts it).
+ */
+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
+export type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+//#endregion
+//#region src/planckToTokens.d.ts
+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
 /**
  * Turns a value into a {@link ReplaySubject} of size 1.
  *
@@ -243,10 +450,12 @@ 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>;
-
-declare const sleep: (ms: number) => Promise<void>;
-
+export declare const replaySubjectFrom: <T>(initialValue: T | Promise<T> | ReplaySubject<T>) => ReplaySubject<T>;
+//#endregion
+//#region src/sleep.d.ts
+export declare const sleep: (ms: number) => Promise<void>;
+//#endregion
+//#region src/splitSubject.d.ts
 /**
  * Takes a subject and splits it into two parts:
  *
@@ -256,8 +465,9 @@ 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
 /**
  * @name stripHexPrefix
  * @description Removes a leading `0x` prefix from a string, if present.
@@ -267,14 +477,45 @@ declare function splitSubject<T>(subject: Subject<T>): readonly [(value: T) => v
  * stripHexPrefix("0x1234") // "1234"
  * stripHexPrefix("1234") // "1234"
  **/
-declare const stripHexPrefix: (str: string) => string;
-
-declare const throwAfter: (ms: number, reason: string) => Promise<never>;
-
-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 const stripHexPrefix: (str: string) => string;
+//#endregion
+//#region src/throwAfter.d.ts
+export declare const throwAfter: (ms: number, reason: string) => Promise<never>;
+//#endregion
+//#region src/tokensToPlanck.d.ts
+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
+export type ItemParseResult<T, E> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: E;
+};
+export type ArrayValidationResult<T, E> = {
+  success: true;
+  data: T[];
+} | {
+  success: false;
+  errors: {
+    index: number;
+    error: E;
+  }[];
+};
+/**
+ * Validates every item of an array within a cooperative time budget, yielding the thread
+ * to the host event loop whenever the budget for the current slice is exhausted.
+ *
+ * Like `z.array(schema).safeParse`, ALL items are validated and all failures collected
+ * (no fail-fast) — pass e.g. `(item) => SomeSchema.safeParse(item)` as `parseItem`.
+ * Zod-agnostic on purpose: this package has no zod dependency.
+ */
+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
 /**
  * @name validateHexString
  * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
@@ -285,6 +526,9 @@ declare function tokensToPlanck(tokens?: string, tokenDecimals?: number): string
  * validateHexString("1234") // Error: Expected a hex string
  * validateHexString(1234) // Error: Expected a string
  **/
-declare const validateHexString: (str: string) => `0x${string}`;
-
-export { BigMath, Deferred, type FunctionProperties, type FunctionPropertyNames, type GetLoadableQueryParams, type HexString, type Loadable, type LoadableOptions, type LoadableStatus, MAX_DECIMALS_FORMAT, type NonFunctionProperties, type NonFunctionPropertyNames, type Prettify, type QueryResult, type QueryStatus, REGEX_HEX_STRING, addTrailingSlash, firstThenDebounce, formatDecimals, formatPrice, getLoadable$, getLoadableQuery$, getQuery$, getSharedObservable, hasOwnProperty, isAbortError, isArrayOf, isAscii, isBigInt, isBooleanTrue, isErrorOfName, isHexString, isNotNil, isPromise, isSubject, isTruthy, keepAlive, planckToTokens, replaySubjectFrom, sleep, splitSubject, stripHexPrefix, throwAfter, tokensToPlanck, validateHexString };
+export declare const validateHexString: (str: string) => `0x${string}`;
+//#endregion
+//#region src/yieldToEventLoop.d.ts
+export declare const yieldToEventLoop: () => Promise<void>;
+//#endregion
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","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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"}