@valtimo/components 4.15.2-next-main.8

package/esm2015/lib/alert/alert.component.js

@@ -0,0 +1,142 @@
+/*
+ * 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';
+import { AlertType } from '@valtimo/contract';
+import { AlertService } from './alert.service';
+export class AlertComponent {
+    constructor(alertService) {
+        this.alertService = alertService;
+        this.alerts = [];
+        this.autoCloseInMS = 5000;
+    }
+    ngOnInit() {
+    }
+    ngAfterContentInit() {
+        this.subscription = this.alertService.onAlert()
+            .subscribe(alert => {
+            if (!alert.message) {
+                // clear alerts when an empty alert is received
+                this.alerts = [];
+                return;
+            }
+            // set empty array when an empty alert confirmations is received
+            if (!alert.confirmations) {
+                alert.confirmations = [];
+            }
+            // add alert to array if not exist
+            const alertExist = this.alerts.filter(x => x.message === alert.message);
+            if (alertExist.length === 0) {
+                this.alerts.push(alert);
+            }
+            if (this.inModal(alert)) {
+                setTimeout(() => {
+                    this.openModal();
+                }, 300);
+            }
+            // auto close except alert confirmations not empty
+            if (this.autoCloseInMS > 0 && alert.confirmations.length === 0) {
+                setTimeout(() => {
+                    this.removeAlert(alert);
+                }, this.autoCloseInMS);
+            }
+        });
+    }
+    closeModal() {
+        $('#modalNotification').modal('hide');
+    }
+    openModal() {
+        $('#modalNotification').modal('show');
+    }
+    alertConfirm(alert, confirm) {
+        alert.confirm = confirm;
+        this.alertService.emitAlertConfirmEvent(alert);
+        this.removeAlert(alert);
+    }
+    ngOnDestroy() {
+        // unsubscribe to avoid memory leaks
+        this.subscription.unsubscribe();
+    }
+    removeAlert(alert) {
+        if (this.inModal(alert)) {
+            this.closeModal();
+        }
+        // remove specified alert from array
+        this.alerts = this.alerts.filter(x => x.message !== alert.message);
+    }
+    inModal(alert) {
+        if (!alert) {
+            return;
+        }
+        // return true based on AlertType.ModalNotification
+        switch (alert.type) {
+            case AlertType.ModalNotification:
+                return true;
+            default:
+                return false;
+        }
+    }
+    cssClass(alert) {
+        if (!alert) {
+            return;
+        }
+        // return css class based on alert type
+        switch (alert.type) {
+            case AlertType.Success:
+                return 'alert alert-success';
+            case AlertType.Error:
+                return 'alert alert-danger';
+            case AlertType.Info:
+                return 'alert alert-info';
+            case AlertType.Warning:
+                return 'alert alert-warning';
+            case AlertType.Notification:
+                return 'alert alert-light';
+            case AlertType.ModalNotification:
+                return 'alert alert-light';
+        }
+    }
+    cssIconClass(alert) {
+        if (!alert) {
+            return;
+        }
+        // return css class based on alert type
+        switch (alert.type) {
+            case AlertType.Success:
+                return 'mdi mdi-check';
+            case AlertType.Error:
+                return 'mdi mdi-close-circle-o';
+            case AlertType.Info:
+                return 'mdi mdi-info-outline';
+            case AlertType.Warning:
+                return 'mdi mdi-alert-triangle';
+            case AlertType.Notification:
+                return 'mdi mdi-notifications';
+            case AlertType.ModalNotification:
+                return 'mdi mdi-notifications';
+        }
+    }
+}
+AlertComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'valtimo-alert',
+                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 *ngFor=\"let alert of alerts\" class=\"{{cssClass(alert)}} rounded-0 m-0 alert-dismissable\">\n\n  <div *ngIf=\"inModal(alert)\">\n    <!-- Modal -->\n    <div class=\"modal fade\" id=\"modalNotification\" tabindex=\"-1\" role=\"dialog\">\n      <div class=\"modal-dialog\" role=\"document\">\n        <div class=\"modal-content\">\n          <div class=\"modal-body p-0\">\n            <button class=\"close\" type=\"button\" (click)=\"removeAlert(alert)\"><span class=\"mdi mdi-close\" aria-hidden=\"true\"></span></button>\n            <div class=\"icon\"><span class=\"{{ alert.iconClass || cssIconClass(alert) }}\"></span></div>\n            <div class=\"message\">\n              <div [innerHTML]=\"alert.message\"></div>\n            </div>\n          </div>\n          <div class=\"modal-footer pt-0\" *ngIf=\"alert.confirmations?.length\">\n              <button class=\"{{ confirmation.class }} mr-2\"\n                      *ngFor=\"let confirmation of alert.confirmations\"\n                      (click)=\"alertConfirm(alert, confirmation.value)\">{{ confirmation.label }}</button>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <div *ngIf=\"!inModal(alert)\" class=\"alert-block\">\n    <div class=\"icon\"><span class=\"{{ alert.iconClass || cssIconClass(alert) }}\"></span></div>\n    <div class=\"message\">\n      <div [innerHTML]=\"alert.message\"></div>\n      <div class=\"mt-3\" *ngIf=\"alert.confirmations?.length\">\n        <button class=\"{{ confirmation.class }} mr-2\"\n                *ngFor=\"let confirmation of alert.confirmations\"\n                (click)=\"alertConfirm(alert, confirmation.value)\">{{ confirmation.label }}</button>\n      </div>\n    </div>\n    <button class=\"close\" type=\"button\" (click)=\"removeAlert(alert)\"><span class=\"mdi mdi-close\" aria-hidden=\"true\"></span></button>\n  </div>\n</div>\n",
+                styles: [".alert-block{display:flex;flex-direction:row;justify-content:space-between}.alert-block .message{width:100%}.alert-block .icon{align-items:center;display:flex}.alert .message{font-size:1.1rem!important;line-height:1.5rem!important;padding:2rem 5rem 2rem 2rem!important}.alert .close{color:#fff!important;opacity:1!important;padding:2rem 2rem 0 0!important;right:0!important}.alert .icon{padding-left:2rem!important}.alert-warning{color:#404040!important}.alert-light .close,.alert-warning .close{color:#404040!important;opacity:1!important}"]
+            },] }
+];
+AlertComponent.ctorParameters = () => [
+    { type: AlertService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert.component.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/alert/alert.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 {AfterContentInit, Component, OnDestroy, OnInit} from '@angular/core';\nimport {Subscription} from 'rxjs';\nimport {Alert, AlertType} from '@valtimo/contract';\nimport {AlertService} from './alert.service';\n\ndeclare var $;\n\n@Component({\n    selector: 'valtimo-alert',\n    templateUrl: './alert.component.html',\n    styleUrls: ['./alert.component.css']\n})\nexport class AlertComponent implements OnInit, AfterContentInit, OnDestroy {\n    alerts: Alert[] = [];\n    subscription: Subscription;\n    autoCloseInMS: number;\n\n    constructor(\n        private alertService: AlertService\n    ) {\n        this.autoCloseInMS = 5000;\n    }\n\n    ngOnInit() {\n    }\n\n    ngAfterContentInit() {\n        this.subscription = this.alertService.onAlert()\n            .subscribe(alert => {\n\n                if (!alert.message) {\n                    // clear alerts when an empty alert is received\n                    this.alerts = [];\n                    return;\n                }\n\n                // set empty array when an empty alert confirmations is received\n                if (!alert.confirmations) {\n                    alert.confirmations = [];\n                }\n\n                // add alert to array if not exist\n                const alertExist = this.alerts.filter(x => x.message === alert.message);\n                if (alertExist.length === 0) {\n                    this.alerts.push(alert);\n                }\n\n                if (this.inModal(alert)) {\n                    setTimeout(() => {\n                        this.openModal();\n                    }, 300);\n                }\n\n                // auto close except alert confirmations not empty\n                if (this.autoCloseInMS > 0 && alert.confirmations.length === 0) {\n                    setTimeout(() => {\n                        this.removeAlert(alert);\n                    }, this.autoCloseInMS);\n                }\n            });\n    }\n\n    closeModal() {\n        $('#modalNotification').modal('hide');\n    }\n\n    openModal() {\n        $('#modalNotification').modal('show');\n    }\n\n    alertConfirm(alert: Alert, confirm: any) {\n        alert.confirm = confirm;\n        this.alertService.emitAlertConfirmEvent(alert);\n        this.removeAlert(alert);\n    }\n\n    ngOnDestroy() {\n        // unsubscribe to avoid memory leaks\n        this.subscription.unsubscribe();\n    }\n\n    removeAlert(alert: Alert) {\n        if (this.inModal(alert)) {\n            this.closeModal();\n        }\n        // remove specified alert from array\n        this.alerts = this.alerts.filter(x => x.message !== alert.message);\n    }\n\n    inModal(alert: Alert) {\n        if (!alert) {\n            return;\n        }\n\n        // return true based on AlertType.ModalNotification\n        switch (alert.type) {\n            case AlertType.ModalNotification:\n                return true;\n            default:\n                return false;\n        }\n    }\n\n    cssClass(alert: Alert) {\n        if (!alert) {\n            return;\n        }\n\n        // return css class based on alert type\n        switch (alert.type) {\n            case AlertType.Success:\n                return 'alert alert-success';\n            case AlertType.Error:\n                return 'alert alert-danger';\n            case AlertType.Info:\n                return 'alert alert-info';\n            case AlertType.Warning:\n                return 'alert alert-warning';\n            case AlertType.Notification:\n                return 'alert alert-light';\n            case AlertType.ModalNotification:\n                return 'alert alert-light';\n        }\n    }\n\n    cssIconClass(alert: Alert) {\n        if (!alert) {\n            return;\n        }\n\n        // return css class based on alert type\n        switch (alert.type) {\n            case AlertType.Success:\n                return 'mdi mdi-check';\n            case AlertType.Error:\n                return 'mdi mdi-close-circle-o';\n            case AlertType.Info:\n                return 'mdi mdi-info-outline';\n            case AlertType.Warning:\n                return 'mdi mdi-alert-triangle';\n            case AlertType.Notification:\n                return 'mdi mdi-notifications';\n            case AlertType.ModalNotification:\n                return 'mdi mdi-notifications';\n        }\n    }\n\n}\n"]}

package/esm2015/lib/alert/alert.module.js

@@ -0,0 +1,28 @@
+/*
+ * 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 { CommonModule } from '@angular/common';
+import { AlertComponent } from './alert.component';
+export class AlertModule {
+}
+AlertModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [CommonModule],
+                declarations: [AlertComponent],
+                exports: [AlertComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmFsdGltby9jb21wb25lbnRzL3NyYy9saWIvYWxlcnQvYWxlcnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBT2pELE1BQU0sT0FBTyxXQUFXOzs7WUFMdkIsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztnQkFDdkIsWUFBWSxFQUFFLENBQUMsY0FBYyxDQUFDO2dCQUM5QixPQUFPLEVBQUUsQ0FBQyxjQUFjLENBQUM7YUFDMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtBbGVydENvbXBvbmVudH0gZnJvbSAnLi9hbGVydC5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbQWxlcnRDb21wb25lbnRdLFxuICBleHBvcnRzOiBbQWxlcnRDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIEFsZXJ0TW9kdWxlIHtcbn1cbiJdfQ==

package/esm2015/lib/alert/alert.service.js

@@ -0,0 +1,81 @@
+/*
+ * 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 { EventEmitter, Injectable } from '@angular/core';
+import { NavigationStart, Router } from '@angular/router';
+import { Subject } from 'rxjs';
+import { Alert, AlertType } from '@valtimo/contract';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class AlertService {
+    constructor(router) {
+        this.router = router;
+        this.confirmed = new EventEmitter();
+        this.subject = new Subject();
+        // clear alert messages on route change unless 'keepAfterRouteChange' flag is true
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                // clear alert messages
+                this.clear();
+            }
+        });
+    }
+    // enable subscribing to alerts observable
+    onAlert() {
+        return this.subject.asObservable();
+    }
+    // convenience methods
+    success(message, confirmations, iconClass) {
+        this.alert(new Alert({ message, type: AlertType.Success, confirmations, iconClass }));
+    }
+    error(message, confirmations, iconClass) {
+        this.alert(new Alert({ message, type: AlertType.Error, confirmations, iconClass }));
+    }
+    info(message, confirmations, iconClass) {
+        this.alert(new Alert({ message, type: AlertType.Info, confirmations, iconClass }));
+    }
+    warning(message, confirmations, iconClass) {
+        this.alert(new Alert({ message, type: AlertType.Warning, confirmations, iconClass }));
+    }
+    notification(message, confirmations, iconClass) {
+        this.alert(new Alert({ message, type: AlertType.Notification, confirmations, iconClass }));
+    }
+    modalNotification(message, confirmations, iconClass) {
+        this.alert(new Alert({ message, type: AlertType.ModalNotification, confirmations, iconClass }));
+    }
+    // main alert method
+    alert(alert) {
+        this.subject.next(alert);
+    }
+    // clear alerts
+    clear() {
+        this.subject.next(new Alert({}));
+    }
+    // emit confirm
+    emitAlertConfirmEvent(alert) {
+        this.confirmed.emit(alert);
+    }
+    getAlertConfirmChangeEmitter() {
+        return this.confirmed;
+    }
+}
+AlertService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AlertService_Factory() { return new AlertService(i0.ɵɵinject(i1.Router)); }, token: AlertService, providedIn: "root" });
+AlertService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+AlertService.ctorParameters = () => [
+    { type: Router }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vY29tcG9uZW50cy9zcmMvbGliL2FsZXJ0L2FsZXJ0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSCxPQUFPLEVBQUMsWUFBWSxFQUFFLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2RCxPQUFPLEVBQUMsZUFBZSxFQUFFLE1BQU0sRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQ3hELE9BQU8sRUFBYSxPQUFPLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFDekMsT0FBTyxFQUFDLEtBQUssRUFBRSxTQUFTLEVBQUMsTUFBTSxtQkFBbUIsQ0FBQzs7O0FBR25ELE1BQU0sT0FBTyxZQUFZO0lBSXZCLFlBQW9CLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBSDNCLGNBQVMsR0FBc0IsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUNqRCxZQUFPLEdBQUcsSUFBSSxPQUFPLEVBQVMsQ0FBQztRQUdyQyxrRkFBa0Y7UUFDbEYsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ25DLElBQUksS0FBSyxZQUFZLGVBQWUsRUFBRTtnQkFDcEMsdUJBQXVCO2dCQUN2QixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7YUFDZDtRQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELDBDQUEwQztJQUMxQyxPQUFPO1FBQ0wsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3JDLENBQUM7SUFFRCxzQkFBc0I7SUFDdEIsT0FBTyxDQUFDLE9BQWUsRUFBRSxhQUFtQixFQUFFLFNBQWtCO1FBQzlELElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLFNBQVMsQ0FBQyxPQUFPLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBQyxDQUFDLENBQUMsQ0FBQztJQUN0RixDQUFDO0lBRUQsS0FBSyxDQUFDLE9BQWUsRUFBRSxhQUFtQixFQUFFLFNBQWtCO1FBQzVELElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLFNBQVMsQ0FBQyxLQUFLLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBQyxDQUFDLENBQUMsQ0FBQztJQUNwRixDQUFDO0lBRUQsSUFBSSxDQUFDLE9BQWUsRUFBRSxhQUFtQixFQUFFLFNBQWtCO1FBQzNELElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLFNBQVMsQ0FBQyxJQUFJLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBQyxDQUFDLENBQUMsQ0FBQztJQUNuRixDQUFDO0lBRUQsT0FBTyxDQUFDLE9BQWUsRUFBRSxhQUFtQixFQUFFLFNBQWtCO1FBQzlELElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLFNBQVMsQ0FBQyxPQUFPLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBQyxDQUFDLENBQUMsQ0FBQztJQUN0RixDQUFDO0lBRUQsWUFBWSxDQUFDLE9BQWUsRUFBRSxhQUFtQixFQUFFLFNBQWtCO1FBQ25FLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLFNBQVMsQ0FBQyxZQUFZLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBQyxDQUFDLENBQUMsQ0FBQztJQUMzRixDQUFDO0lBRUQsaUJBQWlCLENBQUMsT0FBZSxFQUFFLGFBQW1CLEVBQUUsU0FBa0I7UUFDeEUsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEtBQUssQ0FBQyxFQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsU0FBUyxDQUFDLGlCQUFpQixFQUFFLGFBQWEsRUFBRSxTQUFTLEVBQUMsQ0FBQyxDQUFDLENBQUM7SUFDaEcsQ0FBQztJQUVELG9CQUFvQjtJQUNwQixLQUFLLENBQUMsS0FBWTtRQUNoQixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBRUQsZUFBZTtJQUNmLEtBQUs7UUFDSCxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFRCxlQUFlO0lBQ2YscUJBQXFCLENBQUMsS0FBWTtRQUNoQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRUQsNEJBQTRCO1FBQzFCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztJQUN4QixDQUFDOzs7O1lBOURGLFVBQVUsU0FBQyxFQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUM7OztZQUpQLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge0V2ZW50RW1pdHRlciwgSW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge05hdmlnYXRpb25TdGFydCwgUm91dGVyfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHtPYnNlcnZhYmxlLCBTdWJqZWN0fSBmcm9tICdyeGpzJztcbmltcG9ydCB7QWxlcnQsIEFsZXJ0VHlwZX0gZnJvbSAnQHZhbHRpbW8vY29udHJhY3QnO1xuXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcbmV4cG9ydCBjbGFzcyBBbGVydFNlcnZpY2Uge1xuICBwdWJsaWMgY29uZmlybWVkOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgcHJpdmF0ZSBzdWJqZWN0ID0gbmV3IFN1YmplY3Q8QWxlcnQ+KCk7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByb3V0ZXI6IFJvdXRlcikge1xuICAgIC8vIGNsZWFyIGFsZXJ0IG1lc3NhZ2VzIG9uIHJvdXRlIGNoYW5nZSB1bmxlc3MgJ2tlZXBBZnRlclJvdXRlQ2hhbmdlJyBmbGFnIGlzIHRydWVcbiAgICB0aGlzLnJvdXRlci5ldmVudHMuc3Vic2NyaWJlKGV2ZW50ID0+IHtcbiAgICAgIGlmIChldmVudCBpbnN0YW5jZW9mIE5hdmlnYXRpb25TdGFydCkge1xuICAgICAgICAvLyBjbGVhciBhbGVydCBtZXNzYWdlc1xuICAgICAgICB0aGlzLmNsZWFyKCk7XG4gICAgICB9XG4gICAgfSk7XG4gIH1cblxuICAvLyBlbmFibGUgc3Vic2NyaWJpbmcgdG8gYWxlcnRzIG9ic2VydmFibGVcbiAgb25BbGVydCgpOiBPYnNlcnZhYmxlPEFsZXJ0PiB7XG4gICAgcmV0dXJuIHRoaXMuc3ViamVjdC5hc09ic2VydmFibGUoKTtcbiAgfVxuXG4gIC8vIGNvbnZlbmllbmNlIG1ldGhvZHNcbiAgc3VjY2VzcyhtZXNzYWdlOiBzdHJpbmcsIGNvbmZpcm1hdGlvbnM/OiBhbnksIGljb25DbGFzcz86IHN0cmluZykge1xuICAgIHRoaXMuYWxlcnQobmV3IEFsZXJ0KHttZXNzYWdlLCB0eXBlOiBBbGVydFR5cGUuU3VjY2VzcywgY29uZmlybWF0aW9ucywgaWNvbkNsYXNzfSkpO1xuICB9XG5cbiAgZXJyb3IobWVzc2FnZTogc3RyaW5nLCBjb25maXJtYXRpb25zPzogYW55LCBpY29uQ2xhc3M/OiBzdHJpbmcpIHtcbiAgICB0aGlzLmFsZXJ0KG5ldyBBbGVydCh7bWVzc2FnZSwgdHlwZTogQWxlcnRUeXBlLkVycm9yLCBjb25maXJtYXRpb25zLCBpY29uQ2xhc3N9KSk7XG4gIH1cblxuICBpbmZvKG1lc3NhZ2U6IHN0cmluZywgY29uZmlybWF0aW9ucz86IGFueSwgaWNvbkNsYXNzPzogc3RyaW5nKSB7XG4gICAgdGhpcy5hbGVydChuZXcgQWxlcnQoe21lc3NhZ2UsIHR5cGU6IEFsZXJ0VHlwZS5JbmZvLCBjb25maXJtYXRpb25zLCBpY29uQ2xhc3N9KSk7XG4gIH1cblxuICB3YXJuaW5nKG1lc3NhZ2U6IHN0cmluZywgY29uZmlybWF0aW9ucz86IGFueSwgaWNvbkNsYXNzPzogc3RyaW5nKSB7XG4gICAgdGhpcy5hbGVydChuZXcgQWxlcnQoe21lc3NhZ2UsIHR5cGU6IEFsZXJ0VHlwZS5XYXJuaW5nLCBjb25maXJtYXRpb25zLCBpY29uQ2xhc3N9KSk7XG4gIH1cblxuICBub3RpZmljYXRpb24obWVzc2FnZTogc3RyaW5nLCBjb25maXJtYXRpb25zPzogYW55LCBpY29uQ2xhc3M/OiBzdHJpbmcpIHtcbiAgICB0aGlzLmFsZXJ0KG5ldyBBbGVydCh7bWVzc2FnZSwgdHlwZTogQWxlcnRUeXBlLk5vdGlmaWNhdGlvbiwgY29uZmlybWF0aW9ucywgaWNvbkNsYXNzfSkpO1xuICB9XG5cbiAgbW9kYWxOb3RpZmljYXRpb24obWVzc2FnZTogc3RyaW5nLCBjb25maXJtYXRpb25zPzogYW55LCBpY29uQ2xhc3M/OiBzdHJpbmcpIHtcbiAgICB0aGlzLmFsZXJ0KG5ldyBBbGVydCh7bWVzc2FnZSwgdHlwZTogQWxlcnRUeXBlLk1vZGFsTm90aWZpY2F0aW9uLCBjb25maXJtYXRpb25zLCBpY29uQ2xhc3N9KSk7XG4gIH1cblxuICAvLyBtYWluIGFsZXJ0IG1ldGhvZFxuICBhbGVydChhbGVydDogQWxlcnQpIHtcbiAgICB0aGlzLnN1YmplY3QubmV4dChhbGVydCk7XG4gIH1cblxuICAvLyBjbGVhciBhbGVydHNcbiAgY2xlYXIoKSB7XG4gICAgdGhpcy5zdWJqZWN0Lm5leHQobmV3IEFsZXJ0KHt9KSk7XG4gIH1cblxuICAvLyBlbWl0IGNvbmZpcm1cbiAgZW1pdEFsZXJ0Q29uZmlybUV2ZW50KGFsZXJ0OiBBbGVydCkge1xuICAgIHRoaXMuY29uZmlybWVkLmVtaXQoYWxlcnQpO1xuICB9XG5cbiAgZ2V0QWxlcnRDb25maXJtQ2hhbmdlRW1pdHRlcigpIHtcbiAgICByZXR1cm4gdGhpcy5jb25maXJtZWQ7XG4gIH1cbn1cbiJdfQ==

package/esm2015/lib/bpmn-js-diagram/bpmn-js-diagram.component.js

@@ -0,0 +1,160 @@
+/*
+ * 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, Input, Output, ViewChild, EventEmitter } from '@angular/core';
+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 BpmnJsDiagramComponent {
+    constructor() {
+        this.importDone = new EventEmitter();
+        this.heatPoints = { data: [] };
+    }
+    ngOnInit() {
+        this.bpmnJS = new BpmnJS();
+        this.bpmnJS.on('import.done', ({ error }) => {
+            if (!error) {
+                const canvas = this.bpmnJS.get('canvas'), eventBus = this.bpmnJS.get('eventBus');
+                if (this.historicActivityInstances) {
+                    this.historicActivityInstances.forEach(instance => {
+                        canvas.addMarker(instance.activityId, instance.endTime ? 'highlight-overlay-past' : 'highlight-overlay-current');
+                    });
+                }
+                canvas.zoom('fit-viewport', 'auto');
+                if (this.heatmapDuration || this.heatmapCount) {
+                    eventBus.on('canvas.init', () => {
+                        if (this.heatmapMode) {
+                            this.clearHeatmap();
+                        }
+                        this.getHeatmapData();
+                    });
+                    eventBus.on('canvas.viewbox.changing', () => {
+                        if (this.heatmapMode) {
+                            this.clearHeatmap();
+                        }
+                    });
+                    eventBus.on('canvas.viewbox.changed', () => {
+                        this.getHeatmapData();
+                    });
+                }
+            }
+        });
+    }
+    ngAfterContentInit() {
+        this.bpmnJS.importXML(this.bpmn20Xml);
+        this.bpmnJS.attachTo(this.el.nativeElement);
+    }
+    getHeatmapData() {
+        let inputData, valueKey;
+        this.heatPoints = { data: [] };
+        this.min = 0;
+        this.max = 0;
+        if (this.heatmapDuration) {
+            inputData = this.heatmapDuration;
+            valueKey = 'averageDurationInMilliseconds';
+        }
+        else if (this.heatmapCount) {
+            inputData = this.heatmapCount;
+            valueKey = 'totalCount';
+        }
+        if (inputData) {
+            Object.keys(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: inputData[key][valueKey],
+                    radius: diagramElm.width / 2
+                });
+                if (inputData[key].count > 0) {
+                    this.addCounterActiveOverlays(key, inputData);
+                }
+            });
+            if (this.heatmapMode) {
+                this.showHeatmap();
+            }
+        }
+    }
+    setMax(key) {
+        if (this.heatmapDuration) {
+            this.max = Math.max(this.heatmapDuration[key].averageDurationInMilliseconds, this.max);
+        }
+        else if (this.heatmapCount) {
+            this.max = Math.max(this.heatmapCount[key].totalCount + this.heatmapCount[key].count, this.max);
+        }
+    }
+    addCounterActiveOverlays(key, inputData) {
+        const overlays = this.bpmnJS.get('overlays');
+        overlays.add(key, {
+            position: {
+                bottom: -10,
+                left: 0
+            },
+            show: {
+                minZoom: 0,
+                maxZoom: 5.0
+            },
+            html: `<span class="badge badge-pill badge-primary">${inputData[key].count}</span>`
+        });
+    }
+    showHeatmap() {
+        this.heatMapInstance = heatmap.create({
+            radius: 54,
+            blur: .70,
+            maxOpacity: .4,
+            minOpacity: 0,
+            container: this.el.nativeElement
+        });
+        this.heatMapInstance.setData({
+            min: this.min,
+            max: this.max,
+            data: this.heatPoints.data
+        });
+    }
+    clearHeatmap() {
+        this.heatMapInstance.setData({ data: [] });
+    }
+    toggleHeatmap() {
+        this.heatmapMode = !this.heatmapMode;
+        if (this.heatmapMode) {
+            this.showHeatmap();
+        }
+        else {
+            this.clearHeatmap();
+        }
+    }
+    ngOnDestroy() {
+        this.bpmnJS.destroy();
+    }
+}
+BpmnJsDiagramComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'valtimo-bpmn-js-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=\"p-4\" *ngIf=\"heatmapDuration || heatmapCount\">\n  <div class=\"switch-button switch-button-sm switch-button-success\">\n    <input type=\"checkbox\" id=\"toggleHeatmap\" [checked]=\"heatmapMode\" (click)=\"toggleHeatmap()\"><span>\n    <label for=\"toggleHeatmap\"></label></span>\n  </div>\n</div>\n\n<div #ref class=\"diagram-container\"></div>\n\n<div *ngIf=\"historicActivityInstances\" class=\"p-4 text-center legenda-holder\">\n  <span><div class=\"legenda highlight-overlay-past\"></div> Executed tasks</span>\n  <span class=\"ml-3\"><div class=\"legenda highlight-overlay-current\"></div> Current tasks</span>\n</div>\n\n<div *ngIf=\"heatmapDuration || heatmapCount\" 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: [""]
+            },] }
+];
+BpmnJsDiagramComponent.ctorParameters = () => [];
+BpmnJsDiagramComponent.propDecorators = {
+    el: [{ type: ViewChild, args: ['ref', { static: true },] }],
+    importDone: [{ type: Output }],
+    bpmn20Xml: [{ type: Input }],
+    heatmapDuration: [{ type: Input }],
+    heatmapCount: [{ type: Input }],
+    historicActivityInstances: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bpmn-js-diagram.component.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/bpmn-js-diagram/bpmn-js-diagram.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAEL,SAAS,EACT,UAAU,EACV,KAAK,EAEL,MAAM,EACN,SAAS,EACT,YAAY,EAEb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,sDAAsD,CAAC;AAC/E,OAAO,KAAK,OAAO,MAAM,mCAAmC,CAAC;AAQ7D,MAAM,OAAO,sBAAsB;IAiBjC;QAXiB,eAAU,GAAsB,IAAI,YAAY,EAAE,CAAC;QAO7D,eAAU,GAAG,EAAC,IAAI,EAAE,EAAE,EAAC,CAAC;IAIf,CAAC;IAEjB,QAAQ;QACN,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE;YACxC,IAAI,CAAC,KAAK,EAAE;gBACV,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EACpC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAE3C,IAAI,IAAI,CAAC,yBAAyB,EAAE;oBAClC,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;wBAChD,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC;oBACnH,CAAC,CAAC,CAAC;iBACJ;gBAED,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;gBAEpC,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,YAAY,EAAE;oBAC7C,QAAQ,CAAC,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;wBAC9B,IAAI,IAAI,CAAC,WAAW,EAAE;4BACpB,IAAI,CAAC,YAAY,EAAE,CAAC;yBACrB;wBACD,IAAI,CAAC,cAAc,EAAE,CAAC;oBACxB,CAAC,CAAC,CAAC;oBACH,QAAQ,CAAC,EAAE,CAAC,yBAAyB,EAAE,GAAG,EAAE;wBAC1C,IAAI,IAAI,CAAC,WAAW,EAAE;4BACpB,IAAI,CAAC,YAAY,EAAE,CAAC;yBACrB;oBACH,CAAC,CAAC,CAAC;oBACH,QAAQ,CAAC,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;wBACzC,IAAI,CAAC,cAAc,EAAE,CAAC;oBACxB,CAAC,CAAC,CAAC;iBACJ;aACF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC;IAED,cAAc;QACZ,IAAI,SAAc,EACd,QAAa,CAAC;QAElB,IAAI,CAAC,UAAU,GAAG,EAAC,IAAI,EAAE,EAAE,EAAC,CAAC;QAC7B,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;QACb,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;QAEb,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC;YACjC,QAAQ,GAAG,+BAA+B,CAAC;SAC5C;aAAM,IAAI,IAAI,CAAC,YAAY,EAAE;YAC5B,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC;YAC9B,QAAQ,GAAG,YAAY,CAAC;SACzB;QAED,IAAI,SAAS,EAAE;YACb,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACnC,MAAM,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC;qBAC9D,qBAAqB,EAAE,EAC1B,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,aAAa,CAAC,qBAAqB,GAAG,GAAG,CAAC;qBAC1E,qBAAqB,EAAE,CAAC;gBAC7B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACjB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;oBACxB,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC;oBACvE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;oBACxE,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;oBAC/B,MAAM,EAAE,UAAU,CAAC,KAAK,GAAG,CAAC;iBAC7B,CAAC,CAAC;gBACH,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE;oBAC5B,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;iBAC/C;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,IAAI,CAAC,WAAW,EAAE,CAAC;aACpB;SACF;IACH,CAAC;IAED,MAAM,CAAC,GAAQ;QACb,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,6BAA6B,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;SACxF;aAAM,IAAI,IAAI,CAAC,YAAY,EAAE;YAC5B,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;SACjG;IACH,CAAC;IAED,wBAAwB,CAAC,GAAQ,EAAE,SAAc;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC7C,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE;YAChB,QAAQ,EAAE;gBACR,MAAM,EAAE,CAAC,EAAE;gBACX,IAAI,EAAE,CAAC;aACR;YACD,IAAI,EAAE;gBACJ,OAAO,EAAE,CAAC;gBACV,OAAO,EAAE,GAAG;aACb;YACD,IAAI,EAAE,gDAAgD,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,SAAS;SACpF,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;YACpC,MAAM,EAAE,EAAE;YACV,IAAI,EAAE,GAAG;YACT,UAAU,EAAE,EAAE;YACd,UAAU,EAAE,CAAC;YACb,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,aAAa;SACjC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;YAC3B,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI;SAC3B,CAAC,CAAC;IACL,CAAC;IAED,YAAY;QACV,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAC,IAAI,EAAE,EAAE,EAAC,CAAC,CAAC;IAC3C,CAAC;IAED,aAAa;QACX,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC;QACrC,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,CAAC,WAAW,EAAE,CAAC;SACpB;aAAM;YACL,IAAI,CAAC,YAAY,EAAE,CAAC;SACrB;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;;;YA9JF,SAAS,SAAC;gBACT,QAAQ,EAAE,yBAAyB;gBACnC,mpDAA+C;;aAEhD;;;;iBAOE,SAAS,SAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;yBACjC,MAAM;wBACN,KAAK;8BACL,KAAK;2BACL,KAAK;wCACL,KAAK","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 {\n  AfterContentInit,\n  Component,\n  ElementRef,\n  Input,\n  OnDestroy,\n  Output,\n  ViewChild,\n  EventEmitter,\n  OnInit\n} from '@angular/core';\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-bpmn-js-diagram',\n  templateUrl: './bpmn-js-diagram.component.html',\n  styleUrls: ['./bpmn-js-diagram.component.css']\n})\n\nexport class BpmnJsDiagramComponent implements OnInit, AfterContentInit, OnDestroy {\n\n  private bpmnJS: BpmnJS;\n  private heatMapInstance: any;\n\n  @ViewChild('ref', { static: true }) public el: ElementRef;\n  @Output() public importDone: EventEmitter<any> = new EventEmitter();\n  @Input() public bpmn20Xml: any;\n  @Input() public heatmapDuration?: any;\n  @Input() public heatmapCount?: any;\n  @Input() public historicActivityInstances?: any;\n\n  public heatmapMode: boolean;\n  public heatPoints = {data: []};\n  public min: number;\n  public max: number;\n\n  constructor() { }\n\n  ngOnInit(): void {\n    this.bpmnJS = new BpmnJS();\n    this.bpmnJS.on('import.done', ({error}) => {\n      if (!error) {\n        const canvas = this.bpmnJS.get('canvas')\n          , eventBus = this.bpmnJS.get('eventBus');\n\n        if (this.historicActivityInstances) {\n          this.historicActivityInstances.forEach(instance => {\n            canvas.addMarker(instance.activityId, instance.endTime ? 'highlight-overlay-past' : 'highlight-overlay-current');\n          });\n        }\n\n        canvas.zoom('fit-viewport', 'auto');\n\n        if (this.heatmapDuration || this.heatmapCount) {\n          eventBus.on('canvas.init', () => {\n            if (this.heatmapMode) {\n              this.clearHeatmap();\n            }\n            this.getHeatmapData();\n          });\n          eventBus.on('canvas.viewbox.changing', () => {\n            if (this.heatmapMode) {\n              this.clearHeatmap();\n            }\n          });\n          eventBus.on('canvas.viewbox.changed', () => {\n            this.getHeatmapData();\n          });\n        }\n      }\n    });\n  }\n\n  ngAfterContentInit(): void {\n    this.bpmnJS.importXML(this.bpmn20Xml);\n    this.bpmnJS.attachTo(this.el.nativeElement);\n  }\n\n  getHeatmapData() {\n    let inputData: any\n      , valueKey: any;\n\n    this.heatPoints = {data: []};\n    this.min = 0;\n    this.max = 0;\n\n    if (this.heatmapDuration) {\n      inputData = this.heatmapDuration;\n      valueKey = 'averageDurationInMilliseconds';\n    } else if (this.heatmapCount) {\n      inputData = this.heatmapCount;\n      valueKey = 'totalCount';\n    }\n\n    if (inputData) {\n      Object.keys(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: inputData[key][valueKey],\n          radius: diagramElm.width / 2\n        });\n        if (inputData[key].count > 0) {\n          this.addCounterActiveOverlays(key, inputData);\n        }\n      });\n\n      if (this.heatmapMode) {\n        this.showHeatmap();\n      }\n    }\n  }\n\n  setMax(key: any) {\n    if (this.heatmapDuration) {\n      this.max = Math.max(this.heatmapDuration[key].averageDurationInMilliseconds, this.max);\n    } else if (this.heatmapCount) {\n      this.max = Math.max(this.heatmapCount[key].totalCount + this.heatmapCount[key].count, this.max);\n    }\n  }\n\n  addCounterActiveOverlays(key: any, inputData: any) {\n    const overlays = this.bpmnJS.get('overlays');\n    overlays.add(key, {\n      position: {\n        bottom: -10,\n        left: 0\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  showHeatmap() {\n    this.heatMapInstance = heatmap.create({\n      radius: 54,\n      blur: .70,\n      maxOpacity: .4,\n      minOpacity: 0,\n      container: this.el.nativeElement\n    });\n    this.heatMapInstance.setData({\n      min: this.min,\n      max: this.max,\n      data: this.heatPoints.data\n    });\n  }\n\n  clearHeatmap() {\n    this.heatMapInstance.setData({data: []});\n  }\n\n  toggleHeatmap() {\n    this.heatmapMode = !this.heatmapMode;\n    if (this.heatmapMode) {\n      this.showHeatmap();\n    } else {\n      this.clearHeatmap();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.bpmnJS.destroy();\n  }\n\n}\n"]}

package/esm2015/lib/bpmn-js-diagram/bpmn-js-diagram.module.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 { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BpmnJsDiagramComponent } from './bpmn-js-diagram.component';
+export class BpmnJsDiagramModule {
+}
+BpmnJsDiagramModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [BpmnJsDiagramComponent],
+                imports: [
+                    CommonModule
+                ],
+                exports: [BpmnJsDiagramComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnBtbi1qcy1kaWFncmFtLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vY29tcG9uZW50cy9zcmMvbGliL2JwbW4tanMtZGlhZ3JhbS9icG1uLWpzLWRpYWdyYW0ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFVckUsTUFBTSxPQUFPLG1CQUFtQjs7O1lBUi9CLFFBQVEsU0FBQztnQkFDUixZQUFZLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztnQkFDdEMsT0FBTyxFQUFFO29CQUNQLFlBQVk7aUJBQ2I7Z0JBQ0QsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7YUFDbEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEJwbW5Kc0RpYWdyYW1Db21wb25lbnQgfSBmcm9tICcuL2JwbW4tanMtZGlhZ3JhbS5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtCcG1uSnNEaWFncmFtQ29tcG9uZW50XSxcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZVxuICBdLFxuICBleHBvcnRzOiBbQnBtbkpzRGlhZ3JhbUNvbXBvbmVudF1cbn0pXG5cbmV4cG9ydCBjbGFzcyBCcG1uSnNEaWFncmFtTW9kdWxlIHsgfVxuIl19

package/esm2015/lib/breadcrumb-navigation/breadcrumb-navigation.component.js

@@ -0,0 +1,93 @@
+/*
+ * 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';
+import { ActivatedRoute, NavigationEnd, PRIMARY_OUTLET, Router } from '@angular/router';
+import { filter, map } from 'rxjs/operators';
+import { Subscription } from 'rxjs';
+export class BreadcrumbNavigationComponent {
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+        this.breadcrumbs = [];
+        this.appTitle = 'Valtimo';
+        this.routerSub = Subscription.EMPTY;
+    }
+    ngOnInit() {
+        this.setBreadcrumbs(this.route);
+        this.routerSub = this.router.events
+            .pipe(filter(event => event instanceof NavigationEnd))
+            .pipe(map(() => this.route))
+            .pipe(map((route) => {
+            while (route.firstChild) {
+                route = route.firstChild;
+            }
+            return route;
+        }))
+            .pipe(filter(route => route.outlet === PRIMARY_OUTLET))
+            .subscribe(route => {
+            this.setBreadcrumbs(route);
+        });
+    }
+    setBreadcrumbs(route) {
+        while (route.firstChild) {
+            route = route.firstChild;
+        }
+        if (route.outlet === PRIMARY_OUTLET) {
+            const snapshot = route.snapshot;
+            const activeRoute = {
+                url: snapshot.url.join('/'),
+                path: snapshot.routeConfig.path,
+                label: snapshot.data['title'],
+                params: snapshot.params
+            };
+            this.generateBreadcrumbs(activeRoute);
+        }
+    }
+    generateBreadcrumbs(activeBreadcrumb) {
+        this.breadcrumbs = [];
+        this.router.config.map(routerConfig => {
+            if (activeBreadcrumb.path.indexOf(routerConfig.path + '/') === 0
+                && activeBreadcrumb.path !== routerConfig.path
+                && routerConfig.path !== '') {
+                const parentRoute = {
+                    url: routerConfig.path.replace(/:(.+?)\b/g, (_, p1) => activeBreadcrumb.params[p1]),
+                    path: routerConfig.path,
+                    label: routerConfig.data['title'],
+                    params: activeBreadcrumb.params
+                };
+                const exist = this.breadcrumbs.findIndex(item => item.url === parentRoute.url);
+                if (exist === -1) {
+                    this.breadcrumbs.push(parentRoute);
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.routerSub.unsubscribe();
+    }
+}
+BreadcrumbNavigationComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'valtimo-breadcrumb-navigation',
+                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<nav aria-label=\"breadcrumb\" role=\"navigation\">\n  <ol class=\"breadcrumb page-head-nav\">\n    <li class=\"breadcrumb-item\">\n      <a [routerLink]=\"['/']\">{{ appTitle }}</a>\n    </li>\n    <li class=\"breadcrumb-item\" *ngFor=\"let item of breadcrumbs\">\n      <a [routerLink]=\"[item.url]\">{{ item.label | translate }}</a>\n    </li>\n  </ol>\n</nav>\n",
+                styles: [""]
+            },] }
+];
+BreadcrumbNavigationComponent.ctorParameters = () => [
+    { type: Router },
+    { type: ActivatedRoute }
+];
+//# sourceMappingURL=data:application/json;base64,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