tango-app-ui-store-builder 1.2.10 → 1.2.12

package/esm2022/lib/components/look-plano-collection-form/look-plano-collection-form.component.mjs

@@ -0,0 +1,1204 @@
+import { Component } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { debounceTime, lastValueFrom, Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/router";
+import * as i3 from "tango-app-ui-global";
+import * as i4 from "../../services/store-builder.service";
+import * as i5 from "tango-app-ui-shared";
+import * as i6 from "../../services/plano-data.service";
+import * as i7 from "@angular/common";
+import * as i8 from "../multiselect-chip-dropdown/multiselect-chip-dropdown.component";
+import * as i9 from "../fixture-template/template-products/template-products.component";
+import * as i10 from "../searchable-select/searchable-select.component";
+import * as i11 from "../chips-input/chips-input.component";
+import * as i12 from "../fixture-template/template-vms/template-vms.component";
+export class LookPlanoCollectionFormComponent {
+    fb;
+    route;
+    router;
+    gs;
+    builderService;
+    toast;
+    pageInfo;
+    planoDataService;
+    clientId = '';
+    collectionId = null;
+    isNew = true;
+    loading = false;
+    saving = false;
+    form;
+    selectedLookIndex = -1;
+    selectedSlotIndex = -1;
+    // Display labels are Wall / Floor; the stored ids stay 'shelf' / 'eurocenter'
+    // so the library filter, slot defaults, and the backend slotType/fixtureType
+    // enums keep working unchanged ('shelf' → wall fixtures, 'eurocenter' → floor).
+    fixtureTypeOptions = [
+        { id: 'shelf', name: 'Wall' },
+        { id: 'eurocenter', name: 'Floor' },
+    ];
+    fixtureLibraryItems = [];
+    // Dropdowns inside placement rows.
+    vmTypeOptions = [];
+    vmArtworkOptions = [];
+    productOptions = [];
+    /** Cached per-vmType artwork list — same reference returned each lookup so
+     *  lib-reactive-select doesn't reset state every CD cycle. */
+    vmArtworkByType = new Map();
+    /** (vmName||vmType) and (vmName) → planovm _id, so a VM placement's artwork
+     *  name can be resolved to the _id the embedded VM editor matches against. */
+    vmIdByNameType = new Map();
+    /**
+     * Cached filtered list bound to the "Fixture libraries" multiselect.
+     * Must NOT be a getter — the underlying multiselect re-clones its items on
+     * every ngOnChanges, which detaches click targets and breaks selection.
+     */
+    fixtureLibraryItemsForSlot = [];
+    // State for the per-slot Fixture Library Configuration card.
+    selectedLibraryIdInMap = '';
+    selectedLibraryDetails = null;
+    loadingLibraryDetails = false;
+    embeddedTab = 'products';
+    // === Fixture Library Configuration card helpers ===
+    /** Slot's placements with kind = 'vm', exposed as dropdown items. */
+    get currentSlotVmItems() {
+        return this.placementsToItems('vm');
+    }
+    /** Slot's placements with kind = 'pid', exposed as dropdown items. */
+    get currentSlotPidItems() {
+        return this.placementsToItems('pid');
+    }
+    placementsToItems(kind) {
+        const slot = this.selectedSlotGroup;
+        if (!slot)
+            return [];
+        const arr = slot.get('placements');
+        if (!arr)
+            return [];
+        return arr.controls
+            .map((c) => c.value)
+            .filter((p) => p?.kind === kind && p?.position)
+            .map((p) => ({
+            id: p.position,
+            name: p.rawValue ? `${p.position} — ${p.rawValue}` : p.position,
+        }));
+    }
+    /** Fixture-library options for the dropdown — filtered to the libraries
+     *  selected on the currently-active slot's multiselect. */
+    get selectedSlotLibrariesForDropdown() {
+        const slot = this.selectedSlotGroup;
+        if (!slot)
+            return [];
+        const refs = slot.get('fixtureLibraryRefs')?.value || [];
+        return this.fixtureLibraryItems.filter((item) => refs.includes(item.id));
+    }
+    /** The FormArray that stores per-(library, shelf) VM/PID values for the active slot. */
+    get selectedSlotLibraryConfigs() {
+        const slot = this.selectedSlotGroup;
+        return slot ? slot.get('libraryConfigurations') : null;
+    }
+    /** Form-array entries scoped to the currently-shown library in the config card. */
+    configEntriesForCurrentLibrary() {
+        const configs = this.selectedSlotLibraryConfigs;
+        if (!configs || !this.selectedLibraryIdInMap)
+            return [];
+        return configs.controls
+            .map((c, i) => ({ control: c, arrayIndex: i }))
+            .filter((x) => x.control.get('libraryRef')?.value === this.selectedLibraryIdInMap);
+    }
+    /** Reset card state whenever the active slot changes so we don't carry over
+     *  stale selections from a previously-viewed slot. */
+    resetLibraryMap() {
+        this.selectedLibraryIdInMap = '';
+        this.selectedLibraryDetails = null;
+        this.refreshEmbeddedHostKeys();
+        // Clear the shared BehaviorSubject too so the embedded TemplateProducts /
+        // TemplateVms components, if they're still mounted, don't render stale
+        // data from the previous slot's library.
+        this.planoDataService.fixtureTemplateDetails.next(null);
+    }
+    /** When a slot is loaded, automatically pick the first library it has linked
+     *  so the embedded fixture-template editor opens straight to that library. */
+    autoSelectFirstLibrary() {
+        const slot = this.selectedSlotGroup;
+        if (!slot)
+            return;
+        const refs = slot.get('fixtureLibraryRefs')?.value || [];
+        const firstId = refs.find((id) => !!id);
+        if (!firstId)
+            return;
+        if (this.selectedLibraryIdInMap === firstId)
+            return;
+        this.onLibraryMapSelect(firstId);
+    }
+    /** Read the slot's saved snapshot for a library, if any. */
+    getLibrarySnapshot(libId) {
+        const slot = this.selectedSlotGroup;
+        if (!slot)
+            return null;
+        const snaps = slot.get('librarySnapshots')?.value || [];
+        const entry = snaps.find((s) => s?.libraryRef === libId);
+        return entry?.snapshot || null;
+    }
+    /** Persist a snapshot into the slot's librarySnapshots FormControl. */
+    captureLibrarySnapshot(libId, snapshot) {
+        const slot = this.selectedSlotGroup;
+        if (!slot || !libId)
+            return;
+        const ctrl = slot.get('librarySnapshots');
+        if (!ctrl)
+            return;
+        const current = Array.isArray(ctrl.value) ? [...ctrl.value] : [];
+        // Strip the ignoreUpdate flag before saving so we don't echo it back later.
+        const { ignoreUpdate: _ignored, ...clean } = snapshot || {};
+        const i = current.findIndex((s) => s?.libraryRef === libId);
+        if (i >= 0) {
+            current[i] = { libraryRef: libId, snapshot: clean };
+        }
+        else {
+            current.push({ libraryRef: libId, snapshot: clean });
+        }
+        ctrl.setValue(current);
+    }
+    /** Resolve a VM placement's artwork NAME (+ vmType) to its planovm _id. */
+    resolveVmId(vmName, vmType) {
+        const name = this.normVmType(vmName);
+        const type = this.normVmType(vmType);
+        return (this.vmIdByNameType.get(`${name}||${type}`) ||
+            this.vmIdByNameType.get(name) ||
+            vmName);
+    }
+    /**
+     * Re-derive every assigned library's snapshot from the active slot's
+     * current placements. Driven by the "Look and Visual Merchandising
+     * Placements" list — so editing one placement updates ALL assigned
+     * libraries at once.
+     *
+     *  - PID placements: `position` (Top/Mid/Bottom) → shelf zone; the shelf's
+     *    productBrandName is OVERWRITTEN with the placement's product list.
+     *  - VM placements: `position` → vmType; the matching vmConfig entry's
+     *    artwork (vmId/vmName) is updated while the library keeps its own VM
+     *    positions. vmTypes not yet present are appended.
+     */
+    applyPlacementsToAssignedLibraries() {
+        const slot = this.selectedSlotGroup;
+        if (!slot)
+            return;
+        const refs = (slot.get('fixtureLibraryRefs')?.value || [])
+            .filter((r) => !!r);
+        if (!refs.length)
+            return;
+        const placements = slot.get('placements')?.value || [];
+        const norm = (s) => String(s ?? '').trim().toLowerCase();
+        // zone -> product list (PIDs); supports both rawValues[] and legacy rawValue.
+        const pidByZone = new Map();
+        for (const p of placements) {
+            if (p?.kind !== 'pid' || !p?.position)
+                continue;
+            const vals = Array.isArray(p.rawValues) && p.rawValues.length
+                ? p.rawValues.filter((v) => !!v)
+                : (p.rawValue ? [String(p.rawValue)] : []);
+            if (vals.length)
+                pidByZone.set(norm(p.position), vals);
+        }
+        // vmType -> { vmId, vmName, label } (VMs)
+        const vmByType = new Map();
+        for (const p of placements) {
+            if (p?.kind !== 'vm' || !p?.position || !p?.rawValue)
+                continue;
+            const label = String(p.position);
+            vmByType.set(norm(label), {
+                vmId: this.resolveVmId(String(p.rawValue), label),
+                vmName: String(p.rawValue),
+                label,
+            });
+        }
+        for (const libId of refs) {
+            const target = this.getLibrarySnapshot(libId);
+            if (!target)
+                continue; // seed creates one per assigned library
+            const shelves = Array.isArray(target.shelfConfig) ? target.shelfConfig : [];
+            const newShelfConfig = shelves.map((shelf) => {
+                const zone = norm(shelf?.zone || shelf?.label);
+                if (!zone || !pidByZone.has(zone))
+                    return shelf;
+                return {
+                    ...shelf,
+                    zone: shelf?.zone || shelf?.label || '',
+                    productBrandName: [...pidByZone.get(zone)],
+                };
+            });
+            const existingVms = Array.isArray(target.vmConfig) ? target.vmConfig : [];
+            const seen = new Set();
+            const newVmConfig = existingVms.map((vm) => {
+                const key = norm(vm?.vmType);
+                seen.add(key);
+                const upd = vmByType.get(key);
+                return upd ? { ...vm, vmId: upd.vmId, vmName: upd.vmName } : vm;
+            });
+            for (const [key, upd] of vmByType) {
+                if (seen.has(key))
+                    continue;
+                newVmConfig.push({
+                    vmType: upd.label,
+                    vmId: upd.vmId,
+                    vmName: upd.vmName,
+                    startYPosition: 1,
+                    endYPosition: 1,
+                    xZone: '',
+                    yZone: '',
+                    position: '',
+                });
+            }
+            this.captureLibrarySnapshot(libId, {
+                ...target,
+                shelfConfig: newShelfConfig,
+                vmConfig: newVmConfig,
+                productResolutionLevel: 'L3',
+            });
+        }
+        // Reflect the change in the currently-open embedded editor.
+        this.reloadDisplayedLibrary();
+    }
+    /**
+     * Remount the embedded editor for the active library so it picks up the
+     * snapshot we just rewrote. The embedded components guard against re-init
+     * while mounted, so we toggle the host key off then on to force a fresh
+     * ngOnInit with the updated data.
+     */
+    reloadDisplayedLibrary() {
+        const libId = this.selectedLibraryIdInMap;
+        if (!libId)
+            return;
+        const updated = this.getLibrarySnapshot(libId);
+        if (!updated)
+            return;
+        this.selectedLibraryDetails = updated;
+        // Push the fresh snapshot, then bump the nonce so refreshEmbeddedHostKeys
+        // produces a NEW key — that's what actually forces the *ngFor to destroy
+        // the old embedded editor and mount a new one that re-reads the snapshot.
+        this.planoDataService.fixtureTemplateDetails.next({
+            ...updated,
+            productResolutionLevel: updated.productResolutionLevel || 'L3',
+        });
+        this.embeddedReloadNonce++;
+        this.refreshEmbeddedHostKeys();
+    }
+    async onLibraryMapSelect(libId) {
+        // Toggling the active chip off → clear immediately (no async work needed).
+        if (!libId) {
+            this.selectedLibraryIdInMap = '';
+            this.selectedLibraryDetails = null;
+            this.refreshEmbeddedHostKeys();
+            this.planoDataService.fixtureTemplateDetails.next(null);
+            return;
+        }
+        // Switching to a different chip: light the new chip up right away, but
+        // KEEP the previous library's embedded preview mounted while we fetch
+        // the new snapshot/details. Otherwise the card would collapse to its
+        // header height during the fetch and re-expand once new data lands —
+        // visible as a "crunch" the user reported.
+        this.selectedLibraryIdInMap = libId;
+        this.loadingLibraryDetails = true;
+        let newDetails = null;
+        try {
+            // If an auto-apply for this library is still running, wait for it so
+            // we don't beat it to the snapshot and render the un-filled library.
+            const pending = this.autoApplyInFlight.get(libId);
+            if (pending) {
+                try {
+                    await pending;
+                }
+                catch (_e) { /* ignore */ }
+            }
+            const saved = this.getLibrarySnapshot(libId);
+            if (saved) {
+                newDetails = saved;
+            }
+            else {
+                const res = await lastValueFrom(this.builderService.getFixtureLibraryDetails(libId));
+                newDetails = res?.data || null;
+            }
+        }
+        catch (err) {
+            console.log('@@ ~ onLibraryMapSelect [ERR]:', err);
+            newDetails = null;
+        }
+        // Atomic swap — selectedLibraryDetails, BehaviorSubject, and the
+        // ngFor host key all flip in one synchronous block, so Angular destroys
+        // the old embedded component and mounts the new one in the same change
+        // detection cycle. No empty-state in between → no card-height crunch.
+        this.selectedLibraryDetails = newDetails;
+        if (newDetails) {
+            this.planoDataService.fixtureTemplateDetails.next({
+                ...newDetails,
+                productResolutionLevel: newDetails.productResolutionLevel || 'L3',
+            });
+        }
+        else {
+            this.planoDataService.fixtureTemplateDetails.next(null);
+        }
+        this.refreshEmbeddedHostKeys();
+        this.loadingLibraryDetails = false;
+    }
+    /**
+     * Composite key tied to the currently-active (look, slot, library) triple.
+     * Stable property — recomputed only when the underlying selection changes
+     * (see refreshEmbeddedHostKeys()). Avoids returning a new array reference
+     * every CD cycle, which used to ripple into other multi-selects' inputs.
+     */
+    embeddedHostKey = '';
+    embeddedHostKeys = [];
+    // Bumped by reloadDisplayedLibrary() to force the embedded editor to remount
+    // even when look/slot/library are unchanged (a same-key round-trip via the
+    // *ngFor trackBy does NOT remount; a changed key does).
+    embeddedReloadNonce = 0;
+    refreshEmbeddedHostKeys() {
+        const key = `${this.selectedLookIndex}-${this.selectedSlotIndex}-${this.selectedLibraryIdInMap}-${this.embeddedReloadNonce}`;
+        if (key !== this.embeddedHostKey) {
+            this.embeddedHostKey = key;
+        }
+        const next = this.selectedLibraryDetails ? [this.embeddedHostKey] : [];
+        const current = this.embeddedHostKeys;
+        // Only assign a new array if the contents differ — otherwise the ngFor sees
+        // a "new" array each CD and trackBy still has to compare every entry.
+        if (next.length !== current.length || next[0] !== current[0]) {
+            this.embeddedHostKeys = next;
+        }
+    }
+    trackByEmbeddedKey(_, key) {
+        return key;
+    }
+    /**
+     * The slot-type dropdown in the right pane only offers values that the
+     * parent Look has selected in its Fixture Type multiselect. If nothing is
+     * selected yet, fall back to showing all options so the user isn't blocked.
+     */
+    get availableSlotTypes() {
+        const lookGroup = this.selectedLookGroup;
+        if (!lookGroup)
+            return this.fixtureTypeOptions;
+        const selected = lookGroup.get('fixtureType')?.value;
+        if (!Array.isArray(selected) || selected.length === 0) {
+            return this.fixtureTypeOptions;
+        }
+        return this.fixtureTypeOptions.filter((opt) => selected.includes(opt.id));
+    }
+    // 20 very mild pastels (all Tailwind-50 / 100 range) arranged so adjacent
+    // palette slots are on opposite sides of the colour wheel for distinguish-
+    // ability without any colour feeling saturated.
+    static BUCKET_PALETTE = [
+        '#fef2f2',
+        '#f0fdfa',
+        '#fff7ed',
+        '#eef2ff',
+        '#fefce8',
+        '#faf5ff',
+        '#f0fdf4',
+        '#fff1f2',
+        '#ecfeff',
+        '#ffedd5',
+        '#eff6ff',
+        '#f0f9ff',
+        '#f5f3ff',
+        '#f7fee7',
+        '#fdf4ff',
+        '#ecfdf5',
+        '#fdf2f8',
+        '#fffbeb',
+        '#f1f5f9',
+        '#f5f5f4', // 20 Linen          stone-100
+    ];
+    destroy$ = new Subject();
+    constructor(fb, route, router, gs, builderService, toast, pageInfo, planoDataService) {
+        this.fb = fb;
+        this.route = route;
+        this.router = router;
+        this.gs = gs;
+        this.builderService = builderService;
+        this.toast = toast;
+        this.pageInfo = pageInfo;
+        this.planoDataService = planoDataService;
+    }
+    ngOnInit() {
+        this.setPageData();
+        this.initForm();
+        // Listen to the shared fixtureTemplateDetails — when the embedded
+        // TemplateProducts/TemplateVms components push edits back into the
+        // BehaviorSubject, persist a snapshot under the active slot + library.
+        this.planoDataService.fixtureTemplateDetails
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((data) => {
+            if (!data || !this.selectedLibraryIdInMap)
+                return;
+            // Only capture user edits, not the initial load we pushed ourselves.
+            // The embedded components set `ignoreUpdate: true` when they push
+            // their form changes back; we use that as our signal.
+            if (!data.ignoreUpdate)
+                return;
+            // Persist edits made directly in the embedded editor (e.g. VM
+            // positions, which stay editable in looksMode) to the active library.
+            // Cross-library propagation is driven by the slot's placements list
+            // instead (see applyPlacementsToAssignedLibraries).
+            this.captureLibrarySnapshot(this.selectedLibraryIdInMap, data);
+        });
+        this.gs.dataRangeValue.pipe(takeUntil(this.destroy$)).subscribe((data) => {
+            const headerFilters = JSON.parse(localStorage.getItem('header-filters') || '{}');
+            this.clientId = data?.client || headerFilters?.client;
+            if (this.clientId) {
+                this.loadFixtureLibraries();
+                this.loadPlacementDropdownData();
+            }
+        });
+        this.route.params.pipe(takeUntil(this.destroy$)).subscribe(async (params) => {
+            const id = params['collectionId'];
+            this.collectionId = id && id !== 'new' ? id : null;
+            this.isNew = !this.collectionId;
+            if (this.collectionId) {
+                await this.loadDetails();
+            }
+        });
+        // Embedded TemplateProductsComponent / TemplateVmsComponent read these
+        // query params from the active route. Force them to edit-mode and pin
+        // the products view to the "section" level.
+        this.router.navigate([], {
+            relativeTo: this.route,
+            queryParams: { isEdit: 'true', level: 'section' },
+            queryParamsHandling: 'merge',
+            replaceUrl: true,
+        });
+    }
+    setPageData() {
+        this.pageInfo.setTitle('Look Collection');
+        this.pageInfo.setBreadcrumbs([
+            { title: 'Planogram', path: '/manage/planogram/manage-planograms', isActive: false, isSeparator: false },
+            { title: '', path: '', isActive: false, isSeparator: true },
+            { title: 'Looks', path: '/manage/planogram/looks', isActive: false, isSeparator: false },
+            { title: '', path: '', isActive: false, isSeparator: true },
+            { title: 'Edit', path: '', isActive: true, isSeparator: false },
+        ]);
+    }
+    initForm() {
+        this.form = this.fb.group({
+            name: ['', Validators.required],
+            description: [''],
+            isActive: [false],
+            looks: this.fb.array([]),
+        });
+    }
+    get looks() {
+        return this.form.get('looks');
+    }
+    fixtureSlots(lookIndex) {
+        return this.looks.at(lookIndex).get('fixtureSlots');
+    }
+    placements(lookIndex, slotIndex) {
+        return this.fixtureSlots(lookIndex).at(slotIndex).get('placements');
+    }
+    get selectedLookGroup() {
+        return this.selectedLookIndex >= 0 && this.selectedLookIndex < this.looks.length
+            ? this.looks.at(this.selectedLookIndex)
+            : null;
+    }
+    get selectedSlotsArray() {
+        const look = this.selectedLookGroup;
+        return look ? look.get('fixtureSlots') : null;
+    }
+    get selectedSlotGroup() {
+        const slots = this.selectedSlotsArray;
+        if (!slots)
+            return null;
+        return this.selectedSlotIndex >= 0 && this.selectedSlotIndex < slots.length
+            ? slots.at(this.selectedSlotIndex)
+            : null;
+    }
+    get selectedPlacements() {
+        const slot = this.selectedSlotGroup;
+        return slot ? slot.get('placements') : null;
+    }
+    createLookGroup(seed = {}) {
+        const seedSlots = Array.isArray(seed.fixtureSlots) && seed.fixtureSlots.length
+            ? seed.fixtureSlots
+            : Array.from({ length: Math.max(1, Number(seed.fixtureCount) || 1) }, (_, i) => ({ slotIndex: i + 1 }));
+        const slots = seedSlots.map((s, i) => this.createSlotGroup({ ...s, slotIndex: i + 1 }));
+        const lookGroup = this.fb.group({
+            keyType: [seed.keyType || 'mbq'],
+            mbqBucket: [seed.mbqBucket || ''],
+            brandCategory: [seed.brandCategory || ''],
+            fixtureCount: [slots.length, [Validators.required, Validators.min(0)]],
+            fixtureType: [Array.isArray(seed.fixtureType) ? seed.fixtureType : []],
+            layoutVariant: [seed.layoutVariant || 'shelf'],
+            storeProto: [seed.storeProto || ''],
+            fixtureSlots: this.fb.array(slots),
+        });
+        // fixtureCount → slots length (user-edited count adjusts the slots array)
+        lookGroup.get('fixtureCount').valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((next) => {
+            const target = Math.max(0, Math.min(30, Number(next) || 0));
+            const slotsArr = lookGroup.get('fixtureSlots');
+            while (slotsArr.length < target) {
+                slotsArr.push(this.createSlotGroup({ slotIndex: slotsArr.length + 1 }));
+            }
+            while (slotsArr.length > target) {
+                slotsArr.removeAt(slotsArr.length - 1);
+            }
+            this.renumberSlotsForGroup(lookGroup);
+            // Reconcile slot selection if it's now out of bounds
+            if (this.selectedLookIndex >= 0 && this.looks.at(this.selectedLookIndex) === lookGroup) {
+                if (slotsArr.length === 0) {
+                    this.selectedSlotIndex = -1;
+                }
+                else if (this.selectedSlotIndex >= slotsArr.length) {
+                    this.selectedSlotIndex = slotsArr.length - 1;
+                }
+                else if (this.selectedSlotIndex < 0) {
+                    this.selectedSlotIndex = 0;
+                }
+            }
+        });
+        return lookGroup;
+    }
+    createSlotGroup(seed = {}) {
+        const placements = (Array.isArray(seed.placements) ? seed.placements : [])
+            .map((p) => this.createPlacementGroup(p));
+        const libraryConfigs = (Array.isArray(seed.libraryConfigurations) ? seed.libraryConfigurations : [])
+            .map((c) => this.createLibraryConfigGroup(c));
+        return this.fb.group({
+            slotIndex: [seed.slotIndex ?? 1, Validators.required],
+            slotType: [seed.slotType || 'shelf'],
+            brand: [seed.brand || ''],
+            fixtureLevelZone: [seed.fixtureLevelZone || ''],
+            fixtureLibraryRef: [seed.fixtureLibraryRef || ''],
+            fixtureLibraryLabel: [seed.fixtureLibraryLabel || ''],
+            fixtureLibraryRefs: [Array.isArray(seed.fixtureLibraryRefs) ? seed.fixtureLibraryRefs : []],
+            cadHeaderVariants: [Array.isArray(seed.cadHeaderVariants) ? seed.cadHeaderVariants : []],
+            placements: this.fb.array(placements),
+            libraryConfigurations: this.fb.array(libraryConfigs),
+            // Per-library snapshot of the embedded fixture-template editor state
+            // (shelfConfig + product/VM placements). Keyed by libraryRef.
+            librarySnapshots: [
+                Array.isArray(seed.librarySnapshots) ? seed.librarySnapshots : [],
+            ],
+        });
+    }
+    createLibraryConfigGroup(seed = {}) {
+        return this.fb.group({
+            libraryRef: [seed.libraryRef || ''],
+            shelfNumber: [seed.shelfNumber ?? 1],
+            label: [seed.label || ''],
+            shelfType: [seed.shelfType || ''],
+            // VMs and PIDs picked from the slot's `placements` array (by position name).
+            vmRefs: [Array.isArray(seed.vmRefs) ? seed.vmRefs : []],
+            pidRefs: [Array.isArray(seed.pidRefs) ? seed.pidRefs : []],
+        });
+    }
+    createPlacementGroup(seed = {}) {
+        // Backward-compat: legacy data stored a single string in `rawValue`. For
+        // PID placements we now use `rawValues` (array, multi-select). If the
+        // seed only has `rawValue`, migrate it to the array on first load.
+        const rawValuesSeed = Array.isArray(seed.rawValues)
+            ? seed.rawValues
+            : (seed.kind === 'pid' && seed.rawValue ? [String(seed.rawValue)] : []);
+        return this.fb.group({
+            position: [seed.position || ''],
+            kind: [seed.kind || 'pid'],
+            // For VM rows this holds the artwork id (single string). For PID rows
+            // it's left empty in favour of `rawValues`.
+            rawValue: [seed.kind === 'pid' ? '' : (seed.rawValue || '')],
+            rawValues: [rawValuesSeed],
+            vmRef: [seed.vmRef || ''],
+            skuCollectionRef: [seed.skuCollectionRef || ''],
+        });
+    }
+    addPlacement() {
+        if (!this.selectedPlacements)
+            return;
+        this.selectedPlacements.push(this.createPlacementGroup());
+    }
+    removePlacement(index) {
+        if (!this.selectedPlacements)
+            return;
+        this.selectedPlacements.removeAt(index);
+    }
+    normVmType(t) {
+        return String(t ?? '').trim().toLowerCase();
+    }
+    /** Stable per-vmType artwork list lookup. Returns the same array reference
+     *  for the same vmType across CD cycles so lib-reactive-select doesn't
+     *  re-init. Falls back to the full list when vmType is empty. */
+    vmArtworkOptionsFor(vmType) {
+        const key = this.normVmType(vmType);
+        if (key && this.vmArtworkByType.has(key)) {
+            return this.vmArtworkByType.get(key);
+        }
+        return this.vmArtworkByType.get('') || [];
+    }
+    /** Populate the dropdown data used by Placement rows:
+     *  - VM Type list (`getVmTypesList`)
+     *  - VM Artwork list (`vmNameList`)
+     *  - Product / SKU collection list (flattened from brand → category mapping
+     *    that powers /manage/planogram/config). */
+    async loadPlacementDropdownData() {
+        if (!this.clientId)
+            return;
+        try {
+            const [vmTypesRes, vmsRes, brandsRes, brandMetaRes] = await Promise.all([
+                lastValueFrom(this.builderService.getVmTypesList(this.clientId)),
+                lastValueFrom(this.builderService.getVMNameList(this.clientId)),
+                lastValueFrom(this.builderService.getBrandList(this.clientId)),
+                lastValueFrom(this.builderService.getBrandMetaData(this.clientId)),
+            ]);
+            const vmTypes = vmTypesRes?.data || [];
+            this.vmTypeOptions = vmTypes
+                .map((t) => {
+                const v = t?.vmType || t?.vmTypeName || t?.name || t?._id;
+                const l = t?.vmTypeName || t?.vmType || t?.name || v;
+                return v ? { value: String(v), label: String(l) } : null;
+            })
+                .filter((x) => !!x);
+            const vms = vmsRes?.data || [];
+            this.vmArtworkOptions = vms
+                .map((v) => {
+                const id = v?.vmName || v?._id;
+                if (!id)
+                    return null;
+                return {
+                    value: String(id),
+                    label: String(v?.vmName || id),
+                    vmType: v?.vmType ? String(v.vmType) : undefined,
+                };
+            })
+                .filter((x) => !!x);
+            // (vmName, vmType) → _id so we can turn a placement's artwork NAME into
+            // the planovm _id the embedded VM editor matches against.
+            this.vmIdByNameType = new Map();
+            for (const v of vms) {
+                if (!v?._id || !v?.vmName)
+                    continue;
+                const name = this.normVmType(v.vmName);
+                const type = this.normVmType(v.vmType);
+                this.vmIdByNameType.set(`${name}||${type}`, String(v._id));
+                if (!this.vmIdByNameType.has(name)) {
+                    this.vmIdByNameType.set(name, String(v._id));
+                }
+            }
+            // Rebuild the (vmType → artworks) index now that the artwork list
+            // changed. Keys are normalised (trim + lower-case) so a mismatch in
+            // casing/whitespace between vmTypes and vms.vmType still matches.
+            this.vmArtworkByType = new Map();
+            const fullList = this.vmArtworkOptions.map((v) => ({ value: v.value, label: v.label }));
+            this.vmArtworkByType.set('', fullList);
+            for (const v of this.vmArtworkOptions) {
+                const key = this.normVmType(v.vmType);
+                if (!key)
+                    continue;
+                if (!this.vmArtworkByType.has(key))
+                    this.vmArtworkByType.set(key, []);
+                this.vmArtworkByType.get(key).push({ value: v.value, label: v.label });
+            }
+            console.log('[Looks form] vmTypes:', this.vmTypeOptions.length, 'artworks:', this.vmArtworkOptions.length, 'artworksByType keys:', Array.from(this.vmArtworkByType.keys()));
+            // Source: every value the brand & product mapping page exposes.
+            //  - `getBrandList`     → per-brand `category[]` and `subCategory[]`
+            //  - `getBrandMetaData` → rows with `pidCat`, `category`, `tempGroup`
+            const brands = brandsRes?.data || [];
+            const brandMeta = brandMetaRes?.data || [];
+            const seenCats = new Set();
+            const products = [];
+            const pushOne = (v) => {
+                const s = String(v ?? '').trim();
+                if (!s || seenCats.has(s))
+                    return;
+                seenCats.add(s);
+                products.push({ value: s, label: s });
+            };
+            const pushArr = (arr) => {
+                if (!Array.isArray(arr))
+                    return;
+                for (const v of arr)
+                    pushOne(v);
+            };
+            for (const b of brands) {
+                pushArr(b?.category);
+                pushArr(b?.subCategory);
+            }
+            for (const row of brandMeta) {
+                pushOne(row?.pidCat);
+                pushOne(row?.category);
+                pushOne(row?.tempGroup);
+            }
+            this.productOptions = products;
+            console.log('[Looks form] product/SKU options:', this.productOptions.length, 'from', brands.length, 'brands and', brandMeta.length, 'brand-meta rows');
+        }
+        catch (err) {
+            console.log('@@ ~ loadPlacementDropdownData [ERR]:', err);
+        }
+    }
+    async loadFixtureLibraries() {
+        if (!this.clientId)
+            return;
+        try {
+            // Only list fixture templates available in India (country code 'IN').
+            const res = await lastValueFrom(this.builderService.getFixtureLibNameList(this.clientId, 'non-draft', 'IN'));
+            // Response shape: { code, status, data: [{ id, fixtureName, fixtureType }] }.
+            const list = Array.isArray(res?.data) ? res.data : [];
+            this.fixtureLibraryItems = list.map((l) => ({
+                id: l.id,
+                name: l.fixtureName,
+                fixtureType: (l.fixtureType || '').toString().toLowerCase().trim(),
+            }));
+            const typeTally = {};
+            for (const it of this.fixtureLibraryItems) {
+                const k = it.fixtureType || '(empty)';
+                typeTally[k] = (typeTally[k] || 0) + 1;
+            }
+            console.log('[Looks form] fixture libraries loaded:', this.fixtureLibraryItems.length, 'fixtureType tally:', typeTally);
+            this.recomputeFixtureLibraryItemsForSlot();
+        }
+        catch (err) {
+            console.log('@@ ~ loadFixtureLibraries [ERR]:', err);
+            this.fixtureLibraryItems = [];
+        }
+    }
+    /**
+     * Recompute the slot-type-filtered library list once. Stable reference
+     * so the multiselect doesn't tear down its click targets every CD cycle.
+     */
+    recomputeFixtureLibraryItemsForSlot() {
+        const slot = this.selectedSlotGroup;
+        if (!slot) {
+            this.fixtureLibraryItemsForSlot = this.fixtureLibraryItems.slice();
+            return;
+        }
+        const slotType = slot.get('slotType')?.value;
+        const target = slotType === 'eurocenter' ? 'floor' : 'wall';
+        this.fixtureLibraryItemsForSlot = this.fixtureLibraryItems.filter((item) => {
+            const t = item.fixtureType;
+            if (!t)
+                return false;
+            if (target === 'wall')
+                return t === 'wall' || t.includes('wall');
+            return t === 'floor' || t.includes('floor') || t.includes('euro') || t.includes('free');
+        });
+    }
+    /**
+     * Subscriptions scoped to whichever slot is currently active. Cleared and
+     * rebuilt every time the active slot changes.
+     */
+    slotSubs = [];
+    /** Pending auto-apply promises keyed by libId so chip clicks can await. */
+    autoApplyInFlight = new Map();
+    /** Wire/refresh subscriptions that depend on the active slot:
+     *  - re-filter the library multiselect when slotType changes
+     *  - run auto-apply when a new library is added to fixtureLibraryRefs
+     */
+    bindActiveSlotListeners() {
+        for (const s of this.slotSubs)
+            s?.unsubscribe?.();
+        this.slotSubs = [];
+        const slot = this.selectedSlotGroup;
+        if (!slot) {
+            this.fixtureLibraryItemsForSlot = this.fixtureLibraryItems.slice();
+            return;
+        }
+        this.recomputeFixtureLibraryItemsForSlot();
+        const typeSub = slot.get('slotType')?.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(() => this.recomputeFixtureLibraryItemsForSlot());
+        if (typeSub)
+            this.slotSubs.push(typeSub);
+        // Track previous refs so we can detect *new* additions and auto-apply
+        // the slot's PIDs to those new libraries.
+        let prevRefs = [...(slot.get('fixtureLibraryRefs')?.value || [])];
+        const refsSub = slot.get('fixtureLibraryRefs')?.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((nextRefs) => {
+            const next = Array.isArray(nextRefs) ? nextRefs : [];
+            const added = next.filter((r) => !!r && !prevRefs.includes(r));
+            prevRefs = [...next];
+            // If the currently-previewed library was unselected, clear the
+            // embedded view so we don't show stale data.
+            if (this.selectedLibraryIdInMap
+                && !next.includes(this.selectedLibraryIdInMap)) {
+                this.onLibraryMapSelect('');
+            }
+            for (const libId of added) {
+                const p = this.autoApplyPidsToLibrary(libId);
+                this.autoApplyInFlight.set(libId, p);
+                p.finally(() => {
+                    if (this.autoApplyInFlight.get(libId) === p) {
+                        this.autoApplyInFlight.delete(libId);
+                    }
+                });
+            }
+            // If nothing is being previewed yet, auto-activate the first library
+            // the user just added so the embedded PID/VM editor opens immediately
+            // (especially relevant when adding the FIRST library to an empty
+            // multiselect — previously the chip strip showed it but the preview
+            // pane stayed blank until the user clicked the chip).
+            if (!this.selectedLibraryIdInMap) {
+                const firstActive = added.find((id) => !!id) || next.find((id) => !!id);
+                if (firstActive)
+                    this.onLibraryMapSelect(firstActive);
+            }
+        });
+        if (refsSub)
+            this.slotSubs.push(refsSub);
+        // When any placement in the "Look and Visual Merchandising Placements"
+        // list changes, re-derive every assigned library's snapshot so the edit
+        // propagates to all of them. Debounced so rapid typing collapses into a
+        // single re-apply.
+        const placementsArr = slot.get('placements');
+        const placementsSub = placementsArr?.valueChanges
+            .pipe(debounceTime(400), takeUntil(this.destroy$))
+            .subscribe(() => this.applyPlacementsToAssignedLibraries());
+        if (placementsSub)
+            this.slotSubs.push(placementsSub);
+    }
+    /**
+     * When a new library is added to the slot, walk its shelfConfig and for
+     * each shelf whose section currently has no brand, copy the rawValue of
+     * the slot's PID placement whose `position` matches the shelf's
+     * `zone`/`label`. Result is saved as the library's snapshot so the
+     * embedded fixture-template editor picks it up the next time the chip
+     * is opened.
+     */
+    async autoApplyPidsToLibrary(libId) {
+        if (!libId)
+            return;
+        const slot = this.selectedSlotGroup;
+        if (!slot)
+            return;
+        const placementsArr = slot.get('placements');
+        const placements = placementsArr?.value || [];
+        const pidPlacements = placements.filter((p) => p?.kind === 'pid' && p?.position && p?.rawValue);
+        const norm = (s) => String(s ?? '').trim().toLowerCase();
+        const placementMap = new Map();
+        for (const p of pidPlacements) {
+            placementMap.set(norm(p.position), String(p.rawValue));
+        }
+        // Start from an existing snapshot if we already saved one for this slot
+        // + library; otherwise fetch the fresh library doc. The per-field guards
+        // below still ensure we never overwrite user-set brands or VMs.
+        let libData = this.getLibrarySnapshot(libId);
+        if (!libData) {
+            try {
+                const res = await lastValueFrom(this.builderService.getFixtureLibraryDetails(libId));
+                libData = res?.data;
+            }
+            catch (err) {
+                console.log('@@ ~ autoApplyPidsToLibrary [ERR]:', err);
+                return;
+            }
+        }
+        if (!libData)
+            return;
+        const shelfConfig = Array.isArray(libData.shelfConfig) ? libData.shelfConfig : [];
+        let pidsApplied = false;
+        const newShelfConfig = shelfConfig.map((shelf) => {
+            if (Array.isArray(shelf?.productBrandName) && shelf.productBrandName.length > 0) {
+                return shelf;
+            }
+            const sourceLabel = shelf?.zone || shelf?.label || '';
+            const matchKey = norm(sourceLabel);
+            if (!matchKey)
+                return shelf;
+            const match = placementMap.get(matchKey);
+            if (!match)
+                return shelf;
+            pidsApplied = true;
+            // groupShelvesByZone() in TemplateProductsComponent SKIPS any shelf
+            // whose `zone` is empty, so we must set zone (using the shelf's label
+            // if it isn't already set) for the section to form.
+            return {
+                ...shelf,
+                zone: shelf?.zone || sourceLabel,
+                productBrandName: [match],
+            };
+        });
+        // --- VM auto-apply -----------------------------------------------------
+        // If the library has no VMs configured yet, copy each of the slot's VM
+        // placements over as a vmConfig entry. No position-based matching here —
+        // the placement's `rawValue` becomes the VM artwork and `position`
+        // becomes the VM type label.
+        const existingVms = Array.isArray(libData.vmConfig) ? libData.vmConfig : [];
+        let newVmConfig = existingVms;
+        let vmsApplied = false;
+        if (existingVms.length === 0) {
+            const vmPlacements = placements.filter((p) => p?.kind === 'vm' && p?.rawValue);
+            if (vmPlacements.length > 0) {
+                newVmConfig = vmPlacements.map((p) => ({
+                    vmType: String(p?.position || ''),
+                    vmId: String(p?.rawValue || ''),
+                    startYPosition: 1,
+                    endYPosition: 1,
+                    xZone: '',
+                    yZone: '',
+                    position: '',
+                }));
+                vmsApplied = true;
+            }
+        }
+        if (!pidsApplied && !vmsApplied)
+            return;
+        // The embedded TemplateProductsComponent only reads section-level brand
+        // values when productResolutionLevel === 'L3'.
+        const updatedLib = {
+            ...libData,
+            shelfConfig: newShelfConfig,
+            vmConfig: newVmConfig,
+            productResolutionLevel: 'L3',
+        };
+        this.captureLibrarySnapshot(libId, updatedLib);
+    }
+    async loadDetails() {
+        if (!this.collectionId)
+            return;
+        this.loading = true;
+        try {
+            const res = await lastValueFrom(this.builderService.getLookPlanoCollectionDetails(this.collectionId));
+            const data = res?.data;
+            if (data) {
+                this.form.patchValue({
+                    name: data.name || '',
+                    description: data.description || '',
+                    isActive: !!data.isActive,
+                });
+                this.looks.clear();
+                (data.looks || []).forEach((l) => this.looks.push(this.createLookGroup(l)));
+                this.selectedLookIndex = this.looks.length ? 0 : -1;
+                const slots = this.selectedLookIndex >= 0 ? this.fixtureSlots(this.selectedLookIndex) : null;
+                this.selectedSlotIndex = slots && slots.length ? 0 : -1;
+                this.resetLibraryMap();
+                this.bindActiveSlotListeners();
+                this.autoSelectFirstLibrary();
+            }
+        }
+        catch (err) {
+            console.log('@@ ~ loadDetails [ERR]:', err);
+            this.toast.getErrorToast?.('Failed to load Look collection');
+        }
+        finally {
+            this.loading = false;
+        }
+    }
+    addLook() {
+        const next = this.createLookGroup({ mbqBucket: '', fixtureCount: 1 });
+        this.looks.push(next);
+        this.selectedLookIndex = this.looks.length - 1;
+        this.selectedSlotIndex = this.fixtureSlots(this.selectedLookIndex).length ? 0 : -1;
+        this.bindActiveSlotListeners();
+    }
+    removeLook(index) {
+        this.looks.removeAt(index);
+        if (this.selectedLookIndex === index) {
+            this.selectedLookIndex = this.looks.length ? 0 : -1;
+            this.selectedSlotIndex = -1;
+        }
+        else if (this.selectedLookIndex > index) {
+            this.selectedLookIndex -= 1;
+        }
+    }
+    selectLook(index) {
+        this.selectedLookIndex = index;
+        const slots = this.fixtureSlots(index);
+        this.selectedSlotIndex = slots.length ? 0 : -1;
+        this.resetLibraryMap();
+        this.bindActiveSlotListeners();
+        this.autoSelectFirstLibrary();
+    }
+    addSlot() {
+        if (this.selectedLookIndex < 0)
+            return;
+        const lookGroup = this.looks.at(this.selectedLookIndex);
+        const slots = this.fixtureSlots(this.selectedLookIndex);
+        slots.push(this.createSlotGroup({ slotIndex: slots.length + 1 }));
+        lookGroup.get('fixtureCount').setValue(slots.length, { emitEvent: false });
+        this.selectedSlotIndex = slots.length - 1;
+        this.bindActiveSlotListeners();
+    }
+    removeSlot(slotIndex) {
+        if (this.selectedLookIndex < 0)
+            return;
+        const lookGroup = this.looks.at(this.selectedLookIndex);
+        const slots = this.fixtureSlots(this.selectedLookIndex);
+        slots.removeAt(slotIndex);
+        this.renumberSlotsForGroup(lookGroup);
+        lookGroup.get('fixtureCount').setValue(slots.length, { emitEvent: false });
+        if (this.selectedSlotIndex === slotIndex) {
+            this.selectedSlotIndex = slots.length ? Math.min(slotIndex, slots.length - 1) : -1;
+        }
+        else if (this.selectedSlotIndex > slotIndex) {
+            this.selectedSlotIndex -= 1;
+        }
+    }
+    renumberSlotsForGroup(lookGroup) {
+        const slotsArr = lookGroup.get('fixtureSlots');
+        slotsArr.controls.forEach((slot, i) => {
+            slot.get('slotIndex')?.setValue(i + 1, { emitEvent: false });
+        });
+    }
+    selectSlot(slotIndex) {
+        this.selectedSlotIndex = slotIndex;
+        this.resetLibraryMap();
+        this.bindActiveSlotListeners();
+        this.autoSelectFirstLibrary();
+    }
+    lookTitle(lookGroup) {
+        const keyType = lookGroup.get('keyType')?.value;
+        const key = keyType === 'brandCategory'
+            ? lookGroup.get('brandCategory')?.value
+            : lookGroup.get('mbqBucket')?.value;
+        const count = lookGroup.get('fixtureCount')?.value;
+        return `${key || '(unnamed)'} — ${count || 0} fixtures`;
+    }
+    bucketKey(lookGroup) {
+        const keyType = lookGroup.get('keyType')?.value;
+        const key = keyType === 'brandCategory'
+            ? lookGroup.get('brandCategory')?.value
+            : lookGroup.get('mbqBucket')?.value;
+        return (key || '').trim();
+    }
+    /**
+     * Assign a colour to each unique bucket key by **insertion order**, not by hash.
+     * The Nth distinct bucket (counted top-to-bottom through the looks array) gets
+     * `BUCKET_PALETTE[N]`. Only after all 20 palette slots are used does the assignment
+     * wrap around — so no colour is ever reused while < 20 distinct buckets exist.
+     *
+     * Recomputed on every call so live edits to the bucket name re-flow colours.
+     */
+    bucketColor(lookGroup) {
+        const key = this.bucketKey(lookGroup);
+        if (!key)
+            return '#f9fafb';
+        const palette = LookPlanoCollectionFormComponent.BUCKET_PALETTE;
+        let nextIndex = 0;
+        const assigned = new Map();
+        for (const group of this.looks.controls) {
+            const k = this.bucketKey(group);
+            if (k && !assigned.has(k)) {
+                assigned.set(k, palette[nextIndex % palette.length]);
+                nextIndex += 1;
+            }
+            if (k === key) {
+                return assigned.get(k);
+            }
+        }
+        return '#f9fafb';
+    }
+    /**
+     * Reorder the looks FormArray so that the bucket with the **most** looks
+     * comes first and the one with the fewest comes last (alphabetical tie-break
+     * within the same count). Looks within the same bucket are sorted by
+     * ascending fixtureCount. Selection is preserved by reference, not by index.
+     */
+    applySortedOrder() {
+        const groups = this.looks.controls;
+        if (groups.length <= 1)
+            return;
+        // Tally how many looks each bucket has so we can sort buckets by frequency.
+        const bucketCounts = new Map();
+        for (const g of groups) {
+            const k = this.bucketKey(g);
+            if (!k)
+                continue;
+            bucketCounts.set(k, (bucketCounts.get(k) || 0) + 1);
+        }
+        const sorted = [...groups].sort((a, b) => {
+            const aKey = this.bucketKey(a);
+            const bKey = this.bucketKey(b);
+            // Empty bucket keys go to the end so unfinished looks don't disrupt the groups
+            if (aKey && !bKey)
+                return -1;
+            if (!aKey && bKey)
+                return 1;
+            // Primary: bucket frequency, descending (most-populated bucket first)
+            const aCount = bucketCounts.get(aKey) || 0;
+            const bCount = bucketCounts.get(bKey) || 0;
+            if (aCount !== bCount)
+                return bCount - aCount;
+            // Tie-break: alphabetical bucket name
+            if (aKey !== bKey)
+                return aKey.localeCompare(bKey);
+            // Within the same bucket: ascending fixtureCount
+            const aFC = Number(a.get('fixtureCount')?.value) || 0;
+            const bFC = Number(b.get('fixtureCount')?.value) || 0;
+            return aFC - bFC;
+        });
+        const orderChanged = sorted.some((g, i) => g !== groups[i]);
+        if (!orderChanged)
+            return;
+        const currentLook = this.selectedLookGroup;
+        const currentSlot = this.selectedSlotGroup;
+        this.looks.clear({ emitEvent: false });
+        sorted.forEach((g) => this.looks.push(g, { emitEvent: false }));
+        if (currentLook) {
+            const newLookIdx = sorted.indexOf(currentLook);
+            this.selectedLookIndex = newLookIdx;
+            if (this.selectedLookIndex >= 0 && currentSlot) {
+                const slotsArr = this.fixtureSlots(this.selectedLookIndex);
+                const newSlotIdx = slotsArr.controls.indexOf(currentSlot);
+                this.selectedSlotIndex = newSlotIdx;
+            }
+        }
+    }
+    async save() {
+        if (this.form.invalid) {
+            this.toast.getErrorToast?.('Please fill all required fields');
+            return;
+        }
+        this.saving = true;
+        try {
+            // Sort the looks before serialising so both the persisted payload
+            // and the on-screen list reflect grouping by MBQ bucket / brand category
+            // and ascending fixture count.
+            this.applySortedOrder();
+            const payload = {
+                ...this.form.value,
+                clientId: this.clientId,
+            };
+            if (this.isNew) {
+                const res = await lastValueFrom(this.builderService.createLookPlanoCollection(payload));
+                const newId = res?.data?._id;
+                this.toast.getSuccessToast?.('Look collection created');
+                if (newId) {
+                    this.router.navigate(['/manage/planogram/looks', newId]);
+                }
+                else {
+                    this.router.navigate(['/manage/planogram/looks']);
+                }
+            }
+            else {
+                await lastValueFrom(this.builderService.updateLookPlanoCollection({ ...payload, collectionId: this.collectionId }));
+                this.toast.getSuccessToast?.('Look collection updated');
+            }
+        }
+        catch (err) {
+            console.log('@@ ~ save [ERR]:', err);
+            this.toast.getErrorToast?.('Failed to save Look collection');
+        }
+        finally {
+            this.saving = false;
+        }
+    }
+    cancel() {
+        this.router.navigate(['/manage/planogram/looks']);
+    }
+    trackByIndex(index) {
+        return index;
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        // Release the shared BehaviorSubject so other pages don't inherit a stale library.
+        this.planoDataService.fixtureTemplateDetails.next(null);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LookPlanoCollectionFormComponent, deps: [{ token: i1.FormBuilder }, { token: i2.ActivatedRoute }, { token: i2.Router }, { token: i3.GlobalStateService }, { token: i4.StoreBuilderService }, { token: i5.ToastService }, { token: i3.PageInfoService }, { token: i6.PlanoDataService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LookPlanoCollectionFormComponent, selector: "lib-look-plano-collection-form", ngImport: i0, template: "<section class=\"look-form\">\r\n  <!-- Top bar (bound to the outer form) -->\r\n  <div class=\"card p-4 mb-4\" [formGroup]=\"form\">\r\n    <div class=\"row align-items-end\">\r\n      <div class=\"col-md-4\">\r\n        <label class=\"form-label fw-bold\">Name *</label>\r\n        <input type=\"text\" class=\"form-control\" formControlName=\"name\" placeholder=\"e.g. Master Look Plan FY26\" />\r\n      </div>\r\n      <div class=\"col-md-5\">\r\n        <label class=\"form-label fw-bold\">Description</label>\r\n        <input type=\"text\" class=\"form-control\" formControlName=\"description\" placeholder=\"Optional description\" />\r\n      </div>\r\n      <div class=\"col-md-1 text-center\">\r\n        <label class=\"form-label fw-bold d-block\">Active</label>\r\n        <input type=\"checkbox\" class=\"form-check-input\" formControlName=\"isActive\" />\r\n      </div>\r\n      <div class=\"col-md-2 text-end\">\r\n        <button type=\"button\" class=\"btn btn-light me-2\" (click)=\"cancel()\">Cancel</button>\r\n        <button type=\"button\" class=\"btn btn-primary\" [disabled]=\"saving\" (click)=\"save()\">\r\n          {{ saving ? 'Saving\u2026' : 'Save' }}\r\n        </button>\r\n      </div>\r\n    </div>\r\n  </div>\r\n\r\n  <!-- Three-pane editor -->\r\n  <div class=\"row mx-0 g-3\">\r\n    <!-- Left: Looks list (no form binding needed \u2014 just navigation) -->\r\n    <div class=\"col-md-3\">\r\n      <div class=\"card p-3 h-100\">\r\n        <div class=\"d-flex justify-content-between align-items-center mb-3\">\r\n          <h6 class=\"m-0\">MBQ Bucket - Fixture Combinations</h6>\r\n          <button type=\"button\" class=\"btn btn-sm btn-primary\" (click)=\"addLook()\">+ Add Look</button>\r\n        </div>\r\n        <div *ngIf=\"looks.length === 0\" class=\"text-muted small\">No looks yet. Add one to start.</div>\r\n        <div class=\"looks-tree\">\r\n          <div\r\n            *ngFor=\"let look of looks.controls; let i = index; trackBy: trackByIndex\"\r\n            class=\"look-row d-flex justify-content-between align-items-center px-2 py-2 mb-1 rounded\"\r\n            [class.selected]=\"selectedLookIndex === i\"\r\n            [style.background-color]=\"bucketColor($any(look))\"\r\n            (click)=\"selectLook(i)\"\r\n          >\r\n            <span class=\"d-flex align-items-center gap-2 text-truncate\">\r\n              <span class=\"bucket-dot\" [style.background-color]=\"bucketColor($any(look))\"></span>\r\n              <span class=\"text-truncate\">{{ lookTitle($any(look)) }}</span>\r\n            </span>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light-danger ms-2\" (click)=\"$event.stopPropagation(); removeLook(i)\">\u00D7</button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n    <!-- Centre: selected Look metadata + slots -->\r\n    <div class=\"col-md-3\">\r\n      <ng-container *ngIf=\"selectedLookGroup as lookGroup; else noLook\">\r\n        <div class=\"card p-3 h-100\" [formGroup]=\"lookGroup\">\r\n          <h6 class=\"mb-3\">Fixture Combination Details</h6>\r\n\r\n          <div class=\"row g-2 mb-3\">\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">MBQ bucket</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"mbqBucket\" placeholder=\"e.g. JJ / OD Eye\" />\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Fixture count *</label>\r\n              <input type=\"number\" min=\"0\" max=\"30\" class=\"form-control form-control-sm\" formControlName=\"fixtureCount\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Positions</label>\r\n              <multiselect-chip-dropdown\r\n                [items]=\"fixtureTypeOptions\"\r\n                idField=\"id\"\r\n                nameField=\"name\"\r\n                placeholder=\"Select fixture position\"\r\n                formControlName=\"fixtureType\">\r\n              </multiselect-chip-dropdown>\r\n            </div>\r\n          </div>\r\n\r\n          <hr />\r\n\r\n          <div class=\"d-flex justify-content-between align-items-center mb-2\">\r\n            <h6 class=\"m-0\">Fixtures</h6>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light\" (click)=\"addSlot()\">+ Add Fixture</button>\r\n          </div>\r\n          <div class=\"slots-list\">\r\n            <div\r\n              *ngFor=\"let slot of (selectedSlotsArray?.controls || []); let s = index; trackBy: trackByIndex\"\r\n              class=\"slot-row d-flex justify-content-between align-items-center px-2 py-2 mb-1 rounded\"\r\n              [class.selected]=\"selectedSlotIndex === s\"\r\n              (click)=\"selectSlot(s)\"\r\n            >\r\n              <div class=\"d-flex flex-column\">\r\n                <span class=\"fw-bold small\">\r\n                  Fixture {{ $any(slot).get('slotIndex')?.value }} \u2014 {{ $any(slot).get('slotType')?.value }}\r\n                </span>\r\n                <span class=\"text-muted small\">\r\n                  {{ $any(slot).get('brand')?.value || '(no brand)' }} \u00B7\r\n                  {{ $any(slot).get('fixtureLevelZone')?.value || '(no zone)' }}\r\n                </span>\r\n              </div>\r\n              <button type=\"button\" class=\"btn btn-sm btn-light-danger ms-2\" (click)=\"$event.stopPropagation(); removeSlot(s)\">\u00D7</button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n      <ng-template #noLook>\r\n        <div class=\"card p-5 h-100 text-center text-muted\">Select or add a Look to edit it.</div>\r\n      </ng-template>\r\n    </div>\r\n\r\n    <!-- Right: selected slot \u2014 placements editor -->\r\n    <div class=\"col-md-6\">\r\n      <ng-container *ngIf=\"selectedSlotGroup as slotGroup; else noSlot\">\r\n        <div class=\"card p-3 h-100\" [formGroup]=\"slotGroup\">\r\n          <h6 class=\"mb-3\">Fixture {{ selectedSlotIndex + 1 }} - Definition</h6>\r\n\r\n          <div class=\"row g-2 mb-3\">\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small text-muted\">Slot index (auto)</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" [value]=\"selectedSlotIndex + 1\" readonly disabled />\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Fixture Type</label>\r\n              <select class=\"form-select form-select-sm\" formControlName=\"slotType\">\r\n                <option *ngFor=\"let opt of availableSlotTypes\" [value]=\"opt.id\">{{ opt.name }}</option>\r\n              </select>\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Brand</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"brand\" placeholder=\"John Jacobs\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Header</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"fixtureLevelZone\" placeholder=\"Premium Trending\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">CAD Header Varients</label>\r\n              <lib-chips-input\r\n                formControlName=\"cadHeaderVariants\"\r\n                placeholder=\"Type a variant and press Enter\">\r\n              </lib-chips-input>\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Templates</label>\r\n              <multiselect-chip-dropdown\r\n                class=\"fixture-libraries-select\"\r\n                [items]=\"fixtureLibraryItemsForSlot\"\r\n                idField=\"id\"\r\n                nameField=\"name\"\r\n                [search]=\"true\"\r\n                searchField=\"name\"\r\n                placeholder=\"Select fixture templates\"\r\n                formControlName=\"fixtureLibraryRefs\">\r\n              </multiselect-chip-dropdown>\r\n              <small class=\"text-muted\" *ngIf=\"slotGroup.get('slotType')?.value === 'eurocenter'\">\r\n                Showing floor fixtures (eurocenter slot).\r\n              </small>\r\n              <small class=\"text-muted\" *ngIf=\"slotGroup.get('slotType')?.value !== 'eurocenter'\">\r\n                Showing wall fixtures (shelf slot).\r\n              </small>\r\n            </div>\r\n          </div>\r\n\r\n          <hr />\r\n\r\n          <div class=\"d-flex justify-content-between align-items-center mb-2\">\r\n            <h6 class=\"m-0\">Look and Visual Merchandising Placements</h6>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light\" (click)=\"addPlacement()\">+ Add placement</button>\r\n          </div>\r\n          <div *ngIf=\"(selectedPlacements?.length || 0) === 0\" class=\"text-muted small mb-2\">\r\n            No placements yet. Click <strong>+ Add placement</strong> to add one.\r\n          </div>\r\n          <div class=\"placements-scroll\" formArrayName=\"placements\">\r\n            <div\r\n              *ngFor=\"let p of (selectedPlacements?.controls || []); let pi = index; trackBy: trackByIndex\"\r\n              class=\"placement-row mb-2\"\r\n              [formGroupName]=\"pi\"\r\n            >\r\n              <div class=\"d-flex align-items-start gap-2 placement-fields\">\r\n                <div class=\"ph-field\">\r\n                  <select class=\"form-select form-select-sm\" formControlName=\"kind\">\r\n                    <option value=\"pid\">Product Merchandising</option>\r\n                    <option value=\"vm\">Visual Merchandising</option>\r\n                  </select>\r\n                </div>\r\n\r\n                <!-- Visual Merchandising rows: VM Type (single) + VM Artwork (single) -->\r\n                <ng-container *ngIf=\"$any(p).get('kind')?.value === 'vm'; else pidInputs\">\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"vmTypeOptions\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      placeholder=\"Visual Merchandising Type\"\r\n                      formControlName=\"position\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"vmArtworkOptionsFor($any(p).get('position')?.value)\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      placeholder=\"Visual Merchandising Artwork\"\r\n                      formControlName=\"rawValue\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                </ng-container>\r\n\r\n                <!-- Product Merchandising rows: Top/Mid/Bottom position + multi-select product/SKU -->\r\n                <ng-template #pidInputs>\r\n                  <div class=\"ph-field\">\r\n                    <select class=\"form-select form-select-sm\" formControlName=\"position\">\r\n                      <option value=\"\">Position</option>\r\n                      <option value=\"Top\">Top</option>\r\n                      <option value=\"Mid\">Mid</option>\r\n                      <option value=\"Bottom\">Bottom</option>\r\n                    </select>\r\n                  </div>\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"productOptions\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      [multiple]=\"true\"\r\n                      placeholder=\"Product / SKU\"\r\n                      formControlName=\"rawValues\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                </ng-template>\r\n\r\n                <button type=\"button\" class=\"btn btn-sm btn-light-danger ph-remove\" (click)=\"removePlacement(pi)\">\u00D7</button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n      <ng-template #noSlot>\r\n        <div class=\"card p-5 h-100 text-center text-muted\">Select a fixture slot to edit placements.</div>\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n\r\n  <!-- Per-slot Fixture Library Configuration card -->\r\n  <ng-container *ngIf=\"selectedSlotGroup as slotGroupForMap\">\r\n    <div class=\"card p-4 mt-4 library-config-card\" [formGroup]=\"slotGroupForMap\">\r\n      <div class=\"mb-4\">\r\n        <h5 class=\"form-label d-block mb-3\">Fixture library</h5>\r\n        <div class=\"library-chips\">\r\n          <button\r\n            *ngFor=\"let lib of selectedSlotLibrariesForDropdown\"\r\n            type=\"button\"\r\n            class=\"library-chip\"\r\n            [class.active]=\"selectedLibraryIdInMap === lib.id\"\r\n            (click)=\"onLibraryMapSelect(selectedLibraryIdInMap === lib.id ? '' : lib.id)\">\r\n            {{ lib.name }}\r\n          </button>\r\n        </div>\r\n        <small *ngIf=\"selectedSlotLibrariesForDropdown.length === 0\" class=\"text-muted\">\r\n          No libraries linked to this slot yet. Add some in the \"Fixture libraries\" multiselect above.\r\n        </small>\r\n      </div>\r\n\r\n      <div *ngIf=\"loadingLibraryDetails\" class=\"text-muted\">Loading fixture details\u2026</div>\r\n\r\n      <!--\r\n        Use *ngFor + trackBy keyed on (look, slot, library) so Angular treats\r\n        a switch as a new item \u2014 that forces the embedded template-products\r\n        / template-vms components to remount and rerun their ngOnInit\r\n        (otherwise their `isPageLoading` guard skips the form rebuild).\r\n      -->\r\n      <ng-container *ngFor=\"let _ of embeddedHostKeys; trackBy: trackByEmbeddedKey\">\r\n        <ul class=\"nav nav-tabs custom-tabs mb-3\">\r\n          <li class=\"nav-item\">\r\n            <button type=\"button\" class=\"nav-link\"\r\n              [class.active]=\"embeddedTab === 'products'\"\r\n              (click)=\"embeddedTab = 'products'\">Product Merchandising</button>\r\n          </li>\r\n          <li class=\"nav-item\">\r\n            <button type=\"button\" class=\"nav-link\"\r\n              [class.active]=\"embeddedTab === 'vms'\"\r\n              (click)=\"embeddedTab = 'vms'\">Visual Merchandising</button>\r\n          </li>\r\n        </ul>\r\n\r\n        <div *ngIf=\"embeddedTab === 'products'\">\r\n          <lib-template-products [looksMode]=\"true\"></lib-template-products>\r\n        </div>\r\n        <div *ngIf=\"embeddedTab === 'vms'\">\r\n          <lib-template-vms [looksMode]=\"true\"></lib-template-vms>\r\n        </div>\r\n      </ng-container>\r\n    </div>\r\n  </ng-container>\r\n</section>\r\n", styles: [".look-form .col-md-3>.card,.look-form .col-md-6>.card{display:flex!important;flex-direction:column;height:75vh!important;min-height:600px}.look-form .looks-tree,.look-form .slots-list,.look-form .placements-scroll{flex:1 1 auto;min-height:0;overflow-y:auto}.look-form .look-row,.look-form .slot-row{cursor:pointer;border:1px solid transparent;background:#f9fafb;transition:filter .15s ease,box-shadow .15s ease,border-color .15s ease}.look-form .look-row:hover,.look-form .slot-row:hover{filter:brightness(.96)}.look-form .look-row.selected,.look-form .slot-row.selected{filter:brightness(.96);outline:1px solid rgba(14,165,233,.55);outline-offset:-1px}.look-form .bucket-dot{display:inline-block;width:10px;height:10px;border-radius:50%;flex-shrink:0;border:1px solid rgba(0,0,0,.12)}.look-form .fixture-libraries-select{display:block}.look-form .fixture-libraries-select ::ng-deep .multiselect-container{align-items:flex-start}.look-form .fixture-libraries-select ::ng-deep .chip-list{max-height:84px;overflow-y:auto;padding-right:4px}.look-form .placement-row .placement-fields .ph-field{flex:1 1 0;min-width:0}.look-form .placement-row .placement-fields .ph-remove{flex:0 0 auto}.look-form .placement-row .placement-fields ::ng-deep multiselect-chip-dropdown .multiselect-container{padding:4px 10px;min-height:31px}.look-form .placement-row .placement-fields ::ng-deep multiselect-chip-dropdown .chip-list{min-height:21px}.look-form .placement-row .placement-fields ::ng-deep multiselect-chip-dropdown .multi-placeholder{font-size:13px;line-height:21px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.look-form .library-config-card .library-chips{display:flex;flex-wrap:wrap;gap:8px}.look-form .library-config-card .library-chip{background:#f1f5f9;border:1px solid #cbd5e1;color:#1e293b;border-radius:999px;padding:6px 14px;font-size:13px;font-weight:500;cursor:pointer;transition:background-color .15s ease,border-color .15s ease,color .15s ease}.look-form .library-config-card .library-chip:hover{background:#e2e8f0;border-color:#94a3b8}.look-form .library-config-card .library-chip.active{background:#0ea5e9;border-color:#0284c7;color:#fff}.look-form .library-config-card ::ng-deep #fixture-template-products .cols.col>ul.nav.nav-tabs.custom-tabs{display:none!important}.look-form .library-config-card ::ng-deep #fixture-template-products .cols.col-8>ul.nav.nav-tabs.custom-tabs{display:none!important}.look-form .library-config-card ::ng-deep #fixture-template-products input[readonly]{background-color:var(--bs-gray-200, #e9ecef);cursor:not-allowed}.look-form .library-config-card .fixture-preview{border:1px solid #e2e8f0;border-radius:8px;background:#fff;padding:12px}.look-form .library-config-card .fixture-preview .fx-header,.look-form .library-config-card .fixture-preview .fx-footer{background:#f1f5f9;border:1px dashed #cbd5e1;border-radius:6px;padding:6px 10px;font-size:12px;color:#475569;text-align:center;margin:4px 0}.look-form .library-config-card .fixture-preview .fx-body{display:flex;flex-direction:column;gap:4px;padding:4px 0}.look-form .library-config-card .fixture-preview .fx-shelf{background:linear-gradient(180deg,#f8fafc,#eef2f7);border:1px solid #cbd5e1;border-radius:4px;padding:8px 10px;display:flex;align-items:center;gap:8px;font-size:13px;min-height:36px}.look-form .library-config-card .fixture-preview .fx-shelf .fx-shelf-badge{background:#0ea5e9;color:#fff;font-weight:700;padding:2px 8px;border-radius:999px;font-size:11px;flex-shrink:0}.look-form .library-config-card .fixture-preview .fx-shelf .fx-shelf-label{font-weight:500;color:#1e293b}.look-form .library-config-card .fixture-preview .fx-shelf .fx-shelf-meta{color:#64748b;font-size:11px;margin-left:auto}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-tray{background:linear-gradient(180deg,#fef3c7,#fde68a);border-color:#f59e0b}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-tray .fx-shelf-badge{background:#d97706}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-vmonly{background:linear-gradient(180deg,#ede9fe,#ddd6fe);border-color:#8b5cf6}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-vmonly .fx-shelf-badge{background:#7c3aed}.look-form .library-config-card .fixture-preview .fx-dims{text-align:center}.look-form .library-config-card .shelf-mappings{max-height:70vh;overflow-y:auto;padding-right:4px}.look-form .library-config-card .shelf-mappings .shelf-mapping{border:1px solid #e5e7eb;border-radius:8px;padding:12px;background:#f9fafb}\n"], dependencies: [{ kind: "directive", type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1.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: i1.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i1.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i1.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.MinValidator, selector: "input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]", inputs: ["min"] }, { kind: "directive", type: i1.MaxValidator, selector: "input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]", inputs: ["max"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i1.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { kind: "directive", type: i1.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { kind: "component", type: i8.MultiselectChipDropdownComponent, selector: "multiselect-chip-dropdown", inputs: ["idField", "nameField", "placeholder", "items", "search", "searchField", "maxSelection", "compact", "extraActionLabel", "extraActionActive", "disabled"], outputs: ["extraActionClick"] }, { kind: "component", type: i9.TemplateProductsComponent, selector: "lib-template-products", inputs: ["looksMode"] }, { kind: "component", type: i10.SearchableSelectComponent, selector: "lib-searchable-select", inputs: ["items", "idField", "nameField", "searchField", "placeholder", "multiple", "compact"] }, { kind: "component", type: i11.ChipsInputComponent, selector: "lib-chips-input", inputs: ["placeholder", "allowDuplicates"] }, { kind: "component", type: i12.TemplateVmsComponent, selector: "lib-template-vms", inputs: ["looksMode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LookPlanoCollectionFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-look-plano-collection-form', template: "<section class=\"look-form\">\r\n  <!-- Top bar (bound to the outer form) -->\r\n  <div class=\"card p-4 mb-4\" [formGroup]=\"form\">\r\n    <div class=\"row align-items-end\">\r\n      <div class=\"col-md-4\">\r\n        <label class=\"form-label fw-bold\">Name *</label>\r\n        <input type=\"text\" class=\"form-control\" formControlName=\"name\" placeholder=\"e.g. Master Look Plan FY26\" />\r\n      </div>\r\n      <div class=\"col-md-5\">\r\n        <label class=\"form-label fw-bold\">Description</label>\r\n        <input type=\"text\" class=\"form-control\" formControlName=\"description\" placeholder=\"Optional description\" />\r\n      </div>\r\n      <div class=\"col-md-1 text-center\">\r\n        <label class=\"form-label fw-bold d-block\">Active</label>\r\n        <input type=\"checkbox\" class=\"form-check-input\" formControlName=\"isActive\" />\r\n      </div>\r\n      <div class=\"col-md-2 text-end\">\r\n        <button type=\"button\" class=\"btn btn-light me-2\" (click)=\"cancel()\">Cancel</button>\r\n        <button type=\"button\" class=\"btn btn-primary\" [disabled]=\"saving\" (click)=\"save()\">\r\n          {{ saving ? 'Saving\u2026' : 'Save' }}\r\n        </button>\r\n      </div>\r\n    </div>\r\n  </div>\r\n\r\n  <!-- Three-pane editor -->\r\n  <div class=\"row mx-0 g-3\">\r\n    <!-- Left: Looks list (no form binding needed \u2014 just navigation) -->\r\n    <div class=\"col-md-3\">\r\n      <div class=\"card p-3 h-100\">\r\n        <div class=\"d-flex justify-content-between align-items-center mb-3\">\r\n          <h6 class=\"m-0\">MBQ Bucket - Fixture Combinations</h6>\r\n          <button type=\"button\" class=\"btn btn-sm btn-primary\" (click)=\"addLook()\">+ Add Look</button>\r\n        </div>\r\n        <div *ngIf=\"looks.length === 0\" class=\"text-muted small\">No looks yet. Add one to start.</div>\r\n        <div class=\"looks-tree\">\r\n          <div\r\n            *ngFor=\"let look of looks.controls; let i = index; trackBy: trackByIndex\"\r\n            class=\"look-row d-flex justify-content-between align-items-center px-2 py-2 mb-1 rounded\"\r\n            [class.selected]=\"selectedLookIndex === i\"\r\n            [style.background-color]=\"bucketColor($any(look))\"\r\n            (click)=\"selectLook(i)\"\r\n          >\r\n            <span class=\"d-flex align-items-center gap-2 text-truncate\">\r\n              <span class=\"bucket-dot\" [style.background-color]=\"bucketColor($any(look))\"></span>\r\n              <span class=\"text-truncate\">{{ lookTitle($any(look)) }}</span>\r\n            </span>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light-danger ms-2\" (click)=\"$event.stopPropagation(); removeLook(i)\">\u00D7</button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n    <!-- Centre: selected Look metadata + slots -->\r\n    <div class=\"col-md-3\">\r\n      <ng-container *ngIf=\"selectedLookGroup as lookGroup; else noLook\">\r\n        <div class=\"card p-3 h-100\" [formGroup]=\"lookGroup\">\r\n          <h6 class=\"mb-3\">Fixture Combination Details</h6>\r\n\r\n          <div class=\"row g-2 mb-3\">\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">MBQ bucket</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"mbqBucket\" placeholder=\"e.g. JJ / OD Eye\" />\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Fixture count *</label>\r\n              <input type=\"number\" min=\"0\" max=\"30\" class=\"form-control form-control-sm\" formControlName=\"fixtureCount\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Positions</label>\r\n              <multiselect-chip-dropdown\r\n                [items]=\"fixtureTypeOptions\"\r\n                idField=\"id\"\r\n                nameField=\"name\"\r\n                placeholder=\"Select fixture position\"\r\n                formControlName=\"fixtureType\">\r\n              </multiselect-chip-dropdown>\r\n            </div>\r\n          </div>\r\n\r\n          <hr />\r\n\r\n          <div class=\"d-flex justify-content-between align-items-center mb-2\">\r\n            <h6 class=\"m-0\">Fixtures</h6>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light\" (click)=\"addSlot()\">+ Add Fixture</button>\r\n          </div>\r\n          <div class=\"slots-list\">\r\n            <div\r\n              *ngFor=\"let slot of (selectedSlotsArray?.controls || []); let s = index; trackBy: trackByIndex\"\r\n              class=\"slot-row d-flex justify-content-between align-items-center px-2 py-2 mb-1 rounded\"\r\n              [class.selected]=\"selectedSlotIndex === s\"\r\n              (click)=\"selectSlot(s)\"\r\n            >\r\n              <div class=\"d-flex flex-column\">\r\n                <span class=\"fw-bold small\">\r\n                  Fixture {{ $any(slot).get('slotIndex')?.value }} \u2014 {{ $any(slot).get('slotType')?.value }}\r\n                </span>\r\n                <span class=\"text-muted small\">\r\n                  {{ $any(slot).get('brand')?.value || '(no brand)' }} \u00B7\r\n                  {{ $any(slot).get('fixtureLevelZone')?.value || '(no zone)' }}\r\n                </span>\r\n              </div>\r\n              <button type=\"button\" class=\"btn btn-sm btn-light-danger ms-2\" (click)=\"$event.stopPropagation(); removeSlot(s)\">\u00D7</button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n      <ng-template #noLook>\r\n        <div class=\"card p-5 h-100 text-center text-muted\">Select or add a Look to edit it.</div>\r\n      </ng-template>\r\n    </div>\r\n\r\n    <!-- Right: selected slot \u2014 placements editor -->\r\n    <div class=\"col-md-6\">\r\n      <ng-container *ngIf=\"selectedSlotGroup as slotGroup; else noSlot\">\r\n        <div class=\"card p-3 h-100\" [formGroup]=\"slotGroup\">\r\n          <h6 class=\"mb-3\">Fixture {{ selectedSlotIndex + 1 }} - Definition</h6>\r\n\r\n          <div class=\"row g-2 mb-3\">\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small text-muted\">Slot index (auto)</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" [value]=\"selectedSlotIndex + 1\" readonly disabled />\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Fixture Type</label>\r\n              <select class=\"form-select form-select-sm\" formControlName=\"slotType\">\r\n                <option *ngFor=\"let opt of availableSlotTypes\" [value]=\"opt.id\">{{ opt.name }}</option>\r\n              </select>\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Brand</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"brand\" placeholder=\"John Jacobs\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Header</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"fixtureLevelZone\" placeholder=\"Premium Trending\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">CAD Header Varients</label>\r\n              <lib-chips-input\r\n                formControlName=\"cadHeaderVariants\"\r\n                placeholder=\"Type a variant and press Enter\">\r\n              </lib-chips-input>\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Templates</label>\r\n              <multiselect-chip-dropdown\r\n                class=\"fixture-libraries-select\"\r\n                [items]=\"fixtureLibraryItemsForSlot\"\r\n                idField=\"id\"\r\n                nameField=\"name\"\r\n                [search]=\"true\"\r\n                searchField=\"name\"\r\n                placeholder=\"Select fixture templates\"\r\n                formControlName=\"fixtureLibraryRefs\">\r\n              </multiselect-chip-dropdown>\r\n              <small class=\"text-muted\" *ngIf=\"slotGroup.get('slotType')?.value === 'eurocenter'\">\r\n                Showing floor fixtures (eurocenter slot).\r\n              </small>\r\n              <small class=\"text-muted\" *ngIf=\"slotGroup.get('slotType')?.value !== 'eurocenter'\">\r\n                Showing wall fixtures (shelf slot).\r\n              </small>\r\n            </div>\r\n          </div>\r\n\r\n          <hr />\r\n\r\n          <div class=\"d-flex justify-content-between align-items-center mb-2\">\r\n            <h6 class=\"m-0\">Look and Visual Merchandising Placements</h6>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light\" (click)=\"addPlacement()\">+ Add placement</button>\r\n          </div>\r\n          <div *ngIf=\"(selectedPlacements?.length || 0) === 0\" class=\"text-muted small mb-2\">\r\n            No placements yet. Click <strong>+ Add placement</strong> to add one.\r\n          </div>\r\n          <div class=\"placements-scroll\" formArrayName=\"placements\">\r\n            <div\r\n              *ngFor=\"let p of (selectedPlacements?.controls || []); let pi = index; trackBy: trackByIndex\"\r\n              class=\"placement-row mb-2\"\r\n              [formGroupName]=\"pi\"\r\n            >\r\n              <div class=\"d-flex align-items-start gap-2 placement-fields\">\r\n                <div class=\"ph-field\">\r\n                  <select class=\"form-select form-select-sm\" formControlName=\"kind\">\r\n                    <option value=\"pid\">Product Merchandising</option>\r\n                    <option value=\"vm\">Visual Merchandising</option>\r\n                  </select>\r\n                </div>\r\n\r\n                <!-- Visual Merchandising rows: VM Type (single) + VM Artwork (single) -->\r\n                <ng-container *ngIf=\"$any(p).get('kind')?.value === 'vm'; else pidInputs\">\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"vmTypeOptions\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      placeholder=\"Visual Merchandising Type\"\r\n                      formControlName=\"position\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"vmArtworkOptionsFor($any(p).get('position')?.value)\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      placeholder=\"Visual Merchandising Artwork\"\r\n                      formControlName=\"rawValue\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                </ng-container>\r\n\r\n                <!-- Product Merchandising rows: Top/Mid/Bottom position + multi-select product/SKU -->\r\n                <ng-template #pidInputs>\r\n                  <div class=\"ph-field\">\r\n                    <select class=\"form-select form-select-sm\" formControlName=\"position\">\r\n                      <option value=\"\">Position</option>\r\n                      <option value=\"Top\">Top</option>\r\n                      <option value=\"Mid\">Mid</option>\r\n                      <option value=\"Bottom\">Bottom</option>\r\n                    </select>\r\n                  </div>\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"productOptions\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      [multiple]=\"true\"\r\n                      placeholder=\"Product / SKU\"\r\n                      formControlName=\"rawValues\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                </ng-template>\r\n\r\n                <button type=\"button\" class=\"btn btn-sm btn-light-danger ph-remove\" (click)=\"removePlacement(pi)\">\u00D7</button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n      <ng-template #noSlot>\r\n        <div class=\"card p-5 h-100 text-center text-muted\">Select a fixture slot to edit placements.</div>\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n\r\n  <!-- Per-slot Fixture Library Configuration card -->\r\n  <ng-container *ngIf=\"selectedSlotGroup as slotGroupForMap\">\r\n    <div class=\"card p-4 mt-4 library-config-card\" [formGroup]=\"slotGroupForMap\">\r\n      <div class=\"mb-4\">\r\n        <h5 class=\"form-label d-block mb-3\">Fixture library</h5>\r\n        <div class=\"library-chips\">\r\n          <button\r\n            *ngFor=\"let lib of selectedSlotLibrariesForDropdown\"\r\n            type=\"button\"\r\n            class=\"library-chip\"\r\n            [class.active]=\"selectedLibraryIdInMap === lib.id\"\r\n            (click)=\"onLibraryMapSelect(selectedLibraryIdInMap === lib.id ? '' : lib.id)\">\r\n            {{ lib.name }}\r\n          </button>\r\n        </div>\r\n        <small *ngIf=\"selectedSlotLibrariesForDropdown.length === 0\" class=\"text-muted\">\r\n          No libraries linked to this slot yet. Add some in the \"Fixture libraries\" multiselect above.\r\n        </small>\r\n      </div>\r\n\r\n      <div *ngIf=\"loadingLibraryDetails\" class=\"text-muted\">Loading fixture details\u2026</div>\r\n\r\n      <!--\r\n        Use *ngFor + trackBy keyed on (look, slot, library) so Angular treats\r\n        a switch as a new item \u2014 that forces the embedded template-products\r\n        / template-vms components to remount and rerun their ngOnInit\r\n        (otherwise their `isPageLoading` guard skips the form rebuild).\r\n      -->\r\n      <ng-container *ngFor=\"let _ of embeddedHostKeys; trackBy: trackByEmbeddedKey\">\r\n        <ul class=\"nav nav-tabs custom-tabs mb-3\">\r\n          <li class=\"nav-item\">\r\n            <button type=\"button\" class=\"nav-link\"\r\n              [class.active]=\"embeddedTab === 'products'\"\r\n              (click)=\"embeddedTab = 'products'\">Product Merchandising</button>\r\n          </li>\r\n          <li class=\"nav-item\">\r\n            <button type=\"button\" class=\"nav-link\"\r\n              [class.active]=\"embeddedTab === 'vms'\"\r\n              (click)=\"embeddedTab = 'vms'\">Visual Merchandising</button>\r\n          </li>\r\n        </ul>\r\n\r\n        <div *ngIf=\"embeddedTab === 'products'\">\r\n          <lib-template-products [looksMode]=\"true\"></lib-template-products>\r\n        </div>\r\n        <div *ngIf=\"embeddedTab === 'vms'\">\r\n          <lib-template-vms [looksMode]=\"true\"></lib-template-vms>\r\n        </div>\r\n      </ng-container>\r\n    </div>\r\n  </ng-container>\r\n</section>\r\n", styles: [".look-form .col-md-3>.card,.look-form .col-md-6>.card{display:flex!important;flex-direction:column;height:75vh!important;min-height:600px}.look-form .looks-tree,.look-form .slots-list,.look-form .placements-scroll{flex:1 1 auto;min-height:0;overflow-y:auto}.look-form .look-row,.look-form .slot-row{cursor:pointer;border:1px solid transparent;background:#f9fafb;transition:filter .15s ease,box-shadow .15s ease,border-color .15s ease}.look-form .look-row:hover,.look-form .slot-row:hover{filter:brightness(.96)}.look-form .look-row.selected,.look-form .slot-row.selected{filter:brightness(.96);outline:1px solid rgba(14,165,233,.55);outline-offset:-1px}.look-form .bucket-dot{display:inline-block;width:10px;height:10px;border-radius:50%;flex-shrink:0;border:1px solid rgba(0,0,0,.12)}.look-form .fixture-libraries-select{display:block}.look-form .fixture-libraries-select ::ng-deep .multiselect-container{align-items:flex-start}.look-form .fixture-libraries-select ::ng-deep .chip-list{max-height:84px;overflow-y:auto;padding-right:4px}.look-form .placement-row .placement-fields .ph-field{flex:1 1 0;min-width:0}.look-form .placement-row .placement-fields .ph-remove{flex:0 0 auto}.look-form .placement-row .placement-fields ::ng-deep multiselect-chip-dropdown .multiselect-container{padding:4px 10px;min-height:31px}.look-form .placement-row .placement-fields ::ng-deep multiselect-chip-dropdown .chip-list{min-height:21px}.look-form .placement-row .placement-fields ::ng-deep multiselect-chip-dropdown .multi-placeholder{font-size:13px;line-height:21px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.look-form .library-config-card .library-chips{display:flex;flex-wrap:wrap;gap:8px}.look-form .library-config-card .library-chip{background:#f1f5f9;border:1px solid #cbd5e1;color:#1e293b;border-radius:999px;padding:6px 14px;font-size:13px;font-weight:500;cursor:pointer;transition:background-color .15s ease,border-color .15s ease,color .15s ease}.look-form .library-config-card .library-chip:hover{background:#e2e8f0;border-color:#94a3b8}.look-form .library-config-card .library-chip.active{background:#0ea5e9;border-color:#0284c7;color:#fff}.look-form .library-config-card ::ng-deep #fixture-template-products .cols.col>ul.nav.nav-tabs.custom-tabs{display:none!important}.look-form .library-config-card ::ng-deep #fixture-template-products .cols.col-8>ul.nav.nav-tabs.custom-tabs{display:none!important}.look-form .library-config-card ::ng-deep #fixture-template-products input[readonly]{background-color:var(--bs-gray-200, #e9ecef);cursor:not-allowed}.look-form .library-config-card .fixture-preview{border:1px solid #e2e8f0;border-radius:8px;background:#fff;padding:12px}.look-form .library-config-card .fixture-preview .fx-header,.look-form .library-config-card .fixture-preview .fx-footer{background:#f1f5f9;border:1px dashed #cbd5e1;border-radius:6px;padding:6px 10px;font-size:12px;color:#475569;text-align:center;margin:4px 0}.look-form .library-config-card .fixture-preview .fx-body{display:flex;flex-direction:column;gap:4px;padding:4px 0}.look-form .library-config-card .fixture-preview .fx-shelf{background:linear-gradient(180deg,#f8fafc,#eef2f7);border:1px solid #cbd5e1;border-radius:4px;padding:8px 10px;display:flex;align-items:center;gap:8px;font-size:13px;min-height:36px}.look-form .library-config-card .fixture-preview .fx-shelf .fx-shelf-badge{background:#0ea5e9;color:#fff;font-weight:700;padding:2px 8px;border-radius:999px;font-size:11px;flex-shrink:0}.look-form .library-config-card .fixture-preview .fx-shelf .fx-shelf-label{font-weight:500;color:#1e293b}.look-form .library-config-card .fixture-preview .fx-shelf .fx-shelf-meta{color:#64748b;font-size:11px;margin-left:auto}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-tray{background:linear-gradient(180deg,#fef3c7,#fde68a);border-color:#f59e0b}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-tray .fx-shelf-badge{background:#d97706}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-vmonly{background:linear-gradient(180deg,#ede9fe,#ddd6fe);border-color:#8b5cf6}.look-form .library-config-card .fixture-preview .fx-shelf.fx-shelf-vmonly .fx-shelf-badge{background:#7c3aed}.look-form .library-config-card .fixture-preview .fx-dims{text-align:center}.look-form .library-config-card .shelf-mappings{max-height:70vh;overflow-y:auto;padding-right:4px}.look-form .library-config-card .shelf-mappings .shelf-mapping{border:1px solid #e5e7eb;border-radius:8px;padding:12px;background:#f9fafb}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormBuilder }, { type: i2.ActivatedRoute }, { type: i2.Router }, { type: i3.GlobalStateService }, { type: i4.StoreBuilderService }, { type: i5.ToastService }, { type: i3.PageInfoService }, { type: i6.PlanoDataService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"look-plano-collection-form.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-store-builder/src/lib/components/look-plano-collection-form/look-plano-collection-form.component.ts","../../../../../../projects/tango-store-builder/src/lib/components/look-plano-collection-form/look-plano-collection-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnDestroy, OnInit } from '@angular/core';\r\nimport { FormArray, FormBuilder, FormGroup, Validators } from '@angular/forms';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { debounceTime, lastValueFrom, Subject, takeUntil } from 'rxjs';\r\nimport { GlobalStateService, PageInfoService } from 'tango-app-ui-global';\r\nimport { ToastService } from 'tango-app-ui-shared';\r\nimport { StoreBuilderService } from '../../services/store-builder.service';\r\nimport { PlanoDataService } from '../../services/plano-data.service';\r\n\r\n@Component({\r\n  selector: 'lib-look-plano-collection-form',\r\n  templateUrl: './look-plano-collection-form.component.html',\r\n  styleUrl: './look-plano-collection-form.component.scss',\r\n})\r\nexport class LookPlanoCollectionFormComponent implements OnInit, OnDestroy {\r\n  clientId = '';\r\n  collectionId: string | null = null;\r\n  isNew = true;\r\n  loading = false;\r\n  saving = false;\r\n\r\n  form!: FormGroup;\r\n  selectedLookIndex: number = -1;\r\n  selectedSlotIndex: number = -1;\r\n\r\n  // Display labels are Wall / Floor; the stored ids stay 'shelf' / 'eurocenter'\r\n  // so the library filter, slot defaults, and the backend slotType/fixtureType\r\n  // enums keep working unchanged ('shelf' → wall fixtures, 'eurocenter' → floor).\r\n  readonly fixtureTypeOptions = [\r\n    { id: 'shelf', name: 'Wall' },\r\n    { id: 'eurocenter', name: 'Floor' },\r\n  ];\r\n\r\n  fixtureLibraryItems: { id: string; name: string; fixtureType: string }[] = [];\r\n\r\n  // Dropdowns inside placement rows.\r\n  vmTypeOptions: { value: string; label: string }[] = [];\r\n  vmArtworkOptions: { value: string; label: string; vmType?: string }[] = [];\r\n  productOptions: { value: string; label: string }[] = [];\r\n  /** Cached per-vmType artwork list — same reference returned each lookup so\r\n   *  lib-reactive-select doesn't reset state every CD cycle. */\r\n  private vmArtworkByType: Map<string, { value: string; label: string }[]> = new Map();\r\n  /** (vmName||vmType) and (vmName) → planovm _id, so a VM placement's artwork\r\n   *  name can be resolved to the _id the embedded VM editor matches against. */\r\n  private vmIdByNameType: Map<string, string> = new Map();\r\n  /**\r\n   * Cached filtered list bound to the \"Fixture libraries\" multiselect.\r\n   * Must NOT be a getter — the underlying multiselect re-clones its items on\r\n   * every ngOnChanges, which detaches click targets and breaks selection.\r\n   */\r\n  fixtureLibraryItemsForSlot: { id: string; name: string; fixtureType: string }[] = [];\r\n\r\n  // State for the per-slot Fixture Library Configuration card.\r\n  selectedLibraryIdInMap: string = '';\r\n  selectedLibraryDetails: any = null;\r\n  loadingLibraryDetails: boolean = false;\r\n  embeddedTab: 'products' | 'vms' = 'products';\r\n\r\n  // === Fixture Library Configuration card helpers ===\r\n\r\n  /** Slot's placements with kind = 'vm', exposed as dropdown items. */\r\n  get currentSlotVmItems(): { id: string; name: string }[] {\r\n    return this.placementsToItems('vm');\r\n  }\r\n\r\n  /** Slot's placements with kind = 'pid', exposed as dropdown items. */\r\n  get currentSlotPidItems(): { id: string; name: string }[] {\r\n    return this.placementsToItems('pid');\r\n  }\r\n\r\n  private placementsToItems(kind: 'vm' | 'pid'): { id: string; name: string }[] {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) return [];\r\n    const arr = slot.get('placements') as FormArray | null;\r\n    if (!arr) return [];\r\n    return arr.controls\r\n        .map((c) => c.value)\r\n        .filter((p: any) => p?.kind === kind && p?.position)\r\n        .map((p: any) => ({\r\n          id: p.position,\r\n          name: p.rawValue ? `${p.position} — ${p.rawValue}` : p.position,\r\n        }));\r\n  }\r\n\r\n  /** Fixture-library options for the dropdown — filtered to the libraries\r\n   *  selected on the currently-active slot's multiselect. */\r\n  get selectedSlotLibrariesForDropdown(): { id: string; name: string }[] {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) return [];\r\n    const refs: string[] = slot.get('fixtureLibraryRefs')?.value || [];\r\n    return this.fixtureLibraryItems.filter((item) => refs.includes(item.id));\r\n  }\r\n\r\n  /** The FormArray that stores per-(library, shelf) VM/PID values for the active slot. */\r\n  get selectedSlotLibraryConfigs(): FormArray | null {\r\n    const slot = this.selectedSlotGroup;\r\n    return slot ? (slot.get('libraryConfigurations') as FormArray) : null;\r\n  }\r\n\r\n  /** Form-array entries scoped to the currently-shown library in the config card. */\r\n  configEntriesForCurrentLibrary(): { control: FormGroup; arrayIndex: number }[] {\r\n    const configs = this.selectedSlotLibraryConfigs;\r\n    if (!configs || !this.selectedLibraryIdInMap) return [];\r\n    return configs.controls\r\n        .map((c, i) => ({ control: c as FormGroup, arrayIndex: i }))\r\n        .filter((x) => x.control.get('libraryRef')?.value === this.selectedLibraryIdInMap);\r\n  }\r\n\r\n  /** Reset card state whenever the active slot changes so we don't carry over\r\n   *  stale selections from a previously-viewed slot. */\r\n  private resetLibraryMap(): void {\r\n    this.selectedLibraryIdInMap = '';\r\n    this.selectedLibraryDetails = null;\r\n    this.refreshEmbeddedHostKeys();\r\n    // Clear the shared BehaviorSubject too so the embedded TemplateProducts /\r\n    // TemplateVms components, if they're still mounted, don't render stale\r\n    // data from the previous slot's library.\r\n    this.planoDataService.fixtureTemplateDetails.next(null);\r\n  }\r\n\r\n  /** When a slot is loaded, automatically pick the first library it has linked\r\n   *  so the embedded fixture-template editor opens straight to that library. */\r\n  private autoSelectFirstLibrary(): void {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) return;\r\n    const refs: string[] = slot.get('fixtureLibraryRefs')?.value || [];\r\n    const firstId = refs.find((id) => !!id);\r\n    if (!firstId) return;\r\n    if (this.selectedLibraryIdInMap === firstId) return;\r\n    this.onLibraryMapSelect(firstId);\r\n  }\r\n\r\n  /** Read the slot's saved snapshot for a library, if any. */\r\n  private getLibrarySnapshot(libId: string): any | null {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) return null;\r\n    const snaps: any[] = slot.get('librarySnapshots')?.value || [];\r\n    const entry = snaps.find((s) => s?.libraryRef === libId);\r\n    return entry?.snapshot || null;\r\n  }\r\n\r\n  /** Persist a snapshot into the slot's librarySnapshots FormControl. */\r\n  private captureLibrarySnapshot(libId: string, snapshot: any): void {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot || !libId) return;\r\n    const ctrl = slot.get('librarySnapshots');\r\n    if (!ctrl) return;\r\n    const current: any[] = Array.isArray(ctrl.value) ? [...ctrl.value] : [];\r\n    // Strip the ignoreUpdate flag before saving so we don't echo it back later.\r\n    const { ignoreUpdate: _ignored, ...clean } = snapshot || {};\r\n    const i = current.findIndex((s) => s?.libraryRef === libId);\r\n    if (i >= 0) {\r\n      current[i] = { libraryRef: libId, snapshot: clean };\r\n    } else {\r\n      current.push({ libraryRef: libId, snapshot: clean });\r\n    }\r\n    ctrl.setValue(current);\r\n  }\r\n\r\n  /** Resolve a VM placement's artwork NAME (+ vmType) to its planovm _id. */\r\n  private resolveVmId(vmName: string, vmType: string): string {\r\n    const name = this.normVmType(vmName);\r\n    const type = this.normVmType(vmType);\r\n    return (\r\n      this.vmIdByNameType.get(`${name}||${type}`) ||\r\n      this.vmIdByNameType.get(name) ||\r\n      vmName\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Re-derive every assigned library's snapshot from the active slot's\r\n   * current placements. Driven by the \"Look and Visual Merchandising\r\n   * Placements\" list — so editing one placement updates ALL assigned\r\n   * libraries at once.\r\n   *\r\n   *  - PID placements: `position` (Top/Mid/Bottom) → shelf zone; the shelf's\r\n   *    productBrandName is OVERWRITTEN with the placement's product list.\r\n   *  - VM placements: `position` → vmType; the matching vmConfig entry's\r\n   *    artwork (vmId/vmName) is updated while the library keeps its own VM\r\n   *    positions. vmTypes not yet present are appended.\r\n   */\r\n  private applyPlacementsToAssignedLibraries(): void {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) return;\r\n    const refs: string[] = (slot.get('fixtureLibraryRefs')?.value || [])\r\n        .filter((r: string) => !!r);\r\n    if (!refs.length) return;\r\n\r\n    const placements: any[] = (slot.get('placements') as FormArray | null)?.value || [];\r\n    const norm = (s: any): string => String(s ?? '').trim().toLowerCase();\r\n\r\n    // zone -> product list (PIDs); supports both rawValues[] and legacy rawValue.\r\n    const pidByZone = new Map<string, string[]>();\r\n    for (const p of placements) {\r\n      if (p?.kind !== 'pid' || !p?.position) continue;\r\n      const vals: string[] = Array.isArray(p.rawValues) && p.rawValues.length\r\n        ? p.rawValues.filter((v: string) => !!v)\r\n        : (p.rawValue ? [ String(p.rawValue) ] : []);\r\n      if (vals.length) pidByZone.set(norm(p.position), vals);\r\n    }\r\n\r\n    // vmType -> { vmId, vmName, label } (VMs)\r\n    const vmByType = new Map<string, { vmId: string; vmName: string; label: string }>();\r\n    for (const p of placements) {\r\n      if (p?.kind !== 'vm' || !p?.position || !p?.rawValue) continue;\r\n      const label = String(p.position);\r\n      vmByType.set(norm(label), {\r\n        vmId: this.resolveVmId(String(p.rawValue), label),\r\n        vmName: String(p.rawValue),\r\n        label,\r\n      });\r\n    }\r\n\r\n    for (const libId of refs) {\r\n      const target = this.getLibrarySnapshot(libId);\r\n      if (!target) continue; // seed creates one per assigned library\r\n\r\n      const shelves: any[] = Array.isArray(target.shelfConfig) ? target.shelfConfig : [];\r\n      const newShelfConfig = shelves.map((shelf: any) => {\r\n        const zone = norm(shelf?.zone || shelf?.label);\r\n        if (!zone || !pidByZone.has(zone)) return shelf;\r\n        return {\r\n          ...shelf,\r\n          zone: shelf?.zone || shelf?.label || '',\r\n          productBrandName: [ ...pidByZone.get(zone)! ],\r\n        };\r\n      });\r\n\r\n      const existingVms: any[] = Array.isArray(target.vmConfig) ? target.vmConfig : [];\r\n      const seen = new Set<string>();\r\n      const newVmConfig = existingVms.map((vm: any) => {\r\n        const key = norm(vm?.vmType);\r\n        seen.add(key);\r\n        const upd = vmByType.get(key);\r\n        return upd ? { ...vm, vmId: upd.vmId, vmName: upd.vmName } : vm;\r\n      });\r\n      for (const [ key, upd ] of vmByType) {\r\n        if (seen.has(key)) continue;\r\n        newVmConfig.push({\r\n          vmType: upd.label,\r\n          vmId: upd.vmId,\r\n          vmName: upd.vmName,\r\n          startYPosition: 1,\r\n          endYPosition: 1,\r\n          xZone: '',\r\n          yZone: '',\r\n          position: '',\r\n        });\r\n      }\r\n\r\n      this.captureLibrarySnapshot(libId, {\r\n        ...target,\r\n        shelfConfig: newShelfConfig,\r\n        vmConfig: newVmConfig,\r\n        productResolutionLevel: 'L3',\r\n      });\r\n    }\r\n\r\n    // Reflect the change in the currently-open embedded editor.\r\n    this.reloadDisplayedLibrary();\r\n  }\r\n\r\n  /**\r\n   * Remount the embedded editor for the active library so it picks up the\r\n   * snapshot we just rewrote. The embedded components guard against re-init\r\n   * while mounted, so we toggle the host key off then on to force a fresh\r\n   * ngOnInit with the updated data.\r\n   */\r\n  private reloadDisplayedLibrary(): void {\r\n    const libId = this.selectedLibraryIdInMap;\r\n    if (!libId) return;\r\n    const updated = this.getLibrarySnapshot(libId);\r\n    if (!updated) return;\r\n    this.selectedLibraryDetails = updated;\r\n    // Push the fresh snapshot, then bump the nonce so refreshEmbeddedHostKeys\r\n    // produces a NEW key — that's what actually forces the *ngFor to destroy\r\n    // the old embedded editor and mount a new one that re-reads the snapshot.\r\n    this.planoDataService.fixtureTemplateDetails.next({\r\n      ...updated,\r\n      productResolutionLevel: updated.productResolutionLevel || 'L3',\r\n    });\r\n    this.embeddedReloadNonce++;\r\n    this.refreshEmbeddedHostKeys();\r\n  }\r\n\r\n  async onLibraryMapSelect(libId: string): Promise<void> {\r\n    // Toggling the active chip off → clear immediately (no async work needed).\r\n    if (!libId) {\r\n      this.selectedLibraryIdInMap = '';\r\n      this.selectedLibraryDetails = null;\r\n      this.refreshEmbeddedHostKeys();\r\n      this.planoDataService.fixtureTemplateDetails.next(null);\r\n      return;\r\n    }\r\n\r\n    // Switching to a different chip: light the new chip up right away, but\r\n    // KEEP the previous library's embedded preview mounted while we fetch\r\n    // the new snapshot/details. Otherwise the card would collapse to its\r\n    // header height during the fetch and re-expand once new data lands —\r\n    // visible as a \"crunch\" the user reported.\r\n    this.selectedLibraryIdInMap = libId;\r\n    this.loadingLibraryDetails = true;\r\n\r\n    let newDetails: any = null;\r\n    try {\r\n      // If an auto-apply for this library is still running, wait for it so\r\n      // we don't beat it to the snapshot and render the un-filled library.\r\n      const pending = this.autoApplyInFlight.get(libId);\r\n      if (pending) {\r\n        try { await pending; } catch (_e) { /* ignore */ }\r\n      }\r\n      const saved = this.getLibrarySnapshot(libId);\r\n      if (saved) {\r\n        newDetails = saved;\r\n      } else {\r\n        const res: any = await lastValueFrom(\r\n          this.builderService.getFixtureLibraryDetails(libId),\r\n        );\r\n        newDetails = res?.data || null;\r\n      }\r\n    } catch (err) {\r\n      console.log('@@ ~ onLibraryMapSelect [ERR]:', err);\r\n      newDetails = null;\r\n    }\r\n\r\n    // Atomic swap — selectedLibraryDetails, BehaviorSubject, and the\r\n    // ngFor host key all flip in one synchronous block, so Angular destroys\r\n    // the old embedded component and mounts the new one in the same change\r\n    // detection cycle. No empty-state in between → no card-height crunch.\r\n    this.selectedLibraryDetails = newDetails;\r\n    if (newDetails) {\r\n      this.planoDataService.fixtureTemplateDetails.next({\r\n        ...newDetails,\r\n        productResolutionLevel: newDetails.productResolutionLevel || 'L3',\r\n      });\r\n    } else {\r\n      this.planoDataService.fixtureTemplateDetails.next(null);\r\n    }\r\n    this.refreshEmbeddedHostKeys();\r\n    this.loadingLibraryDetails = false;\r\n  }\r\n\r\n  /**\r\n   * Composite key tied to the currently-active (look, slot, library) triple.\r\n   * Stable property — recomputed only when the underlying selection changes\r\n   * (see refreshEmbeddedHostKeys()). Avoids returning a new array reference\r\n   * every CD cycle, which used to ripple into other multi-selects' inputs.\r\n   */\r\n  embeddedHostKey: string = '';\r\n  embeddedHostKeys: string[] = [];\r\n  // Bumped by reloadDisplayedLibrary() to force the embedded editor to remount\r\n  // even when look/slot/library are unchanged (a same-key round-trip via the\r\n  // *ngFor trackBy does NOT remount; a changed key does).\r\n  private embeddedReloadNonce = 0;\r\n\r\n  private refreshEmbeddedHostKeys(): void {\r\n    const key = `${this.selectedLookIndex}-${this.selectedSlotIndex}-${this.selectedLibraryIdInMap}-${this.embeddedReloadNonce}`;\r\n    if (key !== this.embeddedHostKey) {\r\n      this.embeddedHostKey = key;\r\n    }\r\n    const next = this.selectedLibraryDetails ? [this.embeddedHostKey] : [];\r\n    const current = this.embeddedHostKeys;\r\n    // Only assign a new array if the contents differ — otherwise the ngFor sees\r\n    // a \"new\" array each CD and trackBy still has to compare every entry.\r\n    if (next.length !== current.length || next[0] !== current[0]) {\r\n      this.embeddedHostKeys = next;\r\n    }\r\n  }\r\n\r\n  trackByEmbeddedKey(_: number, key: string): string {\r\n    return key;\r\n  }\r\n\r\n  /**\r\n   * The slot-type dropdown in the right pane only offers values that the\r\n   * parent Look has selected in its Fixture Type multiselect. If nothing is\r\n   * selected yet, fall back to showing all options so the user isn't blocked.\r\n   */\r\n  get availableSlotTypes(): { id: string; name: string }[] {\r\n    const lookGroup = this.selectedLookGroup;\r\n    if (!lookGroup) return this.fixtureTypeOptions;\r\n    const selected = lookGroup.get('fixtureType')?.value as string[] | null;\r\n    if (!Array.isArray(selected) || selected.length === 0) {\r\n      return this.fixtureTypeOptions;\r\n    }\r\n    return this.fixtureTypeOptions.filter((opt) => selected.includes(opt.id));\r\n  }\r\n\r\n  // 20 very mild pastels (all Tailwind-50 / 100 range) arranged so adjacent\r\n  // palette slots are on opposite sides of the colour wheel for distinguish-\r\n  // ability without any colour feeling saturated.\r\n  private static readonly BUCKET_PALETTE: readonly string[] = [\r\n    '#fef2f2', //  1 Blush          red-50\r\n    '#f0fdfa', //  2 Mint Whisper   teal-50    (opposite of red)\r\n    '#fff7ed', //  3 Apricot        orange-50\r\n    '#eef2ff', //  4 Iris           indigo-50  (opposite of orange)\r\n    '#fefce8', //  5 Butter         yellow-50\r\n    '#faf5ff', //  6 Lavender       purple-50  (opposite of yellow)\r\n    '#f0fdf4', //  7 Spring         green-50\r\n    '#fff1f2', //  8 Rose Petal     rose-50    (opposite of green)\r\n    '#ecfeff', //  9 Sky Tint       cyan-50\r\n    '#ffedd5', // 10 Peach          orange-100\r\n    '#eff6ff', // 11 Powder Blue    blue-50\r\n    '#f0f9ff', // 12 Sky            sky-50     (opposite of orange)\r\n    '#f5f3ff', // 13 Violet Mist    violet-50\r\n    '#f7fee7', // 14 Lime Whisper   lime-50    (opposite of violet)\r\n    '#fdf4ff', // 15 Lilac          fuchsia-50\r\n    '#ecfdf5', // 16 Mint           emerald-50\r\n    '#fdf2f8', // 17 Petal Pink     pink-50\r\n    '#fffbeb', // 18 Honey          amber-50\r\n    '#f1f5f9', // 19 Cloud          slate-100\r\n    '#f5f5f4', // 20 Linen          stone-100\r\n  ];\r\n\r\n  private destroy$ = new Subject<void>();\r\n\r\n  constructor(\r\n    private fb: FormBuilder,\r\n    private route: ActivatedRoute,\r\n    private router: Router,\r\n    private gs: GlobalStateService,\r\n    private builderService: StoreBuilderService,\r\n    private toast: ToastService,\r\n    private pageInfo: PageInfoService,\r\n    private planoDataService: PlanoDataService,\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.setPageData();\r\n    this.initForm();\r\n\r\n    // Listen to the shared fixtureTemplateDetails — when the embedded\r\n    // TemplateProducts/TemplateVms components push edits back into the\r\n    // BehaviorSubject, persist a snapshot under the active slot + library.\r\n    this.planoDataService.fixtureTemplateDetails\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((data: any) => {\r\n        if (!data || !this.selectedLibraryIdInMap) return;\r\n        // Only capture user edits, not the initial load we pushed ourselves.\r\n        // The embedded components set `ignoreUpdate: true` when they push\r\n        // their form changes back; we use that as our signal.\r\n        if (!data.ignoreUpdate) return;\r\n        // Persist edits made directly in the embedded editor (e.g. VM\r\n        // positions, which stay editable in looksMode) to the active library.\r\n        // Cross-library propagation is driven by the slot's placements list\r\n        // instead (see applyPlacementsToAssignedLibraries).\r\n        this.captureLibrarySnapshot(this.selectedLibraryIdInMap, data);\r\n      });\r\n\r\n    this.gs.dataRangeValue.pipe(takeUntil(this.destroy$)).subscribe((data) => {\r\n      const headerFilters = JSON.parse(localStorage.getItem('header-filters') || '{}');\r\n      this.clientId = data?.client || headerFilters?.client;\r\n      if (this.clientId) {\r\n        this.loadFixtureLibraries();\r\n        this.loadPlacementDropdownData();\r\n      }\r\n    });\r\n\r\n    this.route.params.pipe(takeUntil(this.destroy$)).subscribe(async (params) => {\r\n      const id = params['collectionId'];\r\n      this.collectionId = id && id !== 'new' ? id : null;\r\n      this.isNew = !this.collectionId;\r\n      if (this.collectionId) {\r\n        await this.loadDetails();\r\n      }\r\n    });\r\n\r\n    // Embedded TemplateProductsComponent / TemplateVmsComponent read these\r\n    // query params from the active route. Force them to edit-mode and pin\r\n    // the products view to the \"section\" level.\r\n    this.router.navigate([], {\r\n      relativeTo: this.route,\r\n      queryParams: { isEdit: 'true', level: 'section' },\r\n      queryParamsHandling: 'merge',\r\n      replaceUrl: true,\r\n    });\r\n  }\r\n\r\n  setPageData() {\r\n    this.pageInfo.setTitle('Look Collection');\r\n    this.pageInfo.setBreadcrumbs([\r\n      { title: 'Planogram', path: '/manage/planogram/manage-planograms', isActive: false, isSeparator: false },\r\n      { title: '', path: '', isActive: false, isSeparator: true },\r\n      { title: 'Looks', path: '/manage/planogram/looks', isActive: false, isSeparator: false },\r\n      { title: '', path: '', isActive: false, isSeparator: true },\r\n      { title: 'Edit', path: '', isActive: true, isSeparator: false },\r\n    ]);\r\n  }\r\n\r\n  initForm() {\r\n    this.form = this.fb.group({\r\n      name: ['', Validators.required],\r\n      description: [''],\r\n      isActive: [false],\r\n      looks: this.fb.array([]),\r\n    });\r\n  }\r\n\r\n  get looks(): FormArray {\r\n    return this.form.get('looks') as FormArray;\r\n  }\r\n\r\n  fixtureSlots(lookIndex: number): FormArray {\r\n    return this.looks.at(lookIndex).get('fixtureSlots') as FormArray;\r\n  }\r\n\r\n  placements(lookIndex: number, slotIndex: number): FormArray {\r\n    return this.fixtureSlots(lookIndex).at(slotIndex).get('placements') as FormArray;\r\n  }\r\n\r\n  get selectedLookGroup(): FormGroup | null {\r\n    return this.selectedLookIndex >= 0 && this.selectedLookIndex < this.looks.length\r\n      ? (this.looks.at(this.selectedLookIndex) as FormGroup)\r\n      : null;\r\n  }\r\n\r\n  get selectedSlotsArray(): FormArray | null {\r\n    const look = this.selectedLookGroup;\r\n    return look ? (look.get('fixtureSlots') as FormArray) : null;\r\n  }\r\n\r\n  get selectedSlotGroup(): FormGroup | null {\r\n    const slots = this.selectedSlotsArray;\r\n    if (!slots) return null;\r\n    return this.selectedSlotIndex >= 0 && this.selectedSlotIndex < slots.length\r\n      ? (slots.at(this.selectedSlotIndex) as FormGroup)\r\n      : null;\r\n  }\r\n\r\n  get selectedPlacements(): FormArray | null {\r\n    const slot = this.selectedSlotGroup;\r\n    return slot ? (slot.get('placements') as FormArray) : null;\r\n  }\r\n\r\n  createLookGroup(seed: any = {}): FormGroup {\r\n    const seedSlots = Array.isArray(seed.fixtureSlots) && seed.fixtureSlots.length\r\n      ? seed.fixtureSlots\r\n      : Array.from({ length: Math.max(1, Number(seed.fixtureCount) || 1) }, (_, i) => ({ slotIndex: i + 1 }));\r\n    const slots = seedSlots.map((s: any, i: number) => this.createSlotGroup({ ...s, slotIndex: i + 1 }));\r\n\r\n    const lookGroup = this.fb.group({\r\n      keyType: [seed.keyType || 'mbq'],\r\n      mbqBucket: [seed.mbqBucket || ''],\r\n      brandCategory: [seed.brandCategory || ''],\r\n      fixtureCount: [slots.length, [Validators.required, Validators.min(0)]],\r\n      fixtureType: [Array.isArray(seed.fixtureType) ? seed.fixtureType : []],\r\n      layoutVariant: [seed.layoutVariant || 'shelf'],\r\n      storeProto: [seed.storeProto || ''],\r\n      fixtureSlots: this.fb.array(slots),\r\n    });\r\n\r\n    // fixtureCount → slots length (user-edited count adjusts the slots array)\r\n    lookGroup.get('fixtureCount')!.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((next: number) => {\r\n        const target = Math.max(0, Math.min(30, Number(next) || 0));\r\n        const slotsArr = lookGroup.get('fixtureSlots') as FormArray;\r\n        while (slotsArr.length < target) {\r\n          slotsArr.push(this.createSlotGroup({ slotIndex: slotsArr.length + 1 }));\r\n        }\r\n        while (slotsArr.length > target) {\r\n          slotsArr.removeAt(slotsArr.length - 1);\r\n        }\r\n        this.renumberSlotsForGroup(lookGroup);\r\n        // Reconcile slot selection if it's now out of bounds\r\n        if (this.selectedLookIndex >= 0 && this.looks.at(this.selectedLookIndex) === lookGroup) {\r\n          if (slotsArr.length === 0) {\r\n            this.selectedSlotIndex = -1;\r\n          } else if (this.selectedSlotIndex >= slotsArr.length) {\r\n            this.selectedSlotIndex = slotsArr.length - 1;\r\n          } else if (this.selectedSlotIndex < 0) {\r\n            this.selectedSlotIndex = 0;\r\n          }\r\n        }\r\n      });\r\n\r\n    return lookGroup;\r\n  }\r\n\r\n  createSlotGroup(seed: any = {}): FormGroup {\r\n    const placements = (Array.isArray(seed.placements) ? seed.placements : [])\r\n      .map((p: any) => this.createPlacementGroup(p));\r\n    const libraryConfigs = (Array.isArray(seed.libraryConfigurations) ? seed.libraryConfigurations : [])\r\n      .map((c: any) => this.createLibraryConfigGroup(c));\r\n    return this.fb.group({\r\n      slotIndex: [seed.slotIndex ?? 1, Validators.required],\r\n      slotType: [seed.slotType || 'shelf'],\r\n      brand: [seed.brand || ''],\r\n      fixtureLevelZone: [seed.fixtureLevelZone || ''],\r\n      fixtureLibraryRef: [seed.fixtureLibraryRef || ''],\r\n      fixtureLibraryLabel: [seed.fixtureLibraryLabel || ''],\r\n      fixtureLibraryRefs: [Array.isArray(seed.fixtureLibraryRefs) ? seed.fixtureLibraryRefs : []],\r\n      cadHeaderVariants: [Array.isArray(seed.cadHeaderVariants) ? seed.cadHeaderVariants : []],\r\n      placements: this.fb.array(placements),\r\n      libraryConfigurations: this.fb.array(libraryConfigs),\r\n      // Per-library snapshot of the embedded fixture-template editor state\r\n      // (shelfConfig + product/VM placements). Keyed by libraryRef.\r\n      librarySnapshots: [\r\n        Array.isArray(seed.librarySnapshots) ? seed.librarySnapshots : [],\r\n      ],\r\n    });\r\n  }\r\n\r\n  createLibraryConfigGroup(seed: any = {}): FormGroup {\r\n    return this.fb.group({\r\n      libraryRef: [seed.libraryRef || ''],\r\n      shelfNumber: [seed.shelfNumber ?? 1],\r\n      label: [seed.label || ''],\r\n      shelfType: [seed.shelfType || ''],\r\n      // VMs and PIDs picked from the slot's `placements` array (by position name).\r\n      vmRefs: [Array.isArray(seed.vmRefs) ? seed.vmRefs : []],\r\n      pidRefs: [Array.isArray(seed.pidRefs) ? seed.pidRefs : []],\r\n    });\r\n  }\r\n\r\n  createPlacementGroup(seed: any = {}): FormGroup {\r\n    // Backward-compat: legacy data stored a single string in `rawValue`. For\r\n    // PID placements we now use `rawValues` (array, multi-select). If the\r\n    // seed only has `rawValue`, migrate it to the array on first load.\r\n    const rawValuesSeed = Array.isArray(seed.rawValues)\r\n      ? seed.rawValues\r\n      : (seed.kind === 'pid' && seed.rawValue ? [String(seed.rawValue)] : []);\r\n    return this.fb.group({\r\n      position: [seed.position || ''],\r\n      kind: [seed.kind || 'pid'],\r\n      // For VM rows this holds the artwork id (single string). For PID rows\r\n      // it's left empty in favour of `rawValues`.\r\n      rawValue: [seed.kind === 'pid' ? '' : (seed.rawValue || '')],\r\n      rawValues: [rawValuesSeed],\r\n      vmRef: [seed.vmRef || ''],\r\n      skuCollectionRef: [seed.skuCollectionRef || ''],\r\n    });\r\n  }\r\n\r\n  addPlacement() {\r\n    if (!this.selectedPlacements) return;\r\n    this.selectedPlacements.push(this.createPlacementGroup());\r\n  }\r\n\r\n  removePlacement(index: number) {\r\n    if (!this.selectedPlacements) return;\r\n    this.selectedPlacements.removeAt(index);\r\n  }\r\n\r\n  private normVmType(t: any): string {\r\n    return String(t ?? '').trim().toLowerCase();\r\n  }\r\n\r\n  /** Stable per-vmType artwork list lookup. Returns the same array reference\r\n   *  for the same vmType across CD cycles so lib-reactive-select doesn't\r\n   *  re-init. Falls back to the full list when vmType is empty. */\r\n  vmArtworkOptionsFor(vmType: string): { value: string; label: string }[] {\r\n    const key = this.normVmType(vmType);\r\n    if (key && this.vmArtworkByType.has(key)) {\r\n      return this.vmArtworkByType.get(key)!;\r\n    }\r\n    return this.vmArtworkByType.get('') || [];\r\n  }\r\n\r\n  /** Populate the dropdown data used by Placement rows:\r\n   *  - VM Type list (`getVmTypesList`)\r\n   *  - VM Artwork list (`vmNameList`)\r\n   *  - Product / SKU collection list (flattened from brand → category mapping\r\n   *    that powers /manage/planogram/config). */\r\n  async loadPlacementDropdownData() {\r\n    if (!this.clientId) return;\r\n    try {\r\n      const [vmTypesRes, vmsRes, brandsRes, brandMetaRes] = await Promise.all([\r\n        lastValueFrom(this.builderService.getVmTypesList(this.clientId)),\r\n        lastValueFrom(this.builderService.getVMNameList(this.clientId)),\r\n        lastValueFrom(this.builderService.getBrandList(this.clientId)),\r\n        lastValueFrom(this.builderService.getBrandMetaData(this.clientId)),\r\n      ]);\r\n\r\n      const vmTypes: any[] = (vmTypesRes as any)?.data || [];\r\n      this.vmTypeOptions = vmTypes\r\n        .map((t: any) => {\r\n          const v = t?.vmType || t?.vmTypeName || t?.name || t?._id;\r\n          const l = t?.vmTypeName || t?.vmType || t?.name || v;\r\n          return v ? { value: String(v), label: String(l) } : null;\r\n        })\r\n        .filter((x): x is { value: string; label: string } => !!x);\r\n\r\n      const vms: any[] = (vmsRes as any)?.data || [];\r\n      this.vmArtworkOptions = vms\r\n        .map((v: any): { value: string; label: string; vmType?: string } | null => {\r\n          const id = v?.vmName || v?._id;\r\n          if (!id) return null;\r\n          return {\r\n            value: String(id),\r\n            label: String(v?.vmName || id),\r\n            vmType: v?.vmType ? String(v.vmType) : undefined,\r\n          };\r\n        })\r\n        .filter((x): x is { value: string; label: string; vmType?: string } => !!x);\r\n\r\n      // (vmName, vmType) → _id so we can turn a placement's artwork NAME into\r\n      // the planovm _id the embedded VM editor matches against.\r\n      this.vmIdByNameType = new Map();\r\n      for (const v of vms) {\r\n        if (!v?._id || !v?.vmName) continue;\r\n        const name = this.normVmType(v.vmName);\r\n        const type = this.normVmType(v.vmType);\r\n        this.vmIdByNameType.set(`${name}||${type}`, String(v._id));\r\n        if (!this.vmIdByNameType.has(name)) {\r\n          this.vmIdByNameType.set(name, String(v._id));\r\n        }\r\n      }\r\n\r\n      // Rebuild the (vmType → artworks) index now that the artwork list\r\n      // changed. Keys are normalised (trim + lower-case) so a mismatch in\r\n      // casing/whitespace between vmTypes and vms.vmType still matches.\r\n      this.vmArtworkByType = new Map();\r\n      const fullList = this.vmArtworkOptions.map((v) => ({ value: v.value, label: v.label }));\r\n      this.vmArtworkByType.set('', fullList);\r\n      for (const v of this.vmArtworkOptions) {\r\n        const key = this.normVmType(v.vmType);\r\n        if (!key) continue;\r\n        if (!this.vmArtworkByType.has(key)) this.vmArtworkByType.set(key, []);\r\n        this.vmArtworkByType.get(key)!.push({ value: v.value, label: v.label });\r\n      }\r\n      console.log(\r\n        '[Looks form] vmTypes:', this.vmTypeOptions.length,\r\n        'artworks:', this.vmArtworkOptions.length,\r\n        'artworksByType keys:', Array.from(this.vmArtworkByType.keys()),\r\n      );\r\n\r\n      // Source: every value the brand & product mapping page exposes.\r\n      //  - `getBrandList`     → per-brand `category[]` and `subCategory[]`\r\n      //  - `getBrandMetaData` → rows with `pidCat`, `category`, `tempGroup`\r\n      const brands: any[] = (brandsRes as any)?.data || [];\r\n      const brandMeta: any[] = (brandMetaRes as any)?.data || [];\r\n      const seenCats = new Set<string>();\r\n      const products: { value: string; label: string }[] = [];\r\n      const pushOne = (v: any) => {\r\n        const s = String(v ?? '').trim();\r\n        if (!s || seenCats.has(s)) return;\r\n        seenCats.add(s);\r\n        products.push({ value: s, label: s });\r\n      };\r\n      const pushArr = (arr: any) => {\r\n        if (!Array.isArray(arr)) return;\r\n        for (const v of arr) pushOne(v);\r\n      };\r\n      for (const b of brands) {\r\n        pushArr(b?.category);\r\n        pushArr(b?.subCategory);\r\n      }\r\n      for (const row of brandMeta) {\r\n        pushOne(row?.pidCat);\r\n        pushOne(row?.category);\r\n        pushOne(row?.tempGroup);\r\n      }\r\n      this.productOptions = products;\r\n      console.log(\r\n        '[Looks form] product/SKU options:',\r\n        this.productOptions.length,\r\n        'from',\r\n        brands.length,\r\n        'brands and',\r\n        brandMeta.length,\r\n        'brand-meta rows',\r\n      );\r\n    } catch (err) {\r\n      console.log('@@ ~ loadPlacementDropdownData [ERR]:', err);\r\n    }\r\n  }\r\n\r\n  async loadFixtureLibraries() {\r\n    if (!this.clientId) return;\r\n    try {\r\n      // Only list fixture templates available in India (country code 'IN').\r\n      const res: any = await lastValueFrom(\r\n        this.builderService.getFixtureLibNameList(this.clientId, 'non-draft', 'IN'),\r\n      );\r\n      // Response shape: { code, status, data: [{ id, fixtureName, fixtureType }] }.\r\n      const list: { id: string; fixtureName: string; fixtureType: string }[] =\r\n        Array.isArray(res?.data) ? res.data : [];\r\n      this.fixtureLibraryItems = list.map((l) => ({\r\n        id: l.id,\r\n        name: l.fixtureName,\r\n        fixtureType: (l.fixtureType || '').toString().toLowerCase().trim(),\r\n      }));\r\n      const typeTally: Record<string, number> = {};\r\n      for (const it of this.fixtureLibraryItems) {\r\n        const k = it.fixtureType || '(empty)';\r\n        typeTally[k] = (typeTally[k] || 0) + 1;\r\n      }\r\n      console.log(\r\n        '[Looks form] fixture libraries loaded:',\r\n        this.fixtureLibraryItems.length,\r\n        'fixtureType tally:',\r\n        typeTally,\r\n      );\r\n      this.recomputeFixtureLibraryItemsForSlot();\r\n    } catch (err) {\r\n      console.log('@@ ~ loadFixtureLibraries [ERR]:', err);\r\n      this.fixtureLibraryItems = [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Recompute the slot-type-filtered library list once. Stable reference\r\n   * so the multiselect doesn't tear down its click targets every CD cycle.\r\n   */\r\n  private recomputeFixtureLibraryItemsForSlot(): void {\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) {\r\n      this.fixtureLibraryItemsForSlot = this.fixtureLibraryItems.slice();\r\n      return;\r\n    }\r\n    const slotType = slot.get('slotType')?.value;\r\n    const target = slotType === 'eurocenter' ? 'floor' : 'wall';\r\n    this.fixtureLibraryItemsForSlot = this.fixtureLibraryItems.filter((item) => {\r\n      const t = item.fixtureType;\r\n      if (!t) return false;\r\n      if (target === 'wall') return t === 'wall' || t.includes('wall');\r\n      return t === 'floor' || t.includes('floor') || t.includes('euro') || t.includes('free');\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Subscriptions scoped to whichever slot is currently active. Cleared and\r\n   * rebuilt every time the active slot changes.\r\n   */\r\n  private slotSubs: any[] = [];\r\n\r\n  /** Pending auto-apply promises keyed by libId so chip clicks can await. */\r\n  private autoApplyInFlight = new Map<string, Promise<void>>();\r\n\r\n  /** Wire/refresh subscriptions that depend on the active slot:\r\n   *  - re-filter the library multiselect when slotType changes\r\n   *  - run auto-apply when a new library is added to fixtureLibraryRefs\r\n   */\r\n  private bindActiveSlotListeners(): void {\r\n    for (const s of this.slotSubs) s?.unsubscribe?.();\r\n    this.slotSubs = [];\r\n\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) {\r\n      this.fixtureLibraryItemsForSlot = this.fixtureLibraryItems.slice();\r\n      return;\r\n    }\r\n    this.recomputeFixtureLibraryItemsForSlot();\r\n\r\n    const typeSub = slot.get('slotType')?.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe(() => this.recomputeFixtureLibraryItemsForSlot());\r\n    if (typeSub) this.slotSubs.push(typeSub);\r\n\r\n    // Track previous refs so we can detect *new* additions and auto-apply\r\n    // the slot's PIDs to those new libraries.\r\n    let prevRefs: string[] = [...(slot.get('fixtureLibraryRefs')?.value || [])];\r\n    const refsSub = slot.get('fixtureLibraryRefs')?.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((nextRefs: string[]) => {\r\n      const next = Array.isArray(nextRefs) ? nextRefs : [];\r\n      const added = next.filter((r) => !!r && !prevRefs.includes(r));\r\n      prevRefs = [...next];\r\n\r\n      // If the currently-previewed library was unselected, clear the\r\n      // embedded view so we don't show stale data.\r\n      if (\r\n        this.selectedLibraryIdInMap\r\n          && !next.includes(this.selectedLibraryIdInMap)\r\n      ) {\r\n        this.onLibraryMapSelect('');\r\n      }\r\n\r\n      for (const libId of added) {\r\n        const p = this.autoApplyPidsToLibrary(libId);\r\n        this.autoApplyInFlight.set(libId, p);\r\n        p.finally(() => {\r\n          if (this.autoApplyInFlight.get(libId) === p) {\r\n            this.autoApplyInFlight.delete(libId);\r\n          }\r\n        });\r\n      }\r\n\r\n      // If nothing is being previewed yet, auto-activate the first library\r\n      // the user just added so the embedded PID/VM editor opens immediately\r\n      // (especially relevant when adding the FIRST library to an empty\r\n      // multiselect — previously the chip strip showed it but the preview\r\n      // pane stayed blank until the user clicked the chip).\r\n      if (!this.selectedLibraryIdInMap) {\r\n        const firstActive = added.find((id) => !!id) || next.find((id) => !!id);\r\n        if (firstActive) this.onLibraryMapSelect(firstActive);\r\n      }\r\n      });\r\n    if (refsSub) this.slotSubs.push(refsSub);\r\n\r\n    // When any placement in the \"Look and Visual Merchandising Placements\"\r\n    // list changes, re-derive every assigned library's snapshot so the edit\r\n    // propagates to all of them. Debounced so rapid typing collapses into a\r\n    // single re-apply.\r\n    const placementsArr = slot.get('placements') as FormArray | null;\r\n    const placementsSub = placementsArr?.valueChanges\r\n      .pipe(debounceTime(400), takeUntil(this.destroy$))\r\n      .subscribe(() => this.applyPlacementsToAssignedLibraries());\r\n    if (placementsSub) this.slotSubs.push(placementsSub);\r\n  }\r\n\r\n  /**\r\n   * When a new library is added to the slot, walk its shelfConfig and for\r\n   * each shelf whose section currently has no brand, copy the rawValue of\r\n   * the slot's PID placement whose `position` matches the shelf's\r\n   * `zone`/`label`. Result is saved as the library's snapshot so the\r\n   * embedded fixture-template editor picks it up the next time the chip\r\n   * is opened.\r\n   */\r\n  private async autoApplyPidsToLibrary(libId: string): Promise<void> {\r\n    if (!libId) return;\r\n    const slot = this.selectedSlotGroup;\r\n    if (!slot) return;\r\n\r\n    const placementsArr = slot.get('placements') as FormArray | null;\r\n    const placements: any[] = placementsArr?.value || [];\r\n    const pidPlacements = placements.filter(\r\n      (p) => p?.kind === 'pid' && p?.position && p?.rawValue,\r\n    );\r\n\r\n    const norm = (s: any): string => String(s ?? '').trim().toLowerCase();\r\n\r\n    const placementMap = new Map<string, string>();\r\n    for (const p of pidPlacements) {\r\n      placementMap.set(norm(p.position), String(p.rawValue));\r\n    }\r\n\r\n    // Start from an existing snapshot if we already saved one for this slot\r\n    // + library; otherwise fetch the fresh library doc. The per-field guards\r\n    // below still ensure we never overwrite user-set brands or VMs.\r\n    let libData: any = this.getLibrarySnapshot(libId);\r\n    if (!libData) {\r\n      try {\r\n        const res: any = await lastValueFrom(\r\n          this.builderService.getFixtureLibraryDetails(libId),\r\n        );\r\n        libData = res?.data;\r\n      } catch (err) {\r\n        console.log('@@ ~ autoApplyPidsToLibrary [ERR]:', err);\r\n        return;\r\n      }\r\n    }\r\n    if (!libData) return;\r\n\r\n    const shelfConfig: any[] = Array.isArray(libData.shelfConfig) ? libData.shelfConfig : [];\r\n    let pidsApplied = false;\r\n    const newShelfConfig = shelfConfig.map((shelf: any) => {\r\n      if (Array.isArray(shelf?.productBrandName) && shelf.productBrandName.length > 0) {\r\n        return shelf;\r\n      }\r\n      const sourceLabel = shelf?.zone || shelf?.label || '';\r\n      const matchKey = norm(sourceLabel);\r\n      if (!matchKey) return shelf;\r\n      const match = placementMap.get(matchKey);\r\n      if (!match) return shelf;\r\n      pidsApplied = true;\r\n      // groupShelvesByZone() in TemplateProductsComponent SKIPS any shelf\r\n      // whose `zone` is empty, so we must set zone (using the shelf's label\r\n      // if it isn't already set) for the section to form.\r\n      return {\r\n        ...shelf,\r\n        zone: shelf?.zone || sourceLabel,\r\n        productBrandName: [match],\r\n      };\r\n    });\r\n\r\n    // --- VM auto-apply -----------------------------------------------------\r\n    // If the library has no VMs configured yet, copy each of the slot's VM\r\n    // placements over as a vmConfig entry. No position-based matching here —\r\n    // the placement's `rawValue` becomes the VM artwork and `position`\r\n    // becomes the VM type label.\r\n    const existingVms = Array.isArray(libData.vmConfig) ? libData.vmConfig : [];\r\n    let newVmConfig = existingVms;\r\n    let vmsApplied = false;\r\n    if (existingVms.length === 0) {\r\n      const vmPlacements = placements.filter(\r\n        (p) => p?.kind === 'vm' && p?.rawValue,\r\n      );\r\n      if (vmPlacements.length > 0) {\r\n        newVmConfig = vmPlacements.map((p) => ({\r\n          vmType: String(p?.position || ''),\r\n          vmId: String(p?.rawValue || ''),\r\n          startYPosition: 1,\r\n          endYPosition: 1,\r\n          xZone: '',\r\n          yZone: '',\r\n          position: '',\r\n        }));\r\n        vmsApplied = true;\r\n      }\r\n    }\r\n\r\n    if (!pidsApplied && !vmsApplied) return;\r\n\r\n    // The embedded TemplateProductsComponent only reads section-level brand\r\n    // values when productResolutionLevel === 'L3'.\r\n    const updatedLib = {\r\n      ...libData,\r\n      shelfConfig: newShelfConfig,\r\n      vmConfig: newVmConfig,\r\n      productResolutionLevel: 'L3',\r\n    };\r\n    this.captureLibrarySnapshot(libId, updatedLib);\r\n  }\r\n\r\n  async loadDetails() {\r\n    if (!this.collectionId) return;\r\n    this.loading = true;\r\n    try {\r\n      const res: any = await lastValueFrom(\r\n        this.builderService.getLookPlanoCollectionDetails(this.collectionId),\r\n      );\r\n      const data = res?.data;\r\n      if (data) {\r\n        this.form.patchValue({\r\n          name: data.name || '',\r\n          description: data.description || '',\r\n          isActive: !!data.isActive,\r\n        });\r\n        this.looks.clear();\r\n        (data.looks || []).forEach((l: any) => this.looks.push(this.createLookGroup(l)));\r\n        this.selectedLookIndex = this.looks.length ? 0 : -1;\r\n        const slots = this.selectedLookIndex >= 0 ? this.fixtureSlots(this.selectedLookIndex) : null;\r\n        this.selectedSlotIndex = slots && slots.length ? 0 : -1;\r\n        this.resetLibraryMap();\r\n        this.bindActiveSlotListeners();\r\n        this.autoSelectFirstLibrary();\r\n      }\r\n    } catch (err) {\r\n      console.log('@@ ~ loadDetails [ERR]:', err);\r\n      this.toast.getErrorToast?.('Failed to load Look collection');\r\n    } finally {\r\n      this.loading = false;\r\n    }\r\n  }\r\n\r\n  addLook() {\r\n    const next = this.createLookGroup({ mbqBucket: '', fixtureCount: 1 });\r\n    this.looks.push(next);\r\n    this.selectedLookIndex = this.looks.length - 1;\r\n    this.selectedSlotIndex = this.fixtureSlots(this.selectedLookIndex).length ? 0 : -1;\r\n    this.bindActiveSlotListeners();\r\n  }\r\n\r\n  removeLook(index: number) {\r\n    this.looks.removeAt(index);\r\n    if (this.selectedLookIndex === index) {\r\n      this.selectedLookIndex = this.looks.length ? 0 : -1;\r\n      this.selectedSlotIndex = -1;\r\n    } else if (this.selectedLookIndex > index) {\r\n      this.selectedLookIndex -= 1;\r\n    }\r\n  }\r\n\r\n  selectLook(index: number) {\r\n    this.selectedLookIndex = index;\r\n    const slots = this.fixtureSlots(index);\r\n    this.selectedSlotIndex = slots.length ? 0 : -1;\r\n    this.resetLibraryMap();\r\n    this.bindActiveSlotListeners();\r\n    this.autoSelectFirstLibrary();\r\n  }\r\n\r\n  addSlot() {\r\n    if (this.selectedLookIndex < 0) return;\r\n    const lookGroup = this.looks.at(this.selectedLookIndex) as FormGroup;\r\n    const slots = this.fixtureSlots(this.selectedLookIndex);\r\n    slots.push(this.createSlotGroup({ slotIndex: slots.length + 1 }));\r\n    lookGroup.get('fixtureCount')!.setValue(slots.length, { emitEvent: false });\r\n    this.selectedSlotIndex = slots.length - 1;\r\n    this.bindActiveSlotListeners();\r\n  }\r\n\r\n  removeSlot(slotIndex: number) {\r\n    if (this.selectedLookIndex < 0) return;\r\n    const lookGroup = this.looks.at(this.selectedLookIndex) as FormGroup;\r\n    const slots = this.fixtureSlots(this.selectedLookIndex);\r\n    slots.removeAt(slotIndex);\r\n    this.renumberSlotsForGroup(lookGroup);\r\n    lookGroup.get('fixtureCount')!.setValue(slots.length, { emitEvent: false });\r\n    if (this.selectedSlotIndex === slotIndex) {\r\n      this.selectedSlotIndex = slots.length ? Math.min(slotIndex, slots.length - 1) : -1;\r\n    } else if (this.selectedSlotIndex > slotIndex) {\r\n      this.selectedSlotIndex -= 1;\r\n    }\r\n  }\r\n\r\n  renumberSlotsForGroup(lookGroup: FormGroup) {\r\n    const slotsArr = lookGroup.get('fixtureSlots') as FormArray;\r\n    slotsArr.controls.forEach((slot, i) => {\r\n      (slot as FormGroup).get('slotIndex')?.setValue(i + 1, { emitEvent: false });\r\n    });\r\n  }\r\n\r\n  selectSlot(slotIndex: number) {\r\n    this.selectedSlotIndex = slotIndex;\r\n    this.resetLibraryMap();\r\n    this.bindActiveSlotListeners();\r\n    this.autoSelectFirstLibrary();\r\n  }\r\n\r\n  lookTitle(lookGroup: FormGroup): string {\r\n    const keyType = lookGroup.get('keyType')?.value;\r\n    const key = keyType === 'brandCategory'\r\n      ? lookGroup.get('brandCategory')?.value\r\n      : lookGroup.get('mbqBucket')?.value;\r\n    const count = lookGroup.get('fixtureCount')?.value;\r\n    return `${key || '(unnamed)'} — ${count || 0} fixtures`;\r\n  }\r\n\r\n  bucketKey(lookGroup: FormGroup): string {\r\n    const keyType = lookGroup.get('keyType')?.value;\r\n    const key = keyType === 'brandCategory'\r\n      ? lookGroup.get('brandCategory')?.value\r\n      : lookGroup.get('mbqBucket')?.value;\r\n    return (key || '').trim();\r\n  }\r\n\r\n  /**\r\n   * Assign a colour to each unique bucket key by **insertion order**, not by hash.\r\n   * The Nth distinct bucket (counted top-to-bottom through the looks array) gets\r\n   * `BUCKET_PALETTE[N]`. Only after all 20 palette slots are used does the assignment\r\n   * wrap around — so no colour is ever reused while < 20 distinct buckets exist.\r\n   *\r\n   * Recomputed on every call so live edits to the bucket name re-flow colours.\r\n   */\r\n  bucketColor(lookGroup: FormGroup): string {\r\n    const key = this.bucketKey(lookGroup);\r\n    if (!key) return '#f9fafb';\r\n    const palette = LookPlanoCollectionFormComponent.BUCKET_PALETTE;\r\n    let nextIndex = 0;\r\n    const assigned = new Map<string, string>();\r\n    for (const group of this.looks.controls) {\r\n      const k = this.bucketKey(group as FormGroup);\r\n      if (k && !assigned.has(k)) {\r\n        assigned.set(k, palette[nextIndex % palette.length]);\r\n        nextIndex += 1;\r\n      }\r\n      if (k === key) {\r\n        return assigned.get(k)!;\r\n      }\r\n    }\r\n    return '#f9fafb';\r\n  }\r\n\r\n  /**\r\n   * Reorder the looks FormArray so that the bucket with the **most** looks\r\n   * comes first and the one with the fewest comes last (alphabetical tie-break\r\n   * within the same count). Looks within the same bucket are sorted by\r\n   * ascending fixtureCount. Selection is preserved by reference, not by index.\r\n   */\r\n  private applySortedOrder(): void {\r\n    const groups = this.looks.controls as FormGroup[];\r\n    if (groups.length <= 1) return;\r\n\r\n    // Tally how many looks each bucket has so we can sort buckets by frequency.\r\n    const bucketCounts = new Map<string, number>();\r\n    for (const g of groups) {\r\n      const k = this.bucketKey(g);\r\n      if (!k) continue;\r\n      bucketCounts.set(k, (bucketCounts.get(k) || 0) + 1);\r\n    }\r\n\r\n    const sorted = [...groups].sort((a, b) => {\r\n      const aKey = this.bucketKey(a);\r\n      const bKey = this.bucketKey(b);\r\n      // Empty bucket keys go to the end so unfinished looks don't disrupt the groups\r\n      if (aKey && !bKey) return -1;\r\n      if (!aKey && bKey) return 1;\r\n\r\n      // Primary: bucket frequency, descending (most-populated bucket first)\r\n      const aCount = bucketCounts.get(aKey) || 0;\r\n      const bCount = bucketCounts.get(bKey) || 0;\r\n      if (aCount !== bCount) return bCount - aCount;\r\n\r\n      // Tie-break: alphabetical bucket name\r\n      if (aKey !== bKey) return aKey.localeCompare(bKey);\r\n\r\n      // Within the same bucket: ascending fixtureCount\r\n      const aFC = Number(a.get('fixtureCount')?.value) || 0;\r\n      const bFC = Number(b.get('fixtureCount')?.value) || 0;\r\n      return aFC - bFC;\r\n    });\r\n\r\n    const orderChanged = sorted.some((g, i) => g !== groups[i]);\r\n    if (!orderChanged) return;\r\n\r\n    const currentLook = this.selectedLookGroup;\r\n    const currentSlot = this.selectedSlotGroup;\r\n\r\n    this.looks.clear({ emitEvent: false });\r\n    sorted.forEach((g) => this.looks.push(g, { emitEvent: false }));\r\n\r\n    if (currentLook) {\r\n      const newLookIdx = sorted.indexOf(currentLook);\r\n      this.selectedLookIndex = newLookIdx;\r\n      if (this.selectedLookIndex >= 0 && currentSlot) {\r\n        const slotsArr = this.fixtureSlots(this.selectedLookIndex);\r\n        const newSlotIdx = slotsArr.controls.indexOf(currentSlot);\r\n        this.selectedSlotIndex = newSlotIdx;\r\n      }\r\n    }\r\n  }\r\n\r\n  async save() {\r\n    if (this.form.invalid) {\r\n      this.toast.getErrorToast?.('Please fill all required fields');\r\n      return;\r\n    }\r\n    this.saving = true;\r\n    try {\r\n      // Sort the looks before serialising so both the persisted payload\r\n      // and the on-screen list reflect grouping by MBQ bucket / brand category\r\n      // and ascending fixture count.\r\n      this.applySortedOrder();\r\n\r\n      const payload = {\r\n        ...this.form.value,\r\n        clientId: this.clientId,\r\n      };\r\n      if (this.isNew) {\r\n        const res: any = await lastValueFrom(this.builderService.createLookPlanoCollection(payload));\r\n        const newId = res?.data?._id;\r\n        this.toast.getSuccessToast?.('Look collection created');\r\n        if (newId) {\r\n          this.router.navigate(['/manage/planogram/looks', newId]);\r\n        } else {\r\n          this.router.navigate(['/manage/planogram/looks']);\r\n        }\r\n      } else {\r\n        await lastValueFrom(\r\n          this.builderService.updateLookPlanoCollection({ ...payload, collectionId: this.collectionId }),\r\n        );\r\n        this.toast.getSuccessToast?.('Look collection updated');\r\n      }\r\n    } catch (err) {\r\n      console.log('@@ ~ save [ERR]:', err);\r\n      this.toast.getErrorToast?.('Failed to save Look collection');\r\n    } finally {\r\n      this.saving = false;\r\n    }\r\n  }\r\n\r\n  cancel() {\r\n    this.router.navigate(['/manage/planogram/looks']);\r\n  }\r\n\r\n  trackByIndex(index: number) {\r\n    return index;\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    // Release the shared BehaviorSubject so other pages don't inherit a stale library.\r\n    this.planoDataService.fixtureTemplateDetails.next(null);\r\n  }\r\n}\r\n","<section class=\"look-form\">\r\n  <!-- Top bar (bound to the outer form) -->\r\n  <div class=\"card p-4 mb-4\" [formGroup]=\"form\">\r\n    <div class=\"row align-items-end\">\r\n      <div class=\"col-md-4\">\r\n        <label class=\"form-label fw-bold\">Name *</label>\r\n        <input type=\"text\" class=\"form-control\" formControlName=\"name\" placeholder=\"e.g. Master Look Plan FY26\" />\r\n      </div>\r\n      <div class=\"col-md-5\">\r\n        <label class=\"form-label fw-bold\">Description</label>\r\n        <input type=\"text\" class=\"form-control\" formControlName=\"description\" placeholder=\"Optional description\" />\r\n      </div>\r\n      <div class=\"col-md-1 text-center\">\r\n        <label class=\"form-label fw-bold d-block\">Active</label>\r\n        <input type=\"checkbox\" class=\"form-check-input\" formControlName=\"isActive\" />\r\n      </div>\r\n      <div class=\"col-md-2 text-end\">\r\n        <button type=\"button\" class=\"btn btn-light me-2\" (click)=\"cancel()\">Cancel</button>\r\n        <button type=\"button\" class=\"btn btn-primary\" [disabled]=\"saving\" (click)=\"save()\">\r\n          {{ saving ? 'Saving…' : 'Save' }}\r\n        </button>\r\n      </div>\r\n    </div>\r\n  </div>\r\n\r\n  <!-- Three-pane editor -->\r\n  <div class=\"row mx-0 g-3\">\r\n    <!-- Left: Looks list (no form binding needed — just navigation) -->\r\n    <div class=\"col-md-3\">\r\n      <div class=\"card p-3 h-100\">\r\n        <div class=\"d-flex justify-content-between align-items-center mb-3\">\r\n          <h6 class=\"m-0\">MBQ Bucket - Fixture Combinations</h6>\r\n          <button type=\"button\" class=\"btn btn-sm btn-primary\" (click)=\"addLook()\">+ Add Look</button>\r\n        </div>\r\n        <div *ngIf=\"looks.length === 0\" class=\"text-muted small\">No looks yet. Add one to start.</div>\r\n        <div class=\"looks-tree\">\r\n          <div\r\n            *ngFor=\"let look of looks.controls; let i = index; trackBy: trackByIndex\"\r\n            class=\"look-row d-flex justify-content-between align-items-center px-2 py-2 mb-1 rounded\"\r\n            [class.selected]=\"selectedLookIndex === i\"\r\n            [style.background-color]=\"bucketColor($any(look))\"\r\n            (click)=\"selectLook(i)\"\r\n          >\r\n            <span class=\"d-flex align-items-center gap-2 text-truncate\">\r\n              <span class=\"bucket-dot\" [style.background-color]=\"bucketColor($any(look))\"></span>\r\n              <span class=\"text-truncate\">{{ lookTitle($any(look)) }}</span>\r\n            </span>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light-danger ms-2\" (click)=\"$event.stopPropagation(); removeLook(i)\">×</button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n    <!-- Centre: selected Look metadata + slots -->\r\n    <div class=\"col-md-3\">\r\n      <ng-container *ngIf=\"selectedLookGroup as lookGroup; else noLook\">\r\n        <div class=\"card p-3 h-100\" [formGroup]=\"lookGroup\">\r\n          <h6 class=\"mb-3\">Fixture Combination Details</h6>\r\n\r\n          <div class=\"row g-2 mb-3\">\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">MBQ bucket</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"mbqBucket\" placeholder=\"e.g. JJ / OD Eye\" />\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Fixture count *</label>\r\n              <input type=\"number\" min=\"0\" max=\"30\" class=\"form-control form-control-sm\" formControlName=\"fixtureCount\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Positions</label>\r\n              <multiselect-chip-dropdown\r\n                [items]=\"fixtureTypeOptions\"\r\n                idField=\"id\"\r\n                nameField=\"name\"\r\n                placeholder=\"Select fixture position\"\r\n                formControlName=\"fixtureType\">\r\n              </multiselect-chip-dropdown>\r\n            </div>\r\n          </div>\r\n\r\n          <hr />\r\n\r\n          <div class=\"d-flex justify-content-between align-items-center mb-2\">\r\n            <h6 class=\"m-0\">Fixtures</h6>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light\" (click)=\"addSlot()\">+ Add Fixture</button>\r\n          </div>\r\n          <div class=\"slots-list\">\r\n            <div\r\n              *ngFor=\"let slot of (selectedSlotsArray?.controls || []); let s = index; trackBy: trackByIndex\"\r\n              class=\"slot-row d-flex justify-content-between align-items-center px-2 py-2 mb-1 rounded\"\r\n              [class.selected]=\"selectedSlotIndex === s\"\r\n              (click)=\"selectSlot(s)\"\r\n            >\r\n              <div class=\"d-flex flex-column\">\r\n                <span class=\"fw-bold small\">\r\n                  Fixture {{ $any(slot).get('slotIndex')?.value }} — {{ $any(slot).get('slotType')?.value }}\r\n                </span>\r\n                <span class=\"text-muted small\">\r\n                  {{ $any(slot).get('brand')?.value || '(no brand)' }} ·\r\n                  {{ $any(slot).get('fixtureLevelZone')?.value || '(no zone)' }}\r\n                </span>\r\n              </div>\r\n              <button type=\"button\" class=\"btn btn-sm btn-light-danger ms-2\" (click)=\"$event.stopPropagation(); removeSlot(s)\">×</button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n      <ng-template #noLook>\r\n        <div class=\"card p-5 h-100 text-center text-muted\">Select or add a Look to edit it.</div>\r\n      </ng-template>\r\n    </div>\r\n\r\n    <!-- Right: selected slot — placements editor -->\r\n    <div class=\"col-md-6\">\r\n      <ng-container *ngIf=\"selectedSlotGroup as slotGroup; else noSlot\">\r\n        <div class=\"card p-3 h-100\" [formGroup]=\"slotGroup\">\r\n          <h6 class=\"mb-3\">Fixture {{ selectedSlotIndex + 1 }} - Definition</h6>\r\n\r\n          <div class=\"row g-2 mb-3\">\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small text-muted\">Slot index (auto)</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" [value]=\"selectedSlotIndex + 1\" readonly disabled />\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Fixture Type</label>\r\n              <select class=\"form-select form-select-sm\" formControlName=\"slotType\">\r\n                <option *ngFor=\"let opt of availableSlotTypes\" [value]=\"opt.id\">{{ opt.name }}</option>\r\n              </select>\r\n            </div>\r\n            <div class=\"col-md-6\">\r\n              <label class=\"form-label small\">Brand</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"brand\" placeholder=\"John Jacobs\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Header</label>\r\n              <input type=\"text\" class=\"form-control form-control-sm\" formControlName=\"fixtureLevelZone\" placeholder=\"Premium Trending\" />\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">CAD Header Varients</label>\r\n              <lib-chips-input\r\n                formControlName=\"cadHeaderVariants\"\r\n                placeholder=\"Type a variant and press Enter\">\r\n              </lib-chips-input>\r\n            </div>\r\n            <div class=\"col-md-12\">\r\n              <label class=\"form-label small\">Fixture Templates</label>\r\n              <multiselect-chip-dropdown\r\n                class=\"fixture-libraries-select\"\r\n                [items]=\"fixtureLibraryItemsForSlot\"\r\n                idField=\"id\"\r\n                nameField=\"name\"\r\n                [search]=\"true\"\r\n                searchField=\"name\"\r\n                placeholder=\"Select fixture templates\"\r\n                formControlName=\"fixtureLibraryRefs\">\r\n              </multiselect-chip-dropdown>\r\n              <small class=\"text-muted\" *ngIf=\"slotGroup.get('slotType')?.value === 'eurocenter'\">\r\n                Showing floor fixtures (eurocenter slot).\r\n              </small>\r\n              <small class=\"text-muted\" *ngIf=\"slotGroup.get('slotType')?.value !== 'eurocenter'\">\r\n                Showing wall fixtures (shelf slot).\r\n              </small>\r\n            </div>\r\n          </div>\r\n\r\n          <hr />\r\n\r\n          <div class=\"d-flex justify-content-between align-items-center mb-2\">\r\n            <h6 class=\"m-0\">Look and Visual Merchandising Placements</h6>\r\n            <button type=\"button\" class=\"btn btn-sm btn-light\" (click)=\"addPlacement()\">+ Add placement</button>\r\n          </div>\r\n          <div *ngIf=\"(selectedPlacements?.length || 0) === 0\" class=\"text-muted small mb-2\">\r\n            No placements yet. Click <strong>+ Add placement</strong> to add one.\r\n          </div>\r\n          <div class=\"placements-scroll\" formArrayName=\"placements\">\r\n            <div\r\n              *ngFor=\"let p of (selectedPlacements?.controls || []); let pi = index; trackBy: trackByIndex\"\r\n              class=\"placement-row mb-2\"\r\n              [formGroupName]=\"pi\"\r\n            >\r\n              <div class=\"d-flex align-items-start gap-2 placement-fields\">\r\n                <div class=\"ph-field\">\r\n                  <select class=\"form-select form-select-sm\" formControlName=\"kind\">\r\n                    <option value=\"pid\">Product Merchandising</option>\r\n                    <option value=\"vm\">Visual Merchandising</option>\r\n                  </select>\r\n                </div>\r\n\r\n                <!-- Visual Merchandising rows: VM Type (single) + VM Artwork (single) -->\r\n                <ng-container *ngIf=\"$any(p).get('kind')?.value === 'vm'; else pidInputs\">\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"vmTypeOptions\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      placeholder=\"Visual Merchandising Type\"\r\n                      formControlName=\"position\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"vmArtworkOptionsFor($any(p).get('position')?.value)\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      placeholder=\"Visual Merchandising Artwork\"\r\n                      formControlName=\"rawValue\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                </ng-container>\r\n\r\n                <!-- Product Merchandising rows: Top/Mid/Bottom position + multi-select product/SKU -->\r\n                <ng-template #pidInputs>\r\n                  <div class=\"ph-field\">\r\n                    <select class=\"form-select form-select-sm\" formControlName=\"position\">\r\n                      <option value=\"\">Position</option>\r\n                      <option value=\"Top\">Top</option>\r\n                      <option value=\"Mid\">Mid</option>\r\n                      <option value=\"Bottom\">Bottom</option>\r\n                    </select>\r\n                  </div>\r\n                  <div class=\"ph-field\">\r\n                    <lib-searchable-select\r\n                      [items]=\"productOptions\"\r\n                      idField=\"value\"\r\n                      nameField=\"label\"\r\n                      [multiple]=\"true\"\r\n                      placeholder=\"Product / SKU\"\r\n                      formControlName=\"rawValues\">\r\n                    </lib-searchable-select>\r\n                  </div>\r\n                </ng-template>\r\n\r\n                <button type=\"button\" class=\"btn btn-sm btn-light-danger ph-remove\" (click)=\"removePlacement(pi)\">×</button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n      <ng-template #noSlot>\r\n        <div class=\"card p-5 h-100 text-center text-muted\">Select a fixture slot to edit placements.</div>\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n\r\n  <!-- Per-slot Fixture Library Configuration card -->\r\n  <ng-container *ngIf=\"selectedSlotGroup as slotGroupForMap\">\r\n    <div class=\"card p-4 mt-4 library-config-card\" [formGroup]=\"slotGroupForMap\">\r\n      <div class=\"mb-4\">\r\n        <h5 class=\"form-label d-block mb-3\">Fixture library</h5>\r\n        <div class=\"library-chips\">\r\n          <button\r\n            *ngFor=\"let lib of selectedSlotLibrariesForDropdown\"\r\n            type=\"button\"\r\n            class=\"library-chip\"\r\n            [class.active]=\"selectedLibraryIdInMap === lib.id\"\r\n            (click)=\"onLibraryMapSelect(selectedLibraryIdInMap === lib.id ? '' : lib.id)\">\r\n            {{ lib.name }}\r\n          </button>\r\n        </div>\r\n        <small *ngIf=\"selectedSlotLibrariesForDropdown.length === 0\" class=\"text-muted\">\r\n          No libraries linked to this slot yet. Add some in the \"Fixture libraries\" multiselect above.\r\n        </small>\r\n      </div>\r\n\r\n      <div *ngIf=\"loadingLibraryDetails\" class=\"text-muted\">Loading fixture details…</div>\r\n\r\n      <!--\r\n        Use *ngFor + trackBy keyed on (look, slot, library) so Angular treats\r\n        a switch as a new item — that forces the embedded template-products\r\n        / template-vms components to remount and rerun their ngOnInit\r\n        (otherwise their `isPageLoading` guard skips the form rebuild).\r\n      -->\r\n      <ng-container *ngFor=\"let _ of embeddedHostKeys; trackBy: trackByEmbeddedKey\">\r\n        <ul class=\"nav nav-tabs custom-tabs mb-3\">\r\n          <li class=\"nav-item\">\r\n            <button type=\"button\" class=\"nav-link\"\r\n              [class.active]=\"embeddedTab === 'products'\"\r\n              (click)=\"embeddedTab = 'products'\">Product Merchandising</button>\r\n          </li>\r\n          <li class=\"nav-item\">\r\n            <button type=\"button\" class=\"nav-link\"\r\n              [class.active]=\"embeddedTab === 'vms'\"\r\n              (click)=\"embeddedTab = 'vms'\">Visual Merchandising</button>\r\n          </li>\r\n        </ul>\r\n\r\n        <div *ngIf=\"embeddedTab === 'products'\">\r\n          <lib-template-products [looksMode]=\"true\"></lib-template-products>\r\n        </div>\r\n        <div *ngIf=\"embeddedTab === 'vms'\">\r\n          <lib-template-vms [looksMode]=\"true\"></lib-template-vms>\r\n        </div>\r\n      </ng-container>\r\n    </div>\r\n  </ng-container>\r\n</section>\r\n"]}