@verisoft/core 20.0.0 → 20.1.0

package/src/lib/utils/array.utils.ts

@@ -0,0 +1,54 @@
+import { Sort } from "../models";
+import { getValueByPath } from "./object.utils";
+
+type ArrayIntersectionType = (string | number)[]
+
+export function isArrayIntersected(
+  array1: ArrayIntersectionType,
+  array2: ArrayIntersectionType,
+) {
+  const filteredArray = array1.filter(value => array2.includes(value));
+  return filteredArray.length > 0;
+}
+
+export function multiSort<T>(values: T[], sorts: Sort[]): T[] {
+  return [...values].sort((a, b) => {
+    for (const sort of sorts) {
+      const { field, direction } = sort;
+      const valueA = getValueByPath(a, field);
+      const valueB = getValueByPath(b, field);
+
+      if (valueA !== valueB) {
+        if (isComparable(valueA) && isComparable(valueB)) {
+          if (typeof valueA === 'string' && typeof valueB === 'string') {
+            const baseCompare = valueA.localeCompare(valueB, undefined, {
+              sensitivity: 'base',
+            });
+
+            if (baseCompare === 0) {
+              return valueA < valueB ? -1 : valueA > valueB ? 1 : 0;
+            }
+
+            return direction === 'asc' ? baseCompare : -baseCompare;
+          } else {
+            if (valueA < valueB) {
+              return direction === 'asc' ? -1 : 1;
+            }
+            if (valueA > valueB) {
+              return direction === 'asc' ? 1 : -1;
+            }
+          }
+        }
+      }
+    }
+
+    return 0;
+  });
+}
+
+function isComparable(value: unknown): value is string | number | Date {
+  return typeof value === 'string'
+    || typeof value === 'number'
+    || typeof value === 'boolean'
+    || value instanceof Date;
+}

package/src/lib/utils/clear.utils.ts

@@ -0,0 +1,53 @@
+export class ClearUtils {
+
+  static recursiveObjectAttributesTransformation(obj: any): void {
+    ClearUtils.recursiveObjectAttributesTraversal(
+      obj,
+      ClearUtils.transformEmptyStringToNullStringFn
+    );
+  }
+  static recursiveObjectAttributesDeletation(obj: any): void {
+    ClearUtils.recursiveObjectAttributesTraversal(
+      obj,
+      ClearUtils.deleteEmptyStringToNullStringFn
+    );
+  }
+
+  static transformEmptyStringToNullStringFn(obj: any, key: string) {
+    if (typeof obj[key] === 'string' && obj[key] === '') {
+      obj[key] = null;
+    }
+  }
+  static deleteEmptyStringToNullStringFn(obj: any, key: string) {
+    if (obj[key] === '' || obj[key] === null || obj[key] === undefined) {
+      delete obj[key]
+    }
+  }
+
+
+  static recursiveObjectAttributesTraversal(
+    obj: any,
+    transformationFn: (obj: any, key: string) => void
+  ) {
+    if (
+      obj === null ||
+      transformationFn === null ||
+      typeof transformationFn !== 'function'
+    ) {
+      return;
+    }
+
+    Object.keys(obj).forEach((key) => {
+      transformationFn(obj, key);
+
+      if (typeof obj[key] === 'object') {
+        this.recursiveObjectAttributesTraversal(obj[key], transformationFn);
+
+        if (!Object.keys(obj[key]).length) {
+          delete obj[key];
+        }
+      }
+    });
+  }
+
+}

package/src/lib/utils/data.utils.ts

@@ -0,0 +1,34 @@
+import moment from 'moment';
+
+export function transformData(data: any) {
+  if (data) {
+    if (moment.isMoment(data)) {
+      return moment(data)
+        .toDate()
+        .toISOString();
+    }
+    else if (data instanceof Date) {
+      return data.toISOString();
+    }
+  }
+  return data;
+}
+
+export function convertToDate(data: any) {
+  if (data) {
+    if (!isNaN(Date.parse(data))) {
+      return new Date(data);
+    }
+  }
+  return data;
+}
+
+export function convertToDateTime(data: any) {
+  if (data) {
+    if (!isNaN(Date.parse(data))) {
+      const date = new Date(data);
+      return moment(date).format('DD.MM.yyyy HH:mm');
+    }
+  }
+  return data;
+}

package/src/lib/utils/date.utils.ts

@@ -0,0 +1,30 @@
+const czechDateFormat = new Intl.DateTimeFormat("cs-CZ", {
+  day: "numeric",
+  month: "numeric",
+  year: "numeric"
+});
+
+const czechDateTimeFormat = new Intl.DateTimeFormat("cs-CZ", {
+  second: "numeric",
+  minute: "numeric",
+  hour: "numeric",
+  day: "numeric",
+  month: "numeric",
+  year: "numeric"
+});
+
+export function toCzechDateTimeString(value?: Date | string, time = false): string {
+  if (!value) {
+    return "";
+  }
+
+  if (typeof value === "string") {
+    value = new Date(value);
+  }
+
+  if (time) {
+    return czechDateTimeFormat.format(value);
+  }
+
+  return czechDateFormat.format(value);
+}

package/src/lib/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './clear.utils';
+export * from './keyOrFn.utils';
+export * from './array.utils';
+export * from './data.utils';
+export * from './object.utils';
+export * from './date.utils';

package/src/lib/utils/keyOrFn.utils.ts

@@ -0,0 +1,15 @@
+export function keyOrFn(keyOrFn: ((row: any) => string | undefined) | string, row: any) {
+    if (keyOrFn instanceof Function) {
+        return keyOrFn(row);
+    }
+    else if (typeof keyOrFn === 'string') {
+        const value = row[keyOrFn];
+        if (value) {
+            return value;
+        }
+    }
+    else if (typeof keyOrFn === 'boolean') {
+      return keyOrFn;
+  }
+    return '';
+}

package/src/lib/utils/object.utils.spec.ts

@@ -0,0 +1,69 @@
+import { getValueByPath, sortBy } from './object.utils';
+
+describe('object.utils', () => {
+  describe('sortBy', () => {
+    const items = [
+      { name: undefined, age: 60 },
+      { name: 'Martin', age: 40 },
+      { name: 'Alena', age: 28 },
+      { name: 'Karel', age: 15 },
+    ];
+
+    test('Should sort items by name ascending.', () => {
+      const sortedItems = sortBy(items, (x) => x.name);
+
+      expect(items).not.toBe(sortedItems);
+      expect(sortedItems).toBeDefined();
+      expect(sortedItems?.[0].name).toBeUndefined();
+      expect(sortedItems?.[1].name).toBe('Alena');
+      expect(sortedItems?.[2].name).toBe('Karel');
+      expect(sortedItems?.[3].name).toBe('Martin');
+    });
+
+    test('Should sort items by name descending.', () => {
+      const sortedItems = sortBy(items, (x) => x.name, false);
+
+      expect(items).not.toBe(sortedItems);
+      expect(sortedItems).toBeDefined();
+      expect(sortedItems?.[0].name).toBe('Martin');
+      expect(sortedItems?.[1].name).toBe('Karel');
+      expect(sortedItems?.[2].name).toBe('Alena');
+      expect(sortedItems?.[3].name).toBeUndefined();
+    });
+  });
+
+  describe('getValueByPath', () => {
+    const complexObject = {
+      name: 'Martin',
+      age: 40,
+      address: {
+        city: 'Brno',
+        street: 'Kralova',
+      },
+    };
+
+    test('Should return property value when name of property is provided.', () => {
+      const value = getValueByPath(complexObject, 'name');
+
+      expect(value).toBe('Martin');
+    });
+
+    test('Should return undefined when name is nonexistent.', () => {
+      const value = getValueByPath(complexObject, 'nonexistentProperty');
+
+      expect(value).toBeUndefined();
+    });
+
+    test('Should return property value when name of property is complex path.', () => {
+      const value = getValueByPath(complexObject, 'address.city');
+
+      expect(value).toBe('Brno');
+    });
+
+    test('Should return undefined when some object on complex path missing.', () => {
+      const value = getValueByPath(complexObject, 'car.model');
+
+      expect(value).toBeUndefined();
+    });
+  });
+});

package/src/lib/utils/object.utils.ts

@@ -0,0 +1,47 @@
+export function sortBy<TEntity, TProperty>(
+  items: TEntity[],
+  selector: (item: TEntity) => TProperty,
+  ascending = true
+): TEntity[] {
+  return [...items].sort((item, other) => {
+    const value = selector(item);
+    const otherValue = selector(other);
+    const direction = ascending ? 1 : -1;
+    if (value == undefined && other == undefined) {
+      return 0;
+    }
+
+    if (value == undefined) {
+      return -1 * direction;
+    }
+    if (otherValue == undefined) {
+      return 1 * direction;
+    }
+
+    if (value < otherValue) {
+      return -1 * direction;
+    }
+
+    if (value > otherValue) {
+      return 1 * direction;
+    }
+
+    return 0;
+  });
+}
+
+export function getValueByPath<T, TValue>(
+  obj: T,
+  path: string | undefined,
+): TValue | undefined {
+  if (path == undefined || path == ''){
+    return obj as unknown as TValue;
+  }
+
+  return path.split('.').reduce((acc, key) => {
+    if (acc && typeof acc === 'object' && key in acc) {
+      return (acc as Record<string, TValue>)[key];
+    }
+    return undefined;
+  }, obj as unknown) as TValue;
+}

package/src/test-setup.ts

@@ -0,0 +1,8 @@
+// @ts-expect-error https://thymikee.github.io/jest-preset-angular/docs/getting-started/test-environment
+globalThis.ngJest = {
+  testEnvironmentOptions: {
+    errorOnUnknownElements: true,
+    errorOnUnknownProperties: true,
+  },
+};
+import 'jest-preset-angular/setup-jest';

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "useDefineForClassFields": false,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "extends": "../../../tsconfig.base.json",
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "src/**/*.spec.ts",
+    "src/test-setup.ts",
+    "jest.config.ts",
+    "src/**/*.test.ts"
+  ],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "commonjs",
+    "target": "es2016",
+    "types": ["jest", "node"]
+  },
+  "files": ["src/test-setup.ts"],
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}