@welshman/lib 0.1.1 → 0.2.0

package/{build/src → dist}/Tools.d.ts

@@ -1,38 +1,10 @@
-/** Type representing null or undefined */
+type Obj<T = any> = Record<string, T>;
 export type Nil = null | undefined;
-/** Checks if a value is null or undefined */
-export declare const isNil: (x: any) => boolean;
-/** Type representing an optional value */
-export type Maybe<T> = T | undefined;
-/** Type that is shorthand for Record<string, T> */
-export type Obj<T = any> = Record<string, T>;
-/**
- * Executes a function if the value is defined
- * @param x - The value to check
- * @param f - Function to execute if x is defined
- * @returns Result of f(x) if x is defined, undefined otherwise
- */
-export declare const ifLet: <T>(x: T | undefined, f: (x: T) => void) => void;
+export declare const isNil: <T>(x: T, ...args: unknown[]) => boolean;
+export declare const isNotNil: <T>(x: T, ...args: unknown[]) => x is T & {};
+export declare const assertNotNil: <T>(x: T, ...args: unknown[]) => NonNullable<T>;
 /** Function that does nothing and returns undefined */
 export declare const noop: (...args: unknown[]) => undefined;
-/**
- * Returns the first element of an array
- * @param xs - The array
- * @returns First element or undefined
- */
-export declare const first: <T>(xs: T[], ...args: unknown[]) => T;
-/**
- * Returns the first element of the first array in a nested array
- * @param xs - Array of arrays
- * @returns First element of first array or undefined
- */
-export declare const ffirst: <T>(xs: T[][], ...args: unknown[]) => T;
-/**
- * Returns the last element of an array
- * @param xs - The array
- * @returns Last element or undefined
- */
-export declare const last: <T>(xs: T[], ...args: unknown[]) => T;
 /**
  * Returns the input value unchanged
  * @param x - Any value
@@ -51,174 +23,194 @@ export declare const always: <T>(x: T, ...args: unknown[]) => () => T;
  * @returns !x
  */
 export declare const not: (x: any, ...args: unknown[]) => boolean;
-/** Returns a function that returns the boolean negation of the given function */
-export declare const complement: <T extends unknown[]>(f: (...args: T) => any) => (...args: T) => boolean;
-/** Converts a `Maybe<number>` to a number, defaulting to 0 */
-export declare const num: (x: Maybe<number>) => number;
+/**
+ * Deep equality comparison
+ * @param a - First value
+ * @param b - Second value
+ * @returns True if values are deeply equal
+ */
+export declare const equals: (a: any, b: any) => boolean;
+/** Converts string or number to number */
+export declare const ensureNumber: (x: number | string) => number;
+/** Converts a `number | undefined` to a number, defaulting to 0 */
+export declare const num: (x: number | undefined) => number;
 /** Adds two numbers, handling undefined values */
-export declare const add: (x: Maybe<number>, y: Maybe<number>) => number;
+export declare const add: (x: number | undefined, y: number | undefined) => number;
 /** Subtracts two numbers, handling undefined values */
-export declare const sub: (x: Maybe<number>, y: Maybe<number>) => number;
+export declare const sub: (x: number | undefined, y: number | undefined) => number;
 /** Multiplies two numbers, handling undefined values */
-export declare const mul: (x: Maybe<number>, y: Maybe<number>) => number;
+export declare const mul: (x: number | undefined, y: number | undefined) => number;
 /** Divides two numbers, handling undefined values */
-export declare const div: (x: Maybe<number>, y: number) => number;
+export declare const div: (x: number | undefined, y: number) => number;
 /** Increments a number by 1, handling undefined values */
-export declare const inc: (x: Maybe<number>) => number;
+export declare const inc: (x: number | undefined) => number;
 /** Decrements a number by 1, handling undefined values */
-export declare const dec: (x: Maybe<number>) => number;
+export declare const dec: (x: number | undefined) => number;
 /** Less than comparison, handling undefined values */
-export declare const lt: (x: Maybe<number>, y: Maybe<number>) => boolean;
+export declare const lt: (x: number | undefined, y: number | undefined) => boolean;
 /** Less than or equal comparison, handling undefined values */
-export declare const lte: (x: Maybe<number>, y: Maybe<number>) => boolean;
+export declare const lte: (x: number | undefined, y: number | undefined) => boolean;
 /** Greater than comparison, handling undefined values */
-export declare const gt: (x: Maybe<number>, y: Maybe<number>) => boolean;
+export declare const gt: (x: number | undefined, y: number | undefined) => boolean;
 /** Greater than or equal comparison, handling undefined values */
-export declare const gte: (x: Maybe<number>, y: Maybe<number>) => boolean;
+export declare const gte: (x: number | undefined, y: number | undefined) => boolean;
 /** Returns maximum value in array, handling undefined values */
-export declare const max: (xs: Maybe<number>[]) => number;
+export declare const max: (xs: (number | undefined)[]) => number;
 /** Returns minimum value in array, handling undefined values */
-export declare const min: (xs: Maybe<number>[]) => number;
+export declare const min: (xs: (number | undefined)[]) => number;
 /** Returns sum of array values, handling undefined values */
-export declare const sum: (xs: Maybe<number>[]) => number;
+export declare const sum: (xs: (number | undefined)[]) => number;
 /** Returns average of array values, handling undefined values */
-export declare const avg: (xs: Maybe<number>[]) => number;
-/**
- * Returns array with first n elements removed
- * @param n - Number of elements to drop
- * @param xs - Input array
- * @returns Array with first n elements removed
- */
-export declare const drop: <T>(n: number, xs: T[]) => T[];
+export declare const avg: (xs: (number | undefined)[]) => number;
 /**
- * Returns first n elements of array
- * @param n - Number of elements to take
- * @param xs - Input array
- * @returns Array of first n elements
+ * Checks if a number is between two values (exclusive)
+ * @param bounds - Lower and upper bounds
+ * @param n - Number to check
+ * @returns True if n is between low and high
  */
-export declare const take: <T>(n: number, xs: T[]) => T[];
+export declare const between: ([low, high]: [number, number], n: number) => boolean;
 /**
- * Creates new object with specified keys removed
- * @param ks - Keys to remove
- * @param x - Source object
- * @returns New object without specified keys
+ * Checks if a number is between two values (inclusive)
+ * @param bounds - Lower and upper bounds
+ * @param n - Number to check
+ * @returns True if n is between low and high
  */
-export declare const omit: <T extends Obj>(ks: string[], x: T) => T;
+export declare const within: ([low, high]: [number, number], n: number) => boolean;
 /**
- * Creates new object excluding entries with specified values
- * @param xs - Values to exclude
- * @param x - Source object
- * @returns New object without entries containing specified values
+ * Constrains number between min and max values
+ * @param bounds - Minimum and maximum allowed values
+ * @param n - Number to clamp
+ * @returns Clamped value
  */
-export declare const omitVals: <T extends Obj>(xs: any[], x: T) => T;
+export declare const clamp: ([min, max]: [number, number], n: number) => number;
 /**
- * Creates new object with only specified keys
- * @param ks - Keys to keep
- * @param x - Source object
- * @returns New object with only specified keys
+ * Round a number to the nearest float precision
+ * @param precision - Number of decimal places
+ * @param x - Number to round
+ * @returns Formatted number
  */
-export declare const pick: <T extends Obj>(ks: string[], x: T) => T;
+export declare const round: (precision: number, x: number) => number;
+/** One minute in seconds */
+export declare const MINUTE = 60;
+/** One hour in seconds */
+export declare const HOUR: number;
+/** One day in seconds */
+export declare const DAY: number;
+/** One week in seconds */
+export declare const WEEK: number;
+/** One month in seconds (approximate) */
+export declare const MONTH: number;
+/** One quarter in seconds (approximate) */
+export declare const QUARTER: number;
+/** One year in seconds (approximate) */
+export declare const YEAR: number;
+/** User's default locale */
+export declare const LOCALE: string;
+/** User's default timezone */
+export declare const TIMEZONE: string;
 /**
- * Generates sequence of numbers from a to b
- * @param a - Start number (inclusive)
- * @param b - End number (exclusive)
- * @param step - Increment between numbers
- * @yields Numbers in sequence
+ * Multiplies time unit by count
+ * @param unit - Time unit in seconds
+ * @param count - Number of units
+ * @returns Total seconds
  */
-export declare function range(a: number, b: number, step?: number): Generator<number, void, unknown>;
+export declare const int: (unit: number, count?: number) => number;
+/** Returns current Unix timestamp in seconds */
+export declare const now: () => number;
 /**
- * Yields indexed items
- * @param items - A collection of items
- * @yields tuples of [index, item]
+ * Returns Unix timestamp from specified time ago
+ * @param unit - Time unit in seconds
+ * @param count - Number of units
+ * @returns Timestamp in seconds
  */
-export declare function enumerate<T>(items: T[]): Generator<[number, T], void, unknown>;
+export declare const ago: (unit: number, count?: number) => number;
 /**
- * Creates new object with transformed keys
- * @param f - Function to transform keys
- * @param x - Source object
- * @returns Object with transformed keys
+ * Converts seconds to milliseconds
+ * @param seconds - Time in seconds
+ * @returns Time in milliseconds
  */
-export declare const mapKeys: <T extends Obj>(f: (v: string) => string, x: T) => T;
+export declare const ms: (seconds: number) => number;
 /**
- * Creates new object with transformed values
- * @param f - Function to transform values
- * @param x - Source object
- * @returns Object with transformed values
+ * Converts seconds to date
+ * @param seconds - Time in seconds
+ * @returns Date object
  */
-export declare const mapVals: <V, U>(f: (v: V) => U, x: Record<string, V>) => Record<string, U>;
+export declare const secondsToDate: (seconds: number) => Date;
 /**
- * Merges two objects, with left object taking precedence
- * @param a - Left object
- * @param b - Right object
- * @returns Merged object with a"s properties overriding b"s
+ * Converts date object to seconds
+ * @param date - Date object
+ * @returns timestamp in seconds
  */
-export declare const mergeLeft: <T extends Obj>(a: T, b: T) => T;
+export declare const dateToSeconds: (date: Date) => number;
 /**
- * Merges two objects, with right object taking precedence
- * @param a - Left object
- * @param b - Right object
- * @returns Merged object with b"s properties overriding a"s
+ * Creates a local date from a date string
+ * @param dateString - date string
+ * @param timezone - timezone string
+ * @returns timezone-aware Date object
  */
-export declare const mergeRight: <T extends Obj>(a: T, b: T) => T;
-/** Deep merge two objects, prioritizing the first argument. */
-export declare const deepMergeLeft: (a: Obj, b: Obj) => Obj<any>;
-/** Deep merge two objects, prioritizing the second argument. */
-export declare const deepMergeRight: (a: Obj, b: Obj) => Obj<any>;
+export declare const createLocalDate: (dateString: any, timezone?: string) => Date;
+/** Formatter for date+time */
+export declare const dateTimeFormatter: Intl.DateTimeFormat;
 /**
- * Checks if a number is between two values (exclusive)
- * @param bounds - Lower and upper bounds
- * @param n - Number to check
- * @returns True if n is between low and high
+ * Formats seconds as a datetime
+ * @param seconds - timestamp in seconds
+ * @returns datetime string
  */
-export declare const between: ([low, high]: [number, number], n: number) => boolean;
+export declare const formatTimestamp: (seconds: number) => string;
+/** Formatter for date */
+export declare const dateFormatter: Intl.DateTimeFormat;
 /**
- * Checks if a number is between two values (inclusive)
- * @param bounds - Lower and upper bounds
- * @param n - Number to check
- * @returns True if n is between low and high
+ * Formats seconds as a date
+ * @param seconds - timestamp in seconds
+ * @returns date string
  */
-export declare const within: ([low, high]: [number, number], n: number) => boolean;
+export declare const formatTimestampAsDate: (ts: number) => string;
+/** Formatter for time */
+export declare const timeFormatter: Intl.DateTimeFormat;
 /**
- * Generates random integer between min and max (inclusive)
- * @param min - Minimum value
- * @param max - Maximum value
- * @returns Random integer
+ * Formats seconds as a time
+ * @param seconds - timestamp in seconds
+ * @returns time string
  */
-export declare const randomInt: (min?: number, max?: number) => number;
+export declare const formatTimestampAsTime: (ts: number) => string;
 /**
- * Generates random string ID
- * @returns Random string suitable for use as an ID
+ * Formats seconds as a relative date (x minutes ago)
+ * @param seconds - timestamp in seconds
+ * @returns relative date string
  */
-export declare const randomId: () => string;
+export declare const formatTimestampRelative: (ts: number) => string;
 /**
- * Removes protocol (http://, https://, etc) from URL
- * @param url - URL to process
- * @returns URL without protocol
+ * Returns the first element of an array
+ * @param xs - The array
+ * @returns First element or undefined
  */
-export declare const stripProtocol: (url: string) => string;
+export declare const first: <T>(xs: Iterable<T>, ...args: unknown[]) => T | undefined;
 /**
- * Formats URL for display by removing protocol, www, and trailing slash
- * @param url - URL to format
- * @returns Formatted URL
+ * Returns the first element of the first array in a nested array
+ * @param xs - Array of arrays
+ * @returns First element of first array or undefined
  */
-export declare const displayUrl: (url: string) => string;
+export declare const ffirst: <T>(xs: Iterable<Iterable<T>>, ...args: unknown[]) => T | undefined;
 /**
- * Extracts and formats domain from URL
- * @param url - URL to process
- * @returns Formatted domain name
+ * Returns the last element of an array
+ * @param xs - The array
+ * @returns Last element or undefined
  */
-export declare const displayDomain: (url: string) => string;
+export declare const last: <T>(xs: Iterable<T>, ...args: unknown[]) => T;
 /**
- * Creates a promise that resolves after specified time
- * @param t - Time in milliseconds
- * @returns Promise that resolves after t milliseconds
+ * Returns array with first n elements removed
+ * @param n - Number of elements to drop
+ * @param xs - Input array
+ * @returns Array with first n elements removed
  */
-export declare const sleep: (t: number) => Promise<unknown>;
+export declare const drop: <T>(n: number, xs: Iterable<T>) => T[];
 /**
- * Creates a microtask that yields to other tasks in the event loop
- * @returns Promise that resolves after yielding
+ * Returns first n elements of array
+ * @param n - Number of elements to take
+ * @param xs - Input array
+ * @returns Array of first n elements
  */
-export declare const yieldThread: () => any;
+export declare const take: <T>(n: number, xs: Iterable<T>) => T[];
 /**
  * Concatenates multiple arrays, filtering out null/undefined
  * @param xs - Arrays to concatenate
@@ -260,6 +252,13 @@ export declare const difference: <T>(a: T[], b: T[]) => T[];
  * @returns New array with element removed
  */
 export declare const remove: <T>(a: T, xs: T[]) => T[];
+/**
+ * Removes element at index
+ * @param i - Index to remove
+ * @param xs - Source array
+ * @returns New array with element removed
+ */
+export declare const removeAt: <T>(i: number, xs: T[]) => T[];
 /**
  * Returns elements from second array not present in first
  * @param a - Array of elements to exclude
@@ -275,137 +274,46 @@ export declare const without: <T>(a: T[], b: T[]) => T[];
  */
 export declare const toggle: <T>(x: T, xs: T[]) => T[];
 /**
- * Constrains number between min and max values
- * @param bounds - Minimum and maximum allowed values
- * @param n - Number to clamp
- * @returns Clamped value
+ * Generates sequence of numbers from a to b
+ * @param a - Start number (inclusive)
+ * @param b - End number (exclusive)
+ * @param step - Increment between numbers
+ * @yields Numbers in sequence
  */
-export declare const clamp: ([min, max]: [number, number], n: number) => number;
+export declare function range(a: number, b: number, step?: number): Generator<number, void, unknown>;
 /**
- * Round a number to the nearest float precision
- * @param precision - Number of decimal places
- * @param x - Number to round
- * @returns Formatted number
+ * Yields indexed items
+ * @param items - A collection of items
+ * @yields tuples of [index, item]
  */
-export declare const round: (precision: number, x: number) => number;
+export declare function enumerate<T>(items: T[]): Generator<[number, T], void, unknown>;
+/** Returns a function that gets property value from object */
+export declare const pluck: <T>(k: string, xs: Record<string, unknown>[]) => T[];
 /**
- * Safely parses JSON string
- * @param json - JSON string to parse
- * @returns Parsed object or null if invalid
+ * Creates object from array of key-value pairs
+ * @param pairs - Array of [key, value] tuples
+ * @returns Object with keys and values from pairs
  */
-export declare const parseJson: (json: string | Nil) => any;
+export declare const fromPairs: <T>(pairs: [k?: string, v?: T, ...args: unknown[]][]) => Record<string, T>;
 /**
- * Gets and parses JSON from localStorage
- * @param k - Storage key
- * @returns Parsed value or undefined if invalid/missing
+ * Flattens array of arrays into single array
+ * @param xs - Array of arrays to flatten
+ * @returns Flattened array
  */
-export declare const getJson: (k: string) => any;
+export declare const flatten: <T>(xs: T[][]) => T[];
 /**
- * Stringifies and stores value in localStorage
- * @param k - Storage key
- * @param v - Value to store
+ * Splits array into two arrays based on predicate
+ * @param f - Function to test elements
+ * @param xs - Array to partition
+ * @returns Tuple of [matching, non-matching] arrays
  */
-export declare const setJson: (k: string, v: any) => void;
+export declare const partition: <T>(f: (x: T) => boolean, xs: T[]) => T[][];
 /**
- * Safely executes function and handles errors
- * @param f - Function to execute
- * @param onError - Optional error handler
- * @returns Function result or undefined if error
+ * Returns array with duplicate elements removed
+ * @param xs - Array with possible duplicates
+ * @returns Array with unique elements
  */
-export declare const tryCatch: <T>(f: () => T, onError?: (e: Error) => void) => T | undefined;
-/**
- * Truncates string to length, breaking at word boundaries
- * @param s - String to truncate
- * @param l - Maximum length
- * @param suffix - String to append if truncated
- * @returns Truncated string
- */
-export declare const ellipsize: (s: string, l: number, suffix?: string) => string;
-/**
- * Checks if value is a plain object
- * @param obj - Value to check
- * @returns True if value is a plain object
- */
-export declare const isPojo: (obj: any) => boolean;
-/**
- * Deep equality comparison
- * @param a - First value
- * @param b - Second value
- * @returns True if values are deeply equal
- */
-export declare const equals: (a: any, b: any) => boolean;
-/** Returns a function that gets the nth element of an array */
-export declare const nth: (i: number) => <T>(xs: T[], ...args: unknown[]) => T;
-/** Returns a function that checks if nth element equals value */
-export declare const nthEq: (i: number, v: any) => (xs: any[], ...args: unknown[]) => boolean;
-/** Returns a function that checks if nth element does not equal value */
-export declare const nthNe: (i: number, v: any) => (xs: any[], ...args: unknown[]) => boolean;
-/** Returns a function that checks if key/value pairs of x match all pairs in spec */
-export declare const spec: (values: Obj | Array<any>) => (x: Obj | Array<any>, ...args: unknown[]) => boolean;
-/** Returns a function that checks equality with value */
-export declare const eq: <T>(v: T) => (x: T) => boolean;
-/** Returns a function that checks inequality with value */
-export declare const ne: <T>(v: T) => (x: T) => boolean;
-/** Returns a function that gets property value from object */
-export declare const prop: <T>(k: string) => (x: Record<string, unknown>) => T;
-/** Returns a function that adds/updates a property on object */
-export declare const assoc: <K extends string, T, U>(k: K, v: T) => (o: U) => U & Record<K, T>;
-/** Returns a function that removes a property on object */
-export declare const dissoc: <K extends string, T extends Obj>(k: K) => (o: T) => T;
-/** Generates a hash string from input string */
-export declare const hash: (s: string) => string;
-/** Splits array into two parts at index */
-export declare const splitAt: <T>(n: number, xs: T[]) => T[][];
-/** Inserts element into array at index */
-export declare const insert: <T>(n: number, x: T, xs: T[]) => T[];
-/** Returns random element from array */
-export declare const choice: <T>(xs: T[]) => T;
-/** Returns shuffled copy of iterable */
-export declare const shuffle: <T>(xs: Iterable<T>) => T[];
-/** Returns n random elements from array */
-export declare const sample: <T>(n: number, xs: T[]) => T[];
-/** Checks if value is iterable */
-export declare const isIterable: (x: any) => boolean;
-/** Ensures value is iterable by wrapping in array if needed */
-export declare const toIterable: (x: any) => any;
-/** Ensures value is array by wrapping if needed */
-export declare const ensurePlural: <T>(x: T | T[]) => T[];
-/** Converts string or number to number */
-export declare const ensureNumber: (x: number | string) => number;
-/** Returns a function that gets property value from object */
-export declare const pluck: <T>(k: string, xs: Record<string, unknown>[]) => T[];
-/**
- * Creates object from array of key-value pairs
- * @param pairs - Array of [key, value] tuples
- * @returns Object with keys and values from pairs
- */
-export declare const fromPairs: <T>(pairs: [k?: string, v?: T, ...args: unknown[]][]) => Record<string, T>;
-/**
- * Filters object values based on predicate
- * @param f - Function to test values
- * @param x - Object to filter
- * @returns Object with only values that pass predicate
- */
-export declare const filterVals: <T extends Record<string, any>>(f: (v: any) => boolean, x: T) => T;
-/**
- * Flattens array of arrays into single array
- * @param xs - Array of arrays to flatten
- * @returns Flattened array
- */
-export declare const flatten: <T>(xs: T[][]) => T[];
-/**
- * Splits array into two arrays based on predicate
- * @param f - Function to test elements
- * @param xs - Array to partition
- * @returns Tuple of [matching, non-matching] arrays
- */
-export declare const partition: <T>(f: (x: T) => boolean, xs: T[]) => T[][];
-/**
- * Returns array with duplicate elements removed
- * @param xs - Array with possible duplicates
- * @returns Array with unique elements
- */
-export declare const uniq: <T>(xs: T[]) => T[];
+export declare const uniq: <T>(xs: T[]) => T[];
 /**
  * Returns array with elements unique by key function
  * @param f - Function to generate key for each element
@@ -433,6 +341,13 @@ export declare const sortBy: <T>(f: (x: T) => any, xs: T[]) => T[];
  * @returns Map of groups
  */
 export declare const groupBy: <T, K>(f: (x: T) => K, xs: T[]) => Map<K, T[]>;
+/**
+ * Counts array elements by key function
+ * @param f - Function to generate group key
+ * @param xs - Array to count entries
+ * @returns Map of counts
+ */
+export declare const countBy: <T, K>(f: (x: T) => K, xs: T[]) => Map<K, number>;
 /**
  * Creates map from array using key function
  * @param f - Function to generate key
@@ -461,6 +376,108 @@ export declare const chunk: <T>(chunkLength: number, xs: T[]) => T[][];
  * @returns Array of n chunks
  */
 export declare const chunks: <T>(n: number, xs: T[]) => T[][];
+/** Splits array into two parts at index */
+export declare const splitAt: <T>(n: number, xs: T[]) => T[][];
+/** Inserts element into array at index */
+export declare const insertAt: <T>(n: number, x: T, xs: T[]) => T[];
+/** Replaces array element at index */
+export declare const replaceAt: <T>(n: number, x: T, xs: T[]) => T[];
+/** Returns random element from array */
+export declare const choice: <T>(xs: T[]) => T;
+/** Returns shuffled copy of iterable */
+export declare const shuffle: <T>(xs: Iterable<T>) => T[];
+/** Returns n random elements from array */
+export declare const sample: <T>(n: number, xs: T[]) => T[];
+/** Checks if value is iterable */
+export declare const isIterable: (x: any) => boolean;
+/** Ensures value is iterable by wrapping in array if needed */
+export declare const toIterable: (x: any) => any;
+/** Ensures value is array by wrapping if needed */
+export declare const ensurePlural: <T>(x: T | T[]) => T[];
+/** Ensures values are not undefined */
+export declare const removeNil: <T>(xs: T[]) => NonNullable<T & {}>[];
+/**
+ * Checks if value is a plain object
+ * @param obj - Value to check
+ * @returns True if value is a plain object
+ */
+export declare const isPojo: (obj: any) => boolean;
+/**
+ * Creates new object with only specified keys
+ * @param ks - Keys to keep
+ * @param x - Source object
+ * @returns New object with only specified keys
+ */
+export declare const pick: <T extends Obj>(ks: string[], x: T) => T;
+/**
+ * Creates new object with specified keys removed
+ * @param ks - Keys to remove
+ * @param x - Source object
+ * @returns New object without specified keys
+ */
+export declare const omit: <T extends Obj>(ks: string[], x: T) => T;
+/**
+ * Creates new object excluding entries with specified values
+ * @param xs - Values to exclude
+ * @param x - Source object
+ * @returns New object without entries containing specified values
+ */
+export declare const omitVals: <T extends Obj>(xs: any[], x: T) => T;
+/**
+ * Filters object values based on predicate
+ * @param f - Function to test values
+ * @param x - Object to filter
+ * @returns Object with only values that pass predicate
+ */
+export declare const filterVals: <T extends Record<string, any>>(f: (v: any) => boolean, x: T) => T;
+/**
+ * Creates new object with transformed keys
+ * @param f - Function to transform keys
+ * @param x - Source object
+ * @returns Object with transformed keys
+ */
+export declare const mapKeys: <T extends Obj>(f: (v: string) => string, x: T) => T;
+/**
+ * Creates new object with transformed values
+ * @param f - Function to transform values
+ * @param x - Source object
+ * @returns Object with transformed values
+ */
+export declare const mapVals: <V, U>(f: (v: V) => U, x: Record<string, V>) => Record<string, U>;
+/**
+ * Merges two objects, with left object taking precedence
+ * @param a - Left object
+ * @param b - Right object
+ * @returns Merged object with a"s properties overriding b"s
+ */
+export declare const mergeLeft: <T extends Obj>(a: T, b: T) => T;
+/**
+ * Merges two objects, with right object taking precedence
+ * @param a - Left object
+ * @param b - Right object
+ * @returns Merged object with b"s properties overriding a"s
+ */
+export declare const mergeRight: <T extends Obj>(a: T, b: T) => T;
+/** Deep merge two objects, prioritizing the first argument. */
+export declare const deepMergeLeft: (a: Obj, b: Obj) => Obj<any>;
+/** Deep merge two objects, prioritizing the second argument. */
+export declare const deepMergeRight: (a: Obj, b: Obj) => Obj<any>;
+/**
+ * Switches on key in object, with default fallback
+ * @param k - Key to look up
+ * @param m - Object with values and optional default
+ * @returns Value at key or default value
+ */
+export declare const switcher: <T>(k: string, m: Record<string, T>) => T;
+/** Returns a function that returns the boolean negation of the given function */
+export declare const complement: <T extends unknown[]>(f: (...args: T) => any) => (...args: T) => boolean;
+/**
+ * Safely executes function and handles errors
+ * @param f - Function to execute
+ * @param onError - Optional error handler
+ * @returns Function result or undefined if error
+ */
+export declare const tryCatch: <T>(f: () => T, onError?: (e: Error) => void) => T | undefined;
 /**
  * Creates function that only executes once
  * @param f - Function to wrap
@@ -479,6 +496,47 @@ export declare const call: <T>(f: () => T, ...args: unknown[]) => T;
  * @returns Memoized function
  */
 export declare const memoize: <T>(f: (...args: any[]) => T) => (...args: any[]) => T;
+/**
+ * Executes a function if the value is defined
+ * @param x - The value to check
+ * @param f - Function to execute if x is defined
+ * @returns Result of f(x) if x is defined, undefined otherwise
+ */
+export declare const ifLet: <T>(x: T | undefined, f: (x: T) => void) => void;
+/**
+ * Generates random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ */
+export declare const randomInt: (min?: number, max?: number) => number;
+/**
+ * Generates random string ID
+ * @returns Random string suitable for use as an ID
+ */
+export declare const randomId: () => string;
+/**
+ * Creates a promise that resolves after specified time
+ * @param t - Time in milliseconds
+ * @returns Promise that resolves after t milliseconds
+ */
+export declare const sleep: (t: number) => Promise<unknown>;
+export type PollOptions = {
+    signal: AbortSignal;
+    condition: () => boolean;
+    interval?: number;
+};
+/**
+ * Creates a promise that resolves after the condition completes or timeout
+ * @param options - PollOptions
+ * @returns void Promise
+ */
+export declare const poll: ({ interval, condition, signal }: PollOptions) => Promise<void>;
+/**
+ * Creates a microtask that yields to other tasks in the event loop
+ * @returns Promise that resolves after yielding
+ */
+export declare const yieldThread: () => any;
 /**
  * Creates throttled version of function
  * @param ms - Minimum time between calls
@@ -510,89 +568,48 @@ export declare const batch: <T>(t: number, f: (xs: T[]) => void) => (x: T) => vo
  */
 export declare const batcher: <T, U>(t: number, execute: (request: T[]) => U[] | Promise<U[]>) => (request: T) => Promise<U>;
 /**
- * Adds value to Set at key in object
- * @param m - Object mapping keys to Sets
- * @param k - Key to add to
- * @param v - Value to add
+ * Returns a promise that resolves after some proportion of promises complete
+ * @param threshold - number between 0 and 1 for how many promises to wait for
+ * @param promises - array of promises
+ * @returns promise
  */
-export declare const addToKey: <T>(m: Record<string, Set<T>>, k: string, v: T) => void;
+export declare const race: (threshold: number, promises: Promise<unknown>[]) => Promise<void>;
 /**
- * Pushes value to array at key in object
- * @param m - Object mapping keys to arrays
- * @param k - Key to push to
- * @param v - Value to push
- */
-export declare const pushToKey: <T>(m: Record<string, T[]>, k: string, v: T) => void;
-/**
- * Adds value to Set at key in Map
- * @param m - Map of Sets
- * @param k - Key to add to
- * @param v - Value to add
- */
-export declare const addToMapKey: <K, T>(m: Map<K, Set<T>>, k: K, v: T) => void;
-/**
- * Pushes value to array at key in Map
- * @param m - Map of arrays
- * @param k - Key to push to
- * @param v - Value to push
+ * Removes protocol (http://, https://, etc) from URL
+ * @param url - URL to process
+ * @returns URL without protocol
  */
-export declare const pushToMapKey: <K, T>(m: Map<K, T[]>, k: K, v: T) => void;
+export declare const stripProtocol: (url: string) => string;
 /**
- * A generic type-safe event listener function that auto-detects the appropriate methods
- * for adding and removing event listeners.
- *
- * @param target - The event target object with add/remove listener methods
- * @param eventName - The name of the event to listen for
- * @param callback - The callback function to execute when the event occurs
- * @returns A function that removes the event listener when called
+ * Formats URL for display by removing protocol, www, and trailing slash
+ * @param url - URL to format
+ * @returns Formatted URL
  */
-export declare const on: <EventName extends string, Args extends any[]>(target: {
-    on: (event: EventName, handler: (...args: Args) => any, ...rest: any[]) => any;
-    off: (event: EventName, handler: (...args: Args) => any, ...rest: any[]) => any;
-}, eventName: EventName, callback: (...args: Args) => void) => (() => void);
+export declare const displayUrl: (url: string) => string;
 /**
- * Switches on key in object, with default fallback
- * @param k - Key to look up
- * @param m - Object with values and optional default
- * @returns Value at key or default value
+ * Extracts and formats domain from URL
+ * @param url - URL to process
+ * @returns Formatted domain name
  */
-export declare const switcher: <T>(k: string, m: Record<string, T>) => T;
-/** One minute in seconds */
-export declare const MINUTE = 60;
-/** One hour in seconds */
-export declare const HOUR: number;
-/** One day in seconds */
-export declare const DAY: number;
-/** One week in seconds */
-export declare const WEEK: number;
-/** One month in seconds (approximate) */
-export declare const MONTH: number;
-/** One quarter in seconds (approximate) */
-export declare const QUARTER: number;
-/** One year in seconds (approximate) */
-export declare const YEAR: number;
+export declare const displayDomain: (url: string) => string;
 /**
- * Multiplies time unit by count
- * @param unit - Time unit in seconds
- * @param count - Number of units
- * @returns Total seconds
+ * Safely parses JSON string
+ * @param json - JSON string to parse
+ * @returns Parsed object or null if invalid
  */
-export declare const int: (unit: number, count?: number) => number;
-/** Returns current Unix timestamp in seconds */
-export declare const now: () => number;
+export declare const parseJson: (json: string | undefined) => any;
 /**
- * Returns Unix timestamp from specified time ago
- * @param unit - Time unit in seconds
- * @param count - Number of units
- * @returns Timestamp in seconds
+ * Gets and parses JSON from localStorage
+ * @param k - Storage key
+ * @returns Parsed value or undefined if invalid/missing
  */
-export declare const ago: (unit: number, count?: number) => number;
+export declare const getJson: (k: string) => any;
 /**
- * Converts seconds to milliseconds
- * @param seconds - Time in seconds
- * @returns Time in milliseconds
+ * Stringifies and stores value in localStorage
+ * @param k - Storage key
+ * @param v - Value to store
  */
-export declare const ms: (seconds: number) => number;
+export declare const setJson: (k: string, v: any) => void;
 /** Options for fetch requests */
 type FetchOpts = {
     method?: string;
@@ -621,6 +638,78 @@ export declare const postJson: <T>(url: string, data: T, opts?: FetchOpts) => Pr
  * @returns Promise of parsed JSON response
  */
 export declare const uploadFile: (url: string, file: File) => Promise<any>;
+/**
+ * A generic type-safe event listener function that works with event emitters.
+ *
+ * @param target - The event target object with add/remove listener methods
+ * @param eventName - The name of the event to listen for
+ * @param callback - The callback function to execute when the event occurs
+ * @returns A function that removes the event listener when called
+ */
+export declare const on: <EventMap extends Record<string | symbol, any[]>, E extends keyof EventMap>(target: {
+    on(event: E, listener: (...args: EventMap[E]) => any): any;
+    off(event: E, listener: (...args: EventMap[E]) => any): any;
+}, eventName: E, callback: (...args: EventMap[E]) => void) => (() => void);
+/**
+ * Truncates string to length, breaking at word boundaries
+ * @param s - String to truncate
+ * @param l - Maximum length
+ * @param suffix - String to append if truncated
+ * @returns Truncated string
+ */
+export declare const ellipsize: (s: string, l: number, suffix?: string) => string;
+/** Displays a list of items with oxford commas and a chosen conjunction */
+export declare const displayList: <T>(xs: T[], conj?: string, n?: number) => string;
+/** Generates a hash string from input string */
+export declare const hash: (s: string) => string;
+/** Returns a function that gets the nth element of an array */
+export declare const nth: (i: number) => <T>(xs: T[], ...args: unknown[]) => T;
+/** Returns a function that checks if nth element equals value */
+export declare const nthEq: (i: number, v: any) => (xs: any[], ...args: unknown[]) => boolean;
+/** Returns a function that checks if nth element does not equal value */
+export declare const nthNe: (i: number, v: any) => (xs: any[], ...args: unknown[]) => boolean;
+/** Returns a function that checks if key/value pairs of x match all pairs in spec */
+export declare const spec: (values: Obj | Array<any>) => (x: Obj | Array<any>, ...args: unknown[]) => boolean;
+/** Returns a function that checks equality with value */
+export declare const eq: <T>(v: T) => (x: T, ...args: unknown[]) => boolean;
+/** Returns a function that checks inequality with value */
+export declare const ne: <T>(v: T) => (x: T, ...args: unknown[]) => boolean;
+/** Returns a function that gets property value from object */
+export declare const prop: <T>(k: string) => (x: Record<string, unknown>) => T;
+/** Returns a function that adds/updates a property on object */
+export declare const assoc: <K extends string, T, U>(k: K, v: T) => (o: U) => U & Record<K, T>;
+/** Returns a function that removes a property on object */
+export declare const dissoc: <K extends string, T extends Obj>(k: K) => (o: T) => T;
+/** Returns a function that checks whether a value is in the given sequence */
+export declare const member: <T>(xs: Iterable<T>) => (x: T) => boolean;
+/**
+ * Adds value to Set at key in object
+ * @param m - Object mapping keys to Sets
+ * @param k - Key to add to
+ * @param v - Value to add
+ */
+export declare const addToKey: <T>(m: Record<string, Set<T>>, k: string, v: T) => void;
+/**
+ * Pushes value to array at key in object
+ * @param m - Object mapping keys to arrays
+ * @param k - Key to push to
+ * @param v - Value to push
+ */
+export declare const pushToKey: <T>(m: Record<string, T[]>, k: string, v: T) => void;
+/**
+ * Adds value to Set at key in Map
+ * @param m - Map of Sets
+ * @param k - Key to add to
+ * @param v - Value to add
+ */
+export declare const addToMapKey: <K, T>(m: Map<K, Set<T>>, k: K, v: T) => void;
+/**
+ * Pushes value to array at key in Map
+ * @param m - Map of arrays
+ * @param k - Key to push to
+ * @param v - Value to push
+ */
+export declare const pushToMapKey: <K, T>(m: Map<K, T[]>, k: K, v: T) => void;
 /**
  * Converts hex string to bech32 format
  * @param prefix - Bech32 prefix
@@ -635,3 +724,4 @@ export declare const hexToBech32: (prefix: string, hex: string) => `${Lowercase<
  */
 export declare const bech32ToHex: (b32: string) => string;
 export {};
+//# sourceMappingURL=Tools.d.ts.map