@3dsource/utils 0.0.1

package/README.md

@@ -0,0 +1,64 @@
+# Utils
+
+This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 19.2.0.
+
+## Code scaffolding
+
+Angular CLI includes powerful code scaffolding tools. To generate a new component, run:
+
+```bash
+ng generate component component-name
+```
+
+For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:
+
+```bash
+ng generate --help
+```
+
+## Building
+
+To build the library, run:
+
+```bash
+ng build utils
+```
+
+This command will compile your project, and the build artifacts will be placed in the `dist/` directory.
+
+### Publishing the Library
+
+Once the project is built, you can publish your library by following these steps:
+
+1. Navigate to the `dist` directory:
+
+   ```bash
+   cd dist/utils
+   ```
+
+2. Run the `npm publish` command to publish your library to the npm registry:
+   ```bash
+   npm publish
+   ```
+
+## Running unit tests
+
+To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:
+
+```bash
+ng test
+```
+
+## Running end-to-end tests
+
+For end-to-end (e2e) testing, run:
+
+```bash
+ng e2e
+```
+
+Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.
+
+## Additional Resources
+
+For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

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

@@ -0,0 +1,11 @@
+{
+  "name": "@3dsource/utils",
+  "version": "0.0.1",
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "rxjs": "^7.8.2"
+  }
+}

package/src/lib/color/CMYKtoRGB.ts

@@ -0,0 +1,20 @@
+/**
+ * RGB from each of the CMYK values to determine a return as an any[].
+ * CMYK values are as follows.
+ * C - a number between 0 and 255 representing cyan
+ * M - number between 0 and 255 representing magenta
+ * Y - number between 0 and 255 representing yellow
+ * K - number between 0 and 255 representing black
+ *
+ **/
+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/src/lib/color/RGBtoCMYK.ts

@@ -0,0 +1,50 @@
+/**
+ * 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
+ *
+ * CMYK values are as follows.
+ * C - a number between 0 and 255 representing cyan
+ * M - number between 0 and 255 representing magenta
+ * Y - number between 0 and 255 representing yellow
+ * K - number between 0 and 255 representing black
+ *
+ * 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 CMYK values into an any[] of [H, S, V]
+ **/
+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/index.ts

@@ -0,0 +1,16 @@
+export * from './CMYKtoRGB';
+export * from './HEXtoRGB';
+export * from './hsv';
+export * from './HSVtoRGB';
+export * from './max';
+export * from './min';
+export * from './overlay';
+export * from './rgb';
+export * from './RGBtoCMYK';
+export * from './RGBtoHEX';
+export * from './RGBtoHSV';
+export * from './sub';
+export * from './subtract';
+export * from './sum';
+export * from './toRGB';
+export * from './toRGBA';

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/src/lib/color/rgb.ts

@@ -0,0 +1,10 @@
+/**
+ *  Values calculated from each RGB * RGB color value.
+ * @ Param r the red (R) indicating the number (0-255)
+ * @ Param g green (G) indicates the number (0-255)
+ * @ Param b blue (B) shows the number (0-255)
+ * @ Return obtained from the RGB color value for each indicating the 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/src/lib/color/toRGB.ts

@@ -0,0 +1,14 @@
+/**
+ * RGB figures show (0x000000 0xFFFFFF up from) the
+ * R, G, B returns an any[] divided into a number from 0 to 255, respectively.
+ *
+ * @ Param rgb numbers show (0x000000 0xFFFFFF up from)
+ * @ Return any[] indicates the value of each color [R, G, B]
+ **/
+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/constants/index.ts

@@ -0,0 +1 @@
+export * from './color-codes.constant';

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;
+}