@elderbyte/ngx-starter 14.12.0-beta4 → 14.12.0-beta6

package/.eslintrc.json

@@ -0,0 +1,44 @@
+{
+  "extends": "../../../.eslintrc.json",
+  "ignorePatterns": [
+    "!**/*"
+  ],
+  "overrides": [
+    {
+      "files": [
+        "*.ts"
+      ],
+      "parserOptions": {
+        "project": [
+          "tsconfig.lib.json",
+          "tsconfig.spec.json"
+        ],
+        "createDefaultProgram": true
+      },
+      "rules": {
+        "@angular-eslint/directive-selector": [
+          "error",
+          {
+            "type": "attribute",
+            "prefix": "elder",
+            "style": "camelCase"
+          }
+        ],
+        "@angular-eslint/component-selector": [
+          "error",
+          {
+            "type": "element",
+            "prefix": "elder",
+            "style": "kebab-case"
+          }
+        ]
+      }
+    },
+    {
+      "files": [
+        "*.html"
+      ],
+      "rules": {}
+    }
+  ]
+}

package/karma-ci.conf.js

@@ -0,0 +1,46 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/current/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../coverage/ngx-starter-ci'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_ERROR,
+    autoWatch: false,
+    browsers: ['Chrome'], // Headless chrome will be used in test image automatically.
+    // Configuring headless chrome here will lead to the tests as of Angular 14
+    // https://lightrun.com/answers/karma-runner-karma-angular-14-karma-gets-stuck-after-executing-tests-inside-gitlab-kubernetes-pod-runner-for-chromehead
+    singleRun: true,
+    restartOnFileChange: false
+  });
+};

package/karma.conf.js

@@ -0,0 +1,44 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/latest/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../coverage/ngx-starter'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../../dist/elderbyte/ngx-starter",
+  "deleteDestPath": false,
+  "lib": {
+    "entryFile": "src/public_api.ts"
+  },
+  "assets": [
+    "./**/*.scss"
+  ],
+  "allowedNonPeerDependencies": [
+    "tslib",
+    "streamsaver"
+  ]
+}

package/ng-package.prod.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../../dist/elderbyte/ngx-starter",
+  "lib": {
+    "entryFile": "src/public_api.ts"
+  },
+  "assets": [
+    "./**/*.scss"
+  ],
+  "allowedNonPeerDependencies": [
+    "tslib",
+    "streamsaver"
+  ]
+}

package/package.json

@@ -1,39 +1,23 @@
 {
   "name": "@elderbyte/ngx-starter",
-  "version": "14.12.0-beta4",
+  "version": "14.12.0-beta6",
   "peerDependencies": {
-    "@angular/common": "^14.0.0",
-    "@angular/core": "^14.0.0",
-    "@angular/material": "^14.0.0",
+    "@angular/common": "^14.0.0 || ^15.0.0",
+    "@angular/core": "^14.0.0 || ^15.0.0",
+    "@angular/material": "^14.0.0 || ^15.0.0",
     "@ngx-translate/core": "^14.0.0",
-    "rxjs": "^7.5.5",
+    "rxjs": "^6.5.3 || ^7.5.5",
     "@elderbyte/ts-logger": "^0.1.0",
     "@elderbyte/ngx-simple-webstorage": "^14.0.0",
     "@js-joda/core": "^5.2.0"
   },
   "exports": {
     ".": {
-      "sass": "./_index.scss",
-      "types": "./index.d.ts",
-      "esm2020": "./esm2020/elderbyte-ngx-starter.mjs",
-      "es2020": "./fesm2020/elderbyte-ngx-starter.mjs",
-      "es2015": "./fesm2015/elderbyte-ngx-starter.mjs",
-      "node": "./fesm2015/elderbyte-ngx-starter.mjs",
-      "default": "./fesm2020/elderbyte-ngx-starter.mjs"
-    },
-    "./package.json": {
-      "default": "./package.json"
+      "sass": "./_index.scss"
     }
   },
   "dependencies": {
     "tslib": "^2.2.0",
     "streamsaver": "^2.0.5"
-  },
-  "module": "fesm2015/elderbyte-ngx-starter.mjs",
-  "es2020": "fesm2020/elderbyte-ngx-starter.mjs",
-  "esm2020": "esm2020/elderbyte-ngx-starter.mjs",
-  "fesm2020": "fesm2020/elderbyte-ngx-starter.mjs",
-  "fesm2015": "fesm2015/elderbyte-ngx-starter.mjs",
-  "typings": "index.d.ts",
-  "sideEffects": false
-}
+  }
+}

package/src/lib/common/async/public_api.ts

@@ -0,0 +1,3 @@
+
+export * from './refreshing-entity';
+

package/src/lib/common/async/refreshing-entity.ts

@@ -0,0 +1,128 @@
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {BehaviorSubject, Observable, of, throwError} from 'rxjs';
+import {catchError, delay, share, startWith, switchMap, takeWhile, tap} from 'rxjs/operators';
+import {IDataSource} from '../data/datasource/data-source';
+import {HttpErrorResponse} from '@angular/common/http';
+
+/**
+ * Represents an entity which can refresh itself periodically
+ * until a defined condition is met.
+ */
+export class RefreshingEntity<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly log = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly current$: BehaviorSubject<T>;
+  private readonly entityId: any;
+  private readonly interval: number;
+
+  private readonly _refreshing$: Observable<T>;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  public static refreshWhile<T>(
+    entity: T,
+    dataSource: IDataSource<T>,
+    refreshPredicate: (entity: T) => boolean,
+    interval?: number
+  ): RefreshingEntity<T> {
+    return new RefreshingEntity<T>(dataSource, entity, refreshPredicate, interval);
+  }
+
+  public static of<T>(fallback: T): RefreshingEntity<T> {
+    const neverRefreshFn = (x: T) => false;
+    return RefreshingEntity.refreshWhile(
+      fallback,
+      null,
+      neverRefreshFn
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private readonly dataSource: IDataSource<T>,
+    private readonly entity: T,
+    private readonly refreshPredicate: (entity: T) => boolean,
+    interval: number = 1000
+  ) {
+    this.interval = interval;
+    this.current$ = new BehaviorSubject<T>(entity);
+
+    if (this.dataSource) {
+      this.entityId = this.dataSource.getId(entity);
+    }
+
+    this._refreshing$ = this.current$.pipe(
+      takeWhile(e => this.keepRefreshing(e)),
+      delay(this.interval),
+      switchMap(e => this.refresh(e)),
+      tap(refreshed => this.current$.next(refreshed)),
+      startWith(this.current$.getValue()),
+      share() // Prevent multiple refreshes for each subscriber
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Gets the entity stream which is periodically refreshed.
+   */
+  public get entity$(): Observable<T> {
+    return this._refreshing$;
+  }
+
+  /**
+   * Gets the current entity value as snapshot
+   */
+  public get entitySnapshot(): T {
+    return this.current$.getValue();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private keepRefreshing(entity: T): boolean {
+    if (this.refreshPredicate) {
+      return this.refreshPredicate(entity);
+    }
+    return false;
+  }
+
+  private refresh(current: T): Observable<T> {
+    return this.dataSource.findById(this.entityId).pipe(
+      catchError(err => this.handleRefreshError(err, current))
+    );
+  }
+
+  private handleRefreshError(err: HttpErrorResponse, current: T): Observable<T> {
+    if (err.status >= 500) {
+      this.log.warn('Failed to refresh entity due to server side error, returning current!', err);
+      return of(current);
+    } else {
+      this.log.warn('Failed to refresh entity due to client side error, aborting refresh!', err);
+      return throwError(err);
+    }
+  }
+}

package/src/lib/common/csv/csv-serializer.ts

@@ -0,0 +1,82 @@
+import {CsvColumnSpec, CsvSpec} from './csv-spec';
+import {Observable} from 'rxjs/internal/Observable';
+import {TranslateService} from '@ngx-translate/core';
+import {map} from 'rxjs/operators';
+import {of} from 'rxjs';
+
+export class CsvSerializer<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly _csvSpec: CsvSpec<T>;
+  private readonly _translateService: TranslateService;
+
+  constructor(
+    csvSpec: CsvSpec<T>,
+    translateService?: TranslateService,
+  ) {
+    this._csvSpec = csvSpec;
+    this._translateService = translateService;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get csvSpec(): CsvSpec<T> {
+    return this._csvSpec;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public serializeHeaders(): Observable<string> {
+    return this.getTranslatedHeaders()
+      .pipe(
+        map(translatedHeaders =>
+          this.csvSpec.getHeaderTexts()
+            .map(headerText => translatedHeaders[headerText] || headerText) // fallback if no translation available
+            .join(this.csvSpec.delimiter)
+        )
+      );
+  }
+
+  public serializeRow(record: T): string {
+    return this.csvSpec.columnSpecs
+      .map(columnSpec => this.resolveValue(record, columnSpec))
+      .join(this.csvSpec.delimiter);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private Methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private getTranslatedHeaders(): Observable<{ [key: string]: string; }> {
+    if (this._translateService) {
+      return this._translateService.get(this.csvSpec.getHeaderTexts());
+    } else {
+      return of({});
+    }
+  }
+
+  private resolveValue(record: T, columnSpec: CsvColumnSpec<T>): string {
+    if (columnSpec.valueResolverFn) {
+      return columnSpec.valueResolverFn(record);
+    } else {
+      // @ts-ignore
+      return record[columnSpec.propertyPath];
+    }
+  }
+
+}

package/src/lib/common/csv/csv-spec.ts

@@ -0,0 +1,148 @@
+import {CsvSerializer} from './csv-serializer';
+import {TranslateService} from '@ngx-translate/core';
+
+export class CsvSpec<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  /** File name of CSV File */
+  public filename = 'data.csv';
+
+  /** Delimiter used */
+  public delimiter = ',';
+
+  /** Column specifications */
+  public columnSpecs: CsvColumnSpec<T>[] = [];
+
+  /** If Column header should be included */
+  public includeHeader = true;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  public static start<T>(filename: string): CsvSpec<T> {
+    const spec = new CsvSpec<T>();
+    spec.withFilename(filename);
+    return spec;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor() {
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public getSerializer(translateService?: TranslateService): CsvSerializer<T> {
+    return new CsvSerializer<T>(this, translateService);
+  }
+
+  public getHeaderTexts(): string[] {
+    return this.columnSpecs.map(
+      columnSpec => columnSpec.columnHeaderText
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Fluent API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public withFilename(filename: string): CsvSpec<T> {
+    if (!filename.endsWith('.csv')) {
+      filename = filename + '.csv';
+    }
+    this.filename = filename;
+    return this;
+  }
+
+  public withDelimiter(delimiter: string): CsvSpec<T> {
+    this.delimiter = delimiter;
+    return this;
+  }
+
+  public withColumnSpecs(...columnSpec: CsvColumnSpec<T>[]): CsvSpec<T> {
+    this.columnSpecs.push(...columnSpec);
+    return this;
+  }
+
+  public addColumnSpec(
+    headerText: string,
+    valueResolverFn: (type: T) => string,
+    id?: string
+  ): CsvSpec<T> {
+    this.withColumnSpecs(
+      CsvColumnSpec.start<T>(id || headerText)
+        .withValueResolverFn(valueResolverFn)
+        .withColumnHeaderText(headerText)
+    );
+    return this;
+  }
+}
+
+export class CsvColumnSpec<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  /** ID used for identification of the column */
+  public columnId: string;
+
+  /** Display string of the column header */
+  public columnHeaderText: string;
+
+  /** Function to resolve the value of the record. */
+  public valueResolverFn: (record: T) => string;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  public static start<T>(id?: string): CsvColumnSpec<T> {
+    const spec = new CsvColumnSpec<T>();
+    spec.columnId = id;
+    return spec;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Fluent API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public withColumnHeaderText(columnHeaderText: string): CsvColumnSpec<T> {
+    this.columnHeaderText = columnHeaderText;
+    if (!this.columnId) {
+      this.columnId = columnHeaderText;
+    }
+    return this;
+  }
+
+  public withValueResolverFn(fn: (record: T) => string): CsvColumnSpec<T> {
+    this.valueResolverFn = fn;
+    return this;
+  }
+
+}
+

package/src/lib/common/csv/public_api.ts

@@ -0,0 +1,3 @@
+
+export * from './csv-spec';
+export * from './csv-serializer';

package/src/lib/common/data/continuable-listing.ts

@@ -0,0 +1,35 @@
+
+export class ContinuableListing<T> {
+
+    /**
+     * The data of this listing chunk
+     */
+    public content: T[];
+
+    /**
+     * The current continuation token of this listing.
+     * To fetch the next page, use the NextContinuationToken property not this!
+     */
+    continuationToken?: string;
+
+    /**
+     * The continuation token to fetch the next part
+     */
+    nextContinuationToken?: string;
+
+    /**
+     * The totalSnapshot number of elements
+     * Might be null if the server does not know this
+     */
+    total?: number | undefined = null;
+
+    /**
+     * Size of this chunk (max page size)
+     */
+    chunkSize: number;
+
+    /**
+     * Is there more data to load with the NextContiunationToken?
+     */
+    hasMore: boolean;
+}