tango-app-ui-store-builder 1.0.1-beta-1

package/esm2022/lib/components/layout-summary/layout-summary.component.mjs

@@ -0,0 +1,809 @@
+import { Component, HostListener, ViewChild } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { Subject, takeUntil } from 'rxjs';
+import { StoreOffcanvasComponentComponent } from '../store-offcanvas-component/store-offcanvas-component.component';
+import { CompleteLayoutComponent } from './popups/complete-layout/complete-layout.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services/store-builder.service";
+import * as i3 from "@ng-bootstrap/ng-bootstrap";
+import * as i4 from "tango-app-ui-shared";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "../custom-select/custom-select.component";
+export class LayoutSummaryComponent {
+    route;
+    apiService;
+    modalService;
+    offcanvasService;
+    router;
+    modalDef;
+    toastService;
+    floorsInput = new FormControl();
+    canvasRef;
+    scrollContainerRef;
+    completeLayout;
+    gridWidth = 5;
+    gridHeight = 5;
+    ctx;
+    canvas;
+    layoutPolygon = [[
+            {
+                "x": 100,
+                "y": 100
+            },
+            {
+                "x": 100,
+                "y": 100
+            },
+            {
+                "elementType": "wall",
+                "distance": 0,
+                "unit": "ft",
+                "direction": "right",
+                "angle": 90,
+                "elementNumber": 1
+            }
+        ]];
+    scale = 1;
+    destroy$ = new Subject();
+    headerData;
+    planoStoreList = [];
+    selectedStore;
+    selectedFloor;
+    wallCapacity;
+    facadeCapacity;
+    floorCapacity;
+    floorSelect = { show: false, deleteIndex: null };
+    markAsCompleteType = 'single';
+    itemsPerPage = 1;
+    currentPage = 0;
+    totalItems = 1;
+    paginationSizes = [1];
+    pageSize = 1;
+    pixelPerMetre = 50;
+    onFloorSelect(floorId) {
+        if (this.layoutPolygon[0][0].x !== this.layoutPolygon[0][1].x && this.layoutPolygon[0][0].y !== this.layoutPolygon[0][1].y) {
+            this.updateFloorLayout();
+        }
+        this.selectedFloor = this.selectedStore.floor.filter((floor) => floor.id === floorId)[0];
+        this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);
+    }
+    onOutsideClick(event) {
+        const clickedInside6 = event.target.closest('.floor-select');
+        if (!clickedInside6) {
+            this.floorSelect = { show: false, deleteIndex: null };
+        }
+    }
+    toggleFloorSelect() {
+        this.floorSelect = {
+            show: !this.floorSelect.show,
+            deleteIndex: null
+        };
+    }
+    constructor(route, apiService, modalService, offcanvasService, router, modalDef, toastService) {
+        this.route = route;
+        this.apiService = apiService;
+        this.modalService = modalService;
+        this.offcanvasService = offcanvasService;
+        this.router = router;
+        this.modalDef = modalDef;
+        this.toastService = toastService;
+        this.headerData = JSON.parse(localStorage.getItem('header-filters'));
+    }
+    ngAfterViewInit() {
+        this.initializeLayout();
+    }
+    initializeLayout() {
+        const centerX = this.canvas.width / 2 / this.scale;
+        const centerY = this.canvas.height / 2 / this.scale;
+        this.layoutPolygon = [
+            [
+                {
+                    "x": this.snapToGrid(centerX, this.gridHeight),
+                    "y": this.snapToGrid(centerY, this.gridWidth)
+                },
+                {
+                    "x": this.snapToGrid(centerX, this.gridHeight),
+                    "y": this.snapToGrid(centerY, this.gridWidth)
+                },
+                {
+                    "elementType": "wall",
+                    "distance": 0,
+                    "unit": "ft",
+                    "direction": "right",
+                    "angle": 90,
+                    "elementNumber": 1
+                }
+            ]
+        ];
+    }
+    ngOnInit() {
+        this.canvas = this.canvasRef.nativeElement;
+        this.ctx = this.canvas.getContext('2d');
+        this.canvas.width = 10000;
+        this.canvas.height = 10000;
+        this.drawGrid();
+        this.route.queryParams
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((params) => {
+            if (params?.id) {
+                const ids = params.id.split(',') || [];
+                this.getPlanoData(ids);
+            }
+        });
+        this.floorsInput.valueChanges.subscribe((val) => {
+            if (val) {
+                if (this.layoutPolygon[0][0].x !== this.layoutPolygon[0][1].x && this.layoutPolygon[0][0].y !== this.layoutPolygon[0][1].y) {
+                    this.updateFloorLayout();
+                }
+                this.selectedFloor = this.selectedStore.floor.filter((floor) => floor.id === val)[0];
+                this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    onStoreChange(event) {
+        if (this.layoutPolygon[0][0].x !== this.layoutPolygon[0][1].x && this.layoutPolygon[0][0].y !== this.layoutPolygon[0][1].y) {
+            this.updateFloorLayout();
+        }
+        const index = this.planoStoreList.findIndex(item => item.planoId === event.planoId);
+        this.currentPage = index + 1;
+        this.selectedStore = event;
+        this.selectedFloor = this.selectedStore.floor[0];
+        this.floorsInput.setValue(this.selectedFloor.id, { emitEvent: false });
+        this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);
+    }
+    getPlanoData(planoId) {
+        const payload = {
+            id: planoId
+        };
+        this.apiService.getPlano(payload).subscribe({
+            next: (res) => {
+                this.planoStoreList = res.data;
+                this.totalItems = res.data.length;
+                // this.planoStoreList = res.data.filter((plano:any) => plano.status !== 'completed');
+                if (!this.selectedStore) {
+                    this.selectedStore = this.planoStoreList[0];
+                }
+                else {
+                    this.selectedStore = this.planoStoreList.filter((store) => store.planoId === this.selectedStore.planoId)[0];
+                }
+                if (!this.selectedFloor) {
+                    this.selectedFloor = this.selectedStore.floor[0];
+                }
+                else {
+                    this.selectedFloor = this.selectedStore.floor.filter((floor) => floor.id === this.selectedFloor.id)[0];
+                }
+                this.planoStoreList.forEach((store) => {
+                    if (store.planoId === this.selectedStore.planoId) {
+                        store.selected = true;
+                    }
+                });
+                this.floorsInput.setValue(this.selectedFloor.id, { emitEvent: false });
+                this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);
+            },
+            error: (err) => {
+                console.log(err);
+            }
+        });
+    }
+    updateFloorLayout() {
+        const payload = {
+            id: this.selectedFloor.id,
+            layoutPolygon: this.layoutPolygon.map((segment) => {
+                const [point1, point2, properties] = segment;
+                return properties;
+            })
+        };
+        this.apiService.updateFloorLayout(payload).subscribe({
+            next: (res) => {
+                this.getPlanoData(this.selectedStore.planoId);
+            },
+            error: (err) => {
+                console.log(err);
+            }
+        });
+    }
+    onComplete() {
+        if (this.planoStoreList.length === 1) {
+            const modelRef = this.modalDef.open(CompleteLayoutComponent, { centered: true });
+            modelRef.result.then((val) => {
+                if (val.message === 'confirm') {
+                    this.updatePlanoStatus();
+                }
+            });
+        }
+        else {
+            this.modalService.open(this.completeLayout, { centered: true, size: "lg" });
+        }
+    }
+    drawGrid() {
+        this.ctx.save();
+        this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+        this.ctx.scale(this.scale, this.scale);
+        this.ctx.fillStyle = 'white';
+        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+    }
+    drawPolygon(polygon = this.layoutPolygon) {
+        if (polygon.length < 1)
+            return; // If the polygon has no edges, exit early.
+        this.ctx.save(); // Save the current canvas state.
+        this.ctx.scale(this.scale, this.scale); // Scale the canvas context to match the desired scale.
+        // this.ctx.translate(this.panOffset.x, this.panOffset.y);
+        // Function to draw an arrowhead at a specific location and angle.
+        function drawArrowhead(ctx, x, y, angle) {
+            const size = 5; // Define the size of the arrowhead.
+            ctx.save(); // Save the current canvas state.
+            ctx.translate(x, y); // Move the context to the arrowhead position.
+            ctx.rotate(angle); // Rotate the context to match the arrow's angle.
+            ctx.beginPath(); // Start a new path.
+            ctx.moveTo(0, 0); // Move to the tip of the arrowhead.
+            ctx.lineTo(-size, -size / 2); // Draw one side of the arrowhead.
+            ctx.lineTo(-size, size / 2); // Draw the other side of the arrowhead.
+            ctx.closePath(); // Close the arrowhead path.
+            ctx.fillStyle = 'black'; // Set the arrowhead color.
+            ctx.fill(); // Fill the arrowhead.
+            ctx.restore(); // Restore the previous canvas state.
+        }
+        this.ctx.beginPath(); // Begin the main polygon path.
+        polygon.forEach((edge, edgeIndex) => {
+            const point = edge[0]; // Starting point of the edge.
+            const nextPoint = edge[1]; // Ending point of the edge.
+            const properties = edge[2]; // Properties of the edge (e.g., labels, distances).
+            // Draw the main polygon edge.
+            if (edgeIndex === 0)
+                this.ctx.moveTo(point.x, point.y); // Move to the first edge starting point.
+            this.ctx.lineTo(nextPoint.x, nextPoint.y); // Draw a line to the next point.
+            // Calculate the perpendicular offset for the bounding box.
+            const dx = nextPoint.x - point.x; // X-difference between start and end points.
+            const dy = nextPoint.y - point.y; // Y-difference between start and end points.
+            const length = Math.sqrt(dx * dx + dy * dy); // Length of the edge.
+            const offsetX = (dy / length) * 20; // Offset in the X direction.
+            const offsetY = (-dx / length) * 20; // Offset in the Y direction.
+            // Define the bounding box points.
+            const boxPoints = [
+                { x: point.x, y: point.y },
+                { x: nextPoint.x, y: nextPoint.y },
+                { x: nextPoint.x + offsetX, y: nextPoint.y + offsetY },
+                { x: point.x + offsetX, y: point.y + offsetY },
+            ];
+            // Draw the bounding box.
+            this.ctx.beginPath();
+            this.ctx.moveTo(boxPoints[0].x, boxPoints[0].y);
+            boxPoints.forEach((pt, index) => {
+                if (properties.elementType === 'entrance') {
+                    if (index < 2) {
+                        this.ctx.lineTo(pt.x, pt.y);
+                    }
+                }
+                else {
+                    this.ctx.lineTo(pt.x, pt.y); // Draw each edge of the box.
+                }
+            });
+            if (properties.elementType === 'opening') {
+                this.ctx.closePath(); // Close the bounding box path.
+                this.ctx.fillStyle = '#F9FAFB'; // Set a translucent fill color.
+                this.ctx.fill(); // Fill the bounding box.
+                this.ctx.strokeStyle = '#F9FAFB';
+                this.ctx.stroke(); // Draw the bounding box border. 
+            }
+            else {
+                this.ctx.closePath(); // Close the bounding box path.
+                this.ctx.fillStyle = '#F9FAFB'; // Set a translucent fill color.
+                this.ctx.fill(); // Fill the bounding box.
+                this.ctx.strokeStyle = '#1D2939';
+                this.ctx.stroke(); // Draw the bounding box border. 
+            }
+            // Position text in the middle of the bounding box.
+            const textX = (boxPoints[1].x + boxPoints[3].x) / 2;
+            const textY = (boxPoints[1].y + boxPoints[3].y) / 2;
+            this.ctx.save(); // Save the current canvas state.
+            this.ctx.translate(textX, textY); // Move the context to the text position.
+            // Rotate text based on the edge direction.
+            if (dx === 0) {
+                this.ctx.rotate(-Math.PI / 2); // Rotate for vertical edges.
+            }
+            else if (dy !== 0) {
+                const angle = Math.atan2(dy, dx); // Calculate angle for diagonal edges.
+                this.ctx.rotate(angle); // Rotate the text to match the angle.
+            }
+            // Draw the edge properties as text.
+            this.ctx.font = '12px Arial'; // Set the font style and size.
+            this.ctx.fillStyle = 'black'; // Set the text color.
+            this.ctx.textAlign = 'center'; // Align text to the center.
+            this.ctx.textBaseline = 'middle'; // Align text vertically in the middle.
+            this.ctx.fillText(`${properties.elementType} ${properties.elementNumber} - ${properties.distance} ${properties.unit}`, 0, 0);
+            this.ctx.restore(); // Restore the previous canvas state.
+            if (properties.distance >= 4) {
+                // Define the midpoints of the left and right edges of the bounding box.
+                const centerX = textX;
+                const centerY = textY;
+                const rightX = (boxPoints[1].x + boxPoints[2].x) / 2;
+                const rightY = (boxPoints[1].y + boxPoints[2].y) / 2;
+                const leftX = (boxPoints[0].x + boxPoints[3].x) / 2;
+                const leftY = (boxPoints[0].y + boxPoints[3].y) / 2;
+                // Helper function to adjust points by a specific distance.
+                function adjustPoint(x1, y1, x2, y2, distance) {
+                    const angle = Math.atan2(y2 - y1, x2 - x1); // Calculate the angle.
+                    return {
+                        x: x1 + Math.cos(angle) * distance,
+                        y: y1 + Math.sin(angle) * distance, // Adjust Y by distance.
+                    };
+                }
+                // Define the arrow line start and end points for the right side.
+                const rightStart = adjustPoint(centerX, centerY, rightX, rightY, 50);
+                const rightEnd = adjustPoint(rightX, rightY, centerX, centerY, 10);
+                // Define the arrow line start and end points for the left side.
+                const leftStart = adjustPoint(centerX, centerY, leftX, leftY, 50);
+                const leftEnd = adjustPoint(leftX, leftY, centerX, centerY, 10);
+                // Draw the right arrow.
+                this.ctx.beginPath();
+                this.ctx.moveTo(rightStart.x, rightStart.y);
+                this.ctx.lineTo(rightEnd.x, rightEnd.y);
+                this.ctx.strokeStyle = 'black'; // Set the arrow line color.
+                this.ctx.stroke(); // Draw the arrow line.
+                let rightAngle = Math.atan2(rightEnd.y - rightStart.y, rightEnd.x - rightStart.x);
+                drawArrowhead(this.ctx, rightEnd.x, rightEnd.y, rightAngle); // Draw the arrowhead.
+                // Draw the left arrow.
+                this.ctx.beginPath();
+                this.ctx.moveTo(leftStart.x, leftStart.y);
+                this.ctx.lineTo(leftEnd.x, leftEnd.y);
+                this.ctx.strokeStyle = 'black'; // Set the arrow line color.
+                this.ctx.stroke(); // Draw the arrow line.
+                let leftAngle = Math.atan2(leftEnd.y - leftStart.y, leftEnd.x - leftStart.x);
+                drawArrowhead(this.ctx, leftEnd.x, leftEnd.y, leftAngle); // Draw the arrowhead.
+            }
+            // For Entrance
+            if (properties.elementType === 'entrance') {
+                // Calculate the angle of the main line (edge) in radians.
+                const angle = Math.atan2(nextPoint.y - point.y, nextPoint.x - point.x);
+                // Add 15 degrees to the angle for the entrance line.
+                const entranceAngle = angle + (15 * Math.PI) / 180; // Convert 15 degrees to radians.
+                // Define the length of the entrance line.
+                const lineLength = this.convertToPixels(properties.distance, properties.unit) * 0.75;
+                // Calculate the endpoint of the entrance line based on the angle.
+                const endPoint = {
+                    x: point.x + Math.cos(entranceAngle) * lineLength,
+                    y: point.y + Math.sin(entranceAngle) * lineLength,
+                };
+                // Draw the entrance line.
+                this.ctx.beginPath();
+                this.ctx.moveTo(point.x, point.y);
+                this.ctx.lineTo(endPoint.x, endPoint.y);
+                this.ctx.strokeStyle = '#1D2939';
+                this.ctx.stroke();
+            }
+        });
+        this.ctx.restore(); // Restore the original canvas state.
+    }
+    zoomIn() {
+        this.scale *= 1.1;
+        this.redrawCanvas();
+    }
+    zoomOut() {
+        this.scale /= 1.1;
+        this.redrawCanvas();
+    }
+    redrawCanvas() {
+        this.drawGrid();
+        this.drawPolygon();
+    }
+    snapToGrid(value, gridSize) {
+        return Math.round(value / gridSize) * gridSize;
+    }
+    rotatePolygons() {
+        const rotatePoint = (point, center) => {
+            const dx = point.x - center.x;
+            const dy = point.y - center.y;
+            return { x: center.x - dy, y: center.y + dx };
+        };
+        const getPolygonLineCenter = (line) => {
+            const [start, end] = line;
+            return {
+                x: (start.x + end.x) / 2,
+                y: (start.y + end.y) / 2,
+            };
+        };
+        const getOverallCenter = (lines) => {
+            const sum = lines.reduce((acc, line) => {
+                const center = getPolygonLineCenter(line);
+                acc.x += center.x;
+                acc.y += center.y;
+                return acc;
+            }, { x: 0, y: 0 });
+            return { x: sum.x / lines.length, y: sum.y / lines.length };
+        };
+        const overallCenter = getOverallCenter(this.layoutPolygon);
+        this.layoutPolygon = this.layoutPolygon.map((line) => {
+            const [start, end, properties] = line;
+            return [
+                rotatePoint(start, overallCenter),
+                rotatePoint(end, overallCenter),
+                properties
+            ];
+        });
+        this.drawGrid();
+        this.drawPolygon();
+    }
+    convertToPixels(value, unit) {
+        const PIXELS_PER_METER = this.pixelPerMetre;
+        const PIXELS_PER_FOOT = PIXELS_PER_METER / 3.28084;
+        if (typeof value !== 'number' || value < 0) {
+            throw new Error('Value must be a non-negative number');
+        }
+        switch (unit) {
+            case 'm':
+                return value * PIXELS_PER_METER;
+            case 'ft':
+                return value * PIXELS_PER_FOOT;
+            default:
+                throw new Error("Invalid unit. Supported units are 'mt' for meters and 'ft' for feet.");
+        }
+    }
+    scrollToCanvasPosition(coordinates) {
+        const container = this.scrollContainerRef.nativeElement;
+        const containerRect = container.getBoundingClientRect();
+        const containerScrollLeft = container.scrollLeft;
+        const containerScrollTop = container.scrollTop;
+        const targetX = coordinates.x;
+        const targetY = coordinates.y;
+        const offset = {
+            up: 50,
+            down: 200,
+            left: 100,
+            right: 100,
+        };
+        const visibleLeft = containerScrollLeft + offset.left;
+        const visibleRight = containerScrollLeft + containerRect.width - offset.right;
+        const visibleTop = containerScrollTop + offset.up;
+        const visibleBottom = containerScrollTop + containerRect.height - offset.down;
+        const isXInView = targetX >= visibleLeft && targetX <= visibleRight;
+        const isYInView = targetY >= visibleTop && targetY <= visibleBottom;
+        if (!isXInView || !isYInView) {
+            const adjustedX = Math.max(0, targetX - offset.left);
+            const adjustedY = Math.max(0, targetY - offset.up);
+            container.scrollTo({
+                left: adjustedX,
+                top: adjustedY,
+                behavior: 'smooth',
+            });
+        }
+    }
+    calculatePolygonArea(elements) {
+        const vertices = [];
+        const centerX = 0; // Assuming (0,0) as the starting point for calculation
+        const centerY = 0;
+        let currentPoint = { x: centerX, y: centerY };
+        const conversionFactor = 50; // Pixels per foot (adjust as needed)
+        // Compute vertices based on layout instructions
+        for (const element of elements) {
+            const radians = {
+                up: ((180 - element.angle) * Math.PI) / 180,
+                left: ((270 - element.angle) * Math.PI) / 180,
+                down: ((360 - element.angle) * Math.PI) / 180,
+                right: ((90 - element.angle) * Math.PI) / 180,
+            }[element.direction];
+            if (radians === undefined) {
+                throw new Error(`Invalid direction: ${element.direction}`);
+            }
+            const distanceInPixels = element.distance * conversionFactor;
+            const newX = currentPoint.x + Math.cos(radians) * distanceInPixels;
+            const newY = currentPoint.y - Math.sin(radians) * distanceInPixels;
+            vertices.push({ x: currentPoint.x, y: currentPoint.y });
+            currentPoint = {
+                x: this.snapToGrid(newX, this.gridWidth),
+                y: this.snapToGrid(newY, this.gridHeight),
+            };
+        }
+        // Close the polygon by adding the starting vertex at the end
+        vertices.push(vertices[0]);
+        // Apply the Shoelace formula
+        let areaInPixels = 0;
+        for (let i = 0; i < vertices.length - 1; i++) {
+            const x1 = vertices[i].x;
+            const y1 = vertices[i].y;
+            const x2 = vertices[i + 1].x;
+            const y2 = vertices[i + 1].y;
+            areaInPixels += x1 * y2 - y1 * x2;
+        }
+        // Convert area from pixels² to feet²
+        const areaInSquareFeet = Math.abs(areaInPixels / 2) / (conversionFactor * conversionFactor);
+        return Math.round(areaInSquareFeet); // Return the area in square feet
+    }
+    generateLayoutPolygon(layoutInstructions) {
+        this.pixelPerMetre = this.normalizedPixelPerMetre(layoutInstructions);
+        this.wallCapacity = layoutInstructions.reduce((acc, val) => {
+            if (val.elementType === 'wall') {
+                return acc += val.distance;
+            }
+            else {
+                return acc;
+            }
+        }, 0);
+        this.facadeCapacity = layoutInstructions.reduce((acc, val) => {
+            if (val.elementType === 'facade') {
+                return acc += val.distance;
+            }
+            else {
+                return acc;
+            }
+        }, 0);
+        this.floorCapacity = this.calculatePolygonArea(layoutInstructions);
+        this.layoutPolygon = [];
+        const centerX = this.canvas.width / 2 / this.scale;
+        const centerY = this.canvas.height / 2 / this.scale;
+        let currentPoint = {
+            "x": this.snapToGrid(centerX, this.gridHeight),
+            "y": this.snapToGrid(centerY, this.gridWidth)
+        };
+        if (!layoutInstructions.length) {
+            this.layoutPolygon = [
+                [
+                    {
+                        "x": this.snapToGrid(centerX, this.gridHeight),
+                        "y": this.snapToGrid(centerY, this.gridWidth)
+                    },
+                    {
+                        "x": this.snapToGrid(centerX, this.gridHeight),
+                        "y": this.snapToGrid(centerY, this.gridWidth)
+                    },
+                    {
+                        "elementType": "wall",
+                        "distance": 0,
+                        "unit": "ft",
+                        "direction": "right",
+                        "angle": 90,
+                        "elementNumber": 1
+                    }
+                ]
+            ];
+            this.openWidget({ x: this.snapToGrid(centerX, this.gridHeight), y: this.snapToGrid(centerY, this.gridWidth) });
+            this.drawGrid();
+            this.drawPolygon();
+            return;
+        }
+        layoutInstructions.forEach((instruction) => {
+            const radians = {
+                'up': ((180 - instruction.angle) * Math.PI) / 180,
+                'left': ((270 - instruction.angle) * Math.PI) / 180,
+                'down': ((360 - instruction.angle) * Math.PI) / 180,
+                'right': ((90 - instruction.angle) * Math.PI) / 180,
+            }[instruction.direction];
+            if (radians === undefined) {
+                throw new Error(`Invalid direction: ${instruction.direction}`);
+            }
+            const distanceInPixels = this.convertToPixels(instruction.distance, instruction.unit);
+            const newX = currentPoint.x + Math.cos(radians) * distanceInPixels;
+            const newY = currentPoint.y - Math.sin(radians) * distanceInPixels;
+            const newPoint = {
+                x: this.snapToGrid(newX, this.gridWidth),
+                y: this.snapToGrid(newY, this.gridHeight),
+            };
+            const lineSegment = [
+                currentPoint,
+                newPoint,
+                {
+                    elementType: instruction.elementType,
+                    distance: instruction.distance,
+                    unit: instruction.unit,
+                    direction: instruction.direction,
+                    angle: instruction.angle,
+                    elementNumber: instruction.elementNumber,
+                },
+            ];
+            this.layoutPolygon.push(lineSegment);
+            currentPoint = newPoint;
+        });
+        const lastPoint = this.layoutPolygon[this.layoutPolygon.length - 1][1];
+        if (this.isFloorCompleted(layoutInstructions)) {
+            this.findPolygonCenterAndScroll();
+        }
+        else {
+            this.openWidget(lastPoint);
+        }
+        this.drawGrid();
+        this.drawPolygon();
+    }
+    isFloorCompleted(layoutInstructions, thresholdInFeet = 1) {
+        const layoutPolygon = [];
+        const centerX = this.canvas.width / 2 / this.scale;
+        const centerY = this.canvas.height / 2 / this.scale;
+        let currentPoint = {
+            x: this.snapToGrid(centerX, this.gridHeight),
+            y: this.snapToGrid(centerY, this.gridWidth),
+        };
+        layoutInstructions.forEach((instruction) => {
+            const radians = {
+                'up': ((180 - instruction.angle) * Math.PI) / 180,
+                'left': ((270 - instruction.angle) * Math.PI) / 180,
+                'down': ((360 - instruction.angle) * Math.PI) / 180,
+                'right': ((90 - instruction.angle) * Math.PI) / 180,
+            }[instruction.direction];
+            if (radians === undefined) {
+                throw new Error(`Invalid direction: ${instruction.direction}`);
+            }
+            const distanceInPixels = this.convertToPixels(instruction.distance, instruction.unit);
+            const newX = currentPoint.x + Math.cos(radians) * distanceInPixels;
+            const newY = currentPoint.y - Math.sin(radians) * distanceInPixels;
+            const newPoint = {
+                x: this.snapToGrid(newX, this.gridWidth),
+                y: this.snapToGrid(newY, this.gridHeight),
+            };
+            const lineSegment = [
+                currentPoint,
+                newPoint,
+                {
+                    elementType: instruction.elementType,
+                    distance: instruction.distance,
+                    unit: instruction.unit,
+                    direction: instruction.direction,
+                    angle: instruction.angle,
+                    elementNumber: instruction.elementNumber,
+                },
+            ];
+            layoutPolygon.push(lineSegment);
+            currentPoint = newPoint;
+        });
+        const firstPoint = layoutPolygon?.[0]?.[0];
+        const lastPoint = layoutPolygon?.[layoutPolygon.length - 1]?.[1];
+        if (layoutPolygon.length <= 1 || !firstPoint || !lastPoint) {
+            return false;
+        }
+        const distanceBetweenPoints = Math.sqrt(Math.pow(lastPoint.x - firstPoint.x, 2) + Math.pow(lastPoint.y - firstPoint.y, 2));
+        const thresholdInPixels = this.convertToPixels(thresholdInFeet, 'ft');
+        return distanceBetweenPoints <= thresholdInPixels;
+    }
+    openWidget(position, offset = { up: 0, right: 5, down: 15, left: 0, }) {
+        const adjustedPosition = {
+            x: position.x + offset.right + offset.left,
+            y: position.y + offset.up + offset.down,
+        };
+        this.scrollToCanvasPosition(adjustedPosition);
+    }
+    openOffCanva() {
+        let canvaRef = this.offcanvasService.open(StoreOffcanvasComponentComponent, { position: 'end', panelClass: 'set-height' });
+        canvaRef.componentInstance.store = this.selectedStore;
+        canvaRef.componentInstance.clientId = this.headerData?.client;
+        canvaRef.componentInstance.id = this.selectedStore.planoId;
+    }
+    onModalSelectAll(event) {
+        this.planoStoreList.forEach((store) => store.selected = event.target.checked);
+    }
+    get isAllStoreSelected() {
+        return this.planoStoreList.every((store) => store.selected);
+    }
+    onModalTypeChange(event) {
+        if (event === 'single') {
+            this.planoStoreList.forEach((store, index) => {
+                if (store.planoId === this.selectedStore.planoId) {
+                    store.selected = true;
+                }
+                else {
+                    store.selected = false;
+                }
+            });
+        }
+        else if (event === 'multiple') {
+            this.planoStoreList.forEach((store) => store.selected = true);
+        }
+    }
+    updatePlanoStatus() {
+        const payload = {
+            storeId: this.planoStoreList.filter((store) => store.selected === true).map((store) => store.storeId),
+            status: "completed"
+        };
+        this.apiService.updatePlanoStatus(payload).subscribe({
+            next: (res) => {
+                if (res.code === 200) {
+                    this.toastService.getSuccessToast(res.message);
+                    this.router.navigateByUrl('/manage/planogram/store-layout');
+                }
+            },
+            error: (err) => {
+                console.log(err);
+            }
+        });
+    }
+    onPageChange(val) {
+        this.selectedStore = this.planoStoreList[val - 1];
+        this.selectedFloor = this.selectedStore.floor[0];
+        this.floorsInput.setValue(this.selectedFloor.id, { emitEvent: false });
+        this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);
+    }
+    normalizedPixelPerMetre(polygon) {
+        const MIN_PIXELS_PER_METER = 50;
+        const MAX_PIXELS_PER_METER = 150;
+        let totalLength = 0;
+        let lineCount = 0;
+        polygon.forEach((line) => {
+            if (line.unit === 'ft') {
+                totalLength = totalLength + (line.distance * 3.28084);
+            }
+            else {
+                totalLength = totalLength + line.distance;
+            }
+            lineCount++;
+        });
+        const averageLength = lineCount > 0 ? totalLength / lineCount : 0;
+        const MAX_AVERAGE_LENGTH = 50;
+        const MIN_AVERAGE_LENGTH = 5;
+        const normalizedLength = Math.min(Math.max(averageLength, MIN_AVERAGE_LENGTH), MAX_AVERAGE_LENGTH);
+        const pixelsPerMeter = MAX_PIXELS_PER_METER -
+            ((normalizedLength - MIN_AVERAGE_LENGTH) / (MAX_AVERAGE_LENGTH - MIN_AVERAGE_LENGTH)) *
+                (MAX_PIXELS_PER_METER - MIN_PIXELS_PER_METER);
+        return Math.round(pixelsPerMeter);
+    }
+    findPolygonCenterAndScroll(polygon = this.layoutPolygon) {
+        const vertices = polygon.flatMap((line) => line.slice(0, 2));
+        const minX = Math.min(...vertices.map((v) => v.x));
+        const maxX = Math.max(...vertices.map((v) => v.x));
+        const minY = Math.min(...vertices.map((v) => v.y));
+        const maxY = Math.max(...vertices.map((v) => v.y));
+        let center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+        const step = 1;
+        let bestPoint = center;
+        let bestDistanceSum = Number.MAX_VALUE;
+        for (let x = minX; x <= maxX; x += step) {
+            for (let y = minY; y <= maxY; y += step) {
+                const point = { x, y };
+                if (isPointInsidePolygon(point, vertices)) {
+                    const distanceSum = vertices.reduce((sum, vertex) => sum + Math.sqrt((point.x - vertex.x) ** 2 + (point.y - vertex.y) ** 2), 0);
+                    if (distanceSum < bestDistanceSum) {
+                        bestDistanceSum = distanceSum;
+                        bestPoint = point;
+                    }
+                }
+            }
+        }
+        const scrollContainer = this.scrollContainerRef.nativeElement;
+        scrollContainer.scrollTo({
+            left: bestPoint.x - scrollContainer.offsetWidth / 2,
+            top: bestPoint.y - scrollContainer.offsetHeight / 2,
+            behavior: 'smooth'
+        });
+        function isPointInsidePolygon(point, vertices) {
+            let count = 0;
+            for (let i = 0; i < vertices.length; i++) {
+                const start = vertices[i];
+                const end = vertices[(i + 1) % vertices.length];
+                if (rayIntersectsSegment(point, { start, end })) {
+                    count++;
+                }
+            }
+            return count % 2 === 1;
+        }
+        function rayIntersectsSegment(point, segment) {
+            const { x, y } = point;
+            const { start, end } = segment;
+            if (y < Math.min(start.y, end.y) || y > Math.max(start.y, end.y)) {
+                return false;
+            }
+            const t = (y - start.y) / (end.y - start.y);
+            const intersectX = start.x + t * (end.x - start.x);
+            return intersectX >= x;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LayoutSummaryComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2.StoreBuilderService }, { token: i3.NgbModal }, { token: i3.NgbOffcanvas }, { token: i1.Router }, { token: i3.NgbModal }, { token: i4.ToastService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LayoutSummaryComponent, selector: "lib-layout-summary", host: { listeners: { "document:click": "onOutsideClick($event)" } }, viewQueries: [{ propertyName: "canvasRef", first: true, predicate: ["gridCanvas"], descendants: true, static: true }, { propertyName: "scrollContainerRef", first: true, predicate: ["scrollContainer"], descendants: true }, { propertyName: "completeLayout", first: true, predicate: ["completeLayout"], descendants: true }], ngImport: i0, template: "<div class=\"d-flex align-items-center justify-content-between mb-6\">\r\n  <div>\r\n    <div *ngIf=\"planoStoreList.length === 1\" class=\"storename-txt\">\r\n      {{selectedStore?.storeName}} - Layout\r\n    </div>\r\n    <div *ngIf=\"planoStoreList.length > 1\">\r\n      <lib-select-plano [items]=\"planoStoreList\" [multi]=\"false\" [searchField]=\"'storeName'\" [idField]=\"'storeId'\"\r\n        (selected)=\"onStoreChange($event)\" [selectedValues]=\"[selectedStore]\"></lib-select-plano>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"d-flex align-items-center\">\r\n    <button (click)=\"onComplete()\" class=\"btn btn-sm btn-primary me-5\">Complete</button>\r\n    <button (click)=\"openOffCanva()\" class=\"btn btn-sm btn-outline bg-white\">\r\n      <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n        <path\r\n          d=\"M9 3V21M5 3H19C20.1046 3 21 3.89543 21 5V19C21 20.1046 20.1046 21 19 21H5C3.89543 21 3 20.1046 3 19V5C3 3.89543 3.89543 3 5 3Z\"\r\n          stroke=\"#101828\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n      </svg>\r\n    </button>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"row mb-6\">\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{wallCapacity || 0}}</span> <span class=\"unit-txt\">rft</span> </div>\r\n        <div class=\"sub-txt\">Wall capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"65\" height=\"65\" viewBox=\"0 0 65 65\" fill=\"none\">\r\n          <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n            d=\"M4.33333 4.33333V0H8.66667V4.33333H21.6667V0H26V4.33333H39V0H43.3333V4.33333H56.3333V0H60.6667V4.33333H65V8.66667H60.6667V21.6667H65V26H60.6667V39H65V43.3333H60.6667V56.3333H65V60.6667H60.6667V65H56.3333V60.6667H43.3333V65H39V60.6667H26V65H21.6667V60.6667H8.66667V65H4.33333V60.6667H0V56.3333H4.33333V43.3333H0V39H4.33333V26H0V21.6667H4.33333V8.66667H0V4.33333H4.33333ZM8.66667 8.66667V21.6667H21.6667V8.66667H8.66667ZM26 8.66667V21.6667H39V8.66667H26ZM43.3333 8.66667V21.6667H56.3333V8.66667H43.3333ZM56.3333 26H43.3333V39H56.3333V26ZM56.3333 43.3333H43.3333V56.3333H56.3333V43.3333ZM39 56.3333V43.3333H26V56.3333H39ZM21.6667 56.3333V43.3333H8.66667V56.3333H21.6667ZM8.66667 39H21.6667V26H8.66667V39ZM26 26V39H39V26H26Z\"\r\n            fill=\"#344054\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{facadeCapacity || 0}}</span> <span class=\"unit-txt\">rft</span> </div>\r\n        <div class=\"sub-txt\">Facade capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg width=\"65\" height=\"65\" viewBox=\"0 0 65 65\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n          <rect x=\"0.5\" y=\"0.5\" width=\"64\" height=\"64\" fill=\"#FDFDFD\" stroke=\"black\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{floorCapacity || 0}}</span> <span class=\"unit-txt\">sqft</span> </div>\r\n        <div class=\"sub-txt\">Floor capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"102\" height=\"58\" viewBox=\"0 0 102 58\" fill=\"none\">\r\n          <path d=\"M3.54359 36.4607L29.8929 2.06432L98.0939 6.44191L99.908 55.5468L3.54359 36.4607Z\" stroke=\"#475467\"\r\n            stroke-width=\"4\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"row\">\r\n  <div class=\"col-4\">\r\n    <div class=\"c-card\" style=\"height: 75dvh; position: relative;\">\r\n      <div class=\"d-flex align-items-center justify-content-between mb-5\" style=\"height: 8%;\">\r\n        <div>\r\n          <div class=\"l-pane-head\">\r\n            Capacity details\r\n          </div>\r\n          <div class=\"l-pane-desc\">\r\n            Below are the capacity details of the elements\r\n          </div>\r\n        </div>\r\n        <div class=\"d-flex align-items-center\">\r\n\r\n        </div>\r\n\r\n      </div>\r\n\r\n      <div class=\"table-responsive hide-scrollbar \" style=\"height: 92%;\">\r\n        <table class=\"table\">\r\n          <thead class=\"thead-light\">\r\n            <tr>\r\n              <th>#</th>\r\n              <th> <svg class=\"me-2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"\r\n                  fill=\"none\">\r\n                  <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n                    d=\"M1.33333 1.33333V0L2.66667 0V1.33333L6.66667 1.33333V0L8 0V1.33333L12 1.33333V0L13.3333 0V1.33333L17.3333 1.33333V0L18.6667 0V1.33333H20V2.66667H18.6667V6.66667H20V8H18.6667V12H20V13.3333H18.6667V17.3333H20V18.6667H18.6667V20H17.3333V18.6667H13.3333V20H12V18.6667H8V20H6.66667V18.6667H2.66667V20H1.33333V18.6667H0L0 17.3333H1.33333L1.33333 13.3333H0L0 12H1.33333L1.33333 8H0L0 6.66667H1.33333L1.33333 2.66667H0L0 1.33333H1.33333ZM2.66667 2.66667L2.66667 6.66667H6.66667V2.66667L2.66667 2.66667ZM8 2.66667V6.66667H12V2.66667L8 2.66667ZM13.3333 2.66667V6.66667H17.3333V2.66667H13.3333ZM17.3333 8L13.3333 8V12L17.3333 12V8ZM17.3333 13.3333L13.3333 13.3333L13.3333 17.3333H17.3333V13.3333ZM12 17.3333L12 13.3333H8L8 17.3333H12ZM6.66667 17.3333V13.3333H2.66667V17.3333H6.66667ZM2.66667 12H6.66667V8H2.66667L2.66667 12ZM8 8V12H12V8H8Z\"\r\n                    fill=\"#344054\" />\r\n                </svg> <span>Wall</span> </th>\r\n              <th>RFT ({{wallCapacity || 0}})</th>\r\n\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <ng-container *ngFor=\"let item of layoutPolygon; let i = index\">\r\n              <tr *ngIf=\"item[2] && item[2].elementType === 'wall'\">\r\n                <td>\r\n                  {{1}}\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].elementType}} {{item[2].elementNumber}}</div>\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].distance}}</div>\r\n\r\n                </td>\r\n              </tr>\r\n            </ng-container>\r\n\r\n          </tbody>\r\n        </table>\r\n        <table class=\"table\">\r\n          <thead class=\"thead-light\">\r\n            <tr>\r\n              <th>#</th>\r\n              <th> <svg class=\"me-2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"22\" height=\"22\" viewBox=\"0 0 22 22\"\r\n                  fill=\"none\">\r\n                  <path\r\n                    d=\"M1 11V2.25C1 1.5625 1.5625 1 2.25 1H19.75C20.4375 1 21 1.5625 21 2.25V19.75C21 20.4375 20.4375 21 19.75 21H2.25C1.5625 21 1 20.4375 1 19.75V11Z\"\r\n                    stroke=\"#344054\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg> <span>Facade</span> </th>\r\n              <th>RFT ({{facadeCapacity || 0}})</th>\r\n\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <ng-container *ngFor=\"let item of layoutPolygon; let i = index\">\r\n              <tr *ngIf=\"item[2] && item[2].elementType === 'facade'\">\r\n                <td>\r\n                  {{i}}\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].elementType}} {{item[2].elementNumber}}</div>\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].distance}}</div>\r\n\r\n                </td>\r\n              </tr>\r\n            </ng-container>\r\n\r\n          </tbody>\r\n        </table>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n  <div class=\"col-8\">\r\n    <div class=\"c-card \" style=\"height: 75dvh;\">\r\n      <div style=\"height: 8%;\" class=\"d-flex align-items-center justify-content-between\">\r\n        <div>\r\n          <!-- <lib-reactive-select *ngIf=\"floorsInput.value\" [formControl]=\"floorsInput\" [idField]=\"'id'\"\r\n            [nameField]=\"'floorName'\" [data]=\"selectedStore?.floor\"></lib-reactive-select> -->\r\n          <div (click)=\"toggleFloorSelect()\" class=\"floor-select\">\r\n            <div>{{selectedFloor?.floorName}}</div>\r\n            <div><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                <path d=\"M5 7.5L10 12.5L15 7.5\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\"\r\n                  stroke-linejoin=\"round\" />\r\n              </svg></div>\r\n            <ul *ngIf=\"floorSelect?.show\" class=\"list-unstyled mb-2\">\r\n              <li (click)=\"onFloorSelect(floor.id)\" *ngFor=\"let floor of selectedStore?.floor; let i = index\"\r\n                [ngClass]=\"floor.id === selectedFloor.id ? 'selected': ''\">\r\n                <div class=\"d-flex justify-content-between\">\r\n                  <span>{{floor?.floorName}}</span>\r\n\r\n                </div>\r\n\r\n              </li>\r\n            </ul>\r\n          </div>\r\n        </div>\r\n        <button class=\"btn btn-sm btn-outline bg-white\" (click)=\"rotatePolygons()\">\r\n          <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" fill=\"none\">\r\n            <path\r\n              d=\"M6.36265 7.17838L7.17625 6.36238L5.90425 5.09158L5.08945 5.90518L6.36265 7.17838ZM15.671 6.36358L19.6379 10.3304L20.9099 9.0572L16.9442 5.09038L15.671 6.36358ZM19.6379 18.8252L18.8243 19.6388L20.0963 20.9096L20.9099 20.0972L19.6379 18.8252ZM10.3295 19.6388L6.36265 15.672L5.09065 16.9452L9.05626 20.9108L10.3295 19.6388ZM18.8243 19.6388C17.6543 20.8076 16.8407 21.6188 16.1459 22.1492C15.4715 22.664 15.0155 22.8284 14.5763 22.8284V24.6284C15.5675 24.6284 16.4027 24.2168 17.2367 23.5808C18.0503 22.9604 18.9635 22.0448 20.0963 20.912L18.8243 19.6388ZM9.05626 20.9108C10.1891 22.0448 11.1023 22.9592 11.9159 23.5808C12.7499 24.2168 13.5851 24.6284 14.5763 24.6284V22.8284C14.1371 22.8284 13.6823 22.664 13.0067 22.1492C12.3119 21.6188 11.4983 20.8076 10.3295 19.6388L9.05626 20.9108ZM19.6379 10.3304C20.8067 11.4992 21.6179 12.3128 22.1483 13.0076C22.6631 13.6832 22.8275 14.138 22.8275 14.5772H24.6275C24.6275 13.586 24.2159 12.7508 23.5799 11.9168C22.9595 11.1032 22.0427 10.19 20.9099 9.0572L19.6379 10.3304ZM20.9099 20.0972C22.0439 18.9632 22.9583 18.0512 23.5799 17.2376C24.2159 16.4036 24.6275 15.5684 24.6275 14.5772H22.8275C22.8275 15.0164 22.6631 15.4724 22.1483 16.1468C21.6179 16.8416 20.8067 17.6552 19.6379 18.8252L20.9099 20.0972ZM7.17625 6.36238C8.34625 5.19358 9.15985 4.38118 9.85465 3.85078C10.529 3.33598 10.985 3.17278 11.4242 3.17278V1.37158C10.433 1.37158 9.59785 1.78318 8.76385 2.41918C7.94905 3.04078 7.03705 3.95518 5.90425 5.08798L7.17625 6.36238ZM16.9442 5.09038C15.8114 3.95638 14.8982 3.04078 14.0846 2.41918C13.2506 1.78318 12.4154 1.37158 11.4242 1.37158V3.17278C11.8634 3.17278 12.3182 3.33598 12.9938 3.85078C13.6886 4.38118 14.5022 5.19238 15.671 6.36118L16.9442 5.09038ZM5.08945 5.90278C3.95665 7.03558 3.04225 7.94758 2.42065 8.76238C1.78465 9.59638 1.37305 10.4316 1.37305 11.4228H3.17305C3.17305 10.9836 3.33745 10.5276 3.85225 9.85318C4.38265 9.15838 5.19385 8.34478 6.36265 7.17478L5.08945 5.90278ZM6.36265 15.6708C5.19385 14.5008 4.38265 13.6872 3.85225 12.9924C3.33745 12.318 3.17305 11.862 3.17305 11.4228H1.37305C1.37305 12.414 1.78465 13.2492 2.42065 14.0832C3.04225 14.8968 3.95665 15.81 5.08945 16.9428L6.36265 15.6708Z\"\r\n              fill=\"#1D2939\" />\r\n            <path d=\"M23.2 6.9832L25 8.2C25 4.582 22.4056 1.5796 19 1M2.8 19.0168L1 17.8C1 21.418 3.5944 24.4204 7 25\"\r\n              stroke=\"#1D2939\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n          </svg>\r\n        </button>\r\n      </div>\r\n      <div class=\"hide-scrollbar\" style=\"height: 92%; overflow: scroll; position: relative;\" #scrollContainer>\r\n        <canvas #gridCanvas>\r\n\r\n        </canvas>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <div *ngIf=\"planoStoreList.length > 1\" class=\"col-12 mt-6\">\r\n    <div style=\"padding: 0px !important;\" class=\"c-card\">\r\n        <lib-pagination [itemsPerPage]=\"itemsPerPage\" (pageChange)=\"onPageChange($event)\" [currentPage]=\"currentPage\" [totalItems]=\"totalItems\"\r\n            [paginationSizes]=\"paginationSizes\" [pageSize]=\"pageSize\"></lib-pagination>\r\n    </div>\r\n</div>\r\n\r\n</div>\r\n\r\n<ng-template #completeLayout let-modal>\r\n  <div class=\"card\">\r\n    <div style=\"min-height: unset; border-bottom: unset;  padding-top: 2.25rem;\" class=\"card-header\">\r\n      <div class=\"card-title\">\r\n        <span class=\"modal-header-txt\">Complete Layout</span>\r\n      </div>\r\n    </div>\r\n    <div style=\"padding-top: 1rem;\" class=\"card-body\">\r\n      <div class=\"form-check\">\r\n        <input (ngModelChange)=\"onModalTypeChange($event)\" [(ngModel)]=\"markAsCompleteType\" class=\"form-check-input\" type=\"radio\" name=\"one\" id=\"single\"\r\n          value=\"single\">\r\n        <div class=\"ms-3\">\r\n          <div class=\"modal-main-txt\">Mark as complete for only <span\r\n              class=\"highlight-txt\">{{selectedStore?.storeName}}</span></div>\r\n          <div class=\"modal-sub-txt\">This action will considered as layout completion for {{selectedStore?.storeName}}\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <div class=\"w-100 h-0 border my-5 border-bottom-grey\"></div>\r\n      <div class=\"form-check mb-5\">\r\n        <input (ngModelChange)=\"onModalTypeChange($event)\" [(ngModel)]=\"markAsCompleteType\" class=\"form-check-input\" type=\"radio\" name=\"one\" id=\"multiple\"\r\n          value=\"multiple\">\r\n        <div class=\"ms-3\">\r\n          <div class=\"modal-main-txt\">Mark as complete for all {{planoStoreList.length}} stores</div>\r\n        </div>\r\n      </div>\r\n      <div *ngIf=\"markAsCompleteType === 'multiple'\" class=\"table-responsive\">\r\n        <table class=\"table\">\r\n          <thead>\r\n            <tr style=\"border-bottom: 1px solid #EAECF0; background: #FCFCFD;\">\r\n              <th>\r\n                <div class=\"form-check\">\r\n                  <input (click)=\"onModalSelectAll($event)\" [(ngModel)]=\"isAllStoreSelected\" class=\"form-check-input c-checkbox\" type=\"checkbox\">\r\n                  <label class=\"form-check-label check-label modal-storeName\">\r\n                    Store Name\r\n                  </label>\r\n                </div>\r\n              </th>\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <tr style=\"border-bottom: 1px solid #EAECF0;\" *ngFor=\"let store of planoStoreList\">\r\n              <td>\r\n                <div class=\"form-check\">\r\n                  <input [(ngModel)]=\"store.selected\" class=\"form-check-input c-checkbox\" type=\"checkbox\">\r\n                  <label class=\"form-check-label check-label modal-storeName\">\r\n                    {{store?.storeName}}\r\n                  </label>\r\n                </div>\r\n              </td>\r\n            </tr>\r\n          </tbody>\r\n        </table>\r\n      </div>\r\n      <div class=\"d-flex align-items-center justify-content-end\">\r\n        <button (click)=\"modal.dismiss()\" class=\"btn btn-outline bg-white me-5\">Cancel</button>\r\n        <button (click)=\"updatePlanoStatus(); modal.dismiss()\" class=\"btn btn-sm btn-primary \">Complete</button>\r\n      </div>\r\n    </div>\r\n  </div>\r\n\r\n</ng-template>", styles: [".storename-txt{color:var(--Black, #101828);font-size:16px;font-weight:600;line-height:24px}.c-card{padding:16px;border-radius:8px;background:#fff}.l-pane-head{color:#101828;font-size:18px;font-weight:600;line-height:28px}.l-pane-desc{color:#475467;font-size:12px;font-weight:400;line-height:18px}.no-steps-txt{color:#101828;font-size:18px;font-weight:500;line-height:28px}.no-text-desc{color:#101828;font-size:14px;font-weight:400;line-height:20px}.hide-scrollbar{overflow:scroll;-ms-overflow-style:none;scrollbar-width:none}.hide-scrollbar::-webkit-scrollbar{display:none}.popup{position:absolute;background:#fff;border:1px solid black;padding:10px;box-shadow:0 4px 8px #0003;z-index:1000}.resize-icon{cursor:pointer;border-radius:727.273px;background:#fff;box-shadow:0 8.727px 11.636px -2.909px #10182814,0 2.909px 4.364px -1.455px #10182808;position:absolute;right:-13px;top:70px;padding:7.273px}.resize-icon svg{width:17.455px;height:17.455px}.area-card{padding:20px;border-radius:6px;border:1px solid #D0D5DD;background:#fff;box-shadow:0 1px 3px #1018281a,0 1px 2px #1018280f;display:flex;justify-content:space-between}.area-card .main-txt{color:#101828;font-size:30px;font-weight:600;line-height:38px}.area-card .unit-txt{color:#101828;font-size:20px;font-style:italic;font-weight:600;line-height:30px}.area-card .sub-txt{color:#475467;font-size:16px;font-weight:500;line-height:24px}th{background:unset!important;border-bottom:unset!important;color:#1d2939;font-size:14px!important;font-weight:600!important;line-height:20px!important}.table-td{padding:10px 14px;border-radius:8px;background:#f9fafb}.floor-select{width:155px;height:44px;border-radius:8px;border:1px solid #D0D5DD;background:#fff;box-shadow:0 1px 2px #1018280d;position:relative;display:flex;justify-content:space-between;padding:10px 16px;cursor:pointer;color:#344054;font-size:14px;font-weight:600;line-height:20px}.floor-select ul{width:240px;box-shadow:0 20px 24px -4px #10182814,0 8px 8px -4px #10182808;position:absolute;top:45px;left:0;background:#fff;z-index:4}.floor-select ul li{position:relative;padding:10px 16px;color:#1d2939;font-size:14px;font-weight:500;line-height:20px;align-items:center;cursor:pointer}.floor-select ul li .option{width:200px;position:absolute;padding:10px 16px;background:#fef3f2;color:#d92d20;font-size:14px;font-weight:500;line-height:20px;right:-200px;top:0}.floor-select ul li:hover,.floor-select ul .selected{background:var(--Gray-100, #F2F4F7)}.modal-header-txt{color:#344054;font-size:16px;font-weight:500;line-height:24px}.modal-main-txt{color:#1d2939;font-size:18px;font-weight:600;line-height:28px}.modal-main-txt .highlight-txt{color:#344054;font-size:16px;font-weight:600;line-height:24px}.modal-sub-txt{color:#667085;font-size:16px;font-weight:400;line-height:24px}.modal-storeName{color:#667085;font-size:14px;font-weight:500;line-height:20px}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i6.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i6.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { kind: "directive", type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.PaginationComponent, selector: "lib-pagination", inputs: ["collection", "itemsPerPage", "currentPage", "totalItems", "directionLinks", "pageSize", "paginationSizes"], outputs: ["pageChange", "pageSizeChange"] }, { kind: "component", type: i7.CustomSelectComponent, selector: "lib-select-plano", inputs: ["items", "searchField", "multi", "idField", "selectedValues", "disabled", "label"], outputs: ["selected"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LayoutSummaryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-layout-summary', template: "<div class=\"d-flex align-items-center justify-content-between mb-6\">\r\n  <div>\r\n    <div *ngIf=\"planoStoreList.length === 1\" class=\"storename-txt\">\r\n      {{selectedStore?.storeName}} - Layout\r\n    </div>\r\n    <div *ngIf=\"planoStoreList.length > 1\">\r\n      <lib-select-plano [items]=\"planoStoreList\" [multi]=\"false\" [searchField]=\"'storeName'\" [idField]=\"'storeId'\"\r\n        (selected)=\"onStoreChange($event)\" [selectedValues]=\"[selectedStore]\"></lib-select-plano>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"d-flex align-items-center\">\r\n    <button (click)=\"onComplete()\" class=\"btn btn-sm btn-primary me-5\">Complete</button>\r\n    <button (click)=\"openOffCanva()\" class=\"btn btn-sm btn-outline bg-white\">\r\n      <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n        <path\r\n          d=\"M9 3V21M5 3H19C20.1046 3 21 3.89543 21 5V19C21 20.1046 20.1046 21 19 21H5C3.89543 21 3 20.1046 3 19V5C3 3.89543 3.89543 3 5 3Z\"\r\n          stroke=\"#101828\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n      </svg>\r\n    </button>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"row mb-6\">\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{wallCapacity || 0}}</span> <span class=\"unit-txt\">rft</span> </div>\r\n        <div class=\"sub-txt\">Wall capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"65\" height=\"65\" viewBox=\"0 0 65 65\" fill=\"none\">\r\n          <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n            d=\"M4.33333 4.33333V0H8.66667V4.33333H21.6667V0H26V4.33333H39V0H43.3333V4.33333H56.3333V0H60.6667V4.33333H65V8.66667H60.6667V21.6667H65V26H60.6667V39H65V43.3333H60.6667V56.3333H65V60.6667H60.6667V65H56.3333V60.6667H43.3333V65H39V60.6667H26V65H21.6667V60.6667H8.66667V65H4.33333V60.6667H0V56.3333H4.33333V43.3333H0V39H4.33333V26H0V21.6667H4.33333V8.66667H0V4.33333H4.33333ZM8.66667 8.66667V21.6667H21.6667V8.66667H8.66667ZM26 8.66667V21.6667H39V8.66667H26ZM43.3333 8.66667V21.6667H56.3333V8.66667H43.3333ZM56.3333 26H43.3333V39H56.3333V26ZM56.3333 43.3333H43.3333V56.3333H56.3333V43.3333ZM39 56.3333V43.3333H26V56.3333H39ZM21.6667 56.3333V43.3333H8.66667V56.3333H21.6667ZM8.66667 39H21.6667V26H8.66667V39ZM26 26V39H39V26H26Z\"\r\n            fill=\"#344054\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{facadeCapacity || 0}}</span> <span class=\"unit-txt\">rft</span> </div>\r\n        <div class=\"sub-txt\">Facade capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg width=\"65\" height=\"65\" viewBox=\"0 0 65 65\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n          <rect x=\"0.5\" y=\"0.5\" width=\"64\" height=\"64\" fill=\"#FDFDFD\" stroke=\"black\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{floorCapacity || 0}}</span> <span class=\"unit-txt\">sqft</span> </div>\r\n        <div class=\"sub-txt\">Floor capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"102\" height=\"58\" viewBox=\"0 0 102 58\" fill=\"none\">\r\n          <path d=\"M3.54359 36.4607L29.8929 2.06432L98.0939 6.44191L99.908 55.5468L3.54359 36.4607Z\" stroke=\"#475467\"\r\n            stroke-width=\"4\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"row\">\r\n  <div class=\"col-4\">\r\n    <div class=\"c-card\" style=\"height: 75dvh; position: relative;\">\r\n      <div class=\"d-flex align-items-center justify-content-between mb-5\" style=\"height: 8%;\">\r\n        <div>\r\n          <div class=\"l-pane-head\">\r\n            Capacity details\r\n          </div>\r\n          <div class=\"l-pane-desc\">\r\n            Below are the capacity details of the elements\r\n          </div>\r\n        </div>\r\n        <div class=\"d-flex align-items-center\">\r\n\r\n        </div>\r\n\r\n      </div>\r\n\r\n      <div class=\"table-responsive hide-scrollbar \" style=\"height: 92%;\">\r\n        <table class=\"table\">\r\n          <thead class=\"thead-light\">\r\n            <tr>\r\n              <th>#</th>\r\n              <th> <svg class=\"me-2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"\r\n                  fill=\"none\">\r\n                  <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n                    d=\"M1.33333 1.33333V0L2.66667 0V1.33333L6.66667 1.33333V0L8 0V1.33333L12 1.33333V0L13.3333 0V1.33333L17.3333 1.33333V0L18.6667 0V1.33333H20V2.66667H18.6667V6.66667H20V8H18.6667V12H20V13.3333H18.6667V17.3333H20V18.6667H18.6667V20H17.3333V18.6667H13.3333V20H12V18.6667H8V20H6.66667V18.6667H2.66667V20H1.33333V18.6667H0L0 17.3333H1.33333L1.33333 13.3333H0L0 12H1.33333L1.33333 8H0L0 6.66667H1.33333L1.33333 2.66667H0L0 1.33333H1.33333ZM2.66667 2.66667L2.66667 6.66667H6.66667V2.66667L2.66667 2.66667ZM8 2.66667V6.66667H12V2.66667L8 2.66667ZM13.3333 2.66667V6.66667H17.3333V2.66667H13.3333ZM17.3333 8L13.3333 8V12L17.3333 12V8ZM17.3333 13.3333L13.3333 13.3333L13.3333 17.3333H17.3333V13.3333ZM12 17.3333L12 13.3333H8L8 17.3333H12ZM6.66667 17.3333V13.3333H2.66667V17.3333H6.66667ZM2.66667 12H6.66667V8H2.66667L2.66667 12ZM8 8V12H12V8H8Z\"\r\n                    fill=\"#344054\" />\r\n                </svg> <span>Wall</span> </th>\r\n              <th>RFT ({{wallCapacity || 0}})</th>\r\n\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <ng-container *ngFor=\"let item of layoutPolygon; let i = index\">\r\n              <tr *ngIf=\"item[2] && item[2].elementType === 'wall'\">\r\n                <td>\r\n                  {{1}}\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].elementType}} {{item[2].elementNumber}}</div>\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].distance}}</div>\r\n\r\n                </td>\r\n              </tr>\r\n            </ng-container>\r\n\r\n          </tbody>\r\n        </table>\r\n        <table class=\"table\">\r\n          <thead class=\"thead-light\">\r\n            <tr>\r\n              <th>#</th>\r\n              <th> <svg class=\"me-2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"22\" height=\"22\" viewBox=\"0 0 22 22\"\r\n                  fill=\"none\">\r\n                  <path\r\n                    d=\"M1 11V2.25C1 1.5625 1.5625 1 2.25 1H19.75C20.4375 1 21 1.5625 21 2.25V19.75C21 20.4375 20.4375 21 19.75 21H2.25C1.5625 21 1 20.4375 1 19.75V11Z\"\r\n                    stroke=\"#344054\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg> <span>Facade</span> </th>\r\n              <th>RFT ({{facadeCapacity || 0}})</th>\r\n\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <ng-container *ngFor=\"let item of layoutPolygon; let i = index\">\r\n              <tr *ngIf=\"item[2] && item[2].elementType === 'facade'\">\r\n                <td>\r\n                  {{i}}\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].elementType}} {{item[2].elementNumber}}</div>\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].distance}}</div>\r\n\r\n                </td>\r\n              </tr>\r\n            </ng-container>\r\n\r\n          </tbody>\r\n        </table>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n  <div class=\"col-8\">\r\n    <div class=\"c-card \" style=\"height: 75dvh;\">\r\n      <div style=\"height: 8%;\" class=\"d-flex align-items-center justify-content-between\">\r\n        <div>\r\n          <!-- <lib-reactive-select *ngIf=\"floorsInput.value\" [formControl]=\"floorsInput\" [idField]=\"'id'\"\r\n            [nameField]=\"'floorName'\" [data]=\"selectedStore?.floor\"></lib-reactive-select> -->\r\n          <div (click)=\"toggleFloorSelect()\" class=\"floor-select\">\r\n            <div>{{selectedFloor?.floorName}}</div>\r\n            <div><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                <path d=\"M5 7.5L10 12.5L15 7.5\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\"\r\n                  stroke-linejoin=\"round\" />\r\n              </svg></div>\r\n            <ul *ngIf=\"floorSelect?.show\" class=\"list-unstyled mb-2\">\r\n              <li (click)=\"onFloorSelect(floor.id)\" *ngFor=\"let floor of selectedStore?.floor; let i = index\"\r\n                [ngClass]=\"floor.id === selectedFloor.id ? 'selected': ''\">\r\n                <div class=\"d-flex justify-content-between\">\r\n                  <span>{{floor?.floorName}}</span>\r\n\r\n                </div>\r\n\r\n              </li>\r\n            </ul>\r\n          </div>\r\n        </div>\r\n        <button class=\"btn btn-sm btn-outline bg-white\" (click)=\"rotatePolygons()\">\r\n          <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" fill=\"none\">\r\n            <path\r\n              d=\"M6.36265 7.17838L7.17625 6.36238L5.90425 5.09158L5.08945 5.90518L6.36265 7.17838ZM15.671 6.36358L19.6379 10.3304L20.9099 9.0572L16.9442 5.09038L15.671 6.36358ZM19.6379 18.8252L18.8243 19.6388L20.0963 20.9096L20.9099 20.0972L19.6379 18.8252ZM10.3295 19.6388L6.36265 15.672L5.09065 16.9452L9.05626 20.9108L10.3295 19.6388ZM18.8243 19.6388C17.6543 20.8076 16.8407 21.6188 16.1459 22.1492C15.4715 22.664 15.0155 22.8284 14.5763 22.8284V24.6284C15.5675 24.6284 16.4027 24.2168 17.2367 23.5808C18.0503 22.9604 18.9635 22.0448 20.0963 20.912L18.8243 19.6388ZM9.05626 20.9108C10.1891 22.0448 11.1023 22.9592 11.9159 23.5808C12.7499 24.2168 13.5851 24.6284 14.5763 24.6284V22.8284C14.1371 22.8284 13.6823 22.664 13.0067 22.1492C12.3119 21.6188 11.4983 20.8076 10.3295 19.6388L9.05626 20.9108ZM19.6379 10.3304C20.8067 11.4992 21.6179 12.3128 22.1483 13.0076C22.6631 13.6832 22.8275 14.138 22.8275 14.5772H24.6275C24.6275 13.586 24.2159 12.7508 23.5799 11.9168C22.9595 11.1032 22.0427 10.19 20.9099 9.0572L19.6379 10.3304ZM20.9099 20.0972C22.0439 18.9632 22.9583 18.0512 23.5799 17.2376C24.2159 16.4036 24.6275 15.5684 24.6275 14.5772H22.8275C22.8275 15.0164 22.6631 15.4724 22.1483 16.1468C21.6179 16.8416 20.8067 17.6552 19.6379 18.8252L20.9099 20.0972ZM7.17625 6.36238C8.34625 5.19358 9.15985 4.38118 9.85465 3.85078C10.529 3.33598 10.985 3.17278 11.4242 3.17278V1.37158C10.433 1.37158 9.59785 1.78318 8.76385 2.41918C7.94905 3.04078 7.03705 3.95518 5.90425 5.08798L7.17625 6.36238ZM16.9442 5.09038C15.8114 3.95638 14.8982 3.04078 14.0846 2.41918C13.2506 1.78318 12.4154 1.37158 11.4242 1.37158V3.17278C11.8634 3.17278 12.3182 3.33598 12.9938 3.85078C13.6886 4.38118 14.5022 5.19238 15.671 6.36118L16.9442 5.09038ZM5.08945 5.90278C3.95665 7.03558 3.04225 7.94758 2.42065 8.76238C1.78465 9.59638 1.37305 10.4316 1.37305 11.4228H3.17305C3.17305 10.9836 3.33745 10.5276 3.85225 9.85318C4.38265 9.15838 5.19385 8.34478 6.36265 7.17478L5.08945 5.90278ZM6.36265 15.6708C5.19385 14.5008 4.38265 13.6872 3.85225 12.9924C3.33745 12.318 3.17305 11.862 3.17305 11.4228H1.37305C1.37305 12.414 1.78465 13.2492 2.42065 14.0832C3.04225 14.8968 3.95665 15.81 5.08945 16.9428L6.36265 15.6708Z\"\r\n              fill=\"#1D2939\" />\r\n            <path d=\"M23.2 6.9832L25 8.2C25 4.582 22.4056 1.5796 19 1M2.8 19.0168L1 17.8C1 21.418 3.5944 24.4204 7 25\"\r\n              stroke=\"#1D2939\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n          </svg>\r\n        </button>\r\n      </div>\r\n      <div class=\"hide-scrollbar\" style=\"height: 92%; overflow: scroll; position: relative;\" #scrollContainer>\r\n        <canvas #gridCanvas>\r\n\r\n        </canvas>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <div *ngIf=\"planoStoreList.length > 1\" class=\"col-12 mt-6\">\r\n    <div style=\"padding: 0px !important;\" class=\"c-card\">\r\n        <lib-pagination [itemsPerPage]=\"itemsPerPage\" (pageChange)=\"onPageChange($event)\" [currentPage]=\"currentPage\" [totalItems]=\"totalItems\"\r\n            [paginationSizes]=\"paginationSizes\" [pageSize]=\"pageSize\"></lib-pagination>\r\n    </div>\r\n</div>\r\n\r\n</div>\r\n\r\n<ng-template #completeLayout let-modal>\r\n  <div class=\"card\">\r\n    <div style=\"min-height: unset; border-bottom: unset;  padding-top: 2.25rem;\" class=\"card-header\">\r\n      <div class=\"card-title\">\r\n        <span class=\"modal-header-txt\">Complete Layout</span>\r\n      </div>\r\n    </div>\r\n    <div style=\"padding-top: 1rem;\" class=\"card-body\">\r\n      <div class=\"form-check\">\r\n        <input (ngModelChange)=\"onModalTypeChange($event)\" [(ngModel)]=\"markAsCompleteType\" class=\"form-check-input\" type=\"radio\" name=\"one\" id=\"single\"\r\n          value=\"single\">\r\n        <div class=\"ms-3\">\r\n          <div class=\"modal-main-txt\">Mark as complete for only <span\r\n              class=\"highlight-txt\">{{selectedStore?.storeName}}</span></div>\r\n          <div class=\"modal-sub-txt\">This action will considered as layout completion for {{selectedStore?.storeName}}\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <div class=\"w-100 h-0 border my-5 border-bottom-grey\"></div>\r\n      <div class=\"form-check mb-5\">\r\n        <input (ngModelChange)=\"onModalTypeChange($event)\" [(ngModel)]=\"markAsCompleteType\" class=\"form-check-input\" type=\"radio\" name=\"one\" id=\"multiple\"\r\n          value=\"multiple\">\r\n        <div class=\"ms-3\">\r\n          <div class=\"modal-main-txt\">Mark as complete for all {{planoStoreList.length}} stores</div>\r\n        </div>\r\n      </div>\r\n      <div *ngIf=\"markAsCompleteType === 'multiple'\" class=\"table-responsive\">\r\n        <table class=\"table\">\r\n          <thead>\r\n            <tr style=\"border-bottom: 1px solid #EAECF0; background: #FCFCFD;\">\r\n              <th>\r\n                <div class=\"form-check\">\r\n                  <input (click)=\"onModalSelectAll($event)\" [(ngModel)]=\"isAllStoreSelected\" class=\"form-check-input c-checkbox\" type=\"checkbox\">\r\n                  <label class=\"form-check-label check-label modal-storeName\">\r\n                    Store Name\r\n                  </label>\r\n                </div>\r\n              </th>\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <tr style=\"border-bottom: 1px solid #EAECF0;\" *ngFor=\"let store of planoStoreList\">\r\n              <td>\r\n                <div class=\"form-check\">\r\n                  <input [(ngModel)]=\"store.selected\" class=\"form-check-input c-checkbox\" type=\"checkbox\">\r\n                  <label class=\"form-check-label check-label modal-storeName\">\r\n                    {{store?.storeName}}\r\n                  </label>\r\n                </div>\r\n              </td>\r\n            </tr>\r\n          </tbody>\r\n        </table>\r\n      </div>\r\n      <div class=\"d-flex align-items-center justify-content-end\">\r\n        <button (click)=\"modal.dismiss()\" class=\"btn btn-outline bg-white me-5\">Cancel</button>\r\n        <button (click)=\"updatePlanoStatus(); modal.dismiss()\" class=\"btn btn-sm btn-primary \">Complete</button>\r\n      </div>\r\n    </div>\r\n  </div>\r\n\r\n</ng-template>", styles: [".storename-txt{color:var(--Black, #101828);font-size:16px;font-weight:600;line-height:24px}.c-card{padding:16px;border-radius:8px;background:#fff}.l-pane-head{color:#101828;font-size:18px;font-weight:600;line-height:28px}.l-pane-desc{color:#475467;font-size:12px;font-weight:400;line-height:18px}.no-steps-txt{color:#101828;font-size:18px;font-weight:500;line-height:28px}.no-text-desc{color:#101828;font-size:14px;font-weight:400;line-height:20px}.hide-scrollbar{overflow:scroll;-ms-overflow-style:none;scrollbar-width:none}.hide-scrollbar::-webkit-scrollbar{display:none}.popup{position:absolute;background:#fff;border:1px solid black;padding:10px;box-shadow:0 4px 8px #0003;z-index:1000}.resize-icon{cursor:pointer;border-radius:727.273px;background:#fff;box-shadow:0 8.727px 11.636px -2.909px #10182814,0 2.909px 4.364px -1.455px #10182808;position:absolute;right:-13px;top:70px;padding:7.273px}.resize-icon svg{width:17.455px;height:17.455px}.area-card{padding:20px;border-radius:6px;border:1px solid #D0D5DD;background:#fff;box-shadow:0 1px 3px #1018281a,0 1px 2px #1018280f;display:flex;justify-content:space-between}.area-card .main-txt{color:#101828;font-size:30px;font-weight:600;line-height:38px}.area-card .unit-txt{color:#101828;font-size:20px;font-style:italic;font-weight:600;line-height:30px}.area-card .sub-txt{color:#475467;font-size:16px;font-weight:500;line-height:24px}th{background:unset!important;border-bottom:unset!important;color:#1d2939;font-size:14px!important;font-weight:600!important;line-height:20px!important}.table-td{padding:10px 14px;border-radius:8px;background:#f9fafb}.floor-select{width:155px;height:44px;border-radius:8px;border:1px solid #D0D5DD;background:#fff;box-shadow:0 1px 2px #1018280d;position:relative;display:flex;justify-content:space-between;padding:10px 16px;cursor:pointer;color:#344054;font-size:14px;font-weight:600;line-height:20px}.floor-select ul{width:240px;box-shadow:0 20px 24px -4px #10182814,0 8px 8px -4px #10182808;position:absolute;top:45px;left:0;background:#fff;z-index:4}.floor-select ul li{position:relative;padding:10px 16px;color:#1d2939;font-size:14px;font-weight:500;line-height:20px;align-items:center;cursor:pointer}.floor-select ul li .option{width:200px;position:absolute;padding:10px 16px;background:#fef3f2;color:#d92d20;font-size:14px;font-weight:500;line-height:20px;right:-200px;top:0}.floor-select ul li:hover,.floor-select ul .selected{background:var(--Gray-100, #F2F4F7)}.modal-header-txt{color:#344054;font-size:16px;font-weight:500;line-height:24px}.modal-main-txt{color:#1d2939;font-size:18px;font-weight:600;line-height:28px}.modal-main-txt .highlight-txt{color:#344054;font-size:16px;font-weight:600;line-height:24px}.modal-sub-txt{color:#667085;font-size:16px;font-weight:400;line-height:24px}.modal-storeName{color:#667085;font-size:14px;font-weight:500;line-height:20px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }, { type: i2.StoreBuilderService }, { type: i3.NgbModal }, { type: i3.NgbOffcanvas }, { type: i1.Router }, { type: i3.NgbModal }, { type: i4.ToastService }], propDecorators: { canvasRef: [{
+                type: ViewChild,
+                args: ['gridCanvas', { static: true }]
+            }], scrollContainerRef: [{
+                type: ViewChild,
+                args: ['scrollContainer']
+            }], completeLayout: [{
+                type: ViewChild,
+                args: ['completeLayout']
+            }], onOutsideClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout-summary.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-store-builder/src/lib/components/layout-summary/layout-summary.component.ts","../../../../../../projects/tango-store-builder/src/lib/components/layout-summary/layout-summary.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport { AfterViewInit, ChangeDetectorRef, Component, ElementRef, EventEmitter, HostListener, Input, OnDestroy, OnInit, Output, Renderer2, ViewChild } from '@angular/core';\r\nimport { FormControl } from '@angular/forms';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { Subject, takeUntil } from 'rxjs';\r\nimport { HeaderFilter } from '../../interfaces/layout-builder.interface';\r\nimport { StoreBuilderService } from '../../services/store-builder.service';\r\nimport { NgbModal, NgbOffcanvas } from '@ng-bootstrap/ng-bootstrap';\r\nimport { StoreOffcanvasComponentComponent } from '../store-offcanvas-component/store-offcanvas-component.component';\r\nimport { CompleteLayoutComponent } from './popups/complete-layout/complete-layout.component';\r\nimport { ToastService } from 'tango-app-ui-shared';\r\n\r\n@Component({\r\n  selector: 'lib-layout-summary',\r\n  templateUrl: './layout-summary.component.html',\r\n  styleUrl: './layout-summary.component.scss'\r\n})\r\nexport class LayoutSummaryComponent implements OnInit, AfterViewInit, OnDestroy {\r\n\r\n  floorsInput = new FormControl()\r\n  @ViewChild('gridCanvas', { static: true }) canvasRef!: ElementRef<HTMLCanvasElement>;\r\n  @ViewChild('scrollContainer') scrollContainerRef!: ElementRef;\r\n  @ViewChild('completeLayout') completeLayout!: ElementRef;\r\n\r\n\r\n  gridWidth = 5;\r\n  gridHeight = 5;\r\n\r\n  private ctx!: CanvasRenderingContext2D;\r\n  private canvas!: HTMLCanvasElement;\r\n\r\n  layoutPolygon: any[] = [[\r\n    {\r\n      \"x\": 100,\r\n      \"y\": 100\r\n    },\r\n    {\r\n      \"x\": 100,\r\n      \"y\": 100\r\n    },\r\n    {\r\n      \"elementType\": \"wall\",\r\n      \"distance\": 0,\r\n      \"unit\": \"ft\",\r\n      \"direction\": \"right\",\r\n      \"angle\": 90,\r\n      \"elementNumber\": 1\r\n    }\r\n  ]]\r\n\r\n  private scale = 1;\r\n\r\n  private destroy$ = new Subject<void>();\r\n\r\n  headerData: HeaderFilter | null | undefined;\r\n\r\n  planoStoreList: any[] = []\r\n  selectedStore: any\r\n  selectedFloor: any\r\n  wallCapacity: number\r\n  facadeCapacity: number\r\n  floorCapacity: number\r\n\r\n  floorSelect: { show: boolean, deleteIndex: number | null } = { show: false, deleteIndex: null }\r\n\r\n  markAsCompleteType: 'single' | 'multiple' = 'single'\r\n\r\n  itemsPerPage = 1\r\n  currentPage = 0\r\n  totalItems = 1\r\n  paginationSizes = [1]\r\n  pageSize = 1\r\n\r\n  pixelPerMetre: number = 50\r\n\r\n\r\n  onFloorSelect(floorId: string) {\r\n    if (this.layoutPolygon[0][0].x !== this.layoutPolygon[0][1].x && this.layoutPolygon[0][0].y !== this.layoutPolygon[0][1].y) {\r\n      this.updateFloorLayout()\r\n    }\r\n    this.selectedFloor = this.selectedStore.floor.filter((floor: any) => floor.id === floorId)[0]\r\n    this.generateLayoutPolygon(this.selectedFloor.layoutPolygon)\r\n  }\r\n\r\n  @HostListener('document:click', ['$event'])\r\n  onOutsideClick(event: MouseEvent): void {\r\n\r\n    const clickedInside6 = (event.target as HTMLElement).closest('.floor-select');\r\n    if (!clickedInside6) {\r\n      this.floorSelect = { show: false, deleteIndex: null };\r\n    }\r\n  }\r\n\r\n  toggleFloorSelect(): void {\r\n    this.floorSelect = {\r\n      show: !this.floorSelect.show,\r\n      deleteIndex: null\r\n    };\r\n  }\r\n\r\n  constructor(private route: ActivatedRoute, private apiService: StoreBuilderService, private modalService: NgbModal,\r\n    private offcanvasService: NgbOffcanvas, private router: Router, private modalDef: NgbModal, private toastService:ToastService) {\r\n    this.headerData = JSON.parse(localStorage.getItem('header-filters') as string)\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.initializeLayout()\r\n  }\r\n\r\n  initializeLayout() {\r\n    const centerX = this.canvas.width / 2 / this.scale;\r\n    const centerY = this.canvas.height / 2 / this.scale;\r\n\r\n    this.layoutPolygon = [\r\n      [\r\n        {\r\n          \"x\": this.snapToGrid(centerX, this.gridHeight),\r\n          \"y\": this.snapToGrid(centerY, this.gridWidth)\r\n        },\r\n        {\r\n          \"x\": this.snapToGrid(centerX, this.gridHeight),\r\n          \"y\": this.snapToGrid(centerY, this.gridWidth)\r\n        },\r\n        {\r\n          \"elementType\": \"wall\",\r\n          \"distance\": 0,\r\n          \"unit\": \"ft\",\r\n          \"direction\": \"right\",\r\n          \"angle\": 90,\r\n          \"elementNumber\": 1\r\n        }\r\n      ]\r\n    ]\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.canvas = this.canvasRef.nativeElement;\r\n    this.ctx = this.canvas.getContext('2d')!;\r\n\r\n    this.canvas.width = 10000;\r\n    this.canvas.height = 10000;\r\n\r\n\r\n    this.drawGrid();\r\n\r\n    this.route.queryParams\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((params) => {\r\n        if (params?.id) {\r\n          const ids = params.id.split(',') || [];\r\n          this.getPlanoData(ids)\r\n        }\r\n      });\r\n\r\n    this.floorsInput.valueChanges.subscribe((val) => {\r\n      if (val) {\r\n        if (this.layoutPolygon[0][0].x !== this.layoutPolygon[0][1].x && this.layoutPolygon[0][0].y !== this.layoutPolygon[0][1].y) {\r\n          this.updateFloorLayout()\r\n        }\r\n        this.selectedFloor = this.selectedStore.floor.filter((floor: any) => floor.id === val)[0]\r\n        this.generateLayoutPolygon(this.selectedFloor.layoutPolygon)\r\n      }\r\n    })\r\n\r\n  }\r\n\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n  }\r\n\r\n  onStoreChange(event: any) {\r\n    if (this.layoutPolygon[0][0].x !== this.layoutPolygon[0][1].x && this.layoutPolygon[0][0].y !== this.layoutPolygon[0][1].y) {\r\n      this.updateFloorLayout()\r\n    }\r\n    const index = this.planoStoreList.findIndex(item => item.planoId === event.planoId);\r\n    this.currentPage = index + 1\r\n    this.selectedStore = event;\r\n    this.selectedFloor = this.selectedStore.floor[0];\r\n    this.floorsInput.setValue(this.selectedFloor.id, { emitEvent: false });\r\n    this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);\r\n  }\r\n\r\n  getPlanoData(planoId: string[]) {\r\n    const payload = {\r\n      id: planoId\r\n    }\r\n\r\n    this.apiService.getPlano(payload).subscribe({\r\n      next: (res: any) => {\r\n        this.planoStoreList = res.data\r\n        this.totalItems = res.data.length\r\n        // this.planoStoreList = res.data.filter((plano:any) => plano.status !== 'completed');\r\n        if (!this.selectedStore) {\r\n          this.selectedStore = this.planoStoreList[0]\r\n        } else {\r\n          this.selectedStore = this.planoStoreList.filter((store: any) => store.planoId === this.selectedStore.planoId)[0]\r\n        }\r\n        if (!this.selectedFloor) {\r\n          this.selectedFloor = this.selectedStore.floor[0]\r\n        } else {\r\n          this.selectedFloor = this.selectedStore.floor.filter((floor: any) => floor.id === this.selectedFloor.id)[0]\r\n        }\r\n\r\n        this.planoStoreList.forEach((store) => {\r\n          if (store.planoId === this.selectedStore.planoId) {\r\n            store.selected = true\r\n          }\r\n        })\r\n\r\n        this.floorsInput.setValue(this.selectedFloor.id, { emitEvent: false })\r\n        this.generateLayoutPolygon(this.selectedFloor.layoutPolygon)\r\n      },\r\n      error: (err) => {\r\n        console.log(err)\r\n      }\r\n    })\r\n  }\r\n\r\n  updateFloorLayout() {\r\n    const payload = {\r\n      id: this.selectedFloor.id,\r\n      layoutPolygon: this.layoutPolygon.map((segment) => {\r\n        const [point1, point2, properties] = segment\r\n        return properties\r\n      })\r\n    }\r\n\r\n    this.apiService.updateFloorLayout(payload).subscribe({\r\n      next: (res) => {\r\n        this.getPlanoData(this.selectedStore.planoId)\r\n      },\r\n      error: (err) => {\r\n        console.log(err)\r\n      }\r\n    })\r\n  }\r\n\r\n  onComplete() {\r\n\r\n    if (this.planoStoreList.length === 1) {\r\n      const modelRef = this.modalDef.open(CompleteLayoutComponent, { centered: true });\r\n      modelRef.result.then((val: any) => {\r\n        if (val.message === 'confirm') {\r\n          this.updatePlanoStatus()\r\n        }\r\n      })\r\n    } else {\r\n      this.modalService.open(this.completeLayout, { centered: true, size: \"lg\" })\r\n    }\r\n  }\r\n\r\n\r\n  drawGrid(): void {\r\n    this.ctx.save();\r\n    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);\r\n    this.ctx.scale(this.scale, this.scale);\r\n    this.ctx.fillStyle = 'white';\r\n    this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);\r\n\r\n  }\r\n\r\n  drawPolygon(polygon = this.layoutPolygon) {\r\n    if (polygon.length < 1) return; // If the polygon has no edges, exit early.\r\n\r\n    this.ctx.save(); // Save the current canvas state.\r\n    this.ctx.scale(this.scale, this.scale); // Scale the canvas context to match the desired scale.\r\n    // this.ctx.translate(this.panOffset.x, this.panOffset.y);\r\n\r\n\r\n    // Function to draw an arrowhead at a specific location and angle.\r\n    function drawArrowhead(ctx: any, x: any, y: any, angle: any) {\r\n      const size = 5; // Define the size of the arrowhead.\r\n      ctx.save(); // Save the current canvas state.\r\n      ctx.translate(x, y); // Move the context to the arrowhead position.\r\n      ctx.rotate(angle); // Rotate the context to match the arrow's angle.\r\n      ctx.beginPath(); // Start a new path.\r\n      ctx.moveTo(0, 0); // Move to the tip of the arrowhead.\r\n      ctx.lineTo(-size, -size / 2); // Draw one side of the arrowhead.\r\n      ctx.lineTo(-size, size / 2); // Draw the other side of the arrowhead.\r\n      ctx.closePath(); // Close the arrowhead path.\r\n      ctx.fillStyle = 'black'; // Set the arrowhead color.\r\n      ctx.fill(); // Fill the arrowhead.\r\n      ctx.restore(); // Restore the previous canvas state.\r\n    }\r\n\r\n    this.ctx.beginPath(); // Begin the main polygon path.\r\n    polygon.forEach((edge, edgeIndex) => {\r\n      const point = edge[0]; // Starting point of the edge.\r\n      const nextPoint = edge[1]; // Ending point of the edge.\r\n      const properties = edge[2]; // Properties of the edge (e.g., labels, distances).\r\n\r\n      // Draw the main polygon edge.\r\n      if (edgeIndex === 0) this.ctx.moveTo(point.x, point.y); // Move to the first edge starting point.\r\n      this.ctx.lineTo(nextPoint.x, nextPoint.y); // Draw a line to the next point.\r\n\r\n      // Calculate the perpendicular offset for the bounding box.\r\n      const dx = nextPoint.x - point.x; // X-difference between start and end points.\r\n      const dy = nextPoint.y - point.y; // Y-difference between start and end points.\r\n      const length = Math.sqrt(dx * dx + dy * dy); // Length of the edge.\r\n      const offsetX = (dy / length) * 20; // Offset in the X direction.\r\n      const offsetY = (-dx / length) * 20; // Offset in the Y direction.\r\n\r\n      // Define the bounding box points.\r\n      const boxPoints = [\r\n        { x: point.x, y: point.y },\r\n        { x: nextPoint.x, y: nextPoint.y },\r\n        { x: nextPoint.x + offsetX, y: nextPoint.y + offsetY },\r\n        { x: point.x + offsetX, y: point.y + offsetY },\r\n      ];\r\n\r\n      // Draw the bounding box.\r\n      this.ctx.beginPath();\r\n      this.ctx.moveTo(boxPoints[0].x, boxPoints[0].y);\r\n      boxPoints.forEach((pt, index) => {\r\n        if (properties.elementType === 'entrance') {\r\n          if (index < 2) {\r\n            this.ctx.lineTo(pt.x, pt.y)\r\n          }\r\n        } else {\r\n          this.ctx.lineTo(pt.x, pt.y); // Draw each edge of the box.\r\n        }\r\n      });\r\n      if (properties.elementType === 'opening') {\r\n        this.ctx.closePath(); // Close the bounding box path.\r\n        this.ctx.fillStyle = '#F9FAFB'; // Set a translucent fill color.\r\n        this.ctx.fill(); // Fill the bounding box.\r\n\r\n        this.ctx.strokeStyle = '#F9FAFB'\r\n\r\n        this.ctx.stroke(); // Draw the bounding box border. \r\n      } else {\r\n        this.ctx.closePath(); // Close the bounding box path.\r\n        this.ctx.fillStyle = '#F9FAFB'; // Set a translucent fill color.\r\n        this.ctx.fill(); // Fill the bounding box.\r\n        this.ctx.strokeStyle = '#1D2939'\r\n        this.ctx.stroke(); // Draw the bounding box border. \r\n      }\r\n\r\n\r\n      // Position text in the middle of the bounding box.\r\n      const textX = (boxPoints[1].x + boxPoints[3].x) / 2;\r\n      const textY = (boxPoints[1].y + boxPoints[3].y) / 2;\r\n\r\n      this.ctx.save(); // Save the current canvas state.\r\n      this.ctx.translate(textX, textY); // Move the context to the text position.\r\n\r\n      // Rotate text based on the edge direction.\r\n      if (dx === 0) {\r\n        this.ctx.rotate(-Math.PI / 2); // Rotate for vertical edges.\r\n      } else if (dy !== 0) {\r\n        const angle = Math.atan2(dy, dx); // Calculate angle for diagonal edges.\r\n        this.ctx.rotate(angle); // Rotate the text to match the angle.\r\n      }\r\n\r\n      // Draw the edge properties as text.\r\n      this.ctx.font = '12px Arial'; // Set the font style and size.\r\n      this.ctx.fillStyle = 'black'; // Set the text color.\r\n      this.ctx.textAlign = 'center'; // Align text to the center.\r\n      this.ctx.textBaseline = 'middle'; // Align text vertically in the middle.\r\n      this.ctx.fillText(\r\n        `${properties.elementType} ${properties.elementNumber} - ${properties.distance} ${properties.unit}`,\r\n        0,\r\n        0\r\n      );\r\n      this.ctx.restore(); // Restore the previous canvas state.\r\n\r\n      if (properties.distance >= 4) {\r\n        // Define the midpoints of the left and right edges of the bounding box.\r\n        const centerX = textX;\r\n        const centerY = textY;\r\n        const rightX = (boxPoints[1].x + boxPoints[2].x) / 2;\r\n        const rightY = (boxPoints[1].y + boxPoints[2].y) / 2;\r\n        const leftX = (boxPoints[0].x + boxPoints[3].x) / 2;\r\n        const leftY = (boxPoints[0].y + boxPoints[3].y) / 2;\r\n\r\n        // Helper function to adjust points by a specific distance.\r\n        function adjustPoint(x1: any, y1: any, x2: any, y2: any, distance: any) {\r\n          const angle = Math.atan2(y2 - y1, x2 - x1); // Calculate the angle.\r\n          return {\r\n            x: x1 + Math.cos(angle) * distance, // Adjust X by distance.\r\n            y: y1 + Math.sin(angle) * distance, // Adjust Y by distance.\r\n          };\r\n        }\r\n\r\n        // Define the arrow line start and end points for the right side.\r\n        const rightStart = adjustPoint(centerX, centerY, rightX, rightY, 50);\r\n        const rightEnd = adjustPoint(rightX, rightY, centerX, centerY, 10);\r\n\r\n        // Define the arrow line start and end points for the left side.\r\n        const leftStart = adjustPoint(centerX, centerY, leftX, leftY, 50);\r\n        const leftEnd = adjustPoint(leftX, leftY, centerX, centerY, 10);\r\n\r\n        // Draw the right arrow.\r\n        this.ctx.beginPath();\r\n        this.ctx.moveTo(rightStart.x, rightStart.y);\r\n        this.ctx.lineTo(rightEnd.x, rightEnd.y);\r\n        this.ctx.strokeStyle = 'black'; // Set the arrow line color.\r\n        this.ctx.stroke(); // Draw the arrow line.\r\n        let rightAngle = Math.atan2(rightEnd.y - rightStart.y, rightEnd.x - rightStart.x);\r\n        drawArrowhead(this.ctx, rightEnd.x, rightEnd.y, rightAngle); // Draw the arrowhead.\r\n\r\n        // Draw the left arrow.\r\n        this.ctx.beginPath();\r\n        this.ctx.moveTo(leftStart.x, leftStart.y);\r\n        this.ctx.lineTo(leftEnd.x, leftEnd.y);\r\n        this.ctx.strokeStyle = 'black'; // Set the arrow line color.\r\n        this.ctx.stroke(); // Draw the arrow line.\r\n        let leftAngle = Math.atan2(leftEnd.y - leftStart.y, leftEnd.x - leftStart.x);\r\n        drawArrowhead(this.ctx, leftEnd.x, leftEnd.y, leftAngle); // Draw the arrowhead.\r\n\r\n      }\r\n\r\n      // For Entrance\r\n      if (properties.elementType === 'entrance') {\r\n        // Calculate the angle of the main line (edge) in radians.\r\n        const angle = Math.atan2(nextPoint.y - point.y, nextPoint.x - point.x);\r\n\r\n        // Add 15 degrees to the angle for the entrance line.\r\n        const entranceAngle = angle + (15 * Math.PI) / 180; // Convert 15 degrees to radians.\r\n\r\n        // Define the length of the entrance line.\r\n        const lineLength = this.convertToPixels(properties.distance, properties.unit) * 0.75;\r\n\r\n        // Calculate the endpoint of the entrance line based on the angle.\r\n        const endPoint = {\r\n          x: point.x + Math.cos(entranceAngle) * lineLength,\r\n          y: point.y + Math.sin(entranceAngle) * lineLength,\r\n        };\r\n\r\n        // Draw the entrance line.\r\n        this.ctx.beginPath();\r\n        this.ctx.moveTo(point.x, point.y);\r\n        this.ctx.lineTo(endPoint.x, endPoint.y);\r\n        this.ctx.strokeStyle = '#1D2939'\r\n        this.ctx.stroke();\r\n      }\r\n\r\n\r\n    });\r\n\r\n    this.ctx.restore(); // Restore the original canvas state.\r\n  }\r\n\r\n  zoomIn(): void {\r\n    this.scale *= 1.1;\r\n    this.redrawCanvas();\r\n  }\r\n\r\n  zoomOut(): void {\r\n    this.scale /= 1.1;\r\n    this.redrawCanvas();\r\n  }\r\n\r\n  redrawCanvas(): void {\r\n    this.drawGrid();\r\n    this.drawPolygon();\r\n  }\r\n\r\n\r\n\r\n  snapToGrid(value: number, gridSize: number): number {\r\n    return Math.round(value / gridSize) * gridSize;\r\n  }\r\n\r\n\r\n  rotatePolygons(): void {\r\n    const rotatePoint = (point: { x: number; y: number }, center: { x: number; y: number }): { x: number; y: number } => {\r\n      const dx = point.x - center.x;\r\n      const dy = point.y - center.y;\r\n      return { x: center.x - dy, y: center.y + dx };\r\n    };\r\n\r\n    const getPolygonLineCenter = (line: any[]): { x: number; y: number } => {\r\n      const [start, end] = line;\r\n      return {\r\n        x: (start.x + end.x) / 2,\r\n        y: (start.y + end.y) / 2,\r\n      };\r\n    };\r\n\r\n    const getOverallCenter = (lines: any[]): { x: number; y: number } => {\r\n      const sum = lines.reduce(\r\n        (acc, line) => {\r\n          const center = getPolygonLineCenter(line);\r\n          acc.x += center.x;\r\n          acc.y += center.y;\r\n          return acc;\r\n        },\r\n        { x: 0, y: 0 }\r\n      );\r\n\r\n      return { x: sum.x / lines.length, y: sum.y / lines.length };\r\n    };\r\n\r\n    const overallCenter = getOverallCenter(this.layoutPolygon);\r\n\r\n    this.layoutPolygon = this.layoutPolygon.map((line) => {\r\n      const [start, end, properties] = line;\r\n      return [\r\n        rotatePoint(start, overallCenter),\r\n        rotatePoint(end, overallCenter),\r\n        properties\r\n      ];\r\n    });\r\n\r\n\r\n    this.drawGrid();\r\n    this.drawPolygon();\r\n  }\r\n\r\n  convertToPixels(value: number, unit: 'ft' | 'm'): number {\r\n    const PIXELS_PER_METER = this.pixelPerMetre;\r\n    const PIXELS_PER_FOOT = PIXELS_PER_METER / 3.28084;\r\n\r\n    if (typeof value !== 'number' || value < 0) {\r\n      throw new Error('Value must be a non-negative number');\r\n    }\r\n\r\n    switch (unit) {\r\n      case 'm':\r\n        return value * PIXELS_PER_METER;\r\n      case 'ft':\r\n        return value * PIXELS_PER_FOOT;\r\n      default:\r\n        throw new Error(\"Invalid unit. Supported units are 'mt' for meters and 'ft' for feet.\");\r\n    }\r\n  }\r\n\r\n\r\n  scrollToCanvasPosition(coordinates: { x: number; y: number }): void {\r\n    const container = this.scrollContainerRef.nativeElement;\r\n\r\n    const containerRect = container.getBoundingClientRect();\r\n    const containerScrollLeft = container.scrollLeft;\r\n    const containerScrollTop = container.scrollTop;\r\n\r\n    const targetX = coordinates.x;\r\n    const targetY = coordinates.y;\r\n\r\n    const offset = {\r\n      up: 50,\r\n      down: 200,\r\n      left: 100,\r\n      right: 100,\r\n    };\r\n\r\n    const visibleLeft = containerScrollLeft + offset.left;\r\n    const visibleRight = containerScrollLeft + containerRect.width - offset.right;\r\n    const visibleTop = containerScrollTop + offset.up;\r\n    const visibleBottom = containerScrollTop + containerRect.height - offset.down;\r\n\r\n    const isXInView = targetX >= visibleLeft && targetX <= visibleRight;\r\n    const isYInView = targetY >= visibleTop && targetY <= visibleBottom;\r\n\r\n    if (!isXInView || !isYInView) {\r\n      const adjustedX = Math.max(0, targetX - offset.left);\r\n      const adjustedY = Math.max(0, targetY - offset.up);\r\n\r\n      container.scrollTo({\r\n        left: adjustedX,\r\n        top: adjustedY,\r\n        behavior: 'smooth',\r\n      });\r\n    }\r\n  }\r\n\r\n  calculatePolygonArea(elements: any[]): number {\r\n    const vertices: { x: number; y: number }[] = [];\r\n    const centerX = 0; // Assuming (0,0) as the starting point for calculation\r\n    const centerY = 0;\r\n    let currentPoint = { x: centerX, y: centerY };\r\n\r\n    const conversionFactor = 50; // Pixels per foot (adjust as needed)\r\n\r\n    // Compute vertices based on layout instructions\r\n    for (const element of elements) {\r\n      const radians: number = {\r\n        up: ((180 - element.angle) * Math.PI) / 180,\r\n        left: ((270 - element.angle) * Math.PI) / 180,\r\n        down: ((360 - element.angle) * Math.PI) / 180,\r\n        right: ((90 - element.angle) * Math.PI) / 180,\r\n      }[element.direction as 'up' | 'left' | 'down' | 'right'];\r\n\r\n      if (radians === undefined) {\r\n        throw new Error(`Invalid direction: ${element.direction}`);\r\n      }\r\n\r\n      const distanceInPixels = element.distance * conversionFactor;\r\n      const newX = currentPoint.x + Math.cos(radians) * distanceInPixels;\r\n      const newY = currentPoint.y - Math.sin(radians) * distanceInPixels;\r\n\r\n      vertices.push({ x: currentPoint.x, y: currentPoint.y });\r\n\r\n      currentPoint = {\r\n        x: this.snapToGrid(newX, this.gridWidth),\r\n        y: this.snapToGrid(newY, this.gridHeight),\r\n      };\r\n    }\r\n\r\n    // Close the polygon by adding the starting vertex at the end\r\n    vertices.push(vertices[0]);\r\n\r\n    // Apply the Shoelace formula\r\n    let areaInPixels = 0;\r\n    for (let i = 0; i < vertices.length - 1; i++) {\r\n      const x1 = vertices[i].x;\r\n      const y1 = vertices[i].y;\r\n      const x2 = vertices[i + 1].x;\r\n      const y2 = vertices[i + 1].y;\r\n      areaInPixels += x1 * y2 - y1 * x2;\r\n    }\r\n\r\n    // Convert area from pixels² to feet²\r\n    const areaInSquareFeet = Math.abs(areaInPixels / 2) / (conversionFactor * conversionFactor);\r\n\r\n    return Math.round(areaInSquareFeet); // Return the area in square feet\r\n  }\r\n\r\n\r\n\r\n\r\n  generateLayoutPolygon(layoutInstructions: any) {\r\n\r\n    this.pixelPerMetre = this.normalizedPixelPerMetre(layoutInstructions)\r\n\r\n    this.wallCapacity = layoutInstructions.reduce((acc: any, val: any) => {\r\n      if (val.elementType === 'wall') {\r\n        return acc += val.distance\r\n      } else {\r\n        return acc\r\n      }\r\n    }, 0)\r\n    this.facadeCapacity = layoutInstructions.reduce((acc: any, val: any) => {\r\n      if (val.elementType === 'facade') {\r\n        return acc += val.distance\r\n      } else {\r\n        return acc\r\n      }\r\n    }, 0)\r\n\r\n    this.floorCapacity = this.calculatePolygonArea(layoutInstructions)\r\n\r\n    this.layoutPolygon = [];\r\n\r\n    const centerX = this.canvas.width / 2 / this.scale;\r\n    const centerY = this.canvas.height / 2 / this.scale;\r\n\r\n    let currentPoint = {\r\n      \"x\": this.snapToGrid(centerX, this.gridHeight),\r\n      \"y\": this.snapToGrid(centerY, this.gridWidth)\r\n    };\r\n\r\n    if (!layoutInstructions.length) {\r\n\r\n      this.layoutPolygon = [\r\n        [\r\n          {\r\n            \"x\": this.snapToGrid(centerX, this.gridHeight),\r\n            \"y\": this.snapToGrid(centerY, this.gridWidth)\r\n          },\r\n          {\r\n            \"x\": this.snapToGrid(centerX, this.gridHeight),\r\n            \"y\": this.snapToGrid(centerY, this.gridWidth)\r\n          },\r\n          {\r\n            \"elementType\": \"wall\",\r\n            \"distance\": 0,\r\n            \"unit\": \"ft\",\r\n            \"direction\": \"right\",\r\n            \"angle\": 90,\r\n            \"elementNumber\": 1\r\n          }\r\n        ]\r\n      ]\r\n      this.openWidget({ x: this.snapToGrid(centerX, this.gridHeight), y: this.snapToGrid(centerY, this.gridWidth) })\r\n      this.drawGrid()\r\n      this.drawPolygon()\r\n      return\r\n    }\r\n\r\n    layoutInstructions.forEach((instruction: any) => {\r\n      const radians: number = {\r\n        'up': ((180 - instruction.angle) * Math.PI) / 180,\r\n        'left': ((270 - instruction.angle) * Math.PI) / 180,\r\n        'down': ((360 - instruction.angle) * Math.PI) / 180,\r\n        'right': ((90 - instruction.angle) * Math.PI) / 180,\r\n      }[instruction.direction as 'up' | 'left' | 'down' | 'right'];\r\n\r\n      if (radians === undefined) {\r\n        throw new Error(`Invalid direction: ${instruction.direction}`);\r\n      }\r\n\r\n      const distanceInPixels = this.convertToPixels(instruction.distance, instruction.unit);\r\n      const newX = currentPoint.x + Math.cos(radians) * distanceInPixels;\r\n      const newY = currentPoint.y - Math.sin(radians) * distanceInPixels;\r\n\r\n      const newPoint = {\r\n        x: this.snapToGrid(newX, this.gridWidth),\r\n        y: this.snapToGrid(newY, this.gridHeight),\r\n      };\r\n\r\n      const lineSegment = [\r\n        currentPoint,\r\n        newPoint,\r\n        {\r\n          elementType: instruction.elementType,\r\n          distance: instruction.distance,\r\n          unit: instruction.unit,\r\n          direction: instruction.direction,\r\n          angle: instruction.angle,\r\n          elementNumber: instruction.elementNumber,\r\n        },\r\n      ];\r\n\r\n      this.layoutPolygon.push(lineSegment);\r\n\r\n      currentPoint = newPoint;\r\n    });\r\n\r\n    const lastPoint = this.layoutPolygon[this.layoutPolygon.length - 1][1]\r\n\r\n    if (this.isFloorCompleted(layoutInstructions)) {\r\n      this.findPolygonCenterAndScroll()\r\n    } else {\r\n      this.openWidget(lastPoint)\r\n    }\r\n\r\n    this.drawGrid()\r\n    this.drawPolygon()\r\n\r\n  }\r\n\r\n  isFloorCompleted(layoutInstructions: any, thresholdInFeet: number = 1): boolean {\r\n    const layoutPolygon: any[] = [];\r\n    const centerX = this.canvas.width / 2 / this.scale;\r\n    const centerY = this.canvas.height / 2 / this.scale;\r\n\r\n    let currentPoint = {\r\n      x: this.snapToGrid(centerX, this.gridHeight),\r\n      y: this.snapToGrid(centerY, this.gridWidth),\r\n    };\r\n\r\n    layoutInstructions.forEach((instruction: any) => {\r\n      const radians: number = {\r\n        'up': ((180 - instruction.angle) * Math.PI) / 180,\r\n        'left': ((270 - instruction.angle) * Math.PI) / 180,\r\n        'down': ((360 - instruction.angle) * Math.PI) / 180,\r\n        'right': ((90 - instruction.angle) * Math.PI) / 180,\r\n      }[instruction.direction as 'up' | 'left' | 'down' | 'right'];\r\n\r\n      if (radians === undefined) {\r\n        throw new Error(`Invalid direction: ${instruction.direction}`);\r\n      }\r\n\r\n      const distanceInPixels = this.convertToPixels(instruction.distance, instruction.unit);\r\n      const newX = currentPoint.x + Math.cos(radians) * distanceInPixels;\r\n      const newY = currentPoint.y - Math.sin(radians) * distanceInPixels;\r\n\r\n      const newPoint = {\r\n        x: this.snapToGrid(newX, this.gridWidth),\r\n        y: this.snapToGrid(newY, this.gridHeight),\r\n      };\r\n\r\n      const lineSegment = [\r\n        currentPoint,\r\n        newPoint,\r\n        {\r\n          elementType: instruction.elementType,\r\n          distance: instruction.distance,\r\n          unit: instruction.unit,\r\n          direction: instruction.direction,\r\n          angle: instruction.angle,\r\n          elementNumber: instruction.elementNumber,\r\n        },\r\n      ];\r\n\r\n      layoutPolygon.push(lineSegment);\r\n      currentPoint = newPoint;\r\n    });\r\n\r\n    const firstPoint = layoutPolygon?.[0]?.[0];\r\n    const lastPoint = layoutPolygon?.[layoutPolygon.length - 1]?.[1];\r\n\r\n    if (layoutPolygon.length <= 1 || !firstPoint || !lastPoint) {\r\n      return false;\r\n    }\r\n\r\n    const distanceBetweenPoints = Math.sqrt(\r\n      Math.pow(lastPoint.x - firstPoint.x, 2) + Math.pow(lastPoint.y - firstPoint.y, 2)\r\n    );\r\n\r\n    const thresholdInPixels = this.convertToPixels(thresholdInFeet, 'ft');\r\n    return distanceBetweenPoints <= thresholdInPixels;\r\n  }\r\n\r\n  openWidget(position: { x: number, y: number }, offset = { up: 0, right: 5, down: 15, left: 0, }) {\r\n    const adjustedPosition = {\r\n      x: position.x + offset.right + offset.left,\r\n      y: position.y + offset.up + offset.down,\r\n    };\r\n\r\n    this.scrollToCanvasPosition(adjustedPosition)\r\n\r\n  }\r\n\r\n  openOffCanva() {\r\n    let canvaRef = this.offcanvasService.open(StoreOffcanvasComponentComponent, { position: 'end', panelClass: 'set-height' })\r\n    canvaRef.componentInstance.store = this.selectedStore;\r\n    canvaRef.componentInstance.clientId = this.headerData?.client;\r\n    canvaRef.componentInstance.id = this.selectedStore.planoId;\r\n  }\r\n\r\n  onModalSelectAll(event: any) {\r\n    this.planoStoreList.forEach((store) => store.selected = event.target.checked)\r\n  }\r\n\r\n  get isAllStoreSelected() {\r\n    return this.planoStoreList.every((store) => store.selected)\r\n  }\r\n\r\n  onModalTypeChange(event: 'single' | 'multiple') {\r\n    if (event === 'single') {\r\n      this.planoStoreList.forEach((store, index) => {\r\n        if (store.planoId === this.selectedStore.planoId) {\r\n          store.selected = true\r\n        } else {\r\n          store.selected = false\r\n        }\r\n      })\r\n    } else if (event === 'multiple') {\r\n      this.planoStoreList.forEach((store) => store.selected = true)\r\n    }\r\n\r\n  }\r\n\r\n  updatePlanoStatus() {\r\n    const payload = {\r\n      storeId: this.planoStoreList.filter((store) => store.selected === true).map((store) => store.storeId),\r\n      status: \"completed\"\r\n    }\r\n\r\n    this.apiService.updatePlanoStatus(payload).subscribe({\r\n      next: (res:any) => {\r\n        if(res.code === 200){\r\n          this.toastService.getSuccessToast(res.message)\r\n          this.router.navigateByUrl('/manage/planogram/store-layout')\r\n        }\r\n      },\r\n      error: (err) => {\r\n        console.log(err)\r\n      }\r\n    })\r\n  }\r\n\r\n  onPageChange(val: number) {\r\n    this.selectedStore = this.planoStoreList[val - 1];\r\n    this.selectedFloor = this.selectedStore.floor[0];\r\n    this.floorsInput.setValue(this.selectedFloor.id, { emitEvent: false });\r\n    this.generateLayoutPolygon(this.selectedFloor.layoutPolygon);\r\n  }\r\n\r\n  normalizedPixelPerMetre(polygon: any): number {\r\n    const MIN_PIXELS_PER_METER = 50;\r\n    const MAX_PIXELS_PER_METER = 150;\r\n\r\n    let totalLength = 0;\r\n    let lineCount = 0;\r\n\r\n    polygon.forEach((line: any) => {\r\n      if (line.unit === 'ft') {\r\n        totalLength = totalLength + (line.distance * 3.28084);\r\n      } else {\r\n        totalLength = totalLength + line.distance;\r\n      }\r\n      lineCount++;\r\n    });\r\n\r\n    const averageLength = lineCount > 0 ? totalLength / lineCount : 0;\r\n\r\n    const MAX_AVERAGE_LENGTH = 50;\r\n    const MIN_AVERAGE_LENGTH = 5;\r\n\r\n    const normalizedLength = Math.min(\r\n      Math.max(averageLength, MIN_AVERAGE_LENGTH),\r\n      MAX_AVERAGE_LENGTH\r\n    );\r\n\r\n    const pixelsPerMeter =\r\n      MAX_PIXELS_PER_METER -\r\n      ((normalizedLength - MIN_AVERAGE_LENGTH) / (MAX_AVERAGE_LENGTH - MIN_AVERAGE_LENGTH)) *\r\n      (MAX_PIXELS_PER_METER - MIN_PIXELS_PER_METER);\r\n\r\n    return Math.round(pixelsPerMeter);\r\n  }\r\n\r\n  findPolygonCenterAndScroll(polygon: any = this.layoutPolygon): void {\r\n    const vertices = polygon.flatMap((line: any) => line.slice(0, 2));\r\n\r\n    const minX = Math.min(...vertices.map((v: any) => v.x));\r\n    const maxX = Math.max(...vertices.map((v: any) => v.x));\r\n    const minY = Math.min(...vertices.map((v: any) => v.y));\r\n    const maxY = Math.max(...vertices.map((v: any) => v.y));\r\n\r\n    let center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };\r\n\r\n    const step = 1;\r\n    let bestPoint = center;\r\n    let bestDistanceSum = Number.MAX_VALUE;\r\n\r\n    for (let x = minX; x <= maxX; x += step) {\r\n      for (let y = minY; y <= maxY; y += step) {\r\n        const point = { x, y };\r\n        if (isPointInsidePolygon(point, vertices)) {\r\n          const distanceSum = vertices.reduce(\r\n            (sum: number, vertex: any) => sum + Math.sqrt((point.x - vertex.x) ** 2 + (point.y - vertex.y) ** 2),\r\n            0\r\n          );\r\n          if (distanceSum < bestDistanceSum) {\r\n            bestDistanceSum = distanceSum;\r\n            bestPoint = point;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    const scrollContainer = this.scrollContainerRef.nativeElement;\r\n    scrollContainer.scrollTo({\r\n      left: bestPoint.x - scrollContainer.offsetWidth / 2,\r\n      top: bestPoint.y - scrollContainer.offsetHeight / 2,\r\n      behavior: 'smooth'\r\n    });\r\n\r\n    function isPointInsidePolygon(point: any, vertices: any): boolean {\r\n      let count = 0;\r\n      for (let i = 0; i < vertices.length; i++) {\r\n        const start = vertices[i];\r\n        const end = vertices[(i + 1) % vertices.length];\r\n        if (rayIntersectsSegment(point, { start, end })) {\r\n          count++;\r\n        }\r\n      }\r\n      return count % 2 === 1;\r\n    }\r\n\r\n    function rayIntersectsSegment(point: any, segment: any): boolean {\r\n      const { x, y } = point;\r\n      const { start, end } = segment;\r\n\r\n      if (y < Math.min(start.y, end.y) || y > Math.max(start.y, end.y)) {\r\n        return false;\r\n      }\r\n\r\n      const t = (y - start.y) / (end.y - start.y);\r\n      const intersectX = start.x + t * (end.x - start.x);\r\n\r\n      return intersectX >= x;\r\n    }\r\n  }\r\n\r\n\r\n\r\n\r\n}\r\n","<div class=\"d-flex align-items-center justify-content-between mb-6\">\r\n  <div>\r\n    <div *ngIf=\"planoStoreList.length === 1\" class=\"storename-txt\">\r\n      {{selectedStore?.storeName}} - Layout\r\n    </div>\r\n    <div *ngIf=\"planoStoreList.length > 1\">\r\n      <lib-select-plano [items]=\"planoStoreList\" [multi]=\"false\" [searchField]=\"'storeName'\" [idField]=\"'storeId'\"\r\n        (selected)=\"onStoreChange($event)\" [selectedValues]=\"[selectedStore]\"></lib-select-plano>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"d-flex align-items-center\">\r\n    <button (click)=\"onComplete()\" class=\"btn btn-sm btn-primary me-5\">Complete</button>\r\n    <button (click)=\"openOffCanva()\" class=\"btn btn-sm btn-outline bg-white\">\r\n      <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n        <path\r\n          d=\"M9 3V21M5 3H19C20.1046 3 21 3.89543 21 5V19C21 20.1046 20.1046 21 19 21H5C3.89543 21 3 20.1046 3 19V5C3 3.89543 3.89543 3 5 3Z\"\r\n          stroke=\"#101828\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n      </svg>\r\n    </button>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"row mb-6\">\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{wallCapacity || 0}}</span> <span class=\"unit-txt\">rft</span> </div>\r\n        <div class=\"sub-txt\">Wall capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"65\" height=\"65\" viewBox=\"0 0 65 65\" fill=\"none\">\r\n          <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n            d=\"M4.33333 4.33333V0H8.66667V4.33333H21.6667V0H26V4.33333H39V0H43.3333V4.33333H56.3333V0H60.6667V4.33333H65V8.66667H60.6667V21.6667H65V26H60.6667V39H65V43.3333H60.6667V56.3333H65V60.6667H60.6667V65H56.3333V60.6667H43.3333V65H39V60.6667H26V65H21.6667V60.6667H8.66667V65H4.33333V60.6667H0V56.3333H4.33333V43.3333H0V39H4.33333V26H0V21.6667H4.33333V8.66667H0V4.33333H4.33333ZM8.66667 8.66667V21.6667H21.6667V8.66667H8.66667ZM26 8.66667V21.6667H39V8.66667H26ZM43.3333 8.66667V21.6667H56.3333V8.66667H43.3333ZM56.3333 26H43.3333V39H56.3333V26ZM56.3333 43.3333H43.3333V56.3333H56.3333V43.3333ZM39 56.3333V43.3333H26V56.3333H39ZM21.6667 56.3333V43.3333H8.66667V56.3333H21.6667ZM8.66667 39H21.6667V26H8.66667V39ZM26 26V39H39V26H26Z\"\r\n            fill=\"#344054\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{facadeCapacity || 0}}</span> <span class=\"unit-txt\">rft</span> </div>\r\n        <div class=\"sub-txt\">Facade capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg width=\"65\" height=\"65\" viewBox=\"0 0 65 65\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n          <rect x=\"0.5\" y=\"0.5\" width=\"64\" height=\"64\" fill=\"#FDFDFD\" stroke=\"black\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"col-4\">\r\n    <div class=\"area-card\">\r\n      <div>\r\n        <div> <span class=\"main-txt me-2\">{{floorCapacity || 0}}</span> <span class=\"unit-txt\">sqft</span> </div>\r\n        <div class=\"sub-txt\">Floor capacity</div>\r\n      </div>\r\n      <div>\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"102\" height=\"58\" viewBox=\"0 0 102 58\" fill=\"none\">\r\n          <path d=\"M3.54359 36.4607L29.8929 2.06432L98.0939 6.44191L99.908 55.5468L3.54359 36.4607Z\" stroke=\"#475467\"\r\n            stroke-width=\"4\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"row\">\r\n  <div class=\"col-4\">\r\n    <div class=\"c-card\" style=\"height: 75dvh; position: relative;\">\r\n      <div class=\"d-flex align-items-center justify-content-between mb-5\" style=\"height: 8%;\">\r\n        <div>\r\n          <div class=\"l-pane-head\">\r\n            Capacity details\r\n          </div>\r\n          <div class=\"l-pane-desc\">\r\n            Below are the capacity details of the elements\r\n          </div>\r\n        </div>\r\n        <div class=\"d-flex align-items-center\">\r\n\r\n        </div>\r\n\r\n      </div>\r\n\r\n      <div class=\"table-responsive hide-scrollbar \" style=\"height: 92%;\">\r\n        <table class=\"table\">\r\n          <thead class=\"thead-light\">\r\n            <tr>\r\n              <th>#</th>\r\n              <th> <svg class=\"me-2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"\r\n                  fill=\"none\">\r\n                  <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n                    d=\"M1.33333 1.33333V0L2.66667 0V1.33333L6.66667 1.33333V0L8 0V1.33333L12 1.33333V0L13.3333 0V1.33333L17.3333 1.33333V0L18.6667 0V1.33333H20V2.66667H18.6667V6.66667H20V8H18.6667V12H20V13.3333H18.6667V17.3333H20V18.6667H18.6667V20H17.3333V18.6667H13.3333V20H12V18.6667H8V20H6.66667V18.6667H2.66667V20H1.33333V18.6667H0L0 17.3333H1.33333L1.33333 13.3333H0L0 12H1.33333L1.33333 8H0L0 6.66667H1.33333L1.33333 2.66667H0L0 1.33333H1.33333ZM2.66667 2.66667L2.66667 6.66667H6.66667V2.66667L2.66667 2.66667ZM8 2.66667V6.66667H12V2.66667L8 2.66667ZM13.3333 2.66667V6.66667H17.3333V2.66667H13.3333ZM17.3333 8L13.3333 8V12L17.3333 12V8ZM17.3333 13.3333L13.3333 13.3333L13.3333 17.3333H17.3333V13.3333ZM12 17.3333L12 13.3333H8L8 17.3333H12ZM6.66667 17.3333V13.3333H2.66667V17.3333H6.66667ZM2.66667 12H6.66667V8H2.66667L2.66667 12ZM8 8V12H12V8H8Z\"\r\n                    fill=\"#344054\" />\r\n                </svg> <span>Wall</span> </th>\r\n              <th>RFT ({{wallCapacity || 0}})</th>\r\n\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <ng-container *ngFor=\"let item of layoutPolygon; let i = index\">\r\n              <tr *ngIf=\"item[2] && item[2].elementType === 'wall'\">\r\n                <td>\r\n                  {{1}}\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].elementType}} {{item[2].elementNumber}}</div>\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].distance}}</div>\r\n\r\n                </td>\r\n              </tr>\r\n            </ng-container>\r\n\r\n          </tbody>\r\n        </table>\r\n        <table class=\"table\">\r\n          <thead class=\"thead-light\">\r\n            <tr>\r\n              <th>#</th>\r\n              <th> <svg class=\"me-2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"22\" height=\"22\" viewBox=\"0 0 22 22\"\r\n                  fill=\"none\">\r\n                  <path\r\n                    d=\"M1 11V2.25C1 1.5625 1.5625 1 2.25 1H19.75C20.4375 1 21 1.5625 21 2.25V19.75C21 20.4375 20.4375 21 19.75 21H2.25C1.5625 21 1 20.4375 1 19.75V11Z\"\r\n                    stroke=\"#344054\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg> <span>Facade</span> </th>\r\n              <th>RFT ({{facadeCapacity || 0}})</th>\r\n\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <ng-container *ngFor=\"let item of layoutPolygon; let i = index\">\r\n              <tr *ngIf=\"item[2] && item[2].elementType === 'facade'\">\r\n                <td>\r\n                  {{i}}\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].elementType}} {{item[2].elementNumber}}</div>\r\n                </td>\r\n                <td>\r\n                  <div class=\"table-td\">{{item[2].distance}}</div>\r\n\r\n                </td>\r\n              </tr>\r\n            </ng-container>\r\n\r\n          </tbody>\r\n        </table>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n  <div class=\"col-8\">\r\n    <div class=\"c-card \" style=\"height: 75dvh;\">\r\n      <div style=\"height: 8%;\" class=\"d-flex align-items-center justify-content-between\">\r\n        <div>\r\n          <!-- <lib-reactive-select *ngIf=\"floorsInput.value\" [formControl]=\"floorsInput\" [idField]=\"'id'\"\r\n            [nameField]=\"'floorName'\" [data]=\"selectedStore?.floor\"></lib-reactive-select> -->\r\n          <div (click)=\"toggleFloorSelect()\" class=\"floor-select\">\r\n            <div>{{selectedFloor?.floorName}}</div>\r\n            <div><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                <path d=\"M5 7.5L10 12.5L15 7.5\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\"\r\n                  stroke-linejoin=\"round\" />\r\n              </svg></div>\r\n            <ul *ngIf=\"floorSelect?.show\" class=\"list-unstyled mb-2\">\r\n              <li (click)=\"onFloorSelect(floor.id)\" *ngFor=\"let floor of selectedStore?.floor; let i = index\"\r\n                [ngClass]=\"floor.id === selectedFloor.id ? 'selected': ''\">\r\n                <div class=\"d-flex justify-content-between\">\r\n                  <span>{{floor?.floorName}}</span>\r\n\r\n                </div>\r\n\r\n              </li>\r\n            </ul>\r\n          </div>\r\n        </div>\r\n        <button class=\"btn btn-sm btn-outline bg-white\" (click)=\"rotatePolygons()\">\r\n          <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" fill=\"none\">\r\n            <path\r\n              d=\"M6.36265 7.17838L7.17625 6.36238L5.90425 5.09158L5.08945 5.90518L6.36265 7.17838ZM15.671 6.36358L19.6379 10.3304L20.9099 9.0572L16.9442 5.09038L15.671 6.36358ZM19.6379 18.8252L18.8243 19.6388L20.0963 20.9096L20.9099 20.0972L19.6379 18.8252ZM10.3295 19.6388L6.36265 15.672L5.09065 16.9452L9.05626 20.9108L10.3295 19.6388ZM18.8243 19.6388C17.6543 20.8076 16.8407 21.6188 16.1459 22.1492C15.4715 22.664 15.0155 22.8284 14.5763 22.8284V24.6284C15.5675 24.6284 16.4027 24.2168 17.2367 23.5808C18.0503 22.9604 18.9635 22.0448 20.0963 20.912L18.8243 19.6388ZM9.05626 20.9108C10.1891 22.0448 11.1023 22.9592 11.9159 23.5808C12.7499 24.2168 13.5851 24.6284 14.5763 24.6284V22.8284C14.1371 22.8284 13.6823 22.664 13.0067 22.1492C12.3119 21.6188 11.4983 20.8076 10.3295 19.6388L9.05626 20.9108ZM19.6379 10.3304C20.8067 11.4992 21.6179 12.3128 22.1483 13.0076C22.6631 13.6832 22.8275 14.138 22.8275 14.5772H24.6275C24.6275 13.586 24.2159 12.7508 23.5799 11.9168C22.9595 11.1032 22.0427 10.19 20.9099 9.0572L19.6379 10.3304ZM20.9099 20.0972C22.0439 18.9632 22.9583 18.0512 23.5799 17.2376C24.2159 16.4036 24.6275 15.5684 24.6275 14.5772H22.8275C22.8275 15.0164 22.6631 15.4724 22.1483 16.1468C21.6179 16.8416 20.8067 17.6552 19.6379 18.8252L20.9099 20.0972ZM7.17625 6.36238C8.34625 5.19358 9.15985 4.38118 9.85465 3.85078C10.529 3.33598 10.985 3.17278 11.4242 3.17278V1.37158C10.433 1.37158 9.59785 1.78318 8.76385 2.41918C7.94905 3.04078 7.03705 3.95518 5.90425 5.08798L7.17625 6.36238ZM16.9442 5.09038C15.8114 3.95638 14.8982 3.04078 14.0846 2.41918C13.2506 1.78318 12.4154 1.37158 11.4242 1.37158V3.17278C11.8634 3.17278 12.3182 3.33598 12.9938 3.85078C13.6886 4.38118 14.5022 5.19238 15.671 6.36118L16.9442 5.09038ZM5.08945 5.90278C3.95665 7.03558 3.04225 7.94758 2.42065 8.76238C1.78465 9.59638 1.37305 10.4316 1.37305 11.4228H3.17305C3.17305 10.9836 3.33745 10.5276 3.85225 9.85318C4.38265 9.15838 5.19385 8.34478 6.36265 7.17478L5.08945 5.90278ZM6.36265 15.6708C5.19385 14.5008 4.38265 13.6872 3.85225 12.9924C3.33745 12.318 3.17305 11.862 3.17305 11.4228H1.37305C1.37305 12.414 1.78465 13.2492 2.42065 14.0832C3.04225 14.8968 3.95665 15.81 5.08945 16.9428L6.36265 15.6708Z\"\r\n              fill=\"#1D2939\" />\r\n            <path d=\"M23.2 6.9832L25 8.2C25 4.582 22.4056 1.5796 19 1M2.8 19.0168L1 17.8C1 21.418 3.5944 24.4204 7 25\"\r\n              stroke=\"#1D2939\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n          </svg>\r\n        </button>\r\n      </div>\r\n      <div class=\"hide-scrollbar\" style=\"height: 92%; overflow: scroll; position: relative;\" #scrollContainer>\r\n        <canvas #gridCanvas>\r\n\r\n        </canvas>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <div *ngIf=\"planoStoreList.length > 1\" class=\"col-12 mt-6\">\r\n    <div style=\"padding: 0px !important;\" class=\"c-card\">\r\n        <lib-pagination [itemsPerPage]=\"itemsPerPage\" (pageChange)=\"onPageChange($event)\" [currentPage]=\"currentPage\" [totalItems]=\"totalItems\"\r\n            [paginationSizes]=\"paginationSizes\" [pageSize]=\"pageSize\"></lib-pagination>\r\n    </div>\r\n</div>\r\n\r\n</div>\r\n\r\n<ng-template #completeLayout let-modal>\r\n  <div class=\"card\">\r\n    <div style=\"min-height: unset; border-bottom: unset;  padding-top: 2.25rem;\" class=\"card-header\">\r\n      <div class=\"card-title\">\r\n        <span class=\"modal-header-txt\">Complete Layout</span>\r\n      </div>\r\n    </div>\r\n    <div style=\"padding-top: 1rem;\" class=\"card-body\">\r\n      <div class=\"form-check\">\r\n        <input (ngModelChange)=\"onModalTypeChange($event)\" [(ngModel)]=\"markAsCompleteType\" class=\"form-check-input\" type=\"radio\" name=\"one\" id=\"single\"\r\n          value=\"single\">\r\n        <div class=\"ms-3\">\r\n          <div class=\"modal-main-txt\">Mark as complete for only <span\r\n              class=\"highlight-txt\">{{selectedStore?.storeName}}</span></div>\r\n          <div class=\"modal-sub-txt\">This action will considered as layout completion for {{selectedStore?.storeName}}\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <div class=\"w-100 h-0 border my-5 border-bottom-grey\"></div>\r\n      <div class=\"form-check mb-5\">\r\n        <input (ngModelChange)=\"onModalTypeChange($event)\" [(ngModel)]=\"markAsCompleteType\" class=\"form-check-input\" type=\"radio\" name=\"one\" id=\"multiple\"\r\n          value=\"multiple\">\r\n        <div class=\"ms-3\">\r\n          <div class=\"modal-main-txt\">Mark as complete for all {{planoStoreList.length}} stores</div>\r\n        </div>\r\n      </div>\r\n      <div *ngIf=\"markAsCompleteType === 'multiple'\" class=\"table-responsive\">\r\n        <table class=\"table\">\r\n          <thead>\r\n            <tr style=\"border-bottom: 1px solid #EAECF0; background: #FCFCFD;\">\r\n              <th>\r\n                <div class=\"form-check\">\r\n                  <input (click)=\"onModalSelectAll($event)\" [(ngModel)]=\"isAllStoreSelected\" class=\"form-check-input c-checkbox\" type=\"checkbox\">\r\n                  <label class=\"form-check-label check-label modal-storeName\">\r\n                    Store Name\r\n                  </label>\r\n                </div>\r\n              </th>\r\n            </tr>\r\n          </thead>\r\n          <tbody>\r\n            <tr style=\"border-bottom: 1px solid #EAECF0;\" *ngFor=\"let store of planoStoreList\">\r\n              <td>\r\n                <div class=\"form-check\">\r\n                  <input [(ngModel)]=\"store.selected\" class=\"form-check-input c-checkbox\" type=\"checkbox\">\r\n                  <label class=\"form-check-label check-label modal-storeName\">\r\n                    {{store?.storeName}}\r\n                  </label>\r\n                </div>\r\n              </td>\r\n            </tr>\r\n          </tbody>\r\n        </table>\r\n      </div>\r\n      <div class=\"d-flex align-items-center justify-content-end\">\r\n        <button (click)=\"modal.dismiss()\" class=\"btn btn-outline bg-white me-5\">Cancel</button>\r\n        <button (click)=\"updatePlanoStatus(); modal.dismiss()\" class=\"btn btn-sm btn-primary \">Complete</button>\r\n      </div>\r\n    </div>\r\n  </div>\r\n\r\n</ng-template>"]}