@3dsource/utils 1.0.9 → 1.0.10

package/src/lib/helpers/signal.ts

@@ -0,0 +1,46 @@
+import type { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+
+interface BroadcastEvent {
+  key: any;
+  data?: any;
+}
+
+/**
+ * SingleTone Private class.
+ * Event-Driving pattern for sending signals from component to component.
+ */
+class SignalClass {
+  private static eventBus: Subject<BroadcastEvent>;
+
+  constructor() {
+    if (SignalClass.eventBus) {
+      throw new Error(`Check that 'SignalClass' is not instantiated again!`);
+    }
+    SignalClass.eventBus = new Subject<BroadcastEvent>();
+  }
+
+  /**
+   * It is not recommended to use this class directly.
+   * use the sendSignal functions instead.
+   * those wrappers are more convenient and provide a better type safety.
+   */
+  broadcast<K, D>(key: K, data?: D) {
+    SignalClass.eventBus.next({ key, data });
+  }
+
+  /**
+   * It is not recommended to use this class directly.
+   * use the fromSignal functions instead.
+   * those wrappers are more convenient and provide a better type safety.
+   */
+  on<K, D = any>(key: K): Observable<D> {
+    return SignalClass.eventBus.asObservable().pipe(
+      filter((event) => event.key === key),
+      map((event) => event.data),
+    );
+  }
+}
+
+export const Signal = new SignalClass();

package/src/lib/helpers/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(time: number) {
+  return new Promise((r) => setTimeout(r, time));
+}

package/src/lib/helpers/trimLastSlashFromUrl.ts

@@ -0,0 +1,9 @@
+export function trimLastSlashFromUrl(baseUrl: string) {
+  if (!baseUrl) {
+    return null;
+  } else if (baseUrl[baseUrl.length - 1] === '/') {
+    return baseUrl.substring(0, baseUrl.length - 1);
+  }
+
+  return;
+}

package/src/lib/image/SaveImage.ts

@@ -0,0 +1,65 @@
+import { getSnapshot } from './getSnapshot';
+import type { ImageOutputValues } from '../interfaces';
+
+/**
+ * USE DownloadImage instead!
+ * @deprecated use DownloadImage instead!
+ * @param imageSource
+ * @param name
+ * @param width
+ * @param format
+ */
+function SaveImage(
+  imageSource:
+    | HTMLImageElement
+    | HTMLCanvasElement
+    | HTMLVideoElement
+    | ImageBitmap
+    | string,
+  name: string,
+  width?: number,
+  format?: string | ImageOutputValues,
+): any {
+  let out;
+  const image: any = imageSource;
+
+  if (typeof image !== 'string') {
+    out = getSnapshot(image, width, format as ImageOutputValues);
+  } else {
+    out = image;
+  }
+
+  if ((navigator as any).msSaveBlob) {
+    // IE10+
+    try {
+      const blob = image.msToBlob();
+      return (navigator as any).msSaveBlob(blob, name);
+    } catch (e) {
+      console.warn(e);
+    }
+  } else {
+    const uri = out;
+    const link = document.createElement('a');
+    link.download = name;
+    link.href = uri as string;
+
+    document.body.appendChild(link);
+    if (link.click) {
+      link.click();
+    } else {
+      const event = document.createEvent('MouseEvents');
+      (event as any).initMouseEvent('click', true, true, window);
+      link.dispatchEvent(event);
+    }
+    document.body.removeChild(link);
+  }
+}
+
+/**
+ * @param imageSource
+ * @param string name
+ * @param number width
+ * @param string format
+ */
+const DownloadImage = SaveImage;
+export { SaveImage, DownloadImage };

package/src/lib/image/getCanvasCached.ts

@@ -0,0 +1,16 @@
+const canvasCacheObj: any = {};
+
+export function getCanvasCached(id: string): {
+  canvas: HTMLCanvasElement;
+  ctx: CanvasRenderingContext2D;
+} {
+  if (!canvasCacheObj[id]) {
+    const canvas = document.createElement('canvas');
+    canvasCacheObj[id] = {
+      canvas,
+      ctx: canvas.getContext('2d'),
+    };
+  }
+
+  return canvasCacheObj[id];
+}

package/src/lib/image/getSnapshot.ts

@@ -0,0 +1,99 @@
+import { fitIntoRectangle } from '../geom';
+import type { ImageOutputValues } from '../interfaces';
+
+function getSnapshot2(
+  imageElement:
+    | HTMLImageElement
+    | HTMLCanvasElement
+    | HTMLVideoElement
+    | ImageBitmap,
+  maxWidth = 1024,
+  output: ImageOutputValues = 'image/png',
+  quality = 0.9,
+): HTMLCanvasElement | string {
+  const drawableImage = imageElement as any;
+  const canvasHelper: HTMLCanvasElement = document.createElement('canvas');
+  const drawCTX: CanvasRenderingContext2D = canvasHelper.getContext(
+    '2d',
+  ) as CanvasRenderingContext2D;
+
+  const prop = fitIntoRectangle(
+    {
+      x: 0,
+      y: 0,
+      w: drawableImage.naturalWidth || drawableImage.width,
+      h: drawableImage.naturalHeight || drawableImage.height,
+    },
+    {
+      x: 0,
+      y: 0,
+      w: maxWidth,
+      h: drawableImage.naturalHeight || drawableImage.height,
+    },
+  );
+
+  const width = prop.w;
+  const height = prop.h;
+  canvasHelper.width = width;
+  canvasHelper.height = height;
+
+  drawCTX.save();
+  drawCTX.clearRect(0, 0, width, height);
+  drawCTX.drawImage(drawableImage, 0, 0, width, height);
+  drawCTX.restore();
+
+  if (output === 'canvas') {
+    return canvasHelper;
+  }
+
+  return canvasHelper.toDataURL(output, quality);
+}
+
+export function getSnapshot(
+  imageElement:
+    | HTMLImageElement
+    | HTMLCanvasElement
+    | HTMLVideoElement
+    | ImageBitmap,
+  maxWidth = 1024,
+  output: ImageOutputValues = 'image/png',
+  quality = 0.9,
+): HTMLCanvasElement | string {
+  const drawableImage = imageElement as any;
+  const canvasHelper: HTMLCanvasElement = document.createElement('canvas');
+  const drawCTX: CanvasRenderingContext2D = canvasHelper.getContext(
+    '2d',
+  ) as CanvasRenderingContext2D;
+
+  const prop = fitIntoRectangle(
+    {
+      x: 0,
+      y: 0,
+      w: drawableImage.naturalWidth || drawableImage.width,
+      h: drawableImage.naturalHeight || drawableImage.height,
+    },
+    {
+      x: 0,
+      y: 0,
+      w: (drawableImage.naturalWidth || drawableImage.width) / 2,
+      h: drawableImage.naturalHeight || drawableImage.height,
+    },
+  );
+
+  const width = prop.w;
+  const height = prop.h;
+  canvasHelper.width = width;
+  canvasHelper.height = height;
+
+  drawCTX.save();
+  drawCTX.clearRect(0, 0, width, height);
+  drawCTX.drawImage(drawableImage, 0, 0, width, height);
+
+  drawCTX.restore();
+
+  if (width > maxWidth * 2) {
+    return getSnapshot(canvasHelper, maxWidth, output, quality);
+  }
+
+  return getSnapshot2(drawableImage, maxWidth, output, quality);
+}

package/src/lib/image/loadImage.ts

@@ -0,0 +1,13 @@
+export function loadImage(url: string): Promise<HTMLImageElement> {
+  return new Promise((resolve: any, reject) => {
+    const img = new Image();
+    img.crossOrigin = 'anonymous';
+    img.onload = () => {
+      setTimeout(() => resolve(img), 1);
+    };
+    img.onerror = () => {
+      setTimeout(() => reject(null), 1);
+    };
+    img.src = url;
+  });
+}

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

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

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

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

package/src/lib/interfaces/load-args.interface.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/{lib/math/baseSortedIndex.d.ts → src/lib/math/baseSortedIndex.ts}

@@ -22,4 +22,22 @@
  * // returns 1
  * baseSortedIndex([1, 2, 3], 2);
  */
-export declare function baseSortedIndex(array: number[], value: number): number;
+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;
+}

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

@@ -14,4 +14,20 @@
  * console.log(median); // Output: 2.5
  * ```
  */
-export declare function calculateMedian(numbers: number[]): number;
+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];
+}

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

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

package/src/lib/math/clampf.ts

@@ -0,0 +1,14 @@
+/**
+ * Clamps value between min and max;
+ * @param min minValue
+ * @param max maxValue
+ * @param value inputValue
+ * @returns number
+ */
+
+export function clampf(min: number, max: number, value: number): number {
+  if (min > max) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}

package/src/lib/math/degrees.ts

@@ -0,0 +1,7 @@
+export function degreesToRadians(degrees: number): number {
+  return degrees * (Math.PI / 180);
+}
+
+export function radiansToDegrees(radians: number): number {
+  return radians * (180 / Math.PI);
+}

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

@@ -1,3 +1,11 @@
+/**
+ * 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.
  *
@@ -11,7 +19,15 @@
  * const result = fpIsALessThanB(0.0034, 0.0066); // true
  * ```
  */
-export declare function fpIsALessThanB(A: number, B: number, Epsilon?: number): boolean;
+export function fpIsALessThanB(
+  A: number,
+  B: number,
+  Epsilon?: number,
+): boolean {
+  Epsilon = Epsilon || EPSILON;
+  return A - B < Epsilon && Math.abs(A - B) > Epsilon;
+}
+
 /**
  * Checks if floating-point number `A` is greater than `B` considering a small margin of error.
  *
@@ -25,7 +41,15 @@ export declare function fpIsALessThanB(A: number, B: number, Epsilon?: number):
  * const result = fpIsAGreaterThanB(0.0066, 0.0034); // true
  * ```
  */
-export declare function fpIsAGreaterThanB(A: number, B: number, Epsilon?: number): boolean;
+export function fpIsAGreaterThanB(
+  A: number,
+  B: number,
+  Epsilon?: number,
+): boolean {
+  Epsilon = Epsilon || EPSILON;
+  return A - B > Epsilon && Math.abs(A - B) > Epsilon;
+}
+
 /**
  * Checks if floating-point number `A` is approximately the same as `B` considering a small margin of error.
  *
@@ -39,4 +63,7 @@ export declare function fpIsAGreaterThanB(A: number, B: number, Epsilon?: number
  * const result = fpIsASameAsB(0.005, 0.0051); // true
  * ```
  */
-export declare function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean;
+export function fpIsASameAsB(A: number, B: number, Epsilon?: number): boolean {
+  Epsilon = Epsilon || EPSILON;
+  return Math.abs(A - B) < Epsilon;
+}

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

@@ -14,4 +14,25 @@
  * 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;
+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;
+}

package/src/lib/math/lerp.ts

@@ -0,0 +1,12 @@
+import { clampf } from './clampf';
+
+/**
+ * @param min minimums
+ * @param max maximums
+ * @param value current float value in 0-1 range
+ * @returns clamped value
+ */
+export function lerp(min: number, max: number, value: number): number {
+  value = clampf(0, 1, value);
+  return value * (max - min) + min;
+}

package/{lib/mutex/Mutex.d.ts → src/lib/mutex/Mutex.ts}

@@ -32,12 +32,19 @@
  * [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>;
+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!;
+  }
 }

package/{lib/mutex/Semaphore.d.ts → src/lib/mutex/Semaphore.ts}

@@ -32,11 +32,31 @@
  * [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;
+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--;
+    }
+  }
 }

package/src/lib/mutex/TaskRunner.ts

@@ -0,0 +1,26 @@
+import type { Observable } from 'rxjs';
+import { finalize, from, switchMap } from 'rxjs';
+import { Logger } from '../dev';
+import { Mutex } from './Mutex';
+
+export class TaskRunner {
+  private mutex = new Mutex();
+
+  runTask(name: string, task: () => Observable<string | null>) {
+    // Log that the task is waiting to acquire the mutex
+    Logger.log(`${name} waiting to acquire mutex`);
+
+    return from(this.mutex.acquire()).pipe(
+      switchMap((release) => {
+        // Log that the mutex has been acquired
+        Logger.log(`${name} acquired mutex`);
+        return task().pipe(
+          finalize(() => {
+            Logger.log(`${name} releasing mutex`);
+            release();
+          }),
+        );
+      }),
+    );
+  }
+}

package/src/lib/predicates/operators.ts

@@ -0,0 +1,75 @@
+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 const Truthy: <T>(value: T) => value is TruthyTypesOf<T> = <T>(
+  value?: T,
+): value is TruthyTypesOf<T> =>
+  !!value && value !== 'false' && value !== 'undefined' && value !== 'null';
+
+/**
+ * The Boolean object represents an INVERSE truth value: true or false.
+ * @param value
+ * @constructor
+ * Returns:boolean
+ */
+export const Falsy: <T>(value: T) => value is FalsyTypesOf<T> = <T>(
+  value?: T,
+): value is FalsyTypesOf<T> => !Truthy(value);
+
+/**
+ * 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 const IsEmpty: <T>(value: T) => value is EmptyTypesOf<T> = <T>(
+  value: T,
+): value is EmptyTypesOf<T> => {
+  return (
+    value === undefined ||
+    value === null ||
+    (typeof value === 'object' && Object.keys(value).length === 0) ||
+    (typeof value === 'string' && value.trim().length === 0)
+  );
+};
+
+export const NotEmpty: <T>(value: T) => value is NonEmptyTypesOf<T> = <T>(
+  value: T,
+): value is NonEmptyTypesOf<T> => {
+  return !IsEmpty(value);
+};
+export const isDefined = <T>(arg: T | null | undefined): arg is T =>
+  arg !== null && arg !== undefined;
+
+export const isNotDefined = <T>(
+  arg: T | null | undefined,
+): arg is null | undefined => arg === null || arg === undefined;
+
+export const isJSON = (str: string): boolean => {
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    console.warn(e);
+
+    return false;
+  }
+
+  return true;
+};
+
+export const isEmpty = (value: any) =>
+  value === undefined ||
+  value === null ||
+  (typeof value === 'object' && Object.keys(value).length === 0) ||
+  (typeof value === 'string' && value.trim().length === 0);
+
+export function isAllValuesTruthy<T extends string, K>(value: Record<T, K>) {
+  return Object.values(value).every(Truthy);
+}

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

@@ -1,3 +1,5 @@
+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.
@@ -15,4 +17,18 @@
  * retrieved from the cache or freshly computed and then cached.
  *
  */
-export declare function textForSearch(value: unknown, caseSensitive?: boolean): string;
+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;
+}