@bizdoc/core 1.14.9 → 1.14.12

package/esm2020/lib/core/guide/help-tip.component.mjs

@@ -0,0 +1,58 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./guide.service";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/flex-layout/flex";
+import * as i6 from "../popup/tooltip.directive";
+import * as i7 from "../pipes/translate.pipe";
+/**  */
+export class HelpTipComponent {
+    constructor(_guide) {
+        this._guide = _guide;
+    }
+    ngOnInit() {
+        this.showTip = localStorage.getItem(this.name + '-tip') !== '1';
+        const guide = this._guide.guides.find(g => g.name === this.name);
+        this._message = guide.title.toLowerCase();
+    }
+    open(evt) {
+        this._guide.start(this.name);
+    }
+    dismiss() {
+        localStorage.setItem(this.name + 'tip', '1');
+        this.showTip = false;
+    }
+}
+HelpTipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: HelpTipComponent, deps: [{ token: i1.GuideService }], target: i0.ɵɵFactoryTarget.Component });
+HelpTipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: HelpTipComponent, selector: "bizdoc-help-tip", inputs: { name: "name" }, ngImport: i0, template: `
+  <p fxLayout="row" class="form-help-tip" *ngIf="showTip">
+    <mat-icon>help_outline</mat-icon> &nbsp;<span (click)="open($event)" [innerHTML]="'HelpTip'|translate: _message" class="mat-body-1"></span>
+    <button mat-icon-button (click)="dismiss()" [bizdocTooltip]="'Dismiss'|translate"><mat-icon inline>close</mat-icon></button>
+  </p>
+`, isInline: true, styles: [".form-help-tip{align-items:center;border:1px rgb(0 0 0 / 38%) solid;margin:10px;border-radius:3px;padding:0 8px}\n"], components: [{ type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.DefaultLayoutDirective, selector: "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", inputs: ["fxLayout", "fxLayout.xs", "fxLayout.sm", "fxLayout.md", "fxLayout.lg", "fxLayout.xl", "fxLayout.lt-sm", "fxLayout.lt-md", "fxLayout.lt-lg", "fxLayout.lt-xl", "fxLayout.gt-xs", "fxLayout.gt-sm", "fxLayout.gt-md", "fxLayout.gt-lg"] }, { type: i6.TooltipDirective, selector: "[bizdocTooltip]", inputs: ["bizdocTooltip", "bizdocTooltipTemplate", "bizdocTooltipContext", "bizdocTooltipPosition", "bizdocTooltipDuration", "bizdocTooltipDisabled"] }], pipes: { "translate": i7.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: HelpTipComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+  <p fxLayout="row" class="form-help-tip" *ngIf="showTip">
+    <mat-icon>help_outline</mat-icon> &nbsp;<span (click)="open($event)" [innerHTML]="'HelpTip'|translate: _message" class="mat-body-1"></span>
+    <button mat-icon-button (click)="dismiss()" [bizdocTooltip]="'Dismiss'|translate"><mat-icon inline>close</mat-icon></button>
+  </p>
+`,
+                    styles: [`
+.form-help-tip {
+  align-items: center;
+border: 1px rgb(0 0 0 / 38%) solid;
+  margin: 10px;
+  border-radius: 3px 3px;
+  padding: 0 8px;
+}
+`],
+                    selector: 'bizdoc-help-tip'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GuideService }]; }, propDecorators: { name: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscC10aXAuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicmFyaWVzL2NvcmUvc3JjL2xpYi9jb3JlL2d1aWRlL2hlbHAtdGlwLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBVSxNQUFNLGVBQWUsQ0FBQzs7Ozs7Ozs7O0FBR3pELE9BQU87QUFtQlAsTUFBTSxPQUFPLGdCQUFnQjtJQUszQixZQUNVLE1BQW9CO1FBQXBCLFdBQU0sR0FBTixNQUFNLENBQWM7SUFDMUIsQ0FBQztJQUNMLFFBQVE7UUFDTixJQUFJLENBQUMsT0FBTyxHQUFHLFlBQVksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsS0FBSyxHQUFHLENBQUM7UUFDaEUsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDakUsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzVDLENBQUM7SUFDRCxJQUFJLENBQUMsR0FBZTtRQUNsQixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUNELE9BQU87UUFDTCxZQUFZLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLEdBQUcsS0FBSyxFQUFFLEdBQUcsQ0FBQyxDQUFDO1FBQzdDLElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO0lBQ3ZCLENBQUM7OzZHQW5CVSxnQkFBZ0I7aUdBQWhCLGdCQUFnQixpRkFqQmpCOzs7OztDQUtYOzJGQVlZLGdCQUFnQjtrQkFsQjVCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFOzs7OztDQUtYO29CQUNDLE1BQU0sRUFBRSxDQUFDOzs7Ozs7OztDQVFWLENBQUM7b0JBQ0EsUUFBUSxFQUFFLGlCQUFpQjtpQkFDNUI7bUdBR0MsSUFBSTtzQkFESCxLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBHdWlkZVNlcnZpY2UgfSBmcm9tICcuL2d1aWRlLnNlcnZpY2UnO1xyXG5cbi8qKiAgKi9cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZTogYFxuICA8cCBmeExheW91dD1cInJvd1wiIGNsYXNzPVwiZm9ybS1oZWxwLXRpcFwiICpuZ0lmPVwic2hvd1RpcFwiPlxuICAgIDxtYXQtaWNvbj5oZWxwX291dGxpbmU8L21hdC1pY29uPiAmbmJzcDs8c3BhbiAoY2xpY2spPVwib3BlbigkZXZlbnQpXCIgW2lubmVySFRNTF09XCInSGVscFRpcCd8dHJhbnNsYXRlOiBfbWVzc2FnZVwiIGNsYXNzPVwibWF0LWJvZHktMVwiPjwvc3Bhbj5cbiAgICA8YnV0dG9uIG1hdC1pY29uLWJ1dHRvbiAoY2xpY2spPVwiZGlzbWlzcygpXCIgW2JpemRvY1Rvb2x0aXBdPVwiJ0Rpc21pc3MnfHRyYW5zbGF0ZVwiPjxtYXQtaWNvbiBpbmxpbmU+Y2xvc2U8L21hdC1pY29uPjwvYnV0dG9uPlxuICA8L3A+XG5gLFxuICBzdHlsZXM6IFtgXG4uZm9ybS1oZWxwLXRpcCB7XHJcbiAgYWxpZ24taXRlbXM6IGNlbnRlcjtcclxuYm9yZGVyOiAxcHggcmdiKDAgMCAwIC8gMzglKSBzb2xpZDtcclxuICBtYXJnaW46IDEwcHg7XHJcbiAgYm9yZGVyLXJhZGl1czogM3B4IDNweDtcclxuICBwYWRkaW5nOiAwIDhweDtcclxufVxyXG5gXSxcbiAgc2VsZWN0b3I6ICdiaXpkb2MtaGVscC10aXAnXG59KVxuZXhwb3J0IGNsYXNzIEhlbHBUaXBDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBASW5wdXQoKVxuICBuYW1lITogc3RyaW5nO1xuICBfbWVzc2FnZTogc3RyaW5nO1xyXG4gIHNob3dUaXA6IGJvb2xlYW47XHJcbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBfZ3VpZGU6IEd1aWRlU2VydmljZSxcbiAgKSB7IH1cbiAgbmdPbkluaXQoKTogdm9pZCB7XHJcbiAgICB0aGlzLnNob3dUaXAgPSBsb2NhbFN0b3JhZ2UuZ2V0SXRlbSh0aGlzLm5hbWUgKyAnLXRpcCcpICE9PSAnMSc7XG4gICAgY29uc3QgZ3VpZGUgPSB0aGlzLl9ndWlkZS5ndWlkZXMuZmluZChnID0+IGcubmFtZSA9PT0gdGhpcy5uYW1lKTtcbiAgICB0aGlzLl9tZXNzYWdlID0gZ3VpZGUudGl0bGUudG9Mb3dlckNhc2UoKTtcbiAgfVxyXG4gIG9wZW4oZXZ0OiBNb3VzZUV2ZW50KSB7XG4gICAgdGhpcy5fZ3VpZGUuc3RhcnQodGhpcy5uYW1lKTtcbiAgfVxuICBkaXNtaXNzKCkge1xuICAgIGxvY2FsU3RvcmFnZS5zZXRJdGVtKHRoaXMubmFtZSArICd0aXAnLCAnMScpO1xuICAgIHRoaXMuc2hvd1RpcCA9IGZhbHNlO1xuICB9XG59XG4iXX0=

package/esm2020/lib/core/http.interceptor.mjs

@@ -0,0 +1,79 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { Subject, switchMap, throwError } from 'rxjs';
+import { catchError, map, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./session.service";
+import * as i2 from "./router";
+import * as i3 from "./authentication";
+import * as i4 from "./hub.service";
+export class AppHttpInterceptor {
+    constructor(baseUrl, _session, _router, _auth, _messaging) {
+        this._session = _session;
+        this._router = _router;
+        this._auth = _auth;
+        this._messaging = _messaging;
+        this._ongoing = new Subject();
+        this.active$ = this._ongoing.asObservable().pipe(map(c => c > 0));
+        if (baseUrl) {
+            if (baseUrl.endsWith('/'))
+                this._baseUrl = baseUrl.substr(0, baseUrl.length - 1);
+            else
+                this._baseUrl = baseUrl;
+        }
+        else
+            this._baseUrl = '';
+    }
+    intercept(req, next) {
+        const forward = () => {
+            const url = this._baseUrl + req.url, connectionId = this._messaging.connectionId, headers = {
+                'accept-language': this._session.language,
+            };
+            if (connectionId)
+                headers['connection-id'] = connectionId;
+            const accessToken = this._auth.getAccessToken();
+            if (accessToken)
+                headers['Authorization'] = `Bearer ${accessToken}`;
+            const request = req.clone({
+                setHeaders: headers,
+                url
+            });
+            const handle = next.handle(request).pipe(catchError((e) => {
+                if (this._authenticating)
+                    return this._authenticating;
+                else if (e.status === 401) {
+                    //this._session.ok && this._router.navigate(['broken']);
+                    this._authenticating = this._auth.authorize().pipe(switchMap(() => {
+                        this._authenticating = null;
+                        //this._session.ok && history.back();
+                        return forward();
+                    }));
+                    return this._authenticating;
+                }
+                else
+                    return throwError(e);
+            }));
+            const noprogress = req.headers.has('no-progress');
+            if (!noprogress) {
+                this._ongoing.next(1);
+                return handle.pipe(tap(event => event instanceof HttpResponse
+                    && this._ongoing.next(0), () => this._ongoing.next(0)));
+            }
+            else
+                return handle;
+        };
+        return forward();
+    }
+}
+AppHttpInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: AppHttpInterceptor, deps: [{ token: 'BASE_URL', optional: true }, { token: i1.SessionService }, { token: i2.RouterImpl }, { token: i3.AuthenticationImpl }, { token: i4.HubService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppHttpInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: AppHttpInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: AppHttpInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['BASE_URL']
+                }, {
+                    type: Optional
+                }] }, { type: i1.SessionService }, { type: i2.RouterImpl }, { type: i3.AuthenticationImpl }, { type: i4.HubService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/hub.service.mjs

@@ -0,0 +1,108 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { HubConnectionBuilder, HubConnectionState } from '@microsoft/signalr';
+import * as i0 from "@angular/core";
+import * as i1 from "./authentication";
+/** Listen to hub contracts */
+export class HubService {
+    constructor(_auth) {
+        this._auth = _auth;
+        this._state = new Subject();
+        this.state$ = this._state.asObservable();
+        this._configurationChange = new Subject();
+        this._newMail = new Subject();
+        this._newChat = new Subject();
+        this._newComment = new Subject();
+        this._commentUpdate = new Subject();
+        this._commentDelete = new Subject();
+        this._updateMail = new Subject();
+        this._mailDelete = new Subject();
+        this._mailHeaderUpdate = new Subject();
+        this._newNotify = new Subject();
+        this._updateNotify = new Subject();
+        this._profileChange = new Subject();
+        this._editing = new Subject();
+        this._commentTyping = new Subject();
+        this._chatTyping = new Subject();
+        this._chatWathermark = new Subject();
+        this._voted = new Subject();
+        this._jobProgress = new Subject();
+        this._reportProgress = new Subject();
+        this._callback = new Subject();
+        this.configurationChange$ = this._configurationChange.asObservable();
+        this.jobProgress$ = this._jobProgress.asObservable();
+        this.reportProgress$ = this._reportProgress.asObservable();
+        this.callback$ = this._callback.asObservable();
+        this.vote$ = this._voted.asObservable();
+        this.chatTyping$ = this._chatTyping.asObservable();
+        this.chatWatermark$ = this._chatWathermark.asObservable();
+        this.commentTyping$ = this._commentTyping.asObservable();
+        this.editing$ = this._editing.asObservable();
+        this.commentUpdate$ = this._commentUpdate.asObservable();
+        this.commentDelete$ = this._commentDelete.asObservable();
+        /** new notification */
+        this.notify$ = this._newNotify.asObservable();
+        this.chat$ = this._newChat.asObservable();
+        this.updateNotify$ = this._updateNotify.asObservable();
+        /** new mail */
+        this.new$ = this._newMail.asObservable();
+        /** mail update */
+        this.update$ = this._updateMail.asObservable();
+        this.updateMailHeader$ = this._mailHeaderUpdate.asObservable();
+        this.delete$ = this._mailDelete.asObservable();
+        this.comment$ = this._newComment.asObservable();
+        this.profileChange$ = this._profileChange.asObservable();
+        this._connection = new HubConnectionBuilder().withUrl('/chub', {
+            accessTokenFactory: () => this._auth.getAccessToken()
+        }).withAutomaticReconnect().build();
+        this._connection.on('newMail', (data) => this._newMail.next(data));
+        this._connection.on('mailUpdate', (data) => this._updateMail.next(data));
+        this._connection.on('mailDelete', (data) => this._mailDelete.next(data));
+        this._connection.on('mailHeaderUpdate', (data) => this._mailHeaderUpdate.next(data));
+        this._connection.on('newComment', (data) => {
+            this._newComment.next(data);
+        });
+        this._connection.on('commentUpdate', (data) => this._commentUpdate.next(data));
+        this._connection.on('commentDelete', (data) => this._commentDelete.next(data));
+        this._connection.on('newNotify', (data) => this._newNotify.next(data));
+        this._connection.on('updateNotify', (data) => this._updateNotify.next(data));
+        this._connection.on('profileChange', (data) => this._profileChange.next(data));
+        this._connection.on('newChat', (data) => this._newChat.next(data));
+        this._connection.on('commentTyping', (data) => this._commentTyping.next(data));
+        this._connection.on('editing', (data) => this._editing.next(data));
+        this._connection.on('chatTyping', (data) => this._chatTyping.next(data));
+        this._connection.on('chatSeen', (data) => this._chatWathermark.next(data));
+        this._connection.on('voted', (data) => this._voted.next(data));
+        this._connection.on('callback', (data) => this._callback.next(data));
+        this._connection.on('jobProgress', (data) => this._jobProgress.next(data));
+        this._connection.on('reportProgress', (data) => this._reportProgress.next(data));
+        this._connection.on('configurationChange', () => this._configurationChange.next());
+        this._connection.onclose(() => this._state.next(HubConnectionState.Disconnected));
+        this._connection.onreconnected(() => this._state.next(HubConnectionState.Connected));
+    }
+    get state() {
+        return this._connection.state;
+    }
+    get connectionId() {
+        if (this._connection.state === HubConnectionState.Connected)
+            return this._connection.connectionId;
+        return null;
+    }
+    async start() {
+        await this._connection.start();
+        this._state.next(HubConnectionState.Connected);
+    }
+    async stop() {
+        await this._connection.stop();
+        this._state.next(HubConnectionState.Disconnected);
+    }
+}
+HubService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: HubService, deps: [{ token: i1.AuthenticationImpl }], target: i0.ɵɵFactoryTarget.Injectable });
+HubService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: HubService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: HubService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthenticationImpl }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hub.service.js","sourceRoot":"","sources":["../../../../../libraries/core/src/lib/core/hub.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { Comment, Notification, Chat, AvailabilityState, RecipientModel } from './models';\r\nimport { HubConnectionBuilder, HubConnection, HubConnectionState } from '@microsoft/signalr';\r\nimport { AuthenticationImpl } from './authentication';\r\n\r\n/** Listen to hub contracts */\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class HubService {\r\n  private _connection: HubConnection;\r\n  private readonly _state = new Subject<HubConnectionState>();\r\n  readonly state$ = this._state.asObservable();\r\n  private readonly _configurationChange = new Subject<void>();\r\n  private readonly _newMail = new Subject<NewMailEvent>();\r\n  private readonly _newChat = new Subject<ChatEvent>();\r\n  private readonly _newComment = new Subject<CommentEvent>();\r\n  private readonly _commentUpdate = new Subject<CommentEvent>();\r\n  private readonly _commentDelete = new Subject<CommentDeleteEvent>();\r\n  private readonly _updateMail = new Subject<MailUpdateEvent>();\r\n  private readonly _mailDelete = new Subject<MailDeleteEvent>();\r\n  private readonly _mailHeaderUpdate = new Subject<MailUpdateEvent>();\r\n  private readonly _newNotify = new Subject<NotificationEvent>();\r\n  private readonly _updateNotify = new Subject<NotificationEvent>();\r\n  private readonly _profileChange = new Subject<UserInfoEvent>();\r\n  private readonly _editing = new Subject<EditingEvent>();\r\n  private readonly _commentTyping = new Subject<CommentTypingEvent>();\r\n  private readonly _chatTyping = new Subject<ChatTypingEvent>();\r\n  private readonly _chatWathermark = new Subject<ChatWatermarkEvent>();\r\n  private readonly _voted = new Subject<VoteEvent>();\r\n  private readonly _jobProgress = new Subject<JobProgressEvent>();\r\n  private readonly _reportProgress = new Subject<ReportProgressEvent>();\r\n  private readonly _callback = new Subject<CallbackEvent>();\r\n  readonly configurationChange$ = this._configurationChange.asObservable();\r\n  readonly jobProgress$ = this._jobProgress.asObservable();\r\n  readonly reportProgress$ = this._reportProgress.asObservable();\r\n  readonly callback$ = this._callback.asObservable();\r\n  readonly vote$ = this._voted.asObservable();\r\n  readonly chatTyping$ = this._chatTyping.asObservable();\r\n  readonly chatWatermark$ = this._chatWathermark.asObservable();\r\n  readonly commentTyping$ = this._commentTyping.asObservable();\r\n  readonly editing$ = this._editing.asObservable();\r\n  readonly commentUpdate$ = this._commentUpdate.asObservable();\r\n  readonly commentDelete$ = this._commentDelete.asObservable();\r\n  /** new notification */\r\n  readonly notify$ = this._newNotify.asObservable();\r\n  readonly chat$ = this._newChat.asObservable();\r\n  readonly updateNotify$ = this._updateNotify.asObservable();\r\n  /** new mail */\r\n  readonly new$ = this._newMail.asObservable();\r\n  /** mail update */\r\n  readonly update$ = this._updateMail.asObservable();\r\n  readonly updateMailHeader$ = this._mailHeaderUpdate.asObservable();\r\n  readonly delete$ = this._mailDelete.asObservable();\r\n  readonly comment$ = this._newComment.asObservable();\r\n  readonly profileChange$ = this._profileChange.asObservable();\r\n  constructor(\r\n    private _auth: AuthenticationImpl) {\r\n    this._connection = new HubConnectionBuilder().withUrl('/chub',\r\n      {\r\n        accessTokenFactory: () => \r\n          this._auth.getAccessToken()\r\n      }).withAutomaticReconnect().build();\r\n    this._connection.on('newMail', (data: NewMailEvent) =>\r\n      this._newMail.next(data));\r\n    this._connection.on('mailUpdate', (data: MailUpdateEvent) =>\r\n      this._updateMail.next(data));\r\n    this._connection.on('mailDelete', (data: MailDeleteEvent) =>\r\n      this._mailDelete.next(data));\r\n    this._connection.on('mailHeaderUpdate', (data: MailUpdateEvent) =>\r\n      this._mailHeaderUpdate.next(data));\r\n    this._connection.on('newComment', (data: CommentEvent) => {\r\n      this._newComment.next(data);\r\n    });\r\n    this._connection.on('commentUpdate', (data: CommentEvent) =>\r\n      this._commentUpdate.next(data));\r\n    this._connection.on('commentDelete', (data: CommentDeleteEvent) =>\r\n      this._commentDelete.next(data));\r\n    this._connection.on('newNotify', (data: NotificationEvent) =>\r\n      this._newNotify.next(data));\r\n    this._connection.on('updateNotify', (data: NotificationEvent) =>\r\n      this._updateNotify.next(data));\r\n    this._connection.on('profileChange', (data: UserInfoEvent) =>\r\n      this._profileChange.next(data));\r\n    this._connection.on('newChat', (data: ChatEvent) =>\r\n      this._newChat.next(data));\r\n    this._connection.on('commentTyping', (data: CommentTypingEvent) =>\r\n      this._commentTyping.next(data));\r\n    this._connection.on('editing', (data: EditingEvent) =>\r\n      this._editing.next(data));\r\n    this._connection.on('chatTyping', (data: ChatTypingEvent) =>\r\n      this._chatTyping.next(data));\r\n    this._connection.on('chatSeen', (data: ChatWatermarkEvent) =>\r\n      this._chatWathermark.next(data));\r\n    this._connection.on('voted', (data: VoteEvent) =>\r\n      this._voted.next(data));\r\n    this._connection.on('callback', (data: CallbackEvent) =>\r\n      this._callback.next(data));\r\n    this._connection.on('jobProgress', (data: JobProgressEvent) =>\r\n      this._jobProgress.next(data));\r\n    this._connection.on('reportProgress', (data: ReportProgressEvent) =>\r\n      this._reportProgress.next(data));\r\n    this._connection.on('configurationChange', () =>\r\n      this._configurationChange.next());\r\n    this._connection.onclose(() =>\r\n      this._state.next(HubConnectionState.Disconnected)\r\n    );\r\n    this._connection.onreconnected(() =>\r\n      this._state.next(HubConnectionState.Connected)\r\n    );\r\n  }\r\n\r\n  get state(): HubConnectionState {\r\n    return this._connection.state;\r\n  }\r\n  get connectionId(): string {\r\n    if (this._connection.state === HubConnectionState.Connected)\r\n      return this._connection.connectionId;\r\n    return null;\r\n  }\r\n  public async start() {\r\n    await this._connection.start();\r\n    this._state.next(HubConnectionState.Connected);\r\n  }\r\n  public async stop() {\r\n    await this._connection.stop();\r\n    this._state.next(HubConnectionState.Disconnected);\r\n  }\r\n}\r\nexport interface NewMailEvent {\r\n  userId: string;\r\n  model: RecipientModel<any>;\r\n}\r\nexport interface MailUpdateEvent {\r\n  model: RecipientModel<any>;\r\n  userId: string;\r\n  time: Date;\r\n  originalRead?: boolean;\r\n}\r\nexport interface ChatEvent {\r\n  contactId: string;\r\n  model: Chat;\r\n}\r\nexport interface ChatTypingEvent {\r\n  contactId: string;\r\n}\r\nexport interface ChatWatermarkEvent {\r\n  contactId: string;\r\n  time: Date;\r\n}\r\nexport interface CommentTypingEvent {\r\n  id: number;\r\n  userId: string;\r\n}\r\nexport interface EditingEvent {\r\n  id: number;\r\n  userId: string;\r\n}\r\nexport interface MailDeleteEvent {\r\n  id: number;\r\n}\r\nexport interface CommentEvent {\r\n  id: number;\r\n  model: Comment;\r\n}\r\nexport interface CommentDeleteEvent {\r\n  id: number;\r\n  commentId: number;\r\n}\r\nexport interface VoteEvent {\r\n  id: number;\r\n  commentId: number;\r\n  votes?: number;\r\n  userId: string;\r\n  vote?: number;\r\n}\r\nexport interface NotificationEvent {\r\n  originalRead?: boolean;\r\n  model: Notification;\r\n}\r\nexport interface UserInfoEvent {\r\n  userId: string;\r\n  mode: AvailabilityState;\r\n}\r\nexport interface CallbackEvent {\r\n  message: any;\r\n}\r\nexport interface JobProgressEvent {\r\n  jobId: string;\r\n  event: JobProgress;\r\n}\r\nexport interface ReportProgressEvent {\r\n  name: string;\r\n  progress: number;\r\n}\r\nexport interface JobProgress {\r\n  value: number;\r\n  file?: string;\r\n  message?: string;\r\n  buferringValue?: number;\r\n}\r\n"]}

package/esm2020/lib/core/identity/identity.component.mjs

@@ -0,0 +1,67 @@
+import { Component, Input, Inject } from '@angular/core';
+import { BIZDOC_CONFIG } from '../../core/configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "../session.service";
+import * as i2 from "../translate.service";
+import * as i3 from "../../chat/chat-info";
+import * as i4 from "../account.service";
+import * as i5 from "@angular/common";
+import * as i6 from "../pipes/sanitize-html.pipe";
+import * as i7 from "../pipes/translate.pipe";
+/** identity component*/
+export class IdentityName {
+    /** identity ctor */
+    constructor(_session, _translate, config, _chat, _accounts) {
+        this._session = _session;
+        this._translate = _translate;
+        this._chat = _chat;
+        this._accounts = _accounts;
+        this.chating = 'room';
+        if (config.chating === false)
+            this.chating = 'none';
+    }
+    ngOnChanges() {
+        if (this.identity) {
+            if (this.identity === this._session.userId)
+                this.isMe = true;
+            else
+                this._accounts.get(this.identity).subscribe(u => {
+                    if (this.by)
+                        this._accounts.get(this.by).subscribe(b => this.name = this._translate.get('By', this._formatUserElement(u), this._formatUserElement(b)));
+                    else
+                        this.name = this._formatUserElement(u);
+                });
+        }
+    }
+    _formatUserElement(person) {
+        if (this.chating === 'none')
+            return person.nick || person.name;
+        else
+            return this._chat.format(person);
+    }
+    /**
+     * Chat
+     * @param e
+     */
+    chat(e) {
+        const userId = e.srcElement.getAttribute('data-info');
+        userId &&
+            this._chat.open(userId, { mode: this.chating });
+    }
+}
+IdentityName.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: IdentityName, deps: [{ token: i1.SessionService }, { token: i2.TranslateService }, { token: BIZDOC_CONFIG }, { token: i3.ChatInfo }, { token: i4.AccountService }], target: i0.ɵɵFactoryTarget.Component });
+IdentityName.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: IdentityName, selector: "bizdoc-identity-name", inputs: { identity: "identity", by: "by", chating: "chating" }, usesOnChanges: true, ngImport: i0, template: "<span *ngIf=\"!isMe else you\" class=\"name\" [innerHTML]=\"name | sanitizeHtml\" (click)=\"chat($event)\"></span>\r\n<ng-template #you>{{'You' | translate }}</ng-template>\r\n", directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "sanitizeHtml": i6.SanitizeHtmlPipe, "translate": i7.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: IdentityName, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-identity-name', template: "<span *ngIf=\"!isMe else you\" class=\"name\" [innerHTML]=\"name | sanitizeHtml\" (click)=\"chat($event)\"></span>\r\n<ng-template #you>{{'You' | translate }}</ng-template>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.SessionService }, { type: i2.TranslateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BIZDOC_CONFIG]
+                }] }, { type: i3.ChatInfo }, { type: i4.AccountService }]; }, propDecorators: { identity: [{
+                type: Input
+            }], by: [{
+                type: Input
+            }], chating: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/info/attachment-info.service.mjs

@@ -0,0 +1,51 @@
+import { Injectable, Injector } from '@angular/core';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { AttachmentPreview, FILE_PREVIEW_DIALOG_DATA } from '../../compose/attachments/preview/attachment-preview.component';
+import { isImage } from '../functions';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/cdk/bidi";
+export class AttachmentInfo {
+    constructor(_overlay, _injector, _dir) {
+        this._overlay = _overlay;
+        this._injector = _injector;
+        this._dir = _dir;
+    }
+    static exists(contentType) {
+        return isImage(contentType) || navigator.mimeTypes.namedItem(contentType) != null;
+    }
+    static isImage(contentType) {
+        return isImage(contentType);
+    }
+    static fileExt(fileName) {
+        return fileName.substr(fileName.lastIndexOf('.') + 1);
+    }
+    preview(item, fileId) {
+        const file = item.attachments.find(a => a.id === fileId);
+        const oRef = this._overlay.create({
+            positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),
+            backdropClass: 'dark-backdrop',
+            hasBackdrop: true,
+            direction: this._dir.value
+        });
+        const injector = Injector.create([
+            {
+                provide: FILE_PREVIEW_DIALOG_DATA, useValue: {
+                    file,
+                    documentId: item.documentId
+                }
+            },
+            { provide: OverlayRef, useValue: oRef }
+        ], this._injector);
+        const portal = new ComponentPortal(AttachmentPreview, null, injector);
+        oRef.attach(portal);
+        item.viewed = new Date();
+    }
+}
+AttachmentInfo.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: AttachmentInfo, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: i2.Directionality }], target: i0.ɵɵFactoryTarget.Injectable });
+AttachmentInfo.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: AttachmentInfo });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: AttachmentInfo, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.Directionality }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/info/document-info.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/router";
+export class DocumentInfo {
+    constructor(_router) {
+        this._router = _router;
+    }
+    /**
+     * preview form
+     * @param id documentId
+     */
+    open(id, policy) {
+        return this._router.navigate(['mailbox/d', id.encodeId()], { policy });
+    }
+}
+DocumentInfo.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentInfo, deps: [{ token: i1.RouterImpl }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentInfo.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentInfo });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentInfo, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.RouterImpl }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtaW5mby5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicmFyaWVzL2NvcmUvc3JjL2xpYi9jb3JlL2luZm8vZG9jdW1lbnQtaW5mby5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQUszQyxNQUFNLE9BQU8sWUFBWTtJQUN2QixZQUFvQixPQUFtQjtRQUFuQixZQUFPLEdBQVAsT0FBTyxDQUFZO0lBQUksQ0FBQztJQUM1Qzs7O09BR0c7SUFDSCxJQUFJLENBQUMsRUFBVSxFQUFFLE1BQW1CO1FBQ2xDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLFFBQVEsRUFBRSxDQUFDLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7O3lHQVJVLFlBQVk7NkdBQVosWUFBWTsyRkFBWixZQUFZO2tCQUR4QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBSb3V0ZXJJbXBsIH0gZnJvbSAnLi4vLi4vY29yZS9yb3V0ZXInO1xyXG5pbXBvcnQgeyBPcGVuUG9saWN5IH0gZnJvbSAnLi4vY29uZmlndXJhdGlvbic7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBEb2N1bWVudEluZm8ge1xyXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX3JvdXRlcjogUm91dGVySW1wbCkgeyB9XHJcbiAgLyoqXHJcbiAgICogcHJldmlldyBmb3JtXHJcbiAgICogQHBhcmFtIGlkIGRvY3VtZW50SWRcclxuICAgKi9cclxuICBvcGVuKGlkOiBudW1iZXIsIHBvbGljeT86IE9wZW5Qb2xpY3kpOiBQcm9taXNlPGFueT4ge1xyXG4gICAgcmV0dXJuIHRoaXMuX3JvdXRlci5uYXZpZ2F0ZShbJ21haWxib3gvZCcsIGlkLmVuY29kZUlkKCldLCB7IHBvbGljeSB9KTtcclxuICB9XHJcbn1cclxuIl19

package/esm2020/lib/core/info/location-info.component.mjs

@@ -0,0 +1,61 @@
+import { Component, InjectionToken, Inject } from "@angular/core";
+import { ESCAPE } from "@angular/cdk/keycodes";
+import { filter } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export const LOCATION_DATA = new InjectionToken('location_info');
+const MARKER_DELAY = 500;
+export class MapRef {
+    constructor(_oRef) {
+        this._oRef = _oRef;
+    }
+    closed() {
+        return this._oRef.detachments();
+    }
+}
+export class MapComponent {
+    constructor(_ref, _data, _elementRef) {
+        this._ref = _ref;
+        this._data = _data;
+        this._elementRef = _elementRef;
+    }
+    ngOnInit() {
+        const { placeId, name, location, address, phone, website } = this._data;
+        const map = new google.maps.Map(this._elementRef.nativeElement, {
+            center: location,
+            zoom: 16,
+            mapTypeControlOptions: {
+                mapTypeIds: ['HYBRID']
+            }
+        });
+        const marker = new google.maps.Marker({
+            position: location,
+            animation: google.maps.Animation.DROP,
+            map: map
+        });
+        if (name)
+            setTimeout(() => {
+                const infowindow = new google.maps.InfoWindow({
+                    content: `<h4 class="mat-h3">${name}</h4>
+<br /><address>${address || ''}</address>
+<br /><a href="${website}" target="${placeId}">${website || ''}</a>
+<br /><a href="tel:${phone}" dir="ltr">${phone || ''}</a>`
+                });
+                infowindow.open(map, marker);
+            }, MARKER_DELAY);
+        this._ref.keydownEvents().pipe(filter(k => k.keyCode === ESCAPE)).subscribe(() => this._ref.detach());
+        this._ref.backdropClick().pipe().subscribe(() => this._ref.detach());
+    }
+}
+MapComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: MapComponent, deps: [{ token: i1.OverlayRef }, { token: LOCATION_DATA }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+MapComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: MapComponent, selector: "bizdoc-map", host: { classAttribute: "mat-elevation-z4" }, ngImport: i0, template: '', isInline: true, styles: [":host{animation:scale-up-center .4s cubic-bezier(.39,.575,.565,1) both;min-width:50vw;min-height:50vh;display:block!important}@media (max-width: 599px){:host{width:90vw;height:90vh}}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: MapComponent, decorators: [{
+            type: Component,
+            args: [{ template: '', selector: 'bizdoc-map', host: {
+                        class: 'mat-elevation-z4'
+                    }, styles: [":host{animation:scale-up-center .4s cubic-bezier(.39,.575,.565,1) both;min-width:50vw;min-height:50vh;display:block!important}@media (max-width: 599px){:host{width:90vw;height:90vh}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.OverlayRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCATION_DATA]
+                }] }, { type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/info/map-info.mjs

@@ -0,0 +1,40 @@
+import { Injectable, Injector } from "@angular/core";
+import { OverlayRef } from "@angular/cdk/overlay";
+import { ComponentPortal } from "@angular/cdk/portal";
+import { MapRef, LOCATION_DATA, MapComponent } from "./location-info.component";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+/** helper service opens a map */
+export class MapInfo {
+    constructor(_overlay, _injector) {
+        this._overlay = _overlay;
+        this._injector = _injector;
+    }
+    /** open map */
+    open(location) {
+        const oRef = this._overlay.create({
+            positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),
+            hasBackdrop: true,
+            disposeOnNavigation: true,
+            backdropClass: 'cdk-overlay-transparent-backdrop',
+            panelClass: 'info-panel'
+        });
+        const injector = Injector.create([{
+                provide: OverlayRef,
+                useValue: oRef
+            },
+            {
+                provide: LOCATION_DATA,
+                useValue: location.location ? location : { location }
+            }], this._injector);
+        const portal = new ComponentPortal(MapComponent, null, injector);
+        oRef.attach(portal);
+        return new MapRef(oRef);
+    }
+}
+MapInfo.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: MapInfo, deps: [{ token: i1.Overlay }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+MapInfo.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: MapInfo });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: MapInfo, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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