@rpack-dev/core 0.1.10 → 0.1.11-dev-a14d131

package/dist/rpack-core.d.ts

@@ -79,6 +79,91 @@ export declare abstract class RPackThread {
 	abstract disable(): Promise<void>;
 	abstract terminate(): Promise<void>;
 }
+export declare class ArrayUtils {
+	private static readonly NATURAL_COLLATOR;
+	private constructor();
+	/**
+	 * Performs a binary search on the specified ordered array for the specified element.
+	 * If the object is found within the array, the index of the element is returned.
+	 *
+	 * Let x be the position at which the element should be placed in the array.
+	 * If the object is not found within the array, this method will return -(x + 1).
+	 * @param array the ordered array to search
+	 * @param element the element to search for
+	 * @param compareFunction the function to use for comparing elements
+	 * @returns the index of the element, or the insertion index
+	 */
+	static binarySearch<T>(array: Array<T>, element: T, compareFunction: (a: T, b: T) => number): number;
+	/**
+	 * Performs a binary search on the specified ordered array for the specified element.
+	 * The element being searched is a property of an element in the array.
+	 * If the object is found within the array, the index of the element is returned.
+	 *
+	 * Let x be the position at which the element should be placed in the array.
+	 * If the object is not found within the array, this method will return -(x + 1).
+	 * @param array the ordered array to search
+	 * @param element the element to search for
+	 * @param compareFunction the function to use for comparing elements
+	 * @param convertFunction the function to use to convert an array element to the searched type
+	 * @returns the index of the element, or the insertion index
+	 */
+	static binarySearch2<T, K>(array: Array<T>, element: K, convertFunction: (element: T) => K, compareFunction: (a: K, b: K) => number): number;
+	/**
+	 * Compares two arrays and returns the differences between them as added and removed elements.
+	 *
+	 * This method is O(n * m) where n is the length of newArray and m is the length of oldArray
+	 *
+	 * @param oldArray The old array to compare against
+	 * @param newArray The new array to compare
+	 * @param equality Optional function to determine equality between elements.
+	 *                Default compares elements using == operator
+	 * @returns An object containing two arrays:
+	 *          - added: elements present in newArray but not in oldArray
+	 *          - removed: elements present in oldArray but not in newArray
+	 */
+	static diff<T>(oldArray: T[], newArray: T[], equality?: (a: T, b: T) => boolean): {
+		added: T[];
+		removed: T[];
+	};
+	/**
+	 * Converts an AsyncIterableIterator into an array by collecting all emitted values.
+	 *
+	 * @param it The AsyncIterableIterator whose values should be collected into an array.
+	 * @return A promise that resolves to an array containing all items from the given AsyncIterableIterator.
+	 * @template T the type of the iterator
+	 */
+	static fromAsync<T>(it: AsyncIterableIterator<T>): Promise<T[]>;
+	/**
+	 * Asynchronously sorts an array with a merge sort algorithm, using an async comparator.
+	 * This method is useful when comparison of elements requires asynchronous operations.
+	 * After the Promise returned by this method resolves, the original array will be sorted.
+	 * This same array will be used to resolve the Promise.
+	 *
+	 * @param array the array to be sorted
+	 * @param comparator an async function that compares two elements and returns a Promise
+	 * that resolves to a number (negative if a < b, zero if a = b, positive if a > b)
+	 * @returns a Promise that resolves to the sorted array
+	 */
+	static asyncSort<T>(array: T[], comparator: (a: T, b: T) => Promise<number>): Promise<T[]>;
+	/**
+	 * Returns a comparator function using natural sorting
+	 * for the specified type, using the specified string
+	 * extractor function.
+	 * @param func string extractor function
+	 * @template T the original type
+	 * @returns the comparator function
+	 */
+	static naturalComparator<T>(func?: (element: T) => string): (a: T, b: T) => number;
+	/**
+	 * Sorts the array of type T `array` naturally, with
+	 * the string extractor function `func`.
+	 * @param array the array to sort
+	 * @param func the string extractor function
+	 * @returns the same array
+	 * @template T the original type
+	 */
+	static naturalSort<T>(array: T[], func?: (element: T) => string): T[];
+}
 export declare class AsyncIterableIteratorMirror<T, E> implements AsyncIterableIterator<T> {
 	private readonly it;
 	private readonly converter;
@@ -544,7 +629,7 @@ export declare class StringUtils {
  * A collection of some utilities.
  */
 export declare class Utils {
-	private static readonly NATURAL_COLLATOR;
+	private constructor();
 	/**
 	 * Returns the contents of the specified url.
 	 *
@@ -558,85 +643,12 @@ export declare class Utils {
 	 * @param progressConsumer a callback containing
 	 */
 	static getLargeFile(url: string, fetchOptions: RequestInit, progressConsumer: (read: number, length: number) => void): Promise<ArrayBuffer | undefined>;
-	/**
-	 * Performs a binary search on the specified ordered array for the specified element.
-	 * If the object is found within the array, the index of the element is returned.
-	 *
-	 * Let x be the position at which the element should be placed in the array.
-	 * If the object is not found within the array, this method will return -(x + 1).
-	 * @param array the ordered array to search
-	 * @param element the element to search for
-	 * @param compareFunction the function to use for comparing elements
-	 * @returns the index of the element, or the insertion index
-	 */
-	static binarySearch<T>(array: Array<T>, element: T, compareFunction: (a: T, b: T) => number): number;
-	/**
-	 * Performs a binary search on the specified ordered array for the specified element.
-	 * The element being searched is a property of an element in the array.
-	 * If the object is found within the array, the index of the element is returned.
-	 *
-	 * Let x be the position at which the element should be placed in the array.
-	 * If the object is not found within the array, this method will return -(x + 1).
-	 * @param array the ordered array to search
-	 * @param element the element to search for
-	 * @param compareFunction the function to use for comparing elements
-	 * @param convertFunction the function to use to convert an array element to the searched type
-	 * @returns the index of the element, or the insertion index
-	 */
-	static binarySearch2<T, K>(array: Array<T>, element: K, convertFunction: (element: T) => K, compareFunction: (a: K, b: K) => number): number;
 	/**
 	 * Loads the image at the specified source URL in an asynchronous way.
 	 * @param src the URL to load the image from
 	 * @returns a Future which will complete with an Image object
 	 */
 	static loadImageAsync(src: string): Promise<HTMLImageElement>;
-	/**
-	 * Returns a comparator function using natural sorting
-	 * for the specified type, using the specified string
-	 * extractor function.
-	 * @param func string extractor function
-	 * @template T the original type
-	 * @returns the comparator function
-	 */
-	static naturalComparator<T>(func?: (element: T) => string): (a: T, b: T) => number;
-	/**
-	 * Sorts the array of type T `array` naturally, with
-	 * the string extractor function `func`.
-	 * @param array the array to sort
-	 * @param func the string extractor function
-	 * @returns the same array
-	 * @template T the original type
-	 */
-	static naturalSort<T>(array: T[], func?: (element: T) => string): T[];
-	/**
-	 * Asynchronously sorts an array with a merge sort algorithm, using an async comparator.
-	 * This method is useful when comparison of elements requires asynchronous operations.
-	 * After the Promise returned by this method resolves, the original array will be sorted.
-	 * This same array will be used to resolve the Promise.
-	 *
-	 * @param array the array to be sorted
-	 * @param comparator an async function that compares two elements and returns a Promise
-	 * that resolves to a number (negative if a < b, zero if a = b, positive if a > b)
-	 * @returns a Promise that resolves to the sorted array
-	 */
-	static asyncSort<T>(array: T[], comparator: (a: T, b: T) => Promise<number>): Promise<T[]>;
-	/**
-	 * Compares two arrays and returns the differences between them as added and removed elements.
-	 *
-	 * This method is O(n * m) where n is the length of newArray and m is the length of oldArray
-	 *
-	 * @param newArray The new array to compare
-	 * @param oldArray The old array to compare against
-	 * @param equality Optional function to determine equality between elements.
-	 *                Default compares elements using == operator
-	 * @returns An object containing two arrays:
-	 *          - added: elements present in newArray but not in oldArray
-	 *          - removed: elements present in oldArray but not in newArray
-	 */
-	static diff<T>(newArray: T[], oldArray: T[], equality?: (a: T, b: T) => boolean): {
-		added: T[];
-		removed: T[];
-	};
 	static tableString<T, N extends number>(elements: T[], func: (element: T) => FixedLengthArray<string, N>, options?: TableOptions<N>): string;
 	/**
 	 * Returns an array of string keys from an enum class.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpack-dev/core",
-  "version": "0.1.10",
+  "version": "0.1.11-dev-a14d131",
   "description": "",
   "license": "LGPL-3.0-or-later",
   "repository": {