@sumaris-net/ngx-components 2.6.4-manfilt1 → 2.6.4-rc10

package/esm2020/src/app/shared/named-filter/named-filter.service.mjs

@@ -0,0 +1,123 @@
+import { __decorate } from "tslib";
+import { Directive, InjectionToken } from '@angular/core';
+import { Entity, EntityUtils } from '../../core/services/model/entity.model';
+import { EntityFilter } from '../../core/services/model/filter.model';
+import { BaseEntityService } from '../../core/services/base-entity-service.class';
+import { EntityClass } from '../../core/services/model/entity.decorators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/graphql/graphql.service";
+import * as i2 from "../../core/services/platform.service";
+let NamedFilter = class NamedFilter extends Entity {
+    fromObject(source, opts) {
+        this.name = source.name;
+        this.entityName = source.entityName;
+        this.recorderPersonId = source.recorderPersonId;
+        this.recorderDepartmentId = source.recorderDepartmentId;
+        try {
+            this.content = typeof source?.content === 'string' ? JSON.parse(source?.content) : source?.content || undefined;
+        }
+        catch (e) {
+            console.error('[named-filter] can\'t parse content json', source);
+            throw e;
+        }
+    }
+    asObject(opts) {
+        const target = super.asObject(opts);
+        if (opts?.minify) {
+            target.content = JSON.stringify(this.content);
+        }
+        return target;
+    }
+};
+NamedFilter = __decorate([
+    EntityClass({ typename: 'NamedFilterVO' })
+], NamedFilter);
+export { NamedFilter };
+let NamedFilterFilter = class NamedFilterFilter extends EntityFilter {
+    constructor() {
+        super(...arguments);
+        this.searchText = null;
+        this.entityName = null;
+        this.recorderPersonId = null;
+        this.recorderDepartmentId = null;
+    }
+    fromObject(source, opts) {
+        super.fromObject(source, opts);
+        this.searchText = source.searchText;
+        this.entityName = source.entityName;
+        this.recorderPersonId = source.recorderPersonId;
+        this.recorderDepartmentId = source.recorderDepartmentId;
+    }
+};
+NamedFilterFilter = __decorate([
+    EntityClass({ typename: 'NamedFilterFilterVO' })
+], NamedFilterFilter);
+export { NamedFilterFilter };
+export const APP_NAMED_FILTER_SERVICE = new InjectionToken('namedFilterService');
+// @dynamic
+export class AbstractNamedFilterService extends BaseEntityService {
+    constructor(graphql, platform, dataType, filterType, options) {
+        super(graphql, platform, dataType, filterType, {
+            defaultSortBy: 'name',
+            defaultSortDirection: 'asc',
+            ...options
+        });
+        this.graphql = graphql;
+        this.platform = platform;
+        this.dataType = dataType;
+        this.filterType = filterType;
+        this.options = options;
+        this._logPrefix = '[named-filter-service] ';
+    }
+    watchAll(offset, size, sortBy, sortDirection, filter, options) {
+        if (!filter) {
+            filter = this.defaultFilter();
+        }
+        // Always ask total
+        options = {
+            ...options,
+            withTotal: true
+        };
+        // Set query if content is wanted
+        if (options?.withContent) {
+            options.query = this.queries.loadAllWithContent;
+        }
+        return super.watchAll(offset, size, sortBy, sortDirection, filter, options);
+    }
+    async loadAll(offset, size, sortBy, sortDirection, filter, options) {
+        if (!filter) {
+            filter = this.defaultFilter();
+        }
+        // Always ask total
+        options = {
+            ...options,
+            withTotal: true
+        };
+        // Set query if content is wanted
+        if (options?.withContent) {
+            options.query = this.queries.loadAllWithContent;
+        }
+        return super.loadAll(offset, size, sortBy, sortDirection, filter, options);
+    }
+    async suggest(value, filter) {
+        if (EntityUtils.isNotEmpty(value, 'id'))
+            return { data: [value] };
+        value = (typeof value === 'string' && value !== '*' && value) || undefined;
+        return await this.loadAll(0, 1000, 'name', 'asc', this.suggestFilter(value, filter), {
+            withTotal: true,
+            withContent: false
+        });
+    }
+    suggestFilter(searchText, filter) {
+        return {
+            ...filter,
+            searchText
+        };
+    }
+}
+AbstractNamedFilterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AbstractNamedFilterService, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+AbstractNamedFilterService.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AbstractNamedFilterService, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AbstractNamedFilterService, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.GraphqlService }, { type: i2.PlatformService }, { type: undefined }, { type: undefined }, { type: undefined }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"named-filter.service.js","sourceRoot":"","sources":["../../../../../../src/app/shared/named-filter/named-filter.service.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,SAAS,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAExD,OAAO,EAAC,MAAM,EAAyB,WAAW,EAAU,MAAM,wCAAwC,CAAC;AAC3G,OAAO,EAAC,YAAY,EAAgB,MAAM,wCAAwC,CAAC;AAGnF,OAAO,EAAuD,iBAAiB,EAA2B,MAAM,+CAA+C,CAAC;AAChK,OAAO,EAAC,WAAW,EAAC,MAAM,6CAA6C,CAAC;;;;AAaxE,IAAa,WAAW,GAAxB,MAAa,WAA2D,SAAQ,MAAiB;IAS/F,UAAU,CAAC,MAAW,EAAE,IAAU;QAChC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;QAChD,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;QACxD,IAAI;YACF,IAAI,CAAC,OAAO,GAAG,OAAO,MAAM,EAAE,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,OAAO,IAAI,SAAS,CAAC;SACjH;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,CAAC,KAAK,CAAC,0CAA0C,EAAE,MAAM,CAAC,CAAC;YAClE,MAAM,CAAC,CAAC;SACT;IACH,CAAC;IAED,QAAQ,CAAC,IAA4B;QACnC,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,IAAI,EAAE,MAAM,EAAE;YAChB,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAC/C;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF,CAAA;AA7BY,WAAW;IADvB,WAAW,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC;GAC9B,WAAW,CA6BvB;SA7BY,WAAW;AAuCxB,IAAa,iBAAiB,GAA9B,MAAa,iBACX,SAAQ,YAAkB;IAD5B;;QAIE,eAAU,GAAW,IAAI,CAAC;QAC1B,eAAU,GAAW,IAAI,CAAC;QAC1B,qBAAgB,GAAW,IAAI,CAAC;QAChC,yBAAoB,GAAW,IAAI,CAAC;IAStC,CAAC;IAPC,UAAU,CAAC,MAAW,EAAE,IAAU;QAChC,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;QAChD,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;IAC1D,CAAC;CACF,CAAA;AAhBY,iBAAiB;IAD7B,WAAW,CAAC,EAAC,QAAQ,EAAE,qBAAqB,EAAC,CAAC;GAClC,iBAAiB,CAgB7B;SAhBY,iBAAiB;AAmB9B,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,cAAc,CAAgC,oBAAoB,CAAC,CAAC;AAwBhH,WAAW;AAEX,MAAM,OAAgB,0BAQpB,SAAQ,iBAA6C;IAGrD,YACY,OAAuB,EACvB,QAAyB,EACzB,QAAoB,EACpB,UAAsB,EACtB,OAAkD;QAE5D,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE;YAC7C,aAAa,EAAE,MAAM;YACrB,oBAAoB,EAAE,KAAK;YAC3B,GAAG,OAAO;SACX,CAAC,CAAC;QAVO,YAAO,GAAP,OAAO,CAAgB;QACvB,aAAQ,GAAR,QAAQ,CAAiB;QACzB,aAAQ,GAAR,QAAQ,CAAY;QACpB,eAAU,GAAV,UAAU,CAAY;QACtB,YAAO,GAAP,OAAO,CAA2C;QAO5D,IAAI,CAAC,UAAU,GAAG,yBAAyB,CAAC;IAC9C,CAAC;IAID,QAAQ,CACN,MAAc,EACd,IAAY,EACZ,MAAe,EACf,aAA6B,EAC7B,MAAU,EACV,OAAY;QAGZ,IAAI,CAAC,MAAM,EAAE;YACX,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;SAC/B;QAED,mBAAmB;QACnB,OAAO,GAAG;YACR,GAAG,OAAO;YACV,SAAS,EAAE,IAAI;SAChB,CAAC;QACF,iCAAiC;QACjC,IAAI,OAAO,EAAE,WAAW,EAAE;YACxB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC;SACjD;QAED,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9E,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,MAAc,EAAE,IAAY,EAAE,MAAe,EAAE,aAA6B,EAAE,MAAmB,EAAE,OAAkC;QAEjJ,IAAI,CAAC,MAAM,EAAE;YACX,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;SAC/B;QAED,mBAAmB;QACnB,OAAO,GAAG;YACR,GAAG,OAAO;YACV,SAAS,EAAE,IAAI;SAChB,CAAC;QACF,iCAAiC;QACjC,IAAI,OAAO,EAAE,WAAW,EAAE;YACxB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC;SACjD;QAED,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7E,CAAC;IAGD,KAAK,CAAC,OAAO,CAAC,KAAU,EAAE,MAAkB;QAC1C,IAAI,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC;YAAE,OAAO,EAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAC,CAAC;QAChE,KAAK,GAAG,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,CAAC,IAAI,SAAS,CAAC;QAC3E,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAC9C,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,EAC7B;YACF,SAAS,EAAE,IAAI;YACf,WAAW,EAAE,KAAK;SACnB,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,UAAkB,EAAE,MAAmB;QACnD,OAAU;YACR,GAAG,MAAM;YACT,UAAU;SACX,CAAC;IACJ,CAAC;;uHA1FmB,0BAA0B;2GAA1B,0BAA0B;2FAA1B,0BAA0B;kBAD/C,SAAS","sourcesContent":["import {SortDirection} from '@angular/material/sort';\nimport {Directive, InjectionToken} from '@angular/core';\nimport {Observable} from 'rxjs';\nimport {Entity, EntityAsObjectOptions, EntityUtils, IEntity} from '../../core/services/model/entity.model';\nimport {EntityFilter, IEntityFilter} from '../../core/services/model/filter.model';\nimport {EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, IEntitiesService, IEntityService, LoadResult, SuggestService} from '../services/entity-service.class';\nimport {GraphqlService} from '../../core/graphql/graphql.service';\nimport {BaseEntityGraphqlMutations, BaseEntityGraphqlQueries, BaseEntityService, BaseEntityServiceOptions} from '../../core/services/base-entity-service.class';\nimport {EntityClass} from '../../core/services/model/entity.decorators';\nimport {PlatformService} from '../../core/services/platform.service';\nimport {StoreObject} from '@apollo/client/core';\n\nexport interface INamedFilter<T extends INamedFilter<T>> extends IEntity<T, number> {\n  name: string;\n  entityName: string;\n  content: any;\n  recorderPersonId: number;\n  recorderDepartmentId: number;\n}\n\n@EntityClass({ typename: 'NamedFilterVO' })\nexport class NamedFilter<T extends NamedFilter<any> = NamedFilter<any>> extends Entity<T, number> implements INamedFilter<T> {\n  static fromObject: (source: any, opts?: any) => NamedFilter;\n\n  name: string;\n  entityName: string;\n  content: any;\n  recorderPersonId: number;\n  recorderDepartmentId: number;\n\n  fromObject(source: any, opts?: any) {\n    this.name = source.name;\n    this.entityName = source.entityName;\n    this.recorderPersonId = source.recorderPersonId;\n    this.recorderDepartmentId = source.recorderDepartmentId;\n    try {\n      this.content = typeof source?.content === 'string' ? JSON.parse(source?.content) : source?.content || undefined;\n    } catch (e) {\n      console.error('[named-filter] can\\'t parse content json', source);\n      throw e;\n    }\n  }\n\n  asObject(opts?: EntityAsObjectOptions): StoreObject {\n    const target = super.asObject(opts);\n    if (opts?.minify) {\n      target.content = JSON.stringify(this.content);\n    }\n    return target;\n  }\n}\n\nexport interface INamedFilterFilter<T extends INamedFilter<T>> extends IEntityFilter<any, T> {\n  searchText: string;\n  entityName: string;\n  recorderPersonId: number;\n  recorderDepartmentId: number;\n}\n\n@EntityClass({typename: 'NamedFilterFilterVO'})\nexport class NamedFilterFilter<F extends NamedFilterFilter<any, T> = NamedFilterFilter<any, any>, T extends NamedFilter<any> = NamedFilter<any>>\n  extends EntityFilter<F, T> implements INamedFilterFilter<T> {\n  static fromObject: (source: any, opts?: any) => NamedFilterFilter;\n\n  searchText: string = null;\n  entityName: string = null;\n  recorderPersonId: number = null;\n  recorderDepartmentId: number = null;\n\n  fromObject(source: any, opts?: any) {\n    super.fromObject(source, opts);\n    this.searchText = source.searchText;\n    this.entityName = source.entityName;\n    this.recorderPersonId = source.recorderPersonId;\n    this.recorderDepartmentId = source.recorderDepartmentId;\n  }\n}\n\n\nexport const APP_NAMED_FILTER_SERVICE = new InjectionToken<INamedFilterService<any, any>>('namedFilterService');\n\nexport interface INamedFilterServiceWatchOptions extends EntitiesServiceWatchOptions {\n  withContent: boolean;\n}\n\nexport interface INamedFilterServiceLoadOptions extends EntitiesServiceLoadOptions {\n  withContent: boolean;\n}\n\nexport interface INamedFilterService<T extends INamedFilter<T>, F extends EntityFilter<F, T>>\n  extends IEntitiesService<T, F, INamedFilterServiceWatchOptions>,\n    IEntityService<T, number, INamedFilterServiceLoadOptions>,\n    SuggestService<T, F> {\n\n  defaultFilter(): F;\n\n  suggestFilter(searchText: string, filter?: Partial<F>): F;\n}\n\nexport interface INamedFilterQueries extends BaseEntityGraphqlQueries {\n  loadAllWithContent: any;\n}\n\n// @dynamic\n@Directive()\nexport abstract class AbstractNamedFilterService<\n  T extends NamedFilter<T>,\n  F extends NamedFilterFilter<F, T>,\n  WO extends INamedFilterServiceWatchOptions = INamedFilterServiceWatchOptions,\n  LO extends INamedFilterServiceLoadOptions = INamedFilterServiceLoadOptions,\n  Q extends INamedFilterQueries = INamedFilterQueries,\n  M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations\n>\n  extends BaseEntityService<T, F, number, WO, LO, Q, M>\n  implements INamedFilterService<T, F> {\n\n  protected constructor(\n    protected graphql: GraphqlService,\n    protected platform: PlatformService,\n    protected dataType: new() => T,\n    protected filterType: new() => F,\n    protected options: BaseEntityServiceOptions<T, number, Q, M>\n  ) {\n    super(graphql, platform, dataType, filterType, {\n      defaultSortBy: 'name',\n      defaultSortDirection: 'asc',\n      ...options\n    });\n    this._logPrefix = '[named-filter-service] ';\n  }\n\n  abstract defaultFilter(): F;\n\n  watchAll(\n    offset: number,\n    size: number,\n    sortBy?: string,\n    sortDirection?: SortDirection,\n    filter?: F,\n    options?: WO\n  ): Observable<LoadResult<T>> {\n\n    if (!filter) {\n      filter = this.defaultFilter();\n    }\n\n    // Always ask total\n    options = {\n      ...options,\n      withTotal: true\n    };\n    // Set query if content is wanted\n    if (options?.withContent) {\n      options.query = this.queries.loadAllWithContent;\n    }\n\n    return super.watchAll(offset, size, sortBy, sortDirection, filter, options);\n  }\n\n  async loadAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<F>, options?: LO & { debug?: boolean }): Promise<LoadResult<T>> {\n\n    if (!filter) {\n      filter = this.defaultFilter();\n    }\n\n    // Always ask total\n    options = {\n      ...options,\n      withTotal: true\n    };\n    // Set query if content is wanted\n    if (options?.withContent) {\n      options.query = this.queries.loadAllWithContent;\n    }\n\n    return super.loadAll(offset, size, sortBy, sortDirection, filter, options);\n  }\n\n\n  async suggest(value: any, filter: Partial<F>): Promise<LoadResult<T>> {\n    if (EntityUtils.isNotEmpty(value, 'id')) return {data: [value]};\n    value = (typeof value === 'string' && value !== '*' && value) || undefined;\n    return await this.loadAll(0, 1000, 'name', 'asc',\n      this.suggestFilter(value, filter),\n      <LO>{\n        withTotal: true,\n        withContent: false\n      });\n  }\n\n  suggestFilter(searchText: string, filter?: Partial<F>): F {\n    return <F>{\n      ...filter,\n      searchText\n    };\n  }\n}\n"]}

package/esm2020/src/app/shared/observables.mjs

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

package/esm2020/src/app/shared/pipes/arrays.pipe.mjs

@@ -0,0 +1,141 @@
+import { Pipe } from '@angular/core';
+import { getPropertyByPath, isNotNil } from '../functions';
+import * as i0 from "@angular/core";
+export class NotEmptyArrayPipe {
+    transform(val) {
+        if (!Array.isArray(val))
+            return false;
+        return val.length > 0;
+    }
+}
+NotEmptyArrayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotEmptyArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NotEmptyArrayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: NotEmptyArrayPipe, name: "isNotEmptyArray" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotEmptyArrayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isNotEmptyArray'
+                }]
+        }] });
+export class EmptyArrayPipe {
+    transform(val) {
+        if (!Array.isArray(val))
+            return true;
+        return val.length === 0;
+    }
+}
+EmptyArrayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EmptyArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+EmptyArrayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: EmptyArrayPipe, name: "isEmptyArray" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EmptyArrayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isEmptyArray'
+                }]
+        }] });
+export class ArrayLengthPipe {
+    transform(val, args) {
+        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;
+    }
+}
+ArrayLengthPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayLengthPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayLengthPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ArrayLengthPipe, name: "isArrayLength" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayLengthPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isArrayLength'
+                }]
+        }] });
+export class ArrayFirstPipe {
+    transform(val) {
+        if (!Array.isArray(val))
+            return null;
+        return val.length > 0 ? val[0] : null;
+    }
+}
+ArrayFirstPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayFirstPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayFirstPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ArrayFirstPipe, name: "arrayFirst" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayFirstPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayFirst'
+                }]
+        }] });
+export class ArrayPluckPipe {
+    /**
+     *
+     * @param val
+     * @param opts property to get, or options
+     */
+    transform(val, opts) {
+        if (!Array.isArray(val) || !opts)
+            return null;
+        const property = (typeof opts === 'string') || Array.isArray(opts) ? opts : opts.property;
+        return (opts['omitNil'] !== true) ?
+            val.map(value => getPropertyByPath(value, property)) :
+            val.map(value => getPropertyByPath(value, property)).filter(isNotNil);
+    }
+}
+ArrayPluckPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayPluckPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayPluckPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ArrayPluckPipe, name: "arrayPluck" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayPluckPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayPluck'
+                }]
+        }] });
+export class ArrayIncludesPipe {
+    transform(val, searchElement, fromIndex) {
+        if (!Array.isArray(val))
+            return false;
+        return val && val.includes(searchElement, fromIndex) || false;
+    }
+}
+ArrayIncludesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayIncludesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayIncludesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ArrayIncludesPipe, name: "arrayIncludes" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayIncludesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayIncludes'
+                }]
+        }] });
+export class ArrayFilterPipe {
+    transform(val, filterFn) {
+        if (!Array.isArray(val))
+            return null;
+        return val.filter(filterFn);
+    }
+}
+ArrayFilterPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayFilterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayFilterPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ArrayFilterPipe, name: "arrayFilter" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayFilterPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayFilter'
+                }]
+        }] });
+export class ArrayJoinPipe {
+    transform(val, separator) {
+        if (!Array.isArray(val))
+            return '';
+        return val.join(separator) || '';
+    }
+}
+ArrayJoinPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayJoinPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayJoinPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ArrayJoinPipe, name: "arrayJoin" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayJoinPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayJoin'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arrays.pipe.js","sourceRoot":"","sources":["../../../../../../src/app/shared/pipes/arrays.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import {Pipe, PipeTransform} from '@angular/core';\nimport {getPropertyByPath, isNotNil} from '../functions';\n\n@Pipe({\n    name: 'isNotEmptyArray'\n})\nexport class NotEmptyArrayPipe implements PipeTransform {\n\n    transform<T = any>(val: unknown | T[]): boolean {\n      if (!Array.isArray(val)) return false;\n      return val.length > 0;\n    }\n}\n\n\n@Pipe({\n  name: 'isEmptyArray'\n})\nexport class EmptyArrayPipe implements PipeTransform {\n\n  transform<T = any>(val: unknown | T[]): boolean {\n    if (!Array.isArray(val)) return true;\n    return val.length === 0;\n  }\n}\n\n\n@Pipe({\n  name: 'isArrayLength'\n})\nexport class ArrayLengthPipe implements PipeTransform {\n\n  transform<T = any>(val: unknown | T[], args?: { greaterThan?: number; equals?: number; lessThan?: number }): boolean {\n    args = args || {};\n    const size = !Array.isArray(val) ? 0 : val.length;\n    if (isNotNil(args.lessThan)) {\n      return size < args.lessThan;\n    }\n    if (isNotNil(args.greaterThan)) {\n      return size > args.greaterThan;\n    }\n    if (isNotNil(args.equals)) {\n      return size === args.equals;\n    }\n    return false;\n  }\n}\n\n@Pipe({\n  name: 'arrayFirst'\n})\nexport class ArrayFirstPipe implements PipeTransform {\n\n  transform<T = any>(val: unknown | T[]): T | null {\n    if (!Array.isArray(val)) return null;\n    return val.length > 0 ? val[0] : null;\n  }\n}\n\n@Pipe({\n  name: 'arrayPluck'\n})\nexport class ArrayPluckPipe implements PipeTransform {\n\n  /**\n   *\n   * @param val\n   * @param opts property to get, or options\n   */\n  transform<T = any>(val: unknown | T[], opts: string | string[] | { property: string|string[]; omitNil?: boolean }): any[] {\n    if (!Array.isArray(val) || !opts) return null;\n    const property = (typeof opts === 'string') || Array.isArray(opts) ? opts as string|string[] : opts.property;\n    return (opts['omitNil'] !== true) ?\n      val.map(value => getPropertyByPath(value, property)) :\n      val.map(value => getPropertyByPath(value, property)).filter(isNotNil);\n  }\n}\n\n@Pipe({\n  name: 'arrayIncludes'\n})\nexport class ArrayIncludesPipe implements PipeTransform {\n\n  transform<T = any>(val: unknown | T[], searchElement: T, fromIndex?: number): boolean {\n    if (!Array.isArray(val)) return false;\n    return val && val.includes(searchElement, fromIndex) || false;\n  }\n}\n\n\n@Pipe({\n  name: 'arrayFilter'\n})\nexport class ArrayFilterPipe implements PipeTransform {\n\n   transform<T = any>(val: unknown | T[], filterFn: (T) => boolean): T[] | null {\n     if (!Array.isArray(val)) return null;\n     return val.filter(filterFn);\n  }\n}\n\n@Pipe({\n  name: 'arrayJoin'\n})\nexport class ArrayJoinPipe implements PipeTransform {\n\n  transform<T = any>(val: unknown | T[], separator: string): string {\n    if (!Array.isArray(val)) return '';\n    return val.join(separator) || '';\n  }\n}\n"]}

package/esm2020/src/app/shared/pipes/colors.pipe.mjs

@@ -0,0 +1,23 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MatColorPipe {
+    transform(color) {
+        if (!color)
+            return undefined;
+        switch (color) {
+            case 'warning':
+                return 'warn';
+            default:
+                return color;
+        }
+    }
+}
+MatColorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MatColorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+MatColorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: MatColorPipe, name: "matColor" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MatColorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'matColor'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sb3JzLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9waXBlcy9jb2xvcnMucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQzs7QUFPbEQsTUFBTSxPQUFPLFlBQVk7SUFFckIsU0FBUyxDQUFDLEtBQWdCO1FBQ3hCLElBQUksQ0FBQyxLQUFLO1lBQUUsT0FBTyxTQUFTLENBQUE7UUFDNUIsUUFBUSxLQUFLLEVBQUU7WUFDYixLQUFLLFNBQVM7Z0JBQ1osT0FBTyxNQUFNLENBQUM7WUFDaEI7Z0JBQ0UsT0FBTyxLQUFxQixDQUFBO1NBQy9CO0lBQ0gsQ0FBQzs7eUdBVlEsWUFBWTt1R0FBWixZQUFZOzJGQUFaLFlBQVk7a0JBSHhCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLFVBQVU7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQaXBlLCBQaXBlVHJhbnNmb3JtfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QXBwQ29sb3JzfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQge1RoZW1lUGFsZXR0ZX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvY29yZSc7XG5cbkBQaXBlKHtcbiAgICBuYW1lOiAnbWF0Q29sb3InXG59KVxuZXhwb3J0IGNsYXNzIE1hdENvbG9yUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gICAgdHJhbnNmb3JtKGNvbG9yOiBBcHBDb2xvcnMpOiBUaGVtZVBhbGV0dGUgfCB1bmRlZmluZWQge1xuICAgICAgaWYgKCFjb2xvcikgcmV0dXJuIHVuZGVmaW5lZFxuICAgICAgc3dpdGNoIChjb2xvcikge1xuICAgICAgICBjYXNlICd3YXJuaW5nJzpcbiAgICAgICAgICByZXR1cm4gJ3dhcm4nO1xuICAgICAgICBkZWZhdWx0OlxuICAgICAgICAgIHJldHVybiBjb2xvciBhcyBUaGVtZVBhbGV0dGVcbiAgICAgIH1cbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,48 @@
+import { Injectable, Pipe } from '@angular/core';
+import { DATE_ISO_PATTERN } from '../constants';
+import { DateUtils } from '../dates';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+import * as i2 from "@ngx-translate/core";
+export class DateDiffDurationPipe {
+    constructor(dateAdapter, translate) {
+        this.dateAdapter = dateAdapter;
+        this.translate = translate;
+        this.dayUnit = translate.instant('COMMON.DAY_UNIT');
+        translate.get('COMMON.DAY_UNIT').subscribe(dayUnit => this.dayUnit = dayUnit);
+    }
+    transform(value, args) {
+        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, endDate, args) {
+        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');
+    }
+}
+DateDiffDurationPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateDiffDurationPipe, deps: [{ token: i1.DateAdapter }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe });
+DateDiffDurationPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: DateDiffDurationPipe, name: "dateDiffDuration" });
+DateDiffDurationPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateDiffDurationPipe, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateDiffDurationPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateDiffDuration'
+                }]
+        }, {
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.DateAdapter }, { type: i2.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/pipes/date-format.pipe.mjs

@@ -0,0 +1,66 @@
+import { Injectable, Pipe } from '@angular/core';
+import { isMoment } from 'moment';
+import { DATE_ISO_PATTERN } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material-moment-adapter";
+import * as i2 from "@ngx-translate/core";
+export class AbstractDateFormat {
+    constructor(dateAdapter, translate) {
+        this.dateAdapter = dateAdapter;
+        this.translate = translate;
+        const translations = translate.instant(['COMMON.DATE_PATTERN', 'COMMON.DATE_TIME_PATTERN', 'COMMON.DATE_TIME_SECONDS_PATTERN']);
+        this._updateTranslations(translations);
+    }
+    transform(value, args) {
+        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 = isMoment(value) ? value : this.dateAdapter.parse(value, DATE_ISO_PATTERN);
+        return date && this.dateAdapter.format(date, pattern) || '';
+    }
+    _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');
+    }
+    _getTranslationValue(translations, key, defaultValue) {
+        return (translations[key] !== key) ? translations[key] : defaultValue;
+    }
+}
+export class DateFormatPipe extends AbstractDateFormat {
+    constructor(dateAdapter, translate) {
+        super(dateAdapter, translate);
+    }
+}
+DateFormatPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatPipe, deps: [{ token: i1.MomentDateAdapter }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe });
+DateFormatPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: DateFormatPipe, name: "dateFormat" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateFormat'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MomentDateAdapter }, { type: i2.TranslateService }]; } });
+export class DateFormatService extends AbstractDateFormat {
+    constructor(dateAdapter, translate) {
+        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, pattern) {
+        return this.dateAdapter.format(date, pattern);
+    }
+    parse(value, parseFormat) {
+        return isMoment(value) ? value : this.dateAdapter.parse(value, parseFormat || DATE_ISO_PATTERN);
+    }
+}
+DateFormatService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatService, deps: [{ token: i1.MomentDateAdapter }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+DateFormatService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.MomentDateAdapter }, { type: i2.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { Injectable, Pipe } from '@angular/core';
+import { isMoment } from 'moment';
+import { DATE_ISO_PATTERN } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material-moment-adapter";
+export class DateFromNowPipe {
+    constructor(dateAdapter) {
+        this.dateAdapter = dateAdapter;
+    }
+    transform(value, args) {
+        const date = isMoment(value) ? value : this.dateAdapter.parse(value, DATE_ISO_PATTERN);
+        return date ? date.fromNow(args && args.withoutSuffix) : '';
+    }
+}
+DateFromNowPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFromNowPipe, deps: [{ token: i1.MomentDateAdapter }], target: i0.ɵɵFactoryTarget.Pipe });
+DateFromNowPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: DateFromNowPipe, name: "dateFromNow" });
+DateFromNowPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFromNowPipe, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFromNowPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateFromNow'
+                }]
+        }, {
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.MomentDateAdapter }]; } });
+//# sourceMappingURL=data:application/json;base64,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