@eo-sdk/client 10.7.0-rc.5 → 11.0.0-beta.1

package/esm2022/app/eo-framework-core/layout/layout.service.mjs

@@ -0,0 +1,106 @@
+import { Injectable } from '@angular/core';
+import { NavigationStart } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../pending-changes/pending-changes.service";
+import * as i2 from "@eo-sdk/core";
+import * as i3 from "@angular/router";
+// export class AreaState {
+//   hidden;
+//   dock;
+//   constructor(public area: SplitAreaComponent, visible = true, hidden = false, dock = true) {
+//     this.visible = visible;
+//     this.hidden = hidden;
+//     this.dock = dock;
+//   }
+//   get visible() {
+//     return this.area.visible;
+//   }
+//   set visible(v: boolean) {
+//     this.area.visible = v;
+//   }
+// }
+export class LayoutService {
+    set disableCache(cache) {
+        this._disableCache = cache;
+        if (this._disableCache) {
+            this.clearHistory();
+        }
+        else {
+            Object.keys(this._history).forEach(k => this.cacheLayout(k, this._history[k]));
+        }
+        this.cache.setItem(this.CACHE_DISABLED_KEY, this._disableCache).subscribe();
+    }
+    get disableCache() {
+        return this._disableCache;
+    }
+    // private _undockArea: AreaState;
+    // private areas: AreaState[] = [];
+    // private areasSource = new ReplaySubject<AreaState[]>(1);
+    // public areas$: Observable<AreaState[]> = this.areasSource.asObservable();
+    constructor(pendingChanges, cache, router) {
+        this.pendingChanges = pendingChanges;
+        this.cache = cache;
+        this.router = router;
+        // public onUndockAreaChanged = new EventEmitter<AreaState>();
+        this.CACHE_DISABLED_KEY = 'eo.layout.cache.disabled';
+        this._disableCache = false;
+        this._history = {};
+        this.cache.getItem(this.CACHE_DISABLED_KEY).subscribe(val => this.disableCache = typeof val === 'boolean' ? val : false);
+        this.router.events.pipe(filter(r => r instanceof NavigationStart))
+            .subscribe(() => this.clearHistory());
+    }
+    // getUndockArea() {
+    //   return this._undockArea;
+    // }
+    clearHistory() {
+        this._history = {};
+    }
+    // updateArea(area: AreaState, props: any) {
+    //   let _area = this.areas.find(a => a === area);
+    //   if (_area) {
+    //     Object.assign(_area, props);
+    //     this.areasSource.next(this.areas);
+    //   }
+    // }
+    // setAreas(areas: AreaState[], undockArea: AreaState = null) {
+    //   this._undockArea = undockArea;
+    //   this.areas = areas;
+    //   this.areasSource.next(this.areas);
+    // }
+    // hideAreas(condition: (area, index) => {}) {
+    //   this.areas.forEach((a, i) => Object.assign(a, {visible: !condition.call(this, a, i), hidden: condition.call(this, a, i)}));
+    //   this.areasSource.next(this.areas);
+    // }
+    // toggleArea(area: AreaState) {
+    //   this.updateArea(area, {visible: !area.visible});
+    // }
+    // undockArea() {
+    //   if (this._undockArea && !this.pendingChanges.check()) {
+    //     this.updateArea(this._undockArea, {dock: !this._undockArea.dock});
+    //     this.onUndockAreaChanged.emit(this._undockArea);
+    //   }
+    // }
+    // visibilityUpdate() {
+    //   this.areasSource.next(this.areas);
+    // }
+    cacheLayout(key, layout) {
+        // if (!this.isUndocked()) {
+        if (this.disableCache) {
+            this._history[key] = layout;
+        }
+        else {
+            this.cache.setItem(key, layout).subscribe();
+        }
+        // }
+    }
+    getLayout(key) {
+        return this.cache.getItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LayoutService, deps: [{ token: i1.PendingChangesService }, { token: i2.AppCacheService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LayoutService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LayoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.PendingChangesService }, { type: i2.AppCacheService }, { type: i3.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework-core/layout/layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, Injectable} from '@angular/core';\nimport {NavigationStart, Router} from '@angular/router';\nimport {AppCacheService} from '@eo-sdk/core';\nimport {filter} from 'rxjs/operators';\n// import {SplitAreaComponent} from '../../eo-framework/split/split-area/split-area.component';\nimport {PendingChangesService} from '../pending-changes/pending-changes.service';\n\n// export class AreaState {\n\n//   hidden;\n//   dock;\n\n//   constructor(public area: SplitAreaComponent, visible = true, hidden = false, dock = true) {\n//     this.visible = visible;\n//     this.hidden = hidden;\n//     this.dock = dock;\n//   }\n\n//   get visible() {\n//     return this.area.visible;\n//   }\n\n//   set visible(v: boolean) {\n//     this.area.visible = v;\n//   }\n\n// }\n\n@Injectable()\nexport class LayoutService {\n\n  // public onUndockAreaChanged = new EventEmitter<AreaState>();\n\n  private CACHE_DISABLED_KEY = 'eo.layout.cache.disabled';\n  private _disableCache = false;\n  private _history = {};\n\n  set disableCache(cache: boolean) {\n    this._disableCache = cache;\n    if (this._disableCache) {\n      this.clearHistory();\n    } else {\n      Object.keys(this._history).forEach(k => this.cacheLayout(k, this._history[k]));\n    }\n    this.cache.setItem(this.CACHE_DISABLED_KEY, this._disableCache).subscribe();\n  }\n\n  get disableCache() {\n    return this._disableCache;\n  }\n\n  // private _undockArea: AreaState;\n  // private areas: AreaState[] = [];\n  // private areasSource = new ReplaySubject<AreaState[]>(1);\n  // public areas$: Observable<AreaState[]> = this.areasSource.asObservable();\n\n  constructor(private pendingChanges: PendingChangesService, private cache: AppCacheService, private router: Router) {\n    this.cache.getItem(this.CACHE_DISABLED_KEY).subscribe(val => this.disableCache = typeof val === 'boolean' ? val : false);\n    this.router.events.pipe(filter(r => r instanceof NavigationStart))\n      .subscribe(() => this.clearHistory());\n  }\n\n  // getUndockArea() {\n  //   return this._undockArea;\n  // }\n\n  clearHistory() {\n    this._history = {};\n  }\n\n  // updateArea(area: AreaState, props: any) {\n  //   let _area = this.areas.find(a => a === area);\n  //   if (_area) {\n  //     Object.assign(_area, props);\n  //     this.areasSource.next(this.areas);\n  //   }\n  // }\n\n  // setAreas(areas: AreaState[], undockArea: AreaState = null) {\n  //   this._undockArea = undockArea;\n  //   this.areas = areas;\n  //   this.areasSource.next(this.areas);\n  // }\n\n  // hideAreas(condition: (area, index) => {}) {\n  //   this.areas.forEach((a, i) => Object.assign(a, {visible: !condition.call(this, a, i), hidden: condition.call(this, a, i)}));\n  //   this.areasSource.next(this.areas);\n  // }\n\n  // toggleArea(area: AreaState) {\n  //   this.updateArea(area, {visible: !area.visible});\n  // }\n\n  // undockArea() {\n  //   if (this._undockArea && !this.pendingChanges.check()) {\n  //     this.updateArea(this._undockArea, {dock: !this._undockArea.dock});\n  //     this.onUndockAreaChanged.emit(this._undockArea);\n  //   }\n  // }\n\n  // visibilityUpdate() {\n  //   this.areasSource.next(this.areas);\n  // }\n\n  cacheLayout(key: string, layout: any) {\n    // if (!this.isUndocked()) {\n      if (this.disableCache) {\n        this._history[key] = layout;\n      } else {\n        this.cache.setItem(key, layout).subscribe();\n      }\n    // }\n  }\n\n  getLayout(key: string) {\n    return this.cache.getItem(key);\n  }\n\n  // isUndocked() {\n  //   return this._undockArea && !this._undockArea.dock;\n  // }\n\n}\n"]}

package/esm2022/app/eo-framework-core/location/location.service.mjs

@@ -0,0 +1,146 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { Utils, UploadTarget } from '@eo-sdk/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+import * as i2 from "../agent/agent.service";
+import * as i3 from "@angular/router";
+/**
+ * LocationService keeps track of the location a user visits inside enaio.
+ * This service will be used by the AppAdd component for fetching objects allowed
+ * to be added, because they may be restricted to a certain location.
+ *
+ * For components that display a location inside enaio use `LocationService.enter(id, type)`
+ * in the components `OnInit` method and `LocationService.leave()` in its `OnDestroy` method.
+ * See applications `ObjectStateComponent` for an example.
+ */
+export class LocationService {
+    constructor(appCache, agentService, uploadRegistry, router) {
+        this.appCache = appCache;
+        this.agentService = agentService;
+        this.uploadRegistry = uploadRegistry;
+        this.router = router;
+        // number of entries to keep in the history
+        this.HISTORY_SIZE = 5;
+        this.locationSource = new ReplaySubject(1);
+        this.activeLocation$ = this.locationSource.asObservable();
+        // history of locations visited by the user
+        this.locationHistory = [];
+        this.currentUploadTargets = [];
+        // load history from local storage
+        appCache
+            .getItem(appCache.LOCATION_HISTORY)
+            .subscribe(h => this.locationHistory = h || []);
+        // if (this.activeLocation) {
+        //   // if we already hav an active location we'll add it to the history right away
+        //   this.addHistoryEntry(this.activeLocation);
+        // }
+    }
+    /**
+     * Enter a specific location. This will add the location to the local history
+     * and set the active location.
+     * @param dmsObject
+     * @param treeNode Node from the context folders structure tree
+     */
+    // enter(id: string, type: string, item?: DmsObject, treeNode?: TreeNode) {
+    enter(dmsObject, treeNode) {
+        let loc;
+        this.currentUploadTargets = [];
+        // having a context folder means we could add an upload target for it
+        if (dmsObject.isContextFolder) {
+            let contextTarget = new UploadTarget(Utils.uuid(), UploadTarget.CONTEXT);
+            contextTarget.referenceObject = dmsObject;
+            contextTarget.onUploadSuccess = (target) => this.router.navigate([target]);
+            this.currentUploadTargets.push(contextTarget);
+        }
+        if (treeNode && dmsObject.isContextFolder) {
+            // having an additional tree node means, that a dynamic folder was selected
+            // so we'll add an upload target for that as well
+            let treeNodeTarget = new UploadTarget(Utils.uuid(), UploadTarget.CONTEXT_TREE);
+            treeNodeTarget.referenceObject = dmsObject;
+            treeNodeTarget.subFolder = treeNode;
+            treeNodeTarget.onUploadSuccess = (target) => this.router.navigate([target]);
+            this.currentUploadTargets.push(treeNodeTarget);
+            loc = { id: dmsObject.id, title: dmsObject.title, type: dmsObject.type.name, subFolder: treeNode.data };
+        }
+        else if (dmsObject.isContextFolder) {
+            loc = { id: dmsObject.id, title: dmsObject.title, type: dmsObject.type.name };
+        }
+        else {
+            loc = { id: dmsObject.id, title: dmsObject.title, type: dmsObject.type.name };
+        }
+        if (this.currentUploadTargets.length) {
+            this.currentUploadTargets.forEach(ut => {
+                this.uploadRegistry.register(ut);
+            });
+        }
+        this.activeLocation = loc;
+        this.locationSource.next(this.activeLocation);
+        this.addHistoryEntry(dmsObject, treeNode);
+        this.appCache.setItem(this.appCache.LOCATION_HISTORY, this.locationHistory).subscribe();
+    }
+    /**
+     * Leave a location. This will remove the active location.
+     */
+    leave() {
+        if (this.currentUploadTargets.length) {
+            this.currentUploadTargets.forEach(ut => {
+                this.uploadRegistry.unregister(ut.id);
+            });
+        }
+        this.activeLocation = null;
+        this.locationSource.next(this.activeLocation);
+    }
+    /**
+     * Returns the location history
+     * @return
+     */
+    getHistory() {
+        return this.locationHistory.reverse();
+    }
+    getActiveLocation() {
+        return this.activeLocation;
+    }
+    /**
+     * Adds a location entry to the history.
+     * @param contextFolder The locations context folder
+     * @param treeNode Node from the context folders structure tree
+     */
+    addHistoryEntry(contextFolder, treeNode) {
+        // if the last history entry equals the one that should be added, we'll skip it
+        if (this.isSameAsPrevious(contextFolder, treeNode)) {
+            return false;
+        }
+        // remove the first item if we would exceed the configured history size
+        if (this.locationHistory.length === this.HISTORY_SIZE) {
+            this.locationHistory.pop();
+        }
+        this.locationHistory.push({
+            id: contextFolder.id,
+            type: contextFolder.type.name,
+            subFolder: treeNode ? treeNode.data : null
+        });
+        // also send location to agent service
+        this.agentService.updateUserLocation(contextFolder, treeNode);
+    }
+    isSameAsPrevious(contextFolder, treeNode) {
+        if (!this.locationHistory.length) {
+            return false;
+        }
+        const lastEntry = this.locationHistory[this.locationHistory.length - 1];
+        if (lastEntry.id === contextFolder.id) {
+            const treeLeaf = treeNode ? treeNode.data.key : null;
+            const subFolder = lastEntry.subFolder ? lastEntry.subFolder.key : null;
+            return treeLeaf === subFolder;
+        }
+        else {
+            return false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LocationService, deps: [{ token: i1.AppCacheService }, { token: i2.AgentService }, { token: i1.UploadRegistryService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LocationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LocationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AppCacheService }, { type: i2.AgentService }, { type: i1.UploadRegistryService }, { type: i3.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework-core/location/location.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Observable, ReplaySubject} from 'rxjs';\nimport {Router} from '@angular/router';\nimport {AgentService} from '../agent/agent.service';\nimport {AppCacheService, UploadRegistryService, DmsObject, Utils, UploadTarget} from '@eo-sdk/core';\nimport {TreeNode} from '../../eo-framework/tree/tree.component.interface';\n\nexport interface EoLocation {\n  id: string;\n  type: string;\n  title?: string;\n  subFolder?: any;\n}\n\n/**\n * LocationService keeps track of the location a user visits inside enaio.\n * This service will be used by the AppAdd component for fetching objects allowed\n * to be added, because they may be restricted to a certain location.\n *\n * For components that display a location inside enaio use `LocationService.enter(id, type)`\n * in the components `OnInit` method and `LocationService.leave()` in its `OnDestroy` method.\n * See applications `ObjectStateComponent` for an example.\n */\n\n@Injectable()\nexport class LocationService {\n\n  // number of entries to keep in the history\n  public HISTORY_SIZE = 5;\n\n  // location that is active (currently opened by the user)\n  private activeLocation: EoLocation;\n  private locationSource = new ReplaySubject<EoLocation>(1);\n  public activeLocation$: Observable<any> = this.locationSource.asObservable();\n\n  // history of locations visited by the user\n  private locationHistory: EoLocation[] = [];\n\n  private currentUploadTargets: UploadTarget[] = [];\n\n  constructor(private appCache: AppCacheService,\n              private agentService: AgentService,\n              private uploadRegistry: UploadRegistryService,\n              private router: Router) {\n    // load history from local storage\n    appCache\n      .getItem(appCache.LOCATION_HISTORY)\n      .subscribe(h => this.locationHistory = h || []);\n    // if (this.activeLocation) {\n    //   // if we already hav an active location we'll add it to the history right away\n    //   this.addHistoryEntry(this.activeLocation);\n    // }\n  }\n\n  /**\n   * Enter a specific location. This will add the location to the local history\n   * and set the active location.\n   * @param dmsObject\n   * @param treeNode Node from the context folders structure tree\n   */\n  // enter(id: string, type: string, item?: DmsObject, treeNode?: TreeNode) {\n  enter(dmsObject: DmsObject, treeNode?: TreeNode) {\n    let loc;\n    this.currentUploadTargets = [];\n    // having a context folder means we could add an upload target for it\n    if (dmsObject.isContextFolder) {\n      let contextTarget = new UploadTarget(Utils.uuid(), UploadTarget.CONTEXT);\n      contextTarget.referenceObject = dmsObject;\n      contextTarget.onUploadSuccess = (target) => this.router.navigate([target]);\n      this.currentUploadTargets.push(contextTarget);\n    }\n\n\n    if (treeNode && dmsObject.isContextFolder) {\n\n      // having an additional tree node means, that a dynamic folder was selected\n      // so we'll add an upload target for that as well\n      let treeNodeTarget = new UploadTarget(Utils.uuid(), UploadTarget.CONTEXT_TREE);\n      treeNodeTarget.referenceObject = dmsObject;\n      treeNodeTarget.subFolder = treeNode;\n      treeNodeTarget.onUploadSuccess = (target) => this.router.navigate([target]);\n      this.currentUploadTargets.push(treeNodeTarget);\n      loc = {id: dmsObject.id, title: dmsObject.title, type: dmsObject.type.name, subFolder: treeNode.data};\n\n    } else if (dmsObject.isContextFolder) {\n      loc = {id: dmsObject.id, title: dmsObject.title, type: dmsObject.type.name};\n    } else {\n      loc = {id: dmsObject.id, title: dmsObject.title, type: dmsObject.type.name};\n    }\n\n    if (this.currentUploadTargets.length) {\n      this.currentUploadTargets.forEach(ut => {\n        this.uploadRegistry.register(ut);\n      })\n    }\n\n    this.activeLocation = loc;\n    this.locationSource.next(this.activeLocation);\n    this.addHistoryEntry(dmsObject, treeNode);\n    this.appCache.setItem(this.appCache.LOCATION_HISTORY, this.locationHistory).subscribe();\n  }\n\n  /**\n   * Leave a location. This will remove the active location.\n   */\n  leave() {\n    if (this.currentUploadTargets.length) {\n      this.currentUploadTargets.forEach(ut => {\n        this.uploadRegistry.unregister(ut.id);\n      });\n    }\n    this.activeLocation = null;\n    this.locationSource.next(this.activeLocation);\n  }\n\n  /**\n   * Returns the location history\n   * @return\n   */\n  getHistory(): EoLocation[] {\n    return this.locationHistory.reverse();\n  }\n\n  getActiveLocation() {\n    return this.activeLocation;\n  }\n\n  /**\n   * Adds a location entry to the history.\n   * @param contextFolder The locations context folder\n   * @param treeNode Node from the context folders structure tree\n   */\n  private addHistoryEntry(contextFolder: DmsObject, treeNode?: TreeNode) {\n\n    // if the last history entry equals the one that should be added, we'll skip it\n    if (this.isSameAsPrevious(contextFolder, treeNode)) {\n      return false;\n    }\n\n// remove the first item if we would exceed the configured history size\n    if (this.locationHistory.length === this.HISTORY_SIZE) {\n      this.locationHistory.pop();\n    }\n    this.locationHistory.push({\n      id: contextFolder.id,\n      type: contextFolder.type.name,\n      subFolder: treeNode ? treeNode.data : null\n    });\n\n// also send location to agent service\n    this.agentService.updateUserLocation(contextFolder, treeNode);\n  }\n\n  private isSameAsPrevious(contextFolder: DmsObject, treeNode?: TreeNode): boolean {\n\n    if (!this.locationHistory.length) {\n      return false\n    }\n    const lastEntry = this.locationHistory[this.locationHistory.length - 1];\n    if (lastEntry.id === contextFolder.id) {\n\n      const treeLeaf = treeNode ? treeNode.data.key : null;\n      const subFolder = lastEntry.subFolder ? lastEntry.subFolder.key : null;\n      return treeLeaf === subFolder;\n    } else {\n      return false;\n    }\n  }\n}\n"]}

package/esm2022/app/eo-framework-core/pending-changes/pending-changes-guard.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./pending-changes.service";
+export class PendingChangesGuard {
+    constructor(pendingChanges) {
+        this.pendingChanges = pendingChanges;
+    }
+    canDeactivate(component) {
+        // if there are no pending changes, just allow deactivation; else confirm first
+        return !this.pendingChanges.check(component);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PendingChangesGuard, deps: [{ token: i1.PendingChangesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PendingChangesGuard }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PendingChangesGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.PendingChangesService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVuZGluZy1jaGFuZ2VzLWd1YXJkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2VvLWZyYW1ld29yay1jb3JlL3BlbmRpbmctY2hhbmdlcy9wZW5kaW5nLWNoYW5nZXMtZ3VhcmQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDOzs7QUFNekMsTUFBTSxPQUFPLG1CQUFtQjtJQUU5QixZQUFvQixjQUFxQztRQUFyQyxtQkFBYyxHQUFkLGNBQWMsQ0FBdUI7SUFDekQsQ0FBQztJQUVELGFBQWEsQ0FBQyxTQUFrQztRQUM5QywrRUFBK0U7UUFDL0UsT0FBTyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQy9DLENBQUM7OEdBUlUsbUJBQW1CO2tIQUFuQixtQkFBbUI7OzJGQUFuQixtQkFBbUI7a0JBRC9CLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQge1BlbmRpbmdDaGFuZ2VzQ29tcG9uZW50fSBmcm9tICcuL3BlbmRpbmctY2hhbmdlcy1jb21wb25lbnQuaW50ZXJmYWNlJztcbmltcG9ydCB7UGVuZGluZ0NoYW5nZXNTZXJ2aWNlfSBmcm9tICcuL3BlbmRpbmctY2hhbmdlcy5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFBlbmRpbmdDaGFuZ2VzR3VhcmQgIHtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHBlbmRpbmdDaGFuZ2VzOiBQZW5kaW5nQ2hhbmdlc1NlcnZpY2UpIHtcbiAgfVxuXG4gIGNhbkRlYWN0aXZhdGUoY29tcG9uZW50OiBQZW5kaW5nQ2hhbmdlc0NvbXBvbmVudCk6IGJvb2xlYW4ge1xuICAgIC8vIGlmIHRoZXJlIGFyZSBubyBwZW5kaW5nIGNoYW5nZXMsIGp1c3QgYWxsb3cgZGVhY3RpdmF0aW9uOyBlbHNlIGNvbmZpcm0gZmlyc3RcbiAgICByZXR1cm4gIXRoaXMucGVuZGluZ0NoYW5nZXMuY2hlY2soY29tcG9uZW50KTtcbiAgfVxufVxuIl19

package/esm2022/app/eo-framework-core/pending-changes/pending-changes.service.mjs

@@ -0,0 +1,112 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { Utils } from '@eo-sdk/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+/**
+ * EditingObserver service is used to track changes made inside the application, that should prevent
+ * doing something or going somewhere before the changes are persisted or ignored. For example when
+ * the user starts editing form data and tries to navigate away before saving the changes, this service
+ * will take care of notifying the user.
+ *
+ * It is working kind of like a registry for ongoing tasks that need to be monitored. Every component
+ * that needs to be aware of changes to be persisted can start a task and finish it when everything is done.
+ *
+ * Other components can ask the service for pending tasks to know whether or not to execute an action
+ * (e.g. list component will subscribe and prevent selecting another list item, if changes to the previous one haven't be finished)
+ *
+ * app.component will prevent relevant route changes while tasks are pending.
+ */
+export class PendingChangesService {
+    constructor(logger, translate) {
+        this.logger = logger;
+        this.translate = translate;
+        this.tasks = [];
+        this.tasksSource = new ReplaySubject();
+        this.tasks$ = this.tasksSource.asObservable();
+    }
+    /**
+     * Registers a task to be pending.
+     * @returns Unique id to be used for finishing this task
+     */
+    startTask() {
+        const taskId = Utils.uuid();
+        this.tasks.push(taskId);
+        this.logger.debug('started pending task: ' + taskId);
+        this.tasksSource.next(this.tasks);
+        return taskId;
+    }
+    /**
+     * Finishes a task
+     * @param id The id of the task to be finished. This is the one the component got from startTask()
+     */
+    finishTask(id) {
+        if (id) {
+            this.tasks = this.tasks.filter(t => t !== id);
+            this.tasksSource.next(this.tasks);
+            this.logger.debug('finished pending task: ' + id);
+        }
+    }
+    /**
+     * Returns whether or not the service has pending tasks.
+     * If an id is provided, the method will check existence of one specific task.
+     *
+     * @param id The id of the task to be checked
+     * @returns
+     */
+    hasPendingTask(id) {
+        return !id ? !!this.tasks.length :
+            (Array.isArray(id) ? this.tasks.some(value => id.includes(value)) : this.tasks.includes(id));
+    }
+    /**
+     * Returns whether or not the component|service has pending tasks.
+     * Checks via confirm dialog
+     * @param component
+     * @returns
+     */
+    check(component) {
+        if (component ? !component.hasPendingChanges() : !this.hasPendingTask()) {
+            return false;
+        }
+        else {
+            const confirmed = confirm(this.translate.instant('eo.object.indexdata.save.browsernav'));
+            if (confirmed) {
+                this.clear();
+            }
+            return !confirmed;
+        }
+    }
+    checkForPendingTasks(taskIds) {
+        if (taskIds && this.hasPendingTask(taskIds)) {
+            const confirmed = confirm(this.translate.instant('eo.object.indexdata.save.browsernav'));
+            if (confirmed) {
+                this.removeTasks(Array.isArray(taskIds) ? taskIds : [taskIds]);
+            }
+            return !confirmed;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Removes pending tasks from the list
+     * @param taskIds the ids of the tasks to remove
+     */
+    removeTasks(taskIds) {
+        this.tasks = this.tasks.filter(task => !taskIds.includes(task));
+        this.tasksSource.next(this.tasks);
+    }
+    /**
+     * Clear list of pending tasks
+     */
+    clear() {
+        this.tasks = [];
+        this.tasksSource.next(this.tasks);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PendingChangesService, deps: [{ token: i1.Logger }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PendingChangesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PendingChangesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Logger }, { type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pending-changes.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework-core/pending-changes/pending-changes.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAa,aAAa,EAAC,MAAM,MAAM,CAAC;AAC/C,OAAO,EAAC,KAAK,EAAS,MAAM,cAAc,CAAC;;;AAE3C;;;;;;;;;;;;;GAaG;AAGH,MAAM,OAAO,qBAAqB;IAMhC,YAAoB,MAAc,EAAU,SAA2B;QAAnD,WAAM,GAAN,MAAM,CAAQ;QAAU,cAAS,GAAT,SAAS,CAAkB;QAJ/D,UAAK,GAAa,EAAE,CAAC;QACrB,gBAAW,GAAG,IAAI,aAAa,EAAY,CAAC;QAC7C,WAAM,GAAyB,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IAGtE,CAAC;IAED;;;OAGG;IACH,SAAS;QACP,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wBAAwB,GAAG,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,EAAU;QACnB,IAAI,EAAE,EAAE,CAAC;YACP,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;YAC9C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yBAAyB,GAAG,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,EAAsB;QACnC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAClC,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/F,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,SAAmC;QACvC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACxE,OAAO,KAAK,CAAC;QACf,CAAC;aAAM,CAAC;YACN,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC,CAAC;YACzF,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,CAAC;YACD,OAAO,CAAC,SAAS,CAAC;QACpB,CAAC;IACH,CAAC;IAED,oBAAoB,CAAC,OAA0B;QAC7C,IAAG,OAAO,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3C,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC,CAAC;YACzF,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;YACjE,CAAC;YACD,OAAO,CAAC,SAAS,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,OAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;8GA1FU,qBAAqB;kHAArB,qBAAqB;;2FAArB,qBAAqB;kBADjC,UAAU","sourcesContent":["import {Injectable} from '@angular/core';\nimport {TranslateService} from '@eo-sdk/core';\nimport {PendingChangesComponent} from './pending-changes-component.interface';\nimport {Observable, ReplaySubject} from 'rxjs';\nimport {Utils, Logger} from '@eo-sdk/core';\n\n/**\n * EditingObserver service is used to track changes made inside the application, that should prevent\n * doing something or going somewhere before the changes are persisted or ignored. For example when\n * the user starts editing form data and tries to navigate away before saving the changes, this service\n * will take care of notifying the user.\n *\n * It is working kind of like a registry for ongoing tasks that need to be monitored. Every component\n * that needs to be aware of changes to be persisted can start a task and finish it when everything is done.\n *\n * Other components can ask the service for pending tasks to know whether or not to execute an action\n * (e.g. list component will subscribe and prevent selecting another list item, if changes to the previous one haven't be finished)\n *\n * app.component will prevent relevant route changes while tasks are pending.\n */\n\n@Injectable()\nexport class PendingChangesService {\n\n  private tasks: string[] = [];\n  private tasksSource = new ReplaySubject<string[]>();\n  public tasks$: Observable<string[]> = this.tasksSource.asObservable();\n\n  constructor(private logger: Logger, private translate: TranslateService) {\n  }\n\n  /**\n   * Registers a task to be pending.\n   * @returns Unique id to be used for finishing this task\n   */\n  startTask(): string {\n    const taskId = Utils.uuid();\n    this.tasks.push(taskId);\n    this.logger.debug('started pending task: ' + taskId);\n    this.tasksSource.next(this.tasks);\n    return taskId;\n  }\n\n  /**\n   * Finishes a task\n   * @param id The id of the task to be finished. This is the one the component got from startTask()\n   */\n  finishTask(id: string) {\n    if (id) {\n      this.tasks = this.tasks.filter(t => t !== id);\n      this.tasksSource.next(this.tasks);\n      this.logger.debug('finished pending task: ' + id);\n    }\n  }\n\n  /**\n   * Returns whether or not the service has pending tasks.\n   * If an id is provided, the method will check existence of one specific task.\n   *\n   * @param id The id of the task to be checked\n   * @returns\n   */\n  hasPendingTask(id?: string | string[]): boolean {\n    return !id ? !!this.tasks.length :\n    (Array.isArray(id) ? this.tasks.some(value => id.includes(value)) : this.tasks.includes(id));\n  }\n\n  /**\n   * Returns whether or not the component|service has pending tasks.\n   * Checks via confirm dialog\n   * @param component\n   * @returns\n   */\n  check(component?: PendingChangesComponent): boolean {\n    if (component ? !component.hasPendingChanges() : !this.hasPendingTask()) {\n      return false;\n    } else {\n      const confirmed = confirm(this.translate.instant('eo.object.indexdata.save.browsernav'));\n      if (confirmed) {\n        this.clear();\n      }\n      return !confirmed;\n    }\n  }\n\n  checkForPendingTasks(taskIds: string | string[]):boolean {\n    if(taskIds && this.hasPendingTask(taskIds)) {\n      const confirmed = confirm(this.translate.instant('eo.object.indexdata.save.browsernav'));\n      if (confirmed) {\n        this.removeTasks(Array.isArray(taskIds) ? taskIds : [taskIds]);\n      }\n      return !confirmed;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Removes pending tasks from the list\n   * @param taskIds the ids of the tasks to remove\n   */\n  removeTasks(taskIds: string[]) {\n    this.tasks = this.tasks.filter(task => !taskIds.includes(task));\n    this.tasksSource.next(this.tasks);\n  }\n\n  /**\n   * Clear list of pending tasks\n   */\n  clear() {\n    this.tasks = [];\n    this.tasksSource.next(this.tasks);\n  }\n}\n"]}

package/esm2022/app/eo-framework-core/pipes/filesize.pipe.mjs

@@ -0,0 +1,30 @@
+import { Pipe } from '@angular/core';
+import { LocaleNumberPipe } from './locale-number.pipe';
+import * as i0 from "@angular/core";
+export class FileSizePipe extends LocaleNumberPipe {
+    constructor() {
+        super(...arguments);
+        this.k = 1024;
+        this.sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    }
+    transform(bytes = 0) {
+        if (bytes <= 1) {
+            return bytes === 1 ? '1 Byte' : '0 Bytes';
+        }
+        let i = Math.floor(Math.log(bytes) / Math.log(this.k));
+        return super.transform(parseFloat((bytes / Math.pow(this.k, i)).toFixed(2))) + ' ' + this.sizes[i];
+    }
+    stringToNumber(value) {
+        const sizes = this.sizes.map(s => s.toLowerCase());
+        const match = value.toLowerCase().match(new RegExp(`(.*)(${sizes.join('|')})`));
+        const number = super.stringToNumber((match ? match[1] : value).trim());
+        return isNaN(number) ? number : (number * Math.pow(1024, match ? sizes.indexOf(match[2]) : 0));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: FileSizePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: FileSizePipe, name: "fileSize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: FileSizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'fileSize' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/app/eo-framework-core/pipes/keys.pipe.mjs

@@ -4,11 +4,11 @@ export class KeysPipe {
     transform(value, args = null) {
         return Object.keys(value); //.map(key => value[key]);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: KeysPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: KeysPipe, name: "keys", pure: false }); }
 }
-KeysPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: KeysPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-KeysPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.2", ngImport: i0, type: KeysPipe, name: "keys", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: KeysPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: KeysPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'keys', pure: false }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5cy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9lby1mcmFtZXdvcmstY29yZS9waXBlcy9rZXlzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLElBQUksRUFBZ0IsTUFBTSxlQUFlLENBQUM7O0FBR2xELE1BQU0sT0FBTyxRQUFRO0lBQ25CLFNBQVMsQ0FBQyxLQUFVLEVBQUUsT0FBYyxJQUFJO1FBQ3RDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLDBCQUEwQjtJQUN2RCxDQUFDOztxR0FIVSxRQUFRO21HQUFSLFFBQVE7MkZBQVIsUUFBUTtrQkFEcEIsSUFBSTttQkFBQyxFQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UGlwZSwgUGlwZVRyYW5zZm9ybX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBQaXBlKHtuYW1lOiAna2V5cycsIHB1cmU6IGZhbHNlfSlcbmV4cG9ydCBjbGFzcyBLZXlzUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IGFueSwgYXJnczogYW55W10gPSBudWxsKTogYW55IHtcbiAgICByZXR1cm4gT2JqZWN0LmtleXModmFsdWUpOyAvLy5tYXAoa2V5ID0+IHZhbHVlW2tleV0pO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5cy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9lby1mcmFtZXdvcmstY29yZS9waXBlcy9rZXlzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLElBQUksRUFBZ0IsTUFBTSxlQUFlLENBQUM7O0FBR2xELE1BQU0sT0FBTyxRQUFRO0lBQ25CLFNBQVMsQ0FBQyxLQUFVLEVBQUUsT0FBYyxJQUFJO1FBQ3RDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLDBCQUEwQjtJQUN2RCxDQUFDOzhHQUhVLFFBQVE7NEdBQVIsUUFBUTs7MkZBQVIsUUFBUTtrQkFEcEIsSUFBSTttQkFBQyxFQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UGlwZSwgUGlwZVRyYW5zZm9ybX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBQaXBlKHtuYW1lOiAna2V5cycsIHB1cmU6IGZhbHNlfSlcbmV4cG9ydCBjbGFzcyBLZXlzUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IGFueSwgYXJnczogYW55W10gPSBudWxsKTogYW55IHtcbiAgICByZXR1cm4gT2JqZWN0LmtleXModmFsdWUpOyAvLy5tYXAoa2V5ID0+IHZhbHVlW2tleV0pO1xuICB9XG59XG4iXX0=

package/esm2022/app/eo-framework-core/pipes/locale-date.pipe.mjs

@@ -0,0 +1,63 @@
+import { Pipe } from '@angular/core';
+import { DatePipe, FormatWidth, getLocaleDateFormat, getLocaleDateTimeFormat, getLocaleTimeFormat } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+export class LocaleDatePipe extends DatePipe {
+    constructor(translate) {
+        super(translate.currentLang);
+        this.translate = translate;
+    }
+    get lang() {
+        return this.translate.currentLang ? this.translate.currentLang : 'en';
+    }
+    transform(value, format = '', timezone, locale) {
+        if (format === 'eoNiceShort') {
+            const diff = (new Date(value).setHours(0, 0, 0, 0) - new Date().setHours(0, 0, 0, 0)) / 1000 / 3600 / 24;
+            format = diff === 0 ? 'eoShortTime' : diff > -7 && diff < 0 ? 'eoShortDayTime' : format;
+        }
+        return super.transform(value, this.format(format || 'eoShort'), timezone, locale || this.lang);
+    }
+    format(format) {
+        let formatValue = '';
+        switch (format) {
+            case 'eoNiceShort':
+            case 'eoShortDate':
+                formatValue = getLocaleDateFormat(this.lang, FormatWidth.Short)
+                    .replace(/[d]+/, 'dd')
+                    .replace(/[M]+/, 'MM')
+                    .replace(/[y]+/, 'yyyy');
+                break;
+            case 'eoShortDay':
+                formatValue = 'EE';
+                break;
+            case 'eoShortTime':
+                formatValue = getLocaleTimeFormat(this.lang, FormatWidth.Short)
+                    .replace(/[h]+/, 'hh')
+                    .replace(/[H]+/, 'HH')
+                    .replace(/[m]+/, 'mm')
+                    .replace(/[a]+/, 'aa');
+                break;
+            case 'eoShort':
+                formatValue = getLocaleDateTimeFormat(this.lang, FormatWidth.Short)
+                    .replace('{0}', this.format('eoShortTime'))
+                    .replace('{1}', this.format('eoShortDate'));
+                break;
+            case 'eoShortDayTime':
+                formatValue = getLocaleDateTimeFormat(this.lang, FormatWidth.Short).replace(',', '')
+                    .replace('{0}', this.format('eoShortTime'))
+                    .replace('{1}', this.format('eoShortDay'));
+                break;
+        }
+        return formatValue || format;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LocaleDatePipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: LocaleDatePipe, name: "localeDate", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: LocaleDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeDate',
+                    pure: false
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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