@bizdoc/core 1.7.0-next.3 → 1.7.0-next.7

package/esm2015/lib/views/timeline/timeline.component.exp.js

@@ -0,0 +1,317 @@
+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 * 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/session.service";
+import * as i5 from "../../core/translate.service";
+import * as i6 from "../../core/router";
+const moment = require('moment');
+let TimelineViewComponent = class TimelineViewComponent {
+    /** timeline-view ctor */
+    constructor(_ps, viewRef, config, _users, _session, _translate, _router, _element) {
+        this._ps = _ps;
+        this._users = _users;
+        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;
+            if (this.gantt) {
+                this.gantt.width = d.width;
+                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,
+            //  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 chain = (c) => {
+            c.parent && chain(c.parent);
+        };
+        model.parent && chain(model.parent);
+        model.children.forEach(c => {
+        });
+        model.log.forEach(l => {
+            let task;
+            switch (l.type) {
+                case 'Submit':
+                    this.eventMarkers.push({
+                        day: moment(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: moment(l.time).toDate(),
+                            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 ? moment(l.time).toDate() : new Date();
+                        tasks.push(task);
+                        break;
+                    }
+                case 'ModelChange':
+                    {
+                        task = {
+                            id: i++,
+                            type: l.type,
+                            nodeId: l.nodeId,
+                            time: moment(l.time).toDate(),
+                            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 = moment().toDate();
+                        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 = moment(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: moment(e.starting),
+                label: e.title
+            });
+        });
+        model.recipients.forEach(r => {
+            if (!r.pending)
+                return;
+            const task = {
+                id: i++,
+                type: 'pending',
+                time: moment(r.received).toDate(),
+                title: this._translate.get('IsPending')
+            };
+            if (r.substitutingId) {
+                const byPromise = this._users.get(r.substitutingId);
+                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);
+        });
+        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: "12.2.7", ngImport: i0, type: TimelineViewComponent, deps: [{ token: i1.PromptService }, { token: i2.DocumentViewRef }, { token: BIZDOC_CONFIG }, { token: i3.AccountService }, { token: i4.SessionService }, { token: i5.TranslateService }, { token: i6.RouterImpl }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+TimelineViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", 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: "12.2.7", ngImport: i0, type: TimelineViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-timeline',
+                    template: '',
+                    styleUrls: ['timeline.component.scss'],
+                    host: { class: 'view' },
+                    providers: [SelectionService, DayMarkersService]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PromptService }, { type: i2.DocumentViewRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BIZDOC_CONFIG]
+                }] }, { type: i3.AccountService }, { type: i4.SessionService }, { type: i5.TranslateService }, { type: i6.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\nconst moment = require('moment');\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 _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;\r\n      if (this.gantt) {\r\n        this.gantt.width = d.width;\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      //  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 chain = (c: Chain) => {\r\n\r\n      c.parent && chain(c.parent);\r\n    };\r\n    model.parent && chain(model.parent);\r\n    model.children.forEach(c => {\r\n    });\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: moment(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: moment(l.time).toDate(),\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 ? moment(l.time).toDate() : 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: moment(l.time).toDate(),\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 = moment().toDate();\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 = moment(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: moment(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: moment(r.received).toDate(),\r\n        title: this._translate.get('IsPending')\r\n      };\r\n      if (r.substitutingId) {\r\n        const byPromise = this._users.get(r.substitutingId);\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    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  dependency?: string;\r\n}\r\ninterface Options {\r\n\r\n}\r\n"]}

package/esm2015/lib/views/view-item.component.js

@@ -1,12 +1,14 @@
-import { Component, HostListener, Injector, Input } from "@angular/core";
+import { Component, HostListener, Injector, Input, Optional } 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 "../core/component-factory-resolver";
+import * as i1 from "../core/slots/pane-ref";
+import * as i2 from "../core/component-factory-resolver";
 export class ViewItemComponent {
-    constructor(_vc, _injector, _cf) {
+    constructor(_pane, _vc, _injector, _cf) {
+        this._pane = _pane;
         this._vc = _vc;
         this._injector = _injector;
         this._cf = _cf;
@@ -18,7 +20,7 @@ export class ViewItemComponent {
     }
     ngAfterViewInit() {
         const factory = this._cf.resolve(this.view.template);
-        this._viewRef = new DocumentViewRef(this.model, this.view, this._dim());
+        this._viewRef = new DocumentViewRef(this.model, this.view, this._dim(), !this._pane || !this._pane.tab);
         const injector = Injector.create([{ provide: DocumentViewRef, useValue: this._viewRef }], this._injector);
         this._instance = this._vc.createComponent(factory, null, injector).instance;
         this._instance.onBind(this.model);
@@ -37,7 +39,7 @@ export class ViewItemComponent {
         this._destroy.complete();
     }
 }
-ViewItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ViewItemComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.Injector }, { token: i1.BizDocComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component });
+ViewItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ViewItemComponent, deps: [{ token: i1.PaneRef, optional: true }, { token: i0.ViewContainerRef }, { token: i0.Injector }, { token: i2.BizDocComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component });
 ViewItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", 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: "12.2.7", ngImport: i0, type: ViewItemComponent, decorators: [{
             type: Component,
@@ -45,7 +47,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImpor
                     selector: 'bizdoc-document-view-item',
                     template: ''
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.Injector }, { type: i1.BizDocComponentFactoryResolver }]; }, propDecorators: { model: [{
+        }], ctorParameters: function () { return [{ type: i1.PaneRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ViewContainerRef }, { type: i0.Injector }, { type: i2.BizDocComponentFactoryResolver }]; }, propDecorators: { model: [{
                 type: Input
             }], view: [{
                 type: Input
@@ -53,4 +57,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImpor
                 type: HostListener,
                 args: ['window:resize']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/views/views.component.js

@@ -1,21 +1,20 @@
 import { Component, Input } from "@angular/core";
 import * as i0 from "@angular/core";
-import * as i1 from "../core/component-factory-resolver";
-import * as i2 from "../core/session.service";
-import * as i3 from "./view-item.component";
-import * as i4 from "@angular/common";
+import * as i1 from "../core/session.service";
+import * as i2 from "./view-item.component";
+import * as i3 from "@angular/common";
 export class DocumentViewsComponent {
-    constructor(_cf, vc, _session) {
-        this._cf = _cf;
-        this.vc = vc;
+    constructor(_cd, _session) {
+        this._cd = _cd;
         this._session = _session;
     }
     ngOnChanges(_) {
         this.views = this._session.profile.views.filter(v => !v.forms || v.forms.indexOf(this.model.formId) > -1);
+        this._cd.detectChanges();
     }
 }
-DocumentViewsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: DocumentViewsComponent, deps: [{ token: i1.BizDocComponentFactoryResolver }, { token: i0.ViewContainerRef }, { token: i2.SessionService }], target: i0.ɵɵFactoryTarget.Component });
-DocumentViewsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: DocumentViewsComponent, selector: "bizdoc-document-views", inputs: { model: "model" }, usesOnChanges: true, ngImport: i0, template: "<div *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=\"!last\"/>\r\n</div>\r\n", styles: [":host{display:flex;flex-direction:column}hr{opacity:.4;margin:4px}: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: i3.ViewItemComponent, selector: "bizdoc-document-view-item", inputs: ["model", "view"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+DocumentViewsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: DocumentViewsComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.SessionService }], target: i0.ɵɵFactoryTarget.Component });
+DocumentViewsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: DocumentViewsComponent, selector: "bizdoc-document-views", inputs: { model: "model" }, usesOnChanges: true, ngImport: i0, template: "<div *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=\"!last\"/>\r\n</div>\r\n", styles: [":host{display:flex;flex-direction:column}hr{opacity:.4;margin:4px 8px}: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"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: DocumentViewsComponent, decorators: [{
             type: Component,
             args: [{
@@ -23,7 +22,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImpor
                     templateUrl: 'views.component.html',
                     styleUrls: ['views.component.scss']
                 }]
-        }], ctorParameters: function () { return [{ type: i1.BizDocComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: i2.SessionService }]; }, propDecorators: { model: [{
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.SessionService }]; }, propDecorators: { model: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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