@sumaris-net/ngx-components 18.14.0 → 18.14.2

package/src/app/core/services/model/entity.model.ts

@@ -1,409 +0,0 @@
-import { isMoment, Moment } from 'moment';
-import { getPropertyByPath, isEmptyArray, isNil, isNilOrBlank, isNotNil, joinPropertiesPath } from '../../../shared/functions';
-import { FilterFn, KeyValueType, ObjectMap, ObjectMapEntry } from '../../../shared/types';
-import { StoreObject } from '@apollo/client/core';
-import { fromDateISOString, toDateISOString } from '../../../shared/dates';
-import { TreeItemEntityUtils } from './tree-item-entity.model';
-import { SortDirection } from '@angular/material/sort';
-import { AppPropertiesUtils } from '../../form/properties/properties.utils';
-
-export declare interface Cloneable<T> {
-  clone(): T;
-}
-
-export function entityToString(obj: Entity<any> | any, properties?: string[]): string | undefined {
-  return (obj && obj.id && joinPropertiesPath(obj, properties || ['name'])) || undefined;
-}
-
-export interface EntityAsObjectOptions {
-  minify?: boolean;
-  keepTypename?: boolean; // true by default
-  keepLocalId?: boolean; // true by default
-}
-
-export interface IEntity<T, ID = number, AO extends EntityAsObjectOptions = EntityAsObjectOptions, FO = any> extends Cloneable<T> {
-  id: ID;
-  updateDate: Moment;
-  __typename: string;
-  equals(other: T): boolean;
-  clone(opts?: AO & FO): T;
-  copy(target: T, opts?: AO & FO): void;
-  asObject(opts?: AO): any;
-  fromObject(source: any, opts?: FO): void;
-}
-
-export declare type OmitFunctions<T extends IEntity<T, any>> = {
-  [K in keyof T as T[K] extends Function ? never : K]: T[K];
-};
-
-//@dynamic
-export abstract class Entity<T extends Entity<T, ID, AO, FO>, ID = number, AO extends EntityAsObjectOptions = EntityAsObjectOptions, FO = any>
-  implements IEntity<T, ID, AO, FO>
-{
-  // The GraphQL typename (injected by @EntityClass())
-  static TYPENAME: string;
-
-  id: ID = null;
-  updateDate: Moment = null;
-  __typename: string;
-
-  constructor(__typename?: string) {
-    this.__typename = __typename || null;
-  }
-
-  clone(opts?: AO & FO): T {
-    const target = new (this.constructor as any)() as T;
-    this.copy(target, opts);
-    return target;
-  }
-
-  copy(target: T, opts?: AO & FO) {
-    target.fromObject(this.asObject(opts), opts);
-  }
-
-  asObject(opts?: AO): StoreObject {
-    const target: any = Object.assign({}, this); //= {...this};
-    if (!opts || opts.keepTypename !== true) delete target.__typename;
-    target.updateDate = toDateISOString(this.updateDate);
-    if (target.id == null || (opts && opts.keepLocalId === false && target.id < 0)) {
-      delete target.id;
-      delete target.updateDate; // Make to sens to keep updateDate of a local entity to save
-    }
-    return target;
-  }
-
-  fromObject(source: any, opts?: FO) {
-    this.id = source.id || source.id === 0 ? source.id : undefined;
-    this.updateDate = fromDateISOString(source.updateDate);
-    this.__typename = source.__typename || this.__typename; // Keep original type (can be set in constructor)
-  }
-
-  equals(other: T): boolean {
-    return other && this.id === other.id;
-  }
-}
-
-/**
- * @deprecated use standard instanceof instead
- * @param obj
- * @param constructor
- */
-export function isInstanceOf<T>(obj: any, constructor: new (...args: any[]) => T): obj is T {
-  if (!obj) return false;
-
-  return obj instanceof constructor;
-}
-
-// @dynamic
-export abstract class EntityUtils {
-  // Check that the object is an entity
-  static isEntity<T extends IEntity<any>>(obj: T | any): obj is T {
-    return isNotNil(obj?.__typename) && typeof obj.fromObject === 'function' && typeof obj.asObject === 'function';
-  }
-
-  // Check that the object has a NOT nil attribute (ID by default)
-  static isNotEmpty<T extends IEntity<any> | any>(obj: T, checkedAttribute: keyof T = <keyof T>'id'): boolean {
-    return !!obj && obj[checkedAttribute] !== null && obj[checkedAttribute] !== undefined;
-  }
-
-  // Check that the object has a nil attribute (ID by default)
-  static isEmpty<T extends IEntity<any> | any>(obj: T, checkedAttribute: keyof T = <keyof T>'id'): boolean {
-    return !obj || obj[checkedAttribute] === null || obj[checkedAttribute] === undefined;
-  }
-
-  static equals<T extends IEntity<any> | any>(o1: T, o2: T, checkAttribute?: keyof T): boolean {
-    checkAttribute = checkAttribute || ('id' as keyof T);
-    return o1 === o2 || (isNil(o1) && isNil(o2)) || (o1 && o2 && o1[checkAttribute] === o2[checkAttribute]);
-  }
-
-  static getPropertyByPath = getPropertyByPath;
-
-  static getArrayAsMap<T = any>(source?: ObjectMapEntry<T>[]): ObjectMap<T> {
-    return (source || []).reduce((res, item) => {
-      res[item.key] = item.value;
-      return res;
-    }, {});
-  }
-
-  static getMapAsArray<T = any>(source?: ObjectMap<T>): ObjectMapEntry<T>[] {
-    if (Array.isArray(source)) return source;
-    return Object.getOwnPropertyNames(source || {}).map((key) => ({
-      key,
-      value: source[key],
-    }));
-  }
-
-  static getPropertyArrayAsObject = AppPropertiesUtils.arrayAsObject;
-
-  static copyIdAndUpdateDate<T extends Entity<any, any, any>>(source: T, target: T) {
-    if (!source) return;
-
-    // Update (id and updateDate)
-    target.id = isNotNil(source.id) ? source.id : target.id;
-    target.updateDate = fromDateISOString(source.updateDate) || target.updateDate;
-
-    // Update creation Date, if exists
-    if (source['creationDate']) {
-      target['creationDate'] = fromDateISOString(source['creationDate']);
-    }
-  }
-
-  static async fillLocalIds<T extends IEntity<T, any>>(items: T[], sequenceFactory: (firstEntity: T, incrementSize: number) => Promise<number>) {
-    const newItems = (items || []).filter((item) => isNil(item.id) || item.id === 0);
-    if (isEmptyArray(newItems)) return;
-    // Get the sequence
-    let currentId = (await sequenceFactory(newItems[0], newItems.length)) + 1;
-    // Take the min (sequence, id), in case the sequence is corrupted
-    currentId = items.filter((item) => isNotNil(item.id) && item.id < 0).reduce((res, item) => Math.min(res, item.id), currentId);
-    newItems.forEach((item) => (item.id = --currentId));
-  }
-
-  static cleanIdAndUpdateDate<T extends IEntity<T, any>>(source: T, defaultValue = null) {
-    if (!source) return; // Skip
-    source.id = defaultValue;
-    source.updateDate = defaultValue;
-  }
-
-  static cleanIdsAndUpdateDates<T extends IEntity<T, any>>(items: T[], defaultValue = null) {
-    (items || []).forEach((item) => EntityUtils.cleanIdAndUpdateDate(item, defaultValue));
-  }
-
-  static sort<T extends IEntity<T, any> | any>(data: T[], sortBy?: keyof T | string, sortDirection?: SortDirection): T[] {
-    if (!data || data.length <= 1 || !sortBy) return data;
-    return data.sort(this.sortComparator(sortBy, sortDirection));
-  }
-
-  static sortComparator<T extends IEntity<T, any> | any>(sortBy?: keyof T | string, sortDirection?: SortDirection): (a: T, b: T) => number {
-    const after = !sortDirection || sortDirection === 'asc' ? 1 : -1;
-    const property = (sortBy || 'id') as string;
-    return (a, b) => {
-      const valueA = EntityUtils.getPropertyByPath(a, property);
-      const valueB = EntityUtils.getPropertyByPath(b, property);
-      return EntityUtils.compare(valueA, valueB, after);
-    };
-  }
-
-  static compare<T extends IEntity<T, any>>(value1: T, value2: T, direction: 1 | -1, checkAttribute?: keyof T): number {
-    checkAttribute = checkAttribute || 'id';
-    if (EntityUtils.isNotEmpty(value1, checkAttribute) && EntityUtils.isNotEmpty(value2, checkAttribute)) {
-      return EntityUtils.equals(value1, value2, checkAttribute) ? 0 : value1[checkAttribute] > value2[checkAttribute] ? direction : -1 * direction;
-    }
-    return value1 === value2 ? 0 : value1 > value2 ? direction : -1 * direction;
-  }
-
-  static compareValue<T>(value1: T, value2: T, direction: 1 | -1): number {
-    return value1 === value2 ? 0 : value1 > value2 ? direction : -1 * direction;
-  }
-
-  static filter<T extends IEntity<T, any> | any>(data: T[], searchAttribute: string, searchText: string): T[] {
-    const filterFn = this.searchTextFilter(searchAttribute, searchText);
-    return data.filter(filterFn);
-  }
-
-  static searchTextFilter<T extends IEntity<T, any> | any>(searchAttribute: string | string[], searchText: string): FilterFn<T> {
-    if (isNilOrBlank(searchAttribute) || isNilOrBlank(searchText)) return undefined; // filter not need
-
-    const searchRegexp = searchText
-      // Escape special characters
-      // eslint-disable-next-line no-useless-escape
-      .replace(/[-\/\\^$+.()|[\]{}]/g, '\\$&')
-      // Interpret * as any text
-      .replace(/[*]+/g, '.*')
-      // Interpret ? as one character
-      .replace(/[?]/g, '.');
-    if (searchRegexp === '.*') return undefined; // filter not need
-
-    const flags = 'i'; // don't use global regex search
-    const asPrefixPattern = '^' + searchRegexp;
-    const anyMatchPattern = '^.*' + searchRegexp;
-
-    // Only one search attributes
-    if (typeof searchAttribute === 'string') {
-      const isSimplePath = !searchAttribute || searchAttribute.indexOf('.') === -1;
-      const searchAsPrefix = searchAttribute.toLowerCase().endsWith('label') || searchAttribute.toLowerCase().endsWith('code');
-      const regexp = new RegExp((searchAsPrefix && asPrefixPattern) || anyMatchPattern, flags);
-      if (isSimplePath) {
-        return (a) => regexp.test(a[searchAttribute]);
-      } else {
-        return (a) => regexp.test(EntityUtils.getPropertyByPath(a, searchAttribute));
-      }
-    }
-
-    // many search attributes
-    else {
-      const regexps = searchAttribute.map((path) => {
-        const searchAsPrefix = path.toLowerCase().endsWith('label') || path.toLowerCase().endsWith('code');
-        return new RegExp((searchAsPrefix && asPrefixPattern) || anyMatchPattern, flags);
-      });
-      return (a) => searchAttribute.findIndex((path, index) => regexps[index].test(EntityUtils.getPropertyByPath(a, path))) !== -1;
-    }
-  }
-
-  /**
-   * Transform a batch entity tree into a array list. This method keep links parent/children.
-   *
-   * Method used to find batch without id (e.g. before local storage)
-   *
-   * @param source
-   */
-  static treeToArray = TreeItemEntityUtils.treeToArray;
-
-  static listOfTreeToArray = TreeItemEntityUtils.listOfTreeToArray;
-
-  /**
-   * Fill parent attribute, of all children found in the tree
-   *
-   * @param source
-   */
-  static treeFillParent = TreeItemEntityUtils.treeFillParent;
-
-  static isLocal(entity: IEntity<any, any> | Entity<any, any>): boolean {
-    return entity && isNotNil(entity.id) && +entity.id < 0;
-  }
-
-  static isRemote(entity: IEntity<any, any> | Entity<any, any>): boolean {
-    return entity && !EntityUtils.isLocal(entity);
-  }
-
-  static isLocalId(id: number): boolean {
-    return isNotNil(id) && +id < 0;
-  }
-
-  static isRemoteId(id: number): boolean {
-    return isNotNil(id) && +id >= 0;
-  }
-
-  static getId<T extends IEntity<T, ID> = IEntity<any, any>, ID = any>(entity: T): ID {
-    return entity.id;
-  }
-
-  // Check that the object has an ID
-  static hasId<T extends IEntity<any, any> = IEntity<any, any>>(entity: T): boolean {
-    return isNotNil(entity?.id);
-  }
-
-  // Check that the object has an nil ID
-  static hasNilId<T extends IEntity<any, any> = IEntity<any, any>>(entity: T): boolean {
-    return isNil(entity?.id);
-  }
-
-  /**
-   * Splits an array of entities into a key-value map using an entity ID as the key.
-   *
-   * @param {Array<T>} entities - The array of entities to be split by their ID.
-   * @return {KeyValueType<T>} A key-value map with entity IDs as keys and entities as values.
-   */
-  static splitById<T extends IEntity<T, ID>, ID = any>(entities: T[]): KeyValueType<T> {
-    return (entities || []).reduce(
-      (res, item) => {
-        const key = item?.id;
-        if (typeof key === 'number' || typeof key === 'string') {
-          res[key] = item;
-        }
-        return res;
-      },
-      <KeyValueType<T>>{}
-    );
-  }
-
-  /**
-   * Collects the IDs from an array of entities and returns them as an array.
-   *
-   * @param {T[]} entities - An array of entities from which to collect IDs.
-   * @return {ID[]} An array of IDs collected from the entities.
-   */
-  static collectIds<T extends IEntity<T, ID>, ID = any>(entities: T[]): ID[] {
-    return (entities || []).map((e) => e.id);
-  }
-
-  /**
-   * @deprecated Use collectIds() instead - will be remove in next major release
-   */
-  static collectById<T extends IEntity<T, ID>, ID = any>(entities: T[]): ID[] {
-    return (entities || []).map((e) => e.id);
-  }
-
-  static arrayDistinctFilterFn<E extends IEntity<any, any>>(item: E, index: number, values: E[]): boolean {
-    return values.findIndex((e) => e.id === item.id) === index;
-  }
-
-  static findById<E extends IEntity<any, ID> = IEntity<any, any>, ID = number>(items: E[], id: ID): E | undefined {
-    return (items || []).find((g) => g.id === id);
-  }
-
-  static fromObject<E extends IEntity<any, any>>(source: any, dataType: new () => E): E {
-    if (!source) return source;
-    if (source instanceof dataType) return source as E;
-    const target = new dataType();
-    if (EntityUtils.isEntity(target)) {
-      target.fromObject(source);
-    } else {
-      Object.assign(target, source);
-    }
-    return target;
-  }
-
-  /**
-   * Recursively converts any object, entity, or array to a plain JavaScript object.
-   * This method handles entities by calling their asObject() method, processes arrays recursively,
-   * and provides protection against circular references.
-   *
-   * @param {any} source - The source object, entity, array, or primitive value to convert
-   * @param {any} [opts] - Optional configuration object passed to entity asObject() methods
-   * @param {WeakSet} [visited=new WeakSet()] - Internal parameter for circular reference detection
-   * @returns {any} A plain JavaScript object representation of the source
-   *
-   * @example
-   * // Convert a simple entity
-   * const plainObject = EntityUtils.asObject(myEntity);
-   *
-   * @example
-   * // Convert an array of entities
-   * const plainArray = EntityUtils.asObject([entity1, entity2]);
-   *
-   * @example
-   * // Convert with options
-   * const result = EntityUtils.asObject(myEntity, { minify: true });
-   */
-  static asObject(source: any, opts?: any, visited = new WeakSet()): any {
-    if (!source) return source;
-    if (Array.isArray(source)) return source.map((item) => EntityUtils.asObject(item, opts, visited));
-    if (EntityUtils.isEntity(source)) return source.asObject(opts);
-    if (typeof source === 'function') return undefined;
-    if (typeof source !== 'object') return source;
-
-    // Protection against circular references
-    if (visited.has(source)) {
-      console.warn('[EntityUtils.asObject] Circular reference detected, skipping object');
-      return {}; // or return null based on your needs
-    }
-    visited.add(source);
-
-    // Handle special objects
-    if (isMoment(source) || typeof source.toISOString === 'function') return source.toISOString();
-    if (source instanceof RegExp) return source.toString();
-
-    // Create a copy
-    const target = { ...source };
-
-    // Serialize all properties recursively
-    Object.keys(target).forEach((key) => {
-      const value = target[key];
-
-      // Handle arrays
-      if (Array.isArray(value)) {
-        target[key] = value.map((item) => EntityUtils.asObject(item, opts, visited));
-      }
-      // Handle objects (including entities)
-      else if (value && typeof value === 'object') {
-        target[key] = EntityUtils.asObject(value, opts, visited);
-      }
-      // Primitive values are already copied by spread operator
-    });
-
-    // Remove object from Set after processing
-    visited.delete(source);
-
-    return target;
-  }
-}

package/src/app/core/services/model/filter.model.ts

@@ -1,127 +0,0 @@
-import { isEmptyArray } from '../../../shared/functions';
-import { MINIFY_ENTITY_FOR_POD, ReferentialUtils } from './referential.model';
-import { Entity, EntityAsObjectOptions, IEntity, isInstanceOf } from './entity.model';
-
-import { FilterFn } from '../../../shared/types';
-
-export interface IEntityFilter<
-  F extends IEntityFilter<F, T, ID, AO, FO>,
-  T extends IEntity<T, any>,
-  ID = number,
-  AO extends EntityAsObjectOptions = EntityAsObjectOptions,
-  FO = any,
-> extends IEntity<F, ID, AO, FO> {
-  asPodObject(): any;
-
-  asFilterFn(): FilterFn<T>;
-
-  isEmpty(): boolean;
-
-  countNotEmptyCriteria(): number;
-}
-
-export abstract class EntityFilter<
-    F extends IEntityFilter<F, T, ID, AO, FO>,
-    T extends IEntity<T, any>,
-    ID = number,
-    AO extends EntityAsObjectOptions = EntityAsObjectOptions,
-    FO = any,
-  >
-  extends Entity<F, ID, AO, FO>
-  implements IEntityFilter<F, T, ID, AO, FO>
-{
-  /**
-   * Compose some filter functions: all should return true
-   *
-   * @param filterFns
-   */
-  static composeFilters<T extends IEntity<T, any>>(filterFns: FilterFn<T>[]): FilterFn<T> {
-    if (isEmptyArray(filterFns)) return undefined;
-    return (entity) => (filterFns || []).every((fn) => fn(entity));
-  }
-
-  static compose<F extends EntityFilter<F, T>, T extends IEntity<T, any>>(filters: F[]): FilterFn<T> {
-    const filterFns = (filters || []).reduce((res, f) => {
-      const fns = f.buildFilter();
-      if (!fns) return res;
-      return res.concat(fns);
-    }, []);
-    return this.composeFilters(filterFns);
-  }
-
-  /**
-   * Compose some filter functions: all should return true
-   *
-   * @param filterFns
-   */
-  static composeFns<T extends IEntity<T, any>>(filterFns: FilterFn<T>[]): FilterFn<T> {
-    if (isEmptyArray(filterFns)) return undefined;
-    return (entity) => (filterFns || []).every((fn) => fn(entity));
-  }
-
-  constructor(__typename?: string) {
-    super(__typename);
-  }
-
-  /**
-   * Clean a filter, before sending to the pod (e.g convert dates, remove internal properties, etc.)
-   */
-  asPodObject(): any {
-    return this.asObject(MINIFY_ENTITY_FOR_POD as AO);
-  }
-
-  isEmpty(): boolean {
-    return this.countNotEmptyCriteria() === 0;
-  }
-
-  countNotEmptyCriteria(): number {
-    const json = this.asPodObject();
-    return Object.keys(json).filter((key) => this.isCriteriaNotEmpty(key, json[key])).length;
-  }
-
-  asFilterFn(): FilterFn<T> {
-    const filterFns = this.buildFilter();
-    return EntityFilter.composeFns(filterFns);
-  }
-
-  protected buildFilter(): FilterFn<T>[] {
-    // Can be completed by subclasses
-    return [];
-  }
-
-  protected isCriteriaNotEmpty(key: string, value: any): boolean {
-    // Can be overridden by subclasses
-    return (
-      value !== undefined &&
-      value !== null &&
-      // not empty string
-      ((typeof value === 'string' && value.trim() !== '') ||
-        // valid number
-        (typeof value === 'number' && !isNaN(value)) ||
-        // valid boolean
-        typeof value === 'boolean' ||
-        // not empty array
-        (Array.isArray(value) && value.length > 0) ||
-        // entity with an id
-        ReferentialUtils.isNotEmpty(value))
-    );
-  }
-}
-
-export abstract class EntityFilterUtils {
-  static isEntityFilter<F extends EntityFilter<F, any>>(obj: Partial<F>): obj is F {
-    return (obj && obj.asPodObject && obj.asFilterFn && true) || false;
-  }
-
-  static fromObject<F>(source: any, filterType: new () => F): F {
-    if (!source) return source;
-    if (isInstanceOf(source, filterType)) return source as F;
-    const target = new filterType();
-    if (EntityFilterUtils.isEntityFilter(target)) {
-      target.fromObject(source);
-    } else {
-      Object.assign(target, source);
-    }
-    return target;
-  }
-}

package/src/app/core/services/model/history.model.ts

@@ -1,25 +0,0 @@
-import { Moment } from 'moment';
-
-export declare interface SynchronizationHistory {
-  name: string;
-  filter?: any;
-  execDate: string;
-  execDurationMs: number;
-  lastUpdateDate?: string;
-  children?: SynchronizationHistory[];
-}
-
-export interface HistoryPageReference {
-  title: string;
-  subtitle?: string;
-  path: string;
-  time?: Moment | string;
-  icon?: string;
-  matIcon?: string;
-
-  children?: HistoryPageReference[];
-
-  // Manage visibility and data access
-  offline?: boolean;
-  onlinePeer?: string;
-}

package/src/app/core/services/model/model.enum.ts

@@ -1,10 +0,0 @@
-// TODO: rename to STATUS_ID_MAP
-// then declare a type like this :
-// > export declare type StatusIds = keyof typeof STATUS_ID_MAP;
-export const StatusIds = {
-  DISABLE: 0,
-  ENABLE: 1,
-  TEMPORARY: 2,
-  DELETED: 3,
-  ALL: 99,
-};

package/src/app/core/services/model/node-feature.model.ts

@@ -1,31 +0,0 @@
-import { Moment } from 'moment/moment';
-import { EntityClass } from './entity.decorators';
-import { Cloneable, Entity, EntityAsObjectOptions } from './entity.model';
-
-@EntityClass({ typename: 'NodeFeatureVO' })
-export class NodeFeature extends Entity<NodeFeature> implements Cloneable<NodeFeature> {
-  static fromObject: (source: any, opts?: any) => NodeFeature;
-
-  label: string;
-  name: string;
-  description: string;
-  logo: string;
-  creationDate: Moment;
-  statusId: number;
-  validityStatusId: number;
-
-  asObject(options?: EntityAsObjectOptions): any {
-    return super.asObject(options);
-  }
-
-  fromObject(source: any) {
-    super.fromObject(source);
-    this.label = source.label;
-    this.name = source.name;
-    this.description = source.description;
-    this.logo = source.logo;
-    this.creationDate = source.creationDate;
-    this.statusId = source.statusId;
-    this.validityStatusId = source.validityStatusId;
-  }
-}