@3dsource/utils 1.0.8 → 1.0.10

package/eslint.config.js

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

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

package/package.json

@@ -1,22 +1,13 @@
 {
   "name": "@3dsource/utils",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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"
-    }
+    "rxjs": "^7.8.2",
+    "uuid": "^11.1.0",
+    "ts-md5": "^1.3.1"
   }
-}
+}

package/{lib/color/CMYKtoRGB.d.ts → src/lib/color/CMYKtoRGB.ts}

@@ -7,4 +7,14 @@
  * K - number between 0 and 255 representing black
  *
  **/
-export declare function CMYKtoRGB(c: number, m: number, y: number, k: number): any[];
+export function CMYKtoRGB(c: number, m: number, y: number, k: number): any[] {
+  c = 255 - c;
+  m = 255 - m;
+  y = 255 - y;
+  k = 255 - k;
+  return [
+    ((255 - c) * (255 - k)) / 255,
+    ((255 - m) * (255 - k)) / 255,
+    ((255 - y) * (255 - k)) / 255,
+  ];
+}

package/src/lib/color/HEXtoRGB.ts

@@ -0,0 +1,9 @@
+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 };
+}

package/src/lib/color/HSVtoRGB.ts

@@ -0,0 +1,82 @@
+/* eslint-disable prefer-const */
+/**
+ * HSV from each of the RGB values to determine a return as an any[].
+ * RGB values are as follows.
+ * R - a number from 0 to 255
+ * G - a number from 0 to 255
+ * B - a number from 0 to 255
+ *
+ * HSV values are as follows.
+ * H - a number between 360-0
+ * S - number between 0 and 1.0
+ * V - number between 0 and 1.0
+ *
+ * H is replaced with equivalent numbers in the range of the 360-0 that is out of range.
+ * Cannot compute, including alpha.
+ *
+ * @ Param h hue (Hue) number that indicates (to 360-0)
+ * @ Param s the saturation (Saturation) shows the number (0.0 to 1.0)
+ * @ Param v lightness (Value) indicates the number (0.0 to 1.0)
+ * @ Return RGB values into an any[] of [R, G, B]
+ **/
+
+export function HSVtoRGB(h: number, s: number, v: number): number[] {
+  let r = 0,
+    g = 0,
+    b = 0;
+  let i, x, y, z;
+  if (s < 0) {
+    s = 0;
+  }
+  if (s > 1) {
+    s = 1;
+  }
+  if (v < 0) {
+    v = 0;
+  }
+  if (v > 1) {
+    v = 1;
+  }
+  h = h % 360;
+  if (h < 0) {
+    h += 360;
+  }
+  h /= 60;
+  i = h >> 0;
+  x = v * (1 - s);
+  y = v * (1 - s * (h - i));
+  z = v * (1 - s * (1 - h + i));
+  switch (i) {
+    case 0:
+      r = v;
+      g = z;
+      b = x;
+      break;
+    case 1:
+      r = y;
+      g = v;
+      b = x;
+      break;
+    case 2:
+      r = x;
+      g = v;
+      b = z;
+      break;
+    case 3:
+      r = x;
+      g = y;
+      b = v;
+      break;
+    case 4:
+      r = z;
+      g = x;
+      b = v;
+      break;
+    case 5:
+      r = v;
+      g = x;
+      b = y;
+      break;
+  }
+  return [(r * 255) >> 0, (g * 255) >> 0, (b * 255) >> 0];
+}

package/{lib/color/RGBtoCMYK.d.ts → src/lib/color/RGBtoCMYK.ts}

@@ -17,4 +17,34 @@
  * @ Param b blue (B) shows the number (0x00 to 0xFF to)
  * @ Return CMYK values into an any[] of [H, S, V]
  **/
-export declare function RGBtoCMYK(r: number, g: number, b: number): any[];
+export function RGBtoCMYK(r: number, g: number, b: number): any[] {
+  let c = 0;
+  let m = 0;
+  let y = 0;
+  let k = 0;
+
+  c = 255 - r;
+  m = 255 - g;
+  y = 255 - b;
+  k = 255;
+
+  if (c < k) {
+    k = c;
+  }
+  if (m < k) {
+    k = m;
+  }
+  if (y < k) {
+    k = y;
+  }
+  if (k === 255) {
+    c = 0;
+    m = 0;
+    y = 0;
+  } else {
+    c = Math.round((255 * (c - k)) / (255 - k));
+    m = Math.round((255 * (m - k)) / (255 - k));
+    y = Math.round((255 * (y - k)) / (255 - k));
+  }
+  return [c, m, y, k];
+}

package/src/lib/color/RGBtoHEX.ts

@@ -0,0 +1,17 @@
+export function RGBtoHEX(r: number, g: number, b: number): string {
+  let redColor = r.toString(16);
+  let greenColor = g.toString(16);
+  let blackColor = b.toString(16);
+
+  if (redColor.length === 1) {
+    redColor = '0' + redColor;
+  }
+  if (greenColor.length === 1) {
+    greenColor = '0' + greenColor;
+  }
+  if (blackColor.length === 1) {
+    blackColor = '0' + blackColor;
+  }
+
+  return (redColor + greenColor + blackColor).toUpperCase();
+}

package/src/lib/color/RGBtoHSV.ts

@@ -0,0 +1,53 @@
+/**
+ * RGB from the respective figures, HSV sequences in terms of returns.
+ * RGB values are as follows.
+ * R - a number from 0 to 255
+ * G - a number from 0 to 255
+ * B - a number from 0 to 255
+ *
+ * HSV values are as follows.
+ * H - a number between 360-0
+ * S - number between 0 and 1.0
+ * V - number between 0 and 1.0
+ *
+ * Cannot compute, including alpha.
+ * @ Param r the red (R) indicating the number (0x00 to 0xFF to)
+ * @ Param g green (G) indicates the number (0x00 to 0xFF to)
+ * @ Param b blue (B) shows the number (0x00 to 0xFF to)
+ * @ Return HSV values into an any[] of [H, S, V]
+ **/
+export function RGBtoHSV(r: number, g: number, b: number): number[] {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  let h = 0,
+    s = 0,
+    v = 0;
+  let x: number, y: number;
+  if (r >= g) x = r;
+  else x = g;
+  if (b > x) x = b;
+  if (r <= g) y = r;
+  else y = g;
+  if (b < y) y = b;
+  v = x;
+  const c: number = x - y;
+  if (x === 0) s = 0;
+  else s = c / x;
+  if (s !== 0) {
+    if (r === x) {
+      h = (g - b) / c;
+    } else {
+      if (g === x) {
+        h = 2 + (b - r) / c;
+      } else {
+        if (b === x) {
+          h = 4 + (r - g) / c;
+        }
+      }
+    }
+    h = h * 60;
+    if (h < 0) h = h + 360;
+  }
+  return [h, s, v];
+}

package/src/lib/color/hsv.ts

@@ -0,0 +1,14 @@
+/* eslint-disable prefer-spread */
+/**
+ * HSV calculated from the numbers of each RGB color value.
+ * @ Param h hue (Hue) number that indicates (to 360-0)
+ * @ Param s the saturation (Saturation) shows the number (0.0 to 1.0)
+ * @ Param v lightness (Value) indicates the number (0.0 to 1.0)
+ * @ Return obtained from the RGB color value for each indicating the number
+ **/
+import { rgb } from './rgb';
+import { HSVtoRGB } from './HSVtoRGB';
+
+export function hsv(h: number, s: number, v: number): number {
+  return rgb.apply(null, HSVtoRGB(h, s, v) as any);
+}

package/src/lib/color/max.ts

@@ -0,0 +1,18 @@
+/**
+ * Comparison (light).
+ * 2 RGB single number that indicates (0x000000 0xFFFFFF up from) to compare,
+ * RGB values combined with higher returns to their numbers.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return comparison (light) value
+ **/
+import { toRGB } from './toRGB';
+
+export function max(col1: number, col2: number): number {
+  const c1: any[] = toRGB(col1);
+  const c2: any[] = toRGB(col2);
+  const r: number = Math.max(c1[0], c2[0]);
+  const g: number = Math.max(c1[1], c2[1]);
+  const b: number = Math.max(c1[2], c2[2]);
+  return (r << 16) | (g << 8) | b;
+}

package/src/lib/color/min.ts

@@ -0,0 +1,18 @@
+/**
+ * Comparison (dark).
+ * 2 RGB single numbers that indicate (0x000000 0xFFFFFF up from) to compare,
+ * RGB lower combined returns a numeric value for each number.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return comparison (dark) values
+ **/
+import { toRGB } from './toRGB';
+
+export function min(col1: number, col2: number): number {
+  const c1: any[] = toRGB(col1);
+  const c2: any[] = toRGB(col2);
+  const r: number = Math.min(c1[0], c2[0]);
+  const g: number = Math.min(c1[1], c2[1]);
+  const b: number = Math.min(c1[2], c2[2]);
+  return (r << 16) | (g << 8) | b;
+}

package/src/lib/color/overlay.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ There are two part of formula:
+ First part: If Lower Layer Value > 127.5, then do the following -
+ Value Unit = (255-Lower Layer Value)/127.5
+ Min Value = Lower Layer Value - (255-Lower Layer Value)
+ Overlay = (Upper Layer Value * Value Unit) + Min Value
+ Second part: If Lower Layer Value < 127.5, then do the following -
+ Value Unit=Lower Layer Value/127.5
+
+ Overlay = Upper Layer Value * Value Unit
+ * @param {number} col1
+ * @param {number} col2
+ * @return {number}
+ */
+import { toRGB } from './toRGB';
+
+export function overlay(col1: number, col2: number): number {
+  const c1: any[] = toRGB(col1);
+  const c2: any[] = toRGB(col2);
+  const r: number = Math.max(c1[0], c2[0]);
+  const g: number = Math.max(c1[1], c2[1]);
+  const b: number = Math.max(c1[2], c2[2]);
+  return (r << 16) | (g << 8) | b;
+}

package/{lib/color/rgb.d.ts → src/lib/color/rgb.ts}

@@ -5,4 +5,6 @@
  * @ Param b blue (B) shows the number (0-255)
  * @ Return obtained from the RGB color value for each indicating the number
  **/
-export declare function rgb(r: number, g: number, b: number): number;
+export function rgb(r: number, g: number, b: number): number {
+  return (r << 16) | (g << 8) | b;
+}

package/src/lib/color/sub.ts

@@ -0,0 +1,18 @@
+/**
+ * Subtractive.
+ * 2 RGB single numbers that indicate (0x000000 0xFFFFFF up from) Return the value
+ * of the subtractive color.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return the subtractive
+ **/
+import { toRGB } from './toRGB';
+
+export function sub(col1: number, col2: number): number {
+  const c1: any[] = toRGB(col1);
+  const c2: any[] = toRGB(col2);
+  const r: number = Math.max(c1[0] - c2[0], 0);
+  const g: number = Math.max(c1[1] - c2[1], 0);
+  const b: number = Math.max(c1[2] - c2[2], 0);
+  return (r << 16) | (g << 8) | b;
+}

package/src/lib/color/subtract.ts

@@ -0,0 +1,27 @@
+/**
+ * Subtraction.
+ * 2 RGB single number that indicates (0x000000 0xFFFFFF up from) is subtracted
+ * from the return numbers.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return value subtracted Blend
+ **/
+import { toRGB } from './toRGB';
+
+export function subtract(col1: number, col2: number): number {
+  const colA: any[] = toRGB(col1);
+  const colB: any[] = toRGB(col2);
+  const r: number = Math.max(
+    Math.max(colB[0] - (256 - colA[0]), colA[0] - (256 - colB[0])),
+    0,
+  );
+  const g: number = Math.max(
+    Math.max(colB[1] - (256 - colA[1]), colA[1] - (256 - colB[1])),
+    0,
+  );
+  const b: number = Math.max(
+    Math.max(colB[2] - (256 - colA[2]), colA[2] - (256 - colB[2])),
+    0,
+  );
+  return (r << 16) | (g << 8) | b;
+}

package/src/lib/color/sum.ts

@@ -0,0 +1,19 @@
+/**
+ * Additive color.
+ * 2 RGB single numbers that indicate (0x000000 0xFFFFFF up from) Return the value
+ * of the additive mixture.
+ * @ Param col1 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Param col2 RGB numbers show (0x000000 0xFFFFFF up from)
+ * @ Return the additive color
+ **/
+import { toRGB } from './toRGB';
+
+export function sum(col1: number, col2: number): number {
+  const c1: any[] = toRGB(col1);
+  const c2: any[] = toRGB(col2);
+  const r: number = Math.min(c1[0] + c2[0], 255);
+  const g: number = Math.min(c1[1] + c2[1], 255);
+  const b: number = Math.min(c1[2] + c2[2], 255);
+
+  return (r << 16) | (g << 8) | b;
+}

package/{lib/color/toRGB.d.ts → src/lib/color/toRGB.ts}

@@ -5,4 +5,10 @@
  * @ Param rgb numbers show (0x000000 0xFFFFFF up from)
  * @ Return any[] indicates the value of each color [R, G, B]
  **/
-export declare function toRGB(rgb: number): number[];
+export function toRGB(rgb: number): number[] {
+  const r: number = (rgb >> 16) & 0xff;
+  const g: number = (rgb >> 8) & 0xff;
+  const b: number = rgb & 0xff;
+
+  return [r, g, b];
+}

package/src/lib/color/toRGBA.ts

@@ -0,0 +1,8 @@
+export function toRGBA(rgba: number): number[] {
+  const a: number = (rgba >> 24) & 0xff;
+  const r: number = (rgba >> 16) & 0xff;
+  const g: number = (rgba >> 8) & 0xff;
+  const b: number = rgba & 0xff;
+
+  return [r, g, b, a];
+}

package/src/lib/constants/color-codes.constant.ts

@@ -0,0 +1,9 @@
+export const COLOR_CODES = {
+  TO_UNREAL: ['#ffffff', '#005912', `UNREAL <-`],
+  TAP_LOG: ['#ffff00', '#1976d2', ' [TAPLOG]'],
+  FROM_UNREAL: ['#ffff00', '#898989', 'UNREAL ->'],
+  FROM_UNREAL_ERROR: ['#ffffff', '#ff0000', 'UNREAL ERROR ->'],
+  FROM_CIRRUS: ['#ffffff', '#ef702b', 'CIRRUS ->'],
+  FROM_CIRRUS_ERROR: ['#ffffff', '#ff0000', 'CIRRUS ->'],
+  TO_CIRRUS: ['#ffffff', '#3c9738', 'CIRRUS <-'],
+} as const;

package/src/lib/csv/CSV2Array.ts

@@ -0,0 +1,66 @@
+export function CSV2Array(strData: any, strDelimiter?: string): any[] {
+  // Check to see if the delimiter is defined. If not,
+  // then default to comma.
+  strDelimiter = strDelimiter || ',';
+
+  // Create a regular expression to parse the CSV values.
+  const objPattern = new RegExp(
+    // Delimiters.
+    '(\\' +
+      strDelimiter +
+      '|\\r?\\n|\\r|^)' +
+      // Quoted fields.
+      '(?:"([^"]*(?:""[^"]*)*)"|' +
+      // Standard fields.
+      '([^"\\' +
+      strDelimiter +
+      '\\r\\n]*))',
+    'gi',
+  );
+
+  // Create an array to hold our data. Give the array
+  // a default empty first row.
+  const arrData: any[] = [[]];
+
+  // Create an array to hold our individual pattern
+  // matching groups.
+  let arrMatches = null;
+
+  // Keep looping over the regular expression matches
+  // until we can no longer find a match.
+  while ((arrMatches = objPattern.exec(strData))) {
+    // Get the delimiter that was found.
+    const strMatchedDelimiter = arrMatches[1];
+
+    // Check to see if the given delimiter has a length
+    // (is not the start of string) and if it matches
+    // field delimiter. If idKey does not, then we know
+    // that this delimiter is a row delimiter.
+    if (strMatchedDelimiter.length && strMatchedDelimiter !== strDelimiter) {
+      // Since we have reached a new row of data,
+      // add an empty row to our data array.
+      arrData.push([]);
+    }
+
+    let strMatchedValue: any;
+
+    // Now that we have our delimiter out of the way,
+    // let's check to see which kind of value we
+    // captured (quoted or unquoted).
+    if (arrMatches[2]) {
+      // We found a quoted value. When we capture
+      // this value, unescape any double quotes.
+      strMatchedValue = arrMatches[2].replace(new RegExp('""', 'g'), '"');
+    } else {
+      // We found a non-quoted value.
+      strMatchedValue = arrMatches[3];
+    }
+
+    // Now that we have our value string, let's add
+    // it to the data array.
+    arrData[arrData.length - 1].push(strMatchedValue);
+  }
+
+  // Return the parsed data.
+  return arrData;
+}

package/src/lib/csv/CSV2Records.ts

@@ -0,0 +1,56 @@
+import { CSV2Array } from './CSV2Array';
+
+const booleanRegex = /^(true|false)$/i;
+const trueRegex = /^(true)$/i;
+const jsonRegex = /([\d.]+)|(\[])|(\[.+])|({.+})/i;
+
+const zipObject = (props: string[], values: any[]) =>
+  props.reduce(
+    (obj: any, prop, index) => ((obj[prop] = values[index]), obj),
+    {},
+  );
+
+const toHead = (input: any): string => {
+  return String(input).trim();
+};
+
+const toCorrectString = (input: any): any => {
+  if (typeof input === 'string') {
+    if (input.match(jsonRegex)) {
+      // optimization for use try-catch only after regex match. much faster than without regex
+      try {
+        return JSON.parse(input);
+      } catch {
+        /* empty */
+      }
+    }
+    if (input.match(booleanRegex)) {
+      return !!input.match(trueRegex);
+    }
+    return input.trim();
+  } else if (typeof input === 'number') {
+    return input;
+  }
+};
+
+export function CSV2Records(
+  csv: string,
+  useRowAsHead = 0,
+  strDelimiter?: string,
+): any {
+  const arr = CSV2Array(csv, strDelimiter);
+  const total = arr.length;
+  const keys = arr[useRowAsHead].map(toHead);
+  const data: any[] = [];
+
+  let tmpSKU = 0;
+
+  for (let i = useRowAsHead + 1; i < total; i++) {
+    const obj = zipObject(keys, arr[i].map(toCorrectString));
+    data.push(obj);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    tmpSKU++;
+  }
+
+  return data.filter(Boolean);
+}

package/src/lib/csv/ObjectToCSV.ts

@@ -0,0 +1,21 @@
+export function ObjectToCSV<T extends object>(records: T[]) {
+  if (records.length === 0) {
+    return;
+  }
+
+  const uniqueFields = Array.from(
+    records.reduce((fields, record) => {
+      Object.keys(record).forEach((field: string) => fields.add(field));
+      return fields;
+    }, new Set<string>()),
+  );
+
+  const csvHeader = uniqueFields.join(',') + '\n';
+  const csvRows = records
+    .map((record: any) =>
+      uniqueFields.map((field: any) => `"${record[field] || ''}"`).join(','),
+    )
+    .join('\n');
+
+  return csvHeader + csvRows;
+}

package/src/lib/dev/dev3d.ts

@@ -0,0 +1 @@
+export const isLocalhost = !!window.location.href.match(/localhost/gi);