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

package/src/app/shared/observables.ts

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

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

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

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

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

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

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

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

@@ -1,58 +0,0 @@
-/**
- * @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 ];
-  }
-}