@sumaris-net/ngx-components 2.6.4-alpha3 → 2.6.4-alpha5

package/src/app/shared/observables.ts

@@ -0,0 +1,132 @@
+import {merge, Observable, timer} from 'rxjs';
+import {filter, first, map, switchMap, takeUntil, tap} from 'rxjs/operators';
+import {isNotNil} from './functions';
+import {Predicate} from '@angular/core';
+
+export declare interface FirstOptions {
+  timeout?: number;
+  stop?: Observable<any>;
+  stopError?: boolean|string|Error;
+}
+
+export declare interface WaitForOptions extends FirstOptions{
+  dueTime?: number;
+  checkPeriod?: number;
+}
+
+export function filterNotNil<T = any>(obs: Observable<T>): Observable<T> {
+  return obs.pipe(filter(isNotNil));
+}
+
+export function filterTrue(obs: Observable<boolean>): Observable<boolean> {
+  return obs.pipe(filter((v) => v === true));
+}
+export function filterFalse(obs: Observable<boolean>, opts?: FirstOptions): Observable<boolean> {
+  return obs.pipe(filter((v) => v === false));
+}
+
+function decorateWithTakeUntil<T = any>(obs: Observable<T>, opts?: FirstOptions): Observable<T> {
+  // Set take until notifier
+  let takeUntil$: Observable<any> = opts?.stop || (opts?.timeout && timer(opts.timeout));
+
+  if (!takeUntil$) return obs; // Skip
+
+  // When stop, throw an error (useful when used with a toPromise())
+  if (opts.stopError) {
+    let error: Error;
+    if (opts.stopError === true) {
+      error = new Error(opts.timeout ? `Timeout ${opts.timeout}ms` : `stop`);
+    }
+    else if (typeof opts.stopError === 'string') {
+      error = new Error(opts.stopError);
+    }
+    else {
+      error = opts.stopError;
+    }
+    takeUntil$ = takeUntil$.pipe(
+      map(() => {
+        throw error;
+      }));
+  }
+
+  return obs
+    .pipe(takeUntil(takeUntil$));
+}
+
+export function firstNotNil<T = any>(obs: Observable<T>, opts?: FirstOptions): Observable<T> {
+  return decorateWithTakeUntil(obs.pipe(first(isNotNil)), opts);
+}
+export function firstTrue(obs: Observable<boolean>, opts?: FirstOptions): Observable<void> {
+  return decorateWithTakeUntil(obs.pipe(
+      first((v) => v === true),
+      map(_ => {}) // Convert to void
+    ), opts);
+}
+export function firstFalse(obs: Observable<boolean>, opts?: FirstOptions): Observable<void> {
+  return decorateWithTakeUntil(obs.pipe(
+    first((v) => v === false),
+    map(_ => {}) // Convert to void
+  ), opts);
+}
+export function firstTruePromise(obs: Observable<boolean>, opts?: FirstOptions): Promise<void> {
+  return firstTrue(obs, {stopError: true, ...opts}).toPromise();
+}
+export function firstFalsePromise(obs: Observable<boolean>, opts?: FirstOptions): Promise<void> {
+  return firstFalse(obs, {stopError: true, ...opts}).toPromise();
+}
+export function firstNotNilPromise<T = any>(obs: Observable<T>, opts?: FirstOptions): Promise<T> {
+  return firstNotNil(obs, {stopError: true, ...opts}).toPromise();
+}
+export function chainPromises<T = any>(defers: (() => Promise<any>)[]): Promise<T[]> {
+  return (defers || []).reduce((previous: Promise<any> | null, defer) => {
+    // First job
+    if (!previous) {
+      return defer()
+        // Init the final result array, with the first result
+        .then(jobRes => [jobRes]);
+    }
+    // Other jobs
+    return previous
+      .then((finalResult) => defer()
+        // Add job result to final result array
+        .then(jobRes => finalResult.concat(jobRes)));
+  }, null);
+}
+
+/**
+ * Wait form a predicate return true. This need to implement AppFormUtils.waitWhilePending(), AppFormUtils.waitIdle()
+ * @param predicate
+ * @param opts
+ */
+export async function waitFor(predicate: Predicate<void>, opts?: WaitForOptions): Promise<void> {
+  if (predicate()) return Promise.resolve();
+
+  const period = opts && opts.checkPeriod || 300;
+  const dueTime = opts && opts.dueTime || period;
+  let wait$: Observable<boolean> = timer(dueTime, period)
+    .pipe(
+      // For DEBUG :
+      //tap(() => console.debug("Waiting form idle...", form)),
+      filter(_ => predicate()),
+      map(_ => true)
+    );
+
+  await firstNotNilPromise(wait$, opts);
+}
+
+export function waitForTrue(observable: Observable<boolean>, opts?: WaitForOptions): Promise<void> {
+  opts = {stopError: true, ...opts};
+  // dueTime (without timeout)
+  if (opts && opts.dueTime > 0) {
+    observable = timer(opts.dueTime)
+      .pipe(switchMap(() => observable));
+  }
+  return firstTrue(observable, opts).toPromise();
+}
+
+export function waitForFalse(observable: Observable<boolean>, opts?: WaitForOptions): Promise<void> {
+  return waitForTrue(
+    // Inverse the logic
+    observable.pipe(map(v => v === false)
+  ), opts);
+}

package/src/app/shared/pipes/arrays.pipe.ts

@@ -0,0 +1,111 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {getPropertyByPath, isNotNil} from '../functions';
+
+@Pipe({
+    name: 'isNotEmptyArray'
+})
+export class NotEmptyArrayPipe implements PipeTransform {
+
+    transform<T = any>(val: unknown | T[]): boolean {
+      if (!Array.isArray(val)) return false;
+      return val.length > 0;
+    }
+}
+
+
+@Pipe({
+  name: 'isEmptyArray'
+})
+export class EmptyArrayPipe implements PipeTransform {
+
+  transform<T = any>(val: unknown | T[]): boolean {
+    if (!Array.isArray(val)) return true;
+    return val.length === 0;
+  }
+}
+
+
+@Pipe({
+  name: 'isArrayLength'
+})
+export class ArrayLengthPipe implements PipeTransform {
+
+  transform<T = any>(val: unknown | T[], args?: { greaterThan?: number; equals?: number; lessThan?: number }): boolean {
+    args = args || {};
+    const size = !Array.isArray(val) ? 0 : val.length;
+    if (isNotNil(args.lessThan)) {
+      return size < args.lessThan;
+    }
+    if (isNotNil(args.greaterThan)) {
+      return size > args.greaterThan;
+    }
+    if (isNotNil(args.equals)) {
+      return size === args.equals;
+    }
+    return false;
+  }
+}
+
+@Pipe({
+  name: 'arrayFirst'
+})
+export class ArrayFirstPipe implements PipeTransform {
+
+  transform<T = any>(val: unknown | T[]): T | null {
+    if (!Array.isArray(val)) return null;
+    return val.length > 0 ? val[0] : null;
+  }
+}
+
+@Pipe({
+  name: 'arrayPluck'
+})
+export class ArrayPluckPipe implements PipeTransform {
+
+  /**
+   *
+   * @param val
+   * @param opts property to get, or options
+   */
+  transform<T = any>(val: unknown | T[], opts: string | string[] | { property: string|string[]; omitNil?: boolean }): any[] {
+    if (!Array.isArray(val) || !opts) return null;
+    const property = (typeof opts === 'string') || Array.isArray(opts) ? opts as string|string[] : opts.property;
+    return (opts['omitNil'] !== true) ?
+      val.map(value => getPropertyByPath(value, property)) :
+      val.map(value => getPropertyByPath(value, property)).filter(isNotNil);
+  }
+}
+
+@Pipe({
+  name: 'arrayIncludes'
+})
+export class ArrayIncludesPipe implements PipeTransform {
+
+  transform<T = any>(val: unknown | T[], searchElement: T, fromIndex?: number): boolean {
+    if (!Array.isArray(val)) return false;
+    return val && val.includes(searchElement, fromIndex) || false;
+  }
+}
+
+
+@Pipe({
+  name: 'arrayFilter'
+})
+export class ArrayFilterPipe implements PipeTransform {
+
+   transform<T = any>(val: unknown | T[], filterFn: (T) => boolean): T[] | null {
+     if (!Array.isArray(val)) return null;
+     return val.filter(filterFn);
+  }
+}
+
+@Pipe({
+  name: 'arrayJoin'
+})
+export class ArrayJoinPipe implements PipeTransform {
+
+  transform<T = any>(val: unknown | T[], separator: string): string {
+    if (!Array.isArray(val)) return '';
+    return val.join(separator) || '';
+  }
+}

package/src/app/shared/pipes/colors.pipe.ts

@@ -0,0 +1,19 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {AppColors} from '../types';
+import {ThemePalette} from '@angular/material/core';
+
+@Pipe({
+    name: 'matColor'
+})
+export class MatColorPipe implements PipeTransform {
+
+    transform(color: AppColors): ThemePalette | undefined {
+      if (!color) return undefined
+      switch (color) {
+        case 'warning':
+          return 'warn';
+        default:
+          return color as ThemePalette
+      }
+    }
+}

package/src/app/shared/pipes/date-diff-duration.pipe.ts

@@ -0,0 +1,48 @@
+import {Injectable, Pipe, PipeTransform} from '@angular/core';
+import {Moment} from 'moment';
+import {DateAdapter} from '@angular/material/core';
+import {DATE_ISO_PATTERN} from '../constants';
+import {TranslateService} from '@ngx-translate/core';
+import {DateUtils} from '../dates';
+
+@Pipe({
+  name: 'dateDiffDuration'
+})
+@Injectable({providedIn: 'root'})
+export class DateDiffDurationPipe implements PipeTransform {
+
+  protected dayUnit: string;
+
+  constructor(
+    private dateAdapter: DateAdapter<Moment>,
+    private translate: TranslateService) {
+
+    this.dayUnit = translate.instant('COMMON.DAY_UNIT');
+    translate.get('COMMON.DAY_UNIT').subscribe(dayUnit => this.dayUnit = dayUnit);
+  }
+
+  transform(value: { startValue: string | Moment; endValue: string | Moment }, args?: { seconds?: boolean }): string | Promise<string> {
+    if (!value.startValue || !value.endValue) return '';
+
+    const startDate = this.dateAdapter.parse(value.startValue, DATE_ISO_PATTERN);
+    const endDate = this.dateAdapter.parse(value.endValue, DATE_ISO_PATTERN);
+
+    return this.format(startDate, endDate, args);
+  }
+
+  format(startDate: Moment, endDate: Moment, args: { seconds?: boolean }): string {
+    const duration = DateUtils.moment.duration(endDate.diff(startDate));
+    if (duration.asMinutes() < 0) return '';
+    const withSeconds = args?.seconds;
+
+    const timeDuration = DateUtils.moment(0)
+      .hour(duration.hours())
+      .minute(duration.minutes());
+    if (withSeconds) {
+      timeDuration.second(duration.seconds());
+    }
+
+    const days = Math.floor(duration.asDays());
+    return (days > 0 ? days.toString() + (this.dayUnit + ' ') : '') + timeDuration.format(withSeconds ? 'HH:mm:ss' : 'HH:mm');
+  }
+}

package/src/app/shared/pipes/date-format.pipe.ts

@@ -0,0 +1,78 @@
+import {Injectable, OnDestroy, Pipe, PipeTransform} from '@angular/core';
+import {isMoment, Moment} from 'moment';
+import {DATE_ISO_PATTERN} from '../constants';
+import {TranslateService} from '@ngx-translate/core';
+import {MomentDateAdapter} from '@angular/material-moment-adapter';
+import {Subscription} from 'rxjs';
+
+export abstract class AbstractDateFormat {
+
+  private datePattern: string;
+  private dateTimePattern: string;
+  private dateTimeSecondsPattern: string;
+
+  protected constructor(
+    protected dateAdapter: MomentDateAdapter,
+    protected translate: TranslateService
+  ) {
+    const translations = translate.instant(['COMMON.DATE_PATTERN', 'COMMON.DATE_TIME_PATTERN', 'COMMON.DATE_TIME_SECONDS_PATTERN']);
+    this._updateTranslations(translations);
+  }
+
+  transform(value: string | Moment | Date, args?: { pattern?: string; time?: boolean; seconds?: boolean; } ): string | Promise<string> {
+    const pattern = args && args.pattern ||
+      (args && args.time ? (args.seconds ? this.dateTimeSecondsPattern : this.dateTimePattern) : this.datePattern);
+    // Keep original moment object, if possible (to avoid a conversion)
+    const date: Moment = isMoment(value) ? value : this.dateAdapter.parse(value, DATE_ISO_PATTERN);
+    return date && this.dateAdapter.format(date, pattern) || '';
+  }
+
+  protected _updateTranslations(translations) {
+    this.datePattern = this._getTranslationValue(translations, 'COMMON.DATE_PATTERN', 'DD/MM/YYYY');
+    this.dateTimePattern = this._getTranslationValue(translations, 'COMMON.DATE_TIME_PATTERN', 'DD/MM/YYYY HH:mm');
+    this.dateTimeSecondsPattern = this._getTranslationValue(translations, 'COMMON.DATE_TIME_SECONDS_PATTERN', 'DD/MM/YYYY HH:mm:ss');
+  }
+
+  protected _getTranslationValue(translations: any, key: string, defaultValue: string): string {
+    return (translations[key] !== key) ? translations[key] : defaultValue;
+  }
+}
+
+@Pipe({
+  name: 'dateFormat'
+})
+export class DateFormatPipe extends AbstractDateFormat implements PipeTransform {
+
+  constructor(dateAdapter: MomentDateAdapter,
+              translate: TranslateService) {
+    super(dateAdapter, translate);
+  }
+}
+
+@Injectable({providedIn: 'root'})
+export class DateFormatService extends AbstractDateFormat implements OnDestroy {
+
+  private _subscription: Subscription;
+
+  constructor(dateAdapter: MomentDateAdapter,
+              translate: TranslateService) {
+    super(dateAdapter, translate);
+
+    // Subscribe to changes (e.g. when platform not ready yet)
+    this._subscription = translate.get(['COMMON.DATE_PATTERN', 'COMMON.DATE_TIME_PATTERN', 'COMMON.DATE_TIME_SECONDS_PATTERN'])
+      .subscribe(translations => this._updateTranslations(translations));
+  }
+
+  ngOnDestroy() {
+    this._subscription.unsubscribe();
+  }
+
+  format(date: Moment, pattern: any): string {
+    return this.dateAdapter.format(date, pattern);
+  }
+
+  parse(value: string, parseFormat: any): Moment {
+    return isMoment(value) ? value : this.dateAdapter.parse(value, parseFormat || DATE_ISO_PATTERN);
+  }
+
+}

package/src/app/shared/pipes/date-from-now.pipe.ts

@@ -0,0 +1,20 @@
+import {Injectable, Pipe, PipeTransform} from '@angular/core';
+import {isMoment, Moment} from 'moment';
+import {DATE_ISO_PATTERN} from '../constants';
+import {MomentDateAdapter} from '@angular/material-moment-adapter';
+
+@Pipe({
+  name: 'dateFromNow'
+})
+@Injectable({providedIn: 'root'})
+export class DateFromNowPipe implements PipeTransform {
+
+  constructor(
+    private dateAdapter: MomentDateAdapter) {
+  }
+
+  transform(value: string | Moment, args?: any): string | Promise<string> {
+    const date: Moment = isMoment(value) ? value as Moment : this.dateAdapter.parse(value, DATE_ISO_PATTERN);
+    return date ? date.fromNow(args && args.withoutSuffix) : '';
+  }
+}

package/src/app/shared/pipes/duration.pipe.spec.ts

@@ -0,0 +1,51 @@
+import {DurationPipe} from './duration.pipe';
+import {TestBed} from '@angular/core/testing';
+import {
+  MissingTranslationHandler,
+  MissingTranslationHandlerParams,
+  TranslateModule
+} from '@ngx-translate/core';
+import {HttpClientModule} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+
+describe('DurationPipe', () => {
+
+  let pipe: DurationPipe;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+    imports: [
+        HttpClientModule,
+        TranslateModule.forRoot({
+            missingTranslationHandler: { provide: MissingTranslationHandler, useClass: DummyMissingTranslationHandler }
+        })
+    ],
+    providers: [
+        DurationPipe
+    ],
+    teardown: { destroyAfterEach: false }
+});
+    pipe = TestBed.inject(DurationPipe);
+  });
+
+  it('create an instance', () => {
+    expect(pipe).toBeTruthy();
+  });
+
+  it('transform some values', () => {
+    expect(pipe.transform(1)).not.toBe('1:00');
+    expect(pipe.transform(1)).toBe('01:00');
+    expect(pipe.transform(10)).toBe('10:00');
+    expect(pipe.transform(1.5)).toBe('01:30');
+    expect(pipe.transform(2.9)).toBe('02:54');
+    expect(pipe.transform(24)).toBe('1DUMMY 00:00');
+    expect(pipe.transform(25.25)).toBe('1DUMMY 01:15');
+  });
+});
+
+@Injectable()
+class DummyMissingTranslationHandler implements MissingTranslationHandler {
+  handle(params: MissingTranslationHandlerParams): any {
+    return 'DUMMY';
+  }
+}

package/src/app/shared/pipes/duration.pipe.ts

@@ -0,0 +1,34 @@
+import {Pipe, Injectable, PipeTransform} from '@angular/core';
+import {TranslateService} from '@ngx-translate/core';
+import {toDuration} from '../dates';
+import {unitOfTime} from 'moment';
+
+@Pipe({
+  name: 'duration'
+})
+@Injectable({providedIn: 'root'})
+export class DurationPipe implements PipeTransform {
+
+  protected dayUnit: string;
+
+  constructor(
+    private translate: TranslateService
+  ) {
+    this.dayUnit = translate.instant('COMMON.DAY_UNIT');
+  }
+
+  transform(value: number, args?: unitOfTime.DurationConstructor | any): string {
+    if (!value) return '';
+    const unit = args?.unit || args || 'hours';
+
+    // try with moment
+    const duration = toDuration(value, unit);
+
+    const days = duration.days();
+    const hour = duration.hours().toString().padStart(2, '0');
+    const minute = duration.minutes().toString().padStart(2, '0');
+
+    return (days > 0 ? days.toString() + (this.dayUnit + ' ') : '') + hour + ':' + minute;
+
+  }
+}

package/src/app/shared/pipes/file-size.pipe.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright (c) 2019 Jonathan Catmull.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import {Pipe, PipeTransform} from '@angular/core';
+
+/*
+ * Convert bytes into largest possible unit.
+ * Takes an precision argument that defaults to 2.
+ * Usage:
+ *   bytes | fileSize:precision
+ * Example:
+ *   {{ 1024 |  fileSize}}
+ *   formats to: 1 KB
+*/
+@Pipe({name: 'fileSize'})
+export class FileSizePipe implements PipeTransform {
+
+  private units = [
+    'bytes',
+    'KB',
+    'MB',
+    'GB',
+    'TB',
+    'PB'
+  ];
+
+  transform(bytes: number = 0, precision: number = 2 ): string {
+    if ( isNaN( parseFloat( String(bytes) )) || ! isFinite( bytes ) ) return '?';
+
+    let unit = 0;
+
+    while ( bytes >= 1024 ) {
+      bytes /= 1024;
+      unit ++;
+    }
+
+    return bytes.toFixed( + precision ) + ' ' + this.units[ unit ];
+  }
+}