@3dsource/utils 1.0.3 → 1.0.5

package/src/lib/image/getSnapshot.ts

@@ -1,99 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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/src/lib/interfaces/load-args.interface.ts

@@ -1,15 +0,0 @@
-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/clampf.ts

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

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

package/src/lib/math/lerp.ts

@@ -1,12 +0,0 @@
-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/src/lib/math/test/baseSortedIndex.spec.ts

@@ -1,43 +0,0 @@
-import { baseSortedIndex } from '../baseSortedIndex';
-
-describe('baseSortedIndex', () => {
-  it('should return the correct insertion index in a sorted array', () => {
-    const array = [10, 20, 30, 40, 50];
-    const value = 35;
-    const index = baseSortedIndex(array, value);
-    expect(index).toBe(3); // 35 should be inserted at index 3 to maintain sorted order
-  });
-
-  it('should handle empty arrays', () => {
-    const array: number[] = [];
-    const value = 10;
-    const index = baseSortedIndex(array, value);
-    expect(index).toBe(0); // In an empty array, the insertion index is always 0
-  });
-
-  it('should place value at the start if less than all elements', () => {
-    const array = [10, 20, 30, 40, 50];
-    const value = 5;
-    const index = baseSortedIndex(array, value);
-    expect(index).toBe(0); // 5 should be inserted at index 0
-  });
-
-  it('should place value at the end if greater than all elements', () => {
-    const array = [10, 20, 30, 40, 50];
-    const value = 60;
-    const index = baseSortedIndex(array, value);
-    expect(index).toBe(5); // 60 should be inserted at index 5, which is the array's length
-  });
-
-  it('should handle arrays with the maximum safe size', () => {
-    // Assuming a simplified scenario for demonstration, as actually filling an array to max length would be impractical
-    const array = [1, 2]; // Simulate a sorted array
-    const value = 2;
-    // Manually set the array length to mimic a large array scenario
-    Object.defineProperty(array, 'length', { value: Math.pow(2, 31) - 1 });
-    const index = baseSortedIndex(array, value);
-    // The expected index would depend on the actual implementation and purpose of handling large arrays
-    // For this example, we'll assume it should return the position based on the 'value' in a sorted array logic
-    expect(index).not.toBeUndefined(); // Adjust this based on the actual intended behavior for large arrays
-  });
-});

package/src/lib/math/test/circularIndex.spec.ts

@@ -1,38 +0,0 @@
-import { circularIndex } from '../circularIndex';
-
-describe('circularIndex', () => {
-  it('should return 0', () => {
-    expect(circularIndex(5, 5)).toBe(0);
-  });
-
-  it('should return 1', () => {
-    expect(circularIndex(6, 5)).toBe(1);
-  });
-
-  it('should return 4', () => {
-    expect(circularIndex(-1, 5)).toBe(4);
-  });
-
-  it('should return 3', () => {
-    expect(circularIndex(-2, 5)).toBe(3);
-  });
-  it('should return 4', () => {
-    expect(circularIndex(-6, 5)).toBe(4);
-  });
-  it('should return 1', () => {
-    expect(circularIndex(11, 5)).toBe(1);
-  });
-
-  it('should return 0', () => {
-    expect(circularIndex(1, 1)).toBe(0);
-  });
-  it('should return 0', () => {
-    expect(circularIndex(2, 1)).toBe(0);
-  });
-  it('should return 0', () => {
-    expect(circularIndex(-2, 1)).toBe(0);
-  });
-  it('should return 0', () => {
-    expect(circularIndex(10, 0)).toBe(0);
-  });
-});

package/src/lib/mutex/TaskRunner.ts

@@ -1,26 +0,0 @@
-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/BooleanPredictors.ts

@@ -1,47 +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 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 a 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);
-};

package/src/lib/predicates/test/BooleanPredictors.spec.ts

@@ -1,71 +0,0 @@
-import { Falsy, IsEmpty, Truthy } from '../BooleanPredictors';
-
-describe('Truthy function', () => {
-  it('should return true for truthy values', () => {
-    expect(Truthy(true)).toBeTruthy();
-    expect(Truthy('true')).toBeTruthy();
-    expect(Truthy(1)).toBeTruthy();
-    expect(Truthy('non-empty')).toBeTruthy();
-    expect(Truthy({ key: 'value' })).toBeTruthy();
-    expect(Truthy([1, 2, 3])).toBeTruthy();
-    expect(Truthy([])).toBeTruthy();
-    expect(Truthy({})).toBeTruthy();
-  });
-
-  it('should return false for falsy values', () => {
-    expect(Truthy('undefined')).toBeFalsy();
-    expect(Truthy(undefined)).toBeFalsy();
-    expect(Truthy(null)).toBeFalsy();
-    expect(Truthy('null')).toBeFalsy();
-    expect(Truthy('false')).toBeFalsy();
-    expect(Truthy(false)).toBeFalsy();
-    expect(Truthy(0)).toBeFalsy();
-    expect(Truthy(-0)).toBeFalsy();
-    expect(Truthy(-0)).toBeFalsy();
-    expect(Truthy(NaN)).toBeFalsy();
-    expect(Truthy('')).toBeFalsy();
-  });
-});
-
-describe('Falsy function', () => {
-  it('should return false for truthy values', () => {
-    expect(Falsy(1)).toBeFalsy();
-    expect(Falsy('non-empty')).toBeFalsy();
-    expect(Falsy({ key: 'value' })).toBeFalsy();
-    expect(Falsy([1, 2, 3])).toBeFalsy();
-    expect(Falsy([])).toBeFalsy();
-    expect(Falsy({})).toBeFalsy();
-    expect(Falsy('true')).toBeFalsy();
-  });
-
-  it('should return true for falsy values', () => {
-    expect(Falsy('false')).toBeTruthy();
-    expect(Falsy('undefined')).toBeTruthy();
-    expect(Falsy('null')).toBeTruthy();
-    expect(Falsy(false)).toBeTruthy();
-    expect(Falsy(undefined)).toBeTruthy();
-    expect(Falsy(null)).toBeTruthy();
-    expect(Falsy(0)).toBeTruthy();
-    expect(Falsy(-0)).toBeTruthy();
-    expect(Falsy(-0)).toBeTruthy();
-    expect(Falsy(NaN)).toBeTruthy();
-    expect(Falsy('')).toBeTruthy();
-  });
-});
-
-describe('IsEmpty function', () => {
-  it('should return true for empty values', () => {
-    expect(IsEmpty('')).toBeTruthy();
-    expect(IsEmpty('  ')).toBeTruthy();
-    expect(IsEmpty(null)).toBeTruthy();
-    expect(IsEmpty(undefined)).toBeTruthy();
-    expect(IsEmpty({})).toBeTruthy();
-    expect(IsEmpty([])).toBeTruthy();
-  });
-
-  it('should return false for non-empty values', () => {
-    expect(IsEmpty('non-empty')).toBeFalsy();
-    expect(IsEmpty({ key: 'value' })).toBeFalsy();
-    expect(IsEmpty([1])).toBeFalsy();
-  });
-});

package/src/lib/predicates/test/where.spec.ts

@@ -1,94 +0,0 @@
-// Mocking the textForSearch if necessary, or import if available
-import { where, whereNot } from '../where';
-
-describe('where', () => {
-  it('should filter records based on a single criteria match', () => {
-    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
-    const criteria = { name: 'John Doe' };
-    const filter = where(criteria);
-    expect(records.filter(filter)).toEqual([{ name: 'John Doe' }]);
-  });
-
-  it('should be case sensitive when specified', () => {
-    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
-    const criteria = { name: 'John Doe' };
-    const filter = where(criteria, true);
-    expect(records.filter(filter)).toEqual([]);
-  });
-
-  it('should handle multiple criteria', () => {
-    const records = [
-      { name: 'John Doe', age: 30 },
-      { name: 'Jane Doe', age: 25 },
-    ];
-    const criteria = { name: 'Jane Doe', age: 25 };
-    const filter = where(criteria);
-    expect(records.filter(filter)).toEqual([{ name: 'Jane Doe', age: 25 }]);
-  });
-
-  it('should return empty array if criteria is empty', () => {
-    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
-    const criteria = {};
-    const filter = where(criteria);
-    expect(records.filter(filter)).toEqual([]);
-  });
-
-  it('should handle non-string values correctly', () => {
-    const records = [{ age: 20 }, { age: 30 }];
-    const criteria = { age: 20 };
-    const filter = where(criteria);
-    expect(records.filter(filter)).toEqual([{ age: 20 }]);
-  });
-  it('should handle undefined values correctly', () => {
-    const records = [{ age: 20 }, { age: 30 }];
-    const criteria = { age: undefined };
-    const filter = where(criteria);
-    expect(records.filter(filter)).toEqual([]);
-  });
-});
-
-describe('whereNot', () => {
-  it('should filter records not matching the criteria', () => {
-    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
-    const criteria = { name: 'john doe' };
-    const filter = whereNot(criteria);
-    expect(records.filter(filter)).toEqual([{ name: 'Jane Doe' }]);
-  });
-
-  it('should filter records not matching the criteria', () => {
-    const records = [{ name: 'John Doe' }, { name: 'Jane Doe' }];
-    const criteria = { name: 'john Doe' };
-    const filter = whereNot(criteria, true);
-    expect(records.filter(filter)).toEqual([
-      { name: 'John Doe' },
-      { name: 'Jane Doe' },
-    ]);
-  });
-
-  it('should respect case sensitivity', () => {
-    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
-    const criteria = { name: 'Jane Doe' };
-    const filter = whereNot(criteria);
-    expect(records.filter(filter)).toEqual([{ name: 'john doe' }]);
-  });
-
-  it('should process empty values', () => {
-    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
-    const criteria = { name: undefined };
-    const filter = whereNot(criteria);
-    expect(records.filter(filter)).toEqual([
-      { name: 'john doe' },
-      { name: 'Jane Doe' },
-    ]);
-  });
-
-  it('should process empty values', () => {
-    const records = [{ name: 'john doe' }, { name: 'Jane Doe' }];
-    const criteria = {};
-    const filter = whereNot(criteria);
-    expect(records.filter(filter)).toEqual([
-      { name: 'john doe' },
-      { name: 'Jane Doe' },
-    ]);
-  });
-});

package/src/lib/rxjs/leadingTrailingDebounceTime.ts

@@ -1,86 +0,0 @@
-import type { SchedulerLike, Subscriber, Subscription } from 'rxjs';
-import { asyncScheduler, Observable, timer } 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 function leadingTrailingDebounceTime<T>(
-  dueTime: number,
-  scheduler: SchedulerLike = asyncScheduler,
-): (source: Observable<T>) => Observable<T> {
-  return (source: Observable<T>) =>
-    new Observable<T>((subscriber: Subscriber<T>) => {
-      let hasValue = false;
-      let lastValue: T | null = null;
-      let timerSubscription: Subscription | null = null;
-      let leading = true; // Controls whether we emit immediately.
-
-      const clearTimer = () => {
-        if (timerSubscription) {
-          timerSubscription.unsubscribe();
-          timerSubscription = null;
-        }
-      };
-
-      const resetValues = () => {
-        hasValue = false;
-        lastValue = null;
-        leading = true; // Reset so the next new value is immediate.
-      };
-
-      const emitLastValue = () => {
-        if (hasValue && lastValue !== null) {
-          subscriber.next(lastValue);
-          resetValues();
-        }
-      };
-
-      const sourceSubscription = source.subscribe({
-        next: (value) => {
-          // If we are "leading", emit immediately and switch leading off
-          if (leading) {
-            subscriber.next(value);
-            leading = false;
-            timerSubscription = timer(dueTime, scheduler).subscribe(() => {
-              resetValues();
-              clearTimer();
-            });
-            return;
-          }
-
-          // Otherwise, save the value and start (or restart) timer
-          hasValue = true;
-          lastValue = value;
-          clearTimer();
-          timerSubscription = timer(dueTime, scheduler).subscribe(() => {
-            emitLastValue();
-          });
-        },
-        error: (err: unknown) => {
-          clearTimer();
-          subscriber.error(err);
-        },
-        complete: () => {
-          // If there is a pending emission, emit it before completing
-          clearTimer();
-          emitLastValue();
-          subscriber.complete();
-        },
-      });
-
-      // Cleanup logic
-      return () => {
-        clearTimer();
-        sourceSubscription.unsubscribe();
-      };
-    });
-}

package/src/lib/rxjs/tapLog.ts

@@ -1,13 +0,0 @@
-import { tap } from 'rxjs/operators';
-import type { Observable } from 'rxjs';
-import { Logger } from '../dev';
-import { COLOR_CODES } from '../constants';
-
-export const tapLog =
-  <T>(text: string, ...args: any): ((source: Observable<T>) => Observable<T>) =>
-  (source: Observable<T>) =>
-    source.pipe(
-      tap((data) => {
-        Logger.colored(...COLOR_CODES.TAP_LOG, text, data, ...args);
-      }),
-    );

package/src/lib/strings/pad.ts

@@ -1,18 +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 function pad(
-  input: number | string,
-  size: number,
-  symbol = '0',
-): string {
-  let s = input + '';
-  while (s.length < size) {
-    s = symbol + s;
-  }
-  return s.slice(-size);
-}

package/tsconfig.lib.json

@@ -1,13 +0,0 @@
-/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
-/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../out-tsc/lib",
-    "declaration": true,
-    "declarationMap": true,
-    "inlineSources": true,
-    "types": []
-  },
-  "exclude": ["**/*.spec.ts"]
-}

package/tsconfig.lib.prod.json

@@ -1,11 +0,0 @@
-/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
-/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
-{
-  "extends": "./tsconfig.lib.json",
-  "compilerOptions": {
-    "declarationMap": false
-  },
-  "angularCompilerOptions": {
-    "compilationMode": "partial"
-  }
-}