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

package/src/app/shared/pipes/translate-context.pipe.ts

@@ -0,0 +1,33 @@
+import {ChangeDetectorRef, Injectable, Pipe, PipeTransform} from '@angular/core';
+import {TranslateContextService} from '../services/translate-context.service';
+import {changeCaseToUnderscore, equals, equalsOrNil} from '../functions';
+
+@Injectable()
+@Pipe({
+    name: 'translateContext'
+})
+export class TranslateContextPipe implements PipeTransform {
+
+  constructor(
+    private translate: TranslateContextService
+  ) {
+  }
+
+  transform(query: string, context?: string, interpolateParams?: Object): string {
+    if (!query || !query.length) return query;
+    return this.translate.instant(query, context, interpolateParams);
+  }
+}
+
+
+@Pipe({
+  name: 'translatable'
+})
+@Injectable()
+export class TranslatablePipe implements PipeTransform {
+  transform(value: string): string {
+    // transform a string to a i18n compatible string (ex: QualitativeValue -> QUALITATIVE_VALUE)
+    return changeCaseToUnderscore(value)?.toUpperCase();
+  }
+}
+

package/src/app/shared/pipes/types.pipes.ts

@@ -0,0 +1,31 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {isObservable, Observable} from 'rxjs';
+
+@Pipe({
+  name: 'asAny'
+})
+export class AsAnyPipe implements PipeTransform {
+  transform<T = any>(value: unknown | any): T | null {
+    if (value === null || value === undefined) return null;
+    return value as T;
+  }
+}
+
+@Pipe({
+  name: 'asArray'
+})
+export class AsArrayPipe implements PipeTransform {
+  transform<T = any>(value: unknown): T[]| null {
+    return Array.isArray(value) ? value as any[] : null;
+  }
+}
+
+
+@Pipe({
+  name: 'asObservable'
+})
+export class AsObservablePipe implements PipeTransform {
+  transform<T = any>(value: unknown): Observable<T> | null {
+    return isObservable(value) ? value as Observable<T> : null;
+  }
+}

package/src/app/shared/platforms.ts

@@ -0,0 +1,58 @@
+/* ---
+ * Source: https://github.com/ionic-team/ionic-framework/blob/b0d53ca73619585671d8cf4dc24e47f826495a0a/core/src/utils/platform.ts
+ * --- */
+
+const _cache = {
+  mobile: null,
+  cordova: null,
+  capacitor: null
+};
+
+export const matchMedia = (win: Window, query: string): boolean =>
+  win.matchMedia(query).matches;
+
+export const testUserAgent = (win: Window, expr: RegExp) => {
+  const userAgent: string = win.navigator.userAgent || win.navigator.vendor || (window as any).opera;
+  return expr.test(userAgent);
+}
+
+export const isWindows = (win?: Window) =>
+  testUserAgent(win, /windows/i);
+
+export const isTouchUi = (win?: Window) =>
+  matchMedia(win, '(any-pointer:coarse)');
+
+const isIpad = (win: Window) => {
+  // iOS 12 and below
+  if (testUserAgent(win, /iPad/i)) {
+    return true;
+  }
+
+  // iOS 13+
+  if (testUserAgent(win, /Macintosh/i) && isTouchUi(win)) {
+    return true;
+  }
+
+  return false;
+};
+
+export const isIOS = (win: Window) =>
+  testUserAgent(win, /iPhone|iPod/i) || isIpad(win);
+
+export const isAndroid = (win: Window) =>
+  testUserAgent(win, /android|sink/i);
+
+export const isCapacitor = (win: any): boolean => {
+  if (_cache.capacitor === null || _cache.capacitor === undefined) {
+    _cache.capacitor = !!(win['Capacitor'] || win['capacitor']);
+  }
+  return _cache.capacitor;
+}
+export const isMobile = (win: Window) => {
+  if (_cache.mobile === null || _cache.mobile === undefined) {
+    _cache.mobile = isAndroid(win) || isIOS(window)
+      // Workaround, for MS Windows touch screen (detected as mobile, but forced as desktop)
+      || (isTouchUi(win) && !isWindows(win));
+  }
+  return _cache.mobile;
+}

package/src/app/shared/services/entity-service.class.ts

@@ -0,0 +1,127 @@
+import {Observable} from 'rxjs';
+import {FetchPolicy, WatchQueryFetchPolicy} from '@apollo/client/core';
+import {SortDirection} from '@angular/material/sort';
+import {EmptyObject} from '../../core/graphql/graphql.utils';
+
+export declare interface Page {
+  offset: number;
+  size: number;
+  sortBy?: string;
+  sortDirection?: SortDirection;
+}
+
+export declare type FetchMoreFn<R, V = EmptyObject> = (variables?: V) => Promise<R>;
+
+export declare interface LoadResult<T> {
+  data: T[];
+  total?: number;
+  errors?: any[];
+  fetchMore?: FetchMoreFn<LoadResult<T>>;
+}
+
+export declare type SuggestFn<T, F> = (value: any, filter?: F,
+                                       sortBy?: string|keyof T,
+                                       sortDirection?: SortDirection,
+                                       opts?: {
+                                         fetchPolicy: FetchPolicy;
+                                         [key: string]: any;
+                                       }) => Promise<T[] | LoadResult<T>>;
+
+export declare interface SuggestService<T, F> {
+  suggest: SuggestFn<T, F>;
+}
+
+export declare type FilterFn<T> = (data: T) => boolean;
+export declare type FilterFnFactory<T, F> = (filter: F) => FilterFn<T>;
+
+export declare interface EntityServiceLoadOptions {
+  fetchPolicy?: FetchPolicy;
+  trash?: boolean;
+  toEntity?: boolean;
+  query?: any;
+  variables?: any;
+  [key: string]: any;
+}
+
+
+export declare interface EntityServiceWatchOptions {
+  fetchPolicy?: WatchQueryFetchPolicy;
+  trash?: boolean;
+  toEntity?: boolean;
+  query?: any;
+  variables?: any;
+  [key: string]: any;
+}
+export declare interface EntityServiceListenChangesOptions {
+  interval?: number;
+  fetchPolicy?: FetchPolicy;
+  toEntity?: boolean;
+  query?: any;
+  variables?: any;
+  [key: string]: any;
+}
+
+export declare interface IEntityService<
+  T,
+  ID = any,
+  LO = EntityServiceLoadOptions> {
+
+  load(
+    id: ID,
+    opts?: LO
+  ): Promise<T>;
+
+  canUserWrite(data: T, opts?: any): boolean;
+
+  save(data: T, opts?: any): Promise<T>;
+
+  delete(data: T, opts?: any): Promise<any>;
+
+  listenChanges(id: ID, opts?: any): Observable<T | undefined>;
+}
+
+export declare interface EntitiesServiceLoadOptions extends EntityServiceLoadOptions {
+  withTotal?: boolean;
+}
+
+export declare interface EntitiesServiceWatchOptions extends EntityServiceWatchOptions {
+  withTotal?: boolean;
+}
+
+export declare interface IEntitiesService<T, F, O extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions> {
+
+  watchAll(
+    offset: number,
+    size: number,
+    sortBy?: string,
+    sortDirection?: SortDirection,
+    filter?: Partial<F>,
+    options?: O
+  ): Observable<LoadResult<T>>;
+
+  // TODO
+  /*watchPage(
+    page: Page<T>,
+    filter?: F,
+    options?: O
+  ): Observable<LoadResult<T>>;*/
+
+  saveAll(data: T[], opts?: any): Promise<T[]>;
+
+  deleteAll(data: T[], opts?: any): Promise<any>;
+
+  asFilter(filter: Partial<F>): F;
+}
+
+export declare type LoadResultByPageFn<T> = (offset: number, size: number) => Promise<LoadResult<T>>;
+
+export interface IEntityFullService<T, ID, F, O extends EntitiesServiceWatchOptions & EntityServiceLoadOptions>
+  extends IEntityService<T, ID, O>, IEntitiesService<T, F, O>  {
+}
+
+export function mergeLoadResult<T>(res1: LoadResult<T>, res2: LoadResult<T>): LoadResult<T> {
+  return {
+    data : (res1.data || []).concat(...res2.data),
+    total: ((res1.total || res1.data?.length || 0) + (res2.total || res2.data?.length || 0))
+  };
+}

package/src/app/shared/services/job.utils.ts

@@ -0,0 +1,121 @@
+import { BehaviorSubject, defer, Observable } from 'rxjs';
+import { isNil, isNotNil, toNumber } from '../functions';
+import { LoadResult, LoadResultByPageFn } from './entity-service.class';
+
+export type CallableWithProgressionFn<O extends CallableWithProgressionOptions> = (opts?: O) => Promise<any>;
+export interface CallableWithProgressionOptions {
+  maxProgression?: number;
+  progression?: BehaviorSubject<number>;
+  [key: string]: any;
+}
+
+// @dynamic
+export class JobUtils {
+
+  static defers<O extends CallableWithProgressionOptions>(runnableList: CallableWithProgressionFn<O>[], opts?: O): Observable<number>[] {
+    return runnableList.map(runnable => JobUtils.defer(runnable, opts));
+  }
+
+  static defer<O extends CallableWithProgressionOptions>(runnable: CallableWithProgressionFn<O>, opts?: O): Observable<number> {
+    return defer<Observable<number>>(() => JobUtils.run(runnable, opts));
+  }
+
+  static run<O extends CallableWithProgressionOptions>(runnable: CallableWithProgressionFn<O>, opts: O): Observable<number> {
+
+    const progression = new BehaviorSubject<number>(0);
+    runnable({...opts, progression})
+      .then(() => {
+        if (opts?.maxProgression) progression.next(opts.maxProgression);
+        progression.complete();
+      })
+      .catch(err => progression.error(err));
+    return progression;
+  }
+
+  static async fetchAllPages<T>(
+    loadPageFn: LoadResultByPageFn<T>,
+    opts?: {
+      progression?: BehaviorSubject<number>;
+      maxProgression?: number;
+      onPageLoaded?: (pageResult: LoadResult<T>) => any;
+      logPrefix?: string;
+      fetchSize?: number;
+    }): Promise<LoadResult<T>> {
+
+    const maxProgression = toNumber(opts?.maxProgression, 100);
+    const progression = opts?.progression;
+    let total; let pageCount; let progressionStep; let currentPageDataCount: number;
+    const fetchSize = toNumber(opts?.fetchSize, 1000);
+    if (fetchSize <= 0) throw new Error('Unable to fetch pages: invalid fetchSize: ' + fetchSize);
+    let offset = 0;
+    let data: T[] = [];
+    do {
+
+      if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} Fetching page #${offset / fetchSize}...`);
+
+      // Fetch a page
+      const res = await loadPageFn(offset, fetchSize);
+
+      // Concat to previous result
+      data = data.concat(res.data);
+
+      // Compute variables, for next loop
+      currentPageDataCount = res.data && res.data.length || 0;
+      offset += currentPageDataCount;
+
+      // Set total count (only once)
+      if (isNil(total) && isNotNil(res.total)) {
+        total = res.total;
+        // Compute the number of page
+        pageCount = Math.round(res.total / fetchSize + 0.5); // Round to HALF_UP integer
+        // Compute step, by dividing maxProgression by number of page
+        if (progression) {
+          progressionStep = maxProgression / pageCount;
+          // DEBUG
+          if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} {pageCount: ${pageCount}, progress: ${progression.value?.toFixed(2)}, pageProgressStep: ${progressionStep?.toFixed(1)}}`);
+        }
+      }
+
+      // Increment progression on each iteration (if possible)
+      if (isNotNil(progressionStep)) {
+        progression.next(progression.value + progressionStep);
+      }
+
+      if (opts?.onPageLoaded) opts.onPageLoaded(res);
+
+    } while (currentPageDataCount > 0 && ((isNil(total) && currentPageDataCount === fetchSize) || (isNotNil(total) && (offset < total))));
+
+    // Complete progression to reach progressionStep value (because of round)
+    if (isNotNil(progressionStep)) {
+
+      // If total return by loadAll was bad !
+      if (isNotNil(total) && data.length < total) {
+        console.warn(`A function loadAll() returned a bad total (less than all page's data)! Expected ${total} but fetch ${data.length}`);
+        total = data.length;
+        pageCount = Math.round(data.length / fetchSize + 0.5);
+      }
+
+      // Compute final increment, using the real page count
+      progressionStep = Math.max(0, maxProgression - (progressionStep * pageCount));
+
+    }
+
+    // Or increment once (e.g. when total is not known, in received LoadResult)
+    else if (progression) {
+      progressionStep = maxProgression;
+    }
+
+    // DEBUG
+    if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} All pages fetched - {progress: ${progression.value?.toFixed(2)}, lastProgressStep: ${progressionStep?.toFixed(1)}`);
+
+    // Final increment
+    if (progression && progressionStep > 0) {
+      progression.next(progression.value + progressionStep);
+    }
+
+    return {
+      data,
+      total
+    };
+  }
+}