@3dsource/utils 1.0.4 → 1.0.5

package/lib/helpers/KeyboardNumericCode.d.ts

@@ -0,0 +1,103 @@
+declare const KeyboardNumericCode: {
+    readonly Backspace: 8;
+    readonly Tab: 9;
+    readonly Numpad5: 12;
+    readonly NumpadEnter: 13;
+    readonly ShiftRight: 16;
+    readonly ControlRight: 17;
+    readonly ControlLeft: 17;
+    readonly AltRight: 18;
+    readonly Escape: 27;
+    readonly Space: 32;
+    readonly Numpad9: 33;
+    readonly Numpad3: 34;
+    readonly Numpad1: 35;
+    readonly Numpad7: 36;
+    readonly Numpad4: 37;
+    readonly Numpad8: 38;
+    readonly Numpad6: 39;
+    readonly Numpad2: 40;
+    readonly Numpad0: 45;
+    readonly NumpadDecimal: 46;
+    readonly Digit0: 48;
+    readonly Digit1: 49;
+    readonly Digit2: 50;
+    readonly Digit3: 51;
+    readonly Digit4: 52;
+    readonly Digit5: 53;
+    readonly Digit6: 54;
+    readonly Digit7: 55;
+    readonly Digit8: 56;
+    readonly Digit9: 57;
+    readonly KeyA: 65;
+    readonly KeyB: 66;
+    readonly KeyC: 67;
+    readonly KeyD: 68;
+    readonly KeyE: 69;
+    readonly KeyF: 70;
+    readonly KeyG: 71;
+    readonly KeyH: 72;
+    readonly KeyI: 73;
+    readonly KeyJ: 74;
+    readonly KeyK: 75;
+    readonly KeyL: 76;
+    readonly KeyM: 77;
+    readonly KeyN: 78;
+    readonly KeyO: 79;
+    readonly KeyP: 80;
+    readonly KeyQ: 81;
+    readonly KeyR: 82;
+    readonly KeyS: 83;
+    readonly KeyT: 84;
+    readonly KeyU: 85;
+    readonly KeyV: 86;
+    readonly KeyW: 87;
+    readonly KeyX: 88;
+    readonly KeyY: 89;
+    readonly KeyZ: 90;
+    readonly MetaLeft: 91;
+    readonly ContextMenu: 93;
+    readonly NumpadMultiply: 106;
+    readonly NumpadAdd: 107;
+    readonly NumpadSubtract: 109;
+    readonly NumpadDivide: 111;
+    readonly F1: 112;
+    readonly F2: 113;
+    readonly F3: 114;
+    readonly F4: 115;
+    readonly F5: 116;
+    readonly F6: 117;
+    readonly F7: 118;
+    readonly F8: 119;
+    readonly F9: 120;
+    readonly F10: 121;
+    readonly F11: 122;
+    readonly F12: 123;
+    readonly NumLock: 144;
+    readonly ScrollLock: 145;
+    readonly Semicolon: 186;
+    readonly Equal: 187;
+    readonly Comma: 188;
+    readonly Minus: 189;
+    readonly Period: 190;
+    readonly Slash: 191;
+    readonly Backquote: 192;
+    readonly BracketLeft: 219;
+    readonly Backslash: 220;
+    readonly BracketRight: 221;
+    readonly Quote: 222;
+    readonly IntlBackslash: 226;
+    readonly ArrowUp: 38;
+    readonly ArrowDown: 40;
+    readonly ArrowLeft: 37;
+    readonly ArrowRight: 39;
+};
+type IKeyName = keyof typeof KeyboardNumericCode;
+type IKeyCode = (typeof KeyboardNumericCode)[IKeyName];
+type InvertedKeyMapType = {
+    [K in IKeyName as (typeof KeyboardNumericCode)[K]]: K;
+};
+declare const InvertedKeyMap: InvertedKeyMapType;
+declare const KeyboardStringCode: { [K in IKeyName]: K; };
+export type { IKeyName, IKeyCode };
+export { KeyboardStringCode, InvertedKeyMap, KeyboardNumericCode };

package/lib/helpers/serialize.d.ts

@@ -0,0 +1 @@
+export declare function serialize(obj: any): string;

package/lib/helpers/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(time: number): Promise<unknown>;

package/lib/helpers/trimLastSlashFromUrl.d.ts

@@ -0,0 +1 @@
+export declare function trimLastSlashFromUrl(baseUrl: string): string | null | undefined;

package/lib/image/SaveImage.d.ts

@@ -0,0 +1,18 @@
+import type { ImageOutputValues } from '../interfaces';
+/**
+ * USE DownloadImage instead!
+ * @deprecated use DownloadImage instead!
+ * @param imageSource
+ * @param name
+ * @param width
+ * @param format
+ */
+declare function SaveImage(imageSource: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap | string, name: string, width?: number, format?: string | ImageOutputValues): any;
+/**
+ * @param imageSource
+ * @param string name
+ * @param number width
+ * @param string format
+ */
+declare const DownloadImage: typeof SaveImage;
+export { SaveImage, DownloadImage };

package/lib/image/getCanvasCached.d.ts

@@ -0,0 +1,4 @@
+export declare function getCanvasCached(id: string): {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};

package/lib/image/getSnapshot.d.ts

@@ -0,0 +1,2 @@
+import type { ImageOutputValues } from '../interfaces';
+export declare function getSnapshot(imageElement: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, maxWidth?: number, output?: ImageOutputValues, quality?: number): HTMLCanvasElement | string;

package/lib/image/loadImage.d.ts

@@ -0,0 +1 @@
+export declare function loadImage(url: string): Promise<HTMLImageElement>;

package/lib/interfaces/image-output.d.ts

@@ -0,0 +1,7 @@
+export declare const ImageOutput: {
+    readonly CANVAS: "canvas";
+    readonly PNG: "image/png";
+    readonly WEBP: "image/webp";
+    readonly JPG: "image/jpeg";
+};
+export type ImageOutputValues = (typeof ImageOutput)[keyof typeof ImageOutput];

package/{src/lib/interfaces/load-args-tmp.interface.ts → lib/interfaces/load-args-tmp.interface.d.ts}

@@ -1,5 +1,4 @@
 import type { LoadArgs } from './load-args.interface';
-
 export interface LoadArgsTmp extends LoadArgs {
-  xhr?: XMLHttpRequest;
+    xhr?: XMLHttpRequest;
 }

package/lib/interfaces/load-args.interface.d.ts

@@ -0,0 +1,15 @@
+export interface LoadArgs {
+    order: number;
+    extra: any;
+    item?: HTMLImageElement;
+    useXhr?: boolean;
+    path: string;
+    onLoadEnd: (data: LoadArgs) => void;
+    onLoadStart: (data: ProgressEvent) => void;
+    onProgress: (data: ProgressEvent) => void;
+    id?: string;
+    img?: HTMLImageElement;
+    error?: boolean;
+    fallBack?: string;
+    resolutionId: number | string | null;
+}

package/{src/lib/math/baseSortedIndex.ts → lib/math/baseSortedIndex.d.ts}

@@ -22,22 +22,4 @@
  * // returns 1
  * baseSortedIndex([1, 2, 3], 2);
  */
-export function baseSortedIndex(array: number[], value: number): number {
-  const MAX_ARRAY_LENGTH = 4294967295;
-  const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
-  let low = 0;
-  let high = array?.length || low;
-
-  if (high <= HALF_MAX_ARRAY_LENGTH) {
-    while (low < high) {
-      const mid = (low + high) >>> 1;
-      const computed = array[mid];
-      if (computed !== null && computed < value) {
-        low = mid + 1;
-      } else {
-        high = mid;
-      }
-    }
-  }
-  return high;
-}
+export declare function baseSortedIndex(array: number[], value: number): number;

package/{src/lib/math/calculateMedian.ts → lib/math/calculateMedian.d.ts}

@@ -14,20 +14,4 @@
  * console.log(median); // Output: 2.5
  * ```
  */
-export function calculateMedian(numbers: number[]): number {
-  if (numbers.length === 0) return 0;
-
-  // Sort the array in ascending order
-  const sorted = [...numbers].sort((a, b) => a - b);
-
-  const length = sorted.length;
-  const middle = Math.floor(length / 2);
-
-  // If the length is even, return the average of the two middle numbers
-  if (length % 2 === 0) {
-    return (sorted[middle - 1] + sorted[middle]) / 2;
-  }
-
-  // If the length is odd, return the middle number
-  return sorted[middle];
-}
+export declare function calculateMedian(numbers: number[]): number;

package/{src/lib/math/circularIndex.ts → lib/math/circularIndex.d.ts}

@@ -1,5 +1,3 @@
-import { clampf } from './clampf';
-
 /**
  * Computes a circular index within a given range.
  *
@@ -34,6 +32,4 @@ import { clampf } from './clampf';
  * const index5 = circularIndex(1, 1);
  * console.log(index5); // Output: 0
  */
-export function circularIndex(index: number, totalItems: number): number {
-  return clampf(0, totalItems - 1, (totalItems * 2 + index) % totalItems);
-}
+export declare function circularIndex(index: number, totalItems: number): number;

package/lib/math/clampf.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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

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

package/{src/lib/math/floatCompare.ts → lib/math/floatCompare.d.ts}

@@ -1,11 +1,3 @@
-/**
- * A small epsilon value used for floating-point comparisons.
- *
- * @remarks
- * The value of `EPSILON` is `0.01`. This can be overridden in the comparison functions if needed.
- */
-const EPSILON = 0.01;
-
 /**
  * Checks if floating-point number `A` is less than `B` considering a small margin of error.
  *
@@ -19,15 +11,7 @@ const EPSILON = 0.01;
  * const result = fpIsALessThanB(0.0034, 0.0066); // true
  * ```
  */
-export function fpIsALessThanB(
-  A: number,
-  B: number,
-  Epsilon?: number,
-): boolean {
-  Epsilon = Epsilon || EPSILON;
-  return A - B < Epsilon && Math.abs(A - B) > Epsilon;
-}
-
+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.
  *
@@ -41,15 +25,7 @@ export function fpIsALessThanB(
  * const result = fpIsAGreaterThanB(0.0066, 0.0034); // true
  * ```
  */
-export function fpIsAGreaterThanB(
-  A: number,
-  B: number,
-  Epsilon?: number,
-): boolean {
-  Epsilon = Epsilon || EPSILON;
-  return A - B > Epsilon && Math.abs(A - B) > Epsilon;
-}
-
+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.
  *
@@ -63,7 +39,4 @@ export function fpIsAGreaterThanB(
  * const result = fpIsASameAsB(0.005, 0.0051); // true
  * ```
  */
-export function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean {
-  Epsilon = Epsilon || EPSILON;
-  return Math.abs(A - B) < Epsilon;
-}
+export declare function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean;

package/{src/lib/math/inverseLerp.ts → lib/math/inverseLerp.d.ts}

@@ -14,25 +14,4 @@
  * 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 function inverseLerp(
-  min: number,
-  max: number,
-  value: number,
-  clampToNormal = false,
-): number {
-  if (clampToNormal) {
-    value = Math.min(max, value);
-    value = Math.max(min, value);
-  }
-  const difference = max - min;
-
-  // Avoid JS division error
-  if (difference === 0) {
-    return 1;
-  }
-  const result = (value - min) / difference;
-  if (clampToNormal) {
-    return Math.min(1, Math.max(0, result));
-  }
-  return result;
-}
+export declare function inverseLerp(min: number, max: number, value: number, clampToNormal?: boolean): number;

package/lib/math/lerp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @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/{src/lib/mutex/Mutex.ts → lib/mutex/Mutex.d.ts}

@@ -32,19 +32,12 @@
  * [LOG]: "Task 4 acquired mutex"
  * [LOG]: "Task 4 releasing mutex"
  */
-export class Mutex {
-  private mutex = Promise.resolve();
-
-  /**
-   * 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.
-   */
-  async acquire(): Promise<() => void> {
-    let release: () => void;
-    const previous = this.mutex;
-    this.mutex = new Promise<void>((resolve) => (release = resolve));
-    await previous;
-    return release!;
-  }
+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/{src/lib/mutex/Semaphore.ts → lib/mutex/Semaphore.d.ts}

@@ -32,31 +32,11 @@
  * [LOG]: "Task 4 releasing semaphore"
  * [LOG]: "Task 3 releasing semaphore"
  */
-export class Semaphore {
-  private tasks: (() => void)[] = [];
-  private currentCount = 0;
-
-  constructor(private readonly maxConcurrency: number) {}
-
-  public acquire(): Promise<void> {
-    return new Promise((resolve) => {
-      if (this.currentCount < this.maxConcurrency) {
-        this.currentCount++;
-        resolve();
-      } else {
-        this.tasks.push(resolve);
-      }
-    });
-  }
-
-  public release(): void {
-    if (this.tasks.length > 0) {
-      const nextTask = this.tasks.shift();
-      if (nextTask) {
-        nextTask();
-      }
-    } else if (this.currentCount > 0) {
-      this.currentCount--;
-    }
-  }
+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

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

package/lib/predicates/BooleanPredictors.d.ts

@@ -0,0 +1,27 @@
+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 a 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 {};

package/{src/lib/predicates/textForSearch.ts → lib/predicates/textForSearch.d.ts}

@@ -1,5 +1,3 @@
-const cache: Record<string, unknown> = {};
-
 /**
  * Converts a given value to a string suitable for search comparisons.
  * The resulting string is in lowercase, with consecutive spaces replaced by underscores.
@@ -17,18 +15,4 @@ const cache: Record<string, unknown> = {};
  * retrieved from the cache or freshly computed and then cached.
  *
  */
-export function textForSearch(value: unknown, caseSensitive = false): string {
-  const key = `${value}_${caseSensitive}`;
-  return (cache[key] ||
-    (() => {
-      let result = String(value).trim().replace(/ +/gi, '_');
-
-      if (!caseSensitive) {
-        result = result.toLowerCase();
-      }
-
-      cache[key] = result;
-
-      return result;
-    })()) as string;
-}
+export declare function textForSearch(value: unknown, caseSensitive?: boolean): string;

package/{src/lib/predicates/where.ts → lib/predicates/where.d.ts}

@@ -1,6 +1,4 @@
-import { textForSearch } from './textForSearch';
 import type { TruthyTypesOf } from 'rxjs';
-
 /**
  * Creates a predicate function to filter records from a collection based on specified criteria.
  *
@@ -44,33 +42,5 @@ import type { TruthyTypesOf } from 'rxjs';
  * ensuring the function is only used with object types. This generic approach allows for flexible usage
  * with various record structures.
  */
-
-export function where<T extends object>(
-  criteria: Partial<TruthyTypesOf<T>>,
-  caseSensitive = false,
-): (record: T) => boolean {
-  const preComputedEntries = Object.entries(criteria)
-    .filter(([, value]) => value !== undefined)
-    .map(([key, value]) => [key, textForSearch(value, caseSensitive)] as const);
-
-  return (record: T): boolean => {
-    return (
-      preComputedEntries.length > 0 &&
-      preComputedEntries.every(([key, criterionValue]) => {
-        return (
-          textForSearch(record[key as keyof T] ?? '', caseSensitive) ===
-          criterionValue
-        );
-      })
-    );
-  };
-}
-export function whereNot<T extends object>(
-  criteria: Partial<TruthyTypesOf<T>>,
-  caseSensitive = false,
-): (record: T) => boolean {
-  const whereFunc = where(criteria, caseSensitive);
-  return (record: T) => {
-    return !whereFunc(record);
-  };
-}
+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/leadingTrailingDebounceTime.d.ts

@@ -0,0 +1,15 @@
+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/{src/lib/rxjs/smoothTransition.ts → lib/rxjs/smoothTransition.d.ts}

@@ -1,8 +1,4 @@
 import type { Observable } from 'rxjs';
-import { animationFrameScheduler, interval } from 'rxjs';
-import { distinctUntilChanged, map } from 'rxjs/operators';
-import { clampf, lerp } from '../math';
-
 /**
  * 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].
@@ -12,18 +8,4 @@ import { clampf, lerp } from '../math';
  * @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 const smoothTransition = (
-  start: number,
-  end: number,
-  duration: number,
-): Observable<number> => {
-  const startTime = animationFrameScheduler.now();
-  return interval(0, animationFrameScheduler).pipe(
-    map(() => {
-      const elapsed = (animationFrameScheduler.now() - startTime) / duration;
-      return clampf(0, 1, elapsed);
-    }),
-    distinctUntilChanged(),
-    map((fraction) => lerp(start, end, fraction)),
-  );
-};
+export declare const smoothTransition: (start: number, end: number, duration: number) => Observable<number>;

package/lib/rxjs/tapLog.d.ts

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

package/lib/strings/pad.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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/package.json

@@ -1,11 +1,22 @@
 {
   "name": "@3dsource/utils",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "sideEffects": false,
   "dependencies": {
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
     "rxjs": "^7.8.2"
+  },
+  "module": "fesm2022/3dsource-utils.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/3dsource-utils.mjs"
+    }
   }
-}
+}

package/eslint.config.js

@@ -1,37 +0,0 @@
-// @ts-check
-const tseslint = require('typescript-eslint');
-const rootConfig = require('../../../eslint.config.js');
-
-module.exports = tseslint.config(
-  ...rootConfig,
-  {
-    files: ['**/*.ts'],
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-      },
-    },
-    rules: {
-      '@angular-eslint/directive-selector': [
-        'error',
-        {
-          type: 'attribute',
-          prefix: 'lib',
-          style: 'camelCase',
-        },
-      ],
-      '@angular-eslint/component-selector': [
-        'error',
-        {
-          type: 'element',
-          prefix: 'lib',
-          style: 'kebab-case',
-        },
-      ],
-    },
-  },
-  {
-    files: ['**/*.html'],
-    rules: {},
-  },
-);

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "../../../dist/3dsource/utils",
-  "lib": {
-    "entryFile": "src/public-api.ts"
-  }
-}

package/src/lib/color/HEXtoRGB.ts

@@ -1,9 +0,0 @@
-export function HEXtoRGB(color: number | string) {
-  if (typeof color === 'string') {
-    color = parseInt(color.replace('#', ''), 16);
-  }
-  const r = (color >> 16) & 255;
-  const g = (color >> 8) & 255;
-  const b = color & 255;
-  return { r: r, g: g, b: b };
-}