@bizdoc/core 1.14.9 → 1.14.10

package/esm2020/lib/views/timeline/timeline.component.exp.mjs

@@ -0,0 +1,313 @@
+import { __decorate } from "tslib";
+import { Component, Inject, HostBinding } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { tap, map } from 'rxjs/operators';
+import { BIZDOC_CONFIG } from '../../core/configuration';
+import { BizDoc } from '../../core/decorators';
+import { DayMarkersService, Gantt, SelectionService } from '@syncfusion/ej2-angular-gantt';
+import dayjs from 'dayjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/prompt.service";
+import * as i2 from "../document-view-ref";
+import * as i3 from "../../core/account.service";
+import * as i4 from "../../core/mailbox.service";
+import * as i5 from "../../core/session.service";
+import * as i6 from "../../core/translate.service";
+import * as i7 from "../../core/router";
+let TimelineViewComponent = class TimelineViewComponent {
+    /** timeline-view ctor */
+    constructor(_ps, viewRef, config, _users, _mailbox, _session, _translate, _router, _element) {
+        this._ps = _ps;
+        this._users = _users;
+        this._mailbox = _mailbox;
+        this._session = _session;
+        this._translate = _translate;
+        this._router = _router;
+        this._element = _element;
+        this.dir = this._session.direction;
+        this.locale = this._session.language;
+        this.selectionSettings = {};
+        this.taskFields = {
+            id: 'id',
+            name: 'title',
+            startDate: 'time',
+            endDate: 'ending',
+            duration: 'duration',
+            dependency: 'dependencies',
+            child: 'subtasks'
+        };
+        this.tooltipSettings = { showTooltip: false };
+        this.timelineSettings = {
+            timelineUnitSize: 60,
+            topTier: {
+                format: 'MMM dd, yyyy',
+                unit: 'Day',
+            },
+            bottomTier: {
+                unit: 'Hour',
+                format: 'h.mm a'
+            }
+        };
+        this.eventMarkers = [];
+        this.labelSettings = {
+            rightLabel: 'name', leftLabel: 'title'
+        };
+        this.splitterSettings = {
+            columnIndex: 3,
+            view: 'Chart',
+            separatorSize: 0
+        };
+        this.dayWorkingTime = [{ from: 0, to: 24 }];
+        this.columns = [
+            { field: 'title', headerText: _translate.get('Task') },
+            { field: 'name', headerText: _translate.get('Who') },
+            { field: 'time', headerText: _translate.get('When') }
+        ];
+        this.dateFormat = config && config.formats && config.formats.dateTime || 'MMMM d, yyyy hh:mm';
+        this.holidays = _session.profile.holidays &&
+            _session.profile.holidays.map(h => ({ from: h.startDate, to: h.fromDate, label: h.title }));
+        viewRef.resize.subscribe(d => {
+            this.width = d.width - 16;
+            if (this.gantt) {
+                this.gantt.width = d.width - 16;
+                this.gantt.windowResize();
+            }
+        });
+    }
+    onBind(model) {
+        this.item = model;
+        this._prepare(model).subscribe(tasks => {
+            this._draw(tasks);
+            //this.gantt.scrollToDate(new Date().toString());
+        });
+    }
+    _draw(tasks) {
+        this.gantt && this.gantt.destroy();
+        this.gantt = new Gantt({
+            dataSource: tasks,
+            taskFields: this.taskFields,
+            columns: this.columns,
+            enableRtl: this._session.inverse,
+            //  timelineSettings: this.timelineSettings,
+            labelSettings: this.labelSettings,
+            eventMarkers: this.eventMarkers,
+            readOnly: true,
+            selectionSettings: this.selectionSettings,
+            allowSelection: true,
+            dateFormat: this.dateFormat,
+            tooltipSettings: this.tooltipSettings,
+            rowSelecting: this.rowSelecting.bind(this),
+            holidays: this.holidays,
+            //  includeWeekend: true,
+            splitterSettings: this.splitterSettings,
+            //  durationUnit: 'Hour',
+            taskbarHeight: 30,
+            rowHeight: 40,
+            width: this.width
+            //  dayWorkingTime: this.dayWorkingTime
+        }, this._element.nativeElement);
+        this.columns.forEach(c => this.gantt.hideColumn(c.field));
+    }
+    _prepare(model) {
+        const promisses = [];
+        let i = 0;
+        const tasks = [];
+        //const observable = this._mailbox.timeline(model.documentId).pipe(tap(t => {
+        //}))
+        const process = (model) => {
+            model.log.forEach(l => {
+                let task;
+                switch (l.type) {
+                    case 'Submit':
+                        this.eventMarkers.push({
+                            day: new Date(l.time),
+                            label: this._translate.get('Submition')
+                        });
+                        return;
+                    case 'StateChange':
+                        {
+                            const state = this._session.profile.states.find(s => s.name === l.state);
+                            task = {
+                                id: i++,
+                                type: l.type,
+                                nodeId: l.nodeId,
+                                time: new Date(l.time),
+                                title: state ? state.past || state.title : l.state
+                            };
+                            if (l.duration) {
+                                task.ending = new Date(task.time.valueOf() + l.duration * 1000);
+                                task.duration = l.duration * 1000;
+                            }
+                            else
+                                task.ending = model.completed ? new Date(l.time) : new Date();
+                            tasks.push(task);
+                            break;
+                        }
+                    case 'ModelChange':
+                        {
+                            task = {
+                                id: i++,
+                                type: l.type,
+                                nodeId: l.nodeId,
+                                time: new Date(l.time),
+                                title: this._translate.get('Edited')
+                            };
+                            if (l.duration) {
+                                task.ending = new Date(task.time.valueOf() + l.duration * 1000);
+                                task.duration = l.duration * 1000;
+                            }
+                            else
+                                task.ending = new Date();
+                            const state = tasks.find(t => t.type === 'StateChange' && t.time <= task.time && (!t.ending || t.ending >= task.ending));
+                            if (state) {
+                                if (!state.subtasks)
+                                    state.subtasks = [];
+                                state.subtasks.push(task);
+                            }
+                            else
+                                tasks.push(task);
+                            break;
+                        }
+                    case 'ActionTaken':
+                        {
+                            const action = this._session.profile.actions.find(a => a.name === l.action);
+                            if (l.action === 'delete')
+                                return;
+                            const time = dayjs(l.time);
+                            task = {
+                                id: i++,
+                                type: l.type,
+                                nodeId: l.nodeId,
+                                ending: time.toDate(),
+                                time: time.add(-l.duration, 's').toDate(),
+                                duration: l.duration * 1000,
+                                title: action ? action.past || action.title : l.action
+                            };
+                            if (l.nodeId) {
+                                model.workflow.connectors.filter(c => c.targetId === l.nodeId).forEach(c => {
+                                    const dependencies = tasks.filter(l => l.nodeId === c.sourceId).map(l => `FS${l.id}`);
+                                    if (dependencies.length)
+                                        task.dependencies = dependencies.join(',');
+                                });
+                            }
+                            const state = tasks.find(t => t.type === 'StateChange' && t.time <= task.time && (!t.ending || t.ending >= task.ending));
+                            if (state) {
+                                if (!state.subtasks)
+                                    state.subtasks = [];
+                                state.subtasks.push(task);
+                            }
+                            else
+                                tasks.push(task);
+                            break;
+                        }
+                    default:
+                        return;
+                }
+                if (l.byId) {
+                    const who = this._users.get(l.userId), by = this._users.get(l.byId);
+                    const promise = forkJoin(who, by).pipe(tap(ns => {
+                        const [who, by] = ns;
+                        task.name = this._translate.get('By', who.name, by.name);
+                        //    if (l.role) {
+                        //        const role = this.session.profile.roles.find(o => o.name === l.role);
+                        //        if (role) task.name += `, ${role.name}`;
+                        //    }
+                    }, () => this._ps.error()));
+                    promisses.push(promise);
+                }
+                else if (l.userId) {
+                    const promise = this._users.get(l.userId).pipe(tap(u => {
+                        task.name = u.name;
+                        //    if (l.role) {
+                        //        const role = this.session.profile.roles.find(o => o.name === l.role);
+                        //        if (role) task.name += `, ${role.name}`;
+                        //    }
+                    }, () => this._ps.error()));
+                    promisses.push(promise);
+                }
+            });
+            model.events.forEach(e => {
+                this.eventMarkers.push({
+                    day: new Date(e.starting),
+                    label: e.title
+                });
+            });
+            model.recipients.forEach(r => {
+                if (!r.pending)
+                    return;
+                const task = {
+                    id: i++,
+                    type: 'pending',
+                    time: new Date(r.received),
+                    title: this._translate.get('IsPending')
+                };
+                if (r.substituteId) {
+                    const byPromise = this._users.get(r.substituteId);
+                    const whoPromise = this._users.get(r.userId);
+                    const promise = forkJoin(whoPromise, byPromise).pipe(tap(n => {
+                        task.name = this._translate.get('WhoSubstituting', n[0].name, n[1].name);
+                        if (r.role) {
+                            const role = this._session.profile.roles.find(o => o.name === r.role);
+                            if (role)
+                                task.name += `, ${role.name}`;
+                        }
+                    }, () => this._ps.error()));
+                    promisses.push(promise);
+                }
+                else {
+                    const promise = this._users.get(r.userId).pipe(tap(u => {
+                        task.name = u.name;
+                        if (r.role) {
+                            const role = this._session.profile.roles.find(o => o.name === r.role);
+                            if (role)
+                                task.name += `, ${role.name}`;
+                        }
+                    }, () => this._ps.error()));
+                    promisses.push(promise);
+                }
+                if (r.nodeId) {
+                    model.workflow.connectors.filter(c => c.targetId === r.nodeId).forEach(c => {
+                        const predecessors = tasks.filter(l => l.nodeId === c.sourceId).map(l => l.id);
+                        if (predecessors.length)
+                            task.dependencies = predecessors.join(',');
+                    });
+                }
+                const state = tasks.find(t => t.type === 'StateChange' && t.time <= task.time && (!t.ending || t.ending >= task.time));
+                if (state) {
+                    if (!state.subtasks)
+                        state.subtasks = [];
+                    state.subtasks.push(task);
+                }
+                else
+                    tasks.push(task);
+            });
+        };
+        process(model);
+        return forkJoin(promisses).
+            pipe(map(() => tasks.sort((t0, t1) => t0.time > t1.time ? 1 : -1)));
+    }
+    rowSelecting(r) {
+        if (r.data.taskData.type === 'ModelChange')
+            this._compare(r.data);
+    }
+    _compare(task) {
+        this._router.navigate(['mailbox/d', this.item.documentId.encodeId(), 'version', task.time.valueOf().encodeId()], { state: { item: this.item } });
+    }
+};
+TimelineViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TimelineViewComponent, deps: [{ token: i1.PromptService }, { token: i2.DocumentViewRef }, { token: BIZDOC_CONFIG }, { token: i3.AccountService }, { token: i4.MailboxService }, { token: i5.SessionService }, { token: i6.TranslateService }, { token: i7.RouterImpl }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+TimelineViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: TimelineViewComponent, selector: "bizdoc-timeline", host: { properties: { "dir": "this.dir" }, classAttribute: "view" }, providers: [SelectionService, DayMarkersService], ngImport: i0, template: '', isInline: true, styles: [":host{padding:8px}:host ::ng-deep .e-split-bar{display:none!important}\n"] });
+TimelineViewComponent = __decorate([
+    BizDoc({ selector: 'bizdoc-timeline' })
+    /** timeline-view component*/
+], TimelineViewComponent);
+export { TimelineViewComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TimelineViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-timeline', template: '', host: { class: 'view' }, providers: [SelectionService, DayMarkersService], styles: [":host{padding:8px}:host ::ng-deep .e-split-bar{display:none!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PromptService }, { type: i2.DocumentViewRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BIZDOC_CONFIG]
+                }] }, { type: i3.AccountService }, { type: i4.MailboxService }, { type: i5.SessionService }, { type: i6.TranslateService }, { type: i7.RouterImpl }, { type: i0.ElementRef }]; }, propDecorators: { dir: [{
+                type: HostBinding
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timeline.component.exp.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/views/timeline/timeline.component.exp.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, HostBinding } from '@angular/core';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { PromptService } from '../../core/prompt.service';\r\nimport { AccountService } from '../../core/account.service';\r\nimport { Observable, forkJoin } from 'rxjs';\r\nimport { tap, map } from 'rxjs/operators';\r\nimport { DocumentViewComponent } from '../../core/base';\r\nimport { Chain, DocumentModel } from '../../core/models';\r\nimport { BizDocConfig, BIZDOC_CONFIG } from '../../core/configuration';\r\nimport { BizDoc } from '../../core/decorators';\r\nimport { ColumnModel, DayMarkersService, DayWorkingTimeModel, EventMarkerModel, Gantt, HolidayModel, LabelSettingsModel, SelectionService, SelectionSettingsModel, SplitterSettingsModel, TaskFieldsModel, TimelineSettingsModel } from '@syncfusion/ej2-angular-gantt';\r\nimport { ElementRef } from '@angular/core';\r\nimport { RouterImpl } from '../../core/router';\r\nimport { DocumentViewRef } from '../document-view-ref';\r\nimport { MailboxService } from '../../core/mailbox.service';\r\nimport dayjs from 'dayjs';\r\n\r\n@Component({\r\n  selector: 'bizdoc-timeline',\r\n  template: '',\r\n  styleUrls: ['timeline.component.scss'],\r\n  host: { class: 'view' },\r\n  providers: [SelectionService, DayMarkersService]\r\n})\r\n@BizDoc({ selector: 'bizdoc-timeline' })\r\n/** timeline-view component*/\r\nexport class TimelineViewComponent implements DocumentViewComponent {\r\n  data: Task[];\r\n  @HostBinding()\r\n  readonly dir = this._session.direction;\r\n  readonly locale = this._session.language;\r\n  item: DocumentModel<any>;\r\n  gantt: Gantt;\r\n  dateFormat: string;\r\n  holidays: HolidayModel[];\r\n  width: number;\r\n  readonly selectionSettings = {} as SelectionSettingsModel;\r\n  /** timeline-view ctor */\r\n  constructor(\r\n    private _ps: PromptService,\r\n    viewRef: DocumentViewRef<Options>,\r\n    @Inject(BIZDOC_CONFIG) config: BizDocConfig,\r\n    private _users: AccountService,\r\n    private _mailbox: MailboxService,\r\n    private _session: SessionService,\r\n    private _translate: TranslateService,\r\n    private _router: RouterImpl,\r\n    private _element: ElementRef) {\r\n    this.columns = [\r\n      { field: 'title', headerText: _translate.get('Task') },\r\n      { field: 'name', headerText: _translate.get('Who') },\r\n      { field: 'time', headerText: _translate.get('When') }\r\n    ];\r\n    this.dateFormat = config && config.formats && config.formats.dateTime || 'MMMM d, yyyy hh:mm';\r\n    this.holidays = _session.profile.holidays &&\r\n      _session.profile.holidays.map(h => ({ from: h.startDate, to: h.fromDate, label: h.title }))\r\n    viewRef.resize.subscribe(d => {\r\n      this.width = d.width - 16;\r\n      if (this.gantt) {\r\n        this.gantt.width = d.width - 16;\r\n        this.gantt.windowResize();\r\n      }\r\n    });\r\n  }\r\n  onBind(model: DocumentModel<any>) {\r\n    this.item = model;\r\n    this._prepare(model).subscribe(tasks => {\r\n      this._draw(tasks);\r\n      //this.gantt.scrollToDate(new Date().toString());\r\n    });\r\n  }\r\n  private _draw(tasks: Task[]) {\r\n    this.gantt && this.gantt.destroy();\r\n    this.gantt = new Gantt({\r\n      dataSource: tasks,\r\n      taskFields: this.taskFields,\r\n      columns: this.columns,\r\n      enableRtl: this._session.inverse,\r\n      //  timelineSettings: this.timelineSettings,\r\n      labelSettings: this.labelSettings,\r\n      eventMarkers: this.eventMarkers,\r\n      readOnly: true,\r\n      selectionSettings: this.selectionSettings,\r\n      allowSelection: true,\r\n      dateFormat: this.dateFormat,\r\n      tooltipSettings: this.tooltipSettings,\r\n      rowSelecting: this.rowSelecting.bind(this),\r\n      holidays: this.holidays,\r\n      //  includeWeekend: true,\r\n      splitterSettings: this.splitterSettings,\r\n      //  durationUnit: 'Hour',\r\n      taskbarHeight: 30,\r\n      rowHeight: 40,\r\n      width: this.width\r\n      //  dayWorkingTime: this.dayWorkingTime\r\n    }, this._element.nativeElement)\r\n    this.columns.forEach(c =>\r\n      this.gantt.hideColumn(c.field)\r\n    )\r\n  }\r\n  private _prepare(model: DocumentModel<any>): Observable<Task[]> {\r\n    const promisses: Observable<any>[] = [];\r\n    let i = 0;\r\n    const tasks: Task[] = [];\r\n\r\n    //const observable = this._mailbox.timeline(model.documentId).pipe(tap(t => {\r\n    //}))\r\n\r\n    const process = (model: DocumentModel)=>{\r\n    model.log.forEach(l => {\r\n      let task: Task;\r\n      switch (l.type) {\r\n        case 'Submit':\r\n          this.eventMarkers.push({\r\n            day: new Date(l.time),\r\n            label: this._translate.get('Submition')\r\n          });\r\n          return;\r\n        case 'StateChange':\r\n          {\r\n            const state = this._session.profile.states.find(s => s.name === l.state);\r\n            task = {\r\n              id: i++,\r\n              type: l.type,\r\n              nodeId: l.nodeId,\r\n              time: new Date(l.time),\r\n              title: state ? state.past || state.title : l.state\r\n            };\r\n            if (l.duration) {\r\n              task.ending = new Date(task.time.valueOf() + l.duration * 1000);\r\n              task.duration = l.duration * 1000;\r\n            }\r\n            else\r\n              task.ending = model.completed ? new Date(l.time) : new Date();\r\n            tasks.push(task);\r\n            break;\r\n          }\r\n        case 'ModelChange':\r\n          {\r\n            task = {\r\n              id: i++,\r\n              type: l.type,\r\n              nodeId: l.nodeId,\r\n              time: new Date(l.time),\r\n              title: this._translate.get('Edited')\r\n            };\r\n            if (l.duration) {\r\n              task.ending = new Date(task.time.valueOf() + l.duration * 1000);\r\n              task.duration = l.duration * 1000;\r\n            }\r\n            else task.ending = new Date();\r\n\r\n            const state = tasks.find(t => t.type === 'StateChange' && t.time <= task.time && (!t.ending || t.ending >= task.ending));\r\n            if (state) {\r\n              if (!state.subtasks) state.subtasks = [];\r\n              state.subtasks.push(task);\r\n            }\r\n            else\r\n              tasks.push(task);\r\n            break;\r\n          }\r\n        case 'ActionTaken':\r\n          {\r\n            const action = this._session.profile.actions.find(a => a.name === l.action);\r\n            if (l.action === 'delete') return;\r\n            const time = dayjs(l.time);\r\n            task = {\r\n              id: i++,\r\n              type: l.type,\r\n              nodeId: l.nodeId,\r\n              ending: time.toDate(),\r\n              time: time.add(- l.duration, 's').toDate(),\r\n              duration: l.duration * 1000,\r\n              title: action ? action.past || action.title : l.action\r\n            };\r\n            if (l.nodeId) {\r\n              model.workflow.connectors.filter(c => c.targetId === l.nodeId).forEach(c => {\r\n                const dependencies = tasks.filter(l => l.nodeId === c.sourceId).map(l => `FS${l.id}`);\r\n                if (dependencies.length) task.dependencies = dependencies.join(',');\r\n              });\r\n            }\r\n            const state = tasks.find(t => t.type === 'StateChange' && t.time <= task.time && (!t.ending || t.ending >= task.ending));\r\n            if (state) {\r\n              if (!state.subtasks) state.subtasks = [];\r\n              state.subtasks.push(task);\r\n            }\r\n            else\r\n              tasks.push(task);\r\n            break;\r\n          }\r\n        default:\r\n          return;\r\n      }\r\n      if (l.byId) {\r\n        const who = this._users.get(l.userId),\r\n          by = this._users.get(l.byId);\r\n        const promise = forkJoin(who, by).pipe(tap(ns => {\r\n          const [who, by] = ns;\r\n          task.name = this._translate.get('By', who.name, by.name);\r\n          //    if (l.role) {\r\n          //        const role = this.session.profile.roles.find(o => o.name === l.role);\r\n          //        if (role) task.name += `, ${role.name}`;\r\n          //    }\r\n        }, () => this._ps.error()));\r\n\r\n        promisses.push(promise);\r\n      }\r\n      else if (l.userId) {\r\n        const promise = this._users.get(l.userId).pipe(tap(u => {\r\n          task.name = u.name;\r\n          //    if (l.role) {\r\n          //        const role = this.session.profile.roles.find(o => o.name === l.role);\r\n          //        if (role) task.name += `, ${role.name}`;\r\n          //    }\r\n        }, () => this._ps.error()));\r\n        promisses.push(promise);\r\n      }\r\n    });\r\n    model.events.forEach(e => {\r\n      this.eventMarkers.push({\r\n        day: new Date(e.starting),\r\n        label: e.title\r\n      });\r\n    });\r\n    model.recipients.forEach(r => {\r\n      if (!r.pending)\r\n        return;\r\n      const task: Task = {\r\n        id: i++,\r\n        type: 'pending',\r\n        time: new Date(r.received),\r\n        title: this._translate.get('IsPending')\r\n      };\r\n      if (r.substituteId) {\r\n        const byPromise = this._users.get(r.substituteId);\r\n        const whoPromise = this._users.get(r.userId);\r\n        const promise = forkJoin(whoPromise, byPromise).pipe(tap(n => {\r\n          task.name = this._translate.get('WhoSubstituting', n[0].name, n[1].name);\r\n          if (r.role) {\r\n            const role = this._session.profile.roles.find(o => o.name === r.role);\r\n            if (role) task.name += `, ${role.name}`;\r\n          }\r\n        }, () => this._ps.error()));\r\n\r\n        promisses.push(promise);\r\n      }\r\n      else {\r\n        const promise = this._users.get(r.userId).pipe(tap(u => {\r\n          task.name = u.name;\r\n          if (r.role) {\r\n            const role = this._session.profile.roles.find(o => o.name === r.role);\r\n            if (role) task.name += `, ${role.name}`;\r\n          }\r\n        }, () => this._ps.error()));\r\n        promisses.push(promise);\r\n      }\r\n      if (r.nodeId) {\r\n        model.workflow.connectors.filter(c => c.targetId === r.nodeId).forEach(c => {\r\n          const predecessors = tasks.filter(l => l.nodeId === c.sourceId).map(l => l.id);\r\n          if (predecessors.length) task.dependencies = predecessors.join(',');\r\n        });\r\n      }\r\n      const state = tasks.find(t => t.type === 'StateChange' && t.time <= task.time && (!t.ending || t.ending >= task.time));\r\n      if (state) {\r\n        if (!state.subtasks) state.subtasks = [];\r\n        state.subtasks.push(task);\r\n      }\r\n      else\r\n        tasks.push(task);\r\n    });\r\n  }\r\n    process(model);\r\n    return forkJoin(promisses).\r\n      pipe(map(() => tasks.sort((t0, t1) => t0.time > t1.time ? 1 : -1)));\r\n  }\r\n  rowSelecting(r) {\r\n    if (r.data.taskData.type === 'ModelChange')\r\n      this._compare(r.data);\r\n  }\r\n  public _compare(task: Task) {\r\n    this._router.navigate(['mailbox/d', this.item.documentId.encodeId(), 'version', task.time.valueOf().encodeId()], { state: { item: this.item } })\r\n  }\r\n  readonly taskFields: TaskFieldsModel = {\r\n    id: 'id',\r\n    name: 'title',\r\n    startDate: 'time',\r\n    endDate: 'ending',\r\n    duration: 'duration',\r\n    dependency: 'dependencies',\r\n    child: 'subtasks'\r\n  };\r\n  columns: ColumnModel[];\r\n  readonly tooltipSettings = { showTooltip: false };\r\n  readonly timelineSettings: TimelineSettingsModel = {\r\n    timelineUnitSize: 60,\r\n    topTier: {\r\n      format: 'MMM dd, yyyy',\r\n      unit: 'Day',\r\n    },\r\n    bottomTier: {\r\n      unit: 'Hour',\r\n      format: 'h.mm a'\r\n    }\r\n  };\r\n  readonly eventMarkers: EventMarkerModel[] = [\r\n  ];\r\n  public labelSettings: LabelSettingsModel = {\r\n    rightLabel: 'name', leftLabel: 'title'\r\n  };\r\n  public splitterSettings: SplitterSettingsModel = {\r\n    columnIndex: 3,\r\n    view: 'Chart',\r\n    separatorSize: 0\r\n  };\r\n  public dayWorkingTime: DayWorkingTimeModel[] = [{ from: 0, to: 24 }];\r\n}\r\ninterface Task {\r\n  id: number;\r\n  type: string;\r\n  nodeId?: string;\r\n  name?: string;\r\n  title?: string;\r\n  time: Date;\r\n  ending?: Date;\r\n  duration?: number;\r\n  subtasks?: Task[];\r\n  dependencies?: string;\r\n  indicators?: any[],\r\n}\r\ninterface Options {\r\n\r\n}\r\n"]}

package/esm2020/lib/views/view-item.component.mjs

@@ -0,0 +1,67 @@
+import { Component, HostListener, Injector, Input } from "@angular/core";
+import { takeUntil } from "rxjs";
+import { Subject } from "rxjs";
+import { debounceTime } from "rxjs/operators";
+import { DocumentViewRef } from "./document-view-ref";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../core/component-factory-resolver";
+export class ViewItemComponent {
+    constructor(_http, _vc, _injector, _cf) {
+        this._http = _http;
+        this._vc = _vc;
+        this._injector = _injector;
+        this._cf = _cf;
+        this._resizing = new Subject();
+        this._destroy = new Subject();
+    }
+    get hidden() { return this._viewRef && this._viewRef.hidden; }
+    get viewRef() { return this._viewRef; }
+    ngAfterViewInit() {
+        // dom
+        const factory = this._cf.resolve(this.view.template);
+        this._viewRef = new DocumentViewRef(this._http, this.model, this.view, this._dim());
+        const injector = Injector.create([{ provide: DocumentViewRef, useValue: this._viewRef }], this._injector);
+        this._instance = this._vc.createComponent(factory, 0, injector).instance;
+        try {
+            this._instance.onBind(this.model);
+        }
+        catch (e) {
+        }
+        this._resizing.pipe(debounceTime(150), takeUntil(this._destroy)).subscribe(() => this._viewRef._resize.next(this._dim()));
+    }
+    _dim() {
+        let el = this._vc.element.nativeElement.parentElement, dim = el.getBoundingClientRect();
+        while (dim.width === 0) {
+            el = el.parentElement;
+            dim = el.getBoundingClientRect();
+        }
+        return dim;
+    }
+    resize() {
+        this._resizing.next();
+    }
+    ngOnDestroy() {
+        this._viewRef._destroy();
+        this._destroy.next();
+        this._destroy.complete();
+    }
+}
+ViewItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ViewItemComponent, deps: [{ token: i1.HttpClient }, { token: i0.ViewContainerRef }, { token: i0.Injector }, { token: i2.BizDocComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component });
+ViewItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: ViewItemComponent, selector: "bizdoc-document-view-item", inputs: { model: "model", view: "view" }, host: { listeners: { "window:resize": "resize()" } }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ViewItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-document-view-item',
+                    template: '',
+                    //host: { class: 'bz-view' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.ViewContainerRef }, { type: i0.Injector }, { type: i2.BizDocComponentFactoryResolver }]; }, propDecorators: { model: [{
+                type: Input
+            }], view: [{
+                type: Input
+            }], resize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/views/views.component.mjs

@@ -0,0 +1,33 @@
+import { ViewChildren } from "@angular/core";
+import { Component, Input } from "@angular/core";
+import { ViewItemComponent } from "./view-item.component";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/session.service";
+import * as i2 from "./view-item.component";
+import * as i3 from "@angular/common";
+export class DocumentViewsComponent {
+    constructor(_cd, _session) {
+        this._cd = _cd;
+        this._session = _session;
+    }
+    ngOnChanges(_) {
+        this.views = [];
+        this._cd.detectChanges();
+        this.views = this._session.profile.views.filter(v => !v.forms || v.forms.indexOf(this.model.formId) > -1);
+    }
+    resize() {
+        this.components.forEach(c => c.resize());
+    }
+}
+DocumentViewsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentViewsComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.SessionService }], target: i0.ɵɵFactoryTarget.Component });
+DocumentViewsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: DocumentViewsComponent, selector: "bizdoc-document-views", inputs: { model: "model" }, viewQueries: [{ propertyName: "components", predicate: ViewItemComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngFor=\"let v of views; let last = last;\">\r\n  <bizdoc-document-view-item [model]=\"model\" [view]=\"v\" #view></bizdoc-document-view-item>\r\n  <!--<hr *ngIf=\"!view.hidden && !last\" />-->\r\n</ng-container>\r\n", styles: [":host{display:flex;flex-direction:column}hr{opacity:.4;margin:4px 8px}:host ::ng-deep .nav-toolbar{display:flex;flex-direction:row}:host ::ng-deep .view{display:flex;flex-direction:column;position:relative}:host ::ng-deep .loading-view{position:absolute;width:100%;height:100%;text-align:-webkit-center}\n"], components: [{ type: i2.ViewItemComponent, selector: "bizdoc-document-view-item", inputs: ["model", "view"] }], directives: [{ type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentViewsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-document-views', template: "<ng-container *ngFor=\"let v of views; let last = last;\">\r\n  <bizdoc-document-view-item [model]=\"model\" [view]=\"v\" #view></bizdoc-document-view-item>\r\n  <!--<hr *ngIf=\"!view.hidden && !last\" />-->\r\n</ng-container>\r\n", styles: [":host{display:flex;flex-direction:column}hr{opacity:.4;margin:4px 8px}:host ::ng-deep .nav-toolbar{display:flex;flex-direction:row}:host ::ng-deep .view{display:flex;flex-direction:column;position:relative}:host ::ng-deep .loading-view{position:absolute;width:100%;height:100%;text-align:-webkit-center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.SessionService }]; }, propDecorators: { components: [{
+                type: ViewChildren,
+                args: [ViewItemComponent]
+            }], model: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/views/views.mobile.component.mjs

@@ -0,0 +1,20 @@
+import { Component } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../core/window-title.service";
+import * as i3 from "./views.component";
+export class DocumentViewMobileComponent {
+    constructor(route, title) {
+        route.data.subscribe(d => {
+            this.model = d['item'];
+            title.set(`#${this.model.number}`);
+        });
+    }
+}
+DocumentViewMobileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentViewMobileComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2.WindowTitleService }], target: i0.ɵɵFactoryTarget.Component });
+DocumentViewMobileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: DocumentViewMobileComponent, selector: "ng-component", ngImport: i0, template: '<bizdoc-document-views [model]=model></bizdoc-document-views>', isInline: true, components: [{ type: i3.DocumentViewsComponent, selector: "bizdoc-document-views", inputs: ["model"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentViewMobileComponent, decorators: [{
+            type: Component,
+            args: [{ template: '<bizdoc-document-views [model]=model></bizdoc-document-views>' }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i2.WindowTitleService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlld3MubW9iaWxlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnJhcmllcy9jb3JlL3NyYy9saWIvdmlld3Mvdmlld3MubW9iaWxlLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7OztBQU0xQyxNQUFNLE9BQU8sMkJBQTJCO0lBRXRDLFlBQ0UsS0FBcUIsRUFDckIsS0FBeUI7UUFFekIsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUU7WUFDdkIsSUFBSSxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDdkIsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztRQUNyQyxDQUFDLENBQUMsQ0FBQTtJQUNKLENBQUM7O3dIQVZVLDJCQUEyQjs0R0FBM0IsMkJBQTJCLG9EQURqQiwrREFBK0Q7MkZBQ3pFLDJCQUEyQjtrQkFEdkMsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSwrREFBK0QsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlIH0gZnJvbSBcIkBhbmd1bGFyL3JvdXRlclwiO1xyXG5pbXBvcnQgeyBEb2N1bWVudE1vZGVsIH0gZnJvbSBcIi4uL2NvcmUvbW9kZWxzXCI7XHJcbmltcG9ydCB7IFdpbmRvd1RpdGxlU2VydmljZSB9IGZyb20gXCIuLi9jb3JlL3dpbmRvdy10aXRsZS5zZXJ2aWNlXCI7XHJcblxyXG5AQ29tcG9uZW50KHsgdGVtcGxhdGU6ICc8Yml6ZG9jLWRvY3VtZW50LXZpZXdzIFttb2RlbF09bW9kZWw+PC9iaXpkb2MtZG9jdW1lbnQtdmlld3M+JyB9KVxyXG5leHBvcnQgY2xhc3MgRG9jdW1lbnRWaWV3TW9iaWxlQ29tcG9uZW50IHtcclxuICBtb2RlbDogRG9jdW1lbnRNb2RlbDsgXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICByb3V0ZTogQWN0aXZhdGVkUm91dGUsXHJcbiAgICB0aXRsZTogV2luZG93VGl0bGVTZXJ2aWNlXHJcbiAgKSB7XHJcbiAgICByb3V0ZS5kYXRhLnN1YnNjcmliZShkID0+IHtcclxuICAgICAgdGhpcy5tb2RlbCA9IGRbJ2l0ZW0nXTtcclxuICAgICAgdGl0bGUuc2V0KGAjJHt0aGlzLm1vZGVsLm51bWJlcn1gKTtcclxuICAgIH0pXHJcbiAgfVxyXG59XHJcblxyXG4iXX0=

package/esm2020/lib/views/views.pane.component.mjs

@@ -0,0 +1,35 @@
+import { ViewChild } from "@angular/core";
+import { Component } from "@angular/core";
+import { DocumentViewsComponent } from "./views.component";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/session.service";
+import * as i2 from "../core/translate.service";
+import * as i3 from "../core/slots/pane-ref";
+import * as i4 from "./views.component";
+export class DocumentViewPaneComponent {
+    constructor(session, translate, pane) {
+        pane.title = translate.get('View');
+        pane.dataChange.subscribe(d => {
+            this.model = d['item'];
+            const form = session.profile.forms.find(f => f.name === this.model.formId);
+            pane.group = `#${this.model.number}`;
+            pane.icon = form.icon;
+        });
+        pane.resized.subscribe(() => this.views.resize());
+    }
+}
+DocumentViewPaneComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentViewPaneComponent, deps: [{ token: i1.SessionService }, { token: i2.TranslateService }, { token: i3.PaneRef }], target: i0.ɵɵFactoryTarget.Component });
+DocumentViewPaneComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: DocumentViewPaneComponent, selector: "ng-component", viewQueries: [{ propertyName: "views", first: true, predicate: DocumentViewsComponent, descendants: true }], ngImport: i0, template: '<bizdoc-document-views [model]=model></bizdoc-document-views>', isInline: true, styles: [":host{min-width:450px;flex-grow:1}\n"], components: [{ type: i4.DocumentViewsComponent, selector: "bizdoc-document-views", inputs: ["model"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DocumentViewPaneComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '<bizdoc-document-views [model]=model></bizdoc-document-views>',
+                    styles: [`:host {
+  min-width: 450px;
+    flex-grow: 1;}`]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SessionService }, { type: i2.TranslateService }, { type: i3.PaneRef }]; }, propDecorators: { views: [{
+                type: ViewChild,
+                args: [DocumentViewsComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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