@verisoft/core 20.1.1 → 20.1.3

package/index.d.ts

@@ -0,0 +1,135 @@
+import { HttpParams, HttpResponse, HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ValidationErrors } from '@angular/forms';
+
+interface EnvironmentConfig {
+    production: boolean;
+    apiUrl: string;
+    appVersion: string;
+}
+
+declare const BASE_URL_PATH: InjectionToken<string>;
+declare function requestParamsToHttpParams<T>(requestParams: Partial<RequestParams<T>>, httpParams?: HttpParams): HttpParams;
+declare function saveFile(response: HttpResponse<Blob>): void;
+declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+declare type SortDirectionType = keyof typeof SortDirection;
+declare interface Sort {
+    field: string;
+    direction: SortDirectionType;
+}
+interface RequestParams<T> extends AllDataRequestParams<T> {
+    offset: number;
+    limit: number;
+    id?: string;
+}
+interface AllDataRequestParams<T> {
+    filter?: Partial<T>;
+    sort?: Sort[];
+}
+interface Page<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface CustomExport<T> {
+    sortDefinition?: Sort;
+    filter?: Partial<T>;
+    columnsToExport: ColumnExportSpecification[];
+}
+interface ColumnExportSpecification {
+    name: string;
+    header: string;
+}
+declare const DEFAULT_SEARCH_LIMIT = 50;
+declare const DEFAULT_SEARCH_PARAMS: RequestParams<any>;
+declare function normalizeRequest<T>(request: Partial<RequestParams<T>>, minLimit?: number | undefined): RequestParams<T>;
+
+type LazyLoadEvent = RequestParams<unknown>;
+interface FilterEvent {
+    filter?: string;
+}
+
+declare const DEFAULT_PAGE_SIZE = 50;
+declare const DEFAULT_LAZYLOAD_OPTIONS: LazyLoadEvent;
+
+interface AllItemDatasource<T> {
+    getData$: () => Observable<T[]>;
+}
+
+declare class BaseHttpService<T, TKey = number | string> {
+    readonly http: HttpClient;
+    readonly basePath: string;
+    readonly entityName: string;
+    constructor(http: HttpClient, basePath: string, entityName: string);
+    protected get apiPath(): string;
+    fetchList(requestParams: RequestParams<T>): Observable<Page<T>>;
+    getData$(entityName: keyof T, searchTerm?: string | undefined, lazyLoad?: LazyLoadEvent): Observable<T[]>;
+    get(id: TKey): Observable<T>;
+    post(entity: Partial<T>): Observable<T>;
+    put(id: TKey, entity: Partial<T>): Observable<T>;
+    delete(id: TKey): Observable<T>;
+    export(requestParams: AllDataRequestParams<T>): Observable<Blob>;
+    removeRange(entity: string[]): Observable<Object>;
+    createParams<T>(requestParams: RequestParams<T>): any;
+    private createSorter;
+}
+
+type DatasourceType<T> = string | Observable<T[]> | Observable<Page<T>> | BaseHttpService<T> | T[] | Page<T> | AllItemDatasource<T>;
+type DataSourceFunctionType<T> = (requestParams: RequestParams<T>) => Observable<Page<T>>;
+declare function convertDatasource<T>(datasource: DatasourceType<T>, basePath: string, httpClient: HttpClient): DataSourceFunctionType<T>;
+
+interface ErrorProvider {
+    mapError(errors: ValidationErrors): Observable<string | undefined>;
+    errors: Record<string, (value?: any) => string>;
+}
+declare const ERROR_PROVIDER_TOKEN: InjectionToken<ErrorProvider>;
+declare enum CustomValidationCodes {
+}
+declare const ErrorMap: Record<string, (value?: any) => string>;
+
+declare class LocalStorageService {
+    setItem(key: string, value: string): void;
+    getItem(key: string): string | null;
+    removeItem(key: string): void;
+}
+
+declare class LocalizableErrorProviderService implements ErrorProvider {
+    private readonly translateService;
+    readonly errors: Record<string, (value?: any) => string>;
+    mapError(errors: ValidationErrors): Observable<string | undefined>;
+    private getFirstValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizableErrorProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalizableErrorProviderService>;
+}
+
+declare class ClearUtils {
+    static recursiveObjectAttributesTransformation(obj: any): void;
+    static recursiveObjectAttributesDeletation(obj: any): void;
+    static transformEmptyStringToNullStringFn(obj: any, key: string): void;
+    static deleteEmptyStringToNullStringFn(obj: any, key: string): void;
+    static recursiveObjectAttributesTraversal(obj: any, transformationFn: (obj: any, key: string) => void): void;
+}
+
+declare function keyOrFn(keyOrFn: ((row: any) => string | undefined) | string, row: any): any;
+
+type ArrayIntersectionType = (string | number)[];
+declare function isArrayIntersected(array1: ArrayIntersectionType, array2: ArrayIntersectionType): boolean;
+declare function multiSort<T>(values: T[], sorts: Sort[]): T[];
+
+declare function transformData(data: any): any;
+declare function convertToDate(data: any): any;
+declare function convertToDateTime(data: any): any;
+
+declare function sortBy<TEntity, TProperty>(items: TEntity[], selector: (item: TEntity) => TProperty, ascending?: boolean): TEntity[];
+declare function getValueByPath<T, TValue>(obj: T, path: string | undefined): TValue | undefined;
+
+declare function toCzechDateTimeString(value?: Date | string, time?: boolean): string;
+
+export { BASE_URL_PATH, BaseHttpService, ClearUtils, CustomValidationCodes, DEFAULT_LAZYLOAD_OPTIONS, DEFAULT_PAGE_SIZE, DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_PARAMS, ERROR_PROVIDER_TOKEN, ErrorMap, LocalStorageService, LocalizableErrorProviderService, SortDirection, convertDatasource, convertToDate, convertToDateTime, getValueByPath, isArrayIntersected, keyOrFn, multiSort, normalizeRequest, requestParamsToHttpParams, saveFile, sortBy, toCzechDateTimeString, transformData };
+export type { AllDataRequestParams, AllItemDatasource, ColumnExportSpecification, CustomExport, DataSourceFunctionType, DatasourceType, EnvironmentConfig, ErrorProvider, FilterEvent, LazyLoadEvent, Page, RequestParams, Sort, SortDirectionType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verisoft/core",
-  "version": "20.1.1",
+  "version": "20.1.3",
   "sideEffects": false,
   "peerDependencies": {
     "@angular/common": "~20.2.0",
@@ -9,5 +9,19 @@
     "@ngx-translate/core": "^17.0.0",
     "moment": "^2.30.1",
     "rxjs": "~7.8.0"
+  },
+  "module": "fesm2022/verisoft-core.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/verisoft-core.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
   }
-}
+}

package/.eslintrc.json

@@ -1,43 +0,0 @@
-{
-  "extends": ["../../../.eslintrc.base.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts"],
-      "extends": [
-        "plugin:@nx/angular",
-        "plugin:@angular-eslint/template/process-inline-templates"
-      ],
-      "rules": {
-        "@angular-eslint/directive-selector": [
-          "error",
-          {
-            "type": "attribute",
-            "prefix": "v",
-            "style": "camelCase"
-          }
-        ],
-        "@angular-eslint/component-selector": [
-          "error",
-          {
-            "type": "element",
-            "prefix": "v",
-            "style": "kebab-case"
-          }
-        ]
-      }
-    },
-    {
-      "files": ["*.html"],
-      "extends": ["plugin:@nx/angular-template"],
-      "rules": {}
-    },
-    {
-      "files": ["*.json"],
-      "parser": "jsonc-eslint-parser",
-      "rules": {
-        "@nx/dependency-checks": "error"
-      }
-    }
-  ]
-}

package/jest.config.ts

@@ -1,22 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'core',
-  preset: '../../../jest.preset.js',
-  setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
-  coverageDirectory: '../../../coverage/src/libs/core',
-  transform: {
-    '^.+\\.(ts|mjs|js|html)$': [
-      'jest-preset-angular',
-      {
-        tsconfig: '<rootDir>/tsconfig.spec.json',
-        stringifyContentPathRegex: '\\.(html|svg)$',
-      },
-    ],
-  },
-  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
-  snapshotSerializers: [
-    'jest-preset-angular/build/serializers/no-ng-attributes',
-    'jest-preset-angular/build/serializers/ng-snapshot',
-    'jest-preset-angular/build/serializers/html-comment',
-  ],
-};

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "../../../dist/src/libs/core",
-  "lib": {
-    "entryFile": "src/index.ts"
-  }
-}

package/project.json

@@ -1,36 +0,0 @@
-{
-  "name": "core",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "src/libs/core/src",
-  "prefix": "lib",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/angular:package",
-      "outputs": ["{workspaceRoot}/dist/{projectRoot}"],
-      "options": {
-        "project": "src/libs/core/ng-package.json"
-      },
-      "configurations": {
-        "production": {
-          "tsConfig": "src/libs/core/tsconfig.lib.prod.json"
-        },
-        "development": {
-          "tsConfig": "src/libs/core/tsconfig.lib.json"
-        }
-      },
-      "defaultConfiguration": "production"
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "src/libs/core/jest.config.ts"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './lib/models';
-export * from './lib/services';
-export * from './lib/utils';

package/src/lib/index.ts

@@ -1 +0,0 @@
-export * from './models';

package/src/lib/models/all-item.datasource.ts

@@ -1,5 +0,0 @@
-import { Observable } from 'rxjs';
-
-export interface AllItemDatasource<T> {
-  getData$: () => Observable<T[]>
-}

package/src/lib/models/base-http.models.ts

@@ -1,144 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { HttpParams, HttpResponse } from '@angular/common/http';
-import { InjectionToken } from '@angular/core';
-
-export const BASE_URL_PATH = new InjectionToken<string>('BASE_URL_PATH');
-
-export function requestParamsToHttpParams<T>(
-  requestParams: Partial<RequestParams<T>>,
-  httpParams: HttpParams = new HttpParams()
-): HttpParams {
-  if (requestParams.limit != undefined) {
-    httpParams = httpParams.append('limit', requestParams.limit.toString());
-  }
-
-  if (requestParams.offset != undefined) {
-    httpParams = httpParams.append('offset', requestParams.offset.toString());
-  }
-
-  if (requestParams.id != '' && requestParams.id != undefined) {
-    httpParams = httpParams.append('id', requestParams.id as any);
-  }
-
-  httpParams = getFilter(requestParams, httpParams);
-  httpParams = getSort(requestParams, httpParams);
-
-  return httpParams;
-}
-
-function getFilter<T>(
-  requestParams: Partial<RequestParams<any>>,
-  httpParams: HttpParams
-): HttpParams {
-  if (!requestParams.filter) {
-    return httpParams;
-  }
-  Object.keys(requestParams?.filter).forEach((key) => {
-    const value = requestParams.filter?.[key as keyof Partial<T>];
-    if (value != undefined && !(typeof value === 'string' && value.trim() === "")) {
-      if (Array.isArray(value)) {
-        value.forEach((valueItem: any) => {
-          httpParams = httpParams.append(
-            'Filter.' + key, valueItem
-          );
-        });
-      } else {
-        httpParams = httpParams.append('Filter.' + key, value);
-      }
-    }
-  });
-  return httpParams;
-}
-
-function getSort(
-  requestParams: Partial<RequestParams<any>>,
-  httpParams: HttpParams
-): HttpParams {
-  if (!requestParams.sort) {
-    return httpParams;
-  }
-
-  requestParams.sort?.forEach((sort) => {
-    httpParams = httpParams
-      .append('Sort.Field', sort.field)
-      .append('Sort.Direction', sort.direction);
-  });
-  return httpParams;
-}
-
-export function saveFile(response: HttpResponse<Blob>) {
-  const fileName = response.headers
-    .get('Content-Disposition')
-    ?.split(';')[1]
-    .split('=')[1];
-  const blob: Blob = response.body as Blob;
-  const a = document.createElement('a');
-  a.download = fileName ?? 'undefined';
-  a.href = window.URL.createObjectURL(blob);
-  a.click();
-}
-
-export enum SortDirection {
-  asc = 'asc',
-  desc = 'desc',
-}
-
-export declare type SortDirectionType = keyof typeof SortDirection;
-
-export declare interface Sort {
-  field: string;
-  direction: SortDirectionType;
-}
-
-export interface RequestParams<T> extends AllDataRequestParams<T> {
-  offset: number;
-  limit: number;
-  id?: string;
-}
-
-export interface AllDataRequestParams<T> {
-  filter?: Partial<T>;
-  sort?: Sort[];
-}
-
-export interface Page<T> {
-  data: T[];
-  total: number;
-  limit: number;
-  offset: number;
-}
-
-export interface CustomExport<T> {
-  sortDefinition?: Sort;
-  filter?: Partial<T>;
-  columnsToExport: ColumnExportSpecification[];
-}
-
-export interface ColumnExportSpecification {
-  name: string;
-  header: string;
-}
-
-export const DEFAULT_SEARCH_LIMIT = 50;
-
-export const DEFAULT_SEARCH_PARAMS: RequestParams<any> = {
-  offset: 0,
-  limit: DEFAULT_SEARCH_LIMIT,
-  id: '',
-};
-
-export function normalizeRequest<T>(
-  request: Partial<RequestParams<T>>,
-  minLimit: number | undefined = undefined
-): RequestParams<T> {
-  return {
-    offset: request?.offset ?? 0,
-    limit: !request?.limit
-      ? DEFAULT_SEARCH_LIMIT
-      : minLimit && request.limit < minLimit
-      ? minLimit
-      : request.limit,
-    filter: request?.filter,
-    sort: request?.sort,
-  };
-}

package/src/lib/models/constants.ts

@@ -1,8 +0,0 @@
-import { LazyLoadEvent } from './event.models';
-
-export const DEFAULT_PAGE_SIZE = 50;
-
-export const DEFAULT_LAZYLOAD_OPTIONS: LazyLoadEvent = {
-  offset: 0,
-  limit: DEFAULT_PAGE_SIZE,
-};

package/src/lib/models/datasource.model.ts

@@ -1,77 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { isObservable, map, Observable, of } from 'rxjs';
-import { BaseHttpService } from '../services/base-http.service';
-import { AllItemDatasource } from './all-item.datasource';
-import { Page, RequestParams } from './base-http.models';
-import { DEFAULT_PAGE_SIZE } from './constants';
-
-export type DatasourceType<T> =
-  | string
-  | Observable<T[]>
-  | Observable<Page<T>>
-  | BaseHttpService<T>
-  | T[]
-  | Page<T>
-  | AllItemDatasource<T>;
-
-export type DataSourceFunctionType<T> = (
-  requestParams: RequestParams<T>
-) => Observable<Page<T>>;
-
-export function convertDatasource<T>(
-  datasource: DatasourceType<T>,
-  basePath: string,
-  httpClient: HttpClient
-): DataSourceFunctionType<T> {
-  if (!datasource) {
-    throw new Error('Datasource is not defined');
-  }
-
-  if (typeof datasource === 'string') {
-    const service = new BaseHttpService<T>(httpClient, basePath, datasource);
-    return (requestParams: RequestParams<T>) =>
-      service.fetchList(requestParams);
-  }
-
-  if (datasource instanceof BaseHttpService) {
-    return (requestParams: RequestParams<T>) =>
-      datasource.fetchList(requestParams);
-  }
-
-  if (isObservable(datasource)) {
-    return () =>
-      (datasource as Observable<Page<T> | T[]>).pipe(map(convertArrayToPage));
-  }
-
-  const allItemDatasource = <AllItemDatasource<T>>datasource;
-  if (allItemDatasource.getData$) {
-    return () =>
-      allItemDatasource
-        .getData$()
-        .pipe(map((data) => convertArrayToPage(data)));
-  }
-
-  const page = <Page<T>>datasource;
-  if (page.data) {
-    return () => of(page);
-  }
-
-  if (Array.isArray(datasource)) {
-    return () => of(convertArrayToPage(datasource));
-  }
-
-  throw new Error('Datasource is not supported');
-}
-
-function convertArrayToPage<T>(data: Page<T> | T[]): Page<T> {
-  if (Array.isArray(data)) {
-    return {
-      data: data ?? [],
-      total: data?.length ?? 0,
-      limit: data?.length ?? DEFAULT_PAGE_SIZE,
-      offset: 0,
-    };
-  }
-
-  return data as Page<T>;
-}

package/src/lib/models/environment.model.ts

@@ -1,5 +0,0 @@
-export interface EnvironmentConfig {
-    production: boolean;
-    apiUrl: string;
-    appVersion: string;
-}

package/src/lib/models/error-provider.model.ts

@@ -1,20 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { ValidationErrors } from '@angular/forms';
-import { Observable } from 'rxjs';
-
-export interface ErrorProvider {
-  mapError(errors: ValidationErrors): Observable<string | undefined>;
-  errors: Record<string, (value?: any) => string>;
-}
-
-export const ERROR_PROVIDER_TOKEN
-  = new InjectionToken<ErrorProvider>('ERROR_PROVIDER_TOKEN');
-
-export enum CustomValidationCodes {}
-
-export const ErrorMap: Record<string, (value?: any) => string> = {
-  required: () => `VALIDATIONS.REQUIRED`,
-  email: () => `VALIDATIONS.EMAIL`,
-  minLength: () => 'VALIDATIONS.MIN_LENGTH',
-  maxLength: () => 'VALIDATIONS.MAX_LENGTH',
-};

package/src/lib/models/event.models.ts

@@ -1,7 +0,0 @@
-import { RequestParams } from "./base-http.models";
-
-export type LazyLoadEvent = RequestParams<unknown>;
-
-export interface FilterEvent {
-    filter?: string;
-}

package/src/lib/models/index.ts

@@ -1,7 +0,0 @@
-export * from './environment.model';
-export * from './event.models';
-export * from './constants';
-export * from './base-http.models';
-export * from './all-item.datasource';
-export * from './datasource.model';
-export * from './error-provider.model';

package/src/lib/services/base-http.service.ts

@@ -1,114 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { HttpClient } from '@angular/common/http';
-import { map, Observable } from 'rxjs';
-import {
-  AllDataRequestParams,
-  DEFAULT_SEARCH_PARAMS,
-  Page,
-  RequestParams,
-  requestParamsToHttpParams,
-} from '../models/base-http.models';
-import { LazyLoadEvent } from '../models/event.models';
-import { ClearUtils } from '../utils/clear.utils';
-
-export class BaseHttpService<T, TKey = number | string> {
-  constructor(
-    readonly http: HttpClient,
-    readonly basePath: string,
-    readonly entityName: string
-  ) {
-    this.basePath = basePath;
-  }
-
-  protected get apiPath() {
-    return this.basePath ? this.basePath + this.entityName : this.entityName;
-  }
-
-  fetchList(requestParams: RequestParams<T>): Observable<Page<T>> {
-    const params = requestParamsToHttpParams<T>(requestParams);
-    return this.http.get<Page<T>>(this.apiPath, { params }).pipe(
-      map((response: Page<T>) => {
-        response.limit = requestParams.limit;
-        return response;
-      })
-    );
-  }
-
-  getData$(
-    entityName: keyof T,
-    searchTerm?: string | undefined,
-    lazyLoad?: LazyLoadEvent
-  ): Observable<T[]> {
-    const filter: Partial<T> = { [entityName]: searchTerm } as Partial<T>;
-    const params = lazyLoad
-      ? requestParamsToHttpParams<T>({
-          ...DEFAULT_SEARCH_PARAMS,
-          offset: lazyLoad.offset,
-          limit: lazyLoad.limit,
-          filter,
-        })
-      : requestParamsToHttpParams<T>({
-          ...DEFAULT_SEARCH_PARAMS,
-          filter,
-        });
-
-    return this.http.get<T[]>(this.apiPath, { params });
-  }
-
-  get(id: TKey): Observable<T> {
-    const url = `${this.apiPath}/${id}`;
-    return this.http.get<T>(url);
-  }
-
-  post(entity: Partial<T>): Observable<T> {
-    return this.http.post<T>(this.apiPath, entity);
-  }
-
-  put(id: TKey, entity: Partial<T>): Observable<T> {
-    const url = `${this.apiPath}/${id}`;
-    return this.http.put<T>(url, entity);
-  }
-
-  delete(id: TKey): Observable<T> {
-    const url = `${this.apiPath}/${id}`;
-    return this.http.delete<T>(url);
-  }
-
-  export(requestParams: AllDataRequestParams<T>): Observable<Blob> {
-    const httpParams = requestParamsToHttpParams<T>(requestParams);
-    const url = `${this.apiPath}/export`;
-    return this.http.get(url, { responseType: 'blob', params: httpParams });
-  }
-
-  removeRange(entity: string[]) {
-    return this.http.delete(this.apiPath, {
-      body: entity,
-    });
-  }
-
-  createParams<T>(requestParams: RequestParams<T>): any {
-    const sorter = this.createSorter(requestParams);
-    const filter = JSON.parse(JSON.stringify(requestParams.filter));
-    const transformedFilter = filter;
-    ClearUtils.recursiveObjectAttributesDeletation(transformedFilter);
-    return {
-      paging: {
-        offset: requestParams.offset,
-        limit: requestParams.limit,
-      },
-      ...(sorter && { sorting: sorter }),
-      ...(transformedFilter && { filter: transformedFilter }),
-    };
-  }
-
-  private createSorter<T>(requestParams: RequestParams<T>) {
-    if (requestParams?.sort?.length === 1) {
-      const sorter = requestParams.sort[0];
-      return {
-        sortField: sorter.field,
-        sortOrder: sorter.direction,
-      };
-    }
-    return null;
-  }
-}