@3dsource/utils 1.0.9 → 1.0.10

package/src/lib/dev/logger.ts

@@ -0,0 +1,94 @@
+import { timeUTCToString } from './timeToString';
+import { Truthy } from '../predicates';
+
+export class Logger {
+  static isDevMode = Truthy(localStorage.getItem('devMode'));
+
+  static colored(color: string, background: string, ...args: unknown[]) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    const [first, ...rest] = args;
+    console.log.apply(console, [
+      `%c ${timeUTCToString()} ${first} `,
+      `color: ${color}; background: ${background};`,
+      ...rest,
+    ]);
+  }
+
+  static log(...args: unknown[]) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    console.log.apply(console, [
+      `%c ${timeUTCToString()}  [ LOG  ] `,
+      'color: black; background: #80ff80;',
+      ...args,
+    ]);
+  }
+
+  static warn(...args: unknown[]) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    console.warn.apply(console, [
+      `%c ${timeUTCToString()} WARN `,
+      'color: black; background: #ffd500;',
+      ...args,
+    ]);
+  }
+
+  static info(...args: unknown[]) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    console.log.apply(console, [
+      `%c ${timeUTCToString()}  [ INFO ] `,
+      'color: white; background: blue;',
+      ...args,
+    ]);
+  }
+
+  static error(...args: unknown[]) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    console.error.apply(console, [
+      `%c ${timeUTCToString()} ERROR `,
+      'color: white; background: red;',
+      ...args,
+    ]);
+  }
+
+  static table(...args: unknown[]) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    // eslint-disable-next-line no-console
+    console.table.apply(console, [args]);
+  }
+
+  static time(...args: any) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    // eslint-disable-next-line no-console,prefer-spread
+    console.time.apply(console, args);
+  }
+
+  static timeEnd(...args: any) {
+    if (!Logger.isDevMode) {
+      return;
+    }
+
+    // eslint-disable-next-line no-console,prefer-spread
+    console.timeEnd.apply(console, args);
+  }
+}

package/src/lib/dev/timeToString.ts

@@ -0,0 +1,16 @@
+import { pad } from '../strings';
+
+/**
+ * Create a string of the form 'HOURS.MINUTES.SECONDS.MILLISECONDS'.
+ */
+export function timeToString() {
+  const date = new Date();
+
+  return `${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`;
+}
+
+export function timeUTCToString() {
+  const date = new Date();
+
+  return `${pad(date.getUTCHours(), 2)}:${pad(date.getUTCMinutes(), 2)}:${pad(date.getUTCSeconds(), 2)}.${pad(date.getUTCMilliseconds(), 3)}`;
+}

package/src/lib/filenaming/cleanupFileName.ts

@@ -0,0 +1,18 @@
+export function cleanupFileName(value: string): string {
+  if (!value) {
+    return value;
+  }
+
+  value = value
+    .toString()
+    .replace(/undefined/g, '')
+    .trim()
+    .replace(/\//g, '-')
+    .replace(/[-]+/g, '-')
+    .replace(/[^\w^.-]+/gi, '_')
+    .replace(/[\^]+/gi, '_');
+
+  value = value.split('_').filter(Boolean).join('_').toLowerCase();
+
+  return value;
+}

package/src/lib/filenaming/makePath.ts

@@ -0,0 +1,5 @@
+import { cleanupFileName } from './cleanupFileName';
+
+export function makePath(...value: string[]): string {
+  return [...value].map((el) => cleanupFileName(el)).join('/');
+}

package/src/lib/filenaming/normalizePath.ts

@@ -0,0 +1,9 @@
+import { cleanupFileName } from './cleanupFileName';
+
+export function normalizePath(value: string): string {
+  const re = new RegExp('[/\\\\]+', 'g');
+  return value
+    .split(re)
+    .map((el) => cleanupFileName(el))
+    .join('/');
+}

package/src/lib/geom/expandOverRectangle.ts

@@ -0,0 +1,17 @@
+import type { Area, Rect } from './interfaces';
+
+export function expandOverRectangle(objectRect: Rect, areaRect: Rect): Area {
+  const ratio: number = objectRect.w / objectRect.h;
+  const result: Area = { x: 0, y: 0, w: 0, h: 0, scale: 1 };
+  if (areaRect.w / ratio < areaRect.h) {
+    result.w = areaRect.h * ratio;
+    result.h = areaRect.h;
+  } else {
+    result.w = areaRect.w;
+    result.h = areaRect.w / ratio;
+  }
+  result.x = areaRect.x + (areaRect.w - result.w) / 2;
+  result.y = areaRect.y + (areaRect.h - result.h) / 2;
+  result.scale = result.w / objectRect.w;
+  return result;
+}

package/src/lib/geom/fitIntoRectangle.ts

@@ -0,0 +1,43 @@
+import type { Area, Rect } from './interfaces';
+
+export function fitIntoRectangle(
+  objectRect: Rect,
+  areaRect: Rect,
+  round = true,
+  fixedRatio: number | null = null,
+): Area {
+  const result: Area = { x: 0, y: 0, w: 0, h: 0, scale: 1 };
+  const ratio: number = objectRect.h / objectRect.w;
+
+  if (objectRect.h > objectRect.w) {
+    result.h = areaRect.h;
+    result.w = areaRect.h / ratio;
+
+    if (result.w > areaRect.w) {
+      result.w = areaRect.w;
+      result.h = areaRect.w * ratio;
+    }
+  } else {
+    result.w = areaRect.w;
+    result.h = areaRect.w * ratio;
+
+    if (result.h > areaRect.h) {
+      result.h = areaRect.h;
+      result.w = areaRect.h / ratio;
+    }
+  }
+
+  if (fixedRatio) {
+    result.w = objectRect.w * fixedRatio;
+    result.h = objectRect.h * fixedRatio;
+  }
+  const wOut: number = round ? Math.floor(result.w) : result.w;
+  const hOut: number = round ? Math.floor(result.h) : result.h;
+  return {
+    x: areaRect.x + (areaRect.w - wOut) / 2,
+    y: areaRect.y + (areaRect.h - hOut) / 2,
+    w: wOut,
+    h: hOut,
+    scale: wOut / objectRect.w,
+  };
+}

package/{lib/geom/interfaces/area.interface.d.ts → src/lib/geom/interfaces/area.interface.ts}

@@ -1,4 +1,5 @@
 import type { Rect } from './rect.interface';
+
 export interface Area extends Rect {
-    scale: number;
+  scale: number;
 }

package/{lib/geom/interfaces/rect.interface.d.ts → src/lib/geom/interfaces/rect.interface.ts}

@@ -1,4 +1,4 @@
 import type { Size } from './size.interface';
 import type { Coords } from './сoords.interface';
-export interface Rect extends Size, Coords {
-}
+
+export interface Rect extends Size, Coords {}

package/src/lib/geom/interfaces/size.interface.ts

@@ -0,0 +1,4 @@
+export interface Size {
+  w: number;
+  h: number;
+}

package/src/lib/geom/interfaces//321/201oords.interface.ts

@@ -0,0 +1,4 @@
+export interface Coords {
+  x: number;
+  y: number;
+}

package/src/lib/helpers/BatchLoader.ts

@@ -0,0 +1,243 @@
+import type { LoadArgs, LoadArgsTmp } from '../interfaces';
+import { loadImage } from '../image';
+
+export class BatchLoader {
+  private maximumSlotsNumber = 1;
+  private queue: LoadArgsTmp[] = [];
+  private slots: LoadArgsTmp[] = [];
+  private _whenDone!: () => any;
+
+  clear() {
+    this.queue.forEach((item) => {
+      try {
+        if (item.img) {
+          item.img.src = '';
+        }
+      } catch (e) {
+        console.warn(e);
+      }
+
+      try {
+        item.xhr?.abort();
+      } catch (e) {
+        console.warn(e);
+      }
+    });
+
+    this.slots.forEach((item) => {
+      try {
+        if (item.img) {
+          item.img.src = '';
+        }
+      } catch (e) {
+        console.warn(e);
+      }
+
+      try {
+        item.xhr?.abort();
+      } catch (e) {
+        console.warn(e);
+      }
+    });
+    this.slots.length = 0;
+    this.queue.length = 0;
+  }
+
+  /**
+   * new settings
+   * you must pass new settings
+   * @param sett
+   */
+  setSettings(sett: any) {
+    this.maximumSlotsNumber =
+      sett.maximumSlotsNumber !== undefined
+        ? sett.maximumSlotsNumber
+        : this.maximumSlotsNumber;
+  }
+
+  /**
+   * execute with a chosen file
+   * @param id
+   * @param func
+   */
+  withItem(id: string, func: (item: LoadArgs) => any): boolean {
+    let item = this.getById(id);
+    if (!item) {
+      return false;
+    }
+    item = func(item);
+    this.queue.sort(this.sortByOrder);
+    return true;
+  }
+
+  remove(id: string): LoadArgs[] {
+    this.queue = this.queue.filter((arg) => arg.id !== id);
+    return this.queue;
+  }
+
+  /**
+   * executes when all files are downloaded
+   * @param cb
+   */
+  whenDone(cb: any) {
+    this._whenDone = cb;
+  }
+
+  // order {number} lower will execute first, default *100*
+  load(args: LoadArgs[]) {
+    const out: { path: string; self?: any; id: string }[] = args
+      .filter((arg) => !!arg.path)
+      .map((arg) => ({
+        path: arg.path,
+        id: this.add(arg),
+      }));
+
+    this.queue.sort(this.sortByOrder);
+    this.checkSlots();
+
+    return out;
+  }
+
+  /**
+   * operates with one file
+   * @param item
+   * @private
+   */
+  private add(item: LoadArgs): string {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this;
+    const temp: LoadArgsTmp = {
+      id: item.id,
+      resolutionId: null,
+      useXhr: item.useXhr,
+      order: item.order !== undefined ? item.order : 100,
+      fallBack: item.fallBack,
+      path: item.path,
+      onLoadEnd: item.onLoadEnd,
+      onProgress: item.onProgress,
+      onLoadStart: item.onLoadStart,
+      extra: item.extra,
+    };
+
+    let retryCount = 1;
+    if (temp.useXhr) {
+      temp.xhr = this.getXmlHttp();
+      temp.xhr.onloadstart = (data: ProgressEvent) => item.onLoadStart(data);
+      temp.xhr.onprogress = (data: ProgressEvent) => item.onProgress(data);
+      temp.xhr.onreadystatechange = async function (data: any) {
+        if (this.readyState === 1 && this.status === 0) {
+          return;
+        }
+        if (
+          this.readyState === 4 &&
+          (this.status === 404 || this.status === 0)
+        ) {
+          temp.error = true;
+          that.loadEnd(temp);
+          return;
+        }
+        if (this.readyState === 4 && this.status === 200) {
+          const urlCreator = window.URL;
+          const imageUrl = urlCreator.createObjectURL(data.target.response);
+          temp.img = await loadImage(imageUrl);
+          that.loadEnd(temp);
+          return;
+        }
+      };
+    } else {
+      temp.img = new Image();
+      temp.img.crossOrigin = 'anonymous';
+      temp.img.onload = () => {
+        that.loadEnd(temp);
+      };
+      temp.img.onerror = () => {
+        if (temp.fallBack && retryCount-- > 0) {
+          console.warn('Fallback used =>', temp.path, '=>', temp.fallBack);
+          if (temp.img) {
+            temp.img.onload = null;
+            temp.img.src = temp.fallBack;
+          }
+
+          that.loadEnd(temp);
+        } else {
+          temp.error = true;
+          that.loadEnd(temp);
+        }
+      };
+    }
+    this.queue.push(temp);
+    return temp.id as string;
+  }
+
+  private sortByOrder(a: LoadArgs, b: LoadArgs): number {
+    return a.order > b.order ? 1 : a.order < b.order ? -1 : 0;
+  }
+
+  private loadEnd(item: LoadArgs) {
+    if (item.onLoadEnd !== undefined) {
+      for (let i = 0, len = this.slots.length; i < len; i += 1) {
+        if (this.slots[i].id === item.id) {
+          this.slots.splice(i, 1);
+          break;
+        }
+      }
+      item.onLoadEnd(item);
+    }
+    this.checkSlots();
+  }
+
+  private checkSlots() {
+    while (
+      (this.slots.length < this.maximumSlotsNumber ||
+        this.maximumSlotsNumber === -1) &&
+      this.queue.length
+    ) {
+      this.slots.push(this.queue.shift() as LoadArgsTmp);
+      const slot: LoadArgsTmp = this.slots[
+        this.slots.length - 1
+      ] as LoadArgsTmp;
+      if (slot.useXhr) {
+        slot.xhr?.open('GET', slot.path, true);
+        slot.xhr?.send(null);
+      } else {
+        if (slot.img) {
+          slot.img.src = slot.path;
+        }
+      }
+    }
+
+    if (
+      this.slots.length === 0 &&
+      this.queue.length === 0 &&
+      this._whenDone !== undefined
+    ) {
+      this._whenDone();
+    }
+  }
+
+  /**
+   * get Item By id for interaction with files in this.queue
+   * @param id
+   * @private
+   */
+  private getById(id: string): LoadArgs | null {
+    for (let i = 0, len = this.queue.length; i < len; i += 1) {
+      if (this.queue[i].id === id) {
+        return this.queue[i];
+      }
+    }
+    return null;
+  }
+
+  private getXmlHttp(): XMLHttpRequest {
+    let xhr = null;
+    try {
+      xhr = new XMLHttpRequest();
+      xhr.responseType = 'blob';
+    } catch (e) {
+      console.warn(e);
+    }
+
+    return xhr as any;
+  }
+}

package/src/lib/helpers/KeyboardNumericCode.ts

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

package/src/lib/helpers/debounce.ts

@@ -0,0 +1,10 @@
+export const debounce = <T extends (...args: any[]) => any>(
+  fn: T,
+  ms = 300,
+) => {
+  let timeoutId: ReturnType<typeof setTimeout>;
+  return function (this: any, ...args: any[]) {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn.apply(this, args), ms);
+  };
+};

package/src/lib/helpers/generate-uuid.ts

@@ -0,0 +1,5 @@
+import { v4 as uuidv4 } from 'uuid';
+
+export function generateUuid() {
+  return uuidv4();
+}

package/{lib/helpers/index.d.ts → src/lib/helpers/index.ts}

@@ -7,3 +7,4 @@ export * from './sleep';
 export * from './trimLastSlashFromUrl';
 export * from './signal';
 export * from './generate-uuid';
+export * from './short-hash';

package/src/lib/helpers/save-to-local-drive.ts

@@ -0,0 +1,31 @@
+export const saveToLocalDrive = (uri: string, name: string) => {
+  if (!uri) {
+    return;
+  }
+
+  if ((navigator as any).msSaveBlob) {
+    // IE10+
+    try {
+      return (navigator as any).msSaveBlob(uri, name);
+    } catch (e) {
+      console.warn(e);
+    }
+  } else {
+    const link = document.createElement('a');
+    link.target = '_blank';
+    link.href = uri;
+    link.download = name;
+
+    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);
+  }
+};

package/src/lib/helpers/serialize.ts

@@ -0,0 +1,11 @@
+export function serialize(obj: any): string {
+  const str = [];
+
+  for (const p in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, p)) {
+      str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));
+    }
+  }
+
+  return str.join('&');
+}

package/src/lib/helpers/short-hash.ts

@@ -0,0 +1,20 @@
+import { Md5 } from 'ts-md5';
+
+export function shortHash<T>(data: T, shorten?: boolean): string;
+export function shortHash(data: null | undefined, shorten?: boolean): null;
+export function shortHash<T>(
+  data: T | null | undefined,
+  shorten = true,
+): string | null {
+  if (!data) {
+    return null;
+  }
+
+  const stringify: string = Md5.hashStr(JSON.stringify(data));
+
+  if (shorten) {
+    return parseInt('0x' + stringify.substring(0, 10), 16).toString(32);
+  }
+
+  return stringify;
+}