@rockrms/obsidian-framework 1.16.9-rc.1 → 17.0.43

package/types/Utility/linq.d.ts

@@ -1,174 +1,381 @@
-/**
- * A function that will select a value from the object.
- */
-declare type ValueSelector<T> = (value: T) => string | number | boolean | null | undefined;
-/**
- * A function that will perform testing on a value to see if it meets
- * a certain condition and return true or false.
- */
-declare type PredicateFn<T> = (value: T, index: number) => boolean;
-/**
- * A function that will compare two values to see which one should
- * be ordered first.
- */
-declare type ValueComparer<T> = (a: T, b: T) => number;
-/**
- * Provides LINQ style access to an array of elements.
- */
-export declare class List<T> {
-    /** The elements being tracked by this list. */
-    protected elements: T[];
-    /**
-     * Creates a new list with the given elements.
-     *
-     * @param elements The elements to be made available to LINQ queries.
-     */
-    constructor(elements?: T[]);
-    /**
-     * Creates a new List from the elements without copying to a new array.
-     *
-     * @param elements The elements to initialize the list with.
-     * @returns A new list of elements.
-     */
-    static fromArrayNoCopy<T>(elements: T[]): List<T>;
-    /**
-     * Returns a boolean that determines if the collection contains any elements.
-     *
-     * @returns true if the collection contains any elements; otherwise false.
-     */
-    any(): boolean;
-    /**
-     * Filters the list by the predicate and then returns a boolean that determines
-     * if the filtered collection contains any elements.
-     *
-     * @param predicate The predicate to filter the elements by.
-     *
-     * @returns true if the collection contains any elements; otherwise false.
-     */
-    any(predicate: PredicateFn<T>): boolean;
-    /**
-     * Returns the first element from the collection if there are any elements.
-     * Otherwise will throw an exception.
-     *
-     * @returns The first element in the collection.
-     */
-    first(): T;
-    /**
-     * Filters the list by the predicate and then returns the first element
-     * in the collection if any remain. Otherwise throws an exception.
-     *
-     * @param predicate The predicate to filter the elements by.
-     *
-     * @returns The first element in the collection.
-     */
-    first(predicate: PredicateFn<T>): T;
-    /**
-     * Returns the first element found in the collection or undefined if the
-     * collection contains no elements.
-     *
-     * @returns The first element in the collection or undefined.
-     */
-    firstOrUndefined(): T | undefined;
-    /**
-     * Filters the list by the predicate and then returns the first element
-     * found in the collection. If no elements remain then undefined is
-     * returned instead.
-     *
-     * @param predicate The predicate to filter the elements by.
-     *
-     * @returns The first element in the filtered collection or undefined.
-     */
-    firstOrUndefined(predicate: PredicateFn<T>): T | undefined;
-    /**
-     * Returns a single element from the collection if there is a single
-     * element. Otherwise will throw an exception.
-     *
-     * @returns An element.
-     */
-    single(): T;
-    /**
-     * Filters the list by the predicate and then returns the single remaining
-     * element from the collection. If more than one element remains then an
-     * exception will be thrown.
-     *
-     * @param predicate The predicate to filter the elements by.
-     *
-     * @returns An element.
-     */
-    single(predicate: PredicateFn<T>): T;
-    /**
-     * Returns a single element from the collection if there is a single
-     * element. If no elements are found then undefined is returned. More
-     * than a single element will throw an exception.
-     *
-     * @returns An element or undefined.
-     */
-    singleOrUndefined(): T | undefined;
-    /**
-     * Filters the list by the predicate and then returns the single element
-     * from the collection if there is only one remaining. If no elements
-     * remain then undefined is returned. More than a single element will throw
-     * an exception.
-     *
-     * @param predicate The predicate to filter the elements by.
-     *
-     * @returns An element or undefined.
-     */
-    singleOrUndefined(predicate: PredicateFn<T>): T | undefined;
-    /**
-     * Orders the elements of the array and returns a new list of items
-     * in that order.
-     *
-     * @param keySelector The selector for the key to be ordered by.
-     * @returns A new ordered list of elements.
-     */
-    orderBy(keySelector: ValueSelector<T>): OrderedList<T>;
-    /**
-     * Orders the elements of the array in descending order and returns a
-     * new list of items in that order.
-     *
-     * @param keySelector The selector for the key to be ordered by.
-     * @returns A new ordered list of elements.
-     */
-    orderByDescending(keySelector: ValueSelector<T>): OrderedList<T>;
-    /**
-     * Filters the results and returns a new list containing only the elements
-     * that match the predicate.
-     *
-     * @param predicate The predicate to filter elements with.
-     *
-     * @returns A new collection of elements that match the predicate.
-     */
-    where(predicate: PredicateFn<T>): List<T>;
-    /**
-     * Get the elements of this list as a native array of items.
-     *
-     * @returns An array of items with all filters applied.
-     */
-    toArray(): T[];
-}
-/**
- * A list of items that has ordering already applied.
- */
-declare class OrderedList<T> extends List<T> {
-    /** The base comparer to use when ordering. */
-    private baseComparer;
-    constructor(elements: T[], baseComparer: ValueComparer<T>);
-    /**
-     * Orders the elements of the array and returns a new list of items
-     * in that order.
-     *
-     * @param keySelector The selector for the key to be ordered by.
-     * @returns A new ordered list of elements.
-     */
-    thenBy(keySelector: ValueSelector<T>): OrderedList<T>;
-    /**
-     * Orders the elements of the array in descending order and returns a
-     * new list of items in that order.
-     *
-     * @param keySelector The selector for the key to be ordered by.
-     * @returns A new ordered list of elements.
-     */
-    thenByDescending(keySelector: ValueSelector<T>): OrderedList<T>;
-}
-export {};
+/**
+ * A function that will select a value from the object.
+ */
+type ValueSelector<T> = (value: T) => string | number | boolean | null | undefined;
+/**
+ * A function that will perform testing on a value to see if it meets
+ * a certain condition and return true or false.
+ */
+type PredicateFn<T> = (value: T, index: number) => boolean;
+/**
+ * A function that will compare two values to see which one should
+ * be ordered first.
+ */
+type ValueComparer<T> = (a: T, b: T) => number;
+/**
+ * Provides LINQ style access to an array of elements.
+ */
+export declare class List<T> {
+    /** The elements being tracked by this list. */
+    protected elements: T[];
+    /**
+     * Creates a new list with the given elements.
+     *
+     * @param elements The elements to be made available to LINQ queries.
+     */
+    constructor(elements?: T[]);
+    /**
+     * Creates a new List from the elements without copying to a new array.
+     *
+     * @param elements The elements to initialize the list with.
+     * @returns A new list of elements.
+     */
+    static fromArrayNoCopy<T>(elements: T[]): List<T>;
+    /**
+     * Returns a boolean that determines if the collection contains any elements.
+     *
+     * @returns true if the collection contains any elements; otherwise false.
+     */
+    any(): boolean;
+    /**
+     * Filters the list by the predicate and then returns a boolean that determines
+     * if the filtered collection contains any elements.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns true if the collection contains any elements; otherwise false.
+     */
+    any(predicate: PredicateFn<T>): boolean;
+    /**
+     * Returns the first element from the collection if there are any elements.
+     * Otherwise will throw an exception.
+     *
+     * @returns The first element in the collection.
+     */
+    first(): T;
+    /**
+     * Filters the list by the predicate and then returns the first element
+     * in the collection if any remain. Otherwise throws an exception.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns The first element in the collection.
+     */
+    first(predicate: PredicateFn<T>): T;
+    /**
+     * Returns the first element found in the collection or undefined if the
+     * collection contains no elements.
+     *
+     * @returns The first element in the collection or undefined.
+     */
+    firstOrUndefined(): T | undefined;
+    /**
+     * Filters the list by the predicate and then returns the first element
+     * found in the collection. If no elements remain then undefined is
+     * returned instead.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns The first element in the filtered collection or undefined.
+     */
+    firstOrUndefined(predicate: PredicateFn<T>): T | undefined;
+    /**
+     * Returns the last element found in the collection or undefined if the
+     * collection contains no elements.
+     *
+     * @returns The last element in the collection or undefined.
+     */
+    lastOrUndefined(): T | undefined;
+    /**
+     * Filters the list by the predicate and then returns the last element
+     * found in the collection. If no elements remain then undefined is
+     * returned instead.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns The last element in the filtered collection or undefined.
+     */
+    lastOrUndefined(predicate: PredicateFn<T>): T | undefined;
+    /**
+     * Returns a single element from the collection if there is a single
+     * element. Otherwise will throw an exception.
+     *
+     * @returns An element.
+     */
+    single(): T;
+    /**
+     * Filters the list by the predicate and then returns the single remaining
+     * element from the collection. If more than one element remains then an
+     * exception will be thrown.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns An element.
+     */
+    single(predicate: PredicateFn<T>): T;
+    /**
+     * Returns a single element from the collection if there is a single
+     * element. If no elements are found then undefined is returned. More
+     * than a single element will throw an exception.
+     *
+     * @returns An element or undefined.
+     */
+    singleOrUndefined(): T | undefined;
+    /**
+     * Filters the list by the predicate and then returns the single element
+     * from the collection if there is only one remaining. If no elements
+     * remain then undefined is returned. More than a single element will throw
+     * an exception.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns An element or undefined.
+     */
+    singleOrUndefined(predicate: PredicateFn<T>): T | undefined;
+    /**
+     * Orders the elements of the array and returns a new list of items
+     * in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    orderBy(keySelector: ValueSelector<T>): OrderedList<T>;
+    /**
+     * Orders the elements of the array in descending order and returns a
+     * new list of items in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    orderByDescending(keySelector: ValueSelector<T>): OrderedList<T>;
+    /**
+     * Filters the results and returns a new list containing only the elements
+     * that match the predicate.
+     *
+     * @param predicate The predicate to filter elements with.
+     *
+     * @returns A new collection of elements that match the predicate.
+     */
+    where(predicate: PredicateFn<T>): List<T>;
+    /**
+     * Get the elements of this list as a native array of items.
+     *
+     * @returns An array of items with all filters applied.
+     */
+    toArray(): T[];
+}
+/**
+ * A list of items that has ordering already applied.
+ */
+declare class OrderedList<T> extends List<T> {
+    /** The base comparer to use when ordering. */
+    private baseComparer;
+    constructor(elements: T[], baseComparer: ValueComparer<T>);
+    /**
+     * Orders the elements of the array and returns a new list of items
+     * in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    thenBy(keySelector: ValueSelector<T>): OrderedList<T>;
+    /**
+     * Orders the elements of the array in descending order and returns a
+     * new list of items in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    thenByDescending(keySelector: ValueSelector<T>): OrderedList<T>;
+}
+/**
+ * A utility class for working with iterables in a LINQ-like manner.
+ */
+export declare class Enumerable<T> {
+    protected iterableFactory: () => Iterable<T>;
+    /**
+     * Creates an instance of Enumerable using a factory for the iterable.
+     * @param iterableFactory - A factory function that produces an iterable.
+     */
+    constructor(iterableFactory: () => Iterable<T>);
+    /**
+     * Creates an Enumerable from a regular iterable (e.g., Array, Set).
+     * @param iterable - An iterable to create the Enumerable from.
+     * @returns A new Enumerable instance.
+     */
+    static from<T>(iterable: Iterable<T>): Enumerable<T>;
+    /**
+     * Creates an Enumerable from a generator function.
+     * @param generator - A function that produces an IterableIterator.
+     * @returns A new Enumerable instance.
+     */
+    static from<T>(generator: () => IterableIterator<T>): Enumerable<T>;
+    /**
+     * Returns an iterator for the current Enumerable.
+     * @returns An iterator for the iterable.
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Filters the sequence to include only elements that satisfy the predicate.
+     * @param predicate - A function to test each element for a condition.
+     * @returns A new Enumerable containing the filtered elements.
+     */
+    where(predicate: (item: T) => boolean): Enumerable<T>;
+    /**
+     * Projects each element of the sequence into a new form.
+     * @param selector - A function to project each element into a new form.
+     * @returns A new Enumerable with the projected elements.
+     */
+    select<U>(selector: (item: T) => U): Enumerable<U>;
+    /**
+     * Returns a new Enumerable that skips the first `count` elements of the sequence.
+     * @param count - The number of elements to skip.
+     * @returns A new Enumerable that skips the specified number of elements.
+     */
+    skip(count: number): Enumerable<T>;
+    /**
+     * Returns a new Enumerable that contains the first `count` elements of the sequence.
+     * @param count - The number of elements to take.
+     * @returns A new Enumerable containing the taken elements.
+     */
+    take(count: number): Enumerable<T>;
+    /**
+     * Returns the first element of the sequence or a default value if the sequence is empty.
+     * @param defaultValue - The default value to return if the sequence is empty.
+     * @returns The first element of the sequence or the default value.
+     */
+    firstOrDefault(defaultValue?: T): T | undefined;
+    /**
+     * Returns the last element of the sequence, or a default value if the sequence is empty.
+     * @param defaultValue - The default value to return if the sequence is empty.
+     * @returns The last element of the sequence, or the provided default value.
+     *
+     * @example
+     * const numbers = Enumerable.from([1, 2, 3]);
+     * console.log(numbers.lastOrDefault()); // Outputs: 3
+     *
+     * @example
+     * const empty = Enumerable.from<number>([]);
+     * console.log(empty.lastOrDefault(0)); // Outputs: 0
+     */
+    lastOrDefault(defaultValue?: T): T | undefined;
+    /**
+     * Aggregates the elements of the sequence using a specified accumulator function and seed value.
+     * @param accumulator - A function that accumulates each element.
+     * @param seed - The initial value for the accumulation.
+     * @returns The aggregated value.
+     */
+    aggregate<U>(accumulator: (acc: U, item: T, index: number) => U, seed: U): U;
+    /**
+     * Determines whether any elements in the sequence satisfy a condition or if the sequence contains any elements.
+     * @param predicate - An optional function to test each element for a condition.
+     * @returns `true` if any elements satisfy the condition; otherwise, `false`.
+     */
+    any(predicate?: (item: T) => boolean): boolean;
+    /**
+     * Determines whether all elements in the sequence satisfy a condition or if the sequence contains any elements.
+     * @param predicate - An optional function to test each element for a condition.
+     * @returns `true` if all elements satisfy the condition; otherwise, `false`.
+     */
+    all(predicate: (item: T) => boolean): boolean;
+    /**
+     * Executes a specified action for each element in the sequence.
+     * @param action - A function to execute for each element.
+     */
+    forEach(action: (item: T) => void): void;
+    /**
+     * Converts the sequence into an array.
+     * @returns An array containing all elements in the sequence.
+     */
+    toArray(): T[];
+    /**
+     * Converts the sequence into a List.
+     * @returns An List containing all elements in the sequence.
+     */
+    toList(): List<T>;
+    /**
+     * Sorts the elements of the sequence in ascending order.
+     * @param keySelector - Function to extract the key for comparison.
+     * @param comparer - Optional comparison function for the keys.
+     * @returns An OrderedEnumerable sorted in ascending order.
+     */
+    orderBy<U>(keySelector: (item: T) => U, comparer?: (a: U, b: U) => number): OrderedEnumerable<T>;
+    /**
+     * Sorts the elements of the sequence in descending order.
+     * @param keySelector - Function to extract the key for comparison.
+     * @param comparer - Optional comparison function for the keys.
+     * @returns An OrderedEnumerable sorted in descending order.
+     */
+    orderByDescending<U>(keySelector: (item: T) => U, comparer?: (a: U, b: U) => number): OrderedEnumerable<T>;
+    /**
+     * Returns a generator that yields each element of the sequence paired with its index.
+     *
+     * @generator
+     * @yields {[T, number]} A tuple containing the element and its zero-based index.
+     *
+     * @example
+     * // Example usage with a for...of loop:
+     * const elements = Enumerable.from(['a', 'b', 'c']);
+     * for (const [item, index] of elements.withIndex()) {
+     *     console.log(`Index: ${index}, Item: ${item}`);
+     * }
+     * // Output:
+     * // Index: 0, Item: a
+     * // Index: 1, Item: b
+     * // Index: 2, Item: c
+     *
+     * @example
+     * // Example usage with chaining:
+     * const indexed = Enumerable.from(['x', 'y', 'z'])
+     *     .withIndex()
+     *     .where(([item, index]) => index % 2 === 0)
+     *     .toArray();
+     * console.log(indexed);
+     * // Output: [['x', 0], ['z', 2]]
+     */
+    withIndex(): IterableIterator<[T, number]>;
+    /**
+ * Filters the sequence and returns only elements of the specified type.
+ * @template U The target type to filter by.
+ * @param typeCheck - A runtime check function to validate the type of each element.
+ * @returns A new Enumerable containing elements of type `U`.
+ *
+ * @example
+ * const mixed: Enumerable<unknown> = Enumerable.from([1, "hello", true, 42]);
+ * const numbers = mixed.ofType<number>(item => typeof item === "number");
+ * console.log(numbers.toArray()); // Outputs: [1, 42]
+ *
+ * @example
+ * class Animal {}
+ * class Dog extends Animal {}
+ * const animals: Enumerable<Animal> = Enumerable.from([new Animal(), new Dog()]);
+ * const dogs = animals.ofType<Dog>(item => item instanceof Dog);
+ * console.log(dogs.toArray()); // Outputs: [Dog instance]
+ */
+    ofType<U extends T>(typeCheck: (item: T) => item is U): Enumerable<U>;
+}
+declare class OrderedEnumerable<T> extends Enumerable<T> {
+    private readonly sortComparers;
+    constructor(iterableFactory: () => Iterable<T>, initialComparer: (a: T, b: T) => number);
+    /**
+     * Adds a secondary ascending order comparison to the current sort.
+     * @param keySelector - Function to extract the key for comparison.
+     * @param comparer - Optional comparison function for the keys.
+     * @returns A new OrderedEnumerable with the additional ordering.
+     */
+    thenOrderBy<U>(keySelector: (item: T) => U, comparer?: (a: U, b: U) => number): OrderedEnumerable<T>;
+    /**
+     * Adds a secondary descending order comparison to the current sort.
+     * @param keySelector - Function to extract the key for comparison.
+     * @param comparer - Optional comparison function for the keys.
+     * @returns A new OrderedEnumerable with the additional ordering.
+     */
+    thenOrderByDescending<U>(keySelector: (item: T) => U, comparer?: (a: U, b: U) => number): OrderedEnumerable<T>;
+    toArray(): T[];
+    /**
+     * Sorts the sequence based on the defined comparers.
+     * @returns A new Iterable with elements sorted.
+     */
+    [Symbol.iterator](): Iterator<T>;
+}
+export {};

package/types/Utility/listItemBag.d.ts

@@ -1,2 +1,2 @@
-import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
-export declare function asListItemBagOrNull(bagJson: string): ListItemBag | null;
+import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+export declare function asListItemBagOrNull(bagJson: string): ListItemBag | null;

package/types/Utility/localeDateFormatter.d.ts

@@ -1,52 +1,52 @@
-/**
- * A helper object that provides equivalent format strings for a given locale,
- * for the various date libraries used throughout Rock.
- *
- * This API is internal to Rock, and is not subject to the same compatibility
- * standards as public APIs. It may be changed or removed without notice in any
- * release. You should not use this API directly in any plug-ins. Doing so can
- * result in application failures when updating to a new Rock release.
- */
-export declare class LocaleDateFormatter {
-    /**
-     * The internal JavaScript date format string for the locale represented
-     * by this formatter instance.
-     */
-    private jsDateFormatString;
-    /**
-     * The internal ASP C# date format string for the locale represented by this
-     * formatter instance.
-     */
-    private aspDateFormatString;
-    /**
-     * The internal date picker format string for the locale represented by this
-     * formatter instance.
-     */
-    private datePickerFormatString;
-    /**
-     * Creates a new instance of LocaleDateFormatter.
-     *
-     * @param jsDateFormatString The JavaScript date format string for the
-     * locale represented by this formatter instance.
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#date_time_string_format
-     */
-    private constructor();
-    /**
-     * Creates a new instance of LocaleDateFormatter from the current locale. If
-     * the current locale cannot be determined, a default "en-US" locale
-     * formatter instance will be returned.
-     *
-     * @returns A LocaleDateFormatter instance representing the current locale.
-     */
-    static fromCurrent(): LocaleDateFormatter;
-    /**
-     * The ASP C# date format string for the locale represented by this
-     * formatter instance.
-     */
-    get aspDateFormat(): string;
-    /**
-     * The date picker format string for the locale represented by this
-     * formatter instance.
-     */
-    get datePickerFormat(): string;
-}
+/**
+ * A helper object that provides equivalent format strings for a given locale,
+ * for the various date libraries used throughout Rock.
+ *
+ * This API is internal to Rock, and is not subject to the same compatibility
+ * standards as public APIs. It may be changed or removed without notice in any
+ * release. You should not use this API directly in any plug-ins. Doing so can
+ * result in application failures when updating to a new Rock release.
+ */
+export declare class LocaleDateFormatter {
+    /**
+     * The internal JavaScript date format string for the locale represented
+     * by this formatter instance.
+     */
+    private jsDateFormatString;
+    /**
+     * The internal ASP C# date format string for the locale represented by this
+     * formatter instance.
+     */
+    private aspDateFormatString;
+    /**
+     * The internal date picker format string for the locale represented by this
+     * formatter instance.
+     */
+    private datePickerFormatString;
+    /**
+     * Creates a new instance of LocaleDateFormatter.
+     *
+     * @param jsDateFormatString The JavaScript date format string for the
+     * locale represented by this formatter instance.
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#date_time_string_format
+     */
+    private constructor();
+    /**
+     * Creates a new instance of LocaleDateFormatter from the current locale. If
+     * the current locale cannot be determined, a default "en-US" locale
+     * formatter instance will be returned.
+     *
+     * @returns A LocaleDateFormatter instance representing the current locale.
+     */
+    static fromCurrent(): LocaleDateFormatter;
+    /**
+     * The ASP C# date format string for the locale represented by this
+     * formatter instance.
+     */
+    get aspDateFormat(): string;
+    /**
+     * The date picker format string for the locale represented by this
+     * formatter instance.
+     */
+    get datePickerFormat(): string;
+}