@3dsource/utils 0.0.1

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/csv/index.ts

@@ -0,0 +1,3 @@
+export * from './CSV2Array';
+export * from './CSV2Records';
+export * from './ObjectToCSV';

package/src/lib/csv/test/Csv.spec.ts

@@ -0,0 +1,51 @@
+import { CSV2Records } from '@utils/csv/CSV2Records';
+
+function generateMockCSV() {
+  const headers = '"name","age","isStudent"\n';
+  const mockData = [
+    { name: 'Alice Johnson', age: 22, isStudent: true },
+    { name: 'Bob Smith', age: 28, isStudent: false },
+    { name: 'Charlie Brown', age: 19, isStudent: true },
+  ];
+
+  const rows = mockData
+    .map((record) => `"${record.name}","${record.age}","${record.isStudent}"`)
+    .join('\n');
+
+  return headers + rows;
+}
+
+describe('CSV2Records with mocked data', () => {
+  let csv: string;
+
+  beforeEach(() => {
+    csv = generateMockCSV();
+  });
+
+  it('should convert generated CSV to records correctly', () => {
+    const result = CSV2Records(csv, 0);
+    expect(result).toEqual([
+      { name: 'Alice Johnson', age: 22, isStudent: true },
+      { name: 'Bob Smith', age: 28, isStudent: false },
+      { name: 'Charlie Brown', age: 19, isStudent: true },
+    ]);
+  });
+
+  it('should correctly parse each field from the mock CSV', () => {
+    const result = CSV2Records(csv, 0);
+    expect(result.length).toBe(3);
+
+    // Verify individual properties directly
+    expect(result[0].name).toEqual('Alice Johnson');
+    expect(result[0].age).toEqual(22);
+    expect(result[0].isStudent).toEqual(true);
+
+    expect(result[1].name).toEqual('Bob Smith');
+    expect(result[1].age).toEqual(28);
+    expect(result[1].isStudent).toEqual(false);
+
+    expect(result[2].name).toEqual('Charlie Brown');
+    expect(result[2].age).toEqual(19);
+    expect(result[2].isStudent).toEqual(true);
+  });
+});

package/src/lib/dev/dev3d.ts

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

package/src/lib/dev/index.ts

@@ -0,0 +1,3 @@
+export * from './dev3d';
+export * from './logger';
+export * from './timeToString';

package/src/lib/dev/logger.ts

@@ -0,0 +1,94 @@
+import { timeUTCToString } from './timeToString';
+import { Truthy } from '../predicates/BooleanPredictors';
+
+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/index.ts

@@ -0,0 +1,3 @@
+export * from './cleanupFileName';
+export * from './makePath';
+export * from './normalizePath';

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/filenaming/test/cleanupFileName.spec.ts

@@ -0,0 +1,9 @@
+import { cleanupFileName } from '@shared/utils/filenaming/cleanupFileName';
+
+xdescribe('cleanupFileName', () => {
+  it('should pass', () => {
+    expect(
+      cleanupFileName('T__e*8\\//s!`~"\'-_test =;$%^any word&():,@#{t}e.r'),
+    ).toEqual('t_e_8_-s_-_test_any_word_t_e.r');
+  });
+});

package/src/lib/filenaming/test/makePath.spec.ts

@@ -0,0 +1,7 @@
+import { makePath } from '@shared/utils/filenaming/makePath';
+
+xdescribe('makePath', () => {
+  it('should pass', () => {
+    expect(makePath('$a', '&b', 'c.png')).toEqual('a/b/c.png');
+  });
+});

package/src/lib/filenaming/test/normalizePath.spec.ts

@@ -0,0 +1,9 @@
+import { normalizePath } from '@shared/utils/filenaming/normalizePath';
+
+xdescribe('normalizePath', () => {
+  it('should pass', () => {
+    expect(normalizePath('test//test2\\test3\test4')).toEqual(
+      'test/test2/test3_est4',
+    );
+  });
+});

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/src/lib/geom/index.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './expandOverRectangle';
+export * from './fitIntoRectangle';

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

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

package/src/lib/geom/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from './area.interface';
+export * from './rect.interface';
+export * from './size.interface';
+export * from './сoords.interface';

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

@@ -0,0 +1,4 @@
+import type { Size } from './size.interface';
+import type { Coords } from './сoords.interface';
+
+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/geom/test/fitRectangle.spec.ts

@@ -0,0 +1,54 @@
+import { fitIntoRectangle } from '@shared/utils/geom/fitIntoRectangle';
+
+xdescribe('fitRectangle', () => {
+  it('should pass', () => {
+    expect(
+      fitIntoRectangle(
+        { x: 0, y: 0, w: 100, h: 100 },
+        { x: 0, y: 0, w: 200, h: 150 },
+      ),
+    ).toEqual({ x: 25, y: 0, w: 150, h: 150, scale: 2 });
+    expect(
+      fitIntoRectangle(
+        { x: 0, y: 0, w: 100, h: 100 },
+        { x: 0, y: 0, w: 50, h: 150 },
+      ),
+    ).toEqual({ x: 0, y: 50, w: 50, h: 50, scale: 0.5 });
+    expect(
+      fitIntoRectangle(
+        { x: 0, y: 0, w: 100, h: 100 },
+        { x: 0, y: 0, w: 150, h: 150 },
+      ),
+    ).toEqual({ x: 0, y: 0, w: 150, h: 150, scale: 1.5 });
+    expect(
+      fitIntoRectangle(
+        { x: 0, y: 0, w: 200, h: 200 },
+        { x: 0, y: 0, w: 150, h: 150 },
+      ),
+    ).toEqual({ x: 0, y: 0, w: 150, h: 150, scale: 0.75 });
+    expect(
+      fitIntoRectangle(
+        { x: 0, y: 0, w: 200, h: 200 },
+        { x: 10, y: 10, w: 150, h: 150 },
+      ),
+    ).toEqual({
+      x: 10,
+      y: 10,
+      w: 150,
+      h: 150,
+      scale: 0.75,
+    });
+    expect(
+      fitIntoRectangle(
+        { x: 0, y: 0, w: 200, h: 300 },
+        { x: 10, y: 10, w: 210, h: 150 },
+      ),
+    ).toEqual({
+      x: 65,
+      y: 10,
+      w: 100,
+      h: 150,
+      scale: 1.05,
+    });
+  });
+});