tango-app-ui-store-builder 1.0.74 → 1.0.76

package/esm2022/lib/components/plano-tools/cad-render/cad-render.component.mjs

@@ -0,0 +1,1538 @@
+import { Component, HostListener, ViewChild, } from "@angular/core";
+import * as fabric from "fabric";
+import { Subject, takeUntil } from "rxjs";
+import { TitleCasePipe } from "@angular/common";
+import * as i0 from "@angular/core";
+import * as i1 from "tango-app-ui-global";
+import * as i2 from "@angular/common";
+import * as i3 from "tango-app-ui-shared";
+import * as i4 from "@angular/forms";
+export class CadRenderComponent {
+    gs;
+    titleCase;
+    toastService;
+    canvasRef;
+    containerRef;
+    onResize() {
+        this.resizeCanvas();
+    }
+    clientId;
+    canvas;
+    zoomLevel = 1;
+    wallThickness = 30;
+    verticalMargin = (1.25 / 100) * this.toPixels(1524, "mm");
+    layoutBounds;
+    floorData;
+    rawCADDetails;
+    includeFixtures = true;
+    isAutoAlignMode = true;
+    destroy$ = new Subject();
+    constructor(gs, titleCase, toastService) {
+        this.gs = gs;
+        this.titleCase = titleCase;
+        this.toastService = toastService;
+    }
+    ngOnInit() {
+        this.gs.dataRangeValue
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(async (data) => {
+            if (data?.client) {
+                this.clientId = data?.client;
+            }
+            else {
+                let headerData = JSON.parse(localStorage.getItem("header-filters"));
+                this.clientId = headerData?.client;
+            }
+            // await this.getVmsList();
+        });
+    }
+    ngAfterViewInit() {
+        this.initCanvas();
+    }
+    get wallCount() {
+        if (!this.floorData?.layoutPolygon) {
+            return 0;
+        }
+        const wL = this.floorData?.layoutPolygon?.filter((e) => e?.elementType === "wall");
+        return wL?.length ?? 0;
+    }
+    get wFixturesCount() {
+        return [
+            ...(this.floorData?.layoutPolygon?.flatMap((e) => e?.fixtures ?? []) ?? []),
+        ].length;
+    }
+    get cFixturesCount() {
+        return [...(this.floorData?.centerFixture ?? [])].length;
+    }
+    initCanvas() {
+        this.canvas = new fabric.Canvas(this.canvasRef.nativeElement);
+        this.setupZoomHandlers();
+        this.resizeCanvas();
+    }
+    resizeCanvas() {
+        const container = this.containerRef.nativeElement;
+        this.canvas.setDimensions({
+            width: container.clientWidth - 8,
+            height: container.clientHeight - 75,
+        });
+        this.canvas.requestRenderAll();
+    }
+    setupZoomHandlers() {
+        this.canvas.on("mouse:wheel", (opt) => {
+            const e = opt.e;
+            if (e.ctrlKey || e.metaKey) {
+                // this.isUserInteractedWithCanvas = true;
+                const delta = e.deltaY;
+                let zoom = this.canvas.getZoom();
+                zoom *= 0.995 ** delta;
+                zoom = Math.max(0.05, Math.min(zoom, 5));
+                this.canvas.zoomToPoint({
+                    x: e.offsetX,
+                    y: e.offsetY,
+                }, zoom);
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        });
+        let isDragging = false;
+        let lastPosX = 0;
+        let lastPosY = 0;
+        this.canvas.on("mouse:down", (opt) => {
+            if (!opt.target) {
+                isDragging = true;
+                this.canvas.selection = false;
+                const e = opt.e;
+                lastPosX = e.clientX;
+                lastPosY = e.clientY;
+            }
+        });
+        this.canvas.on("mouse:move", (opt) => {
+            if (isDragging && this.canvas.viewportTransform) {
+                // this.isUserInteractedWithCanvas = true;
+                const e = opt.e;
+                const vpt = this.canvas.viewportTransform;
+                vpt[4] += e.clientX - lastPosX;
+                vpt[5] += e.clientY - lastPosY;
+                this.canvas.requestRenderAll();
+                lastPosX = e.clientX;
+                lastPosY = e.clientY;
+            }
+        });
+        this.canvas.on("mouse:up", () => {
+            isDragging = false;
+            this.canvas.selection = true;
+        });
+    }
+    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));
+    }
+    fromPixels(pixels, unit, dpi = 2.8) {
+        let value;
+        // pixels = pixels >= this.wallThickness ? pixels - this.wallThickness : this.wallThickness;
+        if (unit === "mm") {
+            value = (pixels / dpi) * 25.4;
+        }
+        else if (unit === "ft") {
+            value = pixels / (12 * dpi);
+        }
+        else {
+            throw new Error("Unsupported unit. Use 'mm' or 'ft'.");
+        }
+        return Number(value.toFixed(4));
+    }
+    onClickRenderPlano() {
+        const rawJson = JSON.parse(this.rawCADDetails);
+        console.log("@@ ~ rawJson:", rawJson);
+        this.floorData = this.processRawCADDetails(rawJson);
+        console.log("@@ ~ floorData:", this.floorData);
+        this.drawInitialContent();
+    }
+    processRawCADDetails(rawJson) {
+        try {
+            let floor;
+            if (!rawJson?.data?.layoutPolygon) {
+                this.toastService.getErrorToast("layoutPolygon not found in CAD data");
+                return null;
+            }
+            floor = {
+                layoutPolygon: transformWallData(rawJson.data.layoutPolygon),
+                storeName: "CAD Store",
+                storeId: "CAD Store",
+                floorName: "Floor 1",
+                floorNumber: 1,
+                planoProgress: 0,
+                isEdited: false,
+                cadLayout: true,
+                isPlanoApproved: false,
+                status: "draft",
+                centerFixture: rawJson.data?.centerFixture?.map((f) => transformFixtureData(f)),
+            };
+            return floor;
+        }
+        catch (error) {
+            console.log("@@ ~ processRawCADDetails [ERR]:", error);
+            return null;
+        }
+        function transformWallData(cadRes) {
+            return cadRes.map((w) => {
+                return {
+                    elementType: w?.elementType ?? "wall",
+                    distance: w?.distance ?? 16,
+                    elementNumber: w?.elementNumber ?? 0,
+                    unit: w?.unit ?? "ft",
+                    direction: w?.direction ?? "right",
+                    angle: w?.angle ?? 0,
+                    relativePosition: w?.relativePosition,
+                    fixtures: w.fixtures?.map((f) => transformFixtureData(f)),
+                };
+            });
+        }
+        function transformFixtureData(data) {
+            const f = data;
+            function normalizeCadText(value) {
+                if (typeof value !== "string")
+                    return value;
+                return value.replace(/^\\[^;]+;/, "").trim();
+            }
+            return {
+                fixtureName: normalizeCadText(f?.header?.label ?? ""),
+                relativePosition: f?.relativePosition,
+                fixtureType: f?.associatedElementType,
+                header: {
+                    ...f?.header,
+                    label: normalizeCadText(f?.header?.label ?? ""),
+                },
+                footer: f?.footer,
+                fixtureWidth: f?.fixtureWidth,
+                fixtureLength: f?.fixtureLength,
+                fixtureNumber: f?.fixtureNumber,
+                templateGroupName: f?.templateGroupName ?? f?.header?.label,
+                fixtureCategory: f?.fixtureCategory,
+                fixtureCapacity: f?.fixtureCapacity,
+                associatedElementNumber: data?.wallNumber,
+                associatedElementFixtureNumber: data.fixtureNumber,
+                associatedElementType: f?.associatedElementType === "wall" ? "wall" : undefined,
+                productBrandName: Array.isArray(f?.productBrandName)
+                    ? f?.productBrandName?.map(normalizeCadText)
+                    : normalizeCadText(f?.productBrandName),
+                shelfConfig: f?.shelfConfig ?? [],
+                fixtureHeight: {
+                    value: 0,
+                    unit: "mm",
+                },
+                fixtureStaticLength: {
+                    value: 1524,
+                    unit: "mm",
+                },
+                fixtureStaticWidth: {
+                    value: 1220,
+                    unit: "mm",
+                },
+                productResolutionLevel: "L3",
+                isBodyEnabled: true,
+                isMerchEdited: false,
+                isVmEdited: false,
+            };
+        }
+    }
+    async drawInitialContent() {
+        if (!this.floorData)
+            return;
+        this.canvas.clear();
+        this.reorderFixture(this.floorData);
+        await this.drawLayoutElements();
+        setTimeout(() => {
+            this.resizeCanvas();
+            this.fitCanvasToLayoutAnimated();
+        }, 300);
+    }
+    reorderFixture(floorData) {
+        // Walls
+        floorData.layoutPolygon.forEach((element) => {
+            if (element.elementType === "wall") {
+                let wallAssociatedIndex = 1;
+                element.fixtures.forEach((fixture) => {
+                    fixture.associatedElementType = "wall";
+                    fixture.associatedElementNumber = element.elementNumber;
+                    fixture.fixtureType = "wall";
+                    if (!fixture.ghost) {
+                        // fixture.fixtureNumber = fixtureNumber++;
+                        fixture.associatedElementFixtureNumber = wallAssociatedIndex++;
+                    }
+                    else {
+                        fixture.fixtureNumber = null;
+                        fixture.associatedElementFixtureNumber = null;
+                    }
+                });
+            }
+        });
+        // Center floor fixtures
+        let floorAssociatedIndex = 1;
+        floorData.centerFixture.forEach((fixture) => {
+            fixture.fixtureType = "floor";
+            if (!fixture.ghost) {
+                // fixture.fixtureNumber = fixtureNumber++;
+                fixture.associatedElementFixtureNumber = floorAssociatedIndex++;
+            }
+            else {
+                fixture.fixtureNumber = null;
+                fixture.associatedElementFixtureNumber = null;
+            }
+        });
+    }
+    getFullLayoutBounds() {
+        const objects = this.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) {
+            const rect = obj.getBoundingRect();
+            minX = Math.min(minX, rect.left);
+            minY = Math.min(minY, rect.top);
+            maxX = Math.max(maxX, rect.left + rect.width);
+            maxY = Math.max(maxY, rect.top + rect.height);
+        }
+        return {
+            left: minX,
+            top: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        };
+    }
+    fitCanvasToLayoutAnimated(duration = 400) {
+        if (!this.canvas)
+            return;
+        const bounds = this.getFullLayoutBounds();
+        if (!bounds.width || !bounds.height)
+            return;
+        const canvasW = this.canvas.getWidth();
+        const canvasH = this.canvas.getHeight();
+        // Final zoom to fit (with padding)
+        const scaleX = canvasW / bounds.width;
+        const scaleY = canvasH / bounds.height;
+        const targetZoom = Math.min(scaleX, scaleY) * 0.9; // padding 10%
+        // Desired viewport offset to center layout
+        const targetVpt = [
+            ...(this.canvas.viewportTransform || [1, 0, 0, 1, 0, 0]),
+        ];
+        targetVpt[0] = targetZoom; // scaleX
+        targetVpt[3] = targetZoom; // scaleY
+        const extraTopPaddingPx = 24;
+        targetVpt[4] = canvasW / 2 - (bounds.left + bounds.width / 2) * targetZoom; // center X
+        targetVpt[5] =
+            canvasH / 2 -
+                (bounds.top + bounds.height / 2) * targetZoom +
+                extraTopPaddingPx; // center Y + extra top padding
+        // Current viewport (starting point of animation)
+        const startVpt = [...this.canvas.viewportTransform];
+        fabric.util.animate({
+            startValue: 0,
+            endValue: 1,
+            duration,
+            easing: fabric.util.ease.easeOutCubic,
+            onChange: (value) => {
+                const vpt = this.canvas.viewportTransform;
+                // Interpolate matrix values
+                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;
+                this.canvas.requestRenderAll();
+            },
+        });
+    }
+    async drawLayoutElements() {
+        for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {
+            const element = this.floorData.layoutPolygon[index];
+            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;
+                let width = this.toPixels(element.distance, element.unit);
+                if (width < height)
+                    width = this.wallThickness + 1;
+                await this.drawWall(this.canvas, x, y, height, width, element);
+            }
+            else if (element.elementType === "entrance") {
+                const arrowWidth = 80;
+                const arrowHeight = 75;
+                const arrowBase = 40;
+                this.drawEntrance(this.canvas, x, y, arrowWidth, arrowHeight, arrowBase, element);
+            }
+        }
+        // For cad layouts only.
+        this.layoutBounds = this.getFullLayoutBounds();
+        for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {
+            const element = this.floorData.layoutPolygon[index];
+            if (element.elementType !== "wall")
+                continue;
+            const fixtureGroups = [];
+            for (let j = 0; j < element?.fixtures?.length; j++) {
+                const fixture = element.fixtures[j];
+                const fixtureHeight = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+                const fixtureWidth = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+                let x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+                let y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+                // override the fixture position for initial cad layouts.
+                if (this.floorData?.cadLayout && this.isAutoAlignMode) {
+                    const baseX = this.toPixels(element.relativePosition.x, element.relativePosition.unit);
+                    const baseY = this.toPixels(element.relativePosition.y, element.relativePosition.unit);
+                    const startBuffer = 40;
+                    const spacing = 136;
+                    const offset = startBuffer + spacing * j;
+                    const angleRad = fabric.util.degreesToRadians(element.angle);
+                    const dirX = Math.cos(angleRad);
+                    const dirY = Math.sin(angleRad);
+                    const normalOffset = this.wallThickness;
+                    const normX = Math.cos(angleRad + Math.PI / 2) * normalOffset;
+                    const normY = Math.sin(angleRad + Math.PI / 2) * normalOffset;
+                    x = baseX + dirX * offset + normX;
+                    y = baseY + dirY * offset + normY;
+                }
+                const fixtureObj = await this.drawFixture(this.canvas, x, y, fixtureHeight, fixtureWidth, fixture);
+                fixtureGroups.push(fixtureObj);
+            }
+            for (let j = 0; j < element?.otherElements?.length; j++) {
+                const otherElement = element.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(this.canvas, x, y, a, w, h, otherElement);
+            }
+        }
+        //If CAD layout
+        if (this.floorData?.cadLayout &&
+            this.floorData?.centerFixture?.length &&
+            this.isAutoAlignMode) {
+            const fixtures = this.floorData.centerFixture;
+            const layoutPolygon = this.buildLayoutPolygonFromWalls();
+            const occupiedRects = this.getOccupiedRects();
+            const fixtureWidthPx = this.toPixels(fixtures[0].fixtureStaticWidth.value, fixtures[0].fixtureStaticWidth.unit);
+            const fixtureHeightPx = this.toPixels(fixtures[0].fixtureStaticLength.value, fixtures[0].fixtureStaticLength.unit);
+            const total = fixtures.length;
+            const maxRows = 2;
+            const rows = Math.min(maxRows, total);
+            const columns = Math.ceil(total / rows);
+            const gridWidth = columns * fixtureWidthPx;
+            const gridHeight = rows * fixtureHeightPx;
+            const bounds = this.getFullLayoutBounds();
+            const centerX = bounds.left + bounds.width / 2;
+            const centerY = bounds.top + bounds.height / 2;
+            const isInsidePolygon = (x, y) => {
+                return (this.isPointInsidePolygon({ x, y }, layoutPolygon) &&
+                    this.isPointInsidePolygon({ x: x + gridWidth, y }, layoutPolygon) &&
+                    this.isPointInsidePolygon({ x, y: y + gridHeight }, layoutPolygon) &&
+                    this.isPointInsidePolygon({ x: x + gridWidth, y: y + gridHeight }, layoutPolygon));
+            };
+            const overlapsOccupied = (x, y) => {
+                const gridRect = { x, y, w: gridWidth, h: gridHeight };
+                for (const occ of occupiedRects) {
+                    if (this.rectsOverlap(gridRect, occ)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+            const findBestPosition = (mode) => {
+                let bestScore = -Infinity;
+                let bestPos = null;
+                const step = fixtureWidthPx / 2;
+                for (let y = bounds.top; y <= bounds.top + bounds.height - gridHeight; y += step) {
+                    for (let x = bounds.left; x <= bounds.left + bounds.width - gridWidth; x += step) {
+                        if (!isInsidePolygon(x, y))
+                            continue;
+                        if (mode === "strict" && overlapsOccupied(x, y))
+                            continue;
+                        const gridRect = { x, y, w: gridWidth, h: gridHeight };
+                        const emptyMargin = this.computeEmptyMargin(gridRect, bounds, occupiedRects);
+                        const dx = centerX - (x + gridWidth / 2);
+                        const dy = centerY - (y + gridHeight / 2);
+                        const centerPenalty = dx * dx + dy * dy;
+                        const score = emptyMargin * 1000 - centerPenalty * 0.001;
+                        if (score > bestScore) {
+                            bestScore = score;
+                            bestPos = { x, y };
+                        }
+                    }
+                }
+                return bestPos;
+            };
+            let bestPos = findBestPosition("strict");
+            if (!bestPos) {
+                console.warn("Strict placement failed. Trying relaxed mode...");
+                bestPos = findBestPosition("relaxed");
+            }
+            if (!bestPos) {
+                console.warn("Relaxed placement failed. Falling back to center.");
+                bestPos = {
+                    x: centerX - gridWidth / 2,
+                    y: centerY - gridHeight / 2,
+                };
+            }
+            fixtures.forEach((fixture, index) => {
+                // N-shape traversal: col fills left-to-right, each column fills bottom row first then top row
+                const col = Math.floor(index / 2);
+                const row = index % 2 === 0 ? 1 : 0;
+                const x = bestPos.x + col * fixtureWidthPx;
+                const y = bestPos.y + row * fixtureHeightPx;
+                fixture.relativePosition.x = this.fromPixels(x, "ft");
+                fixture.relativePosition.y = this.fromPixels(y, "ft");
+            });
+        }
+        for (let i = 0; i < this.floorData?.centerFixture?.length; i++) {
+            const fixture = this.floorData.centerFixture[i];
+            const fixtureHeight = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+            const fixtureWidth = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+            const x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+            const y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+            await this.drawFixture(this.canvas, x, y, fixtureHeight, fixtureWidth, 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(this.canvas, x, y, a, w, h, otherElement);
+        }
+        return true;
+    }
+    buildLayoutPolygonFromWalls() {
+        return this.floorData.layoutPolygon
+            .filter((w) => w.elementType === "wall")
+            .map((w) => ({
+            x: this.toPixels(w.relativePosition.x, "ft"),
+            y: this.toPixels(w.relativePosition.y, "ft"),
+        }));
+    }
+    isPointInsidePolygon(point, polygon) {
+        let inside = false;
+        for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+            const xi = polygon[i].x, yi = polygon[i].y;
+            const xj = polygon[j].x, yj = polygon[j].y;
+            const intersect = yi > point.y !== yj > point.y &&
+                point.x < ((xj - xi) * (point.y - yi)) / (yj - yi) + xi;
+            if (intersect)
+                inside = !inside;
+        }
+        return inside;
+    }
+    getOccupiedRects() {
+        return this.canvas.getObjects().map((obj) => {
+            const r = obj.getBoundingRect();
+            return {
+                x: r.left,
+                y: r.top,
+                w: r.width,
+                h: r.height,
+            };
+        });
+    }
+    rectsOverlap(a, b) {
+        return !(a.x + a.w <= b.x ||
+            a.x >= b.x + b.w ||
+            a.y + a.h <= b.y ||
+            a.y >= b.y + b.h);
+    }
+    computeEmptyMargin(gridRect, bounds, occupiedRects) {
+        let minMargin = Infinity;
+        // distance to layout bounds
+        minMargin = Math.min(minMargin, gridRect.x - bounds.left, bounds.left + bounds.width - (gridRect.x + gridRect.w), gridRect.y - bounds.top, bounds.top + bounds.height - (gridRect.y + gridRect.h));
+        // distance to other objects
+        for (const occ of occupiedRects) {
+            // horizontal gap
+            if (occ.y < gridRect.y + gridRect.h && occ.y + occ.h > gridRect.y) {
+                if (occ.x + occ.w <= gridRect.x) {
+                    minMargin = Math.min(minMargin, gridRect.x - (occ.x + occ.w));
+                }
+                else if (occ.x >= gridRect.x + gridRect.w) {
+                    minMargin = Math.min(minMargin, occ.x - (gridRect.x + gridRect.w));
+                }
+            }
+            // vertical gap
+            if (occ.x < gridRect.x + gridRect.w && occ.x + occ.w > gridRect.x) {
+                if (occ.y + occ.h <= gridRect.y) {
+                    minMargin = Math.min(minMargin, gridRect.y - (occ.y + occ.h));
+                }
+                else if (occ.y >= gridRect.y + gridRect.h) {
+                    minMargin = Math.min(minMargin, occ.y - (gridRect.y + gridRect.h));
+                }
+            }
+        }
+        return minMargin;
+    }
+    getWallByNumber(elementNumber) {
+        return this.floorData?.layoutPolygon?.find((w) => w.elementType === "wall" && w.elementNumber === elementNumber);
+    }
+    drawFixtureRowLabel(text, x, y) {
+        const label = new fabric.Text(text, {
+            left: x,
+            top: y,
+            fontSize: 14,
+            fontFamily: "Inter",
+            fontWeight: "600",
+            fill: "#333",
+            originX: "left",
+            originY: "bottom",
+            selectable: false,
+            evented: false,
+        });
+        this.canvas.add(label);
+    }
+    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,
+                }));
+            }
+        }
+        let modCenterX = x;
+        let modCenterY = y;
+        let angle = elementData.angle;
+        const group = new fabric.Group(elements, {
+            left: modCenterX,
+            top: modCenterY,
+            hasControls: true,
+            lockScalingX: isVertical,
+            lockScalingY: !isVertical,
+            selectable: false,
+            evented: true,
+            hoverCursor: "pointer",
+            angle: angle,
+            subTargetCheck: true,
+        });
+        group.objType = elementData.elementType;
+        group.data = elementData;
+        canvas.add(group);
+        return group;
+    }
+    async drawFixture(canvas, x, y, height, width, fixtureData) {
+        const actualShelves = fixtureData.shelfConfig?.filter((s) => s.shelfType != "vmonly") ??
+            [];
+        let fixtureColor;
+        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 topFieldText = (fixtureData.fixtureType === "wall"
+            ? `Wall-${fixtureData.associatedElementNumber} - `
+            : "Floor - ") +
+            `Fixture ${fixtureData.associatedElementFixtureNumber
+                ? fixtureData.associatedElementFixtureNumber +
+                    (fixtureData?.fixtureNumber
+                        ? " - FX-" + fixtureData.fixtureNumber
+                        : "")
+                : "new"}`;
+        const topText = new fabric.Textbox(topFieldText, {
+            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.includes("-ft")
+            ? fixtureData.fixtureName
+            : `${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;
+                if (startIndex > fixtureData?.shelfConfig.length ||
+                    endIndex > fixtureData?.shelfConfig.length)
+                    continue;
+                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(`${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 - ${actualShelves.length} . Products -  ${fixtureData?.fixtureCapacity ?? 0} . VM - ${fixtureData?.vmConfig?.length ?? 0}`, {
+            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,
+        });
+        let angle = fixtureData?.relativePosition?.angle;
+        if (this.floorData.cadLayout && fixtureData.fixtureType === "wall") {
+            const wallData = this.getWallByNumber(fixtureData.associatedElementNumber);
+            const angleDeg = wallData?.angle || 0;
+            angle = angleDeg;
+        }
+        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,
+            hoverCursor: "pointer",
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            subTargetCheck: true,
+            angle: angle,
+        });
+        fixtureGroup.on("mousedown", (event) => {
+            const target = event.target;
+            console.log("@@ ~ target:", target);
+        });
+        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";
+        canvas.add(fixtureGroup);
+        return fixtureGroup;
+    }
+    drawEntrance(canvas, x, y, width, height, arrowWidth, elementData) {
+        const bodyWidth = width - arrowWidth;
+        const angle = elementData.angle;
+        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,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockScalingFlip: true,
+            angle: angle,
+        });
+        group.objType = elementData.elementType;
+        group.data = elementData;
+        canvas.add(group);
+    }
+    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,
+            selectable: false,
+            originX: "center",
+            originY: "center",
+        });
+        group.objType = "others";
+        group.data = element;
+        canvas.add(group);
+        if (element?.newAdded) {
+            try {
+                this.canvas.setActiveObject(group);
+                this.canvas.requestRenderAll();
+            }
+            catch { }
+            delete element.newAdded;
+        }
+        return group;
+    }
+    drawBg() {
+        const wall1 = this.floorData.layoutPolygon.find((e) => e.elementNumber === 1 && e.elementType === "wall");
+        const wall2 = this.floorData.layoutPolygon.find((e) => e.elementNumber === 2 && e.elementType === "wall");
+        const width = this.toPixels(wall1.distance, wall1.unit);
+        const height = this.toPixels(wall2.distance, wall2.unit);
+        const bg = new fabric.Rect({
+            left: this.wallThickness,
+            top: this.wallThickness,
+            width: width,
+            height: height,
+            fill: "#eaecf0",
+            selectable: false,
+            evented: false,
+        });
+        this.canvas.add(bg);
+        this.canvas.remove(bg);
+        this.canvas.insertAt(0, bg);
+        this.canvas.renderAll();
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CadRenderComponent, deps: [{ token: i1.GlobalStateService }, { token: i2.TitleCasePipe }, { token: i3.ToastService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: CadRenderComponent, selector: "cad-render", host: { listeners: { "window:resize": "onResize()" } }, providers: [TitleCasePipe], viewQueries: [{ propertyName: "canvasRef", first: true, predicate: ["canvas"], descendants: true }, { propertyName: "containerRef", first: true, predicate: ["canvasContainer"], descendants: true }], ngImport: i0, template: "<section id=\"cad-render\">\r\n    <div class=\"app-layout\">\r\n\r\n        <!-- LEFT TOOLBAR -->\r\n        <div class=\"sidebar\">\r\n            <div class=\"p-3\">\r\n                <textarea class=\"form-control\" [(ngModel)]=\"rawCADDetails\" placeholder=\"Paste the CAD extracted data\"\r\n                    rows=\"25\"></textarea>\r\n            </div>\r\n        </div>\r\n\r\n        <!-- RIGHT CANVAS PANEL -->\r\n        <div class=\"canvas-wrapper\" #canvasContainer>\r\n\r\n            <!-- Toolbar -->\r\n            <div class=\"toolbar\">\r\n\r\n                <div class=\"form-check form-switch\">\r\n                    <input [checked]=\"isAutoAlignMode\" [(ngModel)]=\"isAutoAlignMode\"\r\n                        [ngModelOptions]=\"{ standalone: true }\" style=\"cursor: pointer\" class=\"form-check-input\"\r\n                        type=\"checkbox\" [disabled]=\"!floorData\" />\r\n                    <label style=\"color: black; white-space: nowrap\" class=\"form-check-label sub ms-2\" for=\"showVMs\">\r\n                        Auto Position Fixtures\r\n                    </label>\r\n                </div>\r\n\r\n                <!-- <div class=\"d-flex gap-2\">\r\n                    <input type=\"checkbox\" class=\"form-check\" name=\"includeBG\" id=\"includeBG\"\r\n                        [(ngModel)]=\"includeFixtures\" [ngModelOptions]=\"{ standalone: true }\" [disabled]=\"!floorData\">\r\n                    <label for=\"includeBG\">Include Fixtures</label>\r\n                </div> -->\r\n\r\n                <button class=\"btn btn-primary\" type=\"button\" (click)=\"onClickRenderPlano()\">\r\n                    Render\r\n                </button>\r\n\r\n                <div class=\"ms-auto d-flex align-items-center gap-3\">\r\n                    <h4 class=\"m-0\"> {{wallCount}} - Walls |</h4>\r\n                    <h4 class=\"m-0\"> {{wFixturesCount}} - Wall Fixtures |</h4>\r\n                    <h4 class=\"m-0\"> {{cFixturesCount}} - Center Fixtures</h4>\r\n                </div>\r\n            </div>\r\n\r\n            <!-- Canvas -->\r\n            <div class=\"canvas-area\">\r\n                <canvas #canvas></canvas>\r\n            </div>\r\n\r\n        </div>\r\n\r\n\r\n    </div>\r\n</section>", styles: ["html,body{height:100%;margin:0}#cad-render .app-layout{display:flex;height:calc(100vh - 260px);overflow:hidden}#cad-render .sidebar{width:350px;min-width:350px;border-right:1px solid #ddd;background:#fafafa;overflow-y:auto}#cad-render .canvas-wrapper{flex:1;display:flex;flex-direction:column;background:#fff;padding:0;overflow:hidden}#cad-render .toolbar{flex-shrink:0;display:flex;align-items:center;gap:12px;padding:8px 12px;border-bottom:1px solid #e6e6e6;background:#fafafa}#cad-render .toggle-fixtures{display:flex;align-items:center;gap:6px;font-size:14px;-webkit-user-select:none;user-select:none}#cad-render .icon-btn{border:none;background:#f1f3f4;width:34px;height:34px;border-radius:6px;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:background .15s;padding:0}#cad-render .icon-btn:hover{background:#e2e5e7}#cad-render .icon-btn:active{background:#d1d4d6}#cad-render .icon{width:18px;height:18px;stroke:#3c3f42;stroke-width:2;fill:none}#cad-render .canvas-area{position:relative;flex:1;overflow:hidden}#cad-render .canvas-area canvas{display:block}#cad-render .id-tile{display:flex;align-items:center;padding:8px 12px;border-radius:6px}#cad-render .id-tile p{margin:0}#cad-render .id-tile.active{background-color:#ffecec;border:1px solid #ffb5b5}#cad-render .store-list{max-height:65vh;overflow:auto}\n"], dependencies: [{ kind: "directive", type: i4.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: i4.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CadRenderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "cad-render", providers: [TitleCasePipe], template: "<section id=\"cad-render\">\r\n    <div class=\"app-layout\">\r\n\r\n        <!-- LEFT TOOLBAR -->\r\n        <div class=\"sidebar\">\r\n            <div class=\"p-3\">\r\n                <textarea class=\"form-control\" [(ngModel)]=\"rawCADDetails\" placeholder=\"Paste the CAD extracted data\"\r\n                    rows=\"25\"></textarea>\r\n            </div>\r\n        </div>\r\n\r\n        <!-- RIGHT CANVAS PANEL -->\r\n        <div class=\"canvas-wrapper\" #canvasContainer>\r\n\r\n            <!-- Toolbar -->\r\n            <div class=\"toolbar\">\r\n\r\n                <div class=\"form-check form-switch\">\r\n                    <input [checked]=\"isAutoAlignMode\" [(ngModel)]=\"isAutoAlignMode\"\r\n                        [ngModelOptions]=\"{ standalone: true }\" style=\"cursor: pointer\" class=\"form-check-input\"\r\n                        type=\"checkbox\" [disabled]=\"!floorData\" />\r\n                    <label style=\"color: black; white-space: nowrap\" class=\"form-check-label sub ms-2\" for=\"showVMs\">\r\n                        Auto Position Fixtures\r\n                    </label>\r\n                </div>\r\n\r\n                <!-- <div class=\"d-flex gap-2\">\r\n                    <input type=\"checkbox\" class=\"form-check\" name=\"includeBG\" id=\"includeBG\"\r\n                        [(ngModel)]=\"includeFixtures\" [ngModelOptions]=\"{ standalone: true }\" [disabled]=\"!floorData\">\r\n                    <label for=\"includeBG\">Include Fixtures</label>\r\n                </div> -->\r\n\r\n                <button class=\"btn btn-primary\" type=\"button\" (click)=\"onClickRenderPlano()\">\r\n                    Render\r\n                </button>\r\n\r\n                <div class=\"ms-auto d-flex align-items-center gap-3\">\r\n                    <h4 class=\"m-0\"> {{wallCount}} - Walls |</h4>\r\n                    <h4 class=\"m-0\"> {{wFixturesCount}} - Wall Fixtures |</h4>\r\n                    <h4 class=\"m-0\"> {{cFixturesCount}} - Center Fixtures</h4>\r\n                </div>\r\n            </div>\r\n\r\n            <!-- Canvas -->\r\n            <div class=\"canvas-area\">\r\n                <canvas #canvas></canvas>\r\n            </div>\r\n\r\n        </div>\r\n\r\n\r\n    </div>\r\n</section>", styles: ["html,body{height:100%;margin:0}#cad-render .app-layout{display:flex;height:calc(100vh - 260px);overflow:hidden}#cad-render .sidebar{width:350px;min-width:350px;border-right:1px solid #ddd;background:#fafafa;overflow-y:auto}#cad-render .canvas-wrapper{flex:1;display:flex;flex-direction:column;background:#fff;padding:0;overflow:hidden}#cad-render .toolbar{flex-shrink:0;display:flex;align-items:center;gap:12px;padding:8px 12px;border-bottom:1px solid #e6e6e6;background:#fafafa}#cad-render .toggle-fixtures{display:flex;align-items:center;gap:6px;font-size:14px;-webkit-user-select:none;user-select:none}#cad-render .icon-btn{border:none;background:#f1f3f4;width:34px;height:34px;border-radius:6px;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:background .15s;padding:0}#cad-render .icon-btn:hover{background:#e2e5e7}#cad-render .icon-btn:active{background:#d1d4d6}#cad-render .icon{width:18px;height:18px;stroke:#3c3f42;stroke-width:2;fill:none}#cad-render .canvas-area{position:relative;flex:1;overflow:hidden}#cad-render .canvas-area canvas{display:block}#cad-render .id-tile{display:flex;align-items:center;padding:8px 12px;border-radius:6px}#cad-render .id-tile p{margin:0}#cad-render .id-tile.active{background-color:#ffecec;border:1px solid #ffb5b5}#cad-render .store-list{max-height:65vh;overflow:auto}\n"] }]
+        }], ctorParameters: () => [{ type: i1.GlobalStateService }, { type: i2.TitleCasePipe }, { type: i3.ToastService }], propDecorators: { canvasRef: [{
+                type: ViewChild,
+                args: ["canvas"]
+            }], containerRef: [{
+                type: ViewChild,
+                args: ["canvasContainer"]
+            }], onResize: [{
+                type: HostListener,
+                args: ["window:resize"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cad-render.component.js","sourceRoot":"","sources":["../../../../../../../projects/tango-store-builder/src/lib/components/plano-tools/cad-render/cad-render.component.ts","../../../../../../../projects/tango-store-builder/src/lib/components/plano-tools/cad-render/cad-render.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterViewInit,\r\n  Component,\r\n  ElementRef,\r\n  HostListener,\r\n  OnDestroy,\r\n  OnInit,\r\n  ViewChild,\r\n} from \"@angular/core\";\r\n\r\nimport * as fabric from \"fabric\";\r\n\r\nimport { Subject, takeUntil } from \"rxjs\";\r\nimport { GlobalStateService } from \"tango-app-ui-global\";\r\n\r\nimport { TitleCasePipe } from \"@angular/common\";\r\nimport { ToastService } from \"tango-app-ui-shared\";\r\n\r\n@Component({\r\n  selector: \"cad-render\",\r\n  templateUrl: \"./cad-render.component.html\",\r\n  styleUrl: \"./cad-render.component.scss\",\r\n  providers: [TitleCasePipe],\r\n})\r\nexport class CadRenderComponent implements AfterViewInit, OnDestroy, OnInit {\r\n  @ViewChild(\"canvas\") canvasRef!: ElementRef<HTMLCanvasElement>;\r\n  @ViewChild(\"canvasContainer\") containerRef!: ElementRef<HTMLDivElement>;\r\n\r\n  @HostListener(\"window:resize\")\r\n  onResize(): void {\r\n    this.resizeCanvas();\r\n  }\r\n\r\n  clientId: string;\r\n\r\n  canvas!: fabric.Canvas;\r\n  zoomLevel: number = 1;\r\n  wallThickness = 30;\r\n  verticalMargin = (1.25 / 100) * this.toPixels(1524, \"mm\");\r\n  layoutBounds: any;\r\n\r\n  floorData: any;\r\n  rawCADDetails: any;\r\n\r\n  includeFixtures: boolean = true;\r\n  isAutoAlignMode: boolean = true;\r\n\r\n  destroy$ = new Subject();\r\n\r\n  constructor(\r\n    private gs: GlobalStateService,\r\n    private titleCase: TitleCasePipe,\r\n    private toastService: ToastService,\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.gs.dataRangeValue\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe(async (data) => {\r\n        if (data?.client) {\r\n          this.clientId = data?.client;\r\n        } else {\r\n          let headerData = JSON.parse(\r\n            localStorage.getItem(\"header-filters\") as string,\r\n          );\r\n          this.clientId = headerData?.client;\r\n        }\r\n\r\n        // await this.getVmsList();\r\n      });\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.initCanvas();\r\n  }\r\n\r\n  get wallCount() {\r\n    if (!this.floorData?.layoutPolygon) {\r\n      return 0;\r\n    }\r\n\r\n    const wL = this.floorData?.layoutPolygon?.filter(\r\n      (e: any) => e?.elementType === \"wall\",\r\n    );\r\n    return wL?.length ?? 0;\r\n  }\r\n\r\n  get wFixturesCount() {\r\n    return [\r\n      ...(this.floorData?.layoutPolygon?.flatMap(\r\n        (e: any) => e?.fixtures ?? [],\r\n      ) ?? []),\r\n    ].length;\r\n  }\r\n\r\n  get cFixturesCount() {\r\n    return [...(this.floorData?.centerFixture ?? [])].length;\r\n  }\r\n\r\n  private initCanvas(): void {\r\n    this.canvas = new fabric.Canvas(this.canvasRef.nativeElement);\r\n\r\n    this.setupZoomHandlers();\r\n    this.resizeCanvas();\r\n  }\r\n\r\n  private resizeCanvas(): void {\r\n    const container = this.containerRef.nativeElement;\r\n    this.canvas.setDimensions({\r\n      width: container.clientWidth - 8,\r\n      height: container.clientHeight - 75,\r\n    });\r\n    this.canvas.requestRenderAll();\r\n  }\r\n\r\n  setupZoomHandlers(): void {\r\n    this.canvas.on(\"mouse:wheel\", (opt: fabric.TEvent<WheelEvent>) => {\r\n      const e = opt.e;\r\n\r\n      if (e.ctrlKey || e.metaKey) {\r\n        // this.isUserInteractedWithCanvas = true;\r\n        const delta = e.deltaY;\r\n        let zoom = this.canvas.getZoom();\r\n        zoom *= 0.995 ** delta;\r\n\r\n        zoom = Math.max(0.05, Math.min(zoom, 5));\r\n\r\n        this.canvas.zoomToPoint(\r\n          {\r\n            x: e.offsetX,\r\n            y: e.offsetY,\r\n          } as fabric.Point,\r\n          zoom,\r\n        );\r\n\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    this.canvas.on(\"mouse:down\", (opt: any) => {\r\n      if (!opt.target) {\r\n        isDragging = true;\r\n        this.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    this.canvas.on(\"mouse:move\", (opt: any) => {\r\n      if (isDragging && this.canvas.viewportTransform) {\r\n        // this.isUserInteractedWithCanvas = true;\r\n        const e = opt.e;\r\n        const vpt = this.canvas.viewportTransform;\r\n        vpt[4] += e.clientX - lastPosX;\r\n        vpt[5] += e.clientY - lastPosY;\r\n        this.canvas.requestRenderAll();\r\n        lastPosX = e.clientX;\r\n        lastPosY = e.clientY;\r\n      }\r\n    });\r\n\r\n    this.canvas.on(\"mouse:up\", () => {\r\n      isDragging = false;\r\n      this.canvas.selection = true;\r\n    });\r\n  }\r\n\r\n  toPixels(value: number, unit: string, dpi = 2.8) {\r\n    let pixels: number;\r\n\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\r\n    return Number(pixels.toFixed(4));\r\n  }\r\n\r\n  fromPixels(pixels: number, unit: string, dpi = 2.8): number {\r\n    let value: number;\r\n\r\n    // pixels = pixels >= this.wallThickness ? pixels - this.wallThickness : this.wallThickness;\r\n\r\n    if (unit === \"mm\") {\r\n      value = (pixels / dpi) * 25.4;\r\n    } else if (unit === \"ft\") {\r\n      value = pixels / (12 * dpi);\r\n    } else {\r\n      throw new Error(\"Unsupported unit. Use 'mm' or 'ft'.\");\r\n    }\r\n\r\n    return Number(value.toFixed(4));\r\n  }\r\n\r\n  onClickRenderPlano() {\r\n    const rawJson = JSON.parse(this.rawCADDetails);\r\n    console.log(\"@@ ~ rawJson:\", rawJson);\r\n\r\n    this.floorData = this.processRawCADDetails(rawJson);\r\n\r\n    console.log(\"@@ ~ floorData:\", this.floorData);\r\n\r\n    this.drawInitialContent();\r\n  }\r\n\r\n  processRawCADDetails(rawJson: any) {\r\n    try {\r\n      let floor;\r\n\r\n      if (!rawJson?.data?.layoutPolygon) {\r\n        this.toastService.getErrorToast(\"layoutPolygon not found in CAD data\");\r\n        return null;\r\n      }\r\n\r\n      floor = {\r\n        layoutPolygon: transformWallData(rawJson.data.layoutPolygon),\r\n        storeName: \"CAD Store\",\r\n        storeId: \"CAD Store\",\r\n        floorName: \"Floor 1\",\r\n        floorNumber: 1,\r\n        planoProgress: 0,\r\n        isEdited: false,\r\n        cadLayout: true,\r\n        isPlanoApproved: false,\r\n        status: \"draft\",\r\n        centerFixture: rawJson.data?.centerFixture?.map((f: any) =>\r\n          transformFixtureData(f),\r\n        ),\r\n      };\r\n\r\n      return floor;\r\n    } catch (error) {\r\n      console.log(\"@@ ~ processRawCADDetails [ERR]:\", error);\r\n      return null;\r\n    }\r\n\r\n    function transformWallData(cadRes: any) {\r\n      return cadRes.map((w: any) => {\r\n        return {\r\n          elementType: w?.elementType ?? \"wall\",\r\n          distance: w?.distance ?? 16,\r\n          elementNumber: w?.elementNumber ?? 0,\r\n          unit: w?.unit ?? \"ft\",\r\n          direction: w?.direction ?? \"right\",\r\n          angle: w?.angle ?? 0,\r\n          relativePosition: w?.relativePosition,\r\n          fixtures: w.fixtures?.map((f: any) => transformFixtureData(f)),\r\n        };\r\n      });\r\n    }\r\n\r\n    function transformFixtureData(data: any) {\r\n      const f = data;\r\n\r\n      function normalizeCadText(value: any) {\r\n        if (typeof value !== \"string\") return value;\r\n        return value.replace(/^\\\\[^;]+;/, \"\").trim();\r\n      }\r\n\r\n      return {\r\n        fixtureName: normalizeCadText(f?.header?.label ?? \"\"),\r\n        relativePosition: f?.relativePosition,\r\n        fixtureType: f?.associatedElementType,\r\n        header: {\r\n          ...f?.header,\r\n          label: normalizeCadText(f?.header?.label ?? \"\"),\r\n        },\r\n        footer: f?.footer,\r\n        fixtureWidth: f?.fixtureWidth,\r\n        fixtureLength: f?.fixtureLength,\r\n        fixtureNumber: f?.fixtureNumber,\r\n        templateGroupName: f?.templateGroupName ?? f?.header?.label,\r\n        fixtureCategory: f?.fixtureCategory,\r\n        fixtureCapacity: f?.fixtureCapacity,\r\n        associatedElementNumber: data?.wallNumber,\r\n        associatedElementFixtureNumber: data.fixtureNumber,\r\n        associatedElementType:\r\n          f?.associatedElementType === \"wall\" ? \"wall\" : undefined,\r\n        productBrandName: Array.isArray(f?.productBrandName)\r\n          ? f?.productBrandName?.map(normalizeCadText)\r\n          : normalizeCadText(f?.productBrandName),\r\n        shelfConfig: f?.shelfConfig ?? [],\r\n        fixtureHeight: {\r\n          value: 0,\r\n          unit: \"mm\",\r\n        },\r\n        fixtureStaticLength: {\r\n          value: 1524,\r\n          unit: \"mm\",\r\n        },\r\n        fixtureStaticWidth: {\r\n          value: 1220,\r\n          unit: \"mm\",\r\n        },\r\n        productResolutionLevel: \"L3\",\r\n        isBodyEnabled: true,\r\n        isMerchEdited: false,\r\n        isVmEdited: false,\r\n      };\r\n    }\r\n  }\r\n\r\n  async drawInitialContent(): Promise<void> {\r\n    if (!this.floorData) return;\r\n\r\n    this.canvas.clear();\r\n    this.reorderFixture(this.floorData);\r\n    await this.drawLayoutElements();\r\n\r\n    setTimeout(() => {\r\n      this.resizeCanvas();\r\n      this.fitCanvasToLayoutAnimated();\r\n    }, 300);\r\n  }\r\n\r\n  reorderFixture(floorData: any) {\r\n    // Walls\r\n    floorData.layoutPolygon.forEach((element: any) => {\r\n      if (element.elementType === \"wall\") {\r\n        let wallAssociatedIndex = 1;\r\n\r\n        element.fixtures.forEach((fixture: any) => {\r\n          fixture.associatedElementType = \"wall\";\r\n          fixture.associatedElementNumber = element.elementNumber;\r\n          fixture.fixtureType = \"wall\";\r\n\r\n          if (!fixture.ghost) {\r\n            // fixture.fixtureNumber = fixtureNumber++;\r\n            fixture.associatedElementFixtureNumber = wallAssociatedIndex++;\r\n          } else {\r\n            fixture.fixtureNumber = null;\r\n            fixture.associatedElementFixtureNumber = null;\r\n          }\r\n        });\r\n      }\r\n    });\r\n\r\n    // Center floor fixtures\r\n    let floorAssociatedIndex = 1;\r\n    floorData.centerFixture.forEach((fixture: any) => {\r\n      fixture.fixtureType = \"floor\";\r\n\r\n      if (!fixture.ghost) {\r\n        // fixture.fixtureNumber = fixtureNumber++;\r\n        fixture.associatedElementFixtureNumber = floorAssociatedIndex++;\r\n      } else {\r\n        fixture.fixtureNumber = null;\r\n        fixture.associatedElementFixtureNumber = null;\r\n      }\r\n    });\r\n  }\r\n\r\n  private getFullLayoutBounds() {\r\n    const objects = this.canvas.getObjects();\r\n    if (!objects.length) return { left: 0, top: 0, width: 0, height: 0 };\r\n\r\n    let minX = Infinity,\r\n      minY = Infinity,\r\n      maxX = -Infinity,\r\n      maxY = -Infinity;\r\n\r\n    for (const obj of objects) {\r\n      const rect = obj.getBoundingRect();\r\n      minX = Math.min(minX, rect.left);\r\n      minY = Math.min(minY, rect.top);\r\n      maxX = Math.max(maxX, rect.left + rect.width);\r\n      maxY = Math.max(maxY, rect.top + rect.height);\r\n    }\r\n\r\n    return {\r\n      left: minX,\r\n      top: minY,\r\n      width: maxX - minX,\r\n      height: maxY - minY,\r\n    };\r\n  }\r\n\r\n  private fitCanvasToLayoutAnimated(duration = 400) {\r\n    if (!this.canvas) return;\r\n\r\n    const bounds = this.getFullLayoutBounds();\r\n    if (!bounds.width || !bounds.height) return;\r\n\r\n    const canvasW = this.canvas.getWidth();\r\n    const canvasH = this.canvas.getHeight();\r\n\r\n    // Final zoom to fit (with padding)\r\n    const scaleX = canvasW / bounds.width;\r\n    const scaleY = canvasH / bounds.height;\r\n    const targetZoom = Math.min(scaleX, scaleY) * 0.9; // padding 10%\r\n\r\n    // Desired viewport offset to center layout\r\n    const targetVpt = [\r\n      ...(this.canvas.viewportTransform || [1, 0, 0, 1, 0, 0]),\r\n    ] as fabric.TMat2D;\r\n\r\n    targetVpt[0] = targetZoom; // scaleX\r\n    targetVpt[3] = targetZoom; // scaleY\r\n\r\n    const extraTopPaddingPx = 24;\r\n    targetVpt[4] = canvasW / 2 - (bounds.left + bounds.width / 2) * targetZoom; // center X\r\n    targetVpt[5] =\r\n      canvasH / 2 -\r\n      (bounds.top + bounds.height / 2) * targetZoom +\r\n      extraTopPaddingPx; // center Y + extra top padding\r\n\r\n    // Current viewport (starting point of animation)\r\n    const startVpt = [...this.canvas.viewportTransform!] as fabric.TMat2D;\r\n\r\n    fabric.util.animate({\r\n      startValue: 0,\r\n      endValue: 1,\r\n      duration,\r\n      easing: fabric.util.ease.easeOutCubic,\r\n      onChange: (value: number) => {\r\n        const vpt = this.canvas.viewportTransform!;\r\n\r\n        // Interpolate matrix values\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\r\n        this.canvas.requestRenderAll();\r\n      },\r\n    });\r\n  }\r\n\r\n  async drawLayoutElements() {\r\n    for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {\r\n      const element = this.floorData.layoutPolygon[index];\r\n\r\n      element.relativePosition ??= {\r\n        x: 0,\r\n        y: 0,\r\n        unit: \"ft\",\r\n      };\r\n\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        let width = this.toPixels(element.distance, element.unit);\r\n        if (width < height) width = this.wallThickness + 1;\r\n        await this.drawWall(this.canvas, x, y, height, width, element);\r\n      } else if (element.elementType === \"entrance\") {\r\n        const arrowWidth = 80;\r\n        const arrowHeight = 75;\r\n        const arrowBase = 40;\r\n        this.drawEntrance(\r\n          this.canvas,\r\n          x,\r\n          y,\r\n          arrowWidth,\r\n          arrowHeight,\r\n          arrowBase,\r\n          element,\r\n        );\r\n      }\r\n    }\r\n\r\n    // For cad layouts only.\r\n    this.layoutBounds = this.getFullLayoutBounds();\r\n\r\n    for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {\r\n      const element = this.floorData.layoutPolygon[index];\r\n      if (element.elementType !== \"wall\") continue;\r\n\r\n      const fixtureGroups: fabric.Group[] = [];\r\n\r\n      for (let j = 0; j < element?.fixtures?.length; j++) {\r\n        const fixture = element.fixtures[j];\r\n\r\n        const fixtureHeight = this.toPixels(\r\n          fixture.fixtureStaticLength.value,\r\n          fixture.fixtureStaticLength.unit,\r\n        );\r\n        const fixtureWidth = this.toPixels(\r\n          fixture.fixtureStaticWidth.value,\r\n          fixture.fixtureStaticWidth.unit,\r\n        );\r\n\r\n        let x = this.toPixels(\r\n          fixture.relativePosition.x,\r\n          fixture.relativePosition.unit,\r\n        );\r\n        let y = this.toPixels(\r\n          fixture.relativePosition.y,\r\n          fixture.relativePosition.unit,\r\n        );\r\n\r\n        // override the fixture position for initial cad layouts.\r\n        if (this.floorData?.cadLayout && this.isAutoAlignMode) {\r\n          const baseX = this.toPixels(\r\n            element.relativePosition.x,\r\n            element.relativePosition.unit,\r\n          );\r\n\r\n          const baseY = this.toPixels(\r\n            element.relativePosition.y,\r\n            element.relativePosition.unit,\r\n          );\r\n          const startBuffer = 40;\r\n          const spacing = 136;\r\n          const offset = startBuffer + spacing * j;\r\n\r\n          const angleRad = fabric.util.degreesToRadians(element.angle);\r\n\r\n          const dirX = Math.cos(angleRad);\r\n          const dirY = Math.sin(angleRad);\r\n\r\n          const normalOffset = this.wallThickness;\r\n\r\n          const normX = Math.cos(angleRad + Math.PI / 2) * normalOffset;\r\n          const normY = Math.sin(angleRad + Math.PI / 2) * normalOffset;\r\n\r\n          x = baseX + dirX * offset + normX;\r\n          y = baseY + dirY * offset + normY;\r\n        }\r\n\r\n        const fixtureObj = await this.drawFixture(\r\n          this.canvas,\r\n          x,\r\n          y,\r\n          fixtureHeight,\r\n          fixtureWidth,\r\n          fixture,\r\n        );\r\n        fixtureGroups.push(fixtureObj as fabric.Group);\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 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(\r\n          otherElement.fixtureStaticLength.value,\r\n          otherElement.fixtureStaticLength.unit,\r\n        );\r\n        const w = this.toPixels(\r\n          otherElement.fixtureStaticWidth.value,\r\n          otherElement.fixtureStaticWidth.unit,\r\n        );\r\n\r\n        this.drawOtherElementsWithLabel(\r\n          this.canvas,\r\n          x,\r\n          y,\r\n          a,\r\n          w,\r\n          h,\r\n          otherElement,\r\n        );\r\n      }\r\n    }\r\n\r\n    //If CAD layout\r\n    if (\r\n      this.floorData?.cadLayout &&\r\n      this.floorData?.centerFixture?.length &&\r\n      this.isAutoAlignMode\r\n    ) {\r\n      const fixtures = this.floorData.centerFixture;\r\n\r\n      const layoutPolygon = this.buildLayoutPolygonFromWalls();\r\n      const occupiedRects = this.getOccupiedRects();\r\n\r\n      const fixtureWidthPx = this.toPixels(\r\n        fixtures[0].fixtureStaticWidth.value,\r\n        fixtures[0].fixtureStaticWidth.unit,\r\n      );\r\n\r\n      const fixtureHeightPx = this.toPixels(\r\n        fixtures[0].fixtureStaticLength.value,\r\n        fixtures[0].fixtureStaticLength.unit,\r\n      );\r\n\r\n      const total = fixtures.length;\r\n\r\n      const maxRows = 2;\r\n      const rows = Math.min(maxRows, total);\r\n      const columns = Math.ceil(total / rows);\r\n\r\n      const gridWidth = columns * fixtureWidthPx;\r\n      const gridHeight = rows * fixtureHeightPx;\r\n\r\n      const bounds = this.getFullLayoutBounds();\r\n      const centerX = bounds.left + bounds.width / 2;\r\n      const centerY = bounds.top + bounds.height / 2;\r\n\r\n      const isInsidePolygon = (x: number, y: number) => {\r\n        return (\r\n          this.isPointInsidePolygon({ x, y }, layoutPolygon) &&\r\n          this.isPointInsidePolygon({ x: x + gridWidth, y }, layoutPolygon) &&\r\n          this.isPointInsidePolygon({ x, y: y + gridHeight }, layoutPolygon) &&\r\n          this.isPointInsidePolygon(\r\n            { x: x + gridWidth, y: y + gridHeight },\r\n            layoutPolygon,\r\n          )\r\n        );\r\n      };\r\n\r\n      const overlapsOccupied = (x: number, y: number) => {\r\n        const gridRect = { x, y, w: gridWidth, h: gridHeight };\r\n\r\n        for (const occ of occupiedRects) {\r\n          if (this.rectsOverlap(gridRect, occ)) {\r\n            return true;\r\n          }\r\n        }\r\n\r\n        return false;\r\n      };\r\n\r\n      const findBestPosition = (mode: \"strict\" | \"relaxed\") => {\r\n        let bestScore = -Infinity;\r\n        let bestPos: { x: number; y: number } | null = null;\r\n\r\n        const step = fixtureWidthPx / 2;\r\n\r\n        for (\r\n          let y = bounds.top;\r\n          y <= bounds.top + bounds.height - gridHeight;\r\n          y += step\r\n        ) {\r\n          for (\r\n            let x = bounds.left;\r\n            x <= bounds.left + bounds.width - gridWidth;\r\n            x += step\r\n          ) {\r\n            if (!isInsidePolygon(x, y)) continue;\r\n\r\n            if (mode === \"strict\" && overlapsOccupied(x, y)) continue;\r\n\r\n            const gridRect = { x, y, w: gridWidth, h: gridHeight };\r\n\r\n            const emptyMargin = this.computeEmptyMargin(\r\n              gridRect,\r\n              bounds,\r\n              occupiedRects,\r\n            );\r\n\r\n            const dx = centerX - (x + gridWidth / 2);\r\n            const dy = centerY - (y + gridHeight / 2);\r\n            const centerPenalty = dx * dx + dy * dy;\r\n\r\n            const score = emptyMargin * 1000 - centerPenalty * 0.001;\r\n\r\n            if (score > bestScore) {\r\n              bestScore = score;\r\n              bestPos = { x, y };\r\n            }\r\n          }\r\n        }\r\n\r\n        return bestPos;\r\n      };\r\n\r\n      let bestPos = findBestPosition(\"strict\");\r\n\r\n      if (!bestPos) {\r\n        console.warn(\"Strict placement failed. Trying relaxed mode...\");\r\n        bestPos = findBestPosition(\"relaxed\");\r\n      }\r\n\r\n      if (!bestPos) {\r\n        console.warn(\"Relaxed placement failed. Falling back to center.\");\r\n        bestPos = {\r\n          x: centerX - gridWidth / 2,\r\n          y: centerY - gridHeight / 2,\r\n        };\r\n      }\r\n\r\n      fixtures.forEach((fixture: any, index: number) => {\r\n        // N-shape traversal: col fills left-to-right, each column fills bottom row first then top row\r\n        const col = Math.floor(index / 2);\r\n        const row = index % 2 === 0 ? 1 : 0;\r\n\r\n        const x = bestPos!.x + col * fixtureWidthPx;\r\n        const y = bestPos!.y + row * fixtureHeightPx;\r\n\r\n        fixture.relativePosition.x = this.fromPixels(x, \"ft\");\r\n        fixture.relativePosition.y = this.fromPixels(y, \"ft\");\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\r\n      const fixtureHeight = this.toPixels(\r\n        fixture.fixtureStaticLength.value,\r\n        fixture.fixtureStaticLength.unit,\r\n      );\r\n\r\n      const fixtureWidth = this.toPixels(\r\n        fixture.fixtureStaticWidth.value,\r\n        fixture.fixtureStaticWidth.unit,\r\n      );\r\n\r\n      const x = this.toPixels(\r\n        fixture.relativePosition.x,\r\n        fixture.relativePosition.unit,\r\n      );\r\n\r\n      const y = this.toPixels(\r\n        fixture.relativePosition.y,\r\n        fixture.relativePosition.unit,\r\n      );\r\n\r\n      await this.drawFixture(\r\n        this.canvas,\r\n        x,\r\n        y,\r\n        fixtureHeight,\r\n        fixtureWidth,\r\n        fixture,\r\n      );\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(\r\n        otherElement.fixtureStaticLength.value,\r\n        otherElement.fixtureStaticLength.unit,\r\n      );\r\n      const w = this.toPixels(\r\n        otherElement.fixtureStaticWidth.value,\r\n        otherElement.fixtureStaticWidth.unit,\r\n      );\r\n\r\n      this.drawOtherElementsWithLabel(this.canvas, x, y, a, w, h, otherElement);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  private buildLayoutPolygonFromWalls() {\r\n    return this.floorData.layoutPolygon\r\n      .filter((w: any) => w.elementType === \"wall\")\r\n      .map((w: any) => ({\r\n        x: this.toPixels(w.relativePosition.x, \"ft\"),\r\n        y: this.toPixels(w.relativePosition.y, \"ft\"),\r\n      }));\r\n  }\r\n\r\n  private isPointInsidePolygon(\r\n    point: { x: number; y: number },\r\n    polygon: { x: number; y: number }[],\r\n  ): boolean {\r\n    let inside = false;\r\n\r\n    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {\r\n      const xi = polygon[i].x,\r\n        yi = polygon[i].y;\r\n      const xj = polygon[j].x,\r\n        yj = polygon[j].y;\r\n\r\n      const intersect =\r\n        yi > point.y !== yj > point.y &&\r\n        point.x < ((xj - xi) * (point.y - yi)) / (yj - yi) + xi;\r\n\r\n      if (intersect) inside = !inside;\r\n    }\r\n\r\n    return inside;\r\n  }\r\n\r\n  private getOccupiedRects(): { x: number; y: number; w: number; h: number }[] {\r\n    return this.canvas.getObjects().map((obj) => {\r\n      const r = obj.getBoundingRect();\r\n      return {\r\n        x: r.left,\r\n        y: r.top,\r\n        w: r.width,\r\n        h: r.height,\r\n      };\r\n    });\r\n  }\r\n\r\n  private rectsOverlap(\r\n    a: { x: number; y: number; w: number; h: number },\r\n    b: { x: number; y: number; w: number; h: number },\r\n  ): boolean {\r\n    return !(\r\n      a.x + a.w <= b.x ||\r\n      a.x >= b.x + b.w ||\r\n      a.y + a.h <= b.y ||\r\n      a.y >= b.y + b.h\r\n    );\r\n  }\r\n\r\n  private computeEmptyMargin(\r\n    gridRect: { x: number; y: number; w: number; h: number },\r\n    bounds: { left: number; top: number; width: number; height: number },\r\n    occupiedRects: { x: number; y: number; w: number; h: number }[],\r\n  ): number {\r\n    let minMargin = Infinity;\r\n\r\n    // distance to layout bounds\r\n    minMargin = Math.min(\r\n      minMargin,\r\n      gridRect.x - bounds.left,\r\n      bounds.left + bounds.width - (gridRect.x + gridRect.w),\r\n      gridRect.y - bounds.top,\r\n      bounds.top + bounds.height - (gridRect.y + gridRect.h),\r\n    );\r\n\r\n    // distance to other objects\r\n    for (const occ of occupiedRects) {\r\n      // horizontal gap\r\n      if (occ.y < gridRect.y + gridRect.h && occ.y + occ.h > gridRect.y) {\r\n        if (occ.x + occ.w <= gridRect.x) {\r\n          minMargin = Math.min(minMargin, gridRect.x - (occ.x + occ.w));\r\n        } else if (occ.x >= gridRect.x + gridRect.w) {\r\n          minMargin = Math.min(minMargin, occ.x - (gridRect.x + gridRect.w));\r\n        }\r\n      }\r\n\r\n      // vertical gap\r\n      if (occ.x < gridRect.x + gridRect.w && occ.x + occ.w > gridRect.x) {\r\n        if (occ.y + occ.h <= gridRect.y) {\r\n          minMargin = Math.min(minMargin, gridRect.y - (occ.y + occ.h));\r\n        } else if (occ.y >= gridRect.y + gridRect.h) {\r\n          minMargin = Math.min(minMargin, occ.y - (gridRect.y + gridRect.h));\r\n        }\r\n      }\r\n    }\r\n\r\n    return minMargin;\r\n  }\r\n\r\n  private getWallByNumber(elementNumber: number): any | undefined {\r\n    return this.floorData?.layoutPolygon?.find(\r\n      (w: any) => w.elementType === \"wall\" && w.elementNumber === elementNumber,\r\n    );\r\n  }\r\n\r\n  drawFixtureRowLabel(text: string, x: number, y: number) {\r\n    const label = new fabric.Text(text, {\r\n      left: x,\r\n      top: y,\r\n      fontSize: 14,\r\n      fontFamily: \"Inter\",\r\n      fontWeight: \"600\",\r\n      fill: \"#333\",\r\n      originX: \"left\",\r\n      originY: \"bottom\",\r\n      selectable: false,\r\n      evented: false,\r\n    });\r\n\r\n    this.canvas.add(label);\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)} ${\r\n      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    let modCenterX = x;\r\n    let modCenterY = y;\r\n    let angle = elementData.angle;\r\n\r\n    const group = new fabric.Group(elements, {\r\n      left: modCenterX,\r\n      top: modCenterY,\r\n      hasControls: true,\r\n      lockScalingX: isVertical,\r\n      lockScalingY: !isVertical,\r\n      selectable: false,\r\n      evented: true,\r\n      hoverCursor: \"pointer\",\r\n      angle: 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    canvas.add(group);\r\n\r\n    return 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    const actualShelves =\r\n      fixtureData.shelfConfig?.filter((s: any) => s.shelfType != \"vmonly\") ??\r\n      [];\r\n\r\n    let fixtureColor: any;\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 topFieldText =\r\n      (fixtureData.fixtureType === \"wall\"\r\n        ? `Wall-${fixtureData.associatedElementNumber} - `\r\n        : \"Floor - \") +\r\n      `Fixture ${\r\n        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    const topText = new fabric.Textbox(topFieldText, {\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    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} ${\r\n         topX + topWidth - radius\r\n       } ${secondBoxY + innerBoxHeight} \r\n       L ${topX + radius} ${secondBoxY + innerBoxHeight} \r\n       Q ${topX} ${secondBoxY + innerBoxHeight} ${topX} ${\r\n         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.includes(\"-ft\")\r\n      ? fixtureData.fixtureName\r\n      : `${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} ${\r\n             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 = [];\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        if (\r\n          startIndex > fixtureData?.shelfConfig.length ||\r\n          endIndex > fixtureData?.shelfConfig.length\r\n        )\r\n          continue;\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              `${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} ${\r\n             midX + midWidth - radius\r\n           } ${lastBoxY + boxHeight} \r\n           L ${midX + radius} ${lastBoxY + boxHeight} \r\n           Q ${midX} ${lastBoxY + boxHeight} ${midX} ${\r\n             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 - ${actualShelves.length} . Products -  ${\r\n        fixtureData?.fixtureCapacity ?? 0\r\n      } . VM - ${fixtureData?.vmConfig?.length ?? 0}`,\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    let angle = fixtureData?.relativePosition?.angle;\r\n\r\n    if (this.floorData.cadLayout && fixtureData.fixtureType === \"wall\") {\r\n      const wallData = this.getWallByNumber(\r\n        fixtureData.associatedElementNumber,\r\n      );\r\n      const angleDeg = wallData?.angle || 0;\r\n      angle = angleDeg;\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        hoverCursor: \"pointer\",\r\n        selectable: false,\r\n        lockScalingX: true,\r\n        lockScalingY: true,\r\n        subTargetCheck: true,\r\n        angle: angle,\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    fixtureGroup.on(\"mousedown\", (event: any) => {\r\n      const target = event.target;\r\n      console.log(\"@@ ~ target:\", target);\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    canvas.add(fixtureGroup);\r\n\r\n    return fixtureGroup;\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    const angle = elementData.angle;\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      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockScalingFlip: true,\r\n      angle: 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  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      selectable: false,\r\n      originX: \"center\",\r\n      originY: \"center\",\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        this.canvas.setActiveObject(group);\r\n        this.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  drawBg() {\r\n    const wall1 = this.floorData.layoutPolygon.find(\r\n      (e: any) => e.elementNumber === 1 && e.elementType === \"wall\",\r\n    );\r\n    const wall2 = this.floorData.layoutPolygon.find(\r\n      (e: any) => e.elementNumber === 2 && e.elementType === \"wall\",\r\n    );\r\n    const width = this.toPixels(wall1.distance, wall1.unit);\r\n    const height = this.toPixels(wall2.distance, wall2.unit);\r\n\r\n    const bg = new fabric.Rect({\r\n      left: this.wallThickness,\r\n      top: this.wallThickness,\r\n      width: width,\r\n      height: height,\r\n      fill: \"#eaecf0\",\r\n      selectable: false,\r\n      evented: false,\r\n    });\r\n\r\n    this.canvas.add(bg);\r\n    this.canvas.remove(bg);\r\n    this.canvas.insertAt(0, bg);\r\n    this.canvas.renderAll();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next(true);\r\n    this.destroy$.complete();\r\n  }\r\n}\r\n","<section id=\"cad-render\">\r\n    <div class=\"app-layout\">\r\n\r\n        <!-- LEFT TOOLBAR -->\r\n        <div class=\"sidebar\">\r\n            <div class=\"p-3\">\r\n                <textarea class=\"form-control\" [(ngModel)]=\"rawCADDetails\" placeholder=\"Paste the CAD extracted data\"\r\n                    rows=\"25\"></textarea>\r\n            </div>\r\n        </div>\r\n\r\n        <!-- RIGHT CANVAS PANEL -->\r\n        <div class=\"canvas-wrapper\" #canvasContainer>\r\n\r\n            <!-- Toolbar -->\r\n            <div class=\"toolbar\">\r\n\r\n                <div class=\"form-check form-switch\">\r\n                    <input [checked]=\"isAutoAlignMode\" [(ngModel)]=\"isAutoAlignMode\"\r\n                        [ngModelOptions]=\"{ standalone: true }\" style=\"cursor: pointer\" class=\"form-check-input\"\r\n                        type=\"checkbox\" [disabled]=\"!floorData\" />\r\n                    <label style=\"color: black; white-space: nowrap\" class=\"form-check-label sub ms-2\" for=\"showVMs\">\r\n                        Auto Position Fixtures\r\n                    </label>\r\n                </div>\r\n\r\n                <!-- <div class=\"d-flex gap-2\">\r\n                    <input type=\"checkbox\" class=\"form-check\" name=\"includeBG\" id=\"includeBG\"\r\n                        [(ngModel)]=\"includeFixtures\" [ngModelOptions]=\"{ standalone: true }\" [disabled]=\"!floorData\">\r\n                    <label for=\"includeBG\">Include Fixtures</label>\r\n                </div> -->\r\n\r\n                <button class=\"btn btn-primary\" type=\"button\" (click)=\"onClickRenderPlano()\">\r\n                    Render\r\n                </button>\r\n\r\n                <div class=\"ms-auto d-flex align-items-center gap-3\">\r\n                    <h4 class=\"m-0\"> {{wallCount}} - Walls |</h4>\r\n                    <h4 class=\"m-0\"> {{wFixturesCount}} - Wall Fixtures |</h4>\r\n                    <h4 class=\"m-0\"> {{cFixturesCount}} - Center Fixtures</h4>\r\n                </div>\r\n            </div>\r\n\r\n            <!-- Canvas -->\r\n            <div class=\"canvas-area\">\r\n                <canvas #canvas></canvas>\r\n            </div>\r\n\r\n        </div>\r\n\r\n\r\n    </div>\r\n</section>"]}