@3dsource/utils 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@3dsource/utils",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "sideEffects": false,
   "dependencies": {
     "tslib": "^2.8.1"

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

@@ -1,51 +0,0 @@
-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/filenaming/test/cleanupFileName.spec.ts

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

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

@@ -1,9 +0,0 @@
-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/test/fitRectangle.spec.ts

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

package/src/lib/helpers/test/sleep.spec.ts

@@ -1,11 +0,0 @@
-import { sleep } from '@shared/utils/helpers/sleep';
-
-describe('sleep', () => {
-  it('should wait 100 msec', async () => {
-    const time = new Date().getTime();
-    await sleep(100);
-    const diff = (new Date().getTime() - time) / 100;
-
-    expect(diff).toBeCloseTo(1.01, 1);
-  });
-});

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/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' },
-    ]);
-  });
-});