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

package/src/app/shared/functions.ts

@@ -1,492 +0,0 @@
-import {KeysEnum, KeyValueType} from './types';
-
-export function isNil<T>(obj: T | null | undefined): boolean {
-  return obj === undefined || obj === null;
-}
-export function isNilOrBlank<T>(obj: T | null | undefined): boolean {
-  return obj === undefined || obj === null || (typeof obj === 'string' && obj.trim() === '');
-}
-export function isNotNil<T>(obj: T | null | undefined): boolean {
-  return obj !== undefined && obj !== null;
-}
-export function isNotNilOrBlank<T>(obj: T | null | undefined): boolean {
-  return obj !== undefined && obj !== null && (typeof obj !== 'string' || obj.trim() !== '');
-}
-export function isNotNilOrNaN<T>(obj: T | null | undefined): boolean {
-  return obj !== undefined && obj !== null && (typeof obj !== 'number' || !isNaN(obj));
-}
-export function isNilOrNaN<T>(obj: T | null | undefined): boolean {
-  return obj === undefined || obj === null || (typeof obj === 'number' && isNaN(obj));
-}
-export function isNotEmptyArray<T>(obj: T[] | null | undefined): boolean {
-  return obj !== undefined && obj !== null && obj.length > 0;
-}
-export function firstArrayValue<T>(obj: T[] | null | undefined): T | undefined {
-  return isNotEmptyArray(obj) ? obj[0] : undefined;
-}
-export function isEmptyArray<T>(obj: T[] | null | undefined): boolean {
-  return obj === undefined || obj === null || !obj.length;
-}
-export function isNotNilBoolean(obj: any | null | undefined): obj is boolean {
-  return obj !== undefined && obj !== null && typeof obj === 'boolean' || false;
-}
-export function isNotNilString(obj: any | null | undefined): obj is string {
-  return obj !== undefined && obj !== null && typeof obj === 'string' || false;
-}
-export function isBlankString(obj: any | null | undefined): obj is string {
-  return (typeof obj === 'string') && obj.trim().length === 0;
-}
-export function notNilOrDefault<T>(obj: T | null | undefined, defaultValue: T): T {
-  return (obj !== undefined && obj !== null) ? obj : defaultValue;
-}
-export function arraySize<T>(obj: T[] | null | undefined): number {
-  return isNotEmptyArray(obj) && obj.length || 0;
-}
-export function arrayGroupBy<
-  T = any,
-  K extends keyof T = any,
-  M extends { [key: string]: T[];
-} = { [key: string]: T[] }>(obj: T[], key: keyof T): M {
-  if (isNil(obj)) return null;
-  return obj.reduce((rv: any, x) => {
-    (rv[x[key]] = rv[x[key]] || []).push(x);
-    return rv;
-  }, {});
-}
-
-/**
- * Remove duplicated value, in array. Will compute a unique key (from given properties, or given function).
- * If propertiesOrKeyFn is nil or undefined, will use all object properties
- * @param values
- * @param propertiesOrKeyFn
- */
-export function arrayDistinct<T = any>(values: T[], propertiesOrKeyFn?: string | string[] | ((obj: T) => string) ): T[] {
-  if (isEmptyArray(values)) return values;
-  const properties: string[] = (!propertiesOrKeyFn && Object.keys(values[0])) || (Array.isArray(propertiesOrKeyFn) && propertiesOrKeyFn);
-  const getKey: (obj: T) => string =
-    (typeof propertiesOrKeyFn === 'function' && propertiesOrKeyFn)
-    || (typeof propertiesOrKeyFn === 'string' && ((obj) => getPropertyByPathAsString(obj, propertiesOrKeyFn)))
-    || (isEmptyArray(properties) && ((obj) => obj?.toString()))
-    || ((obj) => joinPropertiesPath(obj, properties, '|'));
-  const existingIds = new Set<string>();
-  return values.reduce((res, item) => {
-    const uniqueKey = getKey(item);
-    if (existingIds.has(uniqueKey)) return res; // Skip if duplicate
-    existingIds.add(uniqueKey);
-    return res.concat(item);
-  }, []);
-}
-export function nullIfUndefined<T>(obj: T | null | undefined): T | null {
-  return obj === undefined ? null : obj;
-}
-export function undefinedIfNull<T>(obj: T | null | undefined): T | undefined {
-  return obj === null ? undefined : obj;
-}
-export function trimEmptyToNull<T>(str: string | null | undefined): string | null {
-  const value = str && str.trim() || undefined;
-  return value && value.length && value || null;
-}
-export function toBoolean(obj: boolean | null | undefined | string, defaultValue?: boolean): boolean {
-  return (obj !== undefined && obj !== null) ? (obj !== 'false' ? !!obj : false) : defaultValue;
-}
-export function toNumber(obj: number | null | undefined, defaultValue?: number): number {
-  return (obj !== undefined && obj !== null) ? +obj : defaultValue;
-}
-export function toFloat(obj: string | null | undefined, defaultValue?: number): number | null {
-  return (obj !== undefined && obj !== null) ? parseFloat(obj) : defaultValue;
-}
-export function toInt(obj: string | null | undefined, defaultValue?: number): number | null {
-  return (obj !== undefined && obj !== null) ? parseInt(obj, 0) : defaultValue;
-}
-export function toNotNil<T = any>(obj: T, defaultValue?: T): any | null {
-  return (obj !== undefined && obj !== null) ? obj : defaultValue;
-}
-export function removeDuplicatesFromArray<T>(obj: T[] | null | undefined, property?: string): T[] | null | undefined {
-  if (isEmptyArray(obj)) return obj;
-  if (property) {
-    return obj.filter((item, i, array) => array.findIndex(t => t && item && t[property] === item[property]) === i);
-  }
-  return obj.filter((item, i, array) => array.findIndex(t => t && item && t === item) === i);
-}
-export function startsWithUpperCase(input: string, search: string): boolean {
-  return input && input.toUpperCase().startsWith(search);
-}
-export function matchUpperCase(input: string, regexp: string): boolean {
-  return input && !!input.toUpperCase().match(regexp);
-}
-
-/**
- * Remove trailing slash if any. Examples :
- * - '/test/' -> '/test'
- * - '/' -> undefined
- */
-export function noTrailingSlash(path: string): string {
-  if (!path || path.trim() === '/') return undefined;
-  if (path.trim().lastIndexOf('/') === path.length - 1) return path.substring(0, path.length - 1);
-  return path;
-}
-
-export function replaceAll(value: string, searchString: any, replacement): string | undefined {
-  while (value && value.indexOf(searchString) !== -1) {
-    value = value.replace(searchString, replacement);
-  }
-  return value;
-}
-
-export function escapeRegExp(value: string) {
-  return value.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-
-export function removeEnd(value: string, end: string): string {
-  return value?.endsWith(end || '') ? value.substr(0, value.length - end.length) : value;
-}
-
-/**
- * Replace case change by an underscore (.e.g 'myString' becomes 'my_string')
- *
- * @param value
- */
-export function changeCaseToUnderscore(value: string): string {
-  if (isNilOrBlank(value)) return value;
-  return value.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-}
-
-export function removeDiacritics(text: string): string {
-  return text.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
-}
-
-export function suggestFromStringArray(values: string[], value: any, options?: {
-  searchAttribute?: string;
-  searchAttributes?: string[];
-}): string[] {
-  value = (typeof value === 'string' && value !== '*') && value.toUpperCase() || undefined;
-  if (isNilOrBlank(value)) return values;
-
-  // If wildcard, search using regexp
-  if ((value as string).indexOf('*') !== -1) {
-    value = (value as string).replace('*', '.*');
-    return values.filter(v => matchUpperCase(v, value));
-  }
-
-  // If no wildcard, search using startsWith
-  return values.filter(v => startsWithUpperCase(v, value));
-}
-
-export function joinPropertiesPath<T = any>(obj: T, properties: string[], separator?: string): string | undefined {
-  if (!obj) throw new Error('Could not display an undefined entity.');
-  if (isEmptyArray(properties)) throw new Error('Missing or empty \'properties\' argument');
-  return properties
-    .map(path => getPropertyByPath(obj, path))
-    .filter(isNotNilOrBlank)
-    .join(separator || ' - ');
-}
-
-export function joinProperties<T = any, K extends keyof T = any>(obj: T, keys: K[], separator?: string): string | undefined {
-  if (!obj) throw new Error('Could not display an undefined entity.');
-  return keys
-    .map(key => getProperty(obj, key))
-    .filter(isNotNilOrBlank)
-    .join(separator || ' - ');
-}
-
-export function propertyPathComparator<T = any>(path: string|string[]): (a: T, b: T) => number {
-  return (a: T, b: T) => {
-    const valueA = getPropertyByPath(a, path);
-    const valueB = getPropertyByPath(b, path);
-    return valueA === valueB ? 0 : (valueA > valueB ? 1 : -1);
-  };
-}
-
-export function propertyComparator<T = any, K extends keyof T = any>(key: K, defaultValue?: any): (a: T, b: T) => number {
-  return (a: T, b: T) => {
-    const valueA = a[key] !== undefined ? a[key] : defaultValue;
-    const valueB = b[key] ? b[key] : defaultValue;
-    return valueA === valueB ? 0 : (valueA > valueB ? 1 : -1);
-  };
-}
-
-export function propertiesPathComparator<T = any>(keys: string[], defaultValues?: any[]): (a: T, b: T) => number {
-  if (!keys || !keys.length || (defaultValues && keys.length > defaultValues.length)) {
-    throw new Error('Invalid arguments: missing \'keys\' or array \'defaultValues\' has a bad length');
-  }
-  return (a: T, b: T) => keys.map((key, index) => {
-      const valueA = getPropertyByPath(a, key, defaultValues && defaultValues[index]);
-      const valueB = getPropertyByPath(b, key, defaultValues && defaultValues[index]);
-      return valueA === valueB ? 0 : (valueA > valueB ? 1 : -1);
-    })
-      // Stop if not equals, otherwise continue with the next key
-      .find(res => res !== 0) || 0;
-}
-
-export function sort<T>(array: T[], attribute?: string, opts?: Intl.CollatorOptions): T[] {
-  if (isEmptyArray(array)) return array;
-  const compareFn: (a: any, b: any) => number = opts
-    ? new Intl.Collator(undefined, opts).compare
-    : (v1, v2) => v1 === v2 ? 0 : v1 > v2 ? 1 : -1;
-  return array
-    .slice() // copy
-    .sort(attribute
-      ? (a, b) => compareFn(a[attribute], b[attribute])
-      : compareFn);
-}
-const INTEGER_REGEXP = /^[-]?\d+$/;
-export function isInt(value: string): boolean {
-  return isNotNil(value) && INTEGER_REGEXP.test(value);
-}
-const NUMBER_REGEXP = /^[-]?\d+(\.\d+)?$/;
-export function isNumber(value: string): boolean {
-  return isNotNil(value) && NUMBER_REGEXP.test(value);
-}
-
-const NUMBER_RANGE_REGEXP = /^(\d+-\d+)|([><=]*\d+)$/;
-export function isNumberRange(value: string): boolean {
-  return isNotNil(value) && NUMBER_RANGE_REGEXP.test(value);
-}
-
-export function getPropertyByPath(obj: any, path: string|string[], defaultValue?: any): any {
-  // Path is an array: convert path to string
-  if (Array.isArray(path)) {
-    return getPropertyByPath(obj, path.join('.'), defaultValue);
-  }
-  if (isNil(obj)) return defaultValue;
-  if (isNilOrBlank(path)) return obj;
-  const i = path.indexOf('.');
-  // Simple property path
-  if (i === -1) {
-    const res = obj[path];
-    return (isNotNil(res) || isNil(defaultValue)) ? res : defaultValue;
-  }
-  // Complex property path
-  const key = path.substring(0, i);
-  if (isNil(obj[key])) return defaultValue;
-  if (typeof obj[key] === 'object') { // Object or Array
-    // Recursive call
-    return getPropertyByPath(obj[key], path.substring(i + 1));
-  }
-  throw new Error(`Invalid property path: '${key}' is not an valid object.`);
-}
-
-export function getProperty<T = any, K extends keyof T = any>(obj: T, key: K): T[K] {
-  if (isNil(obj)) return undefined;
-  return obj[key]; // Inferred type is T[K]
-}
-
-export function getPropertyByPathAsString(obj: any, path: string|string[]): string | undefined {
-  const res = getPropertyByPath(obj, path);
-  return (typeof res === 'string') ? res : ('' + res);
-}
-
-export function setPropertyByPath(obj: any, path: string|string[], value: any): any {
-  // Path is an array: convert path to string
-  if (Array.isArray(path)) {
-    return setPropertyByPath(obj, path.join('.'), value);
-  }
-  if (isNil(obj)) return; // Skip
-  const i = path.indexOf('.');
-  // Simple property path
-  if (i === -1) {
-    obj[path] = value;
-    return;
-  }
-  const key = path.substring(0, i);
-  if (isNil(obj[key])) return undefined;
-  if (obj[key] && typeof obj[key] === 'object') {
-    return setPropertyByPath(obj[key], path.substring(i + 1), value);
-  }
-  throw new Error(`Invalid form path: '${key}' is not an valid object.`);
-}
-
-export function sleep(ms: number): Promise<void> {
-  if (ms <= 0) return;
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-export function round(value: number | undefined | null): number {
-  if (isNotNilOrNaN(value)) {
-    return Math.round((value + Number.EPSILON) * 100) / 100;
-  }
-  return value;
-}
-
-export function equalsOrNil(value1: any, value2: any) {
-  return (value1 === value2) || (isNil(value1) && isNil(value2));
-}
-
-/**
- * remove elements from an array
- *
- * @return the removed elements
- * @param array the array on which elements will be removed
- * @param predicate the selection predicate
- */
-export function removeAll<T>(array: T[], predicate: (pmfm: T) => boolean): T[] {
-  let nbRemove = 0;
-  return array.slice().map((value, index) => {
-    if (predicate(value)) {
-      nbRemove++; // glitch counter to avoid index gap
-      return array.splice(index - nbRemove + 1, 1)[0];
-    }
-    return null;
-  }).filter(isNotNil);
-}
-
-/**
- * remove the first element from an array
- *
- * @return the removed element
- * @param array the array on which the element will be removed
- * @param predicate the selection predicate
- */
-export function remove<T>(array: T[], predicate: (pmfm: T) => boolean): T {
-  return array.slice().find((value, index) => {
-    if (predicate(value)) {
-      array.splice(index, 1);
-      return true;
-    }
-    return false;
-  });
-}
-
-export function capitalizeFirstLetter(value: string) {
-  if (!value || value.length === 0) return value;
-  return value.substr(0, 1).toUpperCase() + value.substr(1);
-}
-export function uncapitalizeFirstLetter(value: string) {
-  if (!value || value.length === 0) return value;
-  return value.substr(0, 1).toLowerCase() + value.substr(1);
-}
-
-export function splitByProperty<T, M extends KeyValueType<T> = KeyValueType<T>>(array: T[] | readonly T[], propertyName: keyof T | string): M {
-  return (array || []).reduce((res, value) => {
-    const key = (value as unknown as any)?.[propertyName];
-    if (isNotNil(key)) {
-      res[key] = value;
-    }
-    return res;
-  }, {}) as M;
-}
-
-export function splitById<T, M extends KeyValueType<T> = KeyValueType<T>>(array: T[] | readonly T[]): M {
-  return (array || []).reduce((res, value) => {
-    const key = value?.['id'];
-    if (isNotNil(key)) {
-      res[key] = value;
-    }
-    return res;
-  }, <M>{});
-}
-
-/**
- * Split an array, into a map of array, group by property
- */
-export function collectByProperty<T>(values: T[], propertyName: keyof T): KeyValueType<T[]> {
-  return (values || []).reduce((res, item) => {
-    const key = item && item[propertyName];
-    if (typeof key === 'number' || typeof key === 'string') {
-      res[key] = res[key] || [];
-      res[key].push(item);
-    }
-    return res;
-  }, <KeyValueType<T[]>>{});
-}
-
-/**
- * Determines if two objects or two values are equivalent.
- *
- * Two objects or values are considered equivalent if at least one of the following is true:
- *
- * * Both objects or values pass `===` comparison.
- * * Both objects or values are of the same type and all of their properties are equal by
- *   comparing them with `equals`.
- *
- * @param o1 Object or value to compare.
- * @param o2 Object or value to compare.
- * @returns true if arguments are equal.
- */
-export function equals(o1: any, o2: any): boolean {
-  if (o1 === o2) return true;
-  if (o1 === null || o2 === null) return false;
-  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
-  let t1 = typeof o1, t2 = typeof o2, length: number, key: any, keySet: any;
-  if (t1 == t2 && t1 == 'object') {
-    if (Array.isArray(o1)) {
-      if (!Array.isArray(o2)) return false;
-      if ((length = o1.length) == o2.length) {
-        for (key = 0; key < length; key++) {
-          if (!equals(o1[key], o2[key])) return false;
-        }
-        return true;
-      }
-    } else {
-      if (Array.isArray(o2)) {
-        return false;
-      }
-      keySet = Object.create(null);
-      for (key in o1) {
-        if (!equals(o1[key], o2[key])) {
-          return false;
-        }
-        keySet[key] = true;
-      }
-      for (key in o2) {
-        if (!(key in keySet) && typeof o2[key] !== 'undefined') {
-          return false;
-        }
-      }
-      return true;
-    }
-  }
-  return false;
-}
-
-// @dynamic
-export class Beans {
-  /**
-   * Copy a source object, by including only properties of the given dataType.
-   * IMPORTANT: extra properties that are NOT in the targetClass are NOT copied.
-   *
-   * @param source The source object to copy
-   * @param dataType the class to use as target class
-   * @param keys The keys to copy. If empty, will copy only NOT optional properties from the dataType
-   */
-  static copy<T>(source: T, dataType: new () => T, keys?: KeysEnum<T>): T {
-    if (isNil(source)) return source;
-    const target = new dataType();
-    Object.keys(keys || target).forEach(key => {
-      target[key] = source[key];
-    });
-    return target;
-  }
-
-  /**
-   * Says if an object all all properties to nil
-   */
-  static isEmpty<T>(data: T, keys?: KeysEnum<T>|string[], opts?: {
-    blankStringLikeEmpty?: boolean;
-  }): boolean {
-    return isNil(data) || (Array.isArray(keys) ? keys : Object.keys(keys || data))
-      // Find index of the first NOT nil value
-      .findIndex(key => {
-        const value = data[key];
-        if (value && typeof value === 'object') return !Beans.isEmpty(value, null, opts); // Loop
-        if (opts && opts.blankStringLikeEmpty === true && typeof value === 'string') return isNotNilOrBlank(value);
-        return isNotNil(value);
-      }) === -1;
-  }
-
-  static collectById<T>(array: T[]): KeyValueType<T[]> {
-    return collectByProperty(array, 'id' as keyof T);
-  }
-
-  static collectByProperty = collectByProperty;
-}
-
-export function findParentWithClass(elem: HTMLElement, className: string): HTMLElement {
-  if (!className) return undefined;
-  let currentElement = elem?.parentElement;
-  while (currentElement) {
-    if (currentElement.classList.contains(className)) return currentElement;
-    currentElement = currentElement.parentElement;
-  }
-  return undefined;
-}

package/src/app/shared/geolocation/geolocation.utils.ts

@@ -1,101 +0,0 @@
-import { Geolocation, Position } from '@capacitor/geolocation';
-import {PlatformService} from '../../core/services/platform.service';
-import {Platform} from '@ionic/angular';
-import {isNil} from '../functions';
-
-export class IPosition {
-  latitude: number;
-  longitude: number;
-}
-
-export abstract class GeolocationUtils {
-
-  static isNotNilAndValid(position: IPosition, opts?: {debug?: boolean}) {
-
-    if (!position || isNil(position.latitude) || isNil(position.longitude)) return false;
-
-    // Invalid lat/lon
-    if (position.latitude < -90 || position.latitude > 90
-      || position.longitude < -180 || position.longitude > 180) {
-
-      // /!\ Log in console, because should never occur
-      if (opts?.debug) console.warn('Invalid lat/long position:  ', position);
-      return false;
-    }
-
-    // OK: valid
-    return true;
-  }
-
-  static isNilOrInvalid(position: IPosition, opts?: {debug?: boolean}) {
-    return !GeolocationUtils.isNotNilAndValid(position, opts);
-  }
-
-  static computeDistanceInMiles(position1: IPosition, position2: IPosition): number {
-    // Invalid position(s): skip
-    if (GeolocationUtils.isNilOrInvalid(position1, {debug: true})
-      || GeolocationUtils.isNilOrInvalid(position2, {debug: true})) return;
-
-    const latitude1Rad = Math.PI * position1.latitude / 180;
-    const longitude1Rad = Math.PI * position1.longitude / 180;
-    const latitude2Rad = Math.PI * position2.latitude / 180;
-    const longitude2Rad = Math.PI * position2.longitude / 180;
-
-    let distance = 2 * 6371 * Math.asin(
-      Math.sqrt(
-        Math.pow(Math.sin((latitude1Rad - latitude2Rad) / 2), 2)
-        + Math.cos(latitude1Rad) * Math.cos(latitude2Rad) * Math.pow(Math.sin((longitude2Rad - longitude1Rad) / 2), 2)
-      ));
-    distance = Math.round((((distance / 1.852) + Number.EPSILON) * 100)) / 100;
-    return distance;
-  }
-
-  /**
-   * Get the position by geo loc sensor
-   */
-  static async getCurrentPosition(platform: PlatformService|Platform, options?: PositionOptions): Promise<IPosition> {
-
-    // Use Capacitor plugin
-    try {
-      console.info(`[geolocation-utils] Get current geo location, using Capacitor...(timeout: ${options?.timeout})`);
-      const pos: Position = await Geolocation.getCurrentPosition(options);
-      return <IPosition>{
-        latitude: pos.coords.latitude,
-        longitude: pos.coords.longitude
-      };
-    } catch (err) {
-      // If capacitor : throw error (cannot fallback to browser geolocation, because of browser security limitation)
-      if (platform.is('capacitor')) {
-        console.error(`[geolocation-utils] Cannot get current geo location, using Capacitor: ${err?.message||''}`);
-
-        // Detect a permission error, to add code
-        // FIXME - Capacitor use hardcoded strings! (see https://github.com/ionic-team/capacitor-plugins)
-        const message = ((err?.message || '') as string).toLowerCase();
-        if (message.includes('location permission was denied') || message.includes('location disabled')) {
-          throw {...err, code: GeolocationPositionError.PERMISSION_DENIED};
-        }
-        throw err;
-      }
-    }
-
-    // Or fallback to navigator
-    console.info('[geolocation-utils] Get current geo location, using browser...')
-    return new Promise<IPosition>((resolve, reject) => {
-      navigator.geolocation.getCurrentPosition((res) => {
-          resolve(<IPosition>{
-            latitude: res.coords.latitude,
-            longitude: res.coords.longitude
-          });
-        },
-        (err) => {
-          let message = err?.message || err;
-          message = typeof message === 'string' ? message : JSON.stringify(message);
-          console.error('[geolocation-utils] Cannot get current geo location, using browser:' + message);
-          reject(err);
-        },
-        options
-      );
-    });
-  }
-
-}

package/src/app/shared/gesture/gesture-config.ts

@@ -1,45 +0,0 @@
-import {Injectable} from '@angular/core';
-import {HammerGestureConfig} from '@angular/platform-browser';
-
-export const HAMMER_TAP_TIME = 250;
-export const HAMMER_PRESS_TIME = 400; // Increase need for double tap (default: 251 ms)
-/**
- * @hidden
- * This class overrides the default Angular gesture config.
- *
- */
-@Injectable({providedIn: 'root'})
-export class AppGestureConfig extends HammerGestureConfig {
-
-  // Override HammerJS default settings
-  overrides = <any>{
-    press: {
-      time: HAMMER_PRESS_TIME
-    },
-    pinch: {
-      enable: false
-    },
-    rotate: {
-      enable: false
-    },
-    // see https://hammerjs.github.io/recognizer-swipe/
-    swipe: {
-      threshold: 30,  // Minimal distance required before recognizing.
-      velocity: 0.4  //Minimal velocity required before recognizing, unit is in px per ms.
-    }
-  };
-
-  buildHammer(element: HTMLElement) {
-
-    // DEBUG
-    console.debug('[gesture] Applying HammerJS config to ', element.tagName);
-
-    const mc = new (<any>window).Hammer(element);
-
-    for (const eventName in this.overrides) {
-      if (eventName) mc.get(eventName).set(this.overrides[eventName]);
-    }
-
-    return mc;
-  }
-}

package/src/app/shared/gesture/hammer.utils.ts

@@ -1,14 +0,0 @@
-export declare type HammerSwipeAction = 'swipeleft' | 'swiperight';
-export declare interface HammerSwipeEvent extends Event {
-  type: HammerSwipeAction;
-  pointerType?: 'touch' | any;
-  center?: {x: number; y: number };
-  distance?: number;
-  velocity?: number;
-  srcEvent?: Event;
-}
-
-export declare interface HammerTapEvent extends Event {
-  tapCount?: number;
-  srcEvent?: Event;
-}