@provoly/dashboard 0.11.0

package/esm2022/lib/dashboard/components/dashboard.component.mjs

@@ -0,0 +1,558 @@
+import { OverlayConfig } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Component, EventEmitter, Input, Output, TemplateRef, ViewChild } from '@angular/core';
+import equal from 'fast-deep-equal/es6';
+import { auditTime, BehaviorSubject, combineLatest, combineLatestWith, fromEvent, of, switchMap } from 'rxjs';
+import { distinctUntilChanged, filter, map } from 'rxjs/operators';
+import { DashboardGridLayout } from '../../core/model/manifest.interface';
+import { MIME_TYPE_RESULTSET } from '../../core/model/mimetype-resultset.constant';
+import { CategoryActions } from '../../core/store/category/category.actions';
+import { ClassActions } from '../../core/store/class/class.actions';
+import { ConfigActions } from '../../core/store/config/config.actions';
+import { ConfigSelectors } from '../../core/store/config/config.selectors';
+import { DataSourceActions } from '../../core/store/data-source/data-source.actions';
+import { FieldActions } from '../../core/store/field/field.actions';
+import { RelationTypesActions } from '../../core/store/relation-types/relation-types.actions';
+import { WidgetPlacementUtils } from '../components/widgets/widget-placement/widget-placement.utils';
+import { DashboardActions } from '../store/dashboard.actions';
+import { DEFAULT_COLUMNS_NUMBER, DEFAULT_GAP_PX, DEFAULT_ROW_HEIGHT_PX, DEFAULT_ROWS_NUMBER } from '../store/dashboard.contants';
+import { DashboardSelectors } from '../store/dashboard.selectors';
+import { solveCollisions } from './solve-collisions.function';
+import { SubscriptionnerDirective } from './subscriptionner.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "@angular/common";
+import * as i4 from "../../core/components/icon/icon.component";
+import * as i5 from "./widgets/widget-instanciator/widget-instanciator.component";
+import * as i6 from "./context-menu/context-menu.component";
+import * as i7 from "../../core/i18n/i18n.pipe";
+export const MIME_TYPE_WIDGET_MANIFEST = 'application/widget-manifest';
+export const MIME_TYPE_WIDGET_TYPE = 'application/widget-type-';
+export const MIME_TYPE_WIDGET_SIZE = 'application/widget-size-';
+export class DashboardComponent extends SubscriptionnerDirective {
+    set staticDashboard(window) {
+        this.staticDashboard$.next(window);
+    }
+    constructor(store, overlay, viewContainerRef) {
+        super();
+        this.store = store;
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.manifest = null;
+        this.modeEdition = false;
+        this.staticDashboard$ = new BehaviorSubject(null);
+        this.stacked$ = new BehaviorSubject(false);
+        this.indexForRemoval = -1;
+        this.widgetsInstances = [];
+        this.CloseOnDragOut = true;
+        this.canCalculateView = false;
+        this.dashboardParams = {
+            gridWidth: 1,
+            gridHeight: 1,
+            gridGap: DEFAULT_GAP_PX,
+            columns: DEFAULT_COLUMNS_NUMBER,
+            cellWidth: 1,
+            cellHeight: DEFAULT_ROW_HEIGHT_PX,
+            rows: DEFAULT_ROWS_NUMBER,
+            offsetLeft: 0,
+            offsetTop: 0,
+            mobileMode: false
+        };
+        this.breakpoint = 0;
+        this.rowHeight = new EventEmitter();
+        this.rows = new EventEmitter();
+        this.currentlyModifiedManifest = null;
+        this.initialWidgetManifestList = [];
+        this.move = {
+            initialX: -1,
+            initialY: -1,
+            previousX: -1,
+            previousY: -1
+        };
+        this.DashboardGridLayout = DashboardGridLayout;
+        this.layout = DashboardGridLayout.MANUAL;
+        this.modeEdition$ = this.store.select(DashboardSelectors.dashboardEditionMode);
+        this.subscriptions.add(this.modeEdition$.subscribe((mode) => {
+            this.modeEdition = mode;
+            if (!mode) {
+                this.clearActions();
+            }
+        }));
+        this.targetIndexes$ = this.store.select(DashboardSelectors.targetTenantsIndexes);
+        this.subscriptions.add(this.store.select(DashboardSelectors.dashboardCellParams).subscribe((params) => (this.dashboardParams = params)));
+        this.windowManifest$ = this.store.select(DashboardSelectors.windowManifest).pipe(combineLatestWith(this.staticDashboard$), switchMap(([windowManifest, staticDashboard]) => (!staticDashboard ? of(windowManifest) : of(staticDashboard))), distinctUntilChanged((p, c) => equal(p, c)), map((_wManifest) => {
+            const wManifest = JSON.parse(JSON.stringify(_wManifest));
+            if (wManifest.grid?.layout && wManifest.grid.layout !== DashboardGridLayout.MANUAL) {
+                // Complete with placeholders
+                const size = WidgetPlacementUtils.placesForLayout(wManifest.grid.layout);
+                const places = WidgetPlacementUtils.placementOptions({ type: 'filler', layout: { x: 1, y: 1, width: 1, height: 1 } }, wManifest.grid.layout, wManifest.grid);
+                let added = true;
+                while (wManifest.widgets.length < size && added) {
+                    added = false;
+                    for (let i = 0; i < places.length; i++) {
+                        const potential = { ...places[i], options: { index: i } };
+                        if (wManifest.widgets
+                            .map((widget) => WidgetPlacementUtils.areDisjoint(widget, potential))
+                            .reduce((a, b) => a && b, true)) {
+                            wManifest.widgets.push(potential);
+                            added = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            return wManifest;
+        }));
+        this.nonFillerWidgets$ = this.windowManifest$.pipe(map((wManifest) => wManifest.widgets.filter((w) => w.type !== 'filler').length));
+        this.subscriptions.add(this.staticDashboard$.subscribe((manifest) => {
+            if (!!manifest) {
+                const getDataActions = [
+                    ...new Set((manifest.widgets ?? [])
+                        .reduce((p, c) => [...p, c], [])
+                        .map((widManifest) => widManifest.datasource))
+                ].reduce((p, c) => [...p, ...(Array.isArray(c) ? c : [c])], []).map((resultSet) => DashboardActions.assertResultSets({ id: resultSet }));
+                getDataActions.forEach((action) => this.store.dispatch(action));
+            }
+        }));
+        this.store.dispatch(FieldActions.load());
+        this.store.dispatch(ClassActions.load());
+        this.store.dispatch(CategoryActions.load());
+        this.store.dispatch(ConfigActions.getMapStyles());
+        this.store.dispatch(DataSourceActions.load());
+        this.store.dispatch(RelationTypesActions.load());
+        this.store.dispatch(ConfigActions.loadCustomization());
+        this.subscriptions.add(fromEvent(window, 'resize')
+            .pipe(auditTime(100))
+            .subscribe(() => {
+            this.calculateView();
+        }));
+        this.subscriptions.add(combineLatest([this.windowManifest$, this.modeEdition$])
+            .pipe(auditTime(100))
+            .subscribe(() => {
+            this.calculateView();
+        }));
+        this.subscriptions.add(fromEvent(window, 'keydown')
+            .pipe(map(($event) => $event), filter(($event) => $event.key === 'L' && $event.ctrlKey && $event.shiftKey))
+            .subscribe(() => this.store.dispatch(DashboardActions.toggleEditionMode({}))));
+        this.subscriptions.add(fromEvent(window, 'mouseup').subscribe(() => {
+            this.clearActions();
+        }));
+        this.subscriptions.add(this.store.select(ConfigSelectors.breakpoint).subscribe((bp) => {
+            this.breakpoint = bp;
+        }));
+        this.subscriptions.add(this.windowManifest$.subscribe((manifest) => {
+            this.manifest = manifest;
+        }));
+        this.subscriptions.add(this.store.select(DashboardSelectors.gridLayout).subscribe((layout) => {
+            this.layout = layout;
+        }));
+        this.gridTemplateRows$ = combineLatest([this.windowManifest$, this.stacked$]).pipe(map(([manifest, stacked]) => this.generateRows(stacked && this.manifest
+            ? this.manifest?.widgets.map((wm) => wm.layout.height).reduce((wm1, wm2) => wm1 + wm2, 0)
+            : manifest.grid?.rows ?? DEFAULT_ROWS_NUMBER)));
+        this.gridTemplateColumns$ = combineLatest([this.windowManifest$, this.stacked$]).pipe(map(([manifest, stacked]) => this.generateColumns(stacked ? 1 : manifest.grid?.columns || DEFAULT_COLUMNS_NUMBER)));
+        this.backgroundArea$ = combineLatest([this.windowManifest$, this.stacked$]).pipe(map(([manifest, stacked]) => !stacked
+            ? `3/3/${(manifest.grid?.rows ?? DEFAULT_ROWS_NUMBER) - 1}/${(manifest.grid?.columns ?? DEFAULT_COLUMNS_NUMBER) - 1}`
+            : `3/1/${(manifest.grid?.columns ?? DEFAULT_COLUMNS_NUMBER) - 1}/1`));
+        this.separators$ = this.store
+            .select(DashboardSelectors.gridLayout)
+            .pipe(map((layout) => layout === DashboardGridLayout.MANUAL
+            ? []
+            : WidgetPlacementUtils.getLayoutSize(layout, { rows: 1, columns: 1 })));
+    }
+    ngAfterViewInit() {
+        this.canCalculateView = true;
+    }
+    /***
+     * Manage display
+     */
+    calculateView() {
+        if (this.canCalculateView) {
+            let element = this.gridRef.nativeElement;
+            while (element.getBoundingClientRect().height === 0 && !!element.parentElement) {
+                element = element.parentElement;
+            }
+            const gridWidth = element.getBoundingClientRect().width;
+            const mobileMode = gridWidth < this.breakpoint;
+            this.stacked$.next(this.dashboardParams.mobileMode && !this.modeEdition);
+            const rows = !this.displayIsStacked
+                ? (!!this.manifest && !!this.manifest.grid && this.manifest.grid.rows) || DEFAULT_ROWS_NUMBER
+                : this.manifest?.widgets.reduce((p, c) => p + c.layout.height, 0) ?? 1;
+            const params = {
+                gridWidth,
+                // Calculate height to parennt the parent's
+                gridHeight: element.getBoundingClientRect().height,
+                gridGap: 1,
+                columns: (!!this.manifest && !!this.manifest.grid && this.manifest.grid.columns) || DEFAULT_COLUMNS_NUMBER,
+                cellHeight: 1,
+                rows,
+                cellWidth: 0,
+                offsetLeft: this.gridRef.nativeElement.offsetLeft,
+                offsetTop: this.gridRef.nativeElement.offsetTop,
+                mobileMode
+            };
+            params.gridGap =
+                params.rows * params.cellHeight < params.gridHeight
+                    ? !!this.manifest && !!this.manifest.grid
+                        ? this.manifest.grid.gap || DEFAULT_GAP_PX
+                        : DEFAULT_GAP_PX
+                    : 0;
+            params.cellHeight = (params.gridHeight - (params.rows - 1) * params.gridGap) / params.rows;
+            params.cellWidth = (params.gridWidth - (params.columns - 1) * params.gridGap) / params.columns;
+            this.store.dispatch(DashboardActions.updateDashboardParams({ params }));
+            this.rows.next(params.rows);
+            this.rowHeight.next(params.cellHeight);
+        }
+    }
+    get displayIsStacked() {
+        return this.stacked$.getValue();
+    }
+    gridColumn(layout) {
+        if (this.displayIsStacked || !layout) {
+            return '1 / 1';
+        }
+        if (layout.width > 1) {
+            return `${Math.min(layout.x, this.dashboardParams.columns - layout.width + 1)} / ${Math.min(layout.x + layout.width, this.dashboardParams.columns + 1)}`;
+        }
+        else {
+            return `${layout.x}`;
+        }
+    }
+    gridRow(layout) {
+        if (!layout) {
+            return '1';
+        }
+        if (this.displayIsStacked) {
+            const previousHeight = this.manifest?.widgets
+                .filter((wm) => (wm.layout.y === layout.y && wm.layout.x < layout.x) || wm.layout.y < layout.y)
+                .reduce((p, c) => p + c.layout.height, 1);
+            return `${previousHeight ?? 1} / ${(previousHeight ?? 1) + layout.height}`;
+        }
+        if (layout.height > 1) {
+            return `${Math.max(1, Math.min(layout.y, this.dashboardParams.rows - layout.height + 1))} / ${Math.min(layout.y + layout.height, this.dashboardParams.rows + 1)}`;
+        }
+        else {
+            return `${layout.y}`;
+        }
+    }
+    generateRows(rows) {
+        return Array(rows).fill('1fr').join(' ');
+    }
+    generateColumns(columns) {
+        return Array(columns).fill('1fr').join(' ');
+    }
+    /***
+     * Direct actions on widgets
+     */
+    remove(i) {
+        const listWidgetManifests = [...(this.manifest || { widgets: [] }).widgets];
+        listWidgetManifests.splice(i, 1).filter((widget) => widget.type !== 'filler');
+        this.store.dispatch(DashboardActions.updateDashboardManifest({
+            manifest: {
+                ...this.manifest,
+                widgets: listWidgetManifests
+            }
+        }));
+    }
+    moveInNewWindow(widgetIndex, targetIndex) {
+        this.store.dispatch(DashboardActions.moveWidget({ widgetIndex, targetIndex }));
+        this.store.dispatch(DashboardActions.toggleEditionMode({ force: false }));
+    }
+    maximize(widgetIndex) {
+        this.store.dispatch(DashboardActions.maximizeWidget({ widgetIndex }));
+    }
+    /***
+     * Manage drag n drop, move, resize
+     */
+    prepareModification($event, indexManifest) {
+        this.move.initialX = $event.clientX;
+        this.move.initialY = $event.clientY;
+        this.initialWidgetManifestList = JSON.parse(JSON.stringify((this.manifest || { widgets: [] }).widgets));
+        this.currentlyModifiedManifest = this.initialWidgetManifestList.splice(indexManifest, 1)[0];
+        // console.log('prepare', this.currentlyModifiedManifest, this.initialWidgetManifestList);
+    }
+    startResize($event, indexManifest, direction) {
+        this.actionType = direction;
+        this.prepareModification($event, indexManifest);
+        // console.log('start resize', this.currentlyModifiedManifest, this.initialWidgetManifestList);
+    }
+    dragStart($event, indexManifest) {
+        this.actionType = 'move';
+        this.prepareModification($event, indexManifest);
+        DashboardComponent.addTransferManifestMetadata($event, this.currentlyModifiedManifest ?? {});
+        // console.log('start move', this.currentlyModifiedManifest, this.initialWidgetManifestList);
+    }
+    static addTransferManifestMetadata($event, manifest) {
+        if (!!$event && !!$event.dataTransfer && !$event.dataTransfer.types.includes(MIME_TYPE_WIDGET_MANIFEST)) {
+            $event.dataTransfer.setData(MIME_TYPE_WIDGET_MANIFEST, JSON.stringify(manifest));
+            $event.dataTransfer.setData(MIME_TYPE_WIDGET_TYPE + manifest.type, 'unused');
+            // Passing widget size as a mime type, so that we can bypass security for placeholder size at the arrival of the drag
+            $event.dataTransfer.setData(MIME_TYPE_WIDGET_SIZE + `${manifest.layout.width}-${manifest.layout.height}`, 'useless' // data is in the mime type
+            );
+        }
+    }
+    dragEnter($event, force = false) {
+        $event.stopPropagation();
+        $event.preventDefault();
+        const types = ($event.dataTransfer || { types: [''] }).types;
+        if (types.includes(MIME_TYPE_WIDGET_MANIFEST)) {
+            this.store.dispatch(DashboardActions.toggleEditionMode({ force: true }));
+            this.actionType = 'move';
+        }
+    }
+    checkForDragEnter($event) {
+        if (!this.currentlyModifiedManifest) {
+            // create placeholder as a drag entered the component, go into edition mode and move action if it's a widget being dragged
+            const types = ($event.dataTransfer || { types: [''] }).types;
+            if (types.includes(MIME_TYPE_WIDGET_MANIFEST)) {
+                this.actionType = 'move';
+                this.store.dispatch(DashboardActions.toggleEditionMode({ force: true }));
+                // On drag enter, we only can put a placeholder, since for security reasons, the content of the data-transfer is not available
+                this.move.initialX = this.dashboardParams.offsetLeft;
+                this.move.initialY = this.dashboardParams.offsetTop;
+                const target = this.getTarget($event, false);
+                this.currentlyModifiedManifest = {
+                    type: 'placeholder',
+                    layout: { x: target?.x ?? 0, y: target?.y ?? 0, width: 1, height: 1 }
+                };
+                this.initialWidgetManifestList = JSON.parse(JSON.stringify((this.manifest || { widgets: [] }).widgets));
+                // console.log('create placeholder', this.currentlyModifiedManifest, this.initialWidgetManifestList);
+                // We passed widget size as a mimetype so that we can still read it without security issues
+                const widgetSizeMimeType = types.find((type) => type.includes(MIME_TYPE_WIDGET_SIZE));
+                if (!!widgetSizeMimeType) {
+                    const [_, _2, w, h] = widgetSizeMimeType.split('-');
+                    this.currentlyModifiedManifest.layout.width = parseInt(w, 10);
+                    this.currentlyModifiedManifest.layout.height = parseInt(h, 10);
+                }
+                else {
+                    // Use grid size
+                    const layout = WidgetPlacementUtils.getLayoutSize(this.layout, this.dashboardParams)[this.initialWidgetManifestList.length];
+                    this.currentlyModifiedManifest.layout.width = layout.width;
+                    this.currentlyModifiedManifest.layout.height = layout.height;
+                }
+                // We passed the type as a header name so that we can still access it without security issues
+                const widgetType = types.find((type) => type.includes(MIME_TYPE_WIDGET_TYPE));
+                if (!!widgetType) {
+                    const [_, _2, type] = widgetType.split('-');
+                    this.currentlyModifiedManifest.type = type;
+                }
+                // Reset initial position for the one we just calculated, so we can continue properly move the widget
+                this.move.initialX = $event.pageX;
+                this.move.initialY = $event.pageY;
+            }
+        }
+    }
+    getTarget($event, optimize = true) {
+        const dX = $event.pageX - this.move.initialX;
+        const dY = $event.pageY - this.move.initialY;
+        const target = {
+            x: dX === 0
+                ? 0
+                : Math.round(((dX / Math.abs(dX)) * (Math.abs(dX) - 0.5 * this.dashboardParams.cellWidth)) /
+                    (this.dashboardParams.cellWidth + this.dashboardParams.gridGap)),
+            y: dY === 0
+                ? 0
+                : Math.round(((dY / Math.abs(dY)) * (Math.abs(dY) - 0.5 * this.dashboardParams.cellHeight)) /
+                    (this.dashboardParams.cellHeight + this.dashboardParams.gridGap))
+        };
+        if (!optimize || target.x !== this.move.previousX || target.y !== this.move.previousY) {
+            this.move.previousX = target.x;
+            this.move.previousY = target.y;
+            return target;
+        }
+        return null;
+    }
+    movingMouse($event, optimize = true) {
+        if (this.modeEdition && !!this.actionType) {
+            const target = this.getTarget($event, optimize);
+            if (target !== null) {
+                this.checkForDragEnter($event);
+                const candidateWidget = JSON.parse(JSON.stringify(this.currentlyModifiedManifest));
+                switch (this.actionType) {
+                    case 'resize-nw':
+                        if (candidateWidget.layout.x + target.x > 0 && candidateWidget.layout.height - target.y > 0) {
+                            candidateWidget.layout.x += target.x;
+                            candidateWidget.layout.y += target.y;
+                            candidateWidget.layout.width -= target.x;
+                            candidateWidget.layout.height -= target.y;
+                        }
+                        break;
+                    case 'resize-sw':
+                        if (candidateWidget.layout.width - target.x > 0) {
+                            candidateWidget.layout.x += target.x;
+                            candidateWidget.layout.width -= target.x;
+                            candidateWidget.layout.height += target.y;
+                        }
+                        break;
+                    case 'resize-ne':
+                        if (candidateWidget.layout.height - target.y > 0) {
+                            candidateWidget.layout.y += target.y;
+                            candidateWidget.layout.width += target.x;
+                            candidateWidget.layout.height -= target.y;
+                        }
+                        break;
+                    case 'resize-se':
+                        candidateWidget.layout.width += target.x;
+                        candidateWidget.layout.height += target.y;
+                        break;
+                    case 'move':
+                        const currentMaxX = Math.max(this.manifest?.grid?.columns ?? DEFAULT_COLUMNS_NUMBER, ...(this.manifest?.widgets ?? []).map((w) => w.layout.width + w.layout.x)) -
+                            candidateWidget.layout.width +
+                            1;
+                        candidateWidget.layout.x = Math.max(0, Math.min(candidateWidget.layout.x + target.x, currentMaxX));
+                        const currentMaxY = Math.max(this.manifest?.grid?.rows ?? DEFAULT_ROWS_NUMBER, ...(this.manifest?.widgets ?? []).map((w) => w.layout.height + w.layout.y)) -
+                            candidateWidget.layout.height +
+                            1;
+                        candidateWidget.layout.y = Math.max(0, Math.min(candidateWidget.layout.y + target.y, currentMaxY));
+                        break;
+                }
+                this.store.dispatch(DashboardActions.updateDashboardManifest({
+                    manifest: solveCollisions(candidateWidget, this.initialWidgetManifestList, this.manifest ?? {})
+                }));
+            }
+        }
+    }
+    dragMove($event) {
+        $event.stopPropagation();
+        $event.preventDefault();
+        this.movingMouse($event);
+    }
+    dragLeave($event) {
+        $event.stopPropagation();
+        $event.preventDefault();
+        // @ts-ignore
+        if ($event.currentTarget.contains($event.relatedTarget)) {
+            return;
+        }
+        const types = ($event.dataTransfer || { types: [''] }).types;
+        if (types.includes(MIME_TYPE_WIDGET_MANIFEST)) {
+            // As the drag is leaving the window, delete the widget from it, and stop edition mode
+            if (!!$event && !!$event.dataTransfer) {
+                this.store.dispatch(DashboardActions.updateDashboardManifest({
+                    manifest: {
+                        ...this.manifest,
+                        widgets: this.initialWidgetManifestList
+                    }
+                }));
+                this.clearActions();
+            }
+        }
+    }
+    dropping($event) {
+        $event.preventDefault();
+        $event.stopPropagation();
+        // @ts-ignore
+        if (!!$event && !!$event.dataTransfer) {
+            if ($event.dataTransfer.types.includes(MIME_TYPE_WIDGET_MANIFEST)) {
+                // Rearrange drop to correct size, type, ..., as a placeholder already been added to manifest by dragenter event
+                const dataTransferManifest = JSON.parse($event.dataTransfer.getData(MIME_TYPE_WIDGET_MANIFEST));
+                this.currentlyModifiedManifest = {
+                    ...dataTransferManifest,
+                    layout: this.currentlyModifiedManifest?.layout ?? {}
+                };
+                this.movingMouse($event, false);
+                this.store.dispatch(DashboardActions.assertResultSets({}));
+            }
+            this.clearActions();
+        }
+    }
+    clearActions() {
+        this.actionType = undefined;
+        this.move.initialX = 0;
+        this.move.initialY = 0;
+        this.move.previousX = -1;
+        this.move.previousY = -1;
+        this.currentlyModifiedManifest = null;
+        this.initialWidgetManifestList = [];
+    }
+    /***
+     * Manage other kinds of drops (inside widgets)
+     */
+    droppingInWidget($event, index) {
+        if (!!$event && !!$event.dataTransfer) {
+            if ($event.dataTransfer.types.includes(MIME_TYPE_RESULTSET)) {
+                const listWidgetManifests = [...(this.manifest || { widgets: [] }).widgets];
+                const resultSetName = $event.dataTransfer.getData(MIME_TYPE_RESULTSET);
+                const currentResultSet = (Array.isArray(listWidgetManifests[index].datasource)
+                    ? listWidgetManifests[index].datasource
+                    : [listWidgetManifests[index].datasource]);
+                const cumulative = $event.shiftKey;
+                const newResultSet = cumulative ? [...currentResultSet, resultSetName] : resultSetName;
+                listWidgetManifests[index] = {
+                    ...listWidgetManifests[index],
+                    datasource: newResultSet
+                };
+                this.store.dispatch(DashboardActions.updateDashboardManifest({
+                    manifest: {
+                        ...this.manifest,
+                        widgets: listWidgetManifests
+                    }
+                }));
+                this.store.dispatch(DashboardActions.assertResultSets({}));
+                $event.preventDefault();
+                $event.stopPropagation();
+            }
+        }
+    }
+    toggleRemoveConfirm($event, index) {
+        if (!this.confirmRemoveRef) {
+            this.indexForRemoval = index ?? -1;
+            this.confirmRemoveRef = this.overlay.create(new OverlayConfig({
+                hasBackdrop: true,
+                panelClass: ['o-modal-wrapper'],
+                backdropClass: 'backdrop'
+            }));
+            this.store.dispatch(ConfigActions.addingOverlay({ id: this.constructor.name + '-modal' }));
+            this.confirmRemoveRef.backdropClick().subscribe((_) => this.toggleRemoveConfirm());
+            this.confirmRemoveRef.attach(new TemplatePortal(this.templateModal, this.viewContainerRef));
+            if ($event) {
+                const panel = document.querySelector('div.o-modal-wrapper');
+                if (!!panel) {
+                    panel.style.left = Math.max(0, Math.min(window.innerWidth - panel.clientWidth, $event.clientX - 30)) + 'px';
+                    panel.style.top = Math.max(0, Math.min(window.innerHeight - panel.clientHeight, $event.clientY - 10)) + 'px';
+                }
+            }
+        }
+        else {
+            this.confirmRemoveRef.dispose();
+            this.confirmRemoveRef = undefined;
+            this.store.dispatch(ConfigActions.closeOverlay({ id: this.constructor.name + '-modal' }));
+        }
+    }
+    confirmRemove() {
+        this.remove(this.indexForRemoval);
+        this.cancelRemoveConfirm();
+    }
+    cancelRemoveConfirm() {
+        this.store.dispatch(ConfigActions.closeOverlay({ id: this.constructor.name + '-modal' }));
+        this.confirmRemoveRef?.dispose();
+        this.confirmRemoveRef = undefined;
+    }
+    trackWidgets(index, widgetManifest) {
+        return widgetManifest.type + '-' + widgetManifest.datasource;
+    }
+    updateInstance(widgetIndex, $event) {
+        this.widgetsInstances[widgetIndex] = $event;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: DashboardComponent, deps: [{ token: i1.Store }, { token: i2.Overlay }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: DashboardComponent, selector: "pry-dashboard", inputs: { staticDashboard: "staticDashboard", CloseOnDragOut: "CloseOnDragOut" }, outputs: { rowHeight: "rowHeight", rows: "rows" }, viewQueries: [{ propertyName: "templateModal", first: true, predicate: ["templateModal"], descendants: true, read: TemplateRef }, { propertyName: "gridRef", first: true, predicate: ["grid"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<div\n  class=\"o-dashboard-grid\"\n  [style.gridTemplateColumns]=\"gridTemplateColumns$ | async\"\n  [style.gridTemplateRows]=\"gridTemplateRows$ | async\"\n  [style.gridGap]=\"dashboardParams.gridGap + 'px'\"\n  #grid\n  (mousemove)=\"movingMouse($event)\"\n  (drop)=\"dropping($event)\"\n  (dragover)=\"dragMove($event)\"\n  (dragleave)=\"dragLeave($event)\"\n  (dragenter)=\"dragEnter($event)\"\n>\n  <ng-container\n    *ngFor=\"\n      let widgetManifest of (windowManifest$ | async)?.widgets || [];\n      let widgetIndex = index;\n      trackBy: trackWidgets\n    \"\n  >\n    <div\n      class=\"o-dashboard-widget\"\n      [class.-edited]=\"modeEdition\"\n      [style.gridColumn]=\"gridColumn(widgetManifest.layout)\"\n      [style.gridRow]=\"gridRow(widgetManifest.layout)\"\n      (drop)=\"droppingInWidget($event, widgetIndex)\"\n    >\n      <ng-container *ngIf=\"modeEdition\">\n        <div class=\"resize nw-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-nw')\">\n          <pry-icon iconSvg=\"north_west\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize sw-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-sw')\">\n          <pry-icon iconSvg=\"south_west\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize ne-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-ne')\">\n          <pry-icon iconSvg=\"north_east\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize se-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-se')\">\n          <pry-icon iconSvg=\"south_east\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize delete\" (mousedown)=\"toggleRemoveConfirm($event, widgetIndex)\">\n          <pry-icon iconSvg=\"close\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"move\" draggable=\"true\" (dragstart)=\"dragStart($event, widgetIndex)\">\n          <div class=\"move-inside move-{{ widgetManifest.type }}\">\n            <span>{{ widgetManifest.title ?? ('@pry.toolbox.' + widgetManifest.type | i18n) }}</span>\n          </div>\n        </div>\n      </ng-container>\n      <ng-container *ngIf=\"!modeEdition\">\n        <pry-widget-instanciator\n          [staticManifest]=\"widgetManifest\"\n          [widgetIndex]=\"widgetIndex\"\n          (widgetInstance)=\"updateInstance(widgetIndex, $event)\"\n        ></pry-widget-instanciator>\n      </ng-container>\n    </div>\n  </ng-container>\n\n  <ng-container *ngIf=\"(nonFillerWidgets$ | async) === 0\">\n    <div class=\"no-widget\" [style.grid-area]=\"backgroundArea$ | async\">\n      <img\n        class=\"no-widget__search\"\n        src=\"../../../assets/svgs/pry_recherche.svg\"\n        alt=\"{{\n          (layout === DashboardGridLayout.MANUAL ? '@pry.widget.target.none_manual' : '@pry.widget.target.none_auto')\n            | i18n\n        }} {{ backgroundArea$ | async }}\"\n      />\n      <span class=\"no-widget__text\">{{\n        (layout === DashboardGridLayout.MANUAL ? '@pry.widget.target.none_manual' : '@pry.widget.target.none_auto')\n          | i18n\n      }}</span>\n    </div>\n  </ng-container>\n</div>\n<pry-context-menu></pry-context-menu>\n\n<ng-template #templateModal>\n  <div class=\"o-modal\">\n    <div class=\"o-modal__top\">\n      <div class=\"o-modal__top__title\">\n        <h2 class=\"a-h2\" id=\"dialog_title\">\n          {{ '@pry.widget.modalTitle' | i18n }}\n        </h2>\n      </div>\n      <div class=\"o-modal__top__close\">\n        <button class=\"a-btn a-btn--icon-only\" (click)=\"cancelRemoveConfirm()\">\n          <pry-icon iconSvg=\"close\" [height]=\"35\" [width]=\"35\"></pry-icon>\n          <span class=\"u-visually-hidden\">{{ '@pry.toolbox.close' | i18n }}</span>\n        </button>\n      </div>\n    </div>\n    <div class=\"m-btn-group\">\n      <button type=\"button\" (click)=\"cancelRemoveConfirm()\" class=\"a-btn a-btn--secondary\">\n        {{ '@pry.toolbox.manifest.close' | i18n }}\n      </button>\n      <button type=\"submit\" (click)=\"confirmRemove()\" class=\"a-btn a-btn--primary\">\n        {{ '@pry.toolbox.manifest.validate' | i18n }}\n      </button>\n    </div>\n  </div>\n</ng-template>\n", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.PryIconComponent, selector: "pry-icon", inputs: ["color", "iconSvg", "animation", "iconImage", "alt", "width", "height", "classes"] }, { kind: "component", type: i5.WidgetInstanciatorComponent, selector: "pry-widget-instanciator", inputs: ["widgetIndex", "staticManifest", "standalone", "open$"], outputs: ["manifestModified", "widgetInstance"] }, { kind: "component", type: i6.ContextMenuComponent, selector: "pry-context-menu" }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i7.I18nPipe, name: "i18n" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: DashboardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pry-dashboard', template: "<div\n  class=\"o-dashboard-grid\"\n  [style.gridTemplateColumns]=\"gridTemplateColumns$ | async\"\n  [style.gridTemplateRows]=\"gridTemplateRows$ | async\"\n  [style.gridGap]=\"dashboardParams.gridGap + 'px'\"\n  #grid\n  (mousemove)=\"movingMouse($event)\"\n  (drop)=\"dropping($event)\"\n  (dragover)=\"dragMove($event)\"\n  (dragleave)=\"dragLeave($event)\"\n  (dragenter)=\"dragEnter($event)\"\n>\n  <ng-container\n    *ngFor=\"\n      let widgetManifest of (windowManifest$ | async)?.widgets || [];\n      let widgetIndex = index;\n      trackBy: trackWidgets\n    \"\n  >\n    <div\n      class=\"o-dashboard-widget\"\n      [class.-edited]=\"modeEdition\"\n      [style.gridColumn]=\"gridColumn(widgetManifest.layout)\"\n      [style.gridRow]=\"gridRow(widgetManifest.layout)\"\n      (drop)=\"droppingInWidget($event, widgetIndex)\"\n    >\n      <ng-container *ngIf=\"modeEdition\">\n        <div class=\"resize nw-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-nw')\">\n          <pry-icon iconSvg=\"north_west\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize sw-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-sw')\">\n          <pry-icon iconSvg=\"south_west\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize ne-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-ne')\">\n          <pry-icon iconSvg=\"north_east\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize se-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-se')\">\n          <pry-icon iconSvg=\"south_east\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize delete\" (mousedown)=\"toggleRemoveConfirm($event, widgetIndex)\">\n          <pry-icon iconSvg=\"close\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"move\" draggable=\"true\" (dragstart)=\"dragStart($event, widgetIndex)\">\n          <div class=\"move-inside move-{{ widgetManifest.type }}\">\n            <span>{{ widgetManifest.title ?? ('@pry.toolbox.' + widgetManifest.type | i18n) }}</span>\n          </div>\n        </div>\n      </ng-container>\n      <ng-container *ngIf=\"!modeEdition\">\n        <pry-widget-instanciator\n          [staticManifest]=\"widgetManifest\"\n          [widgetIndex]=\"widgetIndex\"\n          (widgetInstance)=\"updateInstance(widgetIndex, $event)\"\n        ></pry-widget-instanciator>\n      </ng-container>\n    </div>\n  </ng-container>\n\n  <ng-container *ngIf=\"(nonFillerWidgets$ | async) === 0\">\n    <div class=\"no-widget\" [style.grid-area]=\"backgroundArea$ | async\">\n      <img\n        class=\"no-widget__search\"\n        src=\"../../../assets/svgs/pry_recherche.svg\"\n        alt=\"{{\n          (layout === DashboardGridLayout.MANUAL ? '@pry.widget.target.none_manual' : '@pry.widget.target.none_auto')\n            | i18n\n        }} {{ backgroundArea$ | async }}\"\n      />\n      <span class=\"no-widget__text\">{{\n        (layout === DashboardGridLayout.MANUAL ? '@pry.widget.target.none_manual' : '@pry.widget.target.none_auto')\n          | i18n\n      }}</span>\n    </div>\n  </ng-container>\n</div>\n<pry-context-menu></pry-context-menu>\n\n<ng-template #templateModal>\n  <div class=\"o-modal\">\n    <div class=\"o-modal__top\">\n      <div class=\"o-modal__top__title\">\n        <h2 class=\"a-h2\" id=\"dialog_title\">\n          {{ '@pry.widget.modalTitle' | i18n }}\n        </h2>\n      </div>\n      <div class=\"o-modal__top__close\">\n        <button class=\"a-btn a-btn--icon-only\" (click)=\"cancelRemoveConfirm()\">\n          <pry-icon iconSvg=\"close\" [height]=\"35\" [width]=\"35\"></pry-icon>\n          <span class=\"u-visually-hidden\">{{ '@pry.toolbox.close' | i18n }}</span>\n        </button>\n      </div>\n    </div>\n    <div class=\"m-btn-group\">\n      <button type=\"button\" (click)=\"cancelRemoveConfirm()\" class=\"a-btn a-btn--secondary\">\n        {{ '@pry.toolbox.manifest.close' | i18n }}\n      </button>\n      <button type=\"submit\" (click)=\"confirmRemove()\" class=\"a-btn a-btn--primary\">\n        {{ '@pry.toolbox.manifest.validate' | i18n }}\n      </button>\n    </div>\n  </div>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Overlay }, { type: i0.ViewContainerRef }]; }, propDecorators: { templateModal: [{
+                type: ViewChild,
+                args: ['templateModal', { read: TemplateRef }]
+            }], staticDashboard: [{
+                type: Input
+            }], CloseOnDragOut: [{
+                type: Input
+            }], gridRef: [{
+                type: ViewChild,
+                args: ['grid']
+            }], rowHeight: [{
+                type: Output
+            }], rows: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.component.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/lib/dashboard/components/dashboard.component.ts","../../../../../../../projects/provoly/dashboard/lib/dashboard/components/dashboard.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Overlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  Output,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef\n} from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport equal from 'fast-deep-equal/es6';\nimport {\n  auditTime,\n  BehaviorSubject,\n  combineLatest,\n  combineLatestWith,\n  fromEvent,\n  Observable,\n  of,\n  switchMap\n} from 'rxjs';\nimport { distinctUntilChanged, filter, map } from 'rxjs/operators';\nimport {\n  DashboardGridLayout,\n  DashboardManifest,\n  WidgetLayout,\n  WidgetManifest\n} from '../../core/model/manifest.interface';\nimport { MIME_TYPE_RESULTSET } from '../../core/model/mimetype-resultset.constant';\nimport { CategoryActions } from '../../core/store/category/category.actions';\nimport { ClassActions } from '../../core/store/class/class.actions';\nimport { ConfigActions } from '../../core/store/config/config.actions';\nimport { ConfigSelectors } from '../../core/store/config/config.selectors';\nimport { DataSourceActions } from '../../core/store/data-source/data-source.actions';\nimport { FieldActions } from '../../core/store/field/field.actions';\nimport { RelationTypesActions } from '../../core/store/relation-types/relation-types.actions';\nimport { WidgetPlacementUtils } from '../components/widgets/widget-placement/widget-placement.utils';\nimport { DashboardActions, DashboardCellParams } from '../store/dashboard.actions';\nimport {\n  DEFAULT_COLUMNS_NUMBER,\n  DEFAULT_GAP_PX,\n  DEFAULT_ROW_HEIGHT_PX,\n  DEFAULT_ROWS_NUMBER\n} from '../store/dashboard.contants';\nimport { DashboardSelectors } from '../store/dashboard.selectors';\nimport { solveCollisions } from './solve-collisions.function';\nimport { SubscriptionnerDirective } from './subscriptionner.directive';\nimport { BaseWidgetComponent } from './widgets/base-widget.component';\n\nexport const MIME_TYPE_WIDGET_MANIFEST = 'application/widget-manifest';\nexport const MIME_TYPE_WIDGET_TYPE = 'application/widget-type-';\nexport const MIME_TYPE_WIDGET_SIZE = 'application/widget-size-';\n\n@Component({\n  selector: 'pry-dashboard',\n  templateUrl: './dashboard.component.html'\n})\nexport class DashboardComponent extends SubscriptionnerDirective implements AfterViewInit {\n  manifest: DashboardManifest | null = null;\n  windowManifest$: Observable<DashboardManifest>;\n  modeEdition = false;\n  modeEdition$: Observable<boolean>;\n  actionType: string | undefined;\n  staticDashboard$: BehaviorSubject<DashboardManifest | null> = new BehaviorSubject<DashboardManifest | null>(null);\n  stacked$ = new BehaviorSubject<boolean>(false);\n  indexForRemoval: number = -1;\n  @ViewChild('templateModal', { read: TemplateRef }) templateModal!: TemplateRef<any>;\n  separators$: Observable<WidgetLayout[]>;\n  nonFillerWidgets$: Observable<number>;\n  widgetsInstances: Array<BaseWidgetComponent> = [];\n\n  @Input() set staticDashboard(window: DashboardManifest) {\n    this.staticDashboard$.next(window);\n  }\n\n  @Input() CloseOnDragOut = true;\n\n  @ViewChild('grid') gridRef!: ElementRef;\n  private canCalculateView = false;\n  targetIndexes$: Observable<number[]>;\n  dashboardParams: DashboardCellParams = {\n    gridWidth: 1,\n    gridHeight: 1,\n    gridGap: DEFAULT_GAP_PX,\n    columns: DEFAULT_COLUMNS_NUMBER,\n    cellWidth: 1,\n    cellHeight: DEFAULT_ROW_HEIGHT_PX,\n    rows: DEFAULT_ROWS_NUMBER,\n    offsetLeft: 0,\n    offsetTop: 0,\n    mobileMode: false\n  };\n  private breakpoint: number = 0;\n  @Output() rowHeight = new EventEmitter<number>();\n  @Output() rows = new EventEmitter<number>();\n  currentlyModifiedManifest: WidgetManifest | null = null;\n  initialWidgetManifestList: WidgetManifest[] = [];\n  move: {\n    initialX: number;\n    initialY: number;\n    previousX: number;\n    previousY: number;\n  } = {\n    initialX: -1,\n    initialY: -1,\n    previousX: -1,\n    previousY: -1\n  };\n  gridTemplateRows$: Observable<string>;\n  gridTemplateColumns$: Observable<string>;\n  DashboardGridLayout = DashboardGridLayout;\n  layout: DashboardGridLayout = DashboardGridLayout.MANUAL;\n  backgroundArea$: Observable<string>;\n  private confirmRemoveRef?: OverlayRef;\n  Array: any;\n\n  constructor(\n    private store: Store<any>,\n    private overlay: Overlay,\n    private viewContainerRef: ViewContainerRef\n  ) {\n    super();\n    this.modeEdition$ = this.store.select(DashboardSelectors.dashboardEditionMode);\n    this.subscriptions.add(\n      this.modeEdition$.subscribe((mode) => {\n        this.modeEdition = mode;\n        if (!mode) {\n          this.clearActions();\n        }\n      })\n    );\n    this.targetIndexes$ = this.store.select(DashboardSelectors.targetTenantsIndexes);\n    this.subscriptions.add(\n      this.store.select(DashboardSelectors.dashboardCellParams).subscribe((params) => (this.dashboardParams = params))\n    );\n    this.windowManifest$ = this.store.select(DashboardSelectors.windowManifest).pipe(\n      combineLatestWith(this.staticDashboard$),\n      switchMap(([windowManifest, staticDashboard]) => (!staticDashboard ? of(windowManifest) : of(staticDashboard))),\n      distinctUntilChanged((p, c) => equal(p, c)),\n      map((_wManifest) => {\n        const wManifest = JSON.parse(JSON.stringify(_wManifest));\n        if (wManifest.grid?.layout && wManifest.grid.layout !== DashboardGridLayout.MANUAL) {\n          // Complete with placeholders\n          const size = WidgetPlacementUtils.placesForLayout(wManifest.grid.layout);\n          const places = WidgetPlacementUtils.placementOptions(\n            { type: 'filler', layout: { x: 1, y: 1, width: 1, height: 1 } },\n            wManifest.grid.layout,\n            wManifest.grid\n          );\n          let added = true;\n          while (wManifest.widgets.length < size && added) {\n            added = false;\n            for (let i = 0; i < places.length; i++) {\n              const potential = { ...places[i], options: { index: i } };\n              if (\n                wManifest.widgets\n                  .map((widget: WidgetManifest) => WidgetPlacementUtils.areDisjoint(widget, potential))\n                  .reduce((a: boolean, b: boolean) => a && b, true)\n              ) {\n                wManifest.widgets.push(potential);\n                added = true;\n                break;\n              }\n            }\n          }\n        }\n        return wManifest;\n      })\n    );\n    this.nonFillerWidgets$ = this.windowManifest$.pipe(\n      map((wManifest) => wManifest.widgets.filter((w) => w.type !== 'filler').length)\n    );\n\n    this.subscriptions.add(\n      this.staticDashboard$.subscribe((manifest) => {\n        if (!!manifest) {\n          const getDataActions = (\n            (\n              [\n                ...new Set(\n                  (manifest.widgets ?? ([] as WidgetManifest[]))\n                    .reduce((p, c) => [...p, c], [] as WidgetManifest[])\n                    .map((widManifest) => widManifest.datasource)\n                )\n              ] as (string | string[])[]\n            ).reduce((p, c) => [...p, ...(Array.isArray(c) ? c : [c])], []) as string[]\n          ).map((resultSet) => DashboardActions.assertResultSets({ id: resultSet }));\n\n          getDataActions.forEach((action) => this.store.dispatch(action));\n        }\n      })\n    );\n\n    this.store.dispatch(FieldActions.load());\n    this.store.dispatch(ClassActions.load());\n    this.store.dispatch(CategoryActions.load());\n    this.store.dispatch(ConfigActions.getMapStyles());\n    this.store.dispatch(DataSourceActions.load());\n    this.store.dispatch(RelationTypesActions.load());\n    this.store.dispatch(ConfigActions.loadCustomization());\n\n    this.subscriptions.add(\n      fromEvent(window, 'resize')\n        .pipe(auditTime(100))\n        .subscribe(() => {\n          this.calculateView();\n        })\n    );\n\n    this.subscriptions.add(\n      combineLatest([this.windowManifest$, this.modeEdition$])\n        .pipe(auditTime(100))\n        .subscribe(() => {\n          this.calculateView();\n        })\n    );\n\n    this.subscriptions.add(\n      fromEvent(window, 'keydown')\n        .pipe(\n          map(($event: Event) => $event as KeyboardEvent),\n          filter(($event: KeyboardEvent) => $event.key === 'L' && $event.ctrlKey && $event.shiftKey)\n        )\n        .subscribe(() => this.store.dispatch(DashboardActions.toggleEditionMode({})))\n    );\n\n    this.subscriptions.add(\n      fromEvent(window, 'mouseup').subscribe(() => {\n        this.clearActions();\n      })\n    );\n\n    this.subscriptions.add(\n      this.store.select(ConfigSelectors.breakpoint).subscribe((bp) => {\n        this.breakpoint = bp;\n      })\n    );\n\n    this.subscriptions.add(\n      this.windowManifest$.subscribe((manifest) => {\n        this.manifest = manifest;\n      })\n    );\n\n    this.subscriptions.add(\n      this.store.select(DashboardSelectors.gridLayout).subscribe((layout) => {\n        this.layout = layout;\n      })\n    );\n\n    this.gridTemplateRows$ = combineLatest([this.windowManifest$, this.stacked$]).pipe(\n      map(([manifest, stacked]) =>\n        this.generateRows(\n          stacked && this.manifest\n            ? this.manifest?.widgets.map((wm) => wm.layout.height).reduce((wm1, wm2) => wm1 + wm2, 0)\n            : manifest.grid?.rows ?? DEFAULT_ROWS_NUMBER\n        )\n      )\n    );\n\n    this.gridTemplateColumns$ = combineLatest([this.windowManifest$, this.stacked$]).pipe(\n      map(([manifest, stacked]) => this.generateColumns(stacked ? 1 : manifest.grid?.columns || DEFAULT_COLUMNS_NUMBER))\n    );\n\n    this.backgroundArea$ = combineLatest([this.windowManifest$, this.stacked$]).pipe(\n      map(([manifest, stacked]) =>\n        !stacked\n          ? `3/3/${(manifest.grid?.rows ?? DEFAULT_ROWS_NUMBER) - 1}/${\n              (manifest.grid?.columns ?? DEFAULT_COLUMNS_NUMBER) - 1\n            }`\n          : `3/1/${(manifest.grid?.columns ?? DEFAULT_COLUMNS_NUMBER) - 1}/1`\n      )\n    );\n\n    this.separators$ = this.store\n      .select(DashboardSelectors.gridLayout)\n      .pipe(\n        map((layout) =>\n          layout === DashboardGridLayout.MANUAL\n            ? []\n            : WidgetPlacementUtils.getLayoutSize(layout, { rows: 1, columns: 1 })\n        )\n      );\n  }\n\n  ngAfterViewInit() {\n    this.canCalculateView = true;\n  }\n\n  /***\n   * Manage display\n   */\n\n  calculateView() {\n    if (this.canCalculateView) {\n      let element = this.gridRef.nativeElement;\n      while (element.getBoundingClientRect().height === 0 && !!element.parentElement) {\n        element = element.parentElement;\n      }\n\n      const gridWidth = (<HTMLElement>element).getBoundingClientRect().width;\n      const mobileMode = gridWidth < this.breakpoint;\n      this.stacked$.next(this.dashboardParams.mobileMode && !this.modeEdition);\n      const rows = !this.displayIsStacked\n        ? (!!this.manifest && !!this.manifest.grid && this.manifest.grid.rows) || DEFAULT_ROWS_NUMBER\n        : this.manifest?.widgets.reduce((p: number, c: WidgetManifest) => p + c.layout.height, 0) ?? 1;\n\n      const params = {\n        gridWidth,\n        // Calculate height to parennt the parent's\n        gridHeight: element.getBoundingClientRect().height,\n        gridGap: 1,\n        columns: (!!this.manifest && !!this.manifest.grid && this.manifest.grid.columns) || DEFAULT_COLUMNS_NUMBER,\n        cellHeight: 1,\n        rows,\n        cellWidth: 0,\n        offsetLeft: this.gridRef.nativeElement.offsetLeft,\n        offsetTop: this.gridRef.nativeElement.offsetTop,\n        mobileMode\n      };\n      params.gridGap =\n        params.rows * params.cellHeight < params.gridHeight\n          ? !!this.manifest && !!this.manifest.grid\n            ? this.manifest.grid.gap || DEFAULT_GAP_PX\n            : DEFAULT_GAP_PX\n          : 0;\n      params.cellHeight = (params.gridHeight - (params.rows - 1) * params.gridGap) / params.rows;\n      params.cellWidth = (params.gridWidth - (params.columns - 1) * params.gridGap) / params.columns;\n\n      this.store.dispatch(DashboardActions.updateDashboardParams({ params }));\n\n      this.rows.next(params.rows);\n      this.rowHeight.next(params.cellHeight);\n    }\n  }\n\n  get displayIsStacked() {\n    return this.stacked$.getValue();\n  }\n\n  gridColumn(layout: WidgetLayout): string {\n    if (this.displayIsStacked || !layout) {\n      return '1 / 1';\n    }\n    if (layout.width > 1) {\n      return `${Math.min(layout.x, this.dashboardParams.columns - layout.width + 1)} / ${Math.min(\n        layout.x + layout.width,\n        this.dashboardParams.columns + 1\n      )}`;\n    } else {\n      return `${layout.x}`;\n    }\n  }\n\n  gridRow(layout: WidgetLayout): string {\n    if (!layout) {\n      return '1';\n    }\n    if (this.displayIsStacked) {\n      const previousHeight = this.manifest?.widgets\n        .filter((wm: WidgetManifest) => (wm.layout.y === layout.y && wm.layout.x < layout.x) || wm.layout.y < layout.y)\n        .reduce((p: number, c: WidgetManifest) => p + c.layout.height, 1);\n      return `${previousHeight ?? 1} / ${(previousHeight ?? 1) + layout.height}`;\n    }\n    if (layout.height > 1) {\n      return `${Math.max(1, Math.min(layout.y, this.dashboardParams.rows - layout.height + 1))} / ${Math.min(\n        layout.y + layout.height,\n        this.dashboardParams.rows + 1\n      )}`;\n    } else {\n      return `${layout.y}`;\n    }\n  }\n\n  generateRows(rows: number): string {\n    return Array(rows).fill('1fr').join(' ');\n  }\n\n  generateColumns(columns: number): string {\n    return Array(columns).fill('1fr').join(' ');\n  }\n\n  /***\n   * Direct actions on widgets\n   */\n\n  remove(i: number) {\n    const listWidgetManifests = [...(this.manifest || { widgets: [] }).widgets];\n    listWidgetManifests.splice(i, 1).filter((widget) => widget.type !== 'filler');\n\n    this.store.dispatch(\n      DashboardActions.updateDashboardManifest({\n        manifest: {\n          ...this.manifest,\n          widgets: listWidgetManifests\n        }\n      })\n    );\n  }\n\n  moveInNewWindow(widgetIndex: number, targetIndex: number) {\n    this.store.dispatch(DashboardActions.moveWidget({ widgetIndex, targetIndex }));\n    this.store.dispatch(DashboardActions.toggleEditionMode({ force: false }));\n  }\n\n  maximize(widgetIndex: number) {\n    this.store.dispatch(DashboardActions.maximizeWidget({ widgetIndex }));\n  }\n\n  /***\n   * Manage drag n drop, move, resize\n   */\n\n  prepareModification($event: MouseEvent, indexManifest: number) {\n    this.move.initialX = $event.clientX;\n    this.move.initialY = $event.clientY;\n    this.initialWidgetManifestList = JSON.parse(JSON.stringify((this.manifest || { widgets: [] }).widgets));\n    this.currentlyModifiedManifest = this.initialWidgetManifestList.splice(indexManifest, 1)[0];\n    // console.log('prepare', this.currentlyModifiedManifest, this.initialWidgetManifestList);\n  }\n\n  startResize($event: MouseEvent, indexManifest: number, direction: string) {\n    this.actionType = direction;\n    this.prepareModification($event, indexManifest);\n    // console.log('start resize', this.currentlyModifiedManifest, this.initialWidgetManifestList);\n  }\n\n  dragStart($event: DragEvent, indexManifest: number) {\n    this.actionType = 'move';\n    this.prepareModification($event, indexManifest);\n    DashboardComponent.addTransferManifestMetadata($event, this.currentlyModifiedManifest ?? ({} as WidgetManifest));\n    // console.log('start move', this.currentlyModifiedManifest, this.initialWidgetManifestList);\n  }\n\n  private static addTransferManifestMetadata($event: DragEvent, manifest: WidgetManifest) {\n    if (!!$event && !!$event.dataTransfer && !$event.dataTransfer.types.includes(MIME_TYPE_WIDGET_MANIFEST)) {\n      $event.dataTransfer.setData(MIME_TYPE_WIDGET_MANIFEST, JSON.stringify(manifest));\n      $event.dataTransfer.setData(MIME_TYPE_WIDGET_TYPE + manifest.type, 'unused');\n      // Passing widget size as a mime type, so that we can bypass security for placeholder size at the arrival of the drag\n      $event.dataTransfer.setData(\n        MIME_TYPE_WIDGET_SIZE + `${manifest.layout.width}-${manifest.layout.height}`,\n        'useless' // data is in the mime type\n      );\n    }\n  }\n\n  dragEnter($event: DragEvent, force: boolean = false) {\n    $event.stopPropagation();\n    $event.preventDefault();\n\n    const types = ($event.dataTransfer || { types: [''] }).types;\n\n    if (types.includes(MIME_TYPE_WIDGET_MANIFEST)) {\n      this.store.dispatch(DashboardActions.toggleEditionMode({ force: true }));\n      this.actionType = 'move';\n    }\n  }\n\n  checkForDragEnter($event: MouseEvent) {\n    if (!this.currentlyModifiedManifest) {\n      // create placeholder as a drag entered the component, go into edition mode and move action if it's a widget being dragged\n      const types = (($event as DragEvent).dataTransfer || { types: [''] }).types;\n      if (types.includes(MIME_TYPE_WIDGET_MANIFEST)) {\n        this.actionType = 'move';\n        this.store.dispatch(DashboardActions.toggleEditionMode({ force: true }));\n\n        // On drag enter, we only can put a placeholder, since for security reasons, the content of the data-transfer is not available\n        this.move.initialX = this.dashboardParams.offsetLeft;\n        this.move.initialY = this.dashboardParams.offsetTop;\n        const target = this.getTarget($event, false);\n        this.currentlyModifiedManifest = {\n          type: 'placeholder',\n          layout: { x: target?.x ?? 0, y: target?.y ?? 0, width: 1, height: 1 }\n        };\n        this.initialWidgetManifestList = JSON.parse(JSON.stringify((this.manifest || { widgets: [] }).widgets));\n        // console.log('create placeholder', this.currentlyModifiedManifest, this.initialWidgetManifestList);\n\n        // We passed widget size as a mimetype so that we can still read it without security issues\n        const widgetSizeMimeType = types.find((type) => type.includes(MIME_TYPE_WIDGET_SIZE));\n        if (!!widgetSizeMimeType) {\n          const [_, _2, w, h] = widgetSizeMimeType.split('-');\n          this.currentlyModifiedManifest.layout.width = parseInt(w, 10);\n          this.currentlyModifiedManifest.layout.height = parseInt(h, 10);\n        } else {\n          // Use grid size\n          const layout = WidgetPlacementUtils.getLayoutSize(this.layout, this.dashboardParams)[\n            this.initialWidgetManifestList.length\n          ];\n          this.currentlyModifiedManifest.layout.width = layout.width;\n          this.currentlyModifiedManifest.layout.height = layout.height;\n        }\n\n        // We passed the type as a header name so that we can still access it without security issues\n        const widgetType = types.find((type) => type.includes(MIME_TYPE_WIDGET_TYPE));\n        if (!!widgetType) {\n          const [_, _2, type] = widgetType.split('-');\n          this.currentlyModifiedManifest.type = type;\n        }\n\n        // Reset initial position for the one we just calculated, so we can continue properly move the widget\n        this.move.initialX = $event.pageX;\n        this.move.initialY = $event.pageY;\n      }\n    }\n  }\n\n  getTarget($event: MouseEvent, optimize = true) {\n    const dX = $event.pageX - this.move.initialX;\n    const dY = $event.pageY - this.move.initialY;\n\n    const target = {\n      x:\n        dX === 0\n          ? 0\n          : Math.round(\n              ((dX / Math.abs(dX)) * (Math.abs(dX) - 0.5 * this.dashboardParams.cellWidth)) /\n                (this.dashboardParams.cellWidth + this.dashboardParams.gridGap)\n            ),\n      y:\n        dY === 0\n          ? 0\n          : Math.round(\n              ((dY / Math.abs(dY)) * (Math.abs(dY) - 0.5 * this.dashboardParams.cellHeight)) /\n                (this.dashboardParams.cellHeight + this.dashboardParams.gridGap)\n            )\n    };\n\n    if (!optimize || target.x !== this.move.previousX || target.y !== this.move.previousY) {\n      this.move.previousX = target.x;\n      this.move.previousY = target.y;\n      return target;\n    }\n\n    return null;\n  }\n\n  movingMouse($event: MouseEvent, optimize = true) {\n    if (this.modeEdition && !!this.actionType) {\n      const target = this.getTarget($event, optimize);\n      if (target !== null) {\n        this.checkForDragEnter($event);\n        const candidateWidget = JSON.parse(JSON.stringify(this.currentlyModifiedManifest));\n\n        switch (this.actionType) {\n          case 'resize-nw':\n            if (candidateWidget.layout.x + target.x > 0 && candidateWidget.layout.height - target.y > 0) {\n              candidateWidget.layout.x += target.x;\n              candidateWidget.layout.y += target.y;\n              candidateWidget.layout.width -= target.x;\n              candidateWidget.layout.height -= target.y;\n            }\n            break;\n          case 'resize-sw':\n            if (candidateWidget.layout.width - target.x > 0) {\n              candidateWidget.layout.x += target.x;\n              candidateWidget.layout.width -= target.x;\n              candidateWidget.layout.height += target.y;\n            }\n            break;\n          case 'resize-ne':\n            if (candidateWidget.layout.height - target.y > 0) {\n              candidateWidget.layout.y += target.y;\n              candidateWidget.layout.width += target.x;\n              candidateWidget.layout.height -= target.y;\n            }\n            break;\n          case 'resize-se':\n            candidateWidget.layout.width += target.x;\n            candidateWidget.layout.height += target.y;\n            break;\n          case 'move':\n            const currentMaxX =\n              Math.max(\n                this.manifest?.grid?.columns ?? DEFAULT_COLUMNS_NUMBER,\n                ...(this.manifest?.widgets ?? []).map((w) => w.layout.width + w.layout.x)\n              ) -\n              candidateWidget.layout.width +\n              1;\n            candidateWidget.layout.x = Math.max(0, Math.min(candidateWidget.layout.x + target.x, currentMaxX));\n\n            const currentMaxY =\n              Math.max(\n                this.manifest?.grid?.rows ?? DEFAULT_ROWS_NUMBER,\n                ...(this.manifest?.widgets ?? []).map((w) => w.layout.height + w.layout.y)\n              ) -\n              candidateWidget.layout.height +\n              1;\n            candidateWidget.layout.y = Math.max(0, Math.min(candidateWidget.layout.y + target.y, currentMaxY));\n            break;\n        }\n\n        this.store.dispatch(\n          DashboardActions.updateDashboardManifest({\n            manifest: solveCollisions(\n              candidateWidget,\n              this.initialWidgetManifestList,\n              this.manifest ?? ({} as DashboardManifest)\n            )\n          })\n        );\n      }\n    }\n  }\n\n  dragMove($event: DragEvent) {\n    $event.stopPropagation();\n    $event.preventDefault();\n\n    this.movingMouse($event);\n  }\n\n  dragLeave($event: DragEvent) {\n    $event.stopPropagation();\n    $event.preventDefault();\n\n    // @ts-ignore\n    if ($event.currentTarget.contains($event.relatedTarget)) {\n      return;\n    }\n\n    const types = ($event.dataTransfer || { types: [''] }).types;\n    if (types.includes(MIME_TYPE_WIDGET_MANIFEST)) {\n      // As the drag is leaving the window, delete the widget from it, and stop edition mode\n      if (!!$event && !!$event.dataTransfer) {\n        this.store.dispatch(\n          DashboardActions.updateDashboardManifest({\n            manifest: {\n              ...this.manifest,\n              widgets: this.initialWidgetManifestList\n            }\n          })\n        );\n        this.clearActions();\n      }\n    }\n  }\n\n  dropping($event: DragEvent) {\n    $event.preventDefault();\n    $event.stopPropagation();\n\n    // @ts-ignore\n    if (!!$event && !!$event.dataTransfer) {\n      if ($event.dataTransfer.types.includes(MIME_TYPE_WIDGET_MANIFEST)) {\n        // Rearrange drop to correct size, type, ..., as a placeholder already been added to manifest by dragenter event\n        const dataTransferManifest = JSON.parse(\n          $event.dataTransfer.getData(MIME_TYPE_WIDGET_MANIFEST)\n        ) as WidgetManifest;\n\n        this.currentlyModifiedManifest = {\n          ...dataTransferManifest,\n          layout: this.currentlyModifiedManifest?.layout ?? ({} as WidgetLayout)\n        };\n\n        this.movingMouse($event, false);\n\n        this.store.dispatch(DashboardActions.assertResultSets({}));\n      }\n\n      this.clearActions();\n    }\n  }\n\n  clearActions() {\n    this.actionType = undefined;\n    this.move.initialX = 0;\n    this.move.initialY = 0;\n    this.move.previousX = -1;\n    this.move.previousY = -1;\n    this.currentlyModifiedManifest = null;\n    this.initialWidgetManifestList = [];\n  }\n\n  /***\n   * Manage other kinds of drops (inside widgets)\n   */\n  droppingInWidget($event: DragEvent, index: number) {\n    if (!!$event && !!$event.dataTransfer) {\n      if ($event.dataTransfer.types.includes(MIME_TYPE_RESULTSET)) {\n        const listWidgetManifests = [...(this.manifest || { widgets: [] }).widgets];\n\n        const resultSetName = $event.dataTransfer.getData(MIME_TYPE_RESULTSET);\n        const currentResultSet = (\n          Array.isArray(listWidgetManifests[index].datasource)\n            ? listWidgetManifests[index].datasource\n            : [listWidgetManifests[index].datasource]\n        ) as string[];\n        const cumulative = $event.shiftKey;\n        const newResultSet = cumulative ? [...currentResultSet, resultSetName] : resultSetName;\n\n        listWidgetManifests[index] = {\n          ...listWidgetManifests[index],\n          datasource: newResultSet\n        };\n\n        this.store.dispatch(\n          DashboardActions.updateDashboardManifest({\n            manifest: {\n              ...this.manifest,\n              widgets: listWidgetManifests\n            }\n          })\n        );\n        this.store.dispatch(DashboardActions.assertResultSets({}));\n        $event.preventDefault();\n        $event.stopPropagation();\n      }\n    }\n  }\n\n  toggleRemoveConfirm($event?: MouseEvent, index?: number) {\n    if (!this.confirmRemoveRef) {\n      this.indexForRemoval = index ?? -1;\n      this.confirmRemoveRef = this.overlay.create(\n        new OverlayConfig({\n          hasBackdrop: true,\n          panelClass: ['o-modal-wrapper'],\n          backdropClass: 'backdrop'\n        })\n      );\n      this.store.dispatch(ConfigActions.addingOverlay({ id: this.constructor.name + '-modal' }));\n      this.confirmRemoveRef.backdropClick().subscribe((_) => this.toggleRemoveConfirm());\n      this.confirmRemoveRef.attach(new TemplatePortal(this.templateModal, this.viewContainerRef));\n      if ($event) {\n        const panel = document.querySelector('div.o-modal-wrapper') as HTMLDivElement;\n        if (!!panel) {\n          panel.style.left = Math.max(0, Math.min(window.innerWidth - panel.clientWidth, $event.clientX - 30)) + 'px';\n          panel.style.top = Math.max(0, Math.min(window.innerHeight - panel.clientHeight, $event.clientY - 10)) + 'px';\n        }\n      }\n    } else {\n      this.confirmRemoveRef.dispose();\n      this.confirmRemoveRef = undefined;\n      this.store.dispatch(ConfigActions.closeOverlay({ id: this.constructor.name + '-modal' }));\n    }\n  }\n\n  confirmRemove() {\n    this.remove(this.indexForRemoval);\n    this.cancelRemoveConfirm();\n  }\n\n  cancelRemoveConfirm() {\n    this.store.dispatch(ConfigActions.closeOverlay({ id: this.constructor.name + '-modal' }));\n    this.confirmRemoveRef?.dispose();\n    this.confirmRemoveRef = undefined;\n  }\n\n  trackWidgets(index: number, widgetManifest: WidgetManifest) {\n    return widgetManifest.type + '-' + widgetManifest.datasource;\n  }\n\n  updateInstance(widgetIndex: number, $event: BaseWidgetComponent) {\n    this.widgetsInstances[widgetIndex] = $event;\n  }\n}\n","<div\n  class=\"o-dashboard-grid\"\n  [style.gridTemplateColumns]=\"gridTemplateColumns$ | async\"\n  [style.gridTemplateRows]=\"gridTemplateRows$ | async\"\n  [style.gridGap]=\"dashboardParams.gridGap + 'px'\"\n  #grid\n  (mousemove)=\"movingMouse($event)\"\n  (drop)=\"dropping($event)\"\n  (dragover)=\"dragMove($event)\"\n  (dragleave)=\"dragLeave($event)\"\n  (dragenter)=\"dragEnter($event)\"\n>\n  <ng-container\n    *ngFor=\"\n      let widgetManifest of (windowManifest$ | async)?.widgets || [];\n      let widgetIndex = index;\n      trackBy: trackWidgets\n    \"\n  >\n    <div\n      class=\"o-dashboard-widget\"\n      [class.-edited]=\"modeEdition\"\n      [style.gridColumn]=\"gridColumn(widgetManifest.layout)\"\n      [style.gridRow]=\"gridRow(widgetManifest.layout)\"\n      (drop)=\"droppingInWidget($event, widgetIndex)\"\n    >\n      <ng-container *ngIf=\"modeEdition\">\n        <div class=\"resize nw-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-nw')\">\n          <pry-icon iconSvg=\"north_west\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize sw-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-sw')\">\n          <pry-icon iconSvg=\"south_west\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize ne-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-ne')\">\n          <pry-icon iconSvg=\"north_east\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize se-resize\" (mousedown)=\"startResize($event, widgetIndex, 'resize-se')\">\n          <pry-icon iconSvg=\"south_east\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"resize delete\" (mousedown)=\"toggleRemoveConfirm($event, widgetIndex)\">\n          <pry-icon iconSvg=\"close\" [animation]=\"false\"></pry-icon>\n        </div>\n        <div class=\"move\" draggable=\"true\" (dragstart)=\"dragStart($event, widgetIndex)\">\n          <div class=\"move-inside move-{{ widgetManifest.type }}\">\n            <span>{{ widgetManifest.title ?? ('@pry.toolbox.' + widgetManifest.type | i18n) }}</span>\n          </div>\n        </div>\n      </ng-container>\n      <ng-container *ngIf=\"!modeEdition\">\n        <pry-widget-instanciator\n          [staticManifest]=\"widgetManifest\"\n          [widgetIndex]=\"widgetIndex\"\n          (widgetInstance)=\"updateInstance(widgetIndex, $event)\"\n        ></pry-widget-instanciator>\n      </ng-container>\n    </div>\n  </ng-container>\n\n  <ng-container *ngIf=\"(nonFillerWidgets$ | async) === 0\">\n    <div class=\"no-widget\" [style.grid-area]=\"backgroundArea$ | async\">\n      <img\n        class=\"no-widget__search\"\n        src=\"../../../assets/svgs/pry_recherche.svg\"\n        alt=\"{{\n          (layout === DashboardGridLayout.MANUAL ? '@pry.widget.target.none_manual' : '@pry.widget.target.none_auto')\n            | i18n\n        }} {{ backgroundArea$ | async }}\"\n      />\n      <span class=\"no-widget__text\">{{\n        (layout === DashboardGridLayout.MANUAL ? '@pry.widget.target.none_manual' : '@pry.widget.target.none_auto')\n          | i18n\n      }}</span>\n    </div>\n  </ng-container>\n</div>\n<pry-context-menu></pry-context-menu>\n\n<ng-template #templateModal>\n  <div class=\"o-modal\">\n    <div class=\"o-modal__top\">\n      <div class=\"o-modal__top__title\">\n        <h2 class=\"a-h2\" id=\"dialog_title\">\n          {{ '@pry.widget.modalTitle' | i18n }}\n        </h2>\n      </div>\n      <div class=\"o-modal__top__close\">\n        <button class=\"a-btn a-btn--icon-only\" (click)=\"cancelRemoveConfirm()\">\n          <pry-icon iconSvg=\"close\" [height]=\"35\" [width]=\"35\"></pry-icon>\n          <span class=\"u-visually-hidden\">{{ '@pry.toolbox.close' | i18n }}</span>\n        </button>\n      </div>\n    </div>\n    <div class=\"m-btn-group\">\n      <button type=\"button\" (click)=\"cancelRemoveConfirm()\" class=\"a-btn a-btn--secondary\">\n        {{ '@pry.toolbox.manifest.close' | i18n }}\n      </button>\n      <button type=\"submit\" (click)=\"confirmRemove()\" class=\"a-btn a-btn--primary\">\n        {{ '@pry.toolbox.manifest.validate' | i18n }}\n      </button>\n    </div>\n  </div>\n</ng-template>\n"]}