tango-app-ui-store-builder 1.0.46 → 1.0.48

package/esm2022/lib/components/collection-update-ai/find-replace-layout/review-replace/review-replace.component.mjs

@@ -0,0 +1,2039 @@
+import { Component, ViewChild } from '@angular/core';
+import { CommonModule, TitleCasePipe } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { Subject, takeUntil } from 'rxjs';
+import * as fabric from "fabric";
+import { CommonSharedModule } from 'tango-app-ui-shared';
+import { NgbDropdownModule } from '@ng-bootstrap/ng-bootstrap';
+import { FixtureBeforeAfterComponent } from './fixture-before-after/fixture-before-after.component';
+import { ApproveCompleteModalComponent } from './approve-complete-modal/approve-complete-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/data.service";
+import * as i2 from "../../../../services/store-builder.service";
+import * as i3 from "tango-app-ui-global";
+import * as i4 from "@angular/common";
+import * as i5 from "@ng-bootstrap/ng-bootstrap";
+import * as i6 from "@angular/router";
+import * as i7 from "@angular/forms";
+import * as i8 from "tango-app-ui-shared";
+export class ReviewReplaceComponent {
+    dataService;
+    storeBuilderService;
+    cdr;
+    gs;
+    titleCase;
+    offcanvasService;
+    modalService;
+    router;
+    findReplaceData = null;
+    stores = [];
+    filteredStores = [];
+    selectedStores = new Set();
+    searchTerm = '';
+    selectedStore = null;
+    // Filter properties
+    selectedStatusFilters = new Set();
+    statusOptions = [
+        { value: 'match', label: 'Match' },
+        { value: 'no-match', label: 'No Match' }
+    ];
+    // Canvas properties
+    previewCanvasRef;
+    previewCanvasContainerRef;
+    previewCanvas;
+    planoData;
+    floorData;
+    canvasLoading = false;
+    approveLoading = false;
+    cdnUrl = '';
+    wallThickness = 30;
+    verticalMargin = (1.25 / 100) * this.toPixels(1524, "mm");
+    allFixtureInstances = [];
+    // Fixture selection and highlighting
+    selectedFixture = null;
+    selectedFixtureData = null;
+    originalFixtureData = null; // Original fixture before replace (for before/after comparison)
+    originalFixturesMap = new Map(); // Store original fixtures by fixtureId
+    activeHighlight = null;
+    cancelHighlightBlink = false;
+    destroy$ = new Subject();
+    // Pagination properties
+    limit = 10;
+    offset = 1;
+    totalItems = 0;
+    paginationSizes = [10, 20, 30];
+    constructor(dataService, storeBuilderService, cdr, gs, titleCase, offcanvasService, modalService, router) {
+        this.dataService = dataService;
+        this.storeBuilderService = storeBuilderService;
+        this.cdr = cdr;
+        this.gs = gs;
+        this.titleCase = titleCase;
+        this.offcanvasService = offcanvasService;
+        this.modalService = modalService;
+        this.router = router;
+    }
+    ngOnInit() {
+        // Get CDN URL
+        this.gs.environment
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((env) => {
+            this.cdnUrl = env.planogramCDN || '';
+        });
+        // Subscribe to data service
+        this.dataService.getFindReplaceData()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((data) => {
+            this.findReplaceData = data;
+            if (data?.stores) {
+                this.stores = data.stores;
+                // Restore checkbox state from isApproved property
+                this.selectedStores.clear();
+                this.stores.forEach(store => {
+                    if (store.isApproved && !this.hasNoMatch(store)) {
+                        this.selectedStores.add(store.storeName);
+                    }
+                });
+                this.applyFilters();
+                // Select first store by default if none selected
+                if (!this.selectedStore && this.filteredStores.length > 0) {
+                    this.onStoreSelect(this.filteredStores[0]);
+                }
+            }
+        });
+    }
+    ngAfterViewInit() {
+        // Canvas will be initialized when store is selected
+    }
+    initializeCanvas() {
+        if (this.previewCanvas) {
+            return true;
+        }
+        if (this.previewCanvasRef?.nativeElement && this.previewCanvasContainerRef?.nativeElement) {
+            try {
+                const containerEl = this.previewCanvasContainerRef.nativeElement;
+                this.previewCanvas = new fabric.Canvas(this.previewCanvasRef.nativeElement, {
+                    selectionFullyContained: true,
+                    perPixelTargetFind: true,
+                    targetFindTolerance: 5,
+                    width: containerEl.clientWidth,
+                    height: containerEl.clientHeight,
+                });
+                this.setupZoomHandlers(this.previewCanvas);
+                return true;
+            }
+            catch (error) {
+                console.error('Error initializing canvas:', error);
+                return false;
+            }
+        }
+        return false;
+    }
+    setupZoomHandlers(canvas) {
+        canvas.selection = false;
+        canvas.on("mouse:wheel", (opt) => {
+            const e = opt.e;
+            if (e.ctrlKey || e.metaKey) {
+                const delta = e.deltaY;
+                let zoom = canvas.getZoom();
+                zoom *= 0.995 ** delta;
+                zoom = Math.max(0.2, Math.min(zoom, 3));
+                canvas.zoomToPoint({ x: e.offsetX, y: e.offsetY }, zoom);
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        });
+        let isDragging = false;
+        let lastPosX = 0;
+        let lastPosY = 0;
+        canvas.on("mouse:down", (opt) => {
+            // Handle fixture clicks - use findTarget to get the actual group
+            if (opt.target) {
+                const obj = opt.target;
+                // Check if it's a fixture group or nested within one
+                let fixtureGroup = obj;
+                // Traverse up to find the fixture group
+                let attempts = 0;
+                while (fixtureGroup && !fixtureGroup.fixtureId && !fixtureGroup.objType && attempts < 10) {
+                    if (fixtureGroup.parent) {
+                        fixtureGroup = fixtureGroup.parent;
+                    }
+                    else if (fixtureGroup.group) {
+                        fixtureGroup = fixtureGroup.group;
+                    }
+                    else {
+                        break;
+                    }
+                    attempts++;
+                }
+                // Check if we found a fixture group
+                if (fixtureGroup.objType === "fixture" || fixtureGroup.fixtureId) {
+                    this.onFixtureClick(fixtureGroup);
+                    canvas.setActiveObject(fixtureGroup);
+                    canvas.requestRenderAll();
+                    return;
+                }
+            }
+            // For non-fixture clicks, enable dragging
+            if (!opt.target) {
+                isDragging = true;
+                canvas.selection = false;
+                const e = opt.e;
+                lastPosX = e.clientX;
+                lastPosY = e.clientY;
+            }
+        });
+        canvas.on("mouse:move", (opt) => {
+            if (isDragging && canvas.viewportTransform && !opt.target) {
+                const e = opt.e;
+                const vpt = canvas.viewportTransform;
+                vpt[4] += e.clientX - lastPosX;
+                vpt[5] += e.clientY - lastPosY;
+                canvas.requestRenderAll();
+                lastPosX = e.clientX;
+                lastPosY = e.clientY;
+            }
+        });
+        canvas.on("mouse:up", () => {
+            isDragging = false;
+            canvas.selection = false;
+        });
+    }
+    onStoreSelect(store) {
+        // Allow viewing planogram even for stores with no-match status
+        this.selectedStore = store;
+        this.cdr.detectChanges();
+        setTimeout(() => {
+            if (this.initializeCanvas()) {
+                // Resize canvas to container size
+                if (this.previewCanvasContainerRef?.nativeElement) {
+                    this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);
+                }
+                this.loadPlanogramForStore(store.storeName);
+            }
+        }, 100);
+    }
+    async loadPlanogramForStore(storeName) {
+        if (!storeName || !this.previewCanvas) {
+            return;
+        }
+        this.canvasLoading = true;
+        try {
+            const response = await this.storeBuilderService.getPlanoId({ stores: [storeName.toUpperCase()] }).toPromise();
+            if (response?.code === 200 && response?.data?.length > 0) {
+                const planoId = response.data[0]._id;
+                await this.getStoreFixtures(planoId);
+            }
+            else {
+                this.canvasLoading = false;
+                this.cdr.detectChanges();
+            }
+        }
+        catch (error) {
+            console.error('Error loading planogram:', error);
+            this.canvasLoading = false;
+            this.cdr.detectChanges();
+        }
+    }
+    async getStoreFixtures(storeId) {
+        if (!this.previewCanvas) {
+            this.canvasLoading = false;
+            this.cdr.detectChanges();
+            return;
+        }
+        this.storeBuilderService.getStoreFixtures({ id: [storeId] })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: async (res) => {
+                if (!res?.data?.[0]?.floors?.length) {
+                    this.canvasLoading = false;
+                    this.cdr.detectChanges();
+                    return;
+                }
+                this.planoData = structuredClone(res.data[0]);
+                this.floorData = structuredClone(res.data[0].floors[0]);
+                // Apply stored response data if available
+                this.applyStoredResponseData();
+                // Collect all fixtures
+                this.collectAllFixtures();
+                if (this.previewCanvas) {
+                    // Render the planogram first
+                    await this.renderFloor(this.previewCanvas);
+                    this.canvasLoading = false;
+                    this.cdr.detectChanges();
+                    // Wait for all objects to be rendered, then resize and recenter
+                    setTimeout(() => {
+                        if (this.previewCanvasContainerRef?.nativeElement && this.previewCanvas) {
+                            // Resize canvas to container dimensions
+                            this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);
+                            // Wait a bit more for canvas to update, then recenter
+                            setTimeout(() => {
+                                if (this.previewCanvas) {
+                                    this.fitCanvasToLayoutAnimated(this.previewCanvas);
+                                    // Highlight fixture if it has replaceResponseData
+                                    const store = this.findReplaceData?.stores?.find((s) => s.storeName === this.selectedStore?.storeName);
+                                    if (store?.findResponseData && store?.replaceResponseData) {
+                                        const fixtureGroup = this.previewCanvas.getObjects().find((obj) => obj.objType === "fixture" && obj.fixtureId === store.findResponseData);
+                                        if (fixtureGroup) {
+                                            this.highlightFixture(this.previewCanvas, fixtureGroup, false);
+                                        }
+                                    }
+                                }
+                            }, 100);
+                        }
+                    }, 300);
+                }
+                else {
+                    this.canvasLoading = false;
+                    this.cdr.detectChanges();
+                }
+            },
+            error: (err) => {
+                this.canvasLoading = false;
+                this.cdr.detectChanges();
+                console.error('Error fetching plano:', err);
+            },
+        });
+    }
+    applyStoredResponseData() {
+        if (!this.findReplaceData?.stores || !this.selectedStore || !this.floorData) {
+            return;
+        }
+        const store = this.findReplaceData.stores.find((s) => s.storeName === this.selectedStore?.storeName);
+        if (!store?.replaceResponseData) {
+            return;
+        }
+        const fixtureId = store.findResponseData;
+        if (!fixtureId)
+            return;
+        const fixture = this.getFixtureByIdFromFloor(fixtureId);
+        if (!fixture)
+            return;
+        // Store the original fixture (before replace) for before/after comparison
+        const originalFixture = structuredClone(fixture);
+        this.originalFixturesMap.set(fixtureId, originalFixture);
+        // Create a deep copy of the fixture to preserve all original properties
+        const updatedFixture = structuredClone(fixture);
+        // Merge replaceResponseData properties while preserving all other fixture properties
+        if (store.replaceResponseData.vmConfig) {
+            updatedFixture.vmConfig = Array.isArray(store.replaceResponseData.vmConfig)
+                ? store.replaceResponseData.vmConfig
+                : [];
+        }
+        // Merge shelfConfig intelligently - preserve original shelf structure and only update provided properties
+        if (store.replaceResponseData.shelfConfig && Array.isArray(store.replaceResponseData.shelfConfig)) {
+            const originalShelfConfig = Array.isArray(fixture.shelfConfig) ? fixture.shelfConfig : [];
+            // Create a map of original shelves by shelf identifier (shelfType + shelfNumber)
+            const originalShelvesMap = new Map();
+            originalShelfConfig.forEach((shelf) => {
+                const key = `${shelf.shelfType || ''}_${shelf.shelfNumber || ''}`;
+                originalShelvesMap.set(key, shelf);
+            });
+            // Merge: for each shelf in replaceResponseData, find the original and merge
+            updatedFixture.shelfConfig = store.replaceResponseData.shelfConfig.map((newShelf) => {
+                const key = `${newShelf.shelfType || ''}_${newShelf.shelfNumber || ''}`;
+                const originalShelf = originalShelvesMap.get(key);
+                if (originalShelf) {
+                    // Merge: preserve all original properties, update with new ones
+                    return {
+                        ...originalShelf,
+                        ...newShelf,
+                        // Ensure critical numeric properties are preserved
+                        productPerShelf: newShelf.productPerShelf !== undefined ? newShelf.productPerShelf : originalShelf.productPerShelf,
+                        trayRows: newShelf.trayRows !== undefined ? newShelf.trayRows : originalShelf.trayRows,
+                        shelfType: newShelf.shelfType || originalShelf.shelfType,
+                        shelfNumber: newShelf.shelfNumber !== undefined ? newShelf.shelfNumber : originalShelf.shelfNumber,
+                    };
+                }
+                else {
+                    // New shelf not in original - use as is but ensure required properties
+                    return {
+                        ...newShelf,
+                        productPerShelf: newShelf.productPerShelf || 0,
+                        trayRows: newShelf.trayRows || 1,
+                    };
+                }
+            });
+        }
+        else if (!Array.isArray(updatedFixture.shelfConfig)) {
+            updatedFixture.shelfConfig = [];
+        }
+        // Ensure arrays are always arrays
+        if (!Array.isArray(updatedFixture.vmConfig)) {
+            updatedFixture.vmConfig = [];
+        }
+        if (!Array.isArray(updatedFixture.shelfConfig)) {
+            updatedFixture.shelfConfig = [];
+        }
+        this.updateAiResponseFixture(updatedFixture);
+    }
+    getFixtureByIdFromFloor(fixtureId) {
+        if (!fixtureId || !this.floorData)
+            return null;
+        for (const element of this.floorData.layoutPolygon || []) {
+            if (element?.elementType === "wall" && Array.isArray(element.fixtures)) {
+                const hit = element.fixtures.find((fx) => fx?._id === fixtureId);
+                if (hit)
+                    return hit;
+            }
+        }
+        for (const fx of this.floorData.centerFixture || []) {
+            if (fx?._id === fixtureId)
+                return fx;
+        }
+        return null;
+    }
+    updateAiResponseFixture(updatedFixture) {
+        if (!this.floorData)
+            return;
+        for (const element of this.floorData.layoutPolygon || []) {
+            if (element?.elementType === "wall" && Array.isArray(element.fixtures)) {
+                const index = element.fixtures.findIndex((fx) => fx?._id === updatedFixture._id);
+                if (index !== -1) {
+                    element.fixtures[index] = updatedFixture;
+                    return;
+                }
+            }
+        }
+        for (let i = 0; i < (this.floorData.centerFixture || []).length; i++) {
+            if (this.floorData.centerFixture[i]?._id === updatedFixture._id) {
+                this.floorData.centerFixture[i] = updatedFixture;
+                return;
+            }
+        }
+    }
+    collectAllFixtures() {
+        this.allFixtureInstances = [];
+        // Collect wall fixtures
+        if (this.floorData?.layoutPolygon) {
+            for (const element of this.floorData.layoutPolygon) {
+                if (element.fixtures && Array.isArray(element.fixtures)) {
+                    this.allFixtureInstances.push(...element.fixtures);
+                }
+            }
+        }
+        // Collect floor fixtures
+        if (this.floorData?.centerFixture && Array.isArray(this.floorData.centerFixture)) {
+            this.allFixtureInstances.push(...this.floorData.centerFixture);
+        }
+    }
+    async renderFloor(canvas) {
+        await this.drawInitialContent(canvas);
+    }
+    async drawInitialContent(canvas) {
+        // Clear canvas and reset viewport
+        canvas.clear();
+        canvas.setViewportTransform([1, 0, 0, 1, 0, 0]);
+        await this.drawLayoutElements(canvas);
+        // Force render after drawing
+        canvas.requestRenderAll();
+    }
+    async drawLayoutElements(canvas) {
+        if (!this.floorData)
+            return;
+        for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {
+            const element = this.floorData.layoutPolygon[index];
+            let wall;
+            element.relativePosition ??= { x: 0, y: 0, unit: "ft" };
+            const x = this.toPixels(element.relativePosition.x, element.unit);
+            const y = this.toPixels(element.relativePosition.y, element.unit);
+            if (element.elementType === "wall") {
+                const height = this.wallThickness;
+                const width = this.toPixels(element.distance, element.unit);
+                wall = await this.drawWall(canvas, x, y, height, width, element);
+            }
+            else if (element.elementType === "entrance") {
+                this.drawEntrance(canvas, x, y, 80, 75, 40, element);
+            }
+            if (element.elementType === "wall") {
+                const fixtureGroups = [];
+                for (let j = 0; j < element?.fixtures?.length; j++) {
+                    const fixture = element.fixtures[j];
+                    const fx = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+                    const fy = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+                    const fh = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+                    const fw = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+                    const fixtureObj = await this.drawFixture(canvas, fx, fy, fh, fw, fixture);
+                    fixtureGroups.push(fixtureObj);
+                }
+                if (element.isLocked && wall) {
+                    canvas.remove(wall);
+                    fixtureGroups.forEach((f) => canvas.remove(f));
+                    const combinedGroup = new fabric.Group([wall, ...fixtureGroups], {
+                        hasControls: false,
+                        selectable: false,
+                        lockMovementX: true,
+                        lockMovementY: true,
+                        lockRotation: true,
+                        lockScalingX: true,
+                        lockScalingY: true,
+                        subTargetCheck: true,
+                    });
+                    combinedGroup.set({ isLocked: true });
+                    canvas.add(combinedGroup);
+                }
+                for (let j = 0; j < element?.otherElements?.length; j++) {
+                    const otherElement = element.otherElements[j];
+                    const ox = this.toPixels(otherElement.relativePosition.x, "ft");
+                    const oy = this.toPixels(otherElement.relativePosition.y, "ft");
+                    const oa = otherElement.relativePosition.angle;
+                    const oh = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);
+                    const ow = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);
+                    this.drawOtherElementsWithLabel(canvas, ox, oy, oa, ow, oh, otherElement);
+                }
+            }
+        }
+        for (let i = 0; i < this.floorData?.centerFixture?.length; i++) {
+            const fixture = this.floorData.centerFixture[i];
+            const x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+            const y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+            const h = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+            const w = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+            await this.drawFixture(canvas, x, y, h, w, fixture);
+        }
+        for (let j = 0; j < this.floorData?.otherElements?.length; j++) {
+            const otherElement = this.floorData.otherElements[j];
+            const x = this.toPixels(otherElement.relativePosition.x, "ft");
+            const y = this.toPixels(otherElement.relativePosition.y, "ft");
+            const a = otherElement.relativePosition.angle;
+            const h = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);
+            const w = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);
+            this.drawOtherElementsWithLabel(canvas, x, y, a, w, h, otherElement);
+        }
+        return true;
+    }
+    async drawWall(canvas, x, y, height, width, elementData) {
+        const radius = 5;
+        const fillColor = "#F6FCFF";
+        const strokeColor = "#D0D5DD";
+        const labelColor = "#009BF3";
+        let text = `${this.titleCase.transform(elementData.elementType)} ${elementData.elementNumber}`;
+        const wall = new fabric.Rect({
+            left: 0,
+            top: 0,
+            width,
+            height,
+            rx: radius,
+            ry: radius,
+            fill: fillColor,
+            stroke: strokeColor,
+            strokeWidth: 0.27,
+            selectable: false,
+            strokeUniform: true,
+        });
+        const centerX = width / 2;
+        const centerY = height / 2;
+        const isVertical = height > width;
+        const label = new fabric.FabricText(text, {
+            left: centerX,
+            top: centerY,
+            fontSize: 10,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: labelColor,
+            originX: "center",
+            originY: "center",
+            angle: isVertical ? -90 : 0,
+            selectable: false,
+        });
+        const arrowHead = 5;
+        const elements = [wall, label];
+        if (isVertical) {
+            const textWidth = label.width || 0;
+            const topArrowY = 5;
+            const topArrowEndY = centerY - textWidth / 2 - 5;
+            if (topArrowEndY > topArrowY + arrowHead) {
+                elements.push(new fabric.Line([centerX, topArrowY, centerX, topArrowEndY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: centerX,
+                    top: topArrowY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: 0,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "bottom",
+                    selectable: false,
+                }));
+            }
+            const bottomArrowStartY = centerY + textWidth / 2 + 5;
+            const bottomArrowEndY = height - 5;
+            if (bottomArrowEndY > bottomArrowStartY + arrowHead) {
+                elements.push(new fabric.Line([centerX, bottomArrowStartY, centerX, bottomArrowEndY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: centerX,
+                    top: bottomArrowEndY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: 180,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "top",
+                    selectable: false,
+                }));
+            }
+        }
+        else {
+            const textWidth = label.width || 0;
+            const leftArrowStartX = 5;
+            const leftArrowEndX = centerX - textWidth / 2 - 5;
+            if (leftArrowEndX > leftArrowStartX + arrowHead) {
+                elements.push(new fabric.Line([leftArrowStartX, centerY, leftArrowEndX, centerY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: leftArrowStartX,
+                    top: centerY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: -90,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "center",
+                    selectable: false,
+                }));
+            }
+            const rightArrowStartX = centerX + textWidth / 2 + 5;
+            const rightArrowEndX = width - 5;
+            if (rightArrowEndX > rightArrowStartX + arrowHead) {
+                elements.push(new fabric.Line([rightArrowStartX, centerY, rightArrowEndX, centerY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: rightArrowEndX,
+                    top: centerY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: 90,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "center",
+                    selectable: false,
+                }));
+            }
+        }
+        const group = new fabric.Group(elements, {
+            left: x,
+            top: y,
+            hasControls: false,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockRotation: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            evented: true,
+            hoverCursor: "default",
+            angle: elementData.angle,
+            subTargetCheck: true,
+        });
+        group.objType = elementData.elementType;
+        group.data = elementData;
+        canvas.add(group);
+        // If newly added, focus it once
+        if (elementData?.newAdded) {
+            try {
+                canvas.setActiveObject(group);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete elementData.newAdded;
+        }
+        return group;
+    }
+    drawEntrance(canvas, x, y, width, height, arrowWidth, elementData) {
+        const bodyWidth = width - arrowWidth;
+        const pathData = [
+            `M 0 0`,
+            `L ${bodyWidth} 0`,
+            `L ${bodyWidth} ${-height / 2}`,
+            `L ${width} ${height / 2}`,
+            `L ${bodyWidth} ${height + height / 2}`,
+            `L ${bodyWidth} ${height}`,
+            `L 0 ${height}`,
+            `Z`,
+        ].join(" ");
+        const arrow = new fabric.Path(pathData, {
+            fill: "#03A9F4",
+            selectable: false,
+            evented: false,
+        });
+        const maxTextHeight = height - 6;
+        const text = new fabric.Text("Entrance", {
+            fontFamily: "Arial",
+            fontWeight: "bold",
+            fill: "white",
+            angle: -90,
+            originX: "center",
+            originY: "center",
+            left: 15,
+            top: height / 2,
+            fontSize: 20,
+            selectable: false,
+            evented: false,
+        });
+        const textBounds = text.getBoundingRect();
+        if (textBounds.height > maxTextHeight) {
+            const scale = maxTextHeight / textBounds.height;
+            text.set("fontSize", text.fontSize * scale);
+        }
+        const group = new fabric.Group([arrow, text], {
+            left: x,
+            top: y,
+            hasControls: false,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockScalingFlip: true,
+            lockRotation: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            evented: true,
+            hoverCursor: "default",
+            angle: elementData.angle,
+        });
+        group.objType = elementData.elementType;
+        group.data = elementData;
+        canvas.add(group);
+    }
+    async drawFixture(canvas, x, y, height, width, fixtureData) {
+        let fixtureColor;
+        // if (["fixture", "fixture-redo"].includes(this.publishingState)) {
+        //   fixtureColor = {
+        //     primary:
+        //       fixtureData.status == "" && fixtureData.taskStatus == "submit"
+        //         ? "#a5a6a8"
+        //         : fixtureData.status == "agree"
+        //         ? "#6CE9A6"
+        //         : "#51C1FF",
+        //     fill:
+        //       fixtureData.status == "" && fixtureData.taskStatus == "submit"
+        //         ? "#f3f4f8"
+        //         : fixtureData.status == "agree"
+        //         ? "#6CE9A6"
+        //         : "#EAF8FF",
+        //     vmFill:
+        //       fixtureData.status == "" && fixtureData.taskStatus == "submit"
+        //         ? "#a5a6a8"
+        //         : "#6938EF",
+        //   };
+        // }
+        if (fixtureData.fixtureName === "space")
+            return;
+        const radius = 5;
+        const mainContainer = new fabric.Rect({
+            left: x,
+            top: y,
+            width: width,
+            height: height,
+            rx: radius,
+            ry: radius,
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "white",
+        });
+        const topWidth = width / 1.05;
+        const topHeight = (15 / 100) * height;
+        const topX = x + (width - topWidth) / 2;
+        const topY = y + this.verticalMargin;
+        const topContainer = new fabric.Rect({
+            left: topX,
+            top: topY,
+            width: topWidth,
+            height: topHeight,
+            rx: radius,
+            ry: radius,
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "white",
+        });
+        const innerBoxHeight = topHeight / 2;
+        const innerTopBox = new fabric.Path(`M ${topX + radius} ${topY} 
+              L ${topX + topWidth - radius} ${topY} 
+              Q ${topX + topWidth} ${topY} ${topX + topWidth} ${topY + radius} 
+              L ${topX + topWidth} ${topY + innerBoxHeight} 
+              L ${topX} ${topY + innerBoxHeight} 
+              L ${topX} ${topY + radius} 
+              Q ${topX} ${topY} ${topX + radius} ${topY} Z`, {
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "transparent",
+        });
+        const topText = new fabric.Textbox(`Fixture ${fixtureData.associatedElementFixtureNumber
+            ? fixtureData.associatedElementFixtureNumber +
+                (fixtureData?.fixtureNumber
+                    ? " - FX-" + fixtureData.fixtureNumber
+                    : "")
+            : "new"}`, {
+            left: topX + topWidth / 2,
+            top: topY + innerBoxHeight / 2,
+            fontSize: 5,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#101828",
+            originX: "center",
+            originY: "center",
+            width: topWidth,
+            height: innerBoxHeight,
+            textAlign: "center",
+        });
+        const secondBoxY = topY + innerBoxHeight;
+        const innerBottomBox = new fabric.Path(`M ${topX} ${secondBoxY} 
+          L ${topX + topWidth} ${secondBoxY} 
+          L ${topX + topWidth} ${secondBoxY + innerBoxHeight - radius} 
+          Q ${topX + topWidth} ${secondBoxY + innerBoxHeight} ${topX + topWidth - radius} ${secondBoxY + innerBoxHeight} 
+          L ${topX + radius} ${secondBoxY + innerBoxHeight} 
+          Q ${topX} ${secondBoxY + innerBoxHeight} ${topX} ${secondBoxY + innerBoxHeight - radius} 
+          L ${topX} ${secondBoxY} Z`, {
+            fill: "#344054",
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+        });
+        let fontSize = 5;
+        let bottomText;
+        const textContent = `${fixtureData?.fixtureName} - ${fixtureData?.fixtureWidth.value} ${fixtureData?.fixtureWidth.unit}`;
+        const createBottomText = (fs) => new fabric.Textbox(textContent, {
+            left: topX + topWidth / 2,
+            top: secondBoxY + innerBoxHeight / 2,
+            fontSize: fs,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#FFFFFF",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            width: topWidth,
+        });
+        do {
+            bottomText = createBottomText(fontSize);
+            fontSize -= 0.5;
+        } while (bottomText.height > innerBoxHeight && fontSize > 2);
+        const midWidth = width / 1.05;
+        const midHeight = (77 / 100) * height;
+        const midX = x + (width - midWidth) / 2;
+        const midY = topY + topHeight + this.verticalMargin;
+        const midContainer = new fabric.Rect({
+            left: midX,
+            top: midY,
+            width: midWidth,
+            height: midHeight,
+            rx: radius,
+            ry: radius,
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "white",
+        });
+        const shelfCount = fixtureData.shelfConfig?.length;
+        const boxHeight = midHeight / (shelfCount + 2);
+        const firstBoxY = midY;
+        const firstBox = new fabric.Path(`M ${midX + radius} ${firstBoxY} 
+              L ${midX + midWidth - radius} ${firstBoxY} 
+              Q ${midX + midWidth} ${firstBoxY} ${midX + midWidth} ${firstBoxY + radius} 
+              L ${midX + midWidth} ${firstBoxY + boxHeight} 
+              L ${midX} ${firstBoxY + boxHeight} 
+              L ${midX} ${firstBoxY + radius} 
+              Q ${midX} ${firstBoxY} ${midX + radius} ${firstBoxY} Z`, {
+            fill: fixtureColor?.fill
+                ? fixtureColor?.fill
+                : fixtureData.issue
+                    ? "#D92D20"
+                    : "#EAF8FF",
+            stroke: fixtureColor?.primary
+                ? fixtureColor?.primary
+                : fixtureData.issue
+                    ? "#D92D20"
+                    : "#6BCAFF",
+            strokeWidth: 0.27,
+        });
+        const firstBoxText = new fabric.Textbox(`${fixtureData?.header?.label ? fixtureData.header.label : ""}`, {
+            left: midX + midWidth / 2,
+            top: firstBoxY + boxHeight / 2,
+            fontSize: 7,
+            fontFamily: "Inter",
+            fontWeight: "600",
+            fill: fixtureData.issue ? "#fff" : "#101828",
+            originX: "center",
+            originY: "center",
+            width: midWidth,
+            height: boxHeight,
+            textAlign: "center",
+        });
+        const shelves = [];
+        const shelfHeight = midHeight - 2 * boxHeight;
+        if (fixtureData.productResolutionLevel === "L1") {
+            const boxY = firstBoxY + boxHeight;
+            const shelf = new fabric.Rect({
+                left: midX,
+                top: boxY,
+                width: midWidth,
+                height: shelfHeight,
+                // stroke: '#51C1FF',
+                stroke: fixtureColor?.primary
+                    ? fixtureColor?.primary
+                    : fixtureData.issue
+                        ? "#D92D20"
+                        : "#51C1FF",
+                strokeWidth: 0.27,
+                fill: "white",
+            });
+            const text = fixtureData?.productBrandName?.join(" + ") || "";
+            // Wrap text within fixture width and shrink to fit vertical space
+            const maxTextWidth = midWidth * 0.9;
+            const maxTextHeight = shelfHeight * 0.8;
+            let fontSizeL1 = 6;
+            const createWrappedTextbox = (fs) => new fabric.Textbox(text, {
+                left: midX + midWidth / 2,
+                top: boxY + shelfHeight / 2,
+                originX: "center",
+                originY: "center",
+                width: maxTextWidth,
+                fontSize: fs,
+                fontFamily: "Inter",
+                fontWeight: "500",
+                textAlign: "center",
+                fill: "#333",
+                selectable: false,
+                evented: false,
+            });
+            let wrappedText = createWrappedTextbox(fontSizeL1);
+            while (wrappedText.height > maxTextHeight && fontSizeL1 > 2) {
+                fontSizeL1 -= 0.5;
+                wrappedText = createWrappedTextbox(fontSizeL1);
+            }
+            const padding = 2;
+            const background = new fabric.Rect({
+                left: midX + midWidth / 2,
+                top: boxY + shelfHeight / 2,
+                originX: "center",
+                originY: "center",
+                width: Math.min(maxTextWidth, wrappedText.width) + padding,
+                height: wrappedText.getScaledHeight() + 2,
+                fill: "rgba(255, 255, 255, 0.5)",
+                selectable: false,
+                evented: false,
+                rx: 1,
+                ry: 1,
+            });
+            shelves.push(shelf, background, wrappedText);
+        }
+        else if (fixtureData.productResolutionLevel === "L2") {
+            for (let i = 0; i < shelfCount; i++) {
+                const boxY = firstBoxY + boxHeight * (i + 1);
+                const shelf = new fabric.Rect({
+                    left: midX,
+                    top: boxY,
+                    width: midWidth,
+                    height: boxHeight,
+                    stroke: fixtureColor?.primary
+                        ? fixtureColor?.primary
+                        : fixtureData.issue
+                            ? "#D92D20"
+                            : "#51C1FF",
+                    strokeWidth: 0.27,
+                    fill: "white",
+                });
+                shelves.push(shelf);
+                if (fixtureData.shelfConfig?.[i].shelfType === "tray") {
+                    const trayRows = fixtureData.shelfConfig?.[i].trayRows || 1;
+                    const rowSpacing = boxHeight / trayRows;
+                    for (let r = 1; r < trayRows; r++) {
+                        const lineY = boxY + r * rowSpacing;
+                        const trayLine = new fabric.Line([midX, lineY, midX + midWidth, lineY], {
+                            stroke: "#999",
+                            strokeWidth: 0.2,
+                            selectable: false,
+                            evented: false,
+                        });
+                        shelves.push(trayLine);
+                    }
+                }
+                const text = fixtureData.shelfConfig?.[i].productBrandName?.join(" + ") || "";
+                // L2: Single-line ellipsis against full shelf width
+                const horizontalPadding = 6;
+                const maxTextWidth = Math.max(0, midWidth - horizontalPadding);
+                const maxTextHeight = boxHeight * 0.8;
+                const baseFontSize = 5;
+                const measure = (t) => new fabric.Text(t, {
+                    fontSize: baseFontSize,
+                    fontFamily: "Inter",
+                    fontWeight: "500",
+                });
+                let displayText = text;
+                let measured = measure(displayText);
+                if ((measured.width ?? 0) > maxTextWidth) {
+                    const ellipsis = "...";
+                    let leftIdx = 0;
+                    let rightIdx = text.length;
+                    while (leftIdx < rightIdx) {
+                        const midIdx = Math.floor((leftIdx + rightIdx) / 2);
+                        const candidate = text.slice(0, midIdx) + ellipsis;
+                        measured = measure(candidate);
+                        if ((measured.width ?? 0) > maxTextWidth) {
+                            rightIdx = midIdx;
+                        }
+                        else {
+                            leftIdx = midIdx + 1;
+                        }
+                    }
+                    displayText = text.slice(0, Math.max(0, leftIdx - 1)) + ellipsis;
+                    measured = measure(displayText);
+                }
+                const background = new fabric.Rect({
+                    left: midX + midWidth / 2,
+                    top: boxY + boxHeight / 2,
+                    originX: "center",
+                    originY: "center",
+                    width: midWidth,
+                    height: Math.min(maxTextHeight, measured.height ?? 10) + 2,
+                    fill: "rgba(255, 255, 255, 0.5)",
+                    selectable: false,
+                    evented: false,
+                    rx: 1,
+                    ry: 1,
+                });
+                const finalText = new fabric.Text(displayText, {
+                    left: midX + midWidth / 2,
+                    top: boxY + boxHeight / 2,
+                    originX: "center",
+                    originY: "center",
+                    fontSize: baseFontSize,
+                    fontFamily: "Inter",
+                    fontWeight: "500",
+                    fill: "#333",
+                    selectable: false,
+                    evented: false,
+                });
+                shelves.push(background, finalText);
+            }
+        }
+        else if (fixtureData.productResolutionLevel === "L3") {
+            const sequentialGroups = [];
+            let previousZone = null;
+            for (const shelf of fixtureData.shelfConfig) {
+                const zone = shelf.zone || "Unknown";
+                if (zone !== previousZone) {
+                    sequentialGroups.push({ zone, shelves: [shelf] });
+                    previousZone = zone;
+                }
+                else {
+                    sequentialGroups[sequentialGroups.length - 1].shelves.push(shelf);
+                }
+            }
+            let currentShelfIndex = 0;
+            for (const group of sequentialGroups) {
+                const { zone, shelves: shelvesInGroup } = group;
+                const groupStartIndex = currentShelfIndex;
+                const groupLength = shelvesInGroup.length;
+                const groupTopY = firstBoxY + boxHeight * (groupStartIndex + 1);
+                const groupBottomY = groupTopY + boxHeight * groupLength;
+                for (let j = 0; j < shelvesInGroup.length; j++) {
+                    const shelfData = shelvesInGroup[j];
+                    const boxY = firstBoxY + boxHeight * (currentShelfIndex + 1);
+                    const shelfRect = new fabric.Rect({
+                        left: midX,
+                        top: boxY,
+                        width: midWidth,
+                        height: boxHeight,
+                        stroke: fixtureColor?.primary
+                            ? fixtureColor?.primary
+                            : fixtureData.issue
+                                ? "#D92D20"
+                                : "#51C1FF",
+                        strokeWidth: 0.27,
+                        fill: "white",
+                    });
+                    shelves.push(shelfRect);
+                    if (shelfData.shelfType === "tray") {
+                        const trayRows = shelfData.trayRows || 0;
+                        const productPerShelf = shelfData.productPerShelf || 0;
+                        const rowSpacing = boxHeight / trayRows;
+                        const columnSpacing = midWidth / productPerShelf;
+                        for (let r = 1; r < trayRows; r++) {
+                            const lineY = boxY + r * rowSpacing;
+                            const trayLine = new fabric.Line([midX, lineY, midX + midWidth, lineY], {
+                                stroke: "#999",
+                                strokeWidth: 0.2,
+                                selectable: false,
+                                evented: false,
+                            });
+                            shelves.push(trayLine);
+                        }
+                        for (let c = 1; c < productPerShelf; c++) {
+                            const lineX = midX + c * columnSpacing;
+                            const verticalLine = new fabric.Line([lineX, boxY, lineX, boxY + boxHeight], {
+                                stroke: "#999",
+                                strokeWidth: 0.2,
+                                selectable: false,
+                                evented: false,
+                            });
+                            shelves.push(verticalLine);
+                        }
+                    }
+                    currentShelfIndex++;
+                }
+                const groupBottomLine = new fabric.Line([midX, groupBottomY, midX + midWidth, groupBottomY], {
+                    stroke: fixtureColor?.primary
+                        ? fixtureColor?.primary
+                        : fixtureData.issue
+                            ? "#D92D20"
+                            : "#51C1FF",
+                    strokeWidth: 1,
+                    selectable: false,
+                    evented: false,
+                });
+                shelves.push(groupBottomLine);
+                if (fixtureData.fixtureType === "wall") {
+                    const labelPadding = 2;
+                    const labelText = new fabric.Textbox(zone, {
+                        left: midX + midWidth - labelPadding,
+                        top: groupBottomY,
+                        fontSize: 5,
+                        fontFamily: "Inter",
+                        fontWeight: "600",
+                        fill: "#707070",
+                        originX: "right",
+                        originY: "bottom",
+                        width: midWidth / 2,
+                        textAlign: "right",
+                    });
+                    shelves.push(labelText);
+                }
+                const groupCenterX = midX + midWidth / 2;
+                const groupCenterY = groupTopY + (groupBottomY - groupTopY) / 2;
+                const sectionBrands = new Set();
+                shelvesInGroup?.forEach((shelf) => {
+                    shelf.productBrandName?.forEach((brand) => {
+                        sectionBrands.add(brand);
+                    });
+                });
+                if ([...sectionBrands].length) {
+                    const text = [...sectionBrands].join(" + ");
+                    const padding = 2;
+                    const maxTextWidth = midWidth;
+                    const rectWidth = midWidth * 0.9;
+                    const maxTextHeight = 20;
+                    let fontSize = 6;
+                    let wrappedText;
+                    const createTextbox = (fs) => {
+                        return new fabric.Textbox(text, {
+                            fontSize: fs,
+                            fontFamily: "Inter",
+                            fontWeight: "400",
+                            width: maxTextWidth,
+                            textAlign: "center",
+                            originX: "center",
+                            originY: "center",
+                            fill: "#101828",
+                            selectable: false,
+                            evented: false,
+                            left: groupCenterX,
+                            top: groupCenterY,
+                        });
+                    };
+                    do {
+                        wrappedText = createTextbox(fontSize);
+                        fontSize -= 0.5;
+                    } while (wrappedText.height > maxTextHeight && fontSize > 2);
+                    const rectHeight = wrappedText.getScaledHeight() + padding;
+                    const groupCenterText = new fabric.Rect({
+                        left: groupCenterX,
+                        top: groupCenterY,
+                        originX: "center",
+                        originY: "center",
+                        width: rectWidth,
+                        height: rectHeight,
+                        fill: "rgba(255, 255, 255, 0.5)",
+                        selectable: false,
+                        evented: false,
+                        rx: 1,
+                        ry: 1,
+                    });
+                    shelves.push(groupCenterText, wrappedText);
+                }
+            }
+        }
+        if (fixtureData?.vmConfig?.length) {
+            for (let i = 0; i < fixtureData.vmConfig.length; i++) {
+                const vm = fixtureData.vmConfig[i];
+                const startIndex = vm.startYPosition - 1;
+                const endIndex = vm.endYPosition - 1;
+                const shelfTopY = firstBoxY + boxHeight * (startIndex + 1);
+                const shelfHeightSpan = boxHeight * (endIndex - startIndex + 1);
+                let vmHeightPx = shelfHeightSpan;
+                let y = shelfTopY;
+                if (vm.yZone && vm.yZone !== "stretch") {
+                    vmHeightPx = shelfHeightSpan / 3;
+                    switch (vm.yZone) {
+                        case "top":
+                            y = shelfTopY;
+                            break;
+                        case "middle":
+                            y = shelfTopY + vmHeightPx;
+                            break;
+                        case "bottom":
+                            y = shelfTopY + 2 * vmHeightPx;
+                            break;
+                        default:
+                            y = shelfTopY;
+                    }
+                }
+                let x = midX;
+                let width = midWidth;
+                if (!vm.xZone || vm.xZone === "stretch") {
+                    width = midWidth;
+                    x = midX;
+                }
+                else {
+                    const sectionWidth = midWidth / 3;
+                    switch (vm.xZone) {
+                        case "left":
+                            width = sectionWidth;
+                            x = midX;
+                            break;
+                        case "middle":
+                            width = sectionWidth;
+                            x = midX + sectionWidth;
+                            break;
+                        case "right":
+                            width = sectionWidth;
+                            x = midX + 2 * sectionWidth;
+                            break;
+                        default:
+                            width = midWidth;
+                            x = midX;
+                    }
+                }
+                if (vm.vmImageUrl) {
+                    try {
+                        const vmImage = await fabric.FabricImage.fromURL(`${this.cdnUrl}${vm.vmImageUrl}?v=${Date.now()}`, {
+                            crossOrigin: "anonymous",
+                        });
+                        vmImage.set({
+                            left: x + width / 2,
+                            top: y + vmHeightPx / 2,
+                            originX: "center",
+                            originY: "center",
+                            scaleX: width / vmImage.width,
+                            scaleY: vmHeightPx / vmImage.height,
+                            selectable: false,
+                            evented: false,
+                        });
+                        shelves.push(vmImage);
+                    }
+                    catch (err) {
+                        console.error(`Error loading image for VM: ${vm.vmImageUrl}`, err);
+                    }
+                }
+                else {
+                    const vmBox = new fabric.Rect({
+                        left: x,
+                        top: y,
+                        width,
+                        height: vmHeightPx,
+                        fill: fixtureColor?.vmFill ?? "#6938EF",
+                        selectable: false,
+                        evented: false,
+                    });
+                    let fontSize = 5;
+                    let vmText;
+                    const createVmText = (fs) => new fabric.Textbox(vm.vmName || "", {
+                        left: x + width / 2,
+                        top: y + vmHeightPx / 2,
+                        originX: "center",
+                        originY: "center",
+                        fontSize: fs,
+                        fontFamily: "Inter",
+                        fontWeight: "600",
+                        fill: "white",
+                        textAlign: "center",
+                        width: width,
+                        selectable: false,
+                        evented: false,
+                    });
+                    do {
+                        vmText = createVmText(fontSize);
+                        fontSize -= 0.5;
+                    } while (vmText.height > vmHeightPx && fontSize > 2);
+                    shelves.push(vmBox, vmText);
+                }
+            }
+        }
+        const lastBoxY = firstBoxY + boxHeight * (shelfCount + 1);
+        const lastBox = new fabric.Path(`M ${midX} ${lastBoxY} 
+              L ${midX + midWidth} ${lastBoxY} 
+              L ${midX + midWidth} ${lastBoxY + boxHeight - radius} 
+              Q ${midX + midWidth} ${lastBoxY + boxHeight} ${midX + midWidth - radius} ${lastBoxY + boxHeight} 
+              L ${midX + radius} ${lastBoxY + boxHeight} 
+              Q ${midX} ${lastBoxY + boxHeight} ${midX} ${lastBoxY + boxHeight - radius} 
+              L ${midX} ${lastBoxY} Z`, {
+            fill: fixtureColor?.fill
+                ? fixtureColor?.fill
+                : fixtureData.issue
+                    ? "#FEE4E2"
+                    : "#EAF8FF",
+            stroke: fixtureColor?.primary
+                ? fixtureColor?.primary
+                : fixtureData.issue
+                    ? "#D92D20"
+                    : "#6BCAFF",
+            strokeWidth: 0.27,
+        });
+        const lastBoxText = new fabric.Textbox(`${fixtureData?.footer?.label ? fixtureData.footer.label : ""}`, {
+            left: midX + midWidth / 2,
+            top: lastBoxY + boxHeight / 2,
+            fontSize: 5,
+            fontFamily: "Inter",
+            fontWeight: "600",
+            fill: "#101828",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            width: midWidth,
+            heigth: boxHeight,
+        });
+        const bottomWidth = width / 1.05;
+        const bottomHeight = (3 / 100) * height;
+        const bottomX = x + (width - bottomWidth) / 2;
+        const bottomY = midY + midHeight + this.verticalMargin;
+        const bottomContainer = new fabric.Rect({
+            left: bottomX,
+            top: bottomY,
+            width: bottomWidth,
+            height: bottomHeight,
+            rx: radius,
+            ry: radius,
+            stroke: "transparent",
+            fill: "transparent",
+        });
+        const bottomTextContent = new fabric.Textbox(`Shelves - ${fixtureData.shelfConfig?.length} . Products -  ${fixtureData.fixtureCapacity} . VM - ${fixtureData.vmConfig?.length}`, {
+            left: bottomX + bottomWidth / 2,
+            top: bottomY + bottomHeight / 2,
+            fontSize: 5,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#333",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            width: bottomWidth,
+            height: bottomHeight,
+        });
+        const fixtureGroup = new fabric.Group([
+            mainContainer,
+            topContainer,
+            innerTopBox,
+            topText,
+            innerBottomBox,
+            bottomText,
+            midContainer,
+            firstBox,
+            firstBoxText,
+            ...shelves,
+            lastBox,
+            lastBoxText,
+            bottomContainer,
+            bottomTextContent,
+        ], {
+            left: x,
+            top: y,
+            evented: true,
+            selectable: false,
+            hoverCursor: "default",
+            lockScalingX: true,
+            lockScalingY: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            lockRotation: true,
+            hasControls: false,
+            subTargetCheck: true,
+            angle: fixtureData.relativePosition?.angle ?? 0,
+        });
+        fixtureGroup.fixtureType = fixtureData.fixtureType;
+        fixtureGroup.wallIndex = fixtureData.associatedElementNumber;
+        fixtureGroup.fixtureIndex = fixtureData.associatedElementFixtureNumber;
+        fixtureGroup.fixtureId = fixtureData._id;
+        fixtureGroup.issue = fixtureData.issue;
+        fixtureGroup.issueData = fixtureData.issueData;
+        fixtureGroup.taskType = fixtureData.taskType;
+        fixtureGroup.vmConfig = fixtureData.vmConfig;
+        fixtureGroup.objType = "fixture";
+        // Add click handler directly on the fixture group
+        fixtureGroup.on("mousedown", (event) => {
+            // Use the fixture group itself (which has all the fixture properties)
+            // The event.target might be a child element, so we use fixtureGroup directly
+            if (fixtureGroup && fixtureGroup.fixtureId) {
+                // this.onFixtureClick(fixtureGroup);
+            }
+        });
+        canvas.add(fixtureGroup);
+        // If newly added, focus it once
+        if (fixtureData?.newAdded) {
+            try {
+                canvas.setActiveObject(fixtureGroup);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete fixtureData.newAdded;
+        }
+        return fixtureGroup;
+    }
+    drawOtherElementsWithLabel(canvas, x, y, a, width, height, element) {
+        const rect = new fabric.Rect({
+            width,
+            height,
+            rx: 2,
+            ry: 2,
+            fill: "#DAF1FF",
+            stroke: "#6BCAFF",
+            strokeWidth: 2,
+            originX: "center",
+            originY: "center",
+        });
+        const text = new fabric.Textbox(element.fixtureName, {
+            width: width - 8,
+            fontSize: 14,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#101828",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            editable: false,
+            splitByGrapheme: true,
+        });
+        const textBounds = text.getBoundingRect();
+        if (textBounds.height > height - 8) {
+            const scale = (height - 8) / textBounds.height;
+            text.set("fontSize", text.fontSize * scale);
+        }
+        const group = new fabric.Group([rect, text], {
+            left: x,
+            top: y,
+            angle: a,
+            originX: "center",
+            originY: "center",
+            hasControls: false,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockRotation: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            evented: true,
+            hoverCursor: "default",
+        });
+        group.objType = "others";
+        group.data = element;
+        canvas.add(group);
+        if (element?.newAdded) {
+            try {
+                canvas.setActiveObject(group);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete element.newAdded;
+        }
+        return group;
+    }
+    resizeCanvas(canvas, container) {
+        const containerEl = container.nativeElement;
+        const width = containerEl.clientWidth || containerEl.offsetWidth;
+        const height = containerEl.clientHeight || containerEl.offsetHeight;
+        if (width > 0 && height > 0) {
+            canvas.setDimensions({
+                width: width,
+                height: height,
+            });
+            canvas.calcOffset();
+            canvas.requestRenderAll();
+        }
+    }
+    fitCanvasToLayoutAnimated(canvas) {
+        if (!canvas)
+            return;
+        // Ensure canvas has objects before calculating bounds
+        const objects = canvas.getObjects();
+        if (!objects || objects.length === 0) {
+            console.warn('No objects on canvas to fit');
+            return;
+        }
+        // Force recalculation of object coordinates
+        canvas.calcOffset();
+        const bounds = this.getFullLayoutBounds(canvas);
+        if (!bounds.width || !bounds.height || bounds.width === 0 || bounds.height === 0) {
+            console.warn('Invalid bounds for canvas fitting', bounds);
+            return;
+        }
+        const canvasW = canvas.getWidth();
+        const canvasH = canvas.getHeight();
+        if (canvasW === 0 || canvasH === 0) {
+            console.warn('Canvas dimensions are zero');
+            return;
+        }
+        const scaleX = canvasW / bounds.width;
+        const scaleY = canvasH / bounds.height;
+        // Use smaller multiplier (0.5) to zoom out more and ensure planogram fits with more padding inside canvas
+        const targetZoom = Math.min(scaleX, scaleY) * 0.9;
+        // Ensure zoom is within reasonable bounds
+        const finalZoom = Math.max(0.1, Math.min(targetZoom, 3));
+        const targetVpt = [...(canvas.viewportTransform || [1, 0, 0, 1, 0, 0])];
+        targetVpt[0] = finalZoom;
+        targetVpt[3] = finalZoom;
+        // Calculate center of layout bounds for horizontal centering
+        const centerX = bounds.left + bounds.width / 2;
+        // Position from top with very minimal padding (use top space)
+        const topPadding = 10; // Fixed 10px padding from top
+        // Calculate translation: center horizontally, position from top
+        targetVpt[4] = canvasW / 2 - centerX * finalZoom;
+        targetVpt[5] = topPadding - bounds.top * finalZoom;
+        const startVpt = [...canvas.viewportTransform];
+        fabric.util.animate({
+            startValue: 0,
+            endValue: 1,
+            duration: 500,
+            onChange: (value) => {
+                const vpt = [...startVpt];
+                vpt[0] = startVpt[0] + (targetVpt[0] - startVpt[0]) * value;
+                vpt[3] = startVpt[3] + (targetVpt[3] - startVpt[3]) * value;
+                vpt[4] = startVpt[4] + (targetVpt[4] - startVpt[4]) * value;
+                vpt[5] = startVpt[5] + (targetVpt[5] - startVpt[5]) * value;
+                canvas.setViewportTransform(vpt);
+                canvas.requestRenderAll();
+            },
+        });
+    }
+    getFullLayoutBounds(canvas) {
+        const objects = canvas.getObjects();
+        if (!objects.length)
+            return { left: 0, top: 0, width: 0, height: 0 };
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const obj of objects) {
+            // Get bounding rect which accounts for object's position, rotation, and scale
+            const boundingRect = obj.getBoundingRect();
+            // Get the actual bounding box
+            const left = boundingRect.left;
+            const top = boundingRect.top;
+            const right = left + boundingRect.width;
+            const bottom = top + boundingRect.height;
+            minX = Math.min(minX, left);
+            minY = Math.min(minY, top);
+            maxX = Math.max(maxX, right);
+            maxY = Math.max(maxY, bottom);
+        }
+        return { left: minX, top: minY, width: maxX - minX, height: maxY - minY };
+    }
+    toPixels(value, unit, dpi = 2.8) {
+        let pixels;
+        if (unit === "mm") {
+            pixels = (value / 25.4) * dpi;
+        }
+        else if (unit === "ft") {
+            pixels = value * 12 * dpi;
+        }
+        else {
+            throw new Error("Unsupported unit. Use 'mm' or 'ft'.");
+        }
+        return Number(pixels.toFixed(4));
+    }
+    // Store list methods
+    onSelectAll(checked) {
+        if (checked) {
+            // Only select stores that don't have no-match status
+            this.filteredStores.forEach(store => {
+                if (!this.hasNoMatch(store)) {
+                    store.isApproved = true;
+                    this.selectedStores.add(store.storeName);
+                }
+            });
+        }
+        else {
+            // Deselect all stores
+            this.filteredStores.forEach(store => {
+                store.isApproved = false;
+            });
+            this.selectedStores.clear();
+        }
+        // Update findReplaceData stores array and notify data service
+        if (this.findReplaceData?.stores) {
+            const stores = this.findReplaceData.stores;
+            this.filteredStores.forEach(filteredStore => {
+                if (filteredStore && stores) {
+                    const storeIndex = stores.findIndex(s => s && s.storeName === filteredStore.storeName);
+                    if (storeIndex !== -1 && stores[storeIndex]) {
+                        stores[storeIndex].isApproved = filteredStore.isApproved;
+                    }
+                }
+            });
+            // Update data service to preserve state
+            if (stores) {
+                this.dataService.updateData({ stores: stores });
+            }
+        }
+    }
+    onStoreCheckboxChange(store, checked) {
+        // Prevent selection if store has no-match status
+        if (this.hasNoMatch(store)) {
+            return;
+        }
+        if (!store) {
+            return;
+        }
+        // Update isApproved property on the store object
+        store.isApproved = checked;
+        // Update the store in the local stores array
+        const localStoreIndex = this.stores.findIndex(s => s.storeName === store.storeName);
+        if (localStoreIndex !== -1 && this.stores[localStoreIndex]) {
+            this.stores[localStoreIndex].isApproved = checked;
+        }
+        // Update selectedStores set for backward compatibility
+        if (checked) {
+            this.selectedStores.add(store.storeName);
+        }
+        else {
+            this.selectedStores.delete(store.storeName);
+        }
+        // Update the store in findReplaceData stores array and notify data service to preserve state
+        if (this.findReplaceData?.stores) {
+            const storeIndex = this.findReplaceData.stores.findIndex(s => s.storeName === store.storeName);
+            if (storeIndex !== -1 && this.findReplaceData.stores[storeIndex]) {
+                this.findReplaceData.stores[storeIndex].isApproved = checked;
+                // Update data service to preserve state when save as draft is called
+                this.dataService.updateData({ stores: this.findReplaceData.stores });
+            }
+        }
+    }
+    isStoreSelected(storeName) {
+        // Check both selectedStores set and isApproved property
+        const store = this.stores.find(s => s.storeName === storeName);
+        return this.selectedStores.has(storeName) || (store?.isApproved === true);
+    }
+    isAllSelected() {
+        // Only consider selectable stores (exclude no-match stores)
+        const selectableStores = this.filteredStores.filter(store => !this.hasNoMatch(store));
+        return selectableStores.length > 0 && selectableStores.every(store => store.isApproved === true);
+    }
+    onSearch() {
+        this.applyFilters();
+    }
+    applyFilters() {
+        let filtered = [...this.stores];
+        // Apply search filter
+        if (this.searchTerm.trim()) {
+            const term = this.searchTerm.toLowerCase();
+            filtered = filtered.filter(store => store.storeName.toLowerCase().includes(term));
+        }
+        // Apply status filter
+        if (this.selectedStatusFilters.size > 0) {
+            filtered = filtered.filter(store => {
+                if (!store.responseStatus) {
+                    return this.selectedStatusFilters.has('unknown');
+                }
+                return this.selectedStatusFilters.has(store.responseStatus);
+            });
+        }
+        this.filteredStores = filtered;
+        this.totalItems = this.filteredStores.length;
+        this.offset = 1; // Reset to first page when filters change
+    }
+    get paginatedStores() {
+        const startIndex = (this.offset - 1) * this.limit;
+        const endIndex = startIndex + this.limit;
+        return this.filteredStores.slice(startIndex, endIndex);
+    }
+    onDownload() {
+        if (!this.stores || this.stores.length === 0) {
+            console.warn('No stores to export');
+            return;
+        }
+        // Prepare data for Excel export
+        const exportData = this.stores.map(store => ({
+            'Store Name': store.storeName,
+            'Status': store.responseStatus === 'match' ? 'Match' :
+                store.responseStatus === 'no-match' ? 'No Match' :
+                    'Unknown'
+        }));
+        // Export to Excel
+        const fileName = `Stores_Export_${new Date().toISOString().split('T')[0]}`;
+        this.storeBuilderService.exportAsExcelFile(exportData, fileName);
+    }
+    onFilter() {
+        // Filter functionality is handled via dropdown in template
+    }
+    onStatusFilterChange(status, event) {
+        const isChecked = event.target.checked;
+        if (isChecked) {
+            this.selectedStatusFilters.add(status);
+        }
+        else {
+            this.selectedStatusFilters.delete(status);
+        }
+        this.applyFilters();
+    }
+    isStatusFilterSelected(status) {
+        return this.selectedStatusFilters.has(status);
+    }
+    clearFilters() {
+        this.selectedStatusFilters.clear();
+        this.searchTerm = '';
+        this.applyFilters();
+    }
+    hasActiveFilters() {
+        return this.selectedStatusFilters.size > 0 || this.searchTerm.trim().length > 0;
+    }
+    async onApproveAndComplete() {
+        try {
+            const modalRef = this.modalService.open(ApproveCompleteModalComponent, {
+                centered: true,
+                size: 'lg',
+                backdrop: 'static',
+                windowClass: 'approve-complete-modal'
+            });
+            // Pre-fill modal with existing schedule values if available
+            modalRef.componentInstance.initialSchedule = this.findReplaceData?.schedule || false;
+            modalRef.componentInstance.initialScheduleDate = this.findReplaceData?.scheduleDate || null;
+            const result = await modalRef.result;
+            if (result) {
+                // Handle the approve and complete action
+                console.log('Approve and complete with schedule:', result.schedule, 'scheduleDate:', result.scheduleDate);
+                // Get findReplaceId from findReplaceData
+                if (!this.findReplaceData?._id) {
+                    console.error('FindReplace ID is missing');
+                    return;
+                }
+                // Save stores, schedule, and scheduleDate using save as draft first
+                const draftData = {};
+                if (this.findReplaceData.stores && this.findReplaceData.stores.length > 0) {
+                    draftData.stores = this.findReplaceData.stores;
+                }
+                if (result.schedule !== undefined) {
+                    draftData.schedule = result.schedule;
+                }
+                if (result.scheduleDate !== undefined) {
+                    draftData.scheduleDate = result.scheduleDate;
+                }
+                // Wait for save as draft to complete before calling approveReplace
+                this.approveLoading = true;
+                try {
+                    // Save all the data using save as draft and wait for it to complete
+                    if (Object.keys(draftData).length > 0) {
+                        const saveResponse = await this.dataService.saveDraftAndWait(draftData).toPromise();
+                        if (saveResponse?.code !== 200) {
+                            console.error('Failed to save as draft:', saveResponse?.message || 'Unknown error');
+                            this.approveLoading = false;
+                            return;
+                        }
+                    }
+                    // Call the approveReplace API with only findReplaceId after save as draft completes
+                    const response = await this.storeBuilderService.approveReplace({
+                        findReplaceId: this.findReplaceData._id,
+                    }).toPromise();
+                    console.log('Approve replace response:', response);
+                    this.approveLoading = false;
+                    // Navigate to table page on successful response
+                    if (response?.code === 200) {
+                        this.router.navigate(['/manage/planogram/find-replace-table']);
+                    }
+                }
+                catch (error) {
+                    console.error('Error approving replace:', error);
+                    this.approveLoading = false;
+                    // TODO: Handle error (e.g., show error message)
+                }
+            }
+        }
+        catch (error) {
+            console.log('Modal dismissed');
+        }
+    }
+    hasNoMatch(store) {
+        return store.responseStatus === 'no-match';
+    }
+    isApproved() {
+        return this.findReplaceData?.status === 'approved';
+    }
+    previousNext(step) {
+        if (!this.selectedStore || this.filteredStores.length === 0)
+            return;
+        const curIdx = this.filteredStores.findIndex((store) => store.storeName === this.selectedStore?.storeName);
+        let newIdx;
+        if (step === 'previous') {
+            if (curIdx === 0)
+                return;
+            newIdx = curIdx - 1;
+        }
+        else {
+            if (curIdx === this.filteredStores.length - 1)
+                return;
+            newIdx = curIdx + 1;
+        }
+        // Update pagination if the new store is on a different page
+        const newPage = Math.floor(newIdx / this.limit) + 1;
+        if (newPage !== this.offset) {
+            this.offset = newPage;
+            // Scroll to top of store list when page changes
+            const listContainer = document.querySelector('.list-container');
+            if (listContainer) {
+                listContainer.scrollTop = 0;
+            }
+        }
+        this.onStoreSelect(this.filteredStores[newIdx]);
+    }
+    paginationSize() {
+        return this.limit;
+    }
+    onPageChange(page) {
+        this.offset = page;
+        // Scroll to top of store list when page changes
+        const listContainer = document.querySelector('.list-container');
+        if (listContainer) {
+            listContainer.scrollTop = 0;
+        }
+    }
+    onPageSizeChange(size) {
+        this.limit = size;
+        this.offset = 1; // Reset to first page when page size changes
+        // Scroll to top of store list when page size changes
+        const listContainer = document.querySelector('.list-container');
+        if (listContainer) {
+            listContainer.scrollTop = 0;
+        }
+    }
+    highlightFixture(canvas, group, blink = false) {
+        this.removeHighlight(canvas);
+        this.cancelHighlightBlink = false;
+        const center = group.getCenterPoint();
+        const realWidth = group.width * group.scaleX;
+        const realHeight = group.height * group.scaleY;
+        const rect = new fabric.Rect({
+            left: center.x,
+            top: center.y,
+            width: realWidth + 8,
+            height: realHeight + 8,
+            rx: 5,
+            ry: 5,
+            stroke: "#00aaff",
+            strokeWidth: 3,
+            fill: "transparent",
+            selectable: false,
+            evented: false,
+            originX: "center",
+            originY: "center",
+            angle: group.angle || 0,
+            opacity: blink ? 0 : 1,
+        });
+        rect.data = { type: "fixture-highlight" };
+        canvas.add(rect);
+        canvas.moveObjectTo(rect, canvas.getObjects().length - 1);
+        canvas.requestRenderAll();
+        this.activeHighlight = rect;
+        if (!blink)
+            return;
+        let cycles = 0;
+        const blinkOnce = () => {
+            if (this.cancelHighlightBlink) {
+                this.removeHighlight(canvas);
+                return;
+            }
+            rect.animate({ opacity: 1 }, {
+                duration: 200,
+                onChange: () => canvas.requestRenderAll(),
+                onComplete: () => {
+                    if (this.cancelHighlightBlink) {
+                        this.removeHighlight(canvas);
+                        return;
+                    }
+                    rect.animate({ opacity: 0 }, {
+                        duration: 200,
+                        onChange: () => canvas.requestRenderAll(),
+                        onComplete: () => {
+                            if (this.cancelHighlightBlink) {
+                                this.removeHighlight(canvas);
+                                return;
+                            }
+                            cycles++;
+                            if (cycles < 20) {
+                                blinkOnce();
+                            }
+                            else {
+                                if (!this.cancelHighlightBlink) {
+                                    rect.set({ opacity: 1 });
+                                    canvas.requestRenderAll();
+                                }
+                            }
+                        },
+                    });
+                },
+            });
+        };
+        blinkOnce();
+    }
+    removeHighlight(canvas) {
+        this.cancelHighlightBlink = true;
+        canvas.getObjects().forEach((obj) => {
+            if (obj.data?.type === "fixture-highlight") {
+                canvas.remove(obj);
+            }
+        });
+        this.activeHighlight = null;
+        canvas.requestRenderAll();
+    }
+    onFixtureClick(target) {
+        if (!target || !this.floorData)
+            return;
+        const fixtureId = target.fixtureId;
+        const fixtureType = target.fixtureType;
+        if (!fixtureId) {
+            console.warn('Fixture click: No fixtureId found on target', target);
+            return;
+        }
+        // Find the fixture data
+        let fixtureData = null;
+        if (fixtureType === "wall") {
+            const wallIndex = target.wallIndex;
+            if (this.floorData.layoutPolygon && wallIndex !== undefined && wallIndex !== null) {
+                // Find wall by elementNumber (wallIndex is the elementNumber)
+                const wall = this.floorData.layoutPolygon.find((w) => w.elementNumber === wallIndex);
+                if (wall && wall.fixtures) {
+                    fixtureData = wall.fixtures.find((f) => f._id === fixtureId);
+                }
+            }
+        }
+        else if (fixtureType === "floor") {
+            fixtureData = this.floorData.centerFixture?.find((f) => f._id === fixtureId);
+        }
+        if (!fixtureData) {
+            console.warn('Fixture click: Fixture data not found', {
+                fixtureId,
+                fixtureType,
+                wallIndex: target.wallIndex,
+                fixtureIndex: target.fixtureIndex,
+                floorData: this.floorData
+            });
+            return;
+        }
+        // Ensure vmConfig is always an array (even if empty) to avoid display issues
+        if (!Array.isArray(fixtureData.vmConfig)) {
+            fixtureData.vmConfig = [];
+        }
+        // Ensure shelfConfig is always an array (even if empty) to avoid display issues
+        if (!Array.isArray(fixtureData.shelfConfig)) {
+            fixtureData.shelfConfig = [];
+        }
+        // Create a deep clone to ensure change detection works
+        const clonedData = structuredClone(fixtureData);
+        // Ensure cloned data also has proper array structures
+        if (!Array.isArray(clonedData.vmConfig)) {
+            clonedData.vmConfig = [];
+        }
+        if (!Array.isArray(clonedData.shelfConfig)) {
+            clonedData.shelfConfig = [];
+        }
+        this.selectedFixture = {
+            fixtureId: fixtureId,
+            fixtureType: fixtureType,
+            wallIndex: target.wallIndex,
+            fixtureIndex: target.fixtureIndex,
+        };
+        // Check if this fixture has replaceResponseData (for before/after comparison)
+        const store = this.findReplaceData?.stores?.find((s) => s.storeName === this.selectedStore?.storeName);
+        // If this fixture matches the findResponseData and has replaceResponseData,
+        // restore the original fixture data for before/after comparison
+        if (store?.findResponseData === fixtureId && store?.replaceResponseData) {
+            // Restore originalFixtureData from the map (persists even when clicking other fixtures)
+            const storedOriginal = this.originalFixturesMap.get(fixtureId);
+            if (storedOriginal) {
+                this.originalFixtureData = structuredClone(storedOriginal);
+                // Ensure original data has proper array structures
+                if (!Array.isArray(this.originalFixtureData.vmConfig)) {
+                    this.originalFixtureData.vmConfig = [];
+                }
+                if (!Array.isArray(this.originalFixtureData.shelfConfig)) {
+                    this.originalFixtureData.shelfConfig = [];
+                }
+            }
+            else {
+                // If not in map (shouldn't happen if applyStoredResponseData ran), 
+                // use current fixture as fallback
+                this.originalFixtureData = structuredClone(clonedData);
+                if (!Array.isArray(this.originalFixtureData.vmConfig)) {
+                    this.originalFixtureData.vmConfig = [];
+                }
+                if (!Array.isArray(this.originalFixtureData.shelfConfig)) {
+                    this.originalFixtureData.shelfConfig = [];
+                }
+            }
+        }
+        else {
+            // No replace data for this fixture, clear original
+            this.originalFixtureData = null;
+        }
+        // Set selected fixture data (this is the "after" data with replaceResponseData applied)
+        // For fixtures with replaceResponseData, ensure all original properties are preserved
+        if (store?.findResponseData === fixtureId && store?.replaceResponseData) {
+            const storedOriginal = this.originalFixturesMap.get(fixtureId);
+            if (storedOriginal) {
+                // Merge: start with original to preserve all base properties, then apply updates
+                this.selectedFixtureData = {
+                    ...storedOriginal,
+                    ...clonedData,
+                    // Explicitly ensure arrays are correct
+                    vmConfig: Array.isArray(clonedData.vmConfig) ? clonedData.vmConfig : (storedOriginal.vmConfig || []),
+                    shelfConfig: Array.isArray(clonedData.shelfConfig) ? clonedData.shelfConfig : (storedOriginal.shelfConfig || [])
+                };
+            }
+            else {
+                this.selectedFixtureData = clonedData;
+            }
+        }
+        else {
+            this.selectedFixtureData = clonedData;
+        }
+        // Don't highlight on click - keep highlight fixed on the fixture with findResponseData
+        // The highlight is set when the planogram loads and should remain fixed
+        // Open offcanvas with before/after comparison
+        this.openFixtureOffcanvas();
+    }
+    openFixtureOffcanvas() {
+        // Use wider offcanvas when showing before/after comparison
+        const hasBeforeAfter = !!this.originalFixtureData;
+        const panelClass = hasBeforeAfter
+            ? 'fixture-before-after-offcanvas-wide'
+            : 'fixture-before-after-offcanvas';
+        const offcanvasRef = this.offcanvasService.open(FixtureBeforeAfterComponent, {
+            position: 'end',
+            panelClass: panelClass,
+            backdrop: true,
+            backdropClass: 'offcanvas-backdrop'
+        });
+        offcanvasRef.componentInstance.selectedFixtureData = this.selectedFixtureData;
+        offcanvasRef.componentInstance.originalFixtureData = this.originalFixtureData;
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        if (this.previewCanvas) {
+            this.previewCanvas.dispose();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ReviewReplaceComponent, deps: [{ token: i1.CollectionUpdateAiDataService }, { token: i2.StoreBuilderService }, { token: i0.ChangeDetectorRef }, { token: i3.GlobalStateService }, { token: i4.TitleCasePipe }, { token: i5.NgbOffcanvas }, { token: i5.NgbModal }, { token: i6.Router }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ReviewReplaceComponent, isStandalone: true, selector: "lib-review-replace", providers: [TitleCasePipe], viewQueries: [{ propertyName: "previewCanvasRef", first: true, predicate: ["previewCanvas"], descendants: true }, { propertyName: "previewCanvasContainerRef", first: true, predicate: ["previewCanvasContainer"], descendants: true }], ngImport: i0, template: "<div class=\"review-replace-container\">\r\n    <div class=\"row g-0 h-100\">\r\n        <!-- Left Sidebar: Store List -->\r\n        <div class=\"col-3 sidebar-container\">\r\n            <div class=\"sidebar-content\">\r\n                <!-- Header Section -->\r\n                <div class=\"header-section\">\r\n                    <div class=\"all-stores-box\">\r\n                        <p class=\"all-stores-text\">All stores</p>\r\n                    </div>\r\n                    <button class=\"download-btn\" (click)=\"onDownload()\" aria-label=\"Download\">\r\n                        <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path d=\"M17.5 12.5V13.5C17.5 14.9001 17.5 15.6002 17.2275 16.135C16.9878 16.6054 16.6054 16.9878 16.135 17.2275C15.6002 17.5 14.9001 17.5 13.5 17.5H6.5C5.09987 17.5 4.3998 17.5 3.86502 17.2275C3.39462 16.9878 3.01217 16.6054 2.77248 16.135C2.5 15.6002 2.5 14.9001 2.5 13.5V12.5M14.1667 8.33333L10 12.5M10 12.5L5.83333 8.33333M10 12.5V2.5\" stroke=\"#344054\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                        </svg>\r\n                    </button>\r\n                </div>\r\n\r\n                <!-- Select All Section -->\r\n                <div class=\"select-all-section\">\r\n                    <div class=\"form-check\">\r\n                        <input \r\n                            class=\"form-check-input\" \r\n                            type=\"checkbox\" \r\n                            id=\"selectAll\"\r\n                            [checked]=\"isAllSelected()\"\r\n                            (change)=\"onSelectAll($any($event.target).checked)\">\r\n                        <label class=\"form-check-label select-all-label\" for=\"selectAll\">\r\n                            Select all ({{ filteredStores.length }})\r\n                        </label>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Search and Filter Section -->\r\n                <div class=\"search-filter-section\">\r\n                    <div class=\"search-input-wrapper\">\r\n                        <svg class=\"search-icon\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path d=\"M17.5 17.5L13.875 13.875M15.8333 9.16667C15.8333 12.8486 12.8486 15.8333 9.16667 15.8333C5.48477 15.8333 2.5 12.8486 2.5 9.16667C2.5 5.48477 5.48477 2.5 9.16667 2.5C12.8486 2.5 15.8333 5.48477 15.8333 9.16667Z\" stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                        </svg>\r\n                        <input \r\n                            type=\"text\" \r\n                            class=\"search-input\" \r\n                            placeholder=\"Search\"\r\n                            [(ngModel)]=\"searchTerm\"\r\n                            (input)=\"onSearch()\">\r\n                    </div>\r\n                    <div class=\"dropdown\" ngbDropdown>\r\n                        <button \r\n                            class=\"filter-btn\" \r\n                            [class.active]=\"hasActiveFilters()\"\r\n                            id=\"filterDropdown\" \r\n                            ngbDropdownToggle\r\n                            aria-label=\"Filter\">\r\n                            <svg width=\"19\" height=\"17\" viewBox=\"0 0 19 17\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                                <path d=\"M17.5026 0.835938H0.835938L7.5026 8.71927V14.1693L10.8359 15.8359V8.71927L17.5026 0.835938Z\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                            </svg>\r\n                            <span *ngIf=\"hasActiveFilters()\" class=\"filter-badge\">{{ selectedStatusFilters.size }}</span>\r\n                        </button>\r\n                        <div class=\"dropdown-menu filter-dropdown\" ngbDropdownMenu aria-labelledby=\"filterDropdown\">\r\n                            <div class=\"filter-dropdown-header\">\r\n                                <h6 class=\"filter-title\">Filter by Status</h6>\r\n                                <button \r\n                                    *ngIf=\"hasActiveFilters()\" \r\n                                    class=\"clear-filters-btn\" \r\n                                    (click)=\"clearFilters()\">\r\n                                    Clear\r\n                                </button>\r\n                            </div>\r\n                            <div class=\"filter-dropdown-body\">\r\n                                <div \r\n                                    *ngFor=\"let option of statusOptions\" \r\n                                    class=\"filter-option\">\r\n                                    <input \r\n                                        class=\"form-check-input\" \r\n                                        type=\"checkbox\" \r\n                                        [id]=\"'statusFilter' + option.value\"\r\n                                        [checked]=\"isStatusFilterSelected(option.value)\"\r\n                                        (change)=\"onStatusFilterChange(option.value, $event)\">\r\n                                    <label \r\n                                        [for]=\"'statusFilter' + option.value\" \r\n                                        class=\"filter-option-label\">\r\n                                        {{ option.label }}\r\n                                    </label>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Store List Container (Scrollable) -->\r\n                <div class=\"list-container\">\r\n                    <!-- Store List -->\r\n                    <div class=\"store-list\">\r\n                        <div \r\n                            *ngFor=\"let store of paginatedStores; let i = index\" \r\n                            class=\"store-item\"\r\n                            [class.selected]=\"selectedStore?.storeName === store.storeName\"\r\n                            (click)=\"onStoreSelect(store)\">\r\n                            <div class=\"store-item-content\" [class.disabled-content]=\"hasNoMatch(store)\">\r\n                                <input \r\n                                    class=\"form-check-input\" \r\n                                    type=\"checkbox\" \r\n                                    [id]=\"'store' + i\"\r\n                                    [checked]=\"store.isApproved === true\"\r\n                                    [disabled]=\"hasNoMatch(store)\"\r\n                                    (click)=\"$event.stopPropagation()\"\r\n                                    (change)=\"onStoreCheckboxChange(store, $any($event.target).checked)\">\r\n                                <label \r\n                                    class=\"store-item-text\" \r\n                                    [for]=\"'store' + i\"\r\n                                    [class.disabled]=\"hasNoMatch(store)\"\r\n                                    (click)=\"hasNoMatch(store) && $event.stopPropagation()\">\r\n                                    {{ store.storeName }}\r\n                                </label>\r\n                            </div>\r\n                            <span *ngIf=\"hasNoMatch(store)\" class=\"badge-error\">Didn't match</span>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n\r\n        <!-- Right Side: Canvas Area -->\r\n        <div class=\"col-9 canvas-area-container\">\r\n            <div class=\"canvas-wrapper\">\r\n                <!-- Header Section with Store Slider and Approve Button -->\r\n                <div class=\"canvas-header\" *ngIf=\"selectedStore && !canvasLoading\">\r\n                    <!-- Store Slider Navigation -->\r\n                    <div class=\"store-slider\">\r\n                    <div (click)=\"previousNext('previous')\" class=\"arrow\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"23\" height=\"24\" viewBox=\"0 0 23 24\" fill=\"none\">\r\n                            <path\r\n                                d=\"M14.3942 6.33329L8.72756 12L14.3942 17.6666\"\r\n                                stroke=\"#344054\"\r\n                                stroke-width=\"1.88889\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    <div\r\n                        class=\"storename\"\r\n                        [routerLink]=\"['/manage/stores/plano']\"\r\n                        [queryParams]=\"{ storeId: selectedStore.storeId }\"\r\n                    >\r\n                        <span class=\"txt me-3\">{{ selectedStore.storeName }} - Plano</span>\r\n                        <svg\r\n                            style=\"cursor: pointer\"\r\n                            xmlns=\"http://www.w3.org/2000/svg\"\r\n                            width=\"24\"\r\n                            height=\"24\"\r\n                            viewBox=\"0 0 24 24\"\r\n                            fill=\"none\"\r\n                        >\r\n                            <path\r\n                                d=\"M17.6261 12.9688V18.7819C17.6261 19.2958 17.422 19.7886 17.0586 20.152C16.6952 20.5154 16.2023 20.7195 15.6884 20.7195H5.03119C4.51728 20.7195 4.02443 20.5154 3.66104 20.152C3.29765 19.7886 3.09351 19.2958 3.09351 18.7819V8.1246C3.09351 7.6107 3.29765 7.11784 3.66104 6.75445C4.02443 6.39107 4.51728 6.18692 5.03119 6.18692H10.8442M14.7196 3.2804H20.5326M20.5326 3.2804V9.09344M20.5326 3.2804L9.87539 13.9376\"\r\n                                stroke=\"#008EDF\"\r\n                                stroke-width=\"1.93768\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    <div (click)=\"previousNext('next')\" class=\"arrow\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"23\" height=\"24\" viewBox=\"0 0 23 24\" fill=\"none\">\r\n                            <path\r\n                                d=\"M8.6059 17.6667L14.2726 12L8.6059 6.33337\"\r\n                                stroke=\"#344054\"\r\n                                stroke-width=\"1.88889\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    </div>\r\n                    <!-- Approve And Complete Button -->\r\n                    <button class=\"approve-complete-btn\" (click)=\"onApproveAndComplete()\" [disabled]=\"approveLoading || isApproved()\">\r\n                        {{ approveLoading ? 'Processing...' : (isApproved() ? 'Approved' : 'Approve & Complete') }}\r\n                    </button>\r\n                </div>\r\n\r\n                <!-- Canvas Container -->\r\n                <div class=\"canvas-container\" #previewCanvasContainer *ngIf=\"selectedStore\">\r\n                    <!-- Loading State - Centered on Canvas -->\r\n                    <div class=\"canvas-loading\" *ngIf=\"canvasLoading\">\r\n                        <div class=\"spinner-border text-primary\" role=\"status\">\r\n                            <span class=\"visually-hidden\">Loading...</span>\r\n                        </div>\r\n                    </div>\r\n                    <canvas #previewCanvas></canvas>\r\n                </div>\r\n\r\n                <!-- Empty State -->\r\n                <div class=\"empty-state\" *ngIf=\"!selectedStore\">\r\n                    <p>Select a store to view its planogram</p>\r\n                </div>\r\n            </div>\r\n\r\n            <!-- Pagination -->\r\n            <lib-pagination\r\n                *ngIf=\"filteredStores.length > 0\"\r\n                [itemsPerPage]=\"limit\"\r\n                [currentPage]=\"offset\"\r\n                [totalItems]=\"totalItems\"\r\n                [paginationSizes]=\"paginationSizes\"\r\n                [pageSize]=\"paginationSize()\"\r\n                (pageChange)=\"onPageChange($event)\"\r\n                (pageSizeChange)=\"onPageSizeChange($event)\">\r\n            </lib-pagination>\r\n        </div>\r\n    </div>\r\n</div>\r\n", styles: [".review-replace-container{height:calc(100vh - 200px);display:flex;flex-direction:column;background-color:#fff;font-family:Inter,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,sans-serif}.review-replace-container .row{height:100%;margin:0}.sidebar-container{border-right:1px solid #d0d5dd;height:100%;overflow:hidden;display:flex;flex-direction:column;background:#fff}.sidebar-content{display:flex;flex-direction:column;height:100%;padding:16px}.header-section{display:flex;gap:8px;align-items:flex-start;margin-bottom:8px}.all-stores-box{flex:1;background:#fff;border-radius:6px;padding:8px 16px}.all-stores-text{font-weight:600;font-size:16px;line-height:24px;color:#344054;margin:0}.download-btn{background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:12px;cursor:pointer;box-shadow:0 1px 2px #1018280d;transition:all .2s;display:flex;align-items:center;justify-content:center}.download-btn:hover{background:#f9fafb}.select-all-section{background:#fff;border-radius:6px;border-bottom:1px solid #eaecf0;padding:8px 16px;margin-bottom:12px;flex-shrink:0}.select-all-label{font-size:16px;line-height:24px;color:#344054;margin-left:12px;cursor:pointer;margin-bottom:0}.search-filter-section{display:flex;gap:12px;margin-bottom:16px;flex-shrink:0}.search-input-wrapper{flex:1;position:relative}.search-input{width:100%;background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:10px 14px 10px 42px;font-size:16px;line-height:24px;color:#344054;box-shadow:0 1px 2px #1018280d}.search-input::placeholder{color:#667085}.search-input:focus{outline:none;border-color:#00a3ff}.search-icon{position:absolute;left:14px;top:50%;transform:translateY(-50%);width:20px;height:20px;pointer-events:none}.dropdown{position:relative}.filter-btn{background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:12px;cursor:pointer;box-shadow:0 1px 2px #1018280d;transition:all .2s;display:flex;align-items:center;justify-content:center;position:relative}.filter-btn:hover{background:#f9fafb}.filter-btn.active{border-color:#00a3ff;background:#eaf8ff}.filter-badge{position:absolute;top:-4px;right:-4px;background:#00a3ff;color:#fff;border-radius:10px;min-width:18px;height:18px;display:flex;align-items:center;justify-content:center;font-size:11px;font-weight:600;padding:0 4px}.filter-dropdown{min-width:220px;padding:0;border-radius:8px;box-shadow:0 4px 6px -2px #10182808,0 12px 16px -4px #10182814;border:1px solid #d0d5dd;margin-top:8px}.filter-dropdown-header{display:flex;justify-content:space-between;align-items:center;padding:12px 16px;border-bottom:1px solid #eaecf0}.filter-title{font-size:14px;font-weight:600;color:#1d2939;margin:0}.clear-filters-btn{background:none;border:none;color:#00a3ff;font-size:14px;font-weight:500;cursor:pointer;padding:0;transition:color .2s}.clear-filters-btn:hover{color:#0090e6;text-decoration:underline}.filter-dropdown-body{padding:8px}.filter-option{display:flex;align-items:center;gap:12px;padding:8px 12px;border-radius:6px;cursor:pointer;transition:background-color .2s}.filter-option:hover{background-color:#f9fafb}.filter-option-label{font-size:14px;font-weight:400;color:#344054;cursor:pointer;margin:0;flex:1}.list-container{flex:1;overflow-y:auto;overflow-x:hidden;min-height:0;padding-bottom:45px}.store-list{display:flex;flex-direction:column;gap:16px}.store-item{background:#fff;border-radius:6px;padding:8px 12px;display:flex;align-items:center;justify-content:space-between;min-height:42px;cursor:pointer;transition:all .2s}.store-item:hover{background:#f9fafb}.store-item.selected{background:#eaf8ff}.store-item-content{display:flex;align-items:center;gap:12px;min-width:120px;flex:1}.store-item-content.disabled-content{opacity:.6}.store-item-text{font-size:16px;line-height:24px;color:#1d2939;margin:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;cursor:pointer}.store-item-text.disabled{color:#98a2b3;cursor:not-allowed;pointer-events:none}.store-item.selected .store-item-text{color:#009bf3}.badge-error{background:#fef3f2;color:#b42318;font-size:12px;line-height:18px;font-weight:500;padding:2px 8px;border-radius:16px;white-space:nowrap}.form-check-input{width:16px;height:16px;border:1px solid #d0d5dd;border-radius:4px;cursor:pointer;margin-top:0;flex-shrink:0}.form-check-input:checked{background-color:#00a3ff;border-color:#00a3ff}.form-check-input:focus{box-shadow:0 0 0 .2rem #00a3ff40}.canvas-area-container{height:100%;display:flex;flex-direction:column;background:#f9fafb;overflow:hidden}.canvas-wrapper{display:flex;flex-direction:column;overflow:hidden;flex:1;min-height:0}.canvas-header{display:flex;align-items:center;justify-content:space-between;padding:16px;background:#fff;gap:16px}.store-slider{display:flex;align-items:center;justify-content:center;flex:1}.store-slider .arrow{border-radius:17px;background:var(--Gray-100, #F2F4F7);width:34px;height:34px;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:background-color .2s}.store-slider .arrow:hover{background:#e5e7eb}.store-slider .storename{display:flex;align-items:center;margin-right:60px;margin-left:60px;cursor:pointer}.store-slider .storename .txt{color:#008edf;font-size:16px;font-weight:500;cursor:pointer}.approve-complete-btn{background:#00a3ff;color:#fff;border:none;border-radius:8px;padding:10px 20px;font-size:16px;font-weight:500;line-height:24px;cursor:pointer;box-shadow:0 1px 2px #1018280d;transition:all .2s;white-space:nowrap;flex-shrink:0}.approve-complete-btn:hover{background:#0090e6;box-shadow:0 2px 4px #1018281a}.approve-complete-btn:active{background:#007acc}.canvas-container{position:relative;flex:1;background:#f9fafb;overflow:hidden;min-height:0;padding:0;height:100%}.canvas-container canvas{background:#fff;width:100%!important;height:100%!important;display:block}.canvas-loading{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);z-index:10}.empty-state{display:flex;align-items:center;justify-content:center;height:100%;color:#667085;font-size:16px}lib-pagination{flex-shrink:0;background:#f9fafb}::ng-deep .fixture-before-after-offcanvas{width:500px!important;max-width:90vw}::ng-deep .fixture-before-after-offcanvas-wide{width:1000px!important;max-width:90vw}::ng-deep .offcanvas-backdrop{background-color:#00000080}::ng-deep .approve-complete-modal .modal-dialog{max-width:650px}::ng-deep .approve-complete-modal .modal-content{border:none;border-radius:12px;box-shadow:0 20px 24px -4px #10182814,0 8px 8px -4px #10182808;padding:0}::ng-deep .approve-complete-modal .modal-header{border-bottom:none;padding:24px 16px 0}::ng-deep .approve-complete-modal .modal-body{padding:0 16px}::ng-deep .approve-complete-modal .modal-footer{border-top:none;padding:0 16px 24px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i7.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: i7.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i7.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: RouterModule }, { kind: "directive", type: i6.RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "ngmodule", type: CommonSharedModule }, { kind: "component", type: i8.PaginationComponent, selector: "lib-pagination", inputs: ["collection", "itemsPerPage", "currentPage", "totalItems", "directionLinks", "pageSize", "paginationSizes"], outputs: ["pageChange", "pageSizeChange"] }, { kind: "ngmodule", type: NgbDropdownModule }, { kind: "directive", type: i5.NgbDropdown, selector: "[ngbDropdown]", inputs: ["autoClose", "dropdownClass", "open", "placement", "popperOptions", "container", "display"], outputs: ["openChange"], exportAs: ["ngbDropdown"] }, { kind: "directive", type: i5.NgbDropdownToggle, selector: "[ngbDropdownToggle]" }, { kind: "directive", type: i5.NgbDropdownMenu, selector: "[ngbDropdownMenu]" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ReviewReplaceComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-review-replace', standalone: true, imports: [CommonModule, FormsModule, RouterModule, CommonSharedModule, NgbDropdownModule], providers: [TitleCasePipe], template: "<div class=\"review-replace-container\">\r\n    <div class=\"row g-0 h-100\">\r\n        <!-- Left Sidebar: Store List -->\r\n        <div class=\"col-3 sidebar-container\">\r\n            <div class=\"sidebar-content\">\r\n                <!-- Header Section -->\r\n                <div class=\"header-section\">\r\n                    <div class=\"all-stores-box\">\r\n                        <p class=\"all-stores-text\">All stores</p>\r\n                    </div>\r\n                    <button class=\"download-btn\" (click)=\"onDownload()\" aria-label=\"Download\">\r\n                        <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path d=\"M17.5 12.5V13.5C17.5 14.9001 17.5 15.6002 17.2275 16.135C16.9878 16.6054 16.6054 16.9878 16.135 17.2275C15.6002 17.5 14.9001 17.5 13.5 17.5H6.5C5.09987 17.5 4.3998 17.5 3.86502 17.2275C3.39462 16.9878 3.01217 16.6054 2.77248 16.135C2.5 15.6002 2.5 14.9001 2.5 13.5V12.5M14.1667 8.33333L10 12.5M10 12.5L5.83333 8.33333M10 12.5V2.5\" stroke=\"#344054\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                        </svg>\r\n                    </button>\r\n                </div>\r\n\r\n                <!-- Select All Section -->\r\n                <div class=\"select-all-section\">\r\n                    <div class=\"form-check\">\r\n                        <input \r\n                            class=\"form-check-input\" \r\n                            type=\"checkbox\" \r\n                            id=\"selectAll\"\r\n                            [checked]=\"isAllSelected()\"\r\n                            (change)=\"onSelectAll($any($event.target).checked)\">\r\n                        <label class=\"form-check-label select-all-label\" for=\"selectAll\">\r\n                            Select all ({{ filteredStores.length }})\r\n                        </label>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Search and Filter Section -->\r\n                <div class=\"search-filter-section\">\r\n                    <div class=\"search-input-wrapper\">\r\n                        <svg class=\"search-icon\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path d=\"M17.5 17.5L13.875 13.875M15.8333 9.16667C15.8333 12.8486 12.8486 15.8333 9.16667 15.8333C5.48477 15.8333 2.5 12.8486 2.5 9.16667C2.5 5.48477 5.48477 2.5 9.16667 2.5C12.8486 2.5 15.8333 5.48477 15.8333 9.16667Z\" stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                        </svg>\r\n                        <input \r\n                            type=\"text\" \r\n                            class=\"search-input\" \r\n                            placeholder=\"Search\"\r\n                            [(ngModel)]=\"searchTerm\"\r\n                            (input)=\"onSearch()\">\r\n                    </div>\r\n                    <div class=\"dropdown\" ngbDropdown>\r\n                        <button \r\n                            class=\"filter-btn\" \r\n                            [class.active]=\"hasActiveFilters()\"\r\n                            id=\"filterDropdown\" \r\n                            ngbDropdownToggle\r\n                            aria-label=\"Filter\">\r\n                            <svg width=\"19\" height=\"17\" viewBox=\"0 0 19 17\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                                <path d=\"M17.5026 0.835938H0.835938L7.5026 8.71927V14.1693L10.8359 15.8359V8.71927L17.5026 0.835938Z\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                            </svg>\r\n                            <span *ngIf=\"hasActiveFilters()\" class=\"filter-badge\">{{ selectedStatusFilters.size }}</span>\r\n                        </button>\r\n                        <div class=\"dropdown-menu filter-dropdown\" ngbDropdownMenu aria-labelledby=\"filterDropdown\">\r\n                            <div class=\"filter-dropdown-header\">\r\n                                <h6 class=\"filter-title\">Filter by Status</h6>\r\n                                <button \r\n                                    *ngIf=\"hasActiveFilters()\" \r\n                                    class=\"clear-filters-btn\" \r\n                                    (click)=\"clearFilters()\">\r\n                                    Clear\r\n                                </button>\r\n                            </div>\r\n                            <div class=\"filter-dropdown-body\">\r\n                                <div \r\n                                    *ngFor=\"let option of statusOptions\" \r\n                                    class=\"filter-option\">\r\n                                    <input \r\n                                        class=\"form-check-input\" \r\n                                        type=\"checkbox\" \r\n                                        [id]=\"'statusFilter' + option.value\"\r\n                                        [checked]=\"isStatusFilterSelected(option.value)\"\r\n                                        (change)=\"onStatusFilterChange(option.value, $event)\">\r\n                                    <label \r\n                                        [for]=\"'statusFilter' + option.value\" \r\n                                        class=\"filter-option-label\">\r\n                                        {{ option.label }}\r\n                                    </label>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Store List Container (Scrollable) -->\r\n                <div class=\"list-container\">\r\n                    <!-- Store List -->\r\n                    <div class=\"store-list\">\r\n                        <div \r\n                            *ngFor=\"let store of paginatedStores; let i = index\" \r\n                            class=\"store-item\"\r\n                            [class.selected]=\"selectedStore?.storeName === store.storeName\"\r\n                            (click)=\"onStoreSelect(store)\">\r\n                            <div class=\"store-item-content\" [class.disabled-content]=\"hasNoMatch(store)\">\r\n                                <input \r\n                                    class=\"form-check-input\" \r\n                                    type=\"checkbox\" \r\n                                    [id]=\"'store' + i\"\r\n                                    [checked]=\"store.isApproved === true\"\r\n                                    [disabled]=\"hasNoMatch(store)\"\r\n                                    (click)=\"$event.stopPropagation()\"\r\n                                    (change)=\"onStoreCheckboxChange(store, $any($event.target).checked)\">\r\n                                <label \r\n                                    class=\"store-item-text\" \r\n                                    [for]=\"'store' + i\"\r\n                                    [class.disabled]=\"hasNoMatch(store)\"\r\n                                    (click)=\"hasNoMatch(store) && $event.stopPropagation()\">\r\n                                    {{ store.storeName }}\r\n                                </label>\r\n                            </div>\r\n                            <span *ngIf=\"hasNoMatch(store)\" class=\"badge-error\">Didn't match</span>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n\r\n        <!-- Right Side: Canvas Area -->\r\n        <div class=\"col-9 canvas-area-container\">\r\n            <div class=\"canvas-wrapper\">\r\n                <!-- Header Section with Store Slider and Approve Button -->\r\n                <div class=\"canvas-header\" *ngIf=\"selectedStore && !canvasLoading\">\r\n                    <!-- Store Slider Navigation -->\r\n                    <div class=\"store-slider\">\r\n                    <div (click)=\"previousNext('previous')\" class=\"arrow\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"23\" height=\"24\" viewBox=\"0 0 23 24\" fill=\"none\">\r\n                            <path\r\n                                d=\"M14.3942 6.33329L8.72756 12L14.3942 17.6666\"\r\n                                stroke=\"#344054\"\r\n                                stroke-width=\"1.88889\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    <div\r\n                        class=\"storename\"\r\n                        [routerLink]=\"['/manage/stores/plano']\"\r\n                        [queryParams]=\"{ storeId: selectedStore.storeId }\"\r\n                    >\r\n                        <span class=\"txt me-3\">{{ selectedStore.storeName }} - Plano</span>\r\n                        <svg\r\n                            style=\"cursor: pointer\"\r\n                            xmlns=\"http://www.w3.org/2000/svg\"\r\n                            width=\"24\"\r\n                            height=\"24\"\r\n                            viewBox=\"0 0 24 24\"\r\n                            fill=\"none\"\r\n                        >\r\n                            <path\r\n                                d=\"M17.6261 12.9688V18.7819C17.6261 19.2958 17.422 19.7886 17.0586 20.152C16.6952 20.5154 16.2023 20.7195 15.6884 20.7195H5.03119C4.51728 20.7195 4.02443 20.5154 3.66104 20.152C3.29765 19.7886 3.09351 19.2958 3.09351 18.7819V8.1246C3.09351 7.6107 3.29765 7.11784 3.66104 6.75445C4.02443 6.39107 4.51728 6.18692 5.03119 6.18692H10.8442M14.7196 3.2804H20.5326M20.5326 3.2804V9.09344M20.5326 3.2804L9.87539 13.9376\"\r\n                                stroke=\"#008EDF\"\r\n                                stroke-width=\"1.93768\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    <div (click)=\"previousNext('next')\" class=\"arrow\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"23\" height=\"24\" viewBox=\"0 0 23 24\" fill=\"none\">\r\n                            <path\r\n                                d=\"M8.6059 17.6667L14.2726 12L8.6059 6.33337\"\r\n                                stroke=\"#344054\"\r\n                                stroke-width=\"1.88889\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    </div>\r\n                    <!-- Approve And Complete Button -->\r\n                    <button class=\"approve-complete-btn\" (click)=\"onApproveAndComplete()\" [disabled]=\"approveLoading || isApproved()\">\r\n                        {{ approveLoading ? 'Processing...' : (isApproved() ? 'Approved' : 'Approve & Complete') }}\r\n                    </button>\r\n                </div>\r\n\r\n                <!-- Canvas Container -->\r\n                <div class=\"canvas-container\" #previewCanvasContainer *ngIf=\"selectedStore\">\r\n                    <!-- Loading State - Centered on Canvas -->\r\n                    <div class=\"canvas-loading\" *ngIf=\"canvasLoading\">\r\n                        <div class=\"spinner-border text-primary\" role=\"status\">\r\n                            <span class=\"visually-hidden\">Loading...</span>\r\n                        </div>\r\n                    </div>\r\n                    <canvas #previewCanvas></canvas>\r\n                </div>\r\n\r\n                <!-- Empty State -->\r\n                <div class=\"empty-state\" *ngIf=\"!selectedStore\">\r\n                    <p>Select a store to view its planogram</p>\r\n                </div>\r\n            </div>\r\n\r\n            <!-- Pagination -->\r\n            <lib-pagination\r\n                *ngIf=\"filteredStores.length > 0\"\r\n                [itemsPerPage]=\"limit\"\r\n                [currentPage]=\"offset\"\r\n                [totalItems]=\"totalItems\"\r\n                [paginationSizes]=\"paginationSizes\"\r\n                [pageSize]=\"paginationSize()\"\r\n                (pageChange)=\"onPageChange($event)\"\r\n                (pageSizeChange)=\"onPageSizeChange($event)\">\r\n            </lib-pagination>\r\n        </div>\r\n    </div>\r\n</div>\r\n", styles: [".review-replace-container{height:calc(100vh - 200px);display:flex;flex-direction:column;background-color:#fff;font-family:Inter,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,sans-serif}.review-replace-container .row{height:100%;margin:0}.sidebar-container{border-right:1px solid #d0d5dd;height:100%;overflow:hidden;display:flex;flex-direction:column;background:#fff}.sidebar-content{display:flex;flex-direction:column;height:100%;padding:16px}.header-section{display:flex;gap:8px;align-items:flex-start;margin-bottom:8px}.all-stores-box{flex:1;background:#fff;border-radius:6px;padding:8px 16px}.all-stores-text{font-weight:600;font-size:16px;line-height:24px;color:#344054;margin:0}.download-btn{background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:12px;cursor:pointer;box-shadow:0 1px 2px #1018280d;transition:all .2s;display:flex;align-items:center;justify-content:center}.download-btn:hover{background:#f9fafb}.select-all-section{background:#fff;border-radius:6px;border-bottom:1px solid #eaecf0;padding:8px 16px;margin-bottom:12px;flex-shrink:0}.select-all-label{font-size:16px;line-height:24px;color:#344054;margin-left:12px;cursor:pointer;margin-bottom:0}.search-filter-section{display:flex;gap:12px;margin-bottom:16px;flex-shrink:0}.search-input-wrapper{flex:1;position:relative}.search-input{width:100%;background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:10px 14px 10px 42px;font-size:16px;line-height:24px;color:#344054;box-shadow:0 1px 2px #1018280d}.search-input::placeholder{color:#667085}.search-input:focus{outline:none;border-color:#00a3ff}.search-icon{position:absolute;left:14px;top:50%;transform:translateY(-50%);width:20px;height:20px;pointer-events:none}.dropdown{position:relative}.filter-btn{background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:12px;cursor:pointer;box-shadow:0 1px 2px #1018280d;transition:all .2s;display:flex;align-items:center;justify-content:center;position:relative}.filter-btn:hover{background:#f9fafb}.filter-btn.active{border-color:#00a3ff;background:#eaf8ff}.filter-badge{position:absolute;top:-4px;right:-4px;background:#00a3ff;color:#fff;border-radius:10px;min-width:18px;height:18px;display:flex;align-items:center;justify-content:center;font-size:11px;font-weight:600;padding:0 4px}.filter-dropdown{min-width:220px;padding:0;border-radius:8px;box-shadow:0 4px 6px -2px #10182808,0 12px 16px -4px #10182814;border:1px solid #d0d5dd;margin-top:8px}.filter-dropdown-header{display:flex;justify-content:space-between;align-items:center;padding:12px 16px;border-bottom:1px solid #eaecf0}.filter-title{font-size:14px;font-weight:600;color:#1d2939;margin:0}.clear-filters-btn{background:none;border:none;color:#00a3ff;font-size:14px;font-weight:500;cursor:pointer;padding:0;transition:color .2s}.clear-filters-btn:hover{color:#0090e6;text-decoration:underline}.filter-dropdown-body{padding:8px}.filter-option{display:flex;align-items:center;gap:12px;padding:8px 12px;border-radius:6px;cursor:pointer;transition:background-color .2s}.filter-option:hover{background-color:#f9fafb}.filter-option-label{font-size:14px;font-weight:400;color:#344054;cursor:pointer;margin:0;flex:1}.list-container{flex:1;overflow-y:auto;overflow-x:hidden;min-height:0;padding-bottom:45px}.store-list{display:flex;flex-direction:column;gap:16px}.store-item{background:#fff;border-radius:6px;padding:8px 12px;display:flex;align-items:center;justify-content:space-between;min-height:42px;cursor:pointer;transition:all .2s}.store-item:hover{background:#f9fafb}.store-item.selected{background:#eaf8ff}.store-item-content{display:flex;align-items:center;gap:12px;min-width:120px;flex:1}.store-item-content.disabled-content{opacity:.6}.store-item-text{font-size:16px;line-height:24px;color:#1d2939;margin:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;cursor:pointer}.store-item-text.disabled{color:#98a2b3;cursor:not-allowed;pointer-events:none}.store-item.selected .store-item-text{color:#009bf3}.badge-error{background:#fef3f2;color:#b42318;font-size:12px;line-height:18px;font-weight:500;padding:2px 8px;border-radius:16px;white-space:nowrap}.form-check-input{width:16px;height:16px;border:1px solid #d0d5dd;border-radius:4px;cursor:pointer;margin-top:0;flex-shrink:0}.form-check-input:checked{background-color:#00a3ff;border-color:#00a3ff}.form-check-input:focus{box-shadow:0 0 0 .2rem #00a3ff40}.canvas-area-container{height:100%;display:flex;flex-direction:column;background:#f9fafb;overflow:hidden}.canvas-wrapper{display:flex;flex-direction:column;overflow:hidden;flex:1;min-height:0}.canvas-header{display:flex;align-items:center;justify-content:space-between;padding:16px;background:#fff;gap:16px}.store-slider{display:flex;align-items:center;justify-content:center;flex:1}.store-slider .arrow{border-radius:17px;background:var(--Gray-100, #F2F4F7);width:34px;height:34px;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:background-color .2s}.store-slider .arrow:hover{background:#e5e7eb}.store-slider .storename{display:flex;align-items:center;margin-right:60px;margin-left:60px;cursor:pointer}.store-slider .storename .txt{color:#008edf;font-size:16px;font-weight:500;cursor:pointer}.approve-complete-btn{background:#00a3ff;color:#fff;border:none;border-radius:8px;padding:10px 20px;font-size:16px;font-weight:500;line-height:24px;cursor:pointer;box-shadow:0 1px 2px #1018280d;transition:all .2s;white-space:nowrap;flex-shrink:0}.approve-complete-btn:hover{background:#0090e6;box-shadow:0 2px 4px #1018281a}.approve-complete-btn:active{background:#007acc}.canvas-container{position:relative;flex:1;background:#f9fafb;overflow:hidden;min-height:0;padding:0;height:100%}.canvas-container canvas{background:#fff;width:100%!important;height:100%!important;display:block}.canvas-loading{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);z-index:10}.empty-state{display:flex;align-items:center;justify-content:center;height:100%;color:#667085;font-size:16px}lib-pagination{flex-shrink:0;background:#f9fafb}::ng-deep .fixture-before-after-offcanvas{width:500px!important;max-width:90vw}::ng-deep .fixture-before-after-offcanvas-wide{width:1000px!important;max-width:90vw}::ng-deep .offcanvas-backdrop{background-color:#00000080}::ng-deep .approve-complete-modal .modal-dialog{max-width:650px}::ng-deep .approve-complete-modal .modal-content{border:none;border-radius:12px;box-shadow:0 20px 24px -4px #10182814,0 8px 8px -4px #10182808;padding:0}::ng-deep .approve-complete-modal .modal-header{border-bottom:none;padding:24px 16px 0}::ng-deep .approve-complete-modal .modal-body{padding:0 16px}::ng-deep .approve-complete-modal .modal-footer{border-top:none;padding:0 16px 24px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.CollectionUpdateAiDataService }, { type: i2.StoreBuilderService }, { type: i0.ChangeDetectorRef }, { type: i3.GlobalStateService }, { type: i4.TitleCasePipe }, { type: i5.NgbOffcanvas }, { type: i5.NgbModal }, { type: i6.Router }], propDecorators: { previewCanvasRef: [{
+                type: ViewChild,
+                args: ['previewCanvas']
+            }], previewCanvasContainerRef: [{
+                type: ViewChild,
+                args: ['previewCanvasContainer']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"review-replace.component.js","sourceRoot":"","sources":["../../../../../../../../projects/tango-store-builder/src/lib/components/collection-update-ai/find-replace-layout/review-replace/review-replace.component.ts","../../../../../../../../projects/tango-store-builder/src/lib/components/collection-update-ai/find-replace-layout/review-replace/review-replace.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnDestroy, AfterViewInit, ViewChild, ElementRef, ChangeDetectorRef } from '@angular/core';\r\nimport { CommonModule, TitleCasePipe } from '@angular/common';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { RouterModule, Router } from '@angular/router';\r\nimport { CollectionUpdateAiDataService } from '../../services/data.service';\r\nimport { Store, FindReplace } from '../../models/find-replace.model';\r\nimport { StoreBuilderService } from '../../../../services/store-builder.service';\r\nimport { Subject, takeUntil } from 'rxjs';\r\nimport * as fabric from \"fabric\";\r\nimport { GlobalStateService } from 'tango-app-ui-global';\r\nimport { CommonSharedModule } from 'tango-app-ui-shared';\r\nimport { NgbOffcanvas, NgbModal, NgbDropdownModule } from '@ng-bootstrap/ng-bootstrap';\r\nimport { FixtureBeforeAfterComponent } from './fixture-before-after/fixture-before-after.component';\r\nimport { ApproveCompleteModalComponent } from './approve-complete-modal/approve-complete-modal.component';\r\n\r\n@Component({\r\n  selector: 'lib-review-replace',\r\n  standalone: true,\r\n  imports: [CommonModule, FormsModule, RouterModule, CommonSharedModule, NgbDropdownModule],\r\n  templateUrl: './review-replace.component.html',\r\n  styleUrl: './review-replace.component.scss',\r\n  providers: [TitleCasePipe]\r\n})\r\nexport class ReviewReplaceComponent implements OnInit, OnDestroy, AfterViewInit {\r\n  findReplaceData: FindReplace | null = null;\r\n  stores: Store[] = [];\r\n  filteredStores: Store[] = [];\r\n  selectedStores: Set<string> = new Set();\r\n  searchTerm: string = '';\r\n  selectedStore: Store | null = null;\r\n\r\n  // Filter properties\r\n  selectedStatusFilters: Set<string> = new Set();\r\n  statusOptions = [\r\n    { value: 'match', label: 'Match' },\r\n    { value: 'no-match', label: 'No Match' }\r\n  ];\r\n\r\n  // Canvas properties\r\n  @ViewChild('previewCanvas') previewCanvasRef!: ElementRef<HTMLCanvasElement>;\r\n  @ViewChild('previewCanvasContainer') previewCanvasContainerRef!: ElementRef<HTMLDivElement>;\r\n  previewCanvas!: fabric.Canvas;\r\n  planoData: any;\r\n  floorData: any;\r\n  canvasLoading = false;\r\n  approveLoading = false;\r\n  cdnUrl: string = '';\r\n  wallThickness = 30;\r\n  verticalMargin = (1.25 / 100) * this.toPixels(1524, \"mm\");\r\n  allFixtureInstances: any[] = [];\r\n\r\n  // Fixture selection and highlighting\r\n  selectedFixture: any = null;\r\n  selectedFixtureData: any = null;\r\n  originalFixtureData: any = null; // Original fixture before replace (for before/after comparison)\r\n  private originalFixturesMap: Map<string, any> = new Map(); // Store original fixtures by fixtureId\r\n  private activeHighlight: fabric.Rect | null = null;\r\n  private cancelHighlightBlink = false;\r\n\r\n  private destroy$ = new Subject<void>();\r\n\r\n  // Pagination properties\r\n  limit: number = 10;\r\n  offset: number = 1;\r\n  totalItems: number = 0;\r\n  paginationSizes = [10, 20, 30];\r\n\r\n  constructor(\r\n    private dataService: CollectionUpdateAiDataService,\r\n    private storeBuilderService: StoreBuilderService,\r\n    private cdr: ChangeDetectorRef,\r\n    private gs: GlobalStateService,\r\n    private titleCase: TitleCasePipe,\r\n    private offcanvasService: NgbOffcanvas,\r\n    private modalService: NgbModal,\r\n    private router: Router\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    // Get CDN URL\r\n    this.gs.environment\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((env) => {\r\n        this.cdnUrl = env.planogramCDN || '';\r\n      });\r\n\r\n    // Subscribe to data service\r\n    this.dataService.getFindReplaceData()\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((data) => {\r\n        this.findReplaceData = data;\r\n        if (data?.stores) {\r\n          this.stores = data.stores;\r\n\r\n          // Restore checkbox state from isApproved property\r\n          this.selectedStores.clear();\r\n          this.stores.forEach(store => {\r\n            if (store.isApproved && !this.hasNoMatch(store)) {\r\n              this.selectedStores.add(store.storeName);\r\n            }\r\n          });\r\n\r\n          this.applyFilters();\r\n\r\n          // Select first store by default if none selected\r\n          if (!this.selectedStore && this.filteredStores.length > 0) {\r\n            this.onStoreSelect(this.filteredStores[0]);\r\n          }\r\n        }\r\n      });\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    // Canvas will be initialized when store is selected\r\n  }\r\n\r\n  initializeCanvas(): boolean {\r\n    if (this.previewCanvas) {\r\n      return true;\r\n    }\r\n\r\n    if (this.previewCanvasRef?.nativeElement && this.previewCanvasContainerRef?.nativeElement) {\r\n      try {\r\n        const containerEl = this.previewCanvasContainerRef.nativeElement;\r\n        this.previewCanvas = new fabric.Canvas(this.previewCanvasRef.nativeElement, {\r\n          selectionFullyContained: true,\r\n          perPixelTargetFind: true,\r\n          targetFindTolerance: 5,\r\n          width: containerEl.clientWidth,\r\n          height: containerEl.clientHeight,\r\n        });\r\n        this.setupZoomHandlers(this.previewCanvas);\r\n        return true;\r\n      } catch (error) {\r\n        console.error('Error initializing canvas:', error);\r\n        return false;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  setupZoomHandlers(canvas: fabric.Canvas): void {\r\n    canvas.selection = false;\r\n\r\n    canvas.on(\"mouse:wheel\", (opt: fabric.TEvent<WheelEvent>) => {\r\n      const e = opt.e;\r\n      if (e.ctrlKey || e.metaKey) {\r\n        const delta = e.deltaY;\r\n        let zoom = canvas.getZoom();\r\n        zoom *= 0.995 ** delta;\r\n        zoom = Math.max(0.2, Math.min(zoom, 3));\r\n        canvas.zoomToPoint({ x: e.offsetX, y: e.offsetY } as fabric.Point, zoom);\r\n        e.preventDefault();\r\n        e.stopPropagation();\r\n      }\r\n    });\r\n\r\n    let isDragging = false;\r\n    let lastPosX = 0;\r\n    let lastPosY = 0;\r\n\r\n    canvas.on(\"mouse:down\", (opt: any) => {\r\n      // Handle fixture clicks - use findTarget to get the actual group\r\n      if (opt.target) {\r\n        const obj = opt.target as any;\r\n        // Check if it's a fixture group or nested within one\r\n        let fixtureGroup = obj;\r\n\r\n        // Traverse up to find the fixture group\r\n        let attempts = 0;\r\n        while (fixtureGroup && !(fixtureGroup as any).fixtureId && !(fixtureGroup as any).objType && attempts < 10) {\r\n          if ((fixtureGroup as any).parent) {\r\n            fixtureGroup = (fixtureGroup as any).parent;\r\n          } else if ((fixtureGroup as any).group) {\r\n            fixtureGroup = (fixtureGroup as any).group;\r\n          } else {\r\n            break;\r\n          }\r\n          attempts++;\r\n        }\r\n\r\n        // Check if we found a fixture group\r\n        if ((fixtureGroup as any).objType === \"fixture\" || (fixtureGroup as any).fixtureId) {\r\n          this.onFixtureClick(fixtureGroup);\r\n          canvas.setActiveObject(fixtureGroup);\r\n          canvas.requestRenderAll();\r\n          return;\r\n        }\r\n      }\r\n\r\n      // For non-fixture clicks, enable dragging\r\n      if (!opt.target) {\r\n        isDragging = true;\r\n        canvas.selection = false;\r\n        const e = opt.e;\r\n        lastPosX = e.clientX;\r\n        lastPosY = e.clientY;\r\n      }\r\n    });\r\n\r\n    canvas.on(\"mouse:move\", (opt: any) => {\r\n      if (isDragging && canvas.viewportTransform && !opt.target) {\r\n        const e = opt.e;\r\n        const vpt = canvas.viewportTransform;\r\n        vpt[4] += e.clientX - lastPosX;\r\n        vpt[5] += e.clientY - lastPosY;\r\n        canvas.requestRenderAll();\r\n        lastPosX = e.clientX;\r\n        lastPosY = e.clientY;\r\n      }\r\n    });\r\n\r\n    canvas.on(\"mouse:up\", () => {\r\n      isDragging = false;\r\n      canvas.selection = false;\r\n    });\r\n  }\r\n\r\n  onStoreSelect(store: Store): void {\r\n    // Allow viewing planogram even for stores with no-match status\r\n    this.selectedStore = store;\r\n    this.cdr.detectChanges();\r\n\r\n    setTimeout(() => {\r\n      if (this.initializeCanvas()) {\r\n        // Resize canvas to container size\r\n        if (this.previewCanvasContainerRef?.nativeElement) {\r\n          this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);\r\n        }\r\n        this.loadPlanogramForStore(store.storeName);\r\n      }\r\n    }, 100);\r\n  }\r\n\r\n  async loadPlanogramForStore(storeName: string): Promise<void> {\r\n    if (!storeName || !this.previewCanvas) {\r\n      return;\r\n    }\r\n\r\n    this.canvasLoading = true;\r\n    try {\r\n      const response: any = await this.storeBuilderService.getPlanoId({ stores: [storeName.toUpperCase()] }).toPromise();\r\n\r\n      if (response?.code === 200 && response?.data?.length > 0) {\r\n        const planoId = response.data[0]._id;\r\n        await this.getStoreFixtures(planoId);\r\n      } else {\r\n        this.canvasLoading = false;\r\n        this.cdr.detectChanges();\r\n      }\r\n    } catch (error) {\r\n      console.error('Error loading planogram:', error);\r\n      this.canvasLoading = false;\r\n      this.cdr.detectChanges();\r\n    }\r\n  }\r\n\r\n  async getStoreFixtures(storeId: string): Promise<void> {\r\n    if (!this.previewCanvas) {\r\n      this.canvasLoading = false;\r\n      this.cdr.detectChanges();\r\n      return;\r\n    }\r\n\r\n    this.storeBuilderService.getStoreFixtures({ id: [storeId] })\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: async (res: any) => {\r\n          if (!res?.data?.[0]?.floors?.length) {\r\n            this.canvasLoading = false;\r\n            this.cdr.detectChanges();\r\n            return;\r\n          }\r\n\r\n          this.planoData = structuredClone(res.data[0]);\r\n          this.floorData = structuredClone(res.data[0].floors[0]);\r\n\r\n          // Apply stored response data if available\r\n          this.applyStoredResponseData();\r\n\r\n          // Collect all fixtures\r\n          this.collectAllFixtures();\r\n\r\n          if (this.previewCanvas) {\r\n            // Render the planogram first\r\n            await this.renderFloor(this.previewCanvas);\r\n            this.canvasLoading = false;\r\n            this.cdr.detectChanges();\r\n\r\n            // Wait for all objects to be rendered, then resize and recenter\r\n            setTimeout(() => {\r\n              if (this.previewCanvasContainerRef?.nativeElement && this.previewCanvas) {\r\n                // Resize canvas to container dimensions\r\n                this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);\r\n\r\n                // Wait a bit more for canvas to update, then recenter\r\n                setTimeout(() => {\r\n                  if (this.previewCanvas) {\r\n                    this.fitCanvasToLayoutAnimated(this.previewCanvas);\r\n\r\n                    // Highlight fixture if it has replaceResponseData\r\n                    const store = this.findReplaceData?.stores?.find(\r\n                      (s: Store) => s.storeName === this.selectedStore?.storeName\r\n                    );\r\n                    if (store?.findResponseData && store?.replaceResponseData) {\r\n                      const fixtureGroup = this.previewCanvas.getObjects().find(\r\n                        (obj: any) => obj.objType === \"fixture\" && obj.fixtureId === store.findResponseData\r\n                      ) as fabric.Group | undefined;\r\n                      if (fixtureGroup) {\r\n                        this.highlightFixture(this.previewCanvas, fixtureGroup, false);\r\n                      }\r\n                    }\r\n                  }\r\n                }, 100);\r\n              }\r\n            }, 300);\r\n          } else {\r\n            this.canvasLoading = false;\r\n            this.cdr.detectChanges();\r\n          }\r\n        },\r\n        error: (err: any) => {\r\n          this.canvasLoading = false;\r\n          this.cdr.detectChanges();\r\n          console.error('Error fetching plano:', err);\r\n        },\r\n      });\r\n  }\r\n\r\n  private applyStoredResponseData(): void {\r\n    if (!this.findReplaceData?.stores || !this.selectedStore || !this.floorData) {\r\n      return;\r\n    }\r\n\r\n    const store = this.findReplaceData.stores.find(\r\n      (s: Store) => s.storeName === this.selectedStore?.storeName\r\n    );\r\n\r\n    if (!store?.replaceResponseData) {\r\n      return;\r\n    }\r\n\r\n    const fixtureId = store.findResponseData;\r\n    if (!fixtureId) return;\r\n\r\n    const fixture = this.getFixtureByIdFromFloor(fixtureId);\r\n    if (!fixture) return;\r\n\r\n    // Store the original fixture (before replace) for before/after comparison\r\n    const originalFixture = structuredClone(fixture);\r\n    this.originalFixturesMap.set(fixtureId, originalFixture);\r\n\r\n    // Create a deep copy of the fixture to preserve all original properties\r\n    const updatedFixture = structuredClone(fixture);\r\n\r\n    // Merge replaceResponseData properties while preserving all other fixture properties\r\n    if (store.replaceResponseData.vmConfig) {\r\n      updatedFixture.vmConfig = Array.isArray(store.replaceResponseData.vmConfig)\r\n        ? store.replaceResponseData.vmConfig\r\n        : [];\r\n    }\r\n\r\n    // Merge shelfConfig intelligently - preserve original shelf structure and only update provided properties\r\n    if (store.replaceResponseData.shelfConfig && Array.isArray(store.replaceResponseData.shelfConfig)) {\r\n      const originalShelfConfig = Array.isArray(fixture.shelfConfig) ? fixture.shelfConfig : [];\r\n\r\n      // Create a map of original shelves by shelf identifier (shelfType + shelfNumber)\r\n      const originalShelvesMap = new Map();\r\n      originalShelfConfig.forEach((shelf: any) => {\r\n        const key = `${shelf.shelfType || ''}_${shelf.shelfNumber || ''}`;\r\n        originalShelvesMap.set(key, shelf);\r\n      });\r\n\r\n      // Merge: for each shelf in replaceResponseData, find the original and merge\r\n      updatedFixture.shelfConfig = store.replaceResponseData.shelfConfig.map((newShelf: any) => {\r\n        const key = `${newShelf.shelfType || ''}_${newShelf.shelfNumber || ''}`;\r\n        const originalShelf = originalShelvesMap.get(key);\r\n\r\n        if (originalShelf) {\r\n          // Merge: preserve all original properties, update with new ones\r\n          return {\r\n            ...originalShelf,\r\n            ...newShelf,\r\n            // Ensure critical numeric properties are preserved\r\n            productPerShelf: newShelf.productPerShelf !== undefined ? newShelf.productPerShelf : originalShelf.productPerShelf,\r\n            trayRows: newShelf.trayRows !== undefined ? newShelf.trayRows : originalShelf.trayRows,\r\n            shelfType: newShelf.shelfType || originalShelf.shelfType,\r\n            shelfNumber: newShelf.shelfNumber !== undefined ? newShelf.shelfNumber : originalShelf.shelfNumber,\r\n          };\r\n        } else {\r\n          // New shelf not in original - use as is but ensure required properties\r\n          return {\r\n            ...newShelf,\r\n            productPerShelf: newShelf.productPerShelf || 0,\r\n            trayRows: newShelf.trayRows || 1,\r\n          };\r\n        }\r\n      });\r\n    } else if (!Array.isArray(updatedFixture.shelfConfig)) {\r\n      updatedFixture.shelfConfig = [];\r\n    }\r\n\r\n    // Ensure arrays are always arrays\r\n    if (!Array.isArray(updatedFixture.vmConfig)) {\r\n      updatedFixture.vmConfig = [];\r\n    }\r\n    if (!Array.isArray(updatedFixture.shelfConfig)) {\r\n      updatedFixture.shelfConfig = [];\r\n    }\r\n\r\n    this.updateAiResponseFixture(updatedFixture);\r\n  }\r\n\r\n  private getFixtureByIdFromFloor(fixtureId: string): any | null {\r\n    if (!fixtureId || !this.floorData) return null;\r\n\r\n    for (const element of this.floorData.layoutPolygon || []) {\r\n      if (element?.elementType === \"wall\" && Array.isArray(element.fixtures)) {\r\n        const hit = element.fixtures.find((fx: any) => fx?._id === fixtureId);\r\n        if (hit) return hit;\r\n      }\r\n    }\r\n\r\n    for (const fx of this.floorData.centerFixture || []) {\r\n      if (fx?._id === fixtureId) return fx;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private updateAiResponseFixture(updatedFixture: any): void {\r\n    if (!this.floorData) return;\r\n\r\n    for (const element of this.floorData.layoutPolygon || []) {\r\n      if (element?.elementType === \"wall\" && Array.isArray(element.fixtures)) {\r\n        const index = element.fixtures.findIndex((fx: any) => fx?._id === updatedFixture._id);\r\n        if (index !== -1) {\r\n          element.fixtures[index] = updatedFixture;\r\n          return;\r\n        }\r\n      }\r\n    }\r\n\r\n    for (let i = 0; i < (this.floorData.centerFixture || []).length; i++) {\r\n      if (this.floorData.centerFixture[i]?._id === updatedFixture._id) {\r\n        this.floorData.centerFixture[i] = updatedFixture;\r\n        return;\r\n      }\r\n    }\r\n  }\r\n\r\n  collectAllFixtures(): void {\r\n    this.allFixtureInstances = [];\r\n\r\n    // Collect wall fixtures\r\n    if (this.floorData?.layoutPolygon) {\r\n      for (const element of this.floorData.layoutPolygon) {\r\n        if (element.fixtures && Array.isArray(element.fixtures)) {\r\n          this.allFixtureInstances.push(...element.fixtures);\r\n        }\r\n      }\r\n    }\r\n\r\n    // Collect floor fixtures\r\n    if (this.floorData?.centerFixture && Array.isArray(this.floorData.centerFixture)) {\r\n      this.allFixtureInstances.push(...this.floorData.centerFixture);\r\n    }\r\n  }\r\n\r\n  async renderFloor(canvas: fabric.Canvas): Promise<void> {\r\n    await this.drawInitialContent(canvas);\r\n  }\r\n\r\n  async drawInitialContent(canvas: fabric.Canvas): Promise<void> {\r\n    // Clear canvas and reset viewport\r\n    canvas.clear();\r\n    canvas.setViewportTransform([1, 0, 0, 1, 0, 0]);\r\n    await this.drawLayoutElements(canvas);\r\n    // Force render after drawing\r\n    canvas.requestRenderAll();\r\n  }\r\n\r\n  async drawLayoutElements(canvas: fabric.Canvas) {\r\n    if (!this.floorData) return;\r\n\r\n    for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {\r\n      const element = this.floorData.layoutPolygon[index];\r\n      let wall;\r\n\r\n      element.relativePosition ??= { x: 0, y: 0, unit: \"ft\" };\r\n      const x = this.toPixels(element.relativePosition.x, element.unit);\r\n      const y = this.toPixels(element.relativePosition.y, element.unit);\r\n\r\n      if (element.elementType === \"wall\") {\r\n        const height = this.wallThickness;\r\n        const width = this.toPixels(element.distance, element.unit);\r\n        wall = await this.drawWall(canvas, x, y, height, width, element);\r\n      } else if (element.elementType === \"entrance\") {\r\n        this.drawEntrance(canvas, x, y, 80, 75, 40, element);\r\n      }\r\n\r\n      if (element.elementType === \"wall\") {\r\n        const fixtureGroups: fabric.Group[] = [];\r\n        for (let j = 0; j < element?.fixtures?.length; j++) {\r\n          const fixture = element.fixtures[j];\r\n          const fx = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);\r\n          const fy = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);\r\n          const fh = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);\r\n          const fw = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);\r\n          const fixtureObj = await this.drawFixture(canvas, fx, fy, fh, fw, fixture);\r\n          fixtureGroups.push(fixtureObj as fabric.Group);\r\n        }\r\n\r\n        if (element.isLocked && wall) {\r\n          canvas.remove(wall);\r\n          fixtureGroups.forEach((f) => canvas.remove(f));\r\n          const combinedGroup = new fabric.Group([wall, ...fixtureGroups], {\r\n            hasControls: false,\r\n            selectable: false,\r\n            lockMovementX: true,\r\n            lockMovementY: true,\r\n            lockRotation: true,\r\n            lockScalingX: true,\r\n            lockScalingY: true,\r\n            subTargetCheck: true,\r\n          });\r\n          combinedGroup.set({ isLocked: true });\r\n          canvas.add(combinedGroup);\r\n        }\r\n\r\n        for (let j = 0; j < element?.otherElements?.length; j++) {\r\n          const otherElement = element.otherElements[j];\r\n          const ox = this.toPixels(otherElement.relativePosition.x, \"ft\");\r\n          const oy = this.toPixels(otherElement.relativePosition.y, \"ft\");\r\n          const oa = otherElement.relativePosition.angle;\r\n          const oh = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);\r\n          const ow = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);\r\n          this.drawOtherElementsWithLabel(canvas, ox, oy, oa, ow, oh, otherElement);\r\n        }\r\n      }\r\n    }\r\n\r\n    for (let i = 0; i < this.floorData?.centerFixture?.length; i++) {\r\n      const fixture = this.floorData.centerFixture[i];\r\n      const x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);\r\n      const y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);\r\n      const h = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);\r\n      const w = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);\r\n      await this.drawFixture(canvas, x, y, h, w, fixture);\r\n    }\r\n\r\n    for (let j = 0; j < this.floorData?.otherElements?.length; j++) {\r\n      const otherElement = this.floorData.otherElements[j];\r\n      const x = this.toPixels(otherElement.relativePosition.x, \"ft\");\r\n      const y = this.toPixels(otherElement.relativePosition.y, \"ft\");\r\n      const a = otherElement.relativePosition.angle;\r\n      const h = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);\r\n      const w = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);\r\n      this.drawOtherElementsWithLabel(canvas, x, y, a, w, h, otherElement);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  async drawWall(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    height: number,\r\n    width: number,\r\n    elementData: any\r\n  ) {\r\n    const radius = 5;\r\n    const fillColor = \"#F6FCFF\";\r\n    const strokeColor = \"#D0D5DD\";\r\n    const labelColor = \"#009BF3\";\r\n    let text = `${this.titleCase.transform(elementData.elementType)} ${elementData.elementNumber\r\n      }`;\r\n\r\n    const wall = new fabric.Rect({\r\n      left: 0,\r\n      top: 0,\r\n      width,\r\n      height,\r\n      rx: radius,\r\n      ry: radius,\r\n      fill: fillColor,\r\n      stroke: strokeColor,\r\n      strokeWidth: 0.27,\r\n      selectable: false,\r\n      strokeUniform: true,\r\n    });\r\n\r\n    const centerX = width / 2;\r\n    const centerY = height / 2;\r\n    const isVertical = height > width;\r\n\r\n    const label = new fabric.FabricText(text, {\r\n      left: centerX,\r\n      top: centerY,\r\n      fontSize: 10,\r\n      fontFamily: \"Inter\",\r\n      fontWeight: \"500\",\r\n      fill: labelColor,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      angle: isVertical ? -90 : 0,\r\n      selectable: false,\r\n    });\r\n\r\n    const arrowHead = 5;\r\n    const elements: fabric.Object[] = [wall, label];\r\n\r\n    if (isVertical) {\r\n      const textWidth = label.width || 0;\r\n      const topArrowY = 5;\r\n      const topArrowEndY = centerY - textWidth / 2 - 5;\r\n\r\n      if (topArrowEndY > topArrowY + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line([centerX, topArrowY, centerX, topArrowEndY], {\r\n            stroke: labelColor,\r\n            strokeWidth: 1,\r\n            selectable: false,\r\n          }),\r\n          new fabric.Triangle({\r\n            left: centerX,\r\n            top: topArrowY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: 0,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"bottom\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n\r\n      const bottomArrowStartY = centerY + textWidth / 2 + 5;\r\n      const bottomArrowEndY = height - 5;\r\n\r\n      if (bottomArrowEndY > bottomArrowStartY + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line(\r\n            [centerX, bottomArrowStartY, centerX, bottomArrowEndY],\r\n            {\r\n              stroke: labelColor,\r\n              strokeWidth: 1,\r\n              selectable: false,\r\n            }\r\n          ),\r\n          new fabric.Triangle({\r\n            left: centerX,\r\n            top: bottomArrowEndY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: 180,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"top\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n    } else {\r\n      const textWidth = label.width || 0;\r\n      const leftArrowStartX = 5;\r\n      const leftArrowEndX = centerX - textWidth / 2 - 5;\r\n\r\n      if (leftArrowEndX > leftArrowStartX + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line([leftArrowStartX, centerY, leftArrowEndX, centerY], {\r\n            stroke: labelColor,\r\n            strokeWidth: 1,\r\n            selectable: false,\r\n          }),\r\n          new fabric.Triangle({\r\n            left: leftArrowStartX,\r\n            top: centerY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: -90,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"center\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n\r\n      const rightArrowStartX = centerX + textWidth / 2 + 5;\r\n      const rightArrowEndX = width - 5;\r\n\r\n      if (rightArrowEndX > rightArrowStartX + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line(\r\n            [rightArrowStartX, centerY, rightArrowEndX, centerY],\r\n            {\r\n              stroke: labelColor,\r\n              strokeWidth: 1,\r\n              selectable: false,\r\n            }\r\n          ),\r\n          new fabric.Triangle({\r\n            left: rightArrowEndX,\r\n            top: centerY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: 90,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"center\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n    }\r\n\r\n\r\n    const group = new fabric.Group(elements, {\r\n      left: x,\r\n      top: y,\r\n      hasControls: false,\r\n      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockRotation: true,\r\n      lockMovementX: true,\r\n      lockMovementY: true,\r\n      evented: true,\r\n      hoverCursor: \"default\",\r\n      angle: elementData.angle,\r\n      subTargetCheck: true,\r\n    }) as fabric.Group & {\r\n      objType: string;\r\n      data: any;\r\n    };\r\n\r\n    group.objType = elementData.elementType;\r\n    group.data = elementData;\r\n\r\n\r\n    canvas.add(group);\r\n\r\n    // If newly added, focus it once\r\n    if ((elementData as any)?.newAdded) {\r\n      try {\r\n        canvas.setActiveObject(group);\r\n        canvas.requestRenderAll();\r\n      } catch { }\r\n      delete (elementData as any).newAdded;\r\n    }\r\n\r\n    return group;\r\n  }\r\n\r\n  drawEntrance(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    width: number,\r\n    height: number,\r\n    arrowWidth: number,\r\n    elementData: any\r\n  ) {\r\n    const bodyWidth = width - arrowWidth;\r\n\r\n    const pathData = [\r\n      `M 0 0`,\r\n      `L ${bodyWidth} 0`,\r\n      `L ${bodyWidth} ${-height / 2}`,\r\n      `L ${width} ${height / 2}`,\r\n      `L ${bodyWidth} ${height + height / 2}`,\r\n      `L ${bodyWidth} ${height}`,\r\n      `L 0 ${height}`,\r\n      `Z`,\r\n    ].join(\" \");\r\n\r\n    const arrow = new fabric.Path(pathData, {\r\n      fill: \"#03A9F4\",\r\n      selectable: false,\r\n      evented: false,\r\n    });\r\n\r\n    const maxTextHeight = height - 6;\r\n    const text = new fabric.Text(\"Entrance\", {\r\n      fontFamily: \"Arial\",\r\n      fontWeight: \"bold\",\r\n      fill: \"white\",\r\n      angle: -90,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      left: 15,\r\n      top: height / 2,\r\n      fontSize: 20,\r\n      selectable: false,\r\n      evented: false,\r\n    });\r\n\r\n    const textBounds = text.getBoundingRect();\r\n    if (textBounds.height > maxTextHeight) {\r\n      const scale = maxTextHeight / textBounds.height;\r\n      text.set(\"fontSize\", text.fontSize! * scale);\r\n    }\r\n\r\n    const group = new fabric.Group([arrow, text], {\r\n      left: x,\r\n      top: y,\r\n      hasControls: false,\r\n      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockScalingFlip: true,\r\n      lockRotation: true,\r\n      lockMovementX: true,\r\n      lockMovementY: true,\r\n      evented: true,\r\n      hoverCursor: \"default\",\r\n      angle: elementData.angle,\r\n    }) as fabric.Group & {\r\n      objType: string;\r\n      data: any;\r\n    };\r\n\r\n    group.objType = elementData.elementType;\r\n    group.data = elementData;\r\n\r\n    canvas.add(group);\r\n  }\r\n\r\n  async drawFixture(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    height: number,\r\n    width: number,\r\n    fixtureData: any\r\n  ) {\r\n    let fixtureColor: any;\r\n    // if ([\"fixture\", \"fixture-redo\"].includes(this.publishingState)) {\r\n    //   fixtureColor = {\r\n    //     primary:\r\n    //       fixtureData.status == \"\" && fixtureData.taskStatus == \"submit\"\r\n    //         ? \"#a5a6a8\"\r\n    //         : fixtureData.status == \"agree\"\r\n    //         ? \"#6CE9A6\"\r\n    //         : \"#51C1FF\",\r\n    //     fill:\r\n    //       fixtureData.status == \"\" && fixtureData.taskStatus == \"submit\"\r\n    //         ? \"#f3f4f8\"\r\n    //         : fixtureData.status == \"agree\"\r\n    //         ? \"#6CE9A6\"\r\n    //         : \"#EAF8FF\",\r\n    //     vmFill:\r\n    //       fixtureData.status == \"\" && fixtureData.taskStatus == \"submit\"\r\n    //         ? \"#a5a6a8\"\r\n    //         : \"#6938EF\",\r\n    //   };\r\n    // }\r\n    if (fixtureData.fixtureName === \"space\") return;\r\n    const radius = 5;\r\n    const mainContainer = new fabric.Rect({\r\n      left: x,\r\n      top: y,\r\n      width: width,\r\n      height: height,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n      strokeWidth: 0.27,\r\n      fill: \"white\",\r\n    });\r\n\r\n    const topWidth = width / 1.05;\r\n    const topHeight = (15 / 100) * height;\r\n    const topX = x + (width - topWidth) / 2;\r\n    const topY = y + this.verticalMargin;\r\n\r\n    const topContainer = new fabric.Rect({\r\n      left: topX,\r\n      top: topY,\r\n      width: topWidth,\r\n      height: topHeight,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n      strokeWidth: 0.27,\r\n      fill: \"white\",\r\n    });\r\n\r\n    const innerBoxHeight = topHeight / 2;\r\n    const innerTopBox = new fabric.Path(\r\n      `M ${topX + radius} ${topY} \r\n              L ${topX + topWidth - radius} ${topY} \r\n              Q ${topX + topWidth} ${topY} ${topX + topWidth} ${topY + radius} \r\n              L ${topX + topWidth} ${topY + innerBoxHeight} \r\n              L ${topX} ${topY + innerBoxHeight} \r\n              L ${topX} ${topY + radius} \r\n              Q ${topX} ${topY} ${topX + radius} ${topY} Z`,\r\n      {\r\n        stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n        strokeWidth: 0.27,\r\n        fill: \"transparent\",\r\n      }\r\n    );\r\n\r\n    const topText = new fabric.Textbox(\r\n      `Fixture ${fixtureData.associatedElementFixtureNumber\r\n        ? fixtureData.associatedElementFixtureNumber +\r\n        (fixtureData?.fixtureNumber\r\n          ? \" - FX-\" + fixtureData.fixtureNumber\r\n          : \"\")\r\n        : \"new\"\r\n      }`,\r\n      {\r\n        left: topX + topWidth / 2,\r\n        top: topY + innerBoxHeight / 2,\r\n        fontSize: 5,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"500\",\r\n        fill: \"#101828\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        width: topWidth,\r\n        height: innerBoxHeight,\r\n        textAlign: \"center\",\r\n      }\r\n    );\r\n\r\n    const secondBoxY = topY + innerBoxHeight;\r\n\r\n    const innerBottomBox = new fabric.Path(\r\n      `M ${topX} ${secondBoxY} \r\n          L ${topX + topWidth} ${secondBoxY} \r\n          L ${topX + topWidth} ${secondBoxY + innerBoxHeight - radius} \r\n          Q ${topX + topWidth} ${secondBoxY + innerBoxHeight} ${topX + topWidth - radius\r\n      } ${secondBoxY + innerBoxHeight} \r\n          L ${topX + radius} ${secondBoxY + innerBoxHeight} \r\n          Q ${topX} ${secondBoxY + innerBoxHeight} ${topX} ${secondBoxY + innerBoxHeight - radius\r\n      } \r\n          L ${topX} ${secondBoxY} Z`,\r\n      {\r\n        fill: \"#344054\",\r\n        stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n        strokeWidth: 0.27,\r\n      }\r\n    );\r\n\r\n    let fontSize = 5;\r\n    let bottomText;\r\n\r\n    const textContent = `${fixtureData?.fixtureName} - ${fixtureData?.fixtureWidth.value} ${fixtureData?.fixtureWidth.unit}`;\r\n\r\n    const createBottomText = (fs: any) =>\r\n      new fabric.Textbox(textContent, {\r\n        left: topX + topWidth / 2,\r\n        top: secondBoxY + innerBoxHeight / 2,\r\n        fontSize: fs,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"500\",\r\n        fill: \"#FFFFFF\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        textAlign: \"center\",\r\n        width: topWidth,\r\n      });\r\n\r\n    do {\r\n      bottomText = createBottomText(fontSize);\r\n      fontSize -= 0.5;\r\n    } while (bottomText.height > innerBoxHeight && fontSize > 2);\r\n\r\n    const midWidth = width / 1.05;\r\n    const midHeight = (77 / 100) * height;\r\n    const midX = x + (width - midWidth) / 2;\r\n    const midY = topY + topHeight + this.verticalMargin;\r\n\r\n    const midContainer = new fabric.Rect({\r\n      left: midX,\r\n      top: midY,\r\n      width: midWidth,\r\n      height: midHeight,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n      strokeWidth: 0.27,\r\n      fill: \"white\",\r\n    });\r\n\r\n    const shelfCount = fixtureData.shelfConfig?.length;\r\n    const boxHeight = midHeight / (shelfCount + 2);\r\n    const firstBoxY = midY;\r\n\r\n    const firstBox = new fabric.Path(\r\n      `M ${midX + radius} ${firstBoxY} \r\n              L ${midX + midWidth - radius} ${firstBoxY} \r\n              Q ${midX + midWidth} ${firstBoxY} ${midX + midWidth} ${firstBoxY + radius\r\n      } \r\n              L ${midX + midWidth} ${firstBoxY + boxHeight} \r\n              L ${midX} ${firstBoxY + boxHeight} \r\n              L ${midX} ${firstBoxY + radius} \r\n              Q ${midX} ${firstBoxY} ${midX + radius} ${firstBoxY} Z`,\r\n      {\r\n        fill: fixtureColor?.fill\r\n          ? fixtureColor?.fill\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#EAF8FF\",\r\n        stroke: fixtureColor?.primary\r\n          ? fixtureColor?.primary\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#6BCAFF\",\r\n        strokeWidth: 0.27,\r\n      }\r\n    );\r\n\r\n    const firstBoxText = new fabric.Textbox(\r\n      `${fixtureData?.header?.label ? fixtureData.header.label : \"\"}`,\r\n      {\r\n        left: midX + midWidth / 2,\r\n        top: firstBoxY + boxHeight / 2,\r\n        fontSize: 7,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"600\",\r\n        fill: fixtureData.issue ? \"#fff\" : \"#101828\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        width: midWidth,\r\n        height: boxHeight,\r\n        textAlign: \"center\",\r\n      }\r\n    );\r\n\r\n    const shelves: fabric.Object[] = [];\r\n    const shelfHeight = midHeight - 2 * boxHeight;\r\n\r\n    if (fixtureData.productResolutionLevel === \"L1\") {\r\n      const boxY = firstBoxY + boxHeight;\r\n\r\n      const shelf = new fabric.Rect({\r\n        left: midX,\r\n        top: boxY,\r\n        width: midWidth,\r\n        height: shelfHeight,\r\n        // stroke: '#51C1FF',\r\n        stroke: fixtureColor?.primary\r\n          ? fixtureColor?.primary\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#51C1FF\",\r\n        strokeWidth: 0.27,\r\n        fill: \"white\",\r\n      });\r\n\r\n      const text = fixtureData?.productBrandName?.join(\" + \") || \"\";\r\n\r\n      // Wrap text within fixture width and shrink to fit vertical space\r\n      const maxTextWidth = midWidth * 0.9;\r\n      const maxTextHeight = shelfHeight * 0.8;\r\n      let fontSizeL1 = 6;\r\n\r\n      const createWrappedTextbox = (fs: number) =>\r\n        new fabric.Textbox(text, {\r\n          left: midX + midWidth / 2,\r\n          top: boxY + shelfHeight / 2,\r\n          originX: \"center\",\r\n          originY: \"center\",\r\n          width: maxTextWidth,\r\n          fontSize: fs,\r\n          fontFamily: \"Inter\",\r\n          fontWeight: \"500\",\r\n          textAlign: \"center\",\r\n          fill: \"#333\",\r\n          selectable: false,\r\n          evented: false,\r\n        });\r\n\r\n      let wrappedText = createWrappedTextbox(fontSizeL1);\r\n      while (wrappedText.height > maxTextHeight && fontSizeL1 > 2) {\r\n        fontSizeL1 -= 0.5;\r\n        wrappedText = createWrappedTextbox(fontSizeL1);\r\n      }\r\n\r\n      const padding = 2;\r\n      const background = new fabric.Rect({\r\n        left: midX + midWidth / 2,\r\n        top: boxY + shelfHeight / 2,\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        width: Math.min(maxTextWidth, wrappedText.width!) + padding,\r\n        height: wrappedText.getScaledHeight() + 2,\r\n        fill: \"rgba(255, 255, 255, 0.5)\",\r\n        selectable: false,\r\n        evented: false,\r\n        rx: 1,\r\n        ry: 1,\r\n      });\r\n\r\n      shelves.push(shelf, background, wrappedText);\r\n    } else if (fixtureData.productResolutionLevel === \"L2\") {\r\n      for (let i = 0; i < shelfCount; i++) {\r\n        const boxY = firstBoxY + boxHeight * (i + 1);\r\n\r\n        const shelf = new fabric.Rect({\r\n          left: midX,\r\n          top: boxY,\r\n          width: midWidth,\r\n          height: boxHeight,\r\n          stroke: fixtureColor?.primary\r\n            ? fixtureColor?.primary\r\n            : fixtureData.issue\r\n              ? \"#D92D20\"\r\n              : \"#51C1FF\",\r\n          strokeWidth: 0.27,\r\n          fill: \"white\",\r\n        });\r\n\r\n        shelves.push(shelf);\r\n\r\n        if (fixtureData.shelfConfig?.[i].shelfType === \"tray\") {\r\n          const trayRows = fixtureData.shelfConfig?.[i].trayRows || 1;\r\n          const rowSpacing = boxHeight / trayRows;\r\n\r\n          for (let r = 1; r < trayRows; r++) {\r\n            const lineY = boxY + r * rowSpacing;\r\n\r\n            const trayLine = new fabric.Line(\r\n              [midX, lineY, midX + midWidth, lineY],\r\n              {\r\n                stroke: \"#999\",\r\n                strokeWidth: 0.2,\r\n                selectable: false,\r\n                evented: false,\r\n              }\r\n            );\r\n\r\n            shelves.push(trayLine);\r\n          }\r\n        }\r\n\r\n        const text =\r\n          fixtureData.shelfConfig?.[i].productBrandName?.join(\" + \") || \"\";\r\n\r\n        // L2: Single-line ellipsis against full shelf width\r\n        const horizontalPadding = 6;\r\n        const maxTextWidth = Math.max(0, midWidth - horizontalPadding);\r\n        const maxTextHeight = boxHeight * 0.8;\r\n        const baseFontSize = 5;\r\n\r\n        const measure = (t: string) =>\r\n          new fabric.Text(t, {\r\n            fontSize: baseFontSize,\r\n            fontFamily: \"Inter\",\r\n            fontWeight: \"500\",\r\n          });\r\n\r\n        let displayText = text;\r\n        let measured = measure(displayText);\r\n\r\n        if ((measured.width ?? 0) > maxTextWidth) {\r\n          const ellipsis = \"...\";\r\n          let leftIdx = 0;\r\n          let rightIdx = text.length;\r\n\r\n          while (leftIdx < rightIdx) {\r\n            const midIdx = Math.floor((leftIdx + rightIdx) / 2);\r\n            const candidate = text.slice(0, midIdx) + ellipsis;\r\n            measured = measure(candidate);\r\n            if ((measured.width ?? 0) > maxTextWidth) {\r\n              rightIdx = midIdx;\r\n            } else {\r\n              leftIdx = midIdx + 1;\r\n            }\r\n          }\r\n          displayText = text.slice(0, Math.max(0, leftIdx - 1)) + ellipsis;\r\n          measured = measure(displayText);\r\n        }\r\n\r\n        const background = new fabric.Rect({\r\n          left: midX + midWidth / 2,\r\n          top: boxY + boxHeight / 2,\r\n          originX: \"center\",\r\n          originY: \"center\",\r\n          width: midWidth,\r\n          height: Math.min(maxTextHeight, measured.height ?? 10) + 2,\r\n          fill: \"rgba(255, 255, 255, 0.5)\",\r\n          selectable: false,\r\n          evented: false,\r\n          rx: 1,\r\n          ry: 1,\r\n        });\r\n\r\n        const finalText = new fabric.Text(displayText, {\r\n          left: midX + midWidth / 2,\r\n          top: boxY + boxHeight / 2,\r\n          originX: \"center\",\r\n          originY: \"center\",\r\n          fontSize: baseFontSize,\r\n          fontFamily: \"Inter\",\r\n          fontWeight: \"500\",\r\n          fill: \"#333\",\r\n          selectable: false,\r\n          evented: false,\r\n        });\r\n\r\n        shelves.push(background, finalText);\r\n      }\r\n    } else if (fixtureData.productResolutionLevel === \"L3\") {\r\n      const sequentialGroups: { zone: string; shelves: any[] }[] = [];\r\n\r\n      let previousZone: string | null = null;\r\n\r\n      for (const shelf of fixtureData.shelfConfig) {\r\n        const zone = shelf.zone || \"Unknown\";\r\n        if (zone !== previousZone) {\r\n          sequentialGroups.push({ zone, shelves: [shelf] });\r\n          previousZone = zone;\r\n        } else {\r\n          sequentialGroups[sequentialGroups.length - 1].shelves.push(shelf);\r\n        }\r\n      }\r\n\r\n      let currentShelfIndex = 0;\r\n\r\n      for (const group of sequentialGroups) {\r\n        const { zone, shelves: shelvesInGroup } = group;\r\n\r\n        const groupStartIndex = currentShelfIndex;\r\n        const groupLength = shelvesInGroup.length;\r\n\r\n        const groupTopY = firstBoxY + boxHeight * (groupStartIndex + 1);\r\n        const groupBottomY = groupTopY + boxHeight * groupLength;\r\n\r\n        for (let j = 0; j < shelvesInGroup.length; j++) {\r\n          const shelfData = shelvesInGroup[j];\r\n          const boxY = firstBoxY + boxHeight * (currentShelfIndex + 1);\r\n\r\n          const shelfRect = new fabric.Rect({\r\n            left: midX,\r\n            top: boxY,\r\n            width: midWidth,\r\n            height: boxHeight,\r\n            stroke: fixtureColor?.primary\r\n              ? fixtureColor?.primary\r\n              : fixtureData.issue\r\n                ? \"#D92D20\"\r\n                : \"#51C1FF\",\r\n            strokeWidth: 0.27,\r\n            fill: \"white\",\r\n          });\r\n\r\n          shelves.push(shelfRect);\r\n\r\n          if (shelfData.shelfType === \"tray\") {\r\n            const trayRows = shelfData.trayRows || 0;\r\n            const productPerShelf = shelfData.productPerShelf || 0;\r\n\r\n            const rowSpacing = boxHeight / trayRows;\r\n            const columnSpacing = midWidth / productPerShelf;\r\n\r\n            for (let r = 1; r < trayRows; r++) {\r\n              const lineY = boxY + r * rowSpacing;\r\n\r\n              const trayLine = new fabric.Line(\r\n                [midX, lineY, midX + midWidth, lineY],\r\n                {\r\n                  stroke: \"#999\",\r\n                  strokeWidth: 0.2,\r\n                  selectable: false,\r\n                  evented: false,\r\n                }\r\n              );\r\n\r\n              shelves.push(trayLine);\r\n            }\r\n\r\n            for (let c = 1; c < productPerShelf; c++) {\r\n              const lineX = midX + c * columnSpacing;\r\n\r\n              const verticalLine = new fabric.Line(\r\n                [lineX, boxY, lineX, boxY + boxHeight],\r\n                {\r\n                  stroke: \"#999\",\r\n                  strokeWidth: 0.2,\r\n                  selectable: false,\r\n                  evented: false,\r\n                }\r\n              );\r\n\r\n              shelves.push(verticalLine);\r\n            }\r\n          }\r\n\r\n          currentShelfIndex++;\r\n        }\r\n\r\n        const groupBottomLine = new fabric.Line(\r\n          [midX, groupBottomY, midX + midWidth, groupBottomY],\r\n          {\r\n            stroke: fixtureColor?.primary\r\n              ? fixtureColor?.primary\r\n              : fixtureData.issue\r\n                ? \"#D92D20\"\r\n                : \"#51C1FF\",\r\n            strokeWidth: 1,\r\n            selectable: false,\r\n            evented: false,\r\n          }\r\n        );\r\n\r\n        shelves.push(groupBottomLine);\r\n\r\n        if (fixtureData.fixtureType === \"wall\") {\r\n          const labelPadding = 2;\r\n          const labelText = new fabric.Textbox(zone, {\r\n            left: midX + midWidth - labelPadding,\r\n            top: groupBottomY,\r\n            fontSize: 5,\r\n            fontFamily: \"Inter\",\r\n            fontWeight: \"600\",\r\n            fill: \"#707070\",\r\n            originX: \"right\",\r\n            originY: \"bottom\",\r\n            width: midWidth / 2,\r\n            textAlign: \"right\",\r\n          });\r\n\r\n          shelves.push(labelText);\r\n        }\r\n\r\n        const groupCenterX = midX + midWidth / 2;\r\n        const groupCenterY = groupTopY + (groupBottomY - groupTopY) / 2;\r\n\r\n        const sectionBrands = new Set();\r\n\r\n        shelvesInGroup?.forEach((shelf) => {\r\n          shelf.productBrandName?.forEach((brand: string) => {\r\n            sectionBrands.add(brand);\r\n          });\r\n        });\r\n\r\n        if ([...sectionBrands].length) {\r\n          const text = [...sectionBrands].join(\" + \");\r\n          const padding = 2;\r\n          const maxTextWidth = midWidth;\r\n          const rectWidth = midWidth * 0.9;\r\n          const maxTextHeight = 20;\r\n\r\n          let fontSize = 6;\r\n          let wrappedText;\r\n\r\n          const createTextbox = (fs: any) => {\r\n            return new fabric.Textbox(text, {\r\n              fontSize: fs,\r\n              fontFamily: \"Inter\",\r\n              fontWeight: \"400\",\r\n              width: maxTextWidth,\r\n              textAlign: \"center\",\r\n              originX: \"center\",\r\n              originY: \"center\",\r\n              fill: \"#101828\",\r\n              selectable: false,\r\n              evented: false,\r\n              left: groupCenterX,\r\n              top: groupCenterY,\r\n            });\r\n          };\r\n\r\n          do {\r\n            wrappedText = createTextbox(fontSize);\r\n            fontSize -= 0.5;\r\n          } while (wrappedText.height > maxTextHeight && fontSize > 2);\r\n\r\n          const rectHeight = wrappedText.getScaledHeight() + padding;\r\n\r\n          const groupCenterText = new fabric.Rect({\r\n            left: groupCenterX,\r\n            top: groupCenterY,\r\n            originX: \"center\",\r\n            originY: \"center\",\r\n            width: rectWidth,\r\n            height: rectHeight,\r\n            fill: \"rgba(255, 255, 255, 0.5)\",\r\n            selectable: false,\r\n            evented: false,\r\n            rx: 1,\r\n            ry: 1,\r\n          });\r\n\r\n          shelves.push(groupCenterText, wrappedText);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (fixtureData?.vmConfig?.length) {\r\n      for (let i = 0; i < fixtureData.vmConfig.length; i++) {\r\n        const vm = fixtureData.vmConfig[i];\r\n\r\n        const startIndex = vm.startYPosition - 1;\r\n        const endIndex = vm.endYPosition - 1;\r\n\r\n        const shelfTopY = firstBoxY + boxHeight * (startIndex + 1);\r\n        const shelfHeightSpan = boxHeight * (endIndex - startIndex + 1);\r\n\r\n        let vmHeightPx: number = shelfHeightSpan;\r\n        let y: number = shelfTopY;\r\n\r\n        if (vm.yZone && vm.yZone !== \"stretch\") {\r\n          vmHeightPx = shelfHeightSpan / 3;\r\n\r\n          switch (vm.yZone) {\r\n            case \"top\":\r\n              y = shelfTopY;\r\n              break;\r\n            case \"middle\":\r\n              y = shelfTopY + vmHeightPx;\r\n              break;\r\n            case \"bottom\":\r\n              y = shelfTopY + 2 * vmHeightPx;\r\n              break;\r\n            default:\r\n              y = shelfTopY;\r\n          }\r\n        }\r\n\r\n        let x = midX;\r\n        let width = midWidth;\r\n\r\n        if (!vm.xZone || vm.xZone === \"stretch\") {\r\n          width = midWidth;\r\n          x = midX;\r\n        } else {\r\n          const sectionWidth = midWidth / 3;\r\n          switch (vm.xZone) {\r\n            case \"left\":\r\n              width = sectionWidth;\r\n              x = midX;\r\n              break;\r\n            case \"middle\":\r\n              width = sectionWidth;\r\n              x = midX + sectionWidth;\r\n              break;\r\n            case \"right\":\r\n              width = sectionWidth;\r\n              x = midX + 2 * sectionWidth;\r\n              break;\r\n            default:\r\n              width = midWidth;\r\n              x = midX;\r\n          }\r\n        }\r\n\r\n        if (vm.vmImageUrl) {\r\n          try {\r\n            const vmImage: any = await fabric.FabricImage.fromURL(\r\n              `${this.cdnUrl}${vm.vmImageUrl}?v=${Date.now()}`,\r\n              {\r\n                crossOrigin: \"anonymous\",\r\n              }\r\n            );\r\n\r\n            vmImage.set({\r\n              left: x + width / 2,\r\n              top: y + vmHeightPx / 2,\r\n              originX: \"center\",\r\n              originY: \"center\",\r\n              scaleX: width / vmImage.width!,\r\n              scaleY: vmHeightPx / vmImage.height!,\r\n              selectable: false,\r\n              evented: false,\r\n            });\r\n\r\n            shelves.push(vmImage);\r\n          } catch (err) {\r\n            console.error(`Error loading image for VM: ${vm.vmImageUrl}`, err);\r\n          }\r\n        } else {\r\n          const vmBox = new fabric.Rect({\r\n            left: x,\r\n            top: y,\r\n            width,\r\n            height: vmHeightPx,\r\n            fill: fixtureColor?.vmFill ?? \"#6938EF\",\r\n            selectable: false,\r\n            evented: false,\r\n          });\r\n\r\n          let fontSize = 5;\r\n          let vmText;\r\n\r\n          const createVmText = (fs: number) =>\r\n            new fabric.Textbox(vm.vmName || \"\", {\r\n              left: x + width / 2,\r\n              top: y + vmHeightPx / 2,\r\n              originX: \"center\",\r\n              originY: \"center\",\r\n              fontSize: fs,\r\n              fontFamily: \"Inter\",\r\n              fontWeight: \"600\",\r\n              fill: \"white\",\r\n              textAlign: \"center\",\r\n              width: width,\r\n              selectable: false,\r\n              evented: false,\r\n            });\r\n\r\n          do {\r\n            vmText = createVmText(fontSize);\r\n            fontSize -= 0.5;\r\n          } while (vmText.height > vmHeightPx && fontSize > 2);\r\n\r\n          shelves.push(vmBox, vmText);\r\n        }\r\n      }\r\n    }\r\n\r\n    const lastBoxY = firstBoxY + boxHeight * (shelfCount + 1);\r\n    const lastBox = new fabric.Path(\r\n      `M ${midX} ${lastBoxY} \r\n              L ${midX + midWidth} ${lastBoxY} \r\n              L ${midX + midWidth} ${lastBoxY + boxHeight - radius} \r\n              Q ${midX + midWidth} ${lastBoxY + boxHeight} ${midX + midWidth - radius\r\n      } ${lastBoxY + boxHeight} \r\n              L ${midX + radius} ${lastBoxY + boxHeight} \r\n              Q ${midX} ${lastBoxY + boxHeight} ${midX} ${lastBoxY + boxHeight - radius\r\n      } \r\n              L ${midX} ${lastBoxY} Z`,\r\n      {\r\n        fill: fixtureColor?.fill\r\n          ? fixtureColor?.fill\r\n          : fixtureData.issue\r\n            ? \"#FEE4E2\"\r\n            : \"#EAF8FF\",\r\n        stroke: fixtureColor?.primary\r\n          ? fixtureColor?.primary\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#6BCAFF\",\r\n        strokeWidth: 0.27,\r\n      }\r\n    );\r\n\r\n    const lastBoxText = new fabric.Textbox(\r\n      `${fixtureData?.footer?.label ? fixtureData.footer.label : \"\"}`,\r\n      {\r\n        left: midX + midWidth / 2,\r\n        top: lastBoxY + boxHeight / 2,\r\n        fontSize: 5,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"600\",\r\n        fill: \"#101828\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        textAlign: \"center\",\r\n        width: midWidth,\r\n        heigth: boxHeight,\r\n      }\r\n    );\r\n\r\n    const bottomWidth = width / 1.05;\r\n    const bottomHeight = (3 / 100) * height;\r\n    const bottomX = x + (width - bottomWidth) / 2;\r\n    const bottomY = midY + midHeight + this.verticalMargin;\r\n\r\n    const bottomContainer = new fabric.Rect({\r\n      left: bottomX,\r\n      top: bottomY,\r\n      width: bottomWidth,\r\n      height: bottomHeight,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: \"transparent\",\r\n      fill: \"transparent\",\r\n    });\r\n\r\n    const bottomTextContent = new fabric.Textbox(\r\n      `Shelves - ${fixtureData.shelfConfig?.length} . Products -  ${fixtureData.fixtureCapacity} . VM - ${fixtureData.vmConfig?.length}`,\r\n      {\r\n        left: bottomX + bottomWidth / 2,\r\n        top: bottomY + bottomHeight / 2,\r\n        fontSize: 5,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"500\",\r\n        fill: \"#333\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        textAlign: \"center\",\r\n        width: bottomWidth,\r\n        height: bottomHeight,\r\n      }\r\n    );\r\n\r\n\r\n    const fixtureGroup = new fabric.Group(\r\n      [\r\n        mainContainer,\r\n        topContainer,\r\n        innerTopBox,\r\n        topText,\r\n        innerBottomBox,\r\n        bottomText,\r\n        midContainer,\r\n        firstBox,\r\n        firstBoxText,\r\n        ...shelves,\r\n        lastBox,\r\n        lastBoxText,\r\n        bottomContainer,\r\n        bottomTextContent,\r\n      ],\r\n      {\r\n        left: x,\r\n        top: y,\r\n        evented: true,\r\n        selectable: false,\r\n        hoverCursor: \"default\",\r\n        lockScalingX: true,\r\n        lockScalingY: true,\r\n        lockMovementX: true,\r\n        lockMovementY: true,\r\n        lockRotation: true,\r\n        hasControls: false,\r\n        subTargetCheck: true,\r\n        angle: fixtureData.relativePosition?.angle ?? 0,\r\n      }\r\n    ) as fabric.Group & {\r\n      wallIndex: number;\r\n      fixtureIndex: number;\r\n      fixtureId: string;\r\n      fixtureType: \"wall\" | \"floor\";\r\n      issue: boolean;\r\n      issueData: any;\r\n      taskType: string;\r\n      vmConfig: [];\r\n      objType: string;\r\n    };\r\n\r\n\r\n\r\n    fixtureGroup.fixtureType = fixtureData.fixtureType;\r\n    fixtureGroup.wallIndex = fixtureData.associatedElementNumber;\r\n    fixtureGroup.fixtureIndex = fixtureData.associatedElementFixtureNumber;\r\n    fixtureGroup.fixtureId = fixtureData._id;\r\n    fixtureGroup.issue = fixtureData.issue;\r\n    fixtureGroup.issueData = fixtureData.issueData;\r\n    fixtureGroup.taskType = fixtureData.taskType;\r\n    fixtureGroup.vmConfig = fixtureData.vmConfig;\r\n    fixtureGroup.objType = \"fixture\";\r\n\r\n    // Add click handler directly on the fixture group\r\n    fixtureGroup.on(\"mousedown\", (event: any) => {\r\n      // Use the fixture group itself (which has all the fixture properties)\r\n      // The event.target might be a child element, so we use fixtureGroup directly\r\n      if (fixtureGroup && (fixtureGroup as any).fixtureId) {\r\n        // this.onFixtureClick(fixtureGroup);\r\n      }\r\n    });\r\n\r\n    canvas.add(fixtureGroup);\r\n\r\n    // If newly added, focus it once\r\n    if ((fixtureData as any)?.newAdded) {\r\n      try {\r\n        canvas.setActiveObject(fixtureGroup);\r\n        canvas.requestRenderAll();\r\n      } catch { }\r\n      delete (fixtureData as any).newAdded;\r\n    }\r\n\r\n    return fixtureGroup;\r\n  }\r\n\r\n  drawOtherElementsWithLabel(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    a: number,\r\n    width: number,\r\n    height: number,\r\n    element: any\r\n  ): fabric.Group {\r\n    const rect = new fabric.Rect({\r\n      width,\r\n      height,\r\n      rx: 2,\r\n      ry: 2,\r\n      fill: \"#DAF1FF\",\r\n      stroke: \"#6BCAFF\",\r\n      strokeWidth: 2,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n    });\r\n\r\n    const text = new fabric.Textbox(element.fixtureName, {\r\n      width: width - 8,\r\n      fontSize: 14,\r\n      fontFamily: \"Inter\",\r\n      fontWeight: \"500\",\r\n      fill: \"#101828\",\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      textAlign: \"center\",\r\n      editable: false,\r\n      splitByGrapheme: true,\r\n    });\r\n\r\n    const textBounds = text.getBoundingRect();\r\n\r\n    if (textBounds.height > height - 8) {\r\n      const scale = (height - 8) / textBounds.height;\r\n      text.set(\"fontSize\", text.fontSize! * scale);\r\n    }\r\n\r\n    const group = new fabric.Group([rect, text], {\r\n      left: x,\r\n      top: y,\r\n      angle: a,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      hasControls: false,\r\n      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockRotation: true,\r\n      lockMovementX: true,\r\n      lockMovementY: true,\r\n      evented: true,\r\n      hoverCursor: \"default\",\r\n    }) as fabric.Group & {\r\n      objType: string;\r\n      data: any;\r\n    };\r\n\r\n    group.objType = \"others\";\r\n    group.data = element;\r\n\r\n    canvas.add(group);\r\n\r\n    if ((element as any)?.newAdded) {\r\n      try {\r\n        canvas.setActiveObject(group);\r\n        canvas.requestRenderAll();\r\n      } catch { }\r\n      delete (element as any).newAdded;\r\n    }\r\n\r\n    return group;\r\n  }\r\n\r\n  resizeCanvas(canvas: fabric.Canvas, container: ElementRef<HTMLDivElement>): void {\r\n    const containerEl = container.nativeElement;\r\n    const width = containerEl.clientWidth || containerEl.offsetWidth;\r\n    const height = containerEl.clientHeight || containerEl.offsetHeight;\r\n\r\n    if (width > 0 && height > 0) {\r\n      canvas.setDimensions({\r\n        width: width,\r\n        height: height,\r\n      });\r\n      canvas.calcOffset();\r\n      canvas.requestRenderAll();\r\n    }\r\n  }\r\n\r\n  private fitCanvasToLayoutAnimated(canvas: fabric.Canvas) {\r\n    if (!canvas) return;\r\n\r\n    // Ensure canvas has objects before calculating bounds\r\n    const objects = canvas.getObjects();\r\n    if (!objects || objects.length === 0) {\r\n      console.warn('No objects on canvas to fit');\r\n      return;\r\n    }\r\n\r\n    // Force recalculation of object coordinates\r\n    canvas.calcOffset();\r\n\r\n    const bounds = this.getFullLayoutBounds(canvas);\r\n    if (!bounds.width || !bounds.height || bounds.width === 0 || bounds.height === 0) {\r\n      console.warn('Invalid bounds for canvas fitting', bounds);\r\n      return;\r\n    }\r\n\r\n    const canvasW = canvas.getWidth();\r\n    const canvasH = canvas.getHeight();\r\n\r\n    if (canvasW === 0 || canvasH === 0) {\r\n      console.warn('Canvas dimensions are zero');\r\n      return;\r\n    }\r\n\r\n    const scaleX = canvasW / bounds.width;\r\n    const scaleY = canvasH / bounds.height;\r\n    // Use smaller multiplier (0.5) to zoom out more and ensure planogram fits with more padding inside canvas\r\n    const targetZoom = Math.min(scaleX, scaleY) * 0.9;\r\n\r\n    // Ensure zoom is within reasonable bounds\r\n    const finalZoom = Math.max(0.1, Math.min(targetZoom, 3));\r\n\r\n    const targetVpt = [...(canvas.viewportTransform || [1, 0, 0, 1, 0, 0])] as fabric.TMat2D;\r\n    targetVpt[0] = finalZoom;\r\n    targetVpt[3] = finalZoom;\r\n\r\n    // Calculate center of layout bounds for horizontal centering\r\n    const centerX = bounds.left + bounds.width / 2;\r\n\r\n    // Position from top with very minimal padding (use top space)\r\n    const topPadding = 10; // Fixed 10px padding from top\r\n\r\n    // Calculate translation: center horizontally, position from top\r\n    targetVpt[4] = canvasW / 2 - centerX * finalZoom;\r\n    targetVpt[5] = topPadding - bounds.top * finalZoom;\r\n\r\n    const startVpt = [...canvas.viewportTransform!] as fabric.TMat2D;\r\n\r\n    fabric.util.animate({\r\n      startValue: 0,\r\n      endValue: 1,\r\n      duration: 500,\r\n      onChange: (value: number) => {\r\n        const vpt = [...startVpt] as fabric.TMat2D;\r\n        vpt[0] = startVpt[0] + (targetVpt[0] - startVpt[0]) * value;\r\n        vpt[3] = startVpt[3] + (targetVpt[3] - startVpt[3]) * value;\r\n        vpt[4] = startVpt[4] + (targetVpt[4] - startVpt[4]) * value;\r\n        vpt[5] = startVpt[5] + (targetVpt[5] - startVpt[5]) * value;\r\n        canvas.setViewportTransform(vpt);\r\n        canvas.requestRenderAll();\r\n      },\r\n    });\r\n  }\r\n\r\n  private getFullLayoutBounds(canvas: fabric.Canvas) {\r\n    const objects = canvas.getObjects();\r\n    if (!objects.length) return { left: 0, top: 0, width: 0, height: 0 };\r\n\r\n    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\r\n\r\n    for (const obj of objects) {\r\n      // Get bounding rect which accounts for object's position, rotation, and scale\r\n      const boundingRect = obj.getBoundingRect();\r\n\r\n      // Get the actual bounding box\r\n      const left = boundingRect.left;\r\n      const top = boundingRect.top;\r\n      const right = left + boundingRect.width;\r\n      const bottom = top + boundingRect.height;\r\n\r\n      minX = Math.min(minX, left);\r\n      minY = Math.min(minY, top);\r\n      maxX = Math.max(maxX, right);\r\n      maxY = Math.max(maxY, bottom);\r\n    }\r\n\r\n    return { left: minX, top: minY, width: maxX - minX, height: maxY - minY };\r\n  }\r\n\r\n  toPixels(value: number, unit: string, dpi = 2.8): number {\r\n    let pixels: number;\r\n    if (unit === \"mm\") {\r\n      pixels = (value / 25.4) * dpi;\r\n    } else if (unit === \"ft\") {\r\n      pixels = value * 12 * dpi;\r\n    } else {\r\n      throw new Error(\"Unsupported unit. Use 'mm' or 'ft'.\");\r\n    }\r\n    return Number(pixels.toFixed(4));\r\n  }\r\n\r\n  // Store list methods\r\n  onSelectAll(checked: boolean): void {\r\n    if (checked) {\r\n      // Only select stores that don't have no-match status\r\n      this.filteredStores.forEach(store => {\r\n        if (!this.hasNoMatch(store)) {\r\n          store.isApproved = true;\r\n          this.selectedStores.add(store.storeName);\r\n        }\r\n      });\r\n    } else {\r\n      // Deselect all stores\r\n      this.filteredStores.forEach(store => {\r\n        store.isApproved = false;\r\n      });\r\n      this.selectedStores.clear();\r\n    }\r\n\r\n    // Update findReplaceData stores array and notify data service\r\n    if (this.findReplaceData?.stores) {\r\n      const stores = this.findReplaceData.stores;\r\n      this.filteredStores.forEach(filteredStore => {\r\n        if (filteredStore && stores) {\r\n          const storeIndex = stores.findIndex(s => s && s.storeName === filteredStore.storeName);\r\n          if (storeIndex !== -1 && stores[storeIndex]) {\r\n            stores[storeIndex].isApproved = filteredStore.isApproved;\r\n          }\r\n        }\r\n      });\r\n      // Update data service to preserve state\r\n      if (stores) {\r\n        this.dataService.updateData({ stores: stores });\r\n      }\r\n    }\r\n  }\r\n\r\n  onStoreCheckboxChange(store: Store, checked: boolean): void {\r\n    // Prevent selection if store has no-match status\r\n    if (this.hasNoMatch(store)) {\r\n      return;\r\n    }\r\n\r\n    if (!store) {\r\n      return;\r\n    }\r\n\r\n    // Update isApproved property on the store object\r\n    store.isApproved = checked;\r\n\r\n    // Update the store in the local stores array\r\n    const localStoreIndex = this.stores.findIndex(s => s.storeName === store.storeName);\r\n    if (localStoreIndex !== -1 && this.stores[localStoreIndex]) {\r\n      this.stores[localStoreIndex].isApproved = checked;\r\n    }\r\n\r\n    // Update selectedStores set for backward compatibility\r\n    if (checked) {\r\n      this.selectedStores.add(store.storeName);\r\n    } else {\r\n      this.selectedStores.delete(store.storeName);\r\n    }\r\n\r\n    // Update the store in findReplaceData stores array and notify data service to preserve state\r\n    if (this.findReplaceData?.stores) {\r\n      const storeIndex = this.findReplaceData.stores.findIndex(s => s.storeName === store.storeName);\r\n      if (storeIndex !== -1 && this.findReplaceData.stores[storeIndex]) {\r\n        this.findReplaceData.stores[storeIndex].isApproved = checked;\r\n        // Update data service to preserve state when save as draft is called\r\n        this.dataService.updateData({ stores: this.findReplaceData.stores });\r\n      }\r\n    }\r\n  }\r\n\r\n  isStoreSelected(storeName: string): boolean {\r\n    // Check both selectedStores set and isApproved property\r\n    const store = this.stores.find(s => s.storeName === storeName);\r\n    return this.selectedStores.has(storeName) || (store?.isApproved === true);\r\n  }\r\n\r\n  isAllSelected(): boolean {\r\n    // Only consider selectable stores (exclude no-match stores)\r\n    const selectableStores = this.filteredStores.filter(store => !this.hasNoMatch(store));\r\n    return selectableStores.length > 0 && selectableStores.every(store => store.isApproved === true);\r\n  }\r\n\r\n  onSearch(): void {\r\n    this.applyFilters();\r\n  }\r\n\r\n  applyFilters(): void {\r\n    let filtered = [...this.stores];\r\n\r\n    // Apply search filter\r\n    if (this.searchTerm.trim()) {\r\n      const term = this.searchTerm.toLowerCase();\r\n      filtered = filtered.filter(store =>\r\n        store.storeName.toLowerCase().includes(term)\r\n      );\r\n    }\r\n\r\n    // Apply status filter\r\n    if (this.selectedStatusFilters.size > 0) {\r\n      filtered = filtered.filter(store => {\r\n        if (!store.responseStatus) {\r\n          return this.selectedStatusFilters.has('unknown');\r\n        }\r\n        return this.selectedStatusFilters.has(store.responseStatus);\r\n      });\r\n    }\r\n\r\n    this.filteredStores = filtered;\r\n    this.totalItems = this.filteredStores.length;\r\n    this.offset = 1; // Reset to first page when filters change\r\n  }\r\n\r\n  get paginatedStores(): Store[] {\r\n    const startIndex = (this.offset - 1) * this.limit;\r\n    const endIndex = startIndex + this.limit;\r\n    return this.filteredStores.slice(startIndex, endIndex);\r\n  }\r\n\r\n  onDownload(): void {\r\n    if (!this.stores || this.stores.length === 0) {\r\n      console.warn('No stores to export');\r\n      return;\r\n    }\r\n\r\n    // Prepare data for Excel export\r\n    const exportData = this.stores.map(store => ({\r\n      'Store Name': store.storeName,\r\n      'Status': store.responseStatus === 'match' ? 'Match' :\r\n        store.responseStatus === 'no-match' ? 'No Match' :\r\n          'Unknown'\r\n    }));\r\n\r\n    // Export to Excel\r\n    const fileName = `Stores_Export_${new Date().toISOString().split('T')[0]}`;\r\n    this.storeBuilderService.exportAsExcelFile(exportData, fileName);\r\n  }\r\n\r\n  onFilter(): void {\r\n    // Filter functionality is handled via dropdown in template\r\n  }\r\n\r\n  onStatusFilterChange(status: string, event: any): void {\r\n    const isChecked = event.target.checked;\r\n    if (isChecked) {\r\n      this.selectedStatusFilters.add(status);\r\n    } else {\r\n      this.selectedStatusFilters.delete(status);\r\n    }\r\n    this.applyFilters();\r\n  }\r\n\r\n  isStatusFilterSelected(status: string): boolean {\r\n    return this.selectedStatusFilters.has(status);\r\n  }\r\n\r\n  clearFilters(): void {\r\n    this.selectedStatusFilters.clear();\r\n    this.searchTerm = '';\r\n    this.applyFilters();\r\n  }\r\n\r\n  hasActiveFilters(): boolean {\r\n    return this.selectedStatusFilters.size > 0 || this.searchTerm.trim().length > 0;\r\n  }\r\n\r\n  async onApproveAndComplete(): Promise<void> {\r\n    try {\r\n      const modalRef = this.modalService.open(ApproveCompleteModalComponent, {\r\n        centered: true,\r\n        size: 'lg',\r\n        backdrop: 'static',\r\n        windowClass: 'approve-complete-modal'\r\n      });\r\n\r\n      // Pre-fill modal with existing schedule values if available\r\n      modalRef.componentInstance.initialSchedule = this.findReplaceData?.schedule || false;\r\n      modalRef.componentInstance.initialScheduleDate = this.findReplaceData?.scheduleDate || null;\r\n\r\n      const result = await modalRef.result;\r\n      if (result) {\r\n        // Handle the approve and complete action\r\n        console.log('Approve and complete with schedule:', result.schedule, 'scheduleDate:', result.scheduleDate);\r\n\r\n        // Get findReplaceId from findReplaceData\r\n        if (!this.findReplaceData?._id) {\r\n          console.error('FindReplace ID is missing');\r\n          return;\r\n        }\r\n\r\n        // Save stores, schedule, and scheduleDate using save as draft first\r\n        const draftData: any = {};\r\n        if (this.findReplaceData.stores && this.findReplaceData.stores.length > 0) {\r\n          draftData.stores = this.findReplaceData.stores;\r\n        }\r\n        if (result.schedule !== undefined) {\r\n          draftData.schedule = result.schedule;\r\n        }\r\n        if (result.scheduleDate !== undefined) {\r\n          draftData.scheduleDate = result.scheduleDate;\r\n        }\r\n        \r\n        // Wait for save as draft to complete before calling approveReplace\r\n        this.approveLoading = true;\r\n        try {\r\n          // Save all the data using save as draft and wait for it to complete\r\n          if (Object.keys(draftData).length > 0) {\r\n            const saveResponse: any = await this.dataService.saveDraftAndWait(draftData).toPromise();\r\n            if (saveResponse?.code !== 200) {\r\n              console.error('Failed to save as draft:', saveResponse?.message || 'Unknown error');\r\n              this.approveLoading = false;\r\n              return;\r\n            }\r\n          }\r\n\r\n          // Call the approveReplace API with only findReplaceId after save as draft completes\r\n          const response: any = await this.storeBuilderService.approveReplace({\r\n            findReplaceId: this.findReplaceData._id,\r\n          }).toPromise();\r\n\r\n          console.log('Approve replace response:', response);\r\n          this.approveLoading = false;\r\n          \r\n          // Navigate to table page on successful response\r\n          if (response?.code === 200) {\r\n            this.router.navigate(['/manage/planogram/find-replace-table']);\r\n          }\r\n        } catch (error) {\r\n          console.error('Error approving replace:', error);\r\n          this.approveLoading = false;\r\n          // TODO: Handle error (e.g., show error message)\r\n        }\r\n      }\r\n    } catch (error) {\r\n      console.log('Modal dismissed');\r\n    }\r\n  }\r\n\r\n  hasNoMatch(store: Store): boolean {\r\n    return store.responseStatus === 'no-match';\r\n  }\r\n\r\n  isApproved(): boolean {\r\n    return this.findReplaceData?.status === 'approved' ;\r\n  }\r\n\r\n\r\n  previousNext(step: 'previous' | 'next'): void {\r\n    if (!this.selectedStore || this.filteredStores.length === 0) return;\r\n\r\n    const curIdx = this.filteredStores.findIndex(\r\n      (store: Store) => store.storeName === this.selectedStore?.storeName\r\n    );\r\n\r\n    let newIdx: number;\r\n    if (step === 'previous') {\r\n      if (curIdx === 0) return;\r\n      newIdx = curIdx - 1;\r\n    } else {\r\n      if (curIdx === this.filteredStores.length - 1) return;\r\n      newIdx = curIdx + 1;\r\n    }\r\n\r\n    // Update pagination if the new store is on a different page\r\n    const newPage = Math.floor(newIdx / this.limit) + 1;\r\n    if (newPage !== this.offset) {\r\n      this.offset = newPage;\r\n      // Scroll to top of store list when page changes\r\n      const listContainer = document.querySelector('.list-container');\r\n      if (listContainer) {\r\n        listContainer.scrollTop = 0;\r\n      }\r\n    }\r\n\r\n    this.onStoreSelect(this.filteredStores[newIdx]);\r\n  }\r\n\r\n  paginationSize(): number {\r\n    return this.limit;\r\n  }\r\n\r\n  onPageChange(page: number): void {\r\n    this.offset = page;\r\n    // Scroll to top of store list when page changes\r\n    const listContainer = document.querySelector('.list-container');\r\n    if (listContainer) {\r\n      listContainer.scrollTop = 0;\r\n    }\r\n  }\r\n\r\n  onPageSizeChange(size: number): void {\r\n    this.limit = size;\r\n    this.offset = 1; // Reset to first page when page size changes\r\n    // Scroll to top of store list when page size changes\r\n    const listContainer = document.querySelector('.list-container');\r\n    if (listContainer) {\r\n      listContainer.scrollTop = 0;\r\n    }\r\n  }\r\n\r\n  highlightFixture(canvas: fabric.Canvas, group: any, blink: boolean = false) {\r\n    this.removeHighlight(canvas);\r\n    this.cancelHighlightBlink = false;\r\n\r\n    const center = group.getCenterPoint();\r\n    const realWidth = group.width! * group.scaleX!;\r\n    const realHeight = group.height! * group.scaleY!;\r\n\r\n    const rect = new fabric.Rect({\r\n      left: center.x,\r\n      top: center.y,\r\n      width: realWidth + 8,\r\n      height: realHeight + 8,\r\n      rx: 5,\r\n      ry: 5,\r\n      stroke: \"#00aaff\",\r\n      strokeWidth: 3,\r\n      fill: \"transparent\",\r\n      selectable: false,\r\n      evented: false,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      angle: group.angle || 0,\r\n      opacity: blink ? 0 : 1,\r\n    });\r\n\r\n    (rect as any).data = { type: \"fixture-highlight\" };\r\n    canvas.add(rect);\r\n    canvas.moveObjectTo(rect, canvas.getObjects().length - 1);\r\n    canvas.requestRenderAll();\r\n    this.activeHighlight = rect;\r\n\r\n    if (!blink) return;\r\n\r\n    let cycles = 0;\r\n    const blinkOnce = () => {\r\n      if (this.cancelHighlightBlink) {\r\n        this.removeHighlight(canvas);\r\n        return;\r\n      }\r\n      rect.animate({ opacity: 1 }, {\r\n        duration: 200,\r\n        onChange: () => canvas.requestRenderAll(),\r\n        onComplete: () => {\r\n          if (this.cancelHighlightBlink) {\r\n            this.removeHighlight(canvas);\r\n            return;\r\n          }\r\n          rect.animate({ opacity: 0 }, {\r\n            duration: 200,\r\n            onChange: () => canvas.requestRenderAll(),\r\n            onComplete: () => {\r\n              if (this.cancelHighlightBlink) {\r\n                this.removeHighlight(canvas);\r\n                return;\r\n              }\r\n              cycles++;\r\n              if (cycles < 20) {\r\n                blinkOnce();\r\n              } else {\r\n                if (!this.cancelHighlightBlink) {\r\n                  rect.set({ opacity: 1 });\r\n                  canvas.requestRenderAll();\r\n                }\r\n              }\r\n            },\r\n          });\r\n        },\r\n      });\r\n    };\r\n    blinkOnce();\r\n  }\r\n\r\n  removeHighlight(canvas: fabric.Canvas) {\r\n    this.cancelHighlightBlink = true;\r\n    canvas.getObjects().forEach((obj) => {\r\n      if ((obj as any).data?.type === \"fixture-highlight\") {\r\n        canvas.remove(obj);\r\n      }\r\n    });\r\n    this.activeHighlight = null;\r\n    canvas.requestRenderAll();\r\n  }\r\n\r\n  onFixtureClick(target: any): void {\r\n    if (!target || !this.floorData) return;\r\n\r\n    const fixtureId = (target as any).fixtureId;\r\n    const fixtureType = (target as any).fixtureType;\r\n\r\n    if (!fixtureId) {\r\n      console.warn('Fixture click: No fixtureId found on target', target);\r\n      return;\r\n    }\r\n\r\n    // Find the fixture data\r\n    let fixtureData: any = null;\r\n\r\n    if (fixtureType === \"wall\") {\r\n      const wallIndex = (target as any).wallIndex;\r\n\r\n      if (this.floorData.layoutPolygon && wallIndex !== undefined && wallIndex !== null) {\r\n        // Find wall by elementNumber (wallIndex is the elementNumber)\r\n        const wall = this.floorData.layoutPolygon.find(\r\n          (w: any) => w.elementNumber === wallIndex\r\n        );\r\n        if (wall && wall.fixtures) {\r\n          fixtureData = wall.fixtures.find((f: any) => f._id === fixtureId);\r\n        }\r\n      }\r\n    } else if (fixtureType === \"floor\") {\r\n      fixtureData = this.floorData.centerFixture?.find((f: any) => f._id === fixtureId);\r\n    }\r\n\r\n    if (!fixtureData) {\r\n      console.warn('Fixture click: Fixture data not found', {\r\n        fixtureId,\r\n        fixtureType,\r\n        wallIndex: (target as any).wallIndex,\r\n        fixtureIndex: (target as any).fixtureIndex,\r\n        floorData: this.floorData\r\n      });\r\n      return;\r\n    }\r\n\r\n    // Ensure vmConfig is always an array (even if empty) to avoid display issues\r\n    if (!Array.isArray(fixtureData.vmConfig)) {\r\n      fixtureData.vmConfig = [];\r\n    }\r\n\r\n    // Ensure shelfConfig is always an array (even if empty) to avoid display issues\r\n    if (!Array.isArray(fixtureData.shelfConfig)) {\r\n      fixtureData.shelfConfig = [];\r\n    }\r\n\r\n    // Create a deep clone to ensure change detection works\r\n    const clonedData = structuredClone(fixtureData);\r\n\r\n    // Ensure cloned data also has proper array structures\r\n    if (!Array.isArray(clonedData.vmConfig)) {\r\n      clonedData.vmConfig = [];\r\n    }\r\n    if (!Array.isArray(clonedData.shelfConfig)) {\r\n      clonedData.shelfConfig = [];\r\n    }\r\n\r\n    this.selectedFixture = {\r\n      fixtureId: fixtureId,\r\n      fixtureType: fixtureType,\r\n      wallIndex: (target as any).wallIndex,\r\n      fixtureIndex: (target as any).fixtureIndex,\r\n    };\r\n\r\n    // Check if this fixture has replaceResponseData (for before/after comparison)\r\n    const store = this.findReplaceData?.stores?.find(\r\n      (s: Store) => s.storeName === this.selectedStore?.storeName\r\n    );\r\n\r\n    // If this fixture matches the findResponseData and has replaceResponseData,\r\n    // restore the original fixture data for before/after comparison\r\n    if (store?.findResponseData === fixtureId && store?.replaceResponseData) {\r\n      // Restore originalFixtureData from the map (persists even when clicking other fixtures)\r\n      const storedOriginal = this.originalFixturesMap.get(fixtureId);\r\n      if (storedOriginal) {\r\n        this.originalFixtureData = structuredClone(storedOriginal);\r\n        // Ensure original data has proper array structures\r\n        if (!Array.isArray(this.originalFixtureData.vmConfig)) {\r\n          this.originalFixtureData.vmConfig = [];\r\n        }\r\n        if (!Array.isArray(this.originalFixtureData.shelfConfig)) {\r\n          this.originalFixtureData.shelfConfig = [];\r\n        }\r\n      } else {\r\n        // If not in map (shouldn't happen if applyStoredResponseData ran), \r\n        // use current fixture as fallback\r\n        this.originalFixtureData = structuredClone(clonedData);\r\n        if (!Array.isArray(this.originalFixtureData.vmConfig)) {\r\n          this.originalFixtureData.vmConfig = [];\r\n        }\r\n        if (!Array.isArray(this.originalFixtureData.shelfConfig)) {\r\n          this.originalFixtureData.shelfConfig = [];\r\n        }\r\n      }\r\n    } else {\r\n      // No replace data for this fixture, clear original\r\n      this.originalFixtureData = null;\r\n    }\r\n\r\n    // Set selected fixture data (this is the \"after\" data with replaceResponseData applied)\r\n    // For fixtures with replaceResponseData, ensure all original properties are preserved\r\n    if (store?.findResponseData === fixtureId && store?.replaceResponseData) {\r\n      const storedOriginal = this.originalFixturesMap.get(fixtureId);\r\n      if (storedOriginal) {\r\n        // Merge: start with original to preserve all base properties, then apply updates\r\n        this.selectedFixtureData = {\r\n          ...storedOriginal,  // Preserve all original properties (fixtureType, header, footer, etc.)\r\n          ...clonedData,      // Apply updated data (which has replaceResponseData applied)\r\n          // Explicitly ensure arrays are correct\r\n          vmConfig: Array.isArray(clonedData.vmConfig) ? clonedData.vmConfig : (storedOriginal.vmConfig || []),\r\n          shelfConfig: Array.isArray(clonedData.shelfConfig) ? clonedData.shelfConfig : (storedOriginal.shelfConfig || [])\r\n        };\r\n      } else {\r\n        this.selectedFixtureData = clonedData;\r\n      }\r\n    } else {\r\n      this.selectedFixtureData = clonedData;\r\n    }\r\n\r\n    // Don't highlight on click - keep highlight fixed on the fixture with findResponseData\r\n    // The highlight is set when the planogram loads and should remain fixed\r\n\r\n    // Open offcanvas with before/after comparison\r\n    this.openFixtureOffcanvas();\r\n  }\r\n\r\n  openFixtureOffcanvas(): void {\r\n    // Use wider offcanvas when showing before/after comparison\r\n    const hasBeforeAfter = !!this.originalFixtureData;\r\n    const panelClass = hasBeforeAfter\r\n      ? 'fixture-before-after-offcanvas-wide'\r\n      : 'fixture-before-after-offcanvas';\r\n\r\n    const offcanvasRef = this.offcanvasService.open(FixtureBeforeAfterComponent, {\r\n      position: 'end',\r\n      panelClass: panelClass,\r\n      backdrop: true,\r\n      backdropClass: 'offcanvas-backdrop'\r\n    });\r\n\r\n    offcanvasRef.componentInstance.selectedFixtureData = this.selectedFixtureData;\r\n    offcanvasRef.componentInstance.originalFixtureData = this.originalFixtureData;\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    if (this.previewCanvas) {\r\n      this.previewCanvas.dispose();\r\n    }\r\n  }\r\n}\r\n","<div class=\"review-replace-container\">\r\n    <div class=\"row g-0 h-100\">\r\n        <!-- Left Sidebar: Store List -->\r\n        <div class=\"col-3 sidebar-container\">\r\n            <div class=\"sidebar-content\">\r\n                <!-- Header Section -->\r\n                <div class=\"header-section\">\r\n                    <div class=\"all-stores-box\">\r\n                        <p class=\"all-stores-text\">All stores</p>\r\n                    </div>\r\n                    <button class=\"download-btn\" (click)=\"onDownload()\" aria-label=\"Download\">\r\n                        <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path d=\"M17.5 12.5V13.5C17.5 14.9001 17.5 15.6002 17.2275 16.135C16.9878 16.6054 16.6054 16.9878 16.135 17.2275C15.6002 17.5 14.9001 17.5 13.5 17.5H6.5C5.09987 17.5 4.3998 17.5 3.86502 17.2275C3.39462 16.9878 3.01217 16.6054 2.77248 16.135C2.5 15.6002 2.5 14.9001 2.5 13.5V12.5M14.1667 8.33333L10 12.5M10 12.5L5.83333 8.33333M10 12.5V2.5\" stroke=\"#344054\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                        </svg>\r\n                    </button>\r\n                </div>\r\n\r\n                <!-- Select All Section -->\r\n                <div class=\"select-all-section\">\r\n                    <div class=\"form-check\">\r\n                        <input \r\n                            class=\"form-check-input\" \r\n                            type=\"checkbox\" \r\n                            id=\"selectAll\"\r\n                            [checked]=\"isAllSelected()\"\r\n                            (change)=\"onSelectAll($any($event.target).checked)\">\r\n                        <label class=\"form-check-label select-all-label\" for=\"selectAll\">\r\n                            Select all ({{ filteredStores.length }})\r\n                        </label>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Search and Filter Section -->\r\n                <div class=\"search-filter-section\">\r\n                    <div class=\"search-input-wrapper\">\r\n                        <svg class=\"search-icon\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path d=\"M17.5 17.5L13.875 13.875M15.8333 9.16667C15.8333 12.8486 12.8486 15.8333 9.16667 15.8333C5.48477 15.8333 2.5 12.8486 2.5 9.16667C2.5 5.48477 5.48477 2.5 9.16667 2.5C12.8486 2.5 15.8333 5.48477 15.8333 9.16667Z\" stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                        </svg>\r\n                        <input \r\n                            type=\"text\" \r\n                            class=\"search-input\" \r\n                            placeholder=\"Search\"\r\n                            [(ngModel)]=\"searchTerm\"\r\n                            (input)=\"onSearch()\">\r\n                    </div>\r\n                    <div class=\"dropdown\" ngbDropdown>\r\n                        <button \r\n                            class=\"filter-btn\" \r\n                            [class.active]=\"hasActiveFilters()\"\r\n                            id=\"filterDropdown\" \r\n                            ngbDropdownToggle\r\n                            aria-label=\"Filter\">\r\n                            <svg width=\"19\" height=\"17\" viewBox=\"0 0 19 17\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                                <path d=\"M17.5026 0.835938H0.835938L7.5026 8.71927V14.1693L10.8359 15.8359V8.71927L17.5026 0.835938Z\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                            </svg>\r\n                            <span *ngIf=\"hasActiveFilters()\" class=\"filter-badge\">{{ selectedStatusFilters.size }}</span>\r\n                        </button>\r\n                        <div class=\"dropdown-menu filter-dropdown\" ngbDropdownMenu aria-labelledby=\"filterDropdown\">\r\n                            <div class=\"filter-dropdown-header\">\r\n                                <h6 class=\"filter-title\">Filter by Status</h6>\r\n                                <button \r\n                                    *ngIf=\"hasActiveFilters()\" \r\n                                    class=\"clear-filters-btn\" \r\n                                    (click)=\"clearFilters()\">\r\n                                    Clear\r\n                                </button>\r\n                            </div>\r\n                            <div class=\"filter-dropdown-body\">\r\n                                <div \r\n                                    *ngFor=\"let option of statusOptions\" \r\n                                    class=\"filter-option\">\r\n                                    <input \r\n                                        class=\"form-check-input\" \r\n                                        type=\"checkbox\" \r\n                                        [id]=\"'statusFilter' + option.value\"\r\n                                        [checked]=\"isStatusFilterSelected(option.value)\"\r\n                                        (change)=\"onStatusFilterChange(option.value, $event)\">\r\n                                    <label \r\n                                        [for]=\"'statusFilter' + option.value\" \r\n                                        class=\"filter-option-label\">\r\n                                        {{ option.label }}\r\n                                    </label>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Store List Container (Scrollable) -->\r\n                <div class=\"list-container\">\r\n                    <!-- Store List -->\r\n                    <div class=\"store-list\">\r\n                        <div \r\n                            *ngFor=\"let store of paginatedStores; let i = index\" \r\n                            class=\"store-item\"\r\n                            [class.selected]=\"selectedStore?.storeName === store.storeName\"\r\n                            (click)=\"onStoreSelect(store)\">\r\n                            <div class=\"store-item-content\" [class.disabled-content]=\"hasNoMatch(store)\">\r\n                                <input \r\n                                    class=\"form-check-input\" \r\n                                    type=\"checkbox\" \r\n                                    [id]=\"'store' + i\"\r\n                                    [checked]=\"store.isApproved === true\"\r\n                                    [disabled]=\"hasNoMatch(store)\"\r\n                                    (click)=\"$event.stopPropagation()\"\r\n                                    (change)=\"onStoreCheckboxChange(store, $any($event.target).checked)\">\r\n                                <label \r\n                                    class=\"store-item-text\" \r\n                                    [for]=\"'store' + i\"\r\n                                    [class.disabled]=\"hasNoMatch(store)\"\r\n                                    (click)=\"hasNoMatch(store) && $event.stopPropagation()\">\r\n                                    {{ store.storeName }}\r\n                                </label>\r\n                            </div>\r\n                            <span *ngIf=\"hasNoMatch(store)\" class=\"badge-error\">Didn't match</span>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n\r\n        <!-- Right Side: Canvas Area -->\r\n        <div class=\"col-9 canvas-area-container\">\r\n            <div class=\"canvas-wrapper\">\r\n                <!-- Header Section with Store Slider and Approve Button -->\r\n                <div class=\"canvas-header\" *ngIf=\"selectedStore && !canvasLoading\">\r\n                    <!-- Store Slider Navigation -->\r\n                    <div class=\"store-slider\">\r\n                    <div (click)=\"previousNext('previous')\" class=\"arrow\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"23\" height=\"24\" viewBox=\"0 0 23 24\" fill=\"none\">\r\n                            <path\r\n                                d=\"M14.3942 6.33329L8.72756 12L14.3942 17.6666\"\r\n                                stroke=\"#344054\"\r\n                                stroke-width=\"1.88889\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    <div\r\n                        class=\"storename\"\r\n                        [routerLink]=\"['/manage/stores/plano']\"\r\n                        [queryParams]=\"{ storeId: selectedStore.storeId }\"\r\n                    >\r\n                        <span class=\"txt me-3\">{{ selectedStore.storeName }} - Plano</span>\r\n                        <svg\r\n                            style=\"cursor: pointer\"\r\n                            xmlns=\"http://www.w3.org/2000/svg\"\r\n                            width=\"24\"\r\n                            height=\"24\"\r\n                            viewBox=\"0 0 24 24\"\r\n                            fill=\"none\"\r\n                        >\r\n                            <path\r\n                                d=\"M17.6261 12.9688V18.7819C17.6261 19.2958 17.422 19.7886 17.0586 20.152C16.6952 20.5154 16.2023 20.7195 15.6884 20.7195H5.03119C4.51728 20.7195 4.02443 20.5154 3.66104 20.152C3.29765 19.7886 3.09351 19.2958 3.09351 18.7819V8.1246C3.09351 7.6107 3.29765 7.11784 3.66104 6.75445C4.02443 6.39107 4.51728 6.18692 5.03119 6.18692H10.8442M14.7196 3.2804H20.5326M20.5326 3.2804V9.09344M20.5326 3.2804L9.87539 13.9376\"\r\n                                stroke=\"#008EDF\"\r\n                                stroke-width=\"1.93768\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    <div (click)=\"previousNext('next')\" class=\"arrow\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"23\" height=\"24\" viewBox=\"0 0 23 24\" fill=\"none\">\r\n                            <path\r\n                                d=\"M8.6059 17.6667L14.2726 12L8.6059 6.33337\"\r\n                                stroke=\"#344054\"\r\n                                stroke-width=\"1.88889\"\r\n                                stroke-linecap=\"round\"\r\n                                stroke-linejoin=\"round\"\r\n                            />\r\n                        </svg>\r\n                    </div>\r\n                    </div>\r\n                    <!-- Approve And Complete Button -->\r\n                    <button class=\"approve-complete-btn\" (click)=\"onApproveAndComplete()\" [disabled]=\"approveLoading || isApproved()\">\r\n                        {{ approveLoading ? 'Processing...' : (isApproved() ? 'Approved' : 'Approve & Complete') }}\r\n                    </button>\r\n                </div>\r\n\r\n                <!-- Canvas Container -->\r\n                <div class=\"canvas-container\" #previewCanvasContainer *ngIf=\"selectedStore\">\r\n                    <!-- Loading State - Centered on Canvas -->\r\n                    <div class=\"canvas-loading\" *ngIf=\"canvasLoading\">\r\n                        <div class=\"spinner-border text-primary\" role=\"status\">\r\n                            <span class=\"visually-hidden\">Loading...</span>\r\n                        </div>\r\n                    </div>\r\n                    <canvas #previewCanvas></canvas>\r\n                </div>\r\n\r\n                <!-- Empty State -->\r\n                <div class=\"empty-state\" *ngIf=\"!selectedStore\">\r\n                    <p>Select a store to view its planogram</p>\r\n                </div>\r\n            </div>\r\n\r\n            <!-- Pagination -->\r\n            <lib-pagination\r\n                *ngIf=\"filteredStores.length > 0\"\r\n                [itemsPerPage]=\"limit\"\r\n                [currentPage]=\"offset\"\r\n                [totalItems]=\"totalItems\"\r\n                [paginationSizes]=\"paginationSizes\"\r\n                [pageSize]=\"paginationSize()\"\r\n                (pageChange)=\"onPageChange($event)\"\r\n                (pageSizeChange)=\"onPageSizeChange($event)\">\r\n            </lib-pagination>\r\n        </div>\r\n    </div>\r\n</div>\r\n"]}