@bizdoc/core 1.14.9 → 1.14.10

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

@@ -0,0 +1,118 @@
+import { Injectable, Inject, Injector } from '@angular/core';
+import { OverlayRef } from "@angular/cdk/overlay";
+import { ComponentPortal } from "@angular/cdk/portal";
+import { isMobile, isString } from '../functions';
+import { BIZDOC_CONFIG } from '../configuration';
+import { GuideComponent, TOUR_TOKEN } from './guide.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../session.service";
+import * as i3 from "../translate.service";
+export class GuideRef {
+    constructor(_guide, _overlayRef) {
+        this._guide = _guide;
+        this._overlayRef = _overlayRef;
+    }
+    closed() {
+        return this._overlayRef.detachments();
+    }
+}
+/** */
+export class GuideService {
+    constructor(_overlay, _injector, _session, _translate, _config) {
+        this._overlay = _overlay;
+        this._injector = _injector;
+        this._session = _session;
+        this._translate = _translate;
+        this._config = _config;
+        const guides = [this._intro()];
+        this._guides = guides.concat(this._session.profile.guides);
+    }
+    /** */
+    _intro() {
+        const mobile = isMobile();
+        const steps = [
+            { selector: '[data-help=compose]', content: this._translate.get('ComposeHelp'), position: 'End', title: this._translate.get('Compose') }
+        ];
+        steps.push({ navigate: 'dashboard', selector: '[data-help=dashboard]', content: this._translate.get('DashboardHelp'), title: this._translate.get('Dashboard') });
+        steps.push({
+            navigate: 'mailbox/f/ib',
+            selector: '[data-help=folders]',
+            simulate: !mobile,
+            content: this._translate.get('MailboxHelp'),
+            title: this._translate.get('Mailbox')
+        });
+        if (!this._config || this._config.chating !== false)
+            steps.push({
+                selector: '[data-help=chat]', content: this._translate.get('ChatHelp'),
+                simulate: !mobile,
+                position: 'Start', title: this._translate.get('Chat')
+            });
+        if (this._session.profile.cubes.length && this._session.profile.cubes[0].views.length) {
+            let path = `cube/${this._session.profile.cubes[0].name}/v/${this._session.profile.cubes[0].views[0].name}`;
+            steps.push({
+                simulate: !mobile,
+                navigate: path, selector: '[data-help=cube]',
+                content: this._translate.get('CubeHelp'), title: this._translate.get('Cube')
+            });
+        }
+        steps.push({ selector: '[data-help=notifications]', content: this._translate.get('NotificationsHelp'), title: this._translate.get('Notifications') });
+        return {
+            name: 'intro',
+            title: this._translate.get('Introduction'),
+            steps
+        };
+    }
+    get guides() {
+        return this._guides;
+    }
+    /**
+     *
+     * @param name
+     */
+    seen(name) {
+        return this._session.profile.options.guides && this._session.profile.options.guides.indexOf(name) > -1;
+    }
+    /**
+     *
+     * @param options
+     */
+    start(options) {
+        let guide;
+        if (isString(options)) {
+            guide = this._guides.find(g => g.name === options);
+            if (!guide)
+                throw `guide ${options} not found`;
+        }
+        else
+            guide = options;
+        const oRef = this._overlay.create({
+            panelClass: 'guide-panel',
+            hasBackdrop: true,
+            backdropClass: 'cdk-overlay-dark-backdrop',
+            disposeOnNavigation: true,
+            direction: this._session.direction
+        });
+        const injector = Injector.create([{
+                provide: TOUR_TOKEN, useValue: guide
+            }, {
+                provide: OverlayRef, useValue: oRef
+            }], this._injector);
+        const portal = new ComponentPortal(GuideComponent, null, injector);
+        oRef.attach(portal);
+        oRef.backdropClick().subscribe(() => oRef.detach());
+        const gRef = new GuideRef(guide, oRef);
+        !this.seen(guide.name) && this._session.guide(guide.name).subscribe();
+        return gRef;
+    }
+}
+GuideService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: GuideService, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: i2.SessionService }, { token: i3.TranslateService }, { token: BIZDOC_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+GuideService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: GuideService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: GuideService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.SessionService }, { type: i3.TranslateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BIZDOC_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guide.service.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/guide/guide.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAW,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,aAAa,EAAgB,MAAM,kBAAkB,CAAC;AAE/D,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;;;;;AAI/D,MAAM,OAAO,QAAQ;IACnB,YAAoB,MAAa,EAAU,WAAuB;QAA9C,WAAM,GAAN,MAAM,CAAO;QAAU,gBAAW,GAAX,WAAW,CAAY;IAAI,CAAC;IACvE,MAAM;QACJ,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;IACxC,CAAC;CACF;AAED,MAAM;AAEN,MAAM,OAAO,YAAY;IAEvB,YAAoB,QAAiB,EAC3B,SAAmB,EACnB,QAAwB,EACxB,UAA4B,EACL,OAAqB;QAJlC,aAAQ,GAAR,QAAQ,CAAS;QAC3B,cAAS,GAAT,SAAS,CAAU;QACnB,aAAQ,GAAR,QAAQ,CAAgB;QACxB,eAAU,GAAV,UAAU,CAAkB;QACL,YAAO,GAAP,OAAO,CAAc;QACpD,MAAM,MAAM,GAAY,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7D,CAAC;IACD,MAAM;IACE,MAAM;QACZ,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAgB;YACzB,EAAE,QAAQ,EAAE,qBAAqB,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;SACzI,CAAC;QACF,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,uBAAuB,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACjK,KAAK,CAAC,IAAI,CAAC;YACT,QAAQ,EAAE,cAAc;YACxB,QAAQ,EAAE,qBAAqB;YAC/B,QAAQ,EAAE,CAAC,MAAM;YACjB,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC;YAC3C,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC;SACtC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,KAAK;YACjD,KAAK,CAAC,IAAI,CAAC;gBACT,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC;gBACtE,QAAQ,EAAE,CAAC,MAAM;gBACjB,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;aACtD,CAAC,CAAC;QACL,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE;YACrF,IAAI,IAAI,GAAG,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC3G,KAAK,CAAC,IAAI,CAAC;gBACT,QAAQ,EAAE,CAAC,MAAM;gBACjB,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB;gBAC5C,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;aAC7E,CAAC,CAAC;SACJ;QACD,KAAK,CAAC,IAAI,CACR,EAAE,QAAQ,EAAE,2BAA2B,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,mBAAmB,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAC1I,CAAC;QACF,OAAO;YACL,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC;YAC1C,KAAK;SACG,CAAC;IACb,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD;;;OAGG;IACH,IAAI,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACzG,CAAC;IACD;;;OAGG;IACH,KAAK,CAAC,OAAuB;QAC3B,IAAI,KAAY,CAAC;QACjB,IAAI,QAAQ,CAAC,OAAO,CAAC,EAAE;YACrB,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;YACnD,IAAI,CAAC,KAAK;gBAAE,MAAM,SAAS,OAAO,YAAY,CAAC;SAChD;;YACI,KAAK,GAAG,OAAgB,CAAC;QAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;YAChC,UAAU,EAAE,aAAa;YACzB,WAAW,EAAE,IAAI;YACjB,aAAa,EAAE,2BAA2B;YAC1C,mBAAmB,EAAE,IAAI;YACzB,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAChC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK;aACrC,EAAE;gBACD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI;aACpC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACpB,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,cAAc,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;QACnE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACpB,IAAI,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACvC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;QACtE,OAAO,IAAI,CAAC;IACd,CAAC;;yGAvFU,YAAY,+HAMb,aAAa;6GANZ,YAAY,cADC,MAAM;2FACnB,YAAY;kBADxB,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAO7B,MAAM;2BAAC,aAAa","sourcesContent":["import { Injectable, Inject, Injector } from '@angular/core';\r\nimport { Overlay, OverlayRef } from \"@angular/cdk/overlay\";\r\nimport { ComponentPortal } from \"@angular/cdk/portal\";\r\nimport { isMobile, isString } from '../functions';\r\nimport { BIZDOC_CONFIG, BizDocConfig } from '../configuration';\r\nimport { GuideStep, Guide } from '../models';\r\nimport { GuideComponent, TOUR_TOKEN } from './guide.component';\r\nimport { SessionService } from '../session.service';\r\nimport { TranslateService } from '../translate.service';\r\n\r\nexport class GuideRef {\r\n  constructor(private _guide: Guide, private _overlayRef: OverlayRef) { }\r\n  closed() {\r\n    return this._overlayRef.detachments();\r\n  }\r\n}\r\n\r\n/** */\r\n@Injectable({ providedIn: 'root' })\r\nexport class GuideService {\r\n  private _guides: Guide[];\r\n  constructor(private _overlay: Overlay,\r\n    private _injector: Injector,\r\n    private _session: SessionService,\r\n    private _translate: TranslateService,\r\n    @Inject(BIZDOC_CONFIG) private _config: BizDocConfig) {\r\n    const guides: Guide[] = [this._intro()];\r\n    this._guides = guides.concat(this._session.profile.guides);\r\n  }\r\n  /** */\r\n  private _intro(): Guide {\r\n    const mobile = isMobile();\r\n    const steps: GuideStep[] = [\r\n      { selector: '[data-help=compose]', content: this._translate.get('ComposeHelp'), position: 'End', title: this._translate.get('Compose') }\r\n    ];\r\n    steps.push({ navigate: 'dashboard', selector: '[data-help=dashboard]', content: this._translate.get('DashboardHelp'), title: this._translate.get('Dashboard') });\r\n    steps.push({\r\n      navigate: 'mailbox/f/ib',\r\n      selector: '[data-help=folders]',\r\n      simulate: !mobile,\r\n      content: this._translate.get('MailboxHelp'),\r\n      title: this._translate.get('Mailbox')\r\n    });\r\n    if (!this._config || this._config.chating !== false)\r\n      steps.push({\r\n        selector: '[data-help=chat]', content: this._translate.get('ChatHelp'),\r\n        simulate: !mobile,\r\n        position: 'Start', title: this._translate.get('Chat')\r\n      });\r\n    if (this._session.profile.cubes.length && this._session.profile.cubes[0].views.length) {\r\n      let path = `cube/${this._session.profile.cubes[0].name}/v/${this._session.profile.cubes[0].views[0].name}`;\r\n      steps.push({\r\n        simulate: !mobile,\r\n        navigate: path, selector: '[data-help=cube]',\r\n        content: this._translate.get('CubeHelp'), title: this._translate.get('Cube')\r\n      });\r\n    }\r\n    steps.push(\r\n      { selector: '[data-help=notifications]', content: this._translate.get('NotificationsHelp'), title: this._translate.get('Notifications') }\r\n    );\r\n    return {\r\n      name: 'intro',\r\n      title: this._translate.get('Introduction'),\r\n      steps\r\n    } as Guide;\r\n  }\r\n\r\n  get guides(): Guide[] {\r\n    return this._guides;\r\n  }\r\n  /**\r\n   * \r\n   * @param name\r\n   */\r\n  seen(name: string): boolean {\r\n    return this._session.profile.options.guides && this._session.profile.options.guides.indexOf(name) > -1;\r\n  }\r\n  /**\r\n   * \r\n   * @param options\r\n   */\r\n  start(options: Guide | string) {\r\n    let guide: Guide;\r\n    if (isString(options)) {\r\n      guide = this._guides.find(g => g.name === options);\r\n      if (!guide) throw `guide ${options} not found`;\r\n    }\r\n    else guide = options as Guide;\r\n    const oRef = this._overlay.create({\r\n      panelClass: 'guide-panel',\r\n      hasBackdrop: true,\r\n      backdropClass: 'cdk-overlay-dark-backdrop',\r\n      disposeOnNavigation: true,\r\n      direction: this._session.direction\r\n    });\r\n    const injector = Injector.create([{\r\n      provide: TOUR_TOKEN, useValue: guide\r\n    }, {\r\n      provide: OverlayRef, useValue: oRef\r\n    }], this._injector);\r\n    const portal = new ComponentPortal(GuideComponent, null, injector);\r\n    oRef.attach(portal);\r\n    oRef.backdropClick().subscribe(() => oRef.detach());\r\n    const gRef = new GuideRef(guide, oRef);\r\n    !this.seen(guide.name) && this._session.guide(guide.name).subscribe();\r\n    return gRef;\r\n  }\r\n}\r\n"]}

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,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

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0YWNobWVudC1pbmZvLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJyYXJpZXMvY29yZS9zcmMvbGliL2NvcmUvaW5mby9hdHRhY2htZW50LWluZm8uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNyRCxPQUFPLEVBQVcsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFM0QsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSx3QkFBd0IsRUFBZSxNQUFNLGdFQUFnRSxDQUFDO0FBRTFJLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxjQUFjLENBQUM7Ozs7QUFHdkMsTUFBTSxPQUFPLGNBQWM7SUErQnpCLFlBQ1UsUUFBaUIsRUFDakIsU0FBbUIsRUFDbkIsSUFBb0I7UUFGcEIsYUFBUSxHQUFSLFFBQVEsQ0FBUztRQUNqQixjQUFTLEdBQVQsU0FBUyxDQUFVO1FBQ25CLFNBQUksR0FBSixJQUFJLENBQWdCO0lBQzlCLENBQUM7SUFsQ0QsTUFBTSxDQUFDLE1BQU0sQ0FBQyxXQUFtQjtRQUMvQixPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsSUFBSSxTQUFTLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsSUFBSSxJQUFJLENBQUM7SUFDcEYsQ0FBQztJQUNELE1BQU0sQ0FBQyxPQUFPLENBQUMsV0FBbUI7UUFDaEMsT0FBTyxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDOUIsQ0FBQztJQUNNLE1BQU0sQ0FBQyxPQUFPLENBQUMsUUFBZ0I7UUFDcEMsT0FBTyxRQUFRLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUNNLE9BQU8sQ0FBVSxJQUFzQixFQUFFLE1BQWM7UUFDNUQsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxDQUFDO1FBQ3pELE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDO1lBQ2hDLGdCQUFnQixFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsa0JBQWtCLEVBQUUsQ0FBQyxnQkFBZ0IsRUFBRTtZQUMzRixhQUFhLEVBQUUsZUFBZTtZQUM5QixXQUFXLEVBQUUsSUFBSTtZQUNqQixTQUFTLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLO1NBQzNCLENBQUMsQ0FBQztRQUNILE1BQU0sUUFBUSxHQUFHLFFBQVEsQ0FBQyxNQUFNLENBQUM7WUFDL0I7Z0JBQ0UsT0FBTyxFQUFFLHdCQUF3QixFQUFFLFFBQVEsRUFBRTtvQkFDM0MsSUFBSTtvQkFDSixVQUFVLEVBQUUsSUFBSSxDQUFDLFVBQVU7aUJBQ2I7YUFDakI7WUFDRCxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtTQUN4QyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNuQixNQUFNLE1BQU0sR0FBRyxJQUFJLGVBQWUsQ0FBQyxpQkFBaUIsRUFBRSxJQUFJLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDdEUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNwQixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7SUFDM0IsQ0FBQzs7MkdBOUJVLGNBQWM7K0dBQWQsY0FBYzsyRkFBZCxjQUFjO2tCQUQxQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgT3ZlcmxheSwgT3ZlcmxheVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9vdmVybGF5JztcclxuaW1wb3J0IHsgRGlyZWN0aW9uYWxpdHkgfSBmcm9tICdAYW5ndWxhci9jZGsvYmlkaSc7XHJcbmltcG9ydCB7IENvbXBvbmVudFBvcnRhbCB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9wb3J0YWwnO1xyXG5pbXBvcnQgeyBBdHRhY2htZW50UHJldmlldywgRklMRV9QUkVWSUVXX0RJQUxPR19EQVRBLCBQcmV2aWV3RGF0YSB9IGZyb20gJy4uLy4uL2NvbXBvc2UvYXR0YWNobWVudHMvcHJldmlldy9hdHRhY2htZW50LXByZXZpZXcuY29tcG9uZW50JztcclxuaW1wb3J0IHsgRG9jdW1lbnRNb2RlbCB9IGZyb20gJy4uLy4uL2NvcmUvbW9kZWxzJztcclxuaW1wb3J0IHsgaXNJbWFnZSB9IGZyb20gJy4uL2Z1bmN0aW9ucyc7IFxyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgQXR0YWNobWVudEluZm8ge1xyXG4gIHN0YXRpYyBleGlzdHMoY29udGVudFR5cGU6IHN0cmluZyk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIGlzSW1hZ2UoY29udGVudFR5cGUpIHx8IG5hdmlnYXRvci5taW1lVHlwZXMubmFtZWRJdGVtKGNvbnRlbnRUeXBlKSAhPSBudWxsO1xyXG4gIH1cclxuICBzdGF0aWMgaXNJbWFnZShjb250ZW50VHlwZTogc3RyaW5nKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gaXNJbWFnZShjb250ZW50VHlwZSk7XHJcbiAgfVxyXG4gIHB1YmxpYyBzdGF0aWMgZmlsZUV4dChmaWxlTmFtZTogc3RyaW5nKSB7XHJcbiAgICByZXR1cm4gZmlsZU5hbWUuc3Vic3RyKGZpbGVOYW1lLmxhc3RJbmRleE9mKCcuJykgKyAxKTtcclxuICB9XHJcbiAgcHVibGljIHByZXZpZXc8VCA9IGFueT4oaXRlbTogRG9jdW1lbnRNb2RlbDxUPiwgZmlsZUlkOiBudW1iZXIpIHtcclxuICAgIGNvbnN0IGZpbGUgPSBpdGVtLmF0dGFjaG1lbnRzLmZpbmQoYSA9PiBhLmlkID09PSBmaWxlSWQpO1xyXG4gICAgY29uc3Qgb1JlZiA9IHRoaXMuX292ZXJsYXkuY3JlYXRlKHtcclxuICAgICAgcG9zaXRpb25TdHJhdGVneTogdGhpcy5fb3ZlcmxheS5wb3NpdGlvbigpLmdsb2JhbCgpLmNlbnRlckhvcml6b250YWxseSgpLmNlbnRlclZlcnRpY2FsbHkoKSxcclxuICAgICAgYmFja2Ryb3BDbGFzczogJ2RhcmstYmFja2Ryb3AnLFxyXG4gICAgICBoYXNCYWNrZHJvcDogdHJ1ZSxcclxuICAgICAgZGlyZWN0aW9uOiB0aGlzLl9kaXIudmFsdWVcclxuICAgIH0pO1xyXG4gICAgY29uc3QgaW5qZWN0b3IgPSBJbmplY3Rvci5jcmVhdGUoW1xyXG4gICAgICB7XHJcbiAgICAgICAgcHJvdmlkZTogRklMRV9QUkVWSUVXX0RJQUxPR19EQVRBLCB1c2VWYWx1ZToge1xyXG4gICAgICAgICAgZmlsZSxcclxuICAgICAgICAgIGRvY3VtZW50SWQ6IGl0ZW0uZG9jdW1lbnRJZFxyXG4gICAgICAgIH0gYXMgUHJldmlld0RhdGFcclxuICAgICAgfSxcclxuICAgICAgeyBwcm92aWRlOiBPdmVybGF5UmVmLCB1c2VWYWx1ZTogb1JlZiB9XHJcbiAgICBdLCB0aGlzLl9pbmplY3Rvcik7XHJcbiAgICBjb25zdCBwb3J0YWwgPSBuZXcgQ29tcG9uZW50UG9ydGFsKEF0dGFjaG1lbnRQcmV2aWV3LCBudWxsLCBpbmplY3Rvcik7XHJcbiAgICBvUmVmLmF0dGFjaChwb3J0YWwpO1xyXG4gICAgaXRlbS52aWV3ZWQgPSBuZXcgRGF0ZSgpO1xyXG4gIH1cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByaXZhdGUgX292ZXJsYXk6IE92ZXJsYXksXHJcbiAgICBwcml2YXRlIF9pbmplY3RvcjogSW5qZWN0b3IsXHJcbiAgICBwcml2YXRlIF9kaXI6IERpcmVjdGlvbmFsaXR5KSB7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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