@valtimo/analyse 4.15.2-next-main.8

package/esm2015/lib/analyse-process-diagram/analyse-process-diagram.component.js

@@ -0,0 +1,249 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, ElementRef, EventEmitter, Output, ViewChild } from '@angular/core';
+import { ProcessService } from '@valtimo/process';
+import * as BpmnJS from 'bpmn-js/dist/bpmn-navigated-viewer.production.min.js';
+import * as heatmap from 'heatmap.js-fixed/build/heatmap.js';
+export class AnalyseProcessDiagramComponent {
+    constructor(processService) {
+        this.processService = processService;
+        this.importDone = new EventEmitter();
+        this.enumHeatmapOptions = ['count', 'duration'];
+        this.initialized = false;
+    }
+    ngOnInit() {
+        this.processService.getProcessDefinitions().subscribe((processDefinitions) => {
+            this.processDefinitions = processDefinitions;
+            if (!this.processDefinitionKey && processDefinitions.length !== 0) {
+                this.processDefinitionKey = processDefinitions[0].key;
+                this.loadProcessDefinitionFromKey(this.processDefinitionKey);
+            }
+        });
+        this.createBpmnViewerInstance();
+    }
+    createBpmnViewerInstance() {
+        this.bpmnJS = new BpmnJS();
+        this.bpmnJS.on('import.done', ({ error }) => {
+            if (!error && !this.initialized) {
+                const canvas = this.bpmnJS.get('canvas'), eventBus = this.bpmnJS.get('eventBus');
+                if (this.processDiagram.historicActivityInstances) {
+                    this.processDiagram.historicActivityInstances.forEach((instance) => {
+                        if (instance.activityType !== 'multiInstanceBody') {
+                            canvas.addMarker(instance.activityId, instance.endTime ? 'highlight-overlay-past' : 'highlight-overlay-current');
+                        }
+                    });
+                }
+                canvas.zoom('fit-viewport', 'auto');
+                if (this.processDefinitionVersions) {
+                    eventBus.on('canvas.init', () => {
+                        if (this.showHeatmap) {
+                            this.clearHeatmap();
+                        }
+                        this.loadHeatmapData();
+                    });
+                    eventBus.on('canvas.viewbox.changing', () => {
+                        if (this.showHeatmap) {
+                            this.clearHeatmap();
+                        }
+                    });
+                    eventBus.on('canvas.viewbox.changed', () => {
+                        this.loadHeatmapData();
+                    });
+                }
+                this.initialized = true;
+            }
+            this.clearHeatmap();
+            if (this.showHeatmap) {
+                this.loadHeatmapData();
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.bpmnJS) {
+            this.bpmnJS.destroy();
+        }
+    }
+    loadProcessDefinition(processDefinitionKey) {
+        this.processService.getProcessDefinition(processDefinitionKey).subscribe((processDefinition) => {
+            this.heatmapOption = this.enumHeatmapOptions[0];
+            this.version = processDefinition.version;
+            this.loadProcessDefinitionXml(processDefinition.id);
+        });
+    }
+    loadProcessDefinitionVersions(processDefinitionKey) {
+        this.processService.getProcessDefinitionVersions(processDefinitionKey).subscribe((processDefinitionVersions) => {
+            this.processDefinitionVersions = processDefinitionVersions;
+        });
+    }
+    loadProcessDefinitionFromKey(processDefinitionKey) {
+        this.loadProcessDefinitionVersions(processDefinitionKey);
+        this.loadProcessDefinition(processDefinitionKey);
+    }
+    loadProcessDefinitionXml(processDefinitionId) {
+        this.processService.getProcessDefinitionXml(processDefinitionId).subscribe(response => {
+            this.processDiagram = response;
+            this.bpmnJS.importXML(this.processDiagram.bpmn20Xml);
+            this.bpmnJS.attachTo(this.el.nativeElement);
+        });
+    }
+    loadProcessDefinitionHeatmapCount(processDefinition) {
+        this.processService.getProcessHeatmapCount(processDefinition).subscribe(response => {
+            this.inputData = response;
+            this.valueKey = 'totalCount';
+            this.heatPoints = { data: [] };
+            this.min = 0;
+            this.max = 0;
+            Object.keys(this.inputData).forEach(key => {
+                const diagramContainer = this.el.nativeElement.querySelector('svg')
+                    .getBoundingClientRect(), diagramElm = this.el.nativeElement.querySelector(`g[data-element-id=${key}]`)
+                    .getBoundingClientRect();
+                this.setMax(key);
+                this.heatPoints.data.push({
+                    x: Math.round(diagramElm.x - diagramContainer.x + diagramElm.width / 2),
+                    y: Math.round(diagramElm.y - diagramContainer.y + diagramElm.height / 2),
+                    value: this.inputData[key][this.valueKey],
+                    radius: diagramElm.width / 2
+                });
+                this.addCounterActiveOverlays(key, this.inputData);
+            });
+            this.clearHeatmap();
+            if (this.showHeatmap) {
+                this.loadHeatmap();
+            }
+        });
+    }
+    onWindowResize() {
+        const oldCanvas = this.el.nativeElement.querySelector('canvas[class=heatmap-canvas]');
+        if (oldCanvas) {
+            oldCanvas.remove();
+            this.heatMapInstance = null;
+        }
+        if (this.showHeatmap) {
+            this.loadHeatmap();
+        }
+    }
+    loadProcessDefinitionHeatmapDuration(processDefinition) {
+        this.processService.getProcessHeatmapDuration(processDefinition).subscribe(response => {
+            this.inputData = response;
+            this.valueKey = 'averageDurationInMilliseconds';
+            this.heatPoints = { data: [] };
+            this.min = 0;
+            this.max = 0;
+            Object.keys(this.inputData).forEach(key => {
+                const diagramContainer = this.el.nativeElement.querySelector('svg')
+                    .getBoundingClientRect(), diagramElm = this.el.nativeElement.querySelector(`g[data-element-id=${key}]`)
+                    .getBoundingClientRect();
+                this.setMax(key);
+                this.heatPoints.data.push({
+                    x: Math.round(diagramElm.x - diagramContainer.x + diagramElm.width / 2),
+                    y: Math.round(diagramElm.y - diagramContainer.y + diagramElm.height / 2),
+                    value: this.inputData[key][this.valueKey],
+                    radius: diagramElm.width / 2
+                });
+                this.addCounterActiveOverlays(key, this.inputData);
+            });
+            this.clearHeatmap();
+            if (this.showHeatmap) {
+                this.loadHeatmap();
+            }
+        });
+    }
+    setProcessDefinitionKey(processDefinitionKey) {
+        this.processDefinitionKey = processDefinitionKey;
+        this.loadProcessDefinitionFromKey(this.processDefinitionKey);
+    }
+    setProcessDefinitionVersion(version) {
+        this.version = +version;
+        this.loadHeatmapData();
+    }
+    setHeatmapOption(heatmapOption) {
+        this.heatmapOption = heatmapOption;
+        this.loadHeatmapData();
+    }
+    toggleShowHeatmap() {
+        this.showHeatmap = !this.showHeatmap;
+        this.loadHeatmapData();
+    }
+    loadHeatmap() {
+        if (!this.heatMapInstance) {
+            this.heatMapInstance = heatmap.create({
+                radius: 54,
+                blur: .70,
+                maxOpacity: .4,
+                minOpacity: 0,
+                container: this.el.nativeElement
+            });
+            const heatmapCanvas = this.el.nativeElement.querySelector('canvas[class=heatmap-canvas]');
+            heatmapCanvas.style.zIndex = 1;
+        }
+        this.heatMapInstance.setData({
+            min: this.min,
+            max: this.max,
+            data: this.heatPoints.data
+        });
+    }
+    clearHeatmap() {
+        if (this.heatMapInstance) {
+            this.heatMapInstance.setData({ data: [] });
+        }
+    }
+    loadHeatmapData() {
+        this.processDefinition = this.processDefinitionVersions.find(definition => definition.version === this.version);
+        if (this.heatmapOption === 'count') {
+            this.loadProcessDefinitionHeatmapCount(this.processDefinition);
+        }
+        if (this.heatmapOption === 'duration') {
+            this.loadProcessDefinitionHeatmapDuration(this.processDefinition);
+        }
+    }
+    setMax(key) {
+        if (this.valueKey === 'averageDurationInMilliseconds') {
+            this.max = Math.max(this.inputData[key].averageDurationInMilliseconds, this.max);
+        }
+        else if (this.valueKey === 'totalCount') {
+            this.max = Math.max(this.inputData[key].totalCount + this.inputData[key].count, this.max);
+        }
+    }
+    addCounterActiveOverlays(key, inputData) {
+        const overlays = this.bpmnJS.get('overlays');
+        overlays.add(key, {
+            position: {
+                bottom: 13,
+                left: -12
+            },
+            show: {
+                minZoom: 0,
+                maxZoom: 5.0
+            },
+            html: `<span class="badge badge-pill badge-primary">${inputData[key].count}</span>`
+        });
+    }
+}
+AnalyseProcessDiagramComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'valtimo-analyse-process-diagram',
+                template: "<!--\n  ~ Copyright 2015-2020 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div class=\"container-fluid\">\n  <div class=\"row p-4 bg-light options\">\n    <div class=\"col-sm-3\">\n      <label><strong>Process</strong></label><br/>\n      <select class=\"form-control\" (change)=\"setProcessDefinitionKey($event.target.value)\">\n        <option *ngFor=\"let processDefinition of processDefinitions\"\n                [value]=\"processDefinition.key\"\n                [selected]=\"processDefinitionKey === processDefinition.key\">\n          {{ processDefinition.name }}\n        </option>\n      </select>\n    </div>\n    <div class=\"col-sm-1\">\n      <label><strong>Version</strong></label><br/>\n      <select class=\"form-control\" (change)=\"setProcessDefinitionVersion($event.target.value)\">\n        <option *ngFor=\"let processDefinitionVersion of processDefinitionVersions\"\n                [value]=\"processDefinitionVersion.version\"\n                [selected]=\"processDefinitionVersion.version === version\">\n          {{ processDefinitionVersion.version }}\n        </option>\n      </select>\n    </div>\n    <div class=\"col-sm-3\" *ngIf=\"showHeatmap\">\n      <label><strong>Heatmap type</strong></label><br/>\n      <select class=\"form-control w-sm-50\" (change)=\"setHeatmapOption($event.target.value)\">\n        <option *ngFor=\"let option of enumHeatmapOptions\"\n                [value]=\"option\"\n                [selected]=\"option === heatmapOption\">\n          {{ option | titlecase }}\n        </option>\n      </select>\n    </div>\n    <div class=\"text-sm-right col-sm-3\" [ngClass]=\"{'offset-sm-2': showHeatmap, 'offset-sm-5': !showHeatmap}\">\n      <label><strong>Show heatmap</strong></label><br/>\n      <div class=\"text-left switch-button switch-button-sm switch-button-success\">\n        <input type=\"checkbox\" id=\"toggleHeatmap\" [checked]=\"showHeatmap\" (click)=\"toggleShowHeatmap()\"><span>\n          <label for=\"toggleHeatmap\"></label></span>\n      </div>\n    </div>\n  </div>\n  <div class=\"row p-4 bg-white\">\n    <div class=\"col\">\n      <div #ref (window:resize)=\"onWindowResize()\" class=\"diagram-container\"></div>\n    </div>\n  </div>\n</div>\n\n<div class=\"p-4 text-center legenda-holder\">\n  <span><span class=\"badge badge-pill badge-primary\">N</span>&nbsp;&nbsp;Amount of currently active instances of this task.</span>\n  <span>&nbsp;&nbsp;|&nbsp;&nbsp;Red/yellow/green orbs: The amount of times the task is executed in comparison to the other tasks.</span>\n</div>\n",
+                styles: ["/*!\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */.diagram-container-switch-holder{width:100%;z-index:1000}.diagram-container{height:58vh}.container-fluid{border:1px solid #dee2e6}.options{border-bottom:1px solid #dee2e6}"]
+            },] }
+];
+AnalyseProcessDiagramComponent.ctorParameters = () => [
+    { type: ProcessService }
+];
+AnalyseProcessDiagramComponent.propDecorators = {
+    el: [{ type: ViewChild, args: ['ref',] }],
+    importDone: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyse-process-diagram.component.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/analyse/src/lib/analyse-process-diagram/analyse-process-diagram.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Component, ElementRef, EventEmitter, OnDestroy, OnInit, Output, ViewChild} from '@angular/core';\nimport {ProcessService} from '@valtimo/process';\nimport {Heatpoint, ProcessDefinition} from '@valtimo/contract';\n\nimport * as BpmnJS from 'bpmn-js/dist/bpmn-navigated-viewer.production.min.js';\nimport * as heatmap from 'heatmap.js-fixed/build/heatmap.js';\n\n@Component({\n  selector: 'valtimo-analyse-process-diagram',\n  templateUrl: './analyse-process-diagram.component.html',\n  styleUrls: ['./analyse-process-diagram.component.scss']\n})\nexport class AnalyseProcessDiagramComponent implements OnInit, OnDestroy {\n\n  private bpmnJS: BpmnJS;\n  private heatMapInstance: any;\n\n  @ViewChild('ref') public el: ElementRef;\n  @Output() public importDone: EventEmitter<any> = new EventEmitter();\n\n  public processDefinitionKey: string;\n  public processDefinitions: ProcessDefinition[];\n  public processDiagram: any;\n  public processDefinition: ProcessDefinition;\n  public processDefinitionVersions: ProcessDefinition[];\n  public showHeatmap: boolean;\n  public enumHeatmapOptions: string[] = ['count', 'duration'];\n  public heatmapOption: string;\n  public version: number;\n  public heatPoints: { data: Heatpoint[] };\n  public min: number;\n  public max: number;\n  public inputData: any[];\n  public valueKey: string;\n  private initialized = false;\n\n  constructor(\n    private processService: ProcessService,\n  ) {\n  }\n\n  ngOnInit() {\n    this.processService.getProcessDefinitions().subscribe((processDefinitions: ProcessDefinition[]) => {\n      this.processDefinitions = processDefinitions;\n      if (!this.processDefinitionKey && processDefinitions.length !== 0) {\n        this.processDefinitionKey = processDefinitions[0].key;\n        this.loadProcessDefinitionFromKey(this.processDefinitionKey);\n      }\n    });\n    this.createBpmnViewerInstance();\n  }\n\n  private createBpmnViewerInstance() {\n    this.bpmnJS = new BpmnJS();\n    this.bpmnJS.on('import.done', ({error}: any) => {\n      if (!error && !this.initialized) {\n        const canvas = this.bpmnJS.get('canvas'),\n          eventBus = this.bpmnJS.get('eventBus');\n        if (this.processDiagram.historicActivityInstances) {\n          this.processDiagram.historicActivityInstances.forEach((instance: any) => {\n            if (instance.activityType !== 'multiInstanceBody') {\n              canvas.addMarker(instance.activityId, instance.endTime ? 'highlight-overlay-past' : 'highlight-overlay-current');\n            }\n          });\n        }\n\n        canvas.zoom('fit-viewport', 'auto');\n        if (this.processDefinitionVersions) {\n          eventBus.on('canvas.init', () => {\n            if (this.showHeatmap) {\n              this.clearHeatmap();\n            }\n            this.loadHeatmapData();\n          });\n          eventBus.on('canvas.viewbox.changing', () => {\n            if (this.showHeatmap) {\n              this.clearHeatmap();\n            }\n          });\n          eventBus.on('canvas.viewbox.changed', () => {\n            this.loadHeatmapData();\n          });\n        }\n        this.initialized = true;\n      }\n      this.clearHeatmap();\n      if (this.showHeatmap) {\n        this.loadHeatmapData();\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    if (this.bpmnJS) {\n      this.bpmnJS.destroy();\n    }\n  }\n\n  public loadProcessDefinition(processDefinitionKey: string): void {\n    this.processService.getProcessDefinition(processDefinitionKey).subscribe((processDefinition: ProcessDefinition) => {\n      this.heatmapOption = this.enumHeatmapOptions[0];\n      this.version = processDefinition.version;\n      this.loadProcessDefinitionXml(processDefinition.id);\n    });\n  }\n\n  public loadProcessDefinitionVersions(processDefinitionKey: string): void {\n    this.processService.getProcessDefinitionVersions(processDefinitionKey).subscribe((processDefinitionVersions: ProcessDefinition[]) => {\n      this.processDefinitionVersions = processDefinitionVersions;\n    });\n  }\n\n  public loadProcessDefinitionFromKey(processDefinitionKey: string): void {\n    this.loadProcessDefinitionVersions(processDefinitionKey);\n    this.loadProcessDefinition(processDefinitionKey);\n  }\n\n  public loadProcessDefinitionXml(processDefinitionId: string): void {\n    this.processService.getProcessDefinitionXml(processDefinitionId).subscribe(response => {\n      this.processDiagram = response;\n      this.bpmnJS.importXML(this.processDiagram.bpmn20Xml);\n      this.bpmnJS.attachTo(this.el.nativeElement);\n    });\n  }\n\n  public loadProcessDefinitionHeatmapCount(processDefinition: ProcessDefinition): void {\n    this.processService.getProcessHeatmapCount(processDefinition).subscribe(response => {\n      this.inputData = response;\n      this.valueKey = 'totalCount';\n      this.heatPoints = {data: []};\n      this.min = 0;\n      this.max = 0;\n\n      Object.keys(this.inputData).forEach(key => {\n        const diagramContainer = this.el.nativeElement.querySelector('svg')\n            .getBoundingClientRect(),\n          diagramElm = this.el.nativeElement.querySelector(`g[data-element-id=${key}]`)\n            .getBoundingClientRect();\n        this.setMax(key);\n        this.heatPoints.data.push({\n          x: Math.round(diagramElm.x - diagramContainer.x + diagramElm.width / 2),\n          y: Math.round(diagramElm.y - diagramContainer.y + diagramElm.height / 2),\n          value: this.inputData[key][this.valueKey],\n          radius: diagramElm.width / 2\n        });\n        this.addCounterActiveOverlays(key, this.inputData);\n\n      });\n      this.clearHeatmap();\n      if (this.showHeatmap) {\n        this.loadHeatmap();\n      }\n    });\n  }\n\n  public onWindowResize(): void {\n    const oldCanvas = this.el.nativeElement.querySelector('canvas[class=heatmap-canvas]');\n    if (oldCanvas) {\n      oldCanvas.remove();\n      this.heatMapInstance = null;\n    }\n    if (this.showHeatmap) {\n      this.loadHeatmap();\n    }\n  }\n\n  public loadProcessDefinitionHeatmapDuration(processDefinition: ProcessDefinition): void {\n    this.processService.getProcessHeatmapDuration(processDefinition).subscribe(response => {\n      this.inputData = response;\n      this.valueKey = 'averageDurationInMilliseconds';\n      this.heatPoints = {data: []};\n      this.min = 0;\n      this.max = 0;\n\n      Object.keys(this.inputData).forEach(key => {\n        const diagramContainer = this.el.nativeElement.querySelector('svg')\n            .getBoundingClientRect(),\n          diagramElm = this.el.nativeElement.querySelector(`g[data-element-id=${key}]`)\n            .getBoundingClientRect();\n        this.setMax(key);\n        this.heatPoints.data.push({\n          x: Math.round(diagramElm.x - diagramContainer.x + diagramElm.width / 2),\n          y: Math.round(diagramElm.y - diagramContainer.y + diagramElm.height / 2),\n          value: this.inputData[key][this.valueKey],\n          radius: diagramElm.width / 2\n        });\n        this.addCounterActiveOverlays(key, this.inputData);\n      });\n      this.clearHeatmap();\n      if (this.showHeatmap) {\n        this.loadHeatmap();\n      }\n    });\n  }\n\n  public setProcessDefinitionKey(processDefinitionKey: string): void {\n    this.processDefinitionKey = processDefinitionKey;\n    this.loadProcessDefinitionFromKey(this.processDefinitionKey);\n  }\n\n  public setProcessDefinitionVersion(version: string): void {\n    this.version = +version;\n    this.loadHeatmapData();\n  }\n\n  public setHeatmapOption(heatmapOption: string): void {\n    this.heatmapOption = heatmapOption;\n    this.loadHeatmapData();\n  }\n\n  public toggleShowHeatmap(): void {\n    this.showHeatmap = !this.showHeatmap;\n    this.loadHeatmapData();\n  }\n\n  public loadHeatmap(): void {\n    if (!this.heatMapInstance) {\n      this.heatMapInstance = heatmap.create({\n        radius: 54,\n        blur: .70,\n        maxOpacity: .4,\n        minOpacity: 0,\n        container: this.el.nativeElement\n      });\n      const heatmapCanvas = this.el.nativeElement.querySelector('canvas[class=heatmap-canvas]');\n      heatmapCanvas.style.zIndex = 1;\n    }\n    this.heatMapInstance.setData({\n      min: this.min,\n      max: this.max,\n      data: this.heatPoints.data\n    });\n  }\n\n  public clearHeatmap(): void {\n    if (this.heatMapInstance) {\n      this.heatMapInstance.setData({data: []});\n    }\n  }\n\n  public loadHeatmapData(): void {\n    this.processDefinition = this.processDefinitionVersions.find(definition => definition.version === this.version);\n\n    if (this.heatmapOption === 'count') {\n      this.loadProcessDefinitionHeatmapCount(this.processDefinition);\n    }\n    if (this.heatmapOption === 'duration') {\n      this.loadProcessDefinitionHeatmapDuration(this.processDefinition);\n    }\n  }\n\n  public setMax(key: any) {\n    if (this.valueKey === 'averageDurationInMilliseconds') {\n      this.max = Math.max(this.inputData[key].averageDurationInMilliseconds, this.max);\n    } else if (this.valueKey === 'totalCount') {\n      this.max = Math.max(this.inputData[key].totalCount + this.inputData[key].count, this.max);\n    }\n  }\n\n  public addCounterActiveOverlays(key: string, inputData: any[]): void {\n    const overlays = this.bpmnJS.get('overlays');\n    overlays.add(key, {\n      position: {\n        bottom: 13,\n        left: -12\n      },\n      show: {\n        minZoom: 0,\n        maxZoom: 5.0\n      },\n      html: `<span class=\"badge badge-pill badge-primary\">${inputData[key].count}</span>`\n    });\n  }\n\n}\n"]}

package/esm2015/lib/analyse-routing.module.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { CommonModule } from '@angular/common';
+import { AuthGuardService } from '@valtimo/security';
+import { AnalyseComponent } from './analyse.component';
+import { ROLE_USER } from '@valtimo/contract';
+const ɵ0 = { title: 'Analysis', roles: [ROLE_USER] };
+const routes = [
+    {
+        path: 'analysis',
+        component: AnalyseComponent,
+        canActivate: [AuthGuardService],
+        data: ɵ0
+    }
+];
+export class AnalyseRoutingModule {
+}
+AnalyseRoutingModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                imports: [
+                    CommonModule,
+                    RouterModule.forChild(routes),
+                ],
+                exports: [RouterModule]
+            },] }
+];
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/analyse.component.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component } from '@angular/core';
+export class AnalyseComponent {
+    constructor() { }
+    ngOnInit() {
+    }
+}
+AnalyseComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'valtimo-analyse',
+                template: "<!--\n  ~ Copyright 2015-2020 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div class=\"main-content\">\n  <div class=\"container-fluid\">\n    <valtimo-analyse-process-diagram></valtimo-analyse-process-diagram>\n  </div>\n</div>\n",
+                styles: ["/*!\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */"]
+            },] }
+];
+AnalyseComponent.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5hbHlzZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2FuYWx5c2Uvc3JjL2xpYi9hbmFseXNlLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILE9BQU8sRUFBQyxTQUFTLEVBQVMsTUFBTSxlQUFlLENBQUM7QUFPaEQsTUFBTSxPQUFPLGdCQUFnQjtJQUUzQixnQkFBZ0IsQ0FBQztJQUVqQixRQUFRO0lBQ1IsQ0FBQzs7O1lBVkYsU0FBUyxTQUFDO2dCQUNULFFBQVEsRUFBRSxpQkFBaUI7Z0JBQzNCLHd6QkFBdUM7O2FBRXhDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjAgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHtDb21wb25lbnQsIE9uSW5pdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3ZhbHRpbW8tYW5hbHlzZScsXG4gIHRlbXBsYXRlVXJsOiAnLi9hbmFseXNlLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vYW5hbHlzZS5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIEFuYWx5c2VDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gIGNvbnN0cnVjdG9yKCkgeyB9XG5cbiAgbmdPbkluaXQoKSB7XG4gIH1cblxufVxuIl19

package/esm2015/lib/analyse.module.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { AnalyseComponent } from './analyse.component';
+import { CommonModule } from '@angular/common';
+import { AnalyseRoutingModule } from './analyse-routing.module';
+import { ProcessModule } from '@valtimo/process';
+import { WidgetModule } from '@valtimo/components';
+import { AnalyseProcessDiagramComponent } from './analyse-process-diagram/analyse-process-diagram.component';
+export class AnalyseModule {
+}
+AnalyseModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [AnalyseComponent, AnalyseProcessDiagramComponent],
+                imports: [
+                    CommonModule,
+                    AnalyseRoutingModule,
+                    ProcessModule,
+                    WidgetModule
+                ],
+                exports: [AnalyseComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public_api.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Public API Surface of analyse
+ */
+export * from './lib/analyse.module';
+export * from './lib/analyse.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vYW5hbHlzZS9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVIOztHQUVHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjAgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBhbmFseXNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvYW5hbHlzZS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYW5hbHlzZS5jb21wb25lbnQnO1xuIl19

package/esm2015/valtimo-analyse.js

@@ -0,0 +1,7 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+export { AnalyseProcessDiagramComponent as ɵa } from './lib/analyse-process-diagram/analyse-process-diagram.component';
+export { AnalyseRoutingModule as ɵb } from './lib/analyse-routing.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsdGltby1hbmFseXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdmFsdGltby9hbmFseXNlL3NyYy92YWx0aW1vLWFuYWx5c2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUU3QixPQUFPLEVBQUMsOEJBQThCLElBQUksRUFBRSxFQUFDLE1BQU0saUVBQWlFLENBQUM7QUFDckgsT0FBTyxFQUFDLG9CQUFvQixJQUFJLEVBQUUsRUFBQyxNQUFNLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuXG5leHBvcnQge0FuYWx5c2VQcm9jZXNzRGlhZ3JhbUNvbXBvbmVudCBhcyDJtWF9IGZyb20gJy4vbGliL2FuYWx5c2UtcHJvY2Vzcy1kaWFncmFtL2FuYWx5c2UtcHJvY2Vzcy1kaWFncmFtLmNvbXBvbmVudCc7XG5leHBvcnQge0FuYWx5c2VSb3V0aW5nTW9kdWxlIGFzIMm1Yn0gZnJvbSAnLi9saWIvYW5hbHlzZS1yb3V0aW5nLm1vZHVsZSc7Il19