@3dsource/utils 1.0.19 → 1.0.21

package/lib/math/circularIndex.d.ts

@@ -1,35 +0,0 @@
-/**
- * Computes a circular index within a given range.
- *
- * This function ensures that the index wraps around within the range of 0 to `totalItems - 1`.
- * It uses the `clampf` function to clamp the result within the valid range.
- *
- * @param index - The current index to be wrapped.
- * @param totalItems - The total number of items in the range.
- * @returns The wrapped index within the range of 0 to `totalItems - 1`.
- *
- * @example
- * ```typescript
- * import { circularIndex } from './circularIndex';
- *
- * // Example 1: Basic usage
- * const index1 = circularIndex(5, 5);
- * console.log(index1); // Output: 0
- *
- * // Example 2: Index greater than totalItems
- * const index2 = circularIndex(6, 5);
- * console.log(index2); // Output: 1
- *
- * // Example 3: Negative index
- * const index3 = circularIndex(-2, 5);
- * console.log(index3); // Output: 3
- *
- * // Example 4: Large Negative index
- * const index4 = circularIndex(-6, 5);
- * console.log(index4); // Output: 4
- *
- * // Example 5: Index equal to totalItems
- * const index5 = circularIndex(1, 1);
- * console.log(index5); // Output: 0
- */
-export declare function circularIndex(index: number, totalItems: number): number;

package/lib/math/clampf.d.ts

@@ -1,8 +0,0 @@
-/**
- * Clamps value between min and max;
- * @param min minValue
- * @param max maxValue
- * @param value inputValue
- * @returns number
- */
-export declare function clampf(min: number, max: number, value: number): number;

package/lib/math/degrees.d.ts

@@ -1,2 +0,0 @@
-export declare function degreesToRadians(degrees: number): number;
-export declare function radiansToDegrees(radians: number): number;

package/lib/math/floatCompare.d.ts

@@ -1,42 +0,0 @@
-/**
- * Checks if floating-point number `A` is less than `B` considering a small margin of error.
- *
- * @param A - The first floating-point number to compare.
- * @param B - The second floating-point number to compare.
- * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
- * @returns `true` if `A` is less than `B` considering the epsilon margin, otherwise `false`.
- *
- * @example
- * ```
- * const result = fpIsALessThanB(0.0034, 0.0066); // true
- * ```
- */
-export declare function fpIsALessThanB(A: number, B: number, Epsilon?: number): boolean;
-/**
- * Checks if floating-point number `A` is greater than `B` considering a small margin of error.
- *
- * @param A - The first floating-point number to compare.
- * @param B - The second floating-point number to compare.
- * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
- * @returns `true` if `A` is greater than `B` considering the epsilon margin, otherwise `false`.
- *
- * @example
- * ```
- * const result = fpIsAGreaterThanB(0.0066, 0.0034); // true
- * ```
- */
-export declare function fpIsAGreaterThanB(A: number, B: number, Epsilon?: number): boolean;
-/**
- * Checks if floating-point number `A` is approximately the same as `B` considering a small margin of error.
- *
- * @param A - The first floating-point number to compare.
- * @param B - The second floating-point number to compare.
- * @param Epsilon - Optional custom epsilon value for comparison. Defaults to `EPSILON` if not provided.
- * @returns `true` if `A` is approximately equal to `B` considering the epsilon margin, otherwise `false`.
- *
- * @example
- * ```
- * const result = fpIsASameAsB(0.005, 0.0051); // true
- * ```
- */
-export declare function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean;

package/lib/math/index.d.ts

@@ -1,8 +0,0 @@
-export * from './baseSortedIndex';
-export * from './calculateMedian';
-export * from './circularIndex';
-export * from './clampf';
-export * from './degrees';
-export * from './floatCompare';
-export * from './inverseLerp';
-export * from './lerp';

package/lib/math/inverseLerp.d.ts

@@ -1,17 +0,0 @@
-/**
- * Performs an inverse linear interpolation.
- *
- * Given a range defined by `min` and `max`, this function calculates the
- * interpolation factor (or percentage) of `value` within that range. Optionally,
- * it can clamp the result to be between 0 and 1 to ensure the return value is
- * within the range of a standard lerp operation.
- *
- * @param {number} min - The minimum value of the interpolation range.
- * @param {number} max - The maximum value of the interpolation range.
- * @param {number} value - The value to interpolate.
- * @param {boolean} [clampToNormal=false] - Whether to clamp the result between 0 and 1.
- * @returns {number} The interpolation factor of `value` between `min` and `max`.
- * If `clampToNormal` is true, the result is clamped between 0 and 1.
- * If the difference between `min` and `max` is 0, returns 1 to avoid division by zero.
- */
-export declare function inverseLerp(min: number, max: number, value: number, clampToNormal?: boolean): number;

package/lib/math/lerp.d.ts

@@ -1,7 +0,0 @@
-/**
- * @param min minimums
- * @param max maximums
- * @param value current float value in 0-1 range
- * @returns clamped value
- */
-export declare function lerp(min: number, max: number, value: number): number;

package/lib/mutex/Mutex.d.ts

@@ -1,43 +0,0 @@
-/**
- * A Mutex class to handle mutual exclusion locks, ensuring that only one asynchronous task can execute a critical section at a time.
- *
- * @example
- * const mutex = new Mutex();
- *
- * async function task(name: string, duration: number) {
- *   console.log(`${name} waiting to acquire mutex`);
- *   const release = await mutex.acquire();
- *   console.log(`${name} acquired mutex`);
- *   await new Promise(resolve => setTimeout(resolve, duration));
- *   console.log(`${name} releasing mutex`);
- *   release();
- * }
- *
- * task('Task 1', 1000);
- * task('Task 2', 2000);
- * task('Task 3', 1500);
- * task('Task 4', 500);
- *
- * Outputs
- * [LOG]: "Task 1 waiting to acquire mutex"
- * [LOG]: "Task 2 waiting to acquire mutex"
- * [LOG]: "Task 3 waiting to acquire mutex"
- * [LOG]: "Task 4 waiting to acquire mutex"
- * [LOG]: "Task 1 acquired mutex"
- * [LOG]: "Task 1 releasing mutex"
- * [LOG]: "Task 2 acquired mutex"
- * [LOG]: "Task 2 releasing mutex"
- * [LOG]: "Task 3 acquired mutex"
- * [LOG]: "Task 3 releasing mutex"
- * [LOG]: "Task 4 acquired mutex"
- * [LOG]: "Task 4 releasing mutex"
- */
-export declare class Mutex {
-    private mutex;
-    /**
-     * Acquires the mutex, returning a promise that resolves when the mutex is acquired.
-     * The returned promise provides a release function that should be called to release the mutex.
-     * @returns A promise that resolves with a release function.
-     */
-    acquire(): Promise<() => void>;
-}

package/lib/mutex/Semaphore.d.ts

@@ -1,42 +0,0 @@
-/**
- * A Semaphore controls access to a resource that can handle a limited number of concurrent operations.
- *
- * @example
- * const semaphore = new Semaphore(2);
- *
- * async function task(name: string, duration: number) {
- *   console.log(`${name} waiting to acquire semaphore`);
- *   await semaphore.acquire();
- *   console.log(`${name} acquired semaphore`);
- *   await new Promise(resolve => setTimeout(resolve, duration));
- *   console.log(`${name} releasing semaphore`);
- *   semaphore.release();
- * }
- *
- * task('Task 1', 1000);
- * task('Task 2', 2000);
- * task('Task 3', 1500);
- * task('Task 4', 500);
- *
- * Outputs
- * [LOG]: "Task 1 waiting to acquire semaphore"
- * [LOG]: "Task 2 waiting to acquire semaphore"
- * [LOG]: "Task 3 waiting to acquire semaphore"
- * [LOG]: "Task 4 waiting to acquire semaphore"
- * [LOG]: "Task 1 acquired semaphore"
- * [LOG]: "Task 2 acquired semaphore"
- * [LOG]: "Task 1 releasing semaphore"
- * [LOG]: "Task 3 acquired semaphore"
- * [LOG]: "Task 2 releasing semaphore"
- * [LOG]: "Task 4 acquired semaphore"
- * [LOG]: "Task 4 releasing semaphore"
- * [LOG]: "Task 3 releasing semaphore"
- */
-export declare class Semaphore {
-    private readonly maxConcurrency;
-    private tasks;
-    private currentCount;
-    constructor(maxConcurrency: number);
-    acquire(): Promise<void>;
-    release(): void;
-}

package/lib/mutex/TaskRunner.d.ts

@@ -1,5 +0,0 @@
-import type { Observable } from 'rxjs';
-export declare class TaskRunner {
-    private mutex;
-    runTask(name: string, task: () => Observable<string | null>): Observable<string | null>;
-}

package/lib/mutex/index.d.ts

@@ -1,3 +0,0 @@
-export * from './Mutex';
-export * from './Semaphore';
-export * from './TaskRunner';

package/lib/predicates/index.d.ts

@@ -1,3 +0,0 @@
-export * from './operators';
-export * from './textForSearch';
-export * from './where';

package/lib/predicates/operators.d.ts

@@ -1,32 +0,0 @@
-type TruthyTypesOf<T> = T extends false | '' | 0 | null | undefined ? never : T;
-type FalsyTypesOf<T> = T extends false | '' | 0 | null | undefined ? T : never;
-type EmptyTypesOf<T> = T extends undefined | null | object | '' ? T : never;
-type NonEmptyTypesOf<T> = T extends undefined | null | object | '' ? never : T;
-/**
- * The Boolean object represents a truth value: true or false.
- * @param value
- * @constructor
- * Returns:boolean
- */
-export declare const Truthy: <T>(value: T) => value is TruthyTypesOf<T>;
-/**
- * The Boolean object represents an INVERSE truth value: true or false.
- * @param value
- * @constructor
- * Returns:boolean
- */
-export declare const Falsy: <T>(value: T) => value is FalsyTypesOf<T>;
-/**
- * Checks if a value is empty.
- *
- * @param {any} value - The value to check.
- * @return {boolean} Returns true if the value is empty, otherwise false.
- */
-export declare const IsEmpty: <T>(value: T) => value is EmptyTypesOf<T>;
-export declare const NotEmpty: <T>(value: T) => value is NonEmptyTypesOf<T>;
-export declare const isDefined: <T>(arg: T | null | undefined) => arg is T;
-export declare const isNotDefined: <T>(arg: T | null | undefined) => arg is null | undefined;
-export declare const isJSON: (str: string) => boolean;
-export declare const isEmpty: (value: any) => boolean;
-export declare function isAllValuesTruthy<T extends string, K>(value: Record<T, K>): boolean;
-export {};

package/lib/predicates/textForSearch.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a given value to a string suitable for search comparisons.
- * The resulting string is in lowercase, with consecutive spaces replaced by underscores.
- * The function uses a cache to improve performance by storing and reusing the results of previous conversions.
- *
- * @param {any} value - The value to be converted to a search-friendly string.
- * It can be of any type, but it will be coerced to a string if not already one.
- *
- * @param {boolean} caseSensitive - A flag indicating whether the comparison should be case-sensitive.
- * If set to true, the function will perform case-sensitive comparisons, preserving the original casing of input strings.
- * If set to false (default), the function will convert the input strings to lowercase for case-insensitive comparisons
- *
- * @returns {string} The processed string, which is trimmed, converted to lowercase (unless caseSensitive is true),
- * and has all sequences of spaces replaced with underscores. This string is either
- * retrieved from the cache or freshly computed and then cached.
- *
- */
-export declare function textForSearch(value: unknown, caseSensitive?: boolean): string;

package/lib/predicates/where.d.ts

@@ -1,46 +0,0 @@
-import type { TruthyTypesOf } from 'rxjs';
-/**
- * Creates a predicate function to filter records from a collection based on specified criteria.
- *
- * The `where` function accepts a criteria object with key-value pairs, indicating the fields
- * and their expected values for filtering. It returns a predicate function that filters a collection
- * of records. This predicate checks if records match the criteria using a case-insensitive comparison,
- * making it particularly useful in conjunction with the `textForSearch` function, which standardizes
- * strings for such comparisons.
- *
- * Each criterion value is first processed with `textForSearch` to normalize spacing and case,
- * ensuring consistent and predictable filtering. The comparison between each record's field value
- * and the criterion value is thus case-insensitive and ignores extra spaces.
- *
- * @param {Partial<Record<K, T[K]>>} criteria - An object representing the filtering criteria.
- * Keys correspond to the record's fields to be filtered, and values are the expected values for those fields,
- * processed in a case-insensitive manner. Undefined values are ignored.
- *
- * @param {boolean} caseSensitive - A flag indicating whether the comparison should be case-sensitive.
- * If set to true, the function will perform case-sensitive comparisons, preserving the original casing of input strings.
- * If set to false (default), the function will convert the input strings to lowercase for case-insensitive comparisons
- *
- * @returns {(record: T) => boolean} A predicate function that takes a record of type `T`
- * and returns `true` if the record's field values match all criteria, otherwise `false`.
- *
- * @example
- * // Define a collection of items
- * const items = [
- *   { name: "Apple", category: "Fruit" },
- *   { name: "Carrot", category: "Vegetable" },
- *   { name: "Banana", category: "Fruit" }
- * ];
- *
- * // Create a predicate to find fruits, using a case-insensitive comparison
- * const isFruit = where({ category: "fruit" }); // 'fruit' will match 'Fruit' in items
- *
- * // Filter the collection with the predicate
- * const fruits = items.filter(isFruit);
- * // Output: [{ name: "Apple", category: "Fruit" }, { name: "Banana", category: "Fruit" }]
- *
- * @typeparam T - Specifies the type of records in the collection to be filtered. It extends `object`,
- * ensuring the function is only used with object types. This generic approach allows for flexible usage
- * with various record structures.
- */
-export declare function where<T extends object>(criteria: Partial<TruthyTypesOf<T>>, caseSensitive?: boolean): (record: T) => boolean;
-export declare function whereNot<T extends object>(criteria: Partial<TruthyTypesOf<T>>, caseSensitive?: boolean): (record: T) => boolean;

package/lib/rxjs/index.d.ts

@@ -1,3 +0,0 @@
-export * from './leadingTrailingDebounceTime';
-export * from './smoothTransition';
-export * from './tapLog';

package/lib/rxjs/leadingTrailingDebounceTime.d.ts

@@ -1,15 +0,0 @@
-import type { SchedulerLike } from 'rxjs';
-import { Observable } from 'rxjs';
-/**
- * Emits the most recent value emitted by the source Observable after a
- * specified time span has passed without another source emission.
- *
- * This is a combination of `debounceTime` and `auditTime` operators.
- *
- * The leading value is emitted immediately, and trailing values are debounced.
- *
- * @param dueTime The time to wait before emitting the last value.
- * @param scheduler The scheduler to use for the timeout.
- * @returns A function that returns an Observable that mirrors the source Observable, but applies the specified debouncing.
- */
-export declare function leadingTrailingDebounceTime<T>(dueTime: number, scheduler?: SchedulerLike): (source: Observable<T>) => Observable<T>;

package/lib/rxjs/smoothTransition.d.ts

@@ -1,11 +0,0 @@
-import type { Observable } from 'rxjs';
-/**
- * Creates an observable that emits values transitioning smoothly from the start value to the end value over a specified duration.
- * The transition is performed using linear interpolation (lerp) and clamped to the range [0, 1].
- *
- * @param {number} start - The starting value of the transition.
- * @param {number} end - The ending value of the transition.
- * @param {number} duration - The duration of the transition in milliseconds.
- * @returns {Observable<number>} An observable that emits the interpolated values from start to end over the specified duration.
- */
-export declare const smoothTransition: (start: number, end: number, duration: number) => Observable<number>;

package/lib/rxjs/tapLog.d.ts

@@ -1,2 +0,0 @@
-import type { Observable } from 'rxjs';
-export declare const tapLog: <T>(text: string, ...args: any) => ((source: Observable<T>) => Observable<T>);

package/lib/strings/index.d.ts

@@ -1 +0,0 @@
-export * from './pad';

package/lib/strings/pad.d.ts

@@ -1,8 +0,0 @@
-/**
- * Adds required number of symbols before input
- * @param input input string
- * @param size amount of total symbols
- * @param symbol filler
- * @returns string
- */
-export declare function pad(input: number | string, size: number, symbol?: string): string;

package/lib/tokens/index.d.ts

@@ -1,3 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export declare const WINDOW: InjectionToken<Window>;
-export declare const DOCUMENT_ROOT: InjectionToken<string>;

package/public-api.d.ts

@@ -1,15 +0,0 @@
-export * from './lib/color';
-export * from './lib/constants';
-export * from './lib/csv';
-export * from './lib/dev';
-export * from './lib/filenaming';
-export * from './lib/geom';
-export * from './lib/helpers';
-export * from './lib/image';
-export * from './lib/interfaces';
-export * from './lib/math';
-export * from './lib/mutex';
-export * from './lib/predicates';
-export * from './lib/rxjs';
-export * from './lib/strings';
-export * from './lib/tokens';