@dereekb/util 12.0.6 → 12.1.1

package/src/lib/boolean.d.ts

@@ -14,39 +14,39 @@ export type IsModified = boolean;
 /**
  * Reduces an array of booleans with the logical AND operation.
  *
- * @param array - Array of boolean values to reduce
- * @param emptyArrayValue - Value to return if the array is empty (default: undefined which becomes false)
- * @returns The result of ANDing all boolean values in the array
+ * @param array - Array of boolean values to reduce.
+ * @param emptyArrayValue - Value to return if the array is empty. If not provided and the array is empty, a TypeError will be thrown.
+ * @returns The result of ANDing all boolean values in the array.
  */
 export declare function reduceBooleansWithAnd(array: boolean[], emptyArrayValue?: boolean): boolean;
 /**
  * Reduces an array of booleans with the logical OR operation.
  *
- * @param array - Array of boolean values to reduce
- * @param emptyArrayValue - Value to return if the array is empty (default: undefined which becomes false)
- * @returns The result of ORing all boolean values in the array
+ * @param array - Array of boolean values to reduce.
+ * @param emptyArrayValue - Value to return if the array is empty. If not provided and the array is empty, a TypeError will be thrown.
+ * @returns The result of ORing all boolean values in the array.
  */
 export declare function reduceBooleansWithOr(array: boolean[], emptyArrayValue?: boolean): boolean;
 /**
  * Creates a function that reduces an array of booleans with the logical AND operation.
  *
- * @param emptyArrayValue - Value to return if the array is empty (default: undefined which becomes false)
- * @returns A function that takes an array of booleans and returns the result of ANDing them
+ * @param emptyArrayValue - Value to return if the array is empty. If not provided and the array is empty, the returned function will throw a TypeError.
+ * @returns A function that takes an array of booleans and returns the result of ANDing them.
  */
 export declare function reduceBooleansWithAndFn(emptyArrayValue?: boolean): (array: boolean[]) => boolean;
 /**
  * Creates a function that reduces an array of booleans with the logical OR operation.
  *
- * @param emptyArrayValue - Value to return if the array is empty (default: undefined which becomes false)
- * @returns A function that takes an array of booleans and returns the result of ORing them
+ * @param emptyArrayValue - Value to return if the array is empty. If not provided and the array is empty, the returned function will throw a TypeError.
+ * @returns A function that takes an array of booleans and returns the result of ORing them.
  */
 export declare function reduceBooleansWithOrFn(emptyArrayValue?: boolean): (array: boolean[]) => boolean;
 /**
  * Creates a function that reduces an array of booleans using a custom reduce function.
  *
- * @param reduceFn - Function that takes two boolean values and returns a single boolean
- * @param emptyArrayValue - Value to return if the array is empty (default: undefined which uses the standard reduce behavior)
- * @returns A function that takes an array of booleans and returns the result of reducing them
+ * @param reduceFn - Function that takes two boolean values and returns a single boolean.
+ * @param emptyArrayValue - Value to return if the array is empty. If not provided and the array is empty, the returned function will throw a TypeError because `Array.prototype.reduce` on an empty array without an initial value throws.
+ * @returns A function that takes an array of booleans and returns the result of reducing them.
  */
 export declare function reduceBooleansFn(reduceFn: (a: boolean, b: boolean) => boolean, emptyArrayValue?: boolean): (array: boolean[]) => boolean;
 /**
@@ -56,24 +56,28 @@ export type BooleanFactory = Factory<boolean>;
 /**
  * Number from 0.0 to 100.0 used for the chance to return true.
  */
-export type BooleanChance = number;
+export type BooleanTrueChance = number;
+/**
+ * Configuration for `booleanFactory`.
+ */
 export interface BooleanFactoryConfig {
     /**
-     * Chance of returning true.
+     * Chance of returning true, expressed as a number from 0.0 to 100.0.
+     * For example, a value of 75 means a 75% chance of returning true.
      */
-    chance: BooleanChance;
+    readonly chance: BooleanTrueChance;
 }
 /**
  * Creates a new BooleanFactory that generates random boolean values based on chance.
  *
- * @param config - Configuration for the boolean factory, including the chance of returning true
- * @returns A factory function that generates random boolean values
+ * @param config - Configuration for the boolean factory, including the chance of returning true.
+ * @returns A factory function (`BooleanFactory`) that generates random boolean values based on the configured chance.
  */
-export declare function booleanFactory(config: BooleanFactoryConfig): () => boolean;
+export declare function booleanFactory(config: BooleanFactoryConfig): BooleanFactory;
 /**
  * Returns a random boolean based on the specified chance.
  *
- * @param chance - Number between 0 and 100 representing the percentage chance of returning true (default: 50)
- * @returns A random boolean value with the specified probability of being true
+ * @param chance - Number between 0.0 and 100.0 representing the percentage chance of returning true (default: 50, i.e., 50%).
+ * @returns A random boolean value with the specified probability of being true.
  */
-export declare function randomBoolean(chance?: BooleanChance): boolean;
+export declare function randomBoolean(chance?: BooleanTrueChance): boolean;

package/src/lib/date/date.d.ts

@@ -209,10 +209,25 @@ export type UnixDateTimeNumber = number;
  * A date or a unix timestamp
  */
 export type DateOrUnixDateTimeNumber = Date | UnixDateTimeNumber;
+/**
+ * Number of milliseconds.
+ */
 export type Milliseconds = number;
+/**
+ * Number of seconds.
+ */
 export type Seconds = number;
+/**
+ * Number of minutes.
+ */
 export type Minutes = number;
+/**
+ * Number of hours.
+ */
 export type Hours = number;
+/**
+ * Number of days.
+ */
 export type Days = number;
 /**
  * Number of hours in a day.
@@ -261,13 +276,23 @@ export type MonthOfYear = number;
  */
 export type DateMonth = number;
 /**
- * Retrieves the MonthOfYear value (1-12) from the input Date.
+ * Retrieves the MonthOfYear value (1-12) from the input Date in the current system timezone.
+ *
  * Converts JavaScript's 0-based month (0-11) to a 1-based month (1-12).
  *
  * @param date - The date to extract the month from
  * @returns The month of year as a number from 1-12
  */
 export declare function monthOfYearFromDate(date: Date): MonthOfYear;
+/**
+ * Retrieves the MonthOfYear value (1-12) from the input Date in the UTC timezone.
+ *
+ * Converts JavaScript's 0-based month (0-11) to a 1-based month (1-12).
+ *
+ * @param date - The date to extract the month from
+ * @returns The month of year as a number from 1-12
+ */
+export declare function monthOfYearFromUTCDate(date: Date): MonthOfYear;
 /**
  * Converts a JavaScript Date month (0-11) to a MonthOfYear (1-12).
  *

package/src/lib/date/time.d.ts

@@ -20,7 +20,7 @@ export type TimePeriodCounter = (() => number) & {
     readonly _reset: (start?: Date) => Date;
 };
 export declare function timePeriodCounter(timePeriodLength: number, lastTimePeriodStart?: Maybe<Date>): TimePeriodCounter;
-export type TimerState = 'running' | 'paused' | 'complete';
+export type TimerState = 'running' | 'paused' | 'complete' | 'cancelled';
 /**
  * Timer object that counts down a fixed duration amount.
  *
@@ -61,6 +61,10 @@ export interface Timer extends Destroyable {
      * If the timer is complete, this returns 0.
      */
     readonly durationRemaining: Maybe<Milliseconds>;
+    /**
+     * Completes the timer immediately.
+     */
+    completeNow(): void;
     /**
      * Starts the timer if it was not running. Does nothing if already running.
      */

package/src/lib/hash.d.ts

@@ -1,5 +1,37 @@
+/**
+ * Represents a salt value used in hashing.
+ */
 export type HashSalt = string;
+/**
+ * A Map used for decoding hashed string values.
+ *
+ * @template H The type of the hashed string (key).
+ * @template V The type of the original string (value).
+ */
 export type HashDecodeMap<H extends string = string, V extends string = string> = Map<H, V>;
+/**
+ * Decodes a list of hashed string values using a provided list of potential original values and a hash function.
+ *
+ * @param hashedValues An array of hashed strings to decode.
+ * @param decodeValues An array of potential original string values.
+ * @param hashFn A function that takes a string and returns its hashed representation.
+ * @returns An array of decoded strings. Values that cannot be decoded are filtered out.
+ */
 export declare function decodeHashedValues(hashedValues: string[], decodeValues: string[], hashFn: (value: string) => string): string[];
+/**
+ * Creates a `HashDecodeMap` from a list of potential original string values and a hash function.
+ * The map's keys are the hashed versions of the `decodeValues`, and the values are the original `decodeValues`.
+ *
+ * @param decodeValues An array of potential original string values.
+ * @param hashFn A function that takes a string and returns its hashed representation.
+ * @returns A `HashDecodeMap` for decoding hashed values.
+ */
 export declare function makeHashDecodeMap(decodeValues: string[], hashFn: (value: string) => string): HashDecodeMap;
+/**
+ * Decodes a list of hashed string values using a pre-built `HashDecodeMap`.
+ *
+ * @param hashedValues An array of hashed strings to decode.
+ * @param decodeMap A `HashDecodeMap` to use for looking up original values.
+ * @returns An array of decoded strings. Values that cannot be decoded are filtered out.
+ */
 export declare function decodeHashedValuesWithDecodeMap(hashedValues: string[], decodeMap: HashDecodeMap): string[];

package/src/lib/misc/host.d.ts

@@ -1,5 +1,12 @@
 import { type Maybe } from '../value/maybe.type';
-export declare function joinHostAndPort(config: Maybe<{
-    host: string;
-    port: number | string;
-}>): Maybe<string>;
+export interface JoinHostAndPortConfig {
+    readonly host: string;
+    readonly port: number | string;
+}
+/**
+ * Joins the host and port into a string.
+ *
+ * @param config
+ * @returns
+ */
+export declare function joinHostAndPort(config: Maybe<JoinHostAndPortConfig>): Maybe<string>;

package/src/lib/object/object.filter.tuple.d.ts

@@ -2,8 +2,8 @@ import { type FilterFunction } from '../filter/filter';
 import { type KeyAsString } from '../type';
 export type ForEachKeyValueTupleFunction<T extends object = object, K extends keyof T = keyof T> = (tuple: KeyValueTuple<T, K>, index: number) => void;
 export interface ForEachKeyValue<T extends object = object, K extends keyof T = keyof T> {
-    filter?: FilterKeyValueTuplesInput<T, K>;
-    forEach: ForEachKeyValueTupleFunction<T, K>;
+    readonly filter?: FilterKeyValueTuplesInput<T, K>;
+    readonly forEach: ForEachKeyValueTupleFunction<T, K>;
 }
 export declare function forEachKeyValue<T extends object = object, K extends keyof T = keyof T>(obj: T, { forEach, filter }: ForEachKeyValue<T, K>): void;
 export declare function filterKeyValueTuples<T extends object = object, K extends keyof T = keyof T>(obj: T, filter?: FilterKeyValueTuplesInput<T, K>): KeyValueTuple<T, K>[];

package/src/lib/set/set.allowed.d.ts

@@ -7,11 +7,11 @@ export interface AllowedSet<T> {
     /**
      * Values that are allowed. Hits against this set result in an initial true.
      */
-    allowed?: Maybe<Set<T>>;
+    readonly allowed?: Maybe<Set<T>>;
     /**
      * Values that are disallowed. Hits against this set result in false.
      */
-    disallowed?: Maybe<Set<T>>;
+    readonly disallowed?: Maybe<Set<T>>;
 }
 /**
  * Determines whether the input values are "allowed" for the given AllowedSet.

package/src/lib/storage/storage.d.ts

@@ -1,11 +1,39 @@
 import { type UnixDateTimeNumber } from '../date/date';
+/**
+ * String representation of data that is stored.
+ */
 export type StoredDataString = string;
+/**
+ * Key used for accessing stored data.
+ */
 export type StoredDataStorageKey = string;
+/**
+ * Interface for data that has been stored, including metadata about its storage time.
+ */
 export interface StoredData {
-    storedAt: UnixDateTimeNumber | undefined;
-    data: StoredDataString;
+    /**
+     * The Unix timestamp (in milliseconds) when the data was stored.
+     * Undefined if the storage time is not known or not applicable.
+     */
+    readonly storedAt: UnixDateTimeNumber | undefined;
+    /**
+     * The actual data stored, as a string.
+     */
+    readonly data: StoredDataString;
 }
+/**
+ * Interface for retrieved stored data that has been processed.
+ * Extends StoredData with information about expiration and the converted data form.
+ *
+ * @template T The type of the converted data.
+ */
 export interface ReadStoredData<T> extends StoredData {
-    expired: boolean;
-    convertedData: T;
+    /**
+     * Whether the stored data is considered expired.
+     */
+    readonly expired: boolean;
+    /**
+     * The data after being converted from its string representation to type T.
+     */
+    readonly convertedData: T;
 }

package/src/lib/storage/storage.error.d.ts

@@ -1,12 +1,36 @@
 import { BaseError } from 'make-error';
 import { type ReadStoredData } from './storage';
+/**
+ * Base error class for storage-related issues.
+ */
 export declare class StoredDataError extends BaseError {
+    /**
+     * Creates an instance of StoredDataError.
+     * @param message Optional error message.
+     */
     constructor(message?: string);
 }
+/**
+ * Error thrown when requested data does not exist in storage.
+ */
 export declare class DataDoesNotExistError extends StoredDataError {
+    /**
+     * Creates an instance of DataDoesNotExistError.
+     * @param message Optional error message.
+     */
     constructor(message?: string);
 }
+/**
+ * Error thrown when data exists in storage but is considered expired.
+ *
+ * @template T The type of the data that is expired.
+ */
 export declare class DataIsExpiredError<T> extends StoredDataError {
     readonly data: ReadStoredData<T>;
+    /**
+     * Creates an instance of DataIsExpiredError.
+     * @param data The expired data, including metadata.
+     * @param message Optional error message. If not provided, a default message will be used.
+     */
     constructor(data: ReadStoredData<T>, message?: string);
 }

package/src/lib/storage/storage.memory.d.ts

@@ -1,14 +1,53 @@
 import { type Maybe } from '../value/maybe.type';
 import { type StorageObject } from './storage.object';
+/**
+ * A StorageObject implementation that stores data in memory.
+ * This is not persistent and will be cleared when the JavaScript context is lost.
+ */
 export declare class MemoryStorageInstance implements StorageObject {
     private _length;
     private _storage;
+    /**
+     * The number of items stored.
+     */
     get length(): number;
+    /**
+     * Returns the key at the given index.
+     * @param index The index of the key to retrieve.
+     * @returns The key string if found, otherwise null.
+     */
     key(index: number): string;
+    /**
+     * Checks if a key exists in the storage.
+     * @param key The key to check.
+     * @returns True if the key exists, false otherwise.
+     */
     hasKey(key: string): boolean;
+    /**
+     * Retrieves an item from storage.
+     * @param key The key of the item to retrieve.
+     * @returns The item string if found, otherwise null or undefined.
+     */
     getItem(key: string): Maybe<string>;
+    /**
+     * Sets an item in storage.
+     * If the item is null or undefined, the key will be removed.
+     * @param key The key of the item to set.
+     * @param item The item string to store.
+     */
     setItem(key: string, item: Maybe<string>): void;
+    /**
+     * Removes an item from storage.
+     * @param key The key of the item to remove.
+     */
     removeItem(key: string): void;
+    /**
+     * Clears all items from the storage.
+     */
     clear(): void;
 }
+/**
+ * A shared, global instance of MemoryStorageInstance.
+ * Useful for singleton-like access to an in-memory store throughout an application.
+ */
 export declare const SHARED_MEMORY_STORAGE: MemoryStorageInstance;

package/src/lib/storage/storage.object.d.ts

@@ -4,8 +4,22 @@ import { type StoredDataStorageKey } from './storage';
  * Limited Class/Interface for storing string values synchronously.
  */
 export declare abstract class SimpleStorageObject {
+    /**
+     * Retrieves an item from storage.
+     * @param key The key of the item to retrieve.
+     * @returns The item string if found, otherwise null or undefined.
+     */
     abstract getItem(key: StoredDataStorageKey): Maybe<string>;
+    /**
+     * Sets an item in storage.
+     * @param key The key of the item to set.
+     * @param item The item string to store. If null or undefined, the item may be removed depending on implementation.
+     */
     abstract setItem(key: StoredDataStorageKey, item: Maybe<string>): void;
+    /**
+     * Removes an item from storage.
+     * @param key The key of the item to remove.
+     */
     abstract removeItem(key: StoredDataStorageKey): void;
 }
 /**
@@ -14,19 +28,47 @@ export declare abstract class SimpleStorageObject {
  * Has the same interface as localStorage for the web.
  */
 export declare abstract class StorageObject extends SimpleStorageObject {
+    /**
+     * The number of items stored in the storage object.
+     */
     abstract readonly length: number;
     /**
      * Returns the string key for the index.
      *
      * Returns null if no key available.
+     * @param index The index of the key to retrieve.
+     * @returns The key string if found, otherwise null.
      */
     abstract key(index: number): string | null;
 }
+/**
+ * Extended synchronous Class/Interface for storing string values with additional properties.
+ */
 export declare abstract class FullStorageObject extends StorageObject {
+    /**
+     * Whether or not the storage is persistant.
+     */
     abstract readonly isPersistant: boolean;
+    /**
+     * Whether or not the storage is available for use.
+     */
     abstract readonly isAvailable: boolean;
+    /**
+     * Removes all items from storage.
+     * @returns An array of keys that were removed.
+     */
     abstract removeAll(): string[];
 }
+/**
+ * Utility class for working with StorageObject instances.
+ */
 export declare class StorageObjectUtility {
+    /**
+     * Retrieves all keys from a StorageObject, optionally filtering by a prefix.
+     *
+     * @param storageObject The StorageObject to retrieve keys from.
+     * @param prefix Optional prefix to filter keys by.
+     * @returns An array of StoredDataStorageKey.
+     */
     static allKeysFromStorageObject(storageObject: StorageObject, prefix?: string): StoredDataStorageKey[];
 }

package/src/lib/string/password.d.ts

@@ -1 +1,4 @@
+/**
+ * A password string
+ */
 export type PasswordString = string;

package/src/lib/string/string.d.ts

@@ -16,6 +16,14 @@ export type ReadStringFunction<T, S extends string = string> = MapFunction<T, S>
  * I.E. 0,1,2
  */
 export type CommaSeparatedString<T = unknown> = string;
+/**
+ * Represents a string that is made up of space-separated values.
+ *
+ * Optional generic typing exists for communicating what values are separated within the string.
+ *
+ * I.E. 0 1 2
+ */
+export type SpaceSeparatedString<T = unknown> = string;
 export declare function caseInsensitiveString(input: string): string;
 export declare function caseInsensitiveString(input: undefined): undefined;
 export declare function caseInsensitiveString(input: Maybe<string>): Maybe<string>;

package/src/lib/string/transform.d.ts

@@ -1,32 +1,96 @@
 import { type MapFunction } from '../value/map';
 import { type Maybe } from '../value/maybe.type';
+/**
+ * Trims leading and trailing whitespace from a string.
+ * @param input The string to trim.
+ * @returns The trimmed string.
+ */
 export declare function stringTrimFunction(input: string): string;
+/**
+ * Converts a string to uppercase.
+ * @param input The string to convert.
+ * @returns The uppercase string.
+ */
 export declare function stringToUppercaseFunction(input: string): string;
+/**
+ * Converts a string to lowercase.
+ * @param input The string to convert.
+ * @returns The lowercase string.
+ */
 export declare function stringToLowercaseFunction(input: string): string;
+/**
+ * Configuration for transforming a string.
+ * Defines operations like trimming, case conversion, or applying a custom transform function.
+ *
+ * @template S The specific string type, defaults to `string`.
+ */
 export type TransformStringFunctionConfig<S extends string = string> = {
     /**
-     * Whether or not to trim the value.
+     * If true, the string will be trimmed of leading/trailing whitespace.
+     * Trimming occurs before other transformations like case conversion or a custom `transform` function.
      */
-    trim?: boolean;
+    readonly trim?: boolean;
     /**
-     * Whether or not to store all values as lowercase. Ignored if transform is provided.
+     * If true, the string will be converted to lowercase.
+     * This is ignored if a custom `transform` function is provided.
      */
-    toLowercase?: boolean;
+    readonly toLowercase?: boolean;
     /**
-     * Whether or not to store all values as uppercase. Ignored if transform is provided.
+     * If true, the string will be converted to uppercase.
+     * This is ignored if a custom `transform` function is provided and takes precedence over `toLowercase` if both are true.
      */
-    toUppercase?: boolean;
+    readonly toUppercase?: boolean;
     /**
-     * Optional transform function for text.
+     * An optional custom function to transform the string.
+     * If provided, `toLowercase` and `toUppercase` are ignored. Trimming (if `trim` is true) occurs before this custom transform.
      */
-    transform?: TransformStringFunction<S>;
+    readonly transform?: TransformStringFunction<S>;
 };
+/**
+ * A reference object holding a `TransformStringFunctionConfig`.
+ *
+ * @template S The specific string type, defaults to `string`.
+ */
 export interface TransformStringFunctionConfigRef<S extends string = string> {
-    transform: TransformStringFunctionConfig<S>;
+    /** The string transformation configuration. */
+    readonly transform: TransformStringFunctionConfig<S>;
 }
+/**
+ * A function that maps a string of type S to another string of type S.
+ *
+ * @template S The specific string type, defaults to `string`.
+ */
 export type TransformStringFunction<S extends string = string> = MapFunction<S, S>;
+/**
+ * Input type for string transformation configuration.
+ * Can be a full `TransformStringFunctionConfig` object or a direct `TransformStringFunction`.
+ *
+ * @template S The specific string type, defaults to `string`.
+ */
 export type TransformStringFunctionConfigInput<S extends string = string> = TransformStringFunctionConfig<S> | TransformStringFunction<S>;
+/**
+ * Normalizes a `TransformStringFunctionConfigInput` into a `TransformStringFunctionConfig` object.
+ * If the input is a function, it's wrapped into a config object with that function as the `transform` property.
+ * If the input is undefined, it returns undefined.
+ *
+ * @template S The specific string type, defaults to `string`.
+ * @param config The configuration input to normalize.
+ * @returns A `TransformStringFunctionConfig` object, or `undefined` if the input config is undefined.
+ */
 export declare function transformStringFunctionConfig<S extends string = string>(config?: TransformStringFunctionConfigInput<S>): Maybe<TransformStringFunctionConfig<S>>;
+/**
+ * Creates a string transformation function based on the provided configuration.
+ * The resulting function will apply transformations in a specific order:
+ * 1. Trimming (if `config.trim` is true).
+ * 2. Custom `config.transform` function (if provided).
+ * 3. Uppercase conversion (if `config.toUppercase` is true and no `config.transform`).
+ * 4. Lowercase conversion (if `config.toLowercase` is true and no `config.transform` or `config.toUppercase`).
+ * If no transformations are specified, the identity function is returned.
+ *
+ * @template S The specific string type, defaults to `string`.
+ * @param config The `TransformStringFunctionConfig` detailing the transformations.
+ * @returns A `TransformStringFunction` that applies the configured transformations.
+ */
 export declare function transformStringFunction<S extends string = string>(config: TransformStringFunctionConfig<S>): TransformStringFunction<S>;
 export declare function addPrefix(prefix: string, input: string): string;
 /**
@@ -34,26 +98,26 @@ export declare function addPrefix(prefix: string, input: string): string;
  */
 export type AddPrefixFunction = (input: string) => string;
 /**
- * Creates an AddPrefixFunction
- *
- * @param input
- * @param replacement
- * @param is
- * @returns
+ * Creates a function that adds a configured prefix to the input string if it does not exist on that string.
+ * @param prefix The prefix to add.
+ * @returns A function that adds the prefix to a string.
  */
 export declare function addPrefixFunction(prefix: string): AddPrefixFunction;
-export declare function addSuffix(suffix: string, input: string): string;
 /**
  * Function that adds a configured suffix to the input string if it does not exist on that string.
  */
 export type AddSuffixFunction = TransformStringFunction;
 /**
- * Creates an AddSuffixFunction
- *
- * @param input
- * @param replacement
- * @param is
- * @returns
+ * Adds a suffix to a string if it does not already end with that suffix.
+ * @param suffix The suffix to add.
+ * @param input The string to modify.
+ * @returns The modified string.
+ */
+export declare function addSuffix(suffix: string, input: string): string;
+/**
+ * Creates a function that adds a configured suffix to the input string if it does not exist on that string.
+ * @param suffix The suffix to add.
+ * @returns A function that adds the suffix to a string.
  */
 export declare function addSuffixFunction(suffix: string): AddSuffixFunction;
 /**
@@ -61,9 +125,9 @@ export declare function addSuffixFunction(suffix: string): AddSuffixFunction;
  */
 export type PadStartFunction = TransformStringFunction;
 /**
- *
- * @param minLength
- * @param padCharacter
- * @returns
+ * Pads the start of a string to a minimum length.
+ * @param minLength The minimum length of the string.
+ * @param padCharacter The character to use for padding.
+ * @returns A function that pads the start of a string.
  */
 export declare function padStartFunction(minLength: number, padCharacter: string): PadStartFunction;

package/src/lib/tree/tree.array.d.ts

@@ -3,13 +3,24 @@ import { type ExpandTreeFunction } from './tree.expand';
 import { type FlattenTreeFunction } from './tree.flatten';
 /**
  * Function that expands the input values into a tree, and then flattens the tree to produce a single array of values of another type.
+ *
+ * @template T The type of the initial input values.
+ * @template V The type of the values in the final flattened output array.
+ * @param values An array of input values of type T.
+ * @returns An array of output values of type V.
  */
 export type ExpandFlattenTreeFunction<T, V> = (values: T[]) => V[];
 /**
- * Creates an ExpandFlattenTree function.
+ * Creates an ExpandFlattenTreeFunction by composing an expansion function and a flattening function.
+ *
+ * This higher-order function takes a function to expand an array of values `T` into a list of trees (`N[]` where `N` is a TreeNode)
+ * and another function to flatten these trees into a single array of values `V`.
  *
- * @param expand
- * @param flatten
- * @returns
+ * @template T The type of the initial input values.
+ * @template V The type of the values in the final flattened output array.
+ * @template N The type of the intermediate tree nodes. Must extend TreeNode with value T and children of type N.
+ * @param expand An ExpandTreeFunction (values: T[]) => N[] that converts an array of T into an array of tree nodes N.
+ * @param flatten A FlattenTreeFunction (tree: N, array?: V[]) => V[] that flattens a tree of N nodes into an array of V values.
+ * @returns An ExpandFlattenTreeFunction (values: T[]) => V[] that performs the combined expansion and flattening.
  */
 export declare function expandFlattenTreeFunction<T, V, N extends TreeNode<T, N> = TreeNode<T, any>>(expand: ExpandTreeFunction<T, N>, flatten: FlattenTreeFunction<N, V>): ExpandFlattenTreeFunction<T, V>;