@libs-ui/components-spreadsheet 0.2.356-43

package/esm2022/spreadsheet.component.mjs

@@ -0,0 +1,869 @@
+import { ChangeDetectionStrategy, Component, NgZone, effect, inject, input, output, signal, untracked, viewChild } from '@angular/core';
+import { LocaleType, Univer, UniverInstanceType } from '@univerjs/core';
+import { defaultTheme } from '@univerjs/design';
+import { UniverDocsPlugin } from '@univerjs/docs';
+import { UniverDocsUIPlugin } from '@univerjs/docs-ui';
+import { UniverFormulaEnginePlugin } from '@univerjs/engine-formula';
+import { UniverRenderEnginePlugin } from '@univerjs/engine-render';
+import { FUniver } from '@univerjs/facade';
+import { InsertColMutation, MoveColsMutation, RemoveColMutation, UniverSheetsPlugin } from '@univerjs/sheets';
+import { UniverSheetsFormulaPlugin } from '@univerjs/sheets-formula';
+import { UniverSheetsFormulaUIPlugin } from '@univerjs/sheets-formula-ui';
+import { UniverSheetsNumfmtPlugin } from '@univerjs/sheets-numfmt';
+import { UniverSheetsUIPlugin } from '@univerjs/sheets-ui';
+import { UniverUIPlugin } from '@univerjs/ui';
+import { univerLocaleEn, univerLocaleVi } from './spreadsheet.locale';
+import { injectCustomDateFormats, syncActiveNumfmtHighlight } from './spreadsheet.numfmt';
+import { applyMappingIndicators, stripMappingIndicators } from './spreadsheet.indicator';
+import * as i0 from "@angular/core";
+// Bộ đếm tạo class scope duy nhất cho mỗi instance spreadsheet (dùng cho <style> chỉnh width toolbar).
+let spreadsheetInstanceCount = 0;
+export class LibsUiComponentsSpreadsheetComponent {
+    univer = null;
+    univerAPI = null;
+    columnClickDisposable = null;
+    formatDisposable = null;
+    columnOpDisposable = null;
+    numfmtObserver = null;
+    toolbarResizeObserver = null;
+    // <style> riêng cho instance: pin width container đo qua CSS rule (React re-render KHÔNG strip được →
+    // tránh vòng lặp oscillation giữa set-inline-width và React strip gây kẹt ⋮). Xem registerToolbarWidthSync.
+    toolbarStyleEl = null;
+    toolbarScopeClass = `libs-ui-spreadsheet-tb-${(spreadsheetInstanceCount += 1)}`;
+    numfmtClickDisposable = null;
+    lastRangeSnapshot = null;
+    pendingNumfmtPattern = null;
+    // true CHỈ khi user bấm nút Confirm trong panel numfmt → giữ format; Cancel/X/click-ngoài = false → revert.
+    numfmtConfirmed = false;
+    // Snapshot numfmt từng ô của vùng chọn tại thời điểm mở panel — dùng khôi phục chính xác khi Cancel.
+    originalCellFormats = null;
+    numfmtPanelOpen = false;
+    // true khi luồng Date custom đang hoạt động (đã inject option ngày). CHỈ khi đó component mới
+    // can thiệp confirm/revert; các Type khác (Số, Tiền tệ, %, Text…) do Univer tự xử lý → không đụng vào.
+    numfmtDateActive = false;
+    // Đồng bộ lại panel Date (label + highlight + auto-apply) theo vùng chọn mới khi user đổi cột lúc panel mở.
+    numfmtResync = null;
+    listenEnabled = false;
+    listenEnableTimer = null;
+    // Defer initial empty-workbook init to allow parent's ngAfterViewInit to call loadData
+    // first (cancelling the empty init), avoiding a race with Univer's async React renders.
+    pendingInitTimer = null;
+    numfmtCleanup = null;
+    pendingReadyCb = null;
+    // Snapshot đã-decorate gần nhất — làm baseline để diff (style id ổn định 'h'/'m', không bị
+    // ảnh hưởng bởi style id tự sinh sau mỗi facade setValue). Dùng cho re-apply incremental.
+    lastDecorated = null;
+    readyObserver = null;
+    // Cache controller numfmt nội bộ của Univer (giữ _previewPattern). Tìm 1 lần qua injector.
+    // CONVENTION-EXCEPT: any — NumfmtController không export khỏi @univerjs/sheets-numfmt
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    numfmtController = null;
+    activeCellFormat = signal('General');
+    activeCellRef = signal('');
+    showToolbar = signal(true);
+    showSheetTabs = signal(true);
+    // Ngôn ngữ đang hiển thị thực tế. Khởi tạo từ input `locale` trong ngAfterViewInit,
+    // sau đó đổi runtime qua setLocale() (kéo theo reinit để Univer render lại UI).
+    activeLocale = signal('vi');
+    /** Ngôn ngữ khởi tạo của spreadsheet. Đổi runtime dùng FunctionControl.setLocale(). */
+    locale = input('vi');
+    /** Cấu hình ẩn / vô hiệu hoá toolbar items. Thay đổi sẽ reinit toàn bộ Univer. */
+    toolbarMenuConfig = input({
+        // 'sheet.command.numfmt.set.currency': { hidden: true },
+        // 'sheet.command.numfmt.add.decimal.command': { hidden: true },
+        // 'sheet.command.numfmt.subtract.decimal.command': { hidden: true },
+        // 'sheet.command.numfmt.set.percent': { hidden: true },
+        'sheet.command.set-once-format-painter': { hidden: true },
+        'sheet.command.set-text-rotation': { hidden: true },
+        'sheet.command.set-range-font-family': { hidden: true },
+        'sheet.command.set-border-basic': { hidden: true },
+        'sheet.command.add-worksheet-merge': { hidden: true },
+        'sheet.command.add-worksheet-merge-all': { hidden: true },
+        'sheet.command.add-worksheet-merge-vertical': { hidden: true },
+        'sheet.command.add-worksheet-merge-horizontal': { hidden: true },
+        'sheet.command.remove-worksheet-merge': { hidden: true },
+    });
+    /**
+     * Cấu hình highlight cột đã map (style / prefix / scope sheet).
+     * Truyền config này = "bật" luồng auto: component sẽ TỰ áp indicator khi load/reset,
+     * TỰ gỡ khi save, và TỰ vẽ lại mỗi khi `mappingTargets` đổi. Bỏ trống = spreadsheet thường.
+     */
+    mappingIndicatorConfig = input();
+    /** Danh sách cột cần highlight (`{ sheetId, colIndex }`). Đổi runtime → tự vẽ lại header. */
+    mappingTargets = input([]);
+    outColumnDblClick = output();
+    /**
+     * Phát khi user insert / remove / move cột (kể cả chọn nhiều cột, và cả undo/redo).
+     * Consumer dùng `remapColumnIndexes(mappings, $event)` để dịch lại mảng mapping bên ngoài
+     * cho khớp vị trí mới — tránh lệch khi chèn/xóa cột ở giữa.
+     */
+    outColumnStructureChange = output();
+    containerRef = viewChild('containerRef');
+    ngZone = inject(NgZone);
+    constructor() {
+        // Auto re-apply: chỉ chạy khi đã bật config + Univer đã khởi tạo. Lần đầu (chưa init) tự bỏ qua.
+        effect(() => {
+            this.mappingTargets();
+            this.mappingIndicatorConfig();
+            untracked(() => this.reapplyIndicators());
+        });
+    }
+    ngAfterViewInit() {
+        this.activeLocale.set(this.locale());
+        this.pendingInitTimer = setTimeout(() => {
+            this.pendingInitTimer = null;
+            this.initUniver(this.buildEmptyWorkbook());
+        });
+    }
+    get FunctionControl() {
+        return {
+            loadData: (data) => this.loadData(data),
+            saveData: () => this.saveData(),
+            getActiveSheetInfo: () => this.getActiveSheetInfo(),
+            getColumnNumfmt: (sheetId, colIndex) => this.getColumnNumfmt(sheetId, colIndex),
+            extractAllColumnFormats: (snapshot) => this.extractAllColumnFormats(snapshot),
+            toggleToolbar: () => this.toggleToolbar(),
+            toggleSheetTabs: () => this.toggleSheetTabs(),
+            reset: (data) => this.reset(data),
+            executeCommand: (commandId, params) => this.executeCommand(commandId, params),
+            applyNumfmt: (row, col, numRows, numCols, pattern) => this.applyNumfmt(row, col, numRows, numCols, pattern),
+            scheduleOnReady: (cb) => {
+                this.pendingReadyCb = cb;
+            },
+            setLocale: (locale) => this.setLocale(locale),
+            activeCellRef: this.activeCellRef,
+            activeCellFormat: this.activeCellFormat,
+            showToolbar: this.showToolbar,
+            showSheetTabs: this.showSheetTabs,
+            locale: this.activeLocale.asReadonly(),
+        };
+    }
+    setLocale(locale) {
+        if (locale === this.activeLocale())
+            return;
+        this.activeLocale.set(locale);
+        this.reinitUniver();
+    }
+    loadData(data) {
+        const decorated = this.decorateSnapshot(data);
+        if (this.pendingInitTimer !== null) {
+            clearTimeout(this.pendingInitTimer);
+            this.pendingInitTimer = null;
+            this.initUniver(decorated);
+            return;
+        }
+        this.destroyUniver();
+        setTimeout(() => this.initUniver(decorated));
+    }
+    /** Snapshot thô từ Univer (CÓ thể còn indicator). Dùng nội bộ cho re-apply. */
+    saveRaw() {
+        return (this.univerAPI?.getActiveWorkbook()?.save() ?? {});
+    }
+    /** Snapshot trả cho consumer — tự gỡ indicator nếu luồng auto đang bật. */
+    saveData() {
+        const config = this.mappingIndicatorConfig();
+        if (!config)
+            return this.saveRaw();
+        return stripMappingIndicators(this.saveRaw(), config);
+    }
+    /** Áp indicator vào snapshot trước khi load — chỉ khi luồng auto đang bật. Lưu baseline để diff. */
+    decorateSnapshot(data) {
+        const config = this.mappingIndicatorConfig();
+        if (!config)
+            return data;
+        const decorated = applyMappingIndicators(data, this.mappingTargets(), config);
+        this.lastDecorated = decorated;
+        return decorated;
+    }
+    /**
+     * Vẽ lại indicator KHÔNG reinit Univer: tính snapshot đích rồi CHỈ ghi đè đúng các ô header
+     * khác so với baseline trước đó (style + prefix + width) lên instance live qua facade.
+     * Diff theo baseline (style id ổn định 'h'/'m') → chỉ các cột vừa map/bỏ map mới được vẽ lại.
+     */
+    reapplyIndicators() {
+        const config = this.mappingIndicatorConfig();
+        const wb = this.univerAPI?.getActiveWorkbook();
+        const prev = this.lastDecorated;
+        if (!config || !wb || !prev)
+            return;
+        const next = applyMappingIndicators(this.saveRaw(), this.mappingTargets(), config);
+        this.lastDecorated = next;
+        const headerKey = String(config.headerRowIndex ?? 0);
+        const headerRow = Number(headerKey);
+        const stylesNext = (next['styles'] ?? {});
+        const sheetsNext = (next['sheets'] ?? {});
+        const sheetsPrev = (prev['sheets'] ?? {});
+        for (const sheetId of Object.keys(sheetsNext)) {
+            const ws = wb.getSheetBySheetId(sheetId);
+            if (!ws)
+                continue;
+            const nextRow = sheetsNext[sheetId]?.cellData?.[headerKey] ?? {};
+            const prevRow = sheetsPrev[sheetId]?.cellData?.[headerKey] ?? {};
+            const colData = sheetsNext[sheetId]?.columnData ?? {};
+            for (const colKey of Object.keys(nextRow)) {
+                const cellNext = nextRow[colKey];
+                const cellPrev = prevRow[colKey];
+                // Ô không đổi cả value lẫn style → bỏ qua (mấu chốt: chỉ vẽ lại cột vừa map/bỏ map).
+                if (!cellNext || (cellNext.v === cellPrev?.v && cellNext.s === cellPrev?.s))
+                    continue;
+                const style = (typeof cellNext.s === 'string' ? stylesNext[cellNext.s] : cellNext.s);
+                const cell = { v: cellNext.v, s: style };
+                void ws.getRange(headerRow, Number(colKey)).setValue(cell);
+                const width = colData[colKey]?.w;
+                if (typeof width === 'number')
+                    void ws.setColumnWidth(Number(colKey), width);
+            }
+        }
+    }
+    toggleToolbar() {
+        this.showToolbar.update((v) => !v);
+        this.reinitUniver();
+    }
+    toggleSheetTabs() {
+        this.showSheetTabs.update((v) => !v);
+        this.reinitUniver();
+    }
+    reset(data) {
+        this.destroyUniver();
+        this.initUniver(this.decorateSnapshot(data ?? this.buildEmptyWorkbook()));
+    }
+    executeCommand(commandId, params) {
+        // CONVENTION-EXCEPT: any — FUniver.executeCommand không expose typing
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        void this.univerAPI?.executeCommand?.(commandId, params);
+    }
+    applyNumfmt(row, col, numRows, numCols, pattern) {
+        // CONVENTION-EXCEPT: any — FWorkbook.getId / FWorksheet.getSheetId not exposed in public types
+        // Note: FRange.setNumberFormat() has a Univer facade bug — it builds `values` but never passes
+        // them to executeCommand. We call the command directly with the correct params instead.
+        // FWorkbook uses getId() (not getUnitId()) and FWorksheet uses getSheetId() for subUnitId.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wb = this.univerAPI?.getActiveWorkbook();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ws = wb?.getActiveSheet?.();
+        if (!wb || !ws)
+            return;
+        const unitId = (wb.getId?.() ?? '');
+        const subUnitId = (ws.getSheetId?.() ?? '');
+        const values = [];
+        for (let r = row; r < row + numRows; r++) {
+            for (let c = col; c < col + numCols; c++) {
+                values.push({ pattern, row: r, col: c });
+            }
+        }
+        this.executeCommand('sheet.command.numfmt.set.numfmt', { unitId, subUnitId, values });
+    }
+    getActiveSheetInfo() {
+        // CONVENTION-EXCEPT: any — FWorksheet public types chưa expose getSheetId/getName
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sheet = this.univerAPI?.getActiveWorkbook()?.getActiveSheet();
+        if (!sheet)
+            return null;
+        return {
+            sheetId: (sheet.getSheetId?.() ?? ''),
+            sheetName: (sheet.getSheetName?.() ?? sheet.getName?.() ?? ''),
+        };
+    }
+    /** Đọc numfmt pattern của một cell từ workbook snapshot. */
+    readCellNumfmt(sheetId, row, col) {
+        try {
+            // CONVENTION-EXCEPT: any — FWorkbook.save() không expose typing
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ss = this.univerAPI?.getActiveWorkbook()?.save();
+            const styles = ss?.styles;
+            const cells = ss?.sheets?.[sheetId]?.cellData;
+            const styleId = cells?.[String(row)]?.[String(col)]?.s;
+            if (!styleId || !styles)
+                return 'General';
+            return styles[styleId]?.n?.pattern ?? styles[styleId]?.nf?.pattern ?? 'General';
+        }
+        catch {
+            return 'General';
+        }
+    }
+    /** Đọc giá trị số (Excel serial) của một ô; null nếu ô rỗng/không phải số. */
+    readCellValue(sheetId, row, col) {
+        try {
+            // CONVENTION-EXCEPT: any — FWorkbook.save() không expose typing
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ss = this.univerAPI?.getActiveWorkbook()?.save();
+            const cells = ss?.sheets?.[sheetId]?.cellData;
+            const value = cells?.[String(row)]?.[String(col)]?.v;
+            return typeof value === 'number' && isFinite(value) ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getColumnNumfmt(sheetId, colIndex) {
+        for (const row of [1, 2, 3]) {
+            const pattern = this.readCellNumfmt(sheetId, row, colIndex);
+            if (pattern !== 'General')
+                return pattern;
+        }
+        return 'General';
+    }
+    /** Chụp numfmt gốc từng ô của vùng chọn (giới hạn 500 dòng như applyFormat) để Cancel khôi phục đúng. */
+    captureRangeNumfmt(snap) {
+        if (!snap)
+            return null;
+        const values = [];
+        const maxRow = Math.min(snap.endRow, snap.startRow + 499);
+        for (let r = snap.startRow; r <= maxRow; r++) {
+            for (let c = snap.startColumn; c <= snap.endColumn; c++) {
+                values.push({ pattern: this.readCellNumfmt(snap.subUnitId, r, c), row: r, col: c });
+            }
+        }
+        return values.length ? values : null;
+    }
+    extractAllColumnFormats(snapshot) {
+        const styles = snapshot['styles'];
+        const sheets = snapshot['sheets'];
+        const order = snapshot['sheetOrder'];
+        if (!styles || !sheets)
+            return [];
+        const results = [];
+        const seen = new Set();
+        for (const sheetId of order ?? Object.keys(sheets)) {
+            const sheetData = sheets[sheetId];
+            if (!sheetData?.cellData)
+                continue;
+            const sheetName = sheetData.name ?? sheetId;
+            const headerRow = sheetData.cellData['0'] ?? {};
+            for (const rowKey of ['1', '2', '3']) {
+                const row = sheetData.cellData[rowKey];
+                if (!row)
+                    continue;
+                for (const colKey of Object.keys(row)) {
+                    const key = `${sheetId}:${colKey}`;
+                    if (seen.has(key))
+                        continue;
+                    const styleId = row[colKey]?.s;
+                    if (!styleId)
+                        continue;
+                    const pattern = styles[styleId]?.n?.pattern ?? styles[styleId]?.nf?.pattern;
+                    if (!pattern)
+                        continue;
+                    seen.add(key);
+                    const colIndex = parseInt(colKey, 10);
+                    const colLetter = this.toColLetter(colIndex);
+                    const headerV = headerRow[colKey]?.v;
+                    results.push({
+                        sheet: sheetName,
+                        col: colLetter,
+                        colIndex,
+                        header: headerV ? String(headerV) : colLetter,
+                        numfmt: pattern,
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    toColLetter(index) {
+        let result = '';
+        let n = index;
+        do {
+            result = String.fromCharCode(65 + (n % 26)) + result;
+            n = Math.floor(n / 26) - 1;
+        } while (n >= 0);
+        return result;
+    }
+    buildEmptyWorkbook() {
+        return {
+            id: 'workbook-default',
+            locale: this.resolveLocaleType(),
+            name: 'Sheet',
+            sheetOrder: ['sheet1'],
+            appVersion: '3.0.0-alpha',
+            sheets: {
+                sheet1: { id: 'sheet1', name: 'Sheet1', rowCount: 30, columnCount: 26, cellData: {} },
+            },
+        };
+    }
+    resolveLocaleType() {
+        return this.activeLocale() === 'vi' ? LocaleType.VI_VN : LocaleType.EN_US;
+    }
+    registerColumnClickListener() {
+        const wrapper = this.containerRef()?.nativeElement;
+        if (!wrapper)
+            return;
+        this.listenEnableTimer = setTimeout(() => {
+            this.listenEnabled = true;
+        }, 600);
+        const handleDblClick = (event) => {
+            if (!this.listenEnabled)
+                return;
+            if (event.target.tagName !== 'CANVAS')
+                return;
+            setTimeout(() => {
+                this.ngZone.run(() => {
+                    const range = this.univerAPI?.getActiveWorkbook()?.getActiveSheet()?.getActiveRange();
+                    if (!range)
+                        return;
+                    const { startRow, endRow, startColumn, rangeType } = range.getRange();
+                    const isColHeader = rangeType === 2 || (startRow === 0 && endRow >= 29);
+                    const isFirstRow = startRow === 0 && endRow === 0;
+                    if (!isColHeader && !isFirstRow)
+                        return;
+                    this.outColumnDblClick.emit(startColumn);
+                });
+            }, 50);
+        };
+        wrapper.addEventListener('dblclick', handleDblClick);
+        this.columnClickDisposable = { dispose: () => wrapper.removeEventListener('dblclick', handleDblClick) };
+    }
+    /**
+     * Lắng nghe MUTATION cột (insert/remove/move) — mức mutation để bắt cả undo/redo, một lần/thao tác.
+     * Chuẩn hoá thành `T_columnStructureChange` rồi phát ra ngoài cho consumer remap mapping.
+     */
+    registerColumnOpListener() {
+        // CONVENTION-EXCEPT: any — FUniver.onCommandExecuted / commandInfo không expose trong public types
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const api = this.univerAPI;
+        if (typeof api?.onCommandExecuted !== 'function')
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.columnOpDisposable = api.onCommandExecuted((commandInfo) => {
+            const change = this.toColumnStructureChange(commandInfo?.id, commandInfo?.params);
+            if (change)
+                this.ngZone.run(() => this.outColumnStructureChange.emit(change));
+        });
+    }
+    toColumnStructureChange(id, params) {
+        const p = params;
+        const sheetId = p?.subUnitId ?? '';
+        if (id === InsertColMutation.id || id === RemoveColMutation.id) {
+            if (!p?.range)
+                return null;
+            const type = id === InsertColMutation.id ? 'insert' : 'remove';
+            return { sheetId, type, startColumn: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 };
+        }
+        if (id === MoveColsMutation.id) {
+            if (!p?.sourceRange || !p?.targetRange)
+                return null;
+            return {
+                sheetId,
+                type: 'move',
+                startColumn: p.sourceRange.startColumn,
+                count: p.sourceRange.endColumn - p.sourceRange.startColumn + 1,
+                toColumn: p.targetRange.startColumn,
+            };
+        }
+        return null;
+    }
+    registerFormatListener() {
+        // CONVENTION-EXCEPT: any — FUniver.onCommandExecuted / commandInfo không expose trong public types
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const api = this.univerAPI;
+        if (typeof api?.onCommandExecuted !== 'function')
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.formatDisposable = api.onCommandExecuted((commandInfo) => {
+            this.ngZone.run(() => {
+                if (commandInfo?.id === 'sheet.operation.open.numfmt.panel') {
+                    this.numfmtPanelOpen = true;
+                    this.numfmtConfirmed = false; // reset cờ — phiên mới mặc định chưa Confirm
+                    this.numfmtDateActive = false; // chưa chọn Type=Date → chưa kích hoạt luồng custom
+                    // Lưu numfmt gốc từng ô để Cancel khôi phục đúng (vùng chọn có thể nhiều format khác nhau)
+                    this.originalCellFormats = this.captureRangeNumfmt(this.lastRangeSnapshot);
+                    // Chỉ bật observer khi panel mở (tránh chạy liên tục theo mọi mutation toàn trang)
+                    this.numfmtObserver?.observe(document.body, { childList: true, subtree: true });
+                    // Reopen: Univer hiện lại panel cũ bằng CSS (không mutation) → observer không fire. Chủ động
+                    // thử inject sau 1 nhịp để bắt trường hợp list ngày đã sẵn trong DOM tái dùng.
+                    setTimeout(() => {
+                        if (this.numfmtPanelOpen)
+                            this.processNumfmtPanel();
+                    }, 60);
+                    return;
+                }
+                if (commandInfo?.id === 'sheet.operation.close.numfmt.panel') {
+                    this.numfmtPanelOpen = false;
+                    // Tắt observer khi đóng (perf). KHÔNG gỡ listener: Univer tái dùng DOM panel, gỡ sẽ làm
+                    // option chết khi mở lại. cleanup chạy trước lần inject mới (DOM mới) hoặc khi destroy.
+                    this.numfmtObserver?.disconnect();
+                    // Univer TÁI DÙNG DOM panel khi reopen (nhớ cả Type=Date) → guard data-custom-dates còn sót sẽ
+                    // chặn re-inject ở lần mở sau, khiến highlight stale + dateActive=false (mất revert). Xoá guard
+                    // để lần mở kế tiếp inject lại + resync highlight/auto-apply theo cột hiện tại.
+                    document.querySelector('.numfmt-panel ul.univer-select-list')?.removeAttribute('data-custom-dates');
+                    // Chỉ khi bấm CONFIRM (numfmtConfirmed=true) mới GIỮ pattern đã chọn cho cả vùng.
+                    // Cancel / X / click-ngoài đều KHÔNG set cờ → KHÔI PHỤC numfmt GỐC TỪNG Ô (đã chụp khi mở panel).
+                    const dateActive = this.numfmtDateActive;
+                    const confirmed = this.numfmtConfirmed;
+                    const pending = this.pendingNumfmtPattern;
+                    const originalCells = this.originalCellFormats;
+                    this.numfmtConfirmed = false;
+                    this.pendingNumfmtPattern = null;
+                    this.originalCellFormats = null;
+                    this.numfmtDateActive = false;
+                    // Type khác Date (Số/Tiền tệ/%/Text…) do Univer tự apply/cancel → KHÔNG can thiệp,
+                    // nếu không sẽ revert nhầm format mà user vừa áp qua luồng native của Univer.
+                    if (!dateActive) {
+                        this.clearNumfmtPreview();
+                        return;
+                    }
+                    const snap = this.lastRangeSnapshot;
+                    if (!snap)
+                        return;
+                    let values;
+                    if (confirmed && pending) {
+                        values = [];
+                        for (let r = snap.startRow; r <= Math.min(snap.endRow, snap.startRow + 499); r++) {
+                            for (let c = snap.startColumn; c <= snap.endColumn; c++) {
+                                values.push({ pattern: pending, row: r, col: c });
+                            }
+                        }
+                    }
+                    else if (!confirmed && originalCells) {
+                        values = originalCells;
+                    }
+                    else {
+                        return;
+                    }
+                    if (!values.length)
+                        return;
+                    // CONVENTION-EXCEPT: any — FUniver.executeCommand không expose typing
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    void this.univerAPI?.executeCommand?.('sheet.command.numfmt.set.numfmt', {
+                        unitId: snap.unitId,
+                        subUnitId: snap.subUnitId,
+                        values,
+                    });
+                    this.clearNumfmtPreview();
+                    return;
+                }
+                // Khi panel đang mở: CHỈ user đổi vùng chọn trên grid (set-selections) mới được cập nhật snapshot
+                // để re-target panel sang cột/cell mới. Command nội bộ panel (numfmt.set, mutation…) KHÔNG đụng snapshot.
+                const isUserSelection = commandInfo?.id === 'sheet.operation.set-selections';
+                if (this.numfmtPanelOpen && !isUserSelection)
+                    return;
+                const wb = this.univerAPI?.getActiveWorkbook();
+                const ws = wb?.getActiveSheet();
+                const range = ws?.getActiveRange();
+                if (!range || !wb || !ws)
+                    return;
+                const rangeData = range.getRange();
+                this.activeCellRef.set(`${this.toColLetter(rangeData.startColumn)}${rangeData.startRow + 1}`);
+                // CONVENTION-EXCEPT: any — FWorkbook.getId / FWorksheet.getSheetId chưa expose trong types
+                /* eslint-disable @typescript-eslint/no-explicit-any */
+                const wbAny = wb;
+                const wsAny = ws;
+                /* eslint-enable @typescript-eslint/no-explicit-any */
+                this.lastRangeSnapshot = {
+                    unitId: (wbAny.getId?.() ?? wbAny.getUnitId?.() ?? ''),
+                    subUnitId: (wsAny.getSheetId?.() ?? wsAny.getUnitId?.() ?? ''),
+                    startRow: rangeData.startRow,
+                    endRow: rangeData.endRow,
+                    startColumn: rangeData.startColumn,
+                    endColumn: rangeData.endColumn,
+                };
+                // CONVENTION-EXCEPT: any — FRange.getCellStyleData chưa expose trong types
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const rangeAny = range;
+                const style = rangeAny.getCellStyleData?.();
+                const numFmt = style?.n?.pattern ?? style?.nf?.pattern;
+                this.activeCellFormat.set(numFmt && numFmt !== '0' ? numFmt : 'General');
+                // User đổi vùng chọn LÚC panel Date đang mở → tích luỹ numfmt gốc của vùng mới (để Cancel
+                // revert đúng mọi ô đã chạm) rồi đồng bộ lại panel (label + highlight + auto-apply) theo cột mới.
+                if (this.numfmtPanelOpen && this.numfmtDateActive) {
+                    this.mergeOriginalCellFormats(this.captureRangeNumfmt(this.lastRangeSnapshot));
+                    this.numfmtResync?.();
+                }
+            });
+        });
+    }
+    /** Gộp numfmt gốc của vùng vừa chọn vào snapshot revert, giữ giá trị GỐC ĐẦU TIÊN cho mỗi ô. */
+    mergeOriginalCellFormats(extra) {
+        if (!extra)
+            return;
+        if (!this.originalCellFormats) {
+            this.originalCellFormats = extra;
+            return;
+        }
+        const seen = new Set(this.originalCellFormats.map((v) => `${v.row}:${v.col}`));
+        for (const cell of extra) {
+            if (seen.has(`${cell.row}:${cell.col}`))
+                continue;
+            this.originalCellFormats.push(cell);
+        }
+    }
+    /**
+     * Xoá live-preview overlay của Univer numfmt panel.
+     *
+     * Khi panel numfmt mở, `NumfmtController._previewPattern` được Univer dùng để vẽ đè
+     * (preview) lên hiển thị thật của vùng chọn. Vì các option date custom ghi numfmt
+     * trực tiếp vào model (không đi qua panel gốc của Univer), preview này không bao giờ
+     * khớp model → cột không đổi hiển thị ngay. Set `_previewPattern = null` + force re-render
+     * (`_forceUpdate`) để canvas vẽ đúng giá trị model tức thì.
+     *
+     * NumfmtController không export khỏi `@univerjs/sheets-numfmt` nên phải tìm instance
+     * qua injector của Univer (cache lại sau lần đầu).
+     */
+    clearNumfmtPreview() {
+        const controller = this.resolveNumfmtController();
+        if (!controller)
+            return;
+        if (controller._previewPattern != null)
+            controller._previewPattern = null;
+        // LUÔN force re-render: numfmt vừa áp vào model cần vẽ lại canvas ngay (kể cả khi không có preview).
+        controller._forceUpdate?.();
+    }
+    // CONVENTION-EXCEPT: any — truy cập injector + NumfmtController nội bộ của Univer (không có public API)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolveNumfmtController() {
+        if (this.numfmtController)
+            return this.numfmtController;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const injector = this.univer?.__getInjector?.();
+        if (!injector)
+            return null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const scanMap = (map) => {
+            if (!(map instanceof Map))
+                return null;
+            for (const value of map.values()) {
+                const candidates = Array.isArray(value) ? value : [value];
+                for (const candidate of candidates) {
+                    const instance = candidate?.instance !== undefined ? candidate.instance : candidate;
+                    if (instance && typeof instance === 'object' && '_previewPattern' in instance)
+                        return instance;
+                }
+            }
+            return null;
+        };
+        // Các instance của redi nằm trong Map lồng 1 cấp (vd injector.resolvedDependencyCollection.resolvedDependencies)
+        for (const key of Object.keys(injector)) {
+            const value = injector[key];
+            let found = scanMap(value);
+            if (!found && value && typeof value === 'object') {
+                for (const nestedKey of Object.keys(value)) {
+                    found = scanMap(value[nestedKey]);
+                    if (found)
+                        break;
+                }
+            }
+            if (found) {
+                this.numfmtController = found;
+                return found;
+            }
+        }
+        return null;
+    }
+    /**
+     * Tạo observer để inject option ngày custom + highlight khi panel numfmt render.
+     * Observer CHỈ được bật/tắt theo vòng đời panel (xem open/close.numfmt.panel handler) để
+     * không chạy liên tục theo mọi mutation DOM toàn trang.
+     */
+    registerNumfmtDropdownObserver() {
+        this.numfmtObserver = new MutationObserver(() => this.processNumfmtPanel());
+    }
+    /**
+     * Thử inject option ngày custom + highlight cho panel numfmt hiện tại.
+     * Gọi từ 2 nguồn: (1) MutationObserver khi Univer render list ngày; (2) trực tiếp lúc mở panel —
+     * vì Univer TÁI DÙNG DOM panel khi reopen (hiện lại bằng CSS, không phát sinh mutation) nên observer
+     * không kích hoạt, phải chủ động gọi để re-inject + resync theo cột hiện tại.
+     */
+    processNumfmtPanel() {
+        syncActiveNumfmtHighlight();
+        const result = injectCustomDateFormats(() => this.lastRangeSnapshot, 
+        // CONVENTION-EXCEPT: any — FUniver.executeCommand không expose typing
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (cmdId, params) => void this.univerAPI.executeCommand?.(cmdId, params), (pattern) => {
+            this.pendingNumfmtPattern = pattern;
+        }, () => {
+            const snap = this.lastRangeSnapshot;
+            if (!snap)
+                return this.activeCellFormat();
+            // Quét vài dòng đầu của vùng chọn, bỏ qua header/General để lấy format ĐẠI DIỆN của dữ liệu.
+            // Khi chọn cả cột, startRow = 0 là header (thường General) → nếu chỉ đọc dòng đó sẽ highlight sai option.
+            const maxScan = Math.min(snap.endRow, snap.startRow + 4);
+            for (let r = snap.startRow; r <= maxScan; r++) {
+                const fmt = this.readCellNumfmt(snap.subUnitId, r, snap.startColumn);
+                if (fmt !== 'General')
+                    return fmt;
+            }
+            return this.activeCellFormat();
+        }, () => this.clearNumfmtPreview(), () => {
+            // Giá trị thực của ô đại diện (dòng dữ liệu đầu có số) → label option khớp dữ liệu cột.
+            const snap = this.lastRangeSnapshot;
+            if (!snap)
+                return null;
+            const maxScan = Math.min(snap.endRow, snap.startRow + 4);
+            for (let r = snap.startRow; r <= maxScan; r++) {
+                const value = this.readCellValue(snap.subUnitId, r, snap.startColumn);
+                if (value !== null)
+                    return value;
+            }
+            return null;
+        }, () => {
+            this.numfmtConfirmed = true;
+        });
+        // result chỉ truthy khi THỰC SỰ inject trên 1 listContainer Date mới (guard data-custom-dates chặn
+        // các lần gọi thừa). Gỡ listener của lần inject trước trước khi giữ cleanup mới → tránh tích tụ.
+        // Đồng thời lưu resync để re-target panel khi user đổi cột, và đánh dấu luồng Date đang hoạt động.
+        if (result) {
+            this.numfmtCleanup?.();
+            this.numfmtCleanup = result.cleanup;
+            this.numfmtResync = result.resync;
+            this.numfmtDateActive = true;
+        }
+    }
+    initUniver(data) {
+        const wrapper = this.containerRef()?.nativeElement;
+        if (!wrapper)
+            return;
+        wrapper.replaceChildren();
+        const container = document.createElement('div');
+        container.style.cssText = 'width:100%;height:100%';
+        wrapper.appendChild(container);
+        const univer = new Univer({
+            locale: this.resolveLocaleType(),
+            locales: {
+                [LocaleType.EN_US]: univerLocaleEn,
+                [LocaleType.VI_VN]: univerLocaleVi,
+            },
+            theme: defaultTheme,
+        });
+        this.univer = univer;
+        univer.registerPlugin(UniverRenderEnginePlugin);
+        univer.registerPlugin(UniverFormulaEnginePlugin);
+        univer.registerPlugin(UniverUIPlugin, { container, header: this.showToolbar(), footer: this.showSheetTabs() });
+        univer.registerPlugin(UniverDocsPlugin, { hasScroll: false });
+        univer.registerPlugin(UniverDocsUIPlugin);
+        univer.registerPlugin(UniverSheetsPlugin);
+        univer.registerPlugin(UniverSheetsUIPlugin, { menu: this.toolbarMenuConfig() });
+        univer.registerPlugin(UniverSheetsNumfmtPlugin);
+        univer.registerPlugin(UniverSheetsFormulaPlugin);
+        univer.registerPlugin(UniverSheetsFormulaUIPlugin);
+        univer.createUnit(UniverInstanceType.UNIVER_SHEET, data);
+        this.univerAPI = FUniver.newAPI(univer);
+        if (this.pendingReadyCb) {
+            // Wait for .more-numfmt-type to appear in DOM — this signals that UniverSheetsUIPlugin
+            // has fully rendered the toolbar and UniverSheetsNumfmtPlugin's INumfmtModel is ready.
+            const wrapper = this.containerRef()?.nativeElement;
+            if (wrapper) {
+                this.readyObserver = new MutationObserver(() => {
+                    if (!wrapper.querySelector('.more-numfmt-type'))
+                        return;
+                    this.readyObserver?.disconnect();
+                    this.readyObserver = null;
+                    const cb = this.pendingReadyCb;
+                    this.pendingReadyCb = null;
+                    cb?.();
+                });
+                this.readyObserver.observe(wrapper, { childList: true, subtree: true });
+            }
+        }
+        this.registerColumnClickListener();
+        this.registerColumnOpListener();
+        this.registerFormatListener();
+        this.registerNumfmtDropdownObserver();
+        this.registerToolbarWidthSync();
+        this.registerNumfmtClickInterceptor();
+    }
+    /**
+     * Khắc phục lỗi toolbar collapse sai (gom item vào menu ⋮ dù còn khoảng trắng).
+     *
+     * Univer (component Ribbon) quyết định overflow bằng 1 container ĐO off-screen (con trực tiếp của
+     * header, position:absolute). Thuật toán: `total = 90; cho mỗi ITEM total += item.clientWidth + 8;
+     * nếu total > measuringContainer.clientWidth → collapse item`. Công thức này OVER-COUNT 2 chỗ:
+     *   • +90px reserve cho nút ⋮ (cộng kể cả khi không cần collapse).
+     *   • +8px MỖI item, trong khi khoảng cách (gap) thực tế chỉ nằm giữa các GROUP.
+     * Nếu set bề rộng container đo = đúng headerW thì `total` (vd 961) > headerW (vd 900) → Univer tưởng
+     * tràn và gom item vào ⋮ dù content thật chỉ ~829px (còn ~70px trống).
+     *
+     * Fix (triệt để, không phụ thuộc timing): pin bề rộng container ĐO = HẰNG SỐ rất lớn qua CSS RULE trong
+     * 1 <style> riêng. Khi đó `total` của Univer KHÔNG BAO GIỜ vượt → KHÔNG gom item vào ⋮ → luôn hiển thị
+     * ĐỦ option (đúng yêu cầu). Vì sao chọn cách này thay vì khớp width = headerW:
+     *   • Thuật toán Univer over-count (90 reserve ⋮ + 8px/item) → khớp sát headerW vẫn collapse sai khi còn chỗ.
+     *   • ResizeObserver của Univer hay KẸT STALE: 1 transient lúc load (icon/font làm item rộng nhất thời) đặt
+     *     collapsedIds rồi KHÔNG re-fire → kẹt ⋮ vĩnh viễn dù sau đó còn chỗ (đúng triệu chứng reload luôn ⋮).
+     *   • Set inline lại bị React re-render strip → oscillation. CSS rule !important React không strip được.
+     * Container đo vốn off-screen (position:absolute, opacity:0) nên width khổng lồ hoàn toàn vô hình. Khi
+     * vùng chứa quá hẹp (hiếm với spreadsheet) toolbar cuộn ngang — xem SCSS `.univer-toolbar` overflow-x.
+     */
+    registerToolbarWidthSync() {
+        const wrapper = this.containerRef()?.nativeElement;
+        if (!wrapper)
+            return;
+        wrapper.classList.add(this.toolbarScopeClass);
+        const styleEl = document.createElement('style');
+        this.toolbarStyleEl = styleEl;
+        styleEl.textContent = `.${this.toolbarScopeClass} .univer-workbench-container-header > .univer-toolbar-container{width:100000px !important;max-width:none !important;}`;
+        document.head.appendChild(styleEl);
+    }
+    registerNumfmtClickInterceptor() {
+        const clickHandler = (e) => {
+            const target = e.target;
+            if (target.closest('.numfmt-panel') ?? target.closest('.more-numfmt-type-options'))
+                return;
+            const numfmtText = target.closest('.more-numfmt-type');
+            const numfmtSelect = target.closest('.univer-toolbar-item-select');
+            const isNumfmtBtn = numfmtText ?? (numfmtSelect?.querySelector('.more-numfmt-type') ? numfmtSelect : null);
+            if (!isNumfmtBtn)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            this.executeCommand('sheet.operation.open.numfmt.panel', undefined);
+        };
+        document.body.addEventListener('click', clickHandler, true);
+        this.numfmtClickDisposable = { dispose: () => document.body.removeEventListener('click', clickHandler, true) };
+    }
+    destroyUniver() {
+        if (this.pendingInitTimer !== null) {
+            clearTimeout(this.pendingInitTimer);
+            this.pendingInitTimer = null;
+        }
+        this.columnClickDisposable?.dispose();
+        this.columnClickDisposable = null;
+        this.columnOpDisposable?.dispose();
+        this.columnOpDisposable = null;
+        this.formatDisposable?.dispose();
+        this.formatDisposable = null;
+        this.numfmtObserver?.disconnect();
+        this.numfmtObserver = null;
+        this.toolbarResizeObserver?.disconnect();
+        this.toolbarResizeObserver = null;
+        this.toolbarStyleEl?.remove();
+        this.toolbarStyleEl = null;
+        this.numfmtClickDisposable?.dispose();
+        this.numfmtClickDisposable = null;
+        this.numfmtCleanup?.();
+        this.numfmtCleanup = null;
+        this.numfmtResync = null;
+        this.numfmtDateActive = false;
+        this.readyObserver?.disconnect();
+        this.readyObserver = null;
+        this.activeCellFormat.set('General');
+        this.activeCellRef.set('');
+        this.lastRangeSnapshot = null;
+        this.pendingNumfmtPattern = null;
+        this.numfmtConfirmed = false;
+        this.originalCellFormats = null;
+        this.numfmtPanelOpen = false;
+        this.listenEnabled = false;
+        if (this.listenEnableTimer !== null) {
+            clearTimeout(this.listenEnableTimer);
+            this.listenEnableTimer = null;
+        }
+        this.numfmtController = null;
+        this.univer?.dispose();
+        this.univer = null;
+        this.univerAPI = null;
+    }
+    reinitUniver() {
+        const currentData = this.univerAPI?.getActiveWorkbook()?.save();
+        this.destroyUniver();
+        setTimeout(() => this.initUniver(currentData ?? this.buildEmptyWorkbook()));
+    }
+    ngOnDestroy() {
+        this.destroyUniver();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiComponentsSpreadsheetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.14", type: LibsUiComponentsSpreadsheetComponent, isStandalone: true, selector: "libs_ui-components-spreadsheet", inputs: { locale: { classPropertyName: "locale", publicName: "locale", isSignal: true, isRequired: false, transformFunction: null }, toolbarMenuConfig: { classPropertyName: "toolbarMenuConfig", publicName: "toolbarMenuConfig", isSignal: true, isRequired: false, transformFunction: null }, mappingIndicatorConfig: { classPropertyName: "mappingIndicatorConfig", publicName: "mappingIndicatorConfig", isSignal: true, isRequired: false, transformFunction: null }, mappingTargets: { classPropertyName: "mappingTargets", publicName: "mappingTargets", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { outColumnDblClick: "outColumnDblClick", outColumnStructureChange: "outColumnStructureChange" }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["containerRef"], descendants: true, isSignal: true }], ngImport: i0, template: "<div #containerRef class=\"libs-ui-components-spreadsheet-container\"></div>\n", styles: ["@charset \"UTF-8\";:host{display:block;width:100%;height:100%}.libs-ui-components-spreadsheet-container{width:100%;height:100%}::ng-deep .univer-toolbar-container{flex-grow:1!important;margin:0!important}::ng-deep .univer-toolbar{overflow-x:auto}::ng-deep .univer-toolbar>.univer-toolbar-container{justify-content:flex-start!important;flex-shrink:0!important}::ng-deep .univer-toolbar-more-container{display:flex!important;flex-wrap:wrap!important;gap:8px!important;width:max-content!important;max-width:320px!important;padding:8px!important}::ng-deep .univer-toolbar-more-container .univer-toolbar-group{flex-shrink:0!important}::ng-deep .univer-select-dropdown .univer-select-item[title=\"Custom Format\"]{display:none!important}::ng-deep .numfmt-panel{padding:0 4px}::ng-deep .univer-custom-format-title{margin-top:12px!important;font-size:11px!important;font-weight:700!important;color:#8c8c8c!important;text-transform:uppercase!important;letter-spacing:.5px!important}::ng-deep .univer-custom-format-input{margin-top:6px!important}::ng-deep .univer-custom-format-input input,::ng-deep .univer-custom-format-input textarea{font-family:SFMono-Regular,Consolas,monospace!important;font-size:12px!important;border-radius:6px!important}::ng-deep .univer-custom-format-history-list{margin-top:6px!important;padding:4px!important;border:1.5px solid #f0f0f0!important;border-radius:8px!important;max-height:260px!important;overflow-y:auto!important;background:#fafafa!important;scrollbar-width:thin;scrollbar-color:#d9d9d9 transparent}::ng-deep .univer-custom-format-history-list::-webkit-scrollbar{width:4px}::ng-deep .univer-custom-format-history-list::-webkit-scrollbar-thumb{background:#d9d9d9;border-radius:4px}::ng-deep .univer-custom-format-history-list-item{padding:5px 8px!important;border-radius:6px!important;gap:8px!important;transition:all .12s;border-bottom:1px solid transparent!important}::ng-deep .univer-custom-format-history-list-item:hover{background:#e6f4ff!important}::ng-deep .univer-custom-format-history-list-item:hover>span:last-child,::ng-deep .univer-custom-format-history-list-item:hover>div:last-child{color:#1677ff!important}::ng-deep .univer-custom-format-history-list-item>span:not(.univer-custom-format-history-list-item-icon-wrap),::ng-deep .univer-custom-format-history-list-item>div:not(.univer-custom-format-history-list-item-icon-wrap){font-family:SFMono-Regular,Consolas,monospace!important;font-size:11px!important;color:#434343!important;overflow:hidden!important;text-overflow:ellipsis!important;white-space:nowrap!important;max-width:240px!important}::ng-deep .univer-custom-format-history-list-item-icon-wrap{flex-shrink:0!important;opacity:.6}::ng-deep .univer-custom-format-des{margin-top:6px!important;font-size:11px!important;line-height:1.5!important;color:#8c8c8c!important;padding:6px 8px!important;background:#f5f5f5!important;border-radius:6px!important;border-left:3px solid #d9d9d9!important}::ng-deep .univer-numfmt-custom-item{position:relative!important;padding:5px 8px!important;border-radius:6px!important;font-family:SFMono-Regular,Consolas,monospace!important;font-size:12px!important;color:#434343!important;cursor:pointer!important;transition:background .12s,color .12s;display:block!important;border-left:3px solid transparent}::ng-deep .univer-numfmt-custom-item:hover{background:#f0f5ff!important;color:#1677ff!important;border-left-color:#1677ff!important}::ng-deep .univer-numfmt-custom-item.univer-numfmt-active{background:#e6f4ff!important;color:#1677ff!important;font-weight:600!important;padding-left:24px!important;border-left:3px solid #1677ff!important}::ng-deep .univer-numfmt-custom-item.univer-numfmt-active:before{content:\"\\2713\";position:absolute;left:7px;top:50%;transform:translateY(-50%);font-size:10px;font-weight:700;color:#1677ff;line-height:1}::ng-deep .numfmt-panel li.univer-select-list-item.univer-select-list-item-select:not(.univer-numfmt-custom-item){background:#e6f4ff!important;border-left:3px solid #1677ff!important;border-radius:6px!important}::ng-deep .numfmt-panel li.univer-select-list-item.univer-select-list-item-select:not(.univer-numfmt-custom-item) a{color:#1677ff!important}::ng-deep .numfmt-panel li.univer-select-list-item.univer-select-list-item-select:not(.univer-numfmt-custom-item) .univer-select-list-item-icon{color:#1677ff!important}::ng-deep .more-numfmt-type{cursor:pointer;font-size:0!important;display:inline-flex;align-items:center;line-height:1}::ng-deep .more-numfmt-type:before{content:\"\";display:inline-block;width:31px;height:18px;background-color:currentColor;mask:url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2034%2020'%3E%3Ctext%20x='0'%20y='15'%20font-size='13'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E123%3C/text%3E%3Ctext%20x='20'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E%25%3C/text%3E%3Ctext%20x='27'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E$%3C/text%3E%3Ccircle%20cx='26.5'%20cy='15'%20r='3.4'%20fill='none'%20stroke='black'%20stroke-width='1.1'/%3E%3Cpath%20d='M26.5%2013.2v1.8l1.2.9'%20fill='none'%20stroke='black'%20stroke-width='1.1'%20stroke-linecap='round'%20stroke-linejoin='round'/%3E%3C/svg%3E\") no-repeat center/contain;-webkit-mask:url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2034%2020'%3E%3Ctext%20x='0'%20y='15'%20font-size='13'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E123%3C/text%3E%3Ctext%20x='20'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E%25%3C/text%3E%3Ctext%20x='27'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E$%3C/text%3E%3Ccircle%20cx='26.5'%20cy='15'%20r='3.4'%20fill='none'%20stroke='black'%20stroke-width='1.1'/%3E%3Cpath%20d='M26.5%2013.2v1.8l1.2.9'%20fill='none'%20stroke='black'%20stroke-width='1.1'%20stroke-linecap='round'%20stroke-linejoin='round'/%3E%3C/svg%3E\") no-repeat center/contain}::ng-deep .univer-toolbar-item-select:has(.more-numfmt-type):hover{background-color:rgb(var(--grey-100));border-radius:var(--border-radius-base)}::ng-deep .univer-toolbar-item-select:has(.more-numfmt-type) .more-numfmt-type,::ng-deep .univer-toolbar-item-select:has(.more-numfmt-type) .univer-toolbar-item-select-arrow{background-color:transparent!important}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiComponentsSpreadsheetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'libs_ui-components-spreadsheet', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div #containerRef class=\"libs-ui-components-spreadsheet-container\"></div>\n", styles: ["@charset \"UTF-8\";:host{display:block;width:100%;height:100%}.libs-ui-components-spreadsheet-container{width:100%;height:100%}::ng-deep .univer-toolbar-container{flex-grow:1!important;margin:0!important}::ng-deep .univer-toolbar{overflow-x:auto}::ng-deep .univer-toolbar>.univer-toolbar-container{justify-content:flex-start!important;flex-shrink:0!important}::ng-deep .univer-toolbar-more-container{display:flex!important;flex-wrap:wrap!important;gap:8px!important;width:max-content!important;max-width:320px!important;padding:8px!important}::ng-deep .univer-toolbar-more-container .univer-toolbar-group{flex-shrink:0!important}::ng-deep .univer-select-dropdown .univer-select-item[title=\"Custom Format\"]{display:none!important}::ng-deep .numfmt-panel{padding:0 4px}::ng-deep .univer-custom-format-title{margin-top:12px!important;font-size:11px!important;font-weight:700!important;color:#8c8c8c!important;text-transform:uppercase!important;letter-spacing:.5px!important}::ng-deep .univer-custom-format-input{margin-top:6px!important}::ng-deep .univer-custom-format-input input,::ng-deep .univer-custom-format-input textarea{font-family:SFMono-Regular,Consolas,monospace!important;font-size:12px!important;border-radius:6px!important}::ng-deep .univer-custom-format-history-list{margin-top:6px!important;padding:4px!important;border:1.5px solid #f0f0f0!important;border-radius:8px!important;max-height:260px!important;overflow-y:auto!important;background:#fafafa!important;scrollbar-width:thin;scrollbar-color:#d9d9d9 transparent}::ng-deep .univer-custom-format-history-list::-webkit-scrollbar{width:4px}::ng-deep .univer-custom-format-history-list::-webkit-scrollbar-thumb{background:#d9d9d9;border-radius:4px}::ng-deep .univer-custom-format-history-list-item{padding:5px 8px!important;border-radius:6px!important;gap:8px!important;transition:all .12s;border-bottom:1px solid transparent!important}::ng-deep .univer-custom-format-history-list-item:hover{background:#e6f4ff!important}::ng-deep .univer-custom-format-history-list-item:hover>span:last-child,::ng-deep .univer-custom-format-history-list-item:hover>div:last-child{color:#1677ff!important}::ng-deep .univer-custom-format-history-list-item>span:not(.univer-custom-format-history-list-item-icon-wrap),::ng-deep .univer-custom-format-history-list-item>div:not(.univer-custom-format-history-list-item-icon-wrap){font-family:SFMono-Regular,Consolas,monospace!important;font-size:11px!important;color:#434343!important;overflow:hidden!important;text-overflow:ellipsis!important;white-space:nowrap!important;max-width:240px!important}::ng-deep .univer-custom-format-history-list-item-icon-wrap{flex-shrink:0!important;opacity:.6}::ng-deep .univer-custom-format-des{margin-top:6px!important;font-size:11px!important;line-height:1.5!important;color:#8c8c8c!important;padding:6px 8px!important;background:#f5f5f5!important;border-radius:6px!important;border-left:3px solid #d9d9d9!important}::ng-deep .univer-numfmt-custom-item{position:relative!important;padding:5px 8px!important;border-radius:6px!important;font-family:SFMono-Regular,Consolas,monospace!important;font-size:12px!important;color:#434343!important;cursor:pointer!important;transition:background .12s,color .12s;display:block!important;border-left:3px solid transparent}::ng-deep .univer-numfmt-custom-item:hover{background:#f0f5ff!important;color:#1677ff!important;border-left-color:#1677ff!important}::ng-deep .univer-numfmt-custom-item.univer-numfmt-active{background:#e6f4ff!important;color:#1677ff!important;font-weight:600!important;padding-left:24px!important;border-left:3px solid #1677ff!important}::ng-deep .univer-numfmt-custom-item.univer-numfmt-active:before{content:\"\\2713\";position:absolute;left:7px;top:50%;transform:translateY(-50%);font-size:10px;font-weight:700;color:#1677ff;line-height:1}::ng-deep .numfmt-panel li.univer-select-list-item.univer-select-list-item-select:not(.univer-numfmt-custom-item){background:#e6f4ff!important;border-left:3px solid #1677ff!important;border-radius:6px!important}::ng-deep .numfmt-panel li.univer-select-list-item.univer-select-list-item-select:not(.univer-numfmt-custom-item) a{color:#1677ff!important}::ng-deep .numfmt-panel li.univer-select-list-item.univer-select-list-item-select:not(.univer-numfmt-custom-item) .univer-select-list-item-icon{color:#1677ff!important}::ng-deep .more-numfmt-type{cursor:pointer;font-size:0!important;display:inline-flex;align-items:center;line-height:1}::ng-deep .more-numfmt-type:before{content:\"\";display:inline-block;width:31px;height:18px;background-color:currentColor;mask:url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2034%2020'%3E%3Ctext%20x='0'%20y='15'%20font-size='13'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E123%3C/text%3E%3Ctext%20x='20'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E%25%3C/text%3E%3Ctext%20x='27'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E$%3C/text%3E%3Ccircle%20cx='26.5'%20cy='15'%20r='3.4'%20fill='none'%20stroke='black'%20stroke-width='1.1'/%3E%3Cpath%20d='M26.5%2013.2v1.8l1.2.9'%20fill='none'%20stroke='black'%20stroke-width='1.1'%20stroke-linecap='round'%20stroke-linejoin='round'/%3E%3C/svg%3E\") no-repeat center/contain;-webkit-mask:url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2034%2020'%3E%3Ctext%20x='0'%20y='15'%20font-size='13'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E123%3C/text%3E%3Ctext%20x='20'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E%25%3C/text%3E%3Ctext%20x='27'%20y='8'%20font-size='7'%20font-weight='700'%20fill='black'%20font-family='Arial,sans-serif'%3E$%3C/text%3E%3Ccircle%20cx='26.5'%20cy='15'%20r='3.4'%20fill='none'%20stroke='black'%20stroke-width='1.1'/%3E%3Cpath%20d='M26.5%2013.2v1.8l1.2.9'%20fill='none'%20stroke='black'%20stroke-width='1.1'%20stroke-linecap='round'%20stroke-linejoin='round'/%3E%3C/svg%3E\") no-repeat center/contain}::ng-deep .univer-toolbar-item-select:has(.more-numfmt-type):hover{background-color:rgb(var(--grey-100));border-radius:var(--border-radius-base)}::ng-deep .univer-toolbar-item-select:has(.more-numfmt-type) .more-numfmt-type,::ng-deep .univer-toolbar-item-select:has(.more-numfmt-type) .univer-toolbar-item-select-arrow{background-color:transparent!important}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.component.js","sourceRoot":"","sources":["../../../../../libs-ui/components/spreadsheet/src/spreadsheet.component.ts","../../../../../libs-ui/components/spreadsheet/src/spreadsheet.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, Component, ElementRef, NgZone, OnDestroy, effect, inject, input, output, signal, untracked, viewChild } from '@angular/core';\nimport { LocaleType, Univer, UniverInstanceType } from '@univerjs/core';\nimport type { CellValue, ICellData, IStyleData } from '@univerjs/core';\nimport { defaultTheme } from '@univerjs/design';\nimport { UniverDocsPlugin } from '@univerjs/docs';\nimport { UniverDocsUIPlugin } from '@univerjs/docs-ui';\nimport { UniverFormulaEnginePlugin } from '@univerjs/engine-formula';\nimport { UniverRenderEnginePlugin } from '@univerjs/engine-render';\nimport { FUniver } from '@univerjs/facade';\nimport { InsertColMutation, MoveColsMutation, RemoveColMutation, UniverSheetsPlugin } from '@univerjs/sheets';\nimport { UniverSheetsFormulaPlugin } from '@univerjs/sheets-formula';\nimport { UniverSheetsFormulaUIPlugin } from '@univerjs/sheets-formula-ui';\nimport { UniverSheetsNumfmtPlugin } from '@univerjs/sheets-numfmt';\nimport { UniverSheetsUIPlugin } from '@univerjs/sheets-ui';\nimport { UniverUIPlugin } from '@univerjs/ui';\nimport { univerLocaleEn, univerLocaleVi } from './spreadsheet.locale';\nimport { injectCustomDateFormats, syncActiveNumfmtHighlight } from './spreadsheet.numfmt';\nimport { applyMappingIndicators, stripMappingIndicators } from './spreadsheet.indicator';\nimport type { T_columnStructureChange, T_indicatorTarget, T_mappingIndicatorConfig } from './spreadsheet.indicator';\nimport type { T_cellFormatResult, T_rangeSnapshot, T_spreadsheet_locale, T_toolbar_menu_config } from './spreadsheet.type';\n\n// Bộ đếm tạo class scope duy nhất cho mỗi instance spreadsheet (dùng cho <style> chỉnh width toolbar).\nlet spreadsheetInstanceCount = 0;\n\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'libs_ui-components-spreadsheet',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  templateUrl: './spreadsheet.component.html',\n  styleUrl: './spreadsheet.component.scss',\n})\nexport class LibsUiComponentsSpreadsheetComponent implements AfterViewInit, OnDestroy {\n  private univer: Univer | null = null;\n  private univerAPI: FUniver | null = null;\n  private columnClickDisposable: { dispose: () => void } | null = null;\n  private formatDisposable: { dispose: () => void } | null = null;\n  private columnOpDisposable: { dispose: () => void } | null = null;\n  private numfmtObserver: MutationObserver | null = null;\n  private toolbarResizeObserver: ResizeObserver | null = null;\n  // <style> riêng cho instance: pin width container đo qua CSS rule (React re-render KHÔNG strip được →\n  // tránh vòng lặp oscillation giữa set-inline-width và React strip gây kẹt ⋮). Xem registerToolbarWidthSync.\n  private toolbarStyleEl: HTMLStyleElement | null = null;\n  private readonly toolbarScopeClass = `libs-ui-spreadsheet-tb-${(spreadsheetInstanceCount += 1)}`;\n  private numfmtClickDisposable: { dispose: () => void } | null = null;\n  private lastRangeSnapshot: T_rangeSnapshot | null = null;\n  private pendingNumfmtPattern: string | null = null;\n  // true CHỈ khi user bấm nút Confirm trong panel numfmt → giữ format; Cancel/X/click-ngoài = false → revert.\n  private numfmtConfirmed = false;\n  // Snapshot numfmt từng ô của vùng chọn tại thời điểm mở panel — dùng khôi phục chính xác khi Cancel.\n  private originalCellFormats: { pattern: string; row: number; col: number }[] | null = null;\n  private numfmtPanelOpen = false;\n  // true khi luồng Date custom đang hoạt động (đã inject option ngày). CHỈ khi đó component mới\n  // can thiệp confirm/revert; các Type khác (Số, Tiền tệ, %, Text…) do Univer tự xử lý → không đụng vào.\n  private numfmtDateActive = false;\n  // Đồng bộ lại panel Date (label + highlight + auto-apply) theo vùng chọn mới khi user đổi cột lúc panel mở.\n  private numfmtResync: (() => void) | null = null;\n  private listenEnabled = false;\n  private listenEnableTimer: ReturnType<typeof setTimeout> | null = null;\n  // Defer initial empty-workbook init to allow parent's ngAfterViewInit to call loadData\n  // first (cancelling the empty init), avoiding a race with Univer's async React renders.\n  private pendingInitTimer: ReturnType<typeof setTimeout> | null = null;\n  private numfmtCleanup: (() => void) | null = null;\n  private pendingReadyCb: (() => void) | null = null;\n  // Snapshot đã-decorate gần nhất — làm baseline để diff (style id ổn định 'h'/'m', không bị\n  // ảnh hưởng bởi style id tự sinh sau mỗi facade setValue). Dùng cho re-apply incremental.\n  private lastDecorated: Record<string, unknown> | null = null;\n  private readyObserver: MutationObserver | null = null;\n  // Cache controller numfmt nội bộ của Univer (giữ _previewPattern). Tìm 1 lần qua injector.\n  // CONVENTION-EXCEPT: any — NumfmtController không export khỏi @univerjs/sheets-numfmt\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private numfmtController: any = null;\n\n  private readonly activeCellFormat = signal('General');\n  private readonly activeCellRef = signal('');\n  private readonly showToolbar = signal(true);\n  private readonly showSheetTabs = signal(true);\n  // Ngôn ngữ đang hiển thị thực tế. Khởi tạo từ input `locale` trong ngAfterViewInit,\n  // sau đó đổi runtime qua setLocale() (kéo theo reinit để Univer render lại UI).\n  private readonly activeLocale = signal<T_spreadsheet_locale>('vi');\n\n  /** Ngôn ngữ khởi tạo của spreadsheet. Đổi runtime dùng FunctionControl.setLocale(). */\n  readonly locale = input<T_spreadsheet_locale>('vi');\n\n  /** Cấu hình ẩn / vô hiệu hoá toolbar items. Thay đổi sẽ reinit toàn bộ Univer. */\n  readonly toolbarMenuConfig = input<T_toolbar_menu_config>({\n    // 'sheet.command.numfmt.set.currency': { hidden: true },\n    // 'sheet.command.numfmt.add.decimal.command': { hidden: true },\n    // 'sheet.command.numfmt.subtract.decimal.command': { hidden: true },\n    // 'sheet.command.numfmt.set.percent': { hidden: true },\n    'sheet.command.set-once-format-painter': { hidden: true },\n    'sheet.command.set-text-rotation': { hidden: true },\n    'sheet.command.set-range-font-family': { hidden: true },\n    'sheet.command.set-border-basic': { hidden: true },\n    'sheet.command.add-worksheet-merge': { hidden: true },\n    'sheet.command.add-worksheet-merge-all': { hidden: true },\n    'sheet.command.add-worksheet-merge-vertical': { hidden: true },\n    'sheet.command.add-worksheet-merge-horizontal': { hidden: true },\n    'sheet.command.remove-worksheet-merge': { hidden: true },\n  });\n\n  /**\n   * Cấu hình highlight cột đã map (style / prefix / scope sheet).\n   * Truyền config này = \"bật\" luồng auto: component sẽ TỰ áp indicator khi load/reset,\n   * TỰ gỡ khi save, và TỰ vẽ lại mỗi khi `mappingTargets` đổi. Bỏ trống = spreadsheet thường.\n   */\n  readonly mappingIndicatorConfig = input<T_mappingIndicatorConfig>();\n\n  /** Danh sách cột cần highlight (`{ sheetId, colIndex }`). Đổi runtime → tự vẽ lại header. */\n  readonly mappingTargets = input<T_indicatorTarget[]>([]);\n\n  readonly outColumnDblClick = output<number>();\n\n  /**\n   * Phát khi user insert / remove / move cột (kể cả chọn nhiều cột, và cả undo/redo).\n   * Consumer dùng `remapColumnIndexes(mappings, $event)` để dịch lại mảng mapping bên ngoài\n   * cho khớp vị trí mới — tránh lệch khi chèn/xóa cột ở giữa.\n   */\n  readonly outColumnStructureChange = output<T_columnStructureChange>();\n\n  private readonly containerRef = viewChild<ElementRef>('containerRef');\n  private readonly ngZone = inject(NgZone);\n\n  constructor() {\n    // Auto re-apply: chỉ chạy khi đã bật config + Univer đã khởi tạo. Lần đầu (chưa init) tự bỏ qua.\n    effect(() => {\n      this.mappingTargets();\n      this.mappingIndicatorConfig();\n      untracked(() => this.reapplyIndicators());\n    });\n  }\n\n  ngAfterViewInit() {\n    this.activeLocale.set(this.locale());\n    this.pendingInitTimer = setTimeout(() => {\n      this.pendingInitTimer = null;\n      this.initUniver(this.buildEmptyWorkbook());\n    });\n  }\n\n  get FunctionControl() {\n    return {\n      loadData: (data: Record<string, unknown>) => this.loadData(data),\n      saveData: () => this.saveData(),\n      getActiveSheetInfo: () => this.getActiveSheetInfo(),\n      getColumnNumfmt: (sheetId: string, colIndex: number) => this.getColumnNumfmt(sheetId, colIndex),\n      extractAllColumnFormats: (snapshot: Record<string, unknown>) => this.extractAllColumnFormats(snapshot),\n      toggleToolbar: () => this.toggleToolbar(),\n      toggleSheetTabs: () => this.toggleSheetTabs(),\n      reset: (data?: Record<string, unknown>) => this.reset(data),\n      executeCommand: (commandId: string, params: unknown) => this.executeCommand(commandId, params),\n      applyNumfmt: (row: number, col: number, numRows: number, numCols: number, pattern: string) => this.applyNumfmt(row, col, numRows, numCols, pattern),\n      scheduleOnReady: (cb: () => void) => {\n        this.pendingReadyCb = cb;\n      },\n      setLocale: (locale: T_spreadsheet_locale) => this.setLocale(locale),\n      activeCellRef: this.activeCellRef,\n      activeCellFormat: this.activeCellFormat,\n      showToolbar: this.showToolbar,\n      showSheetTabs: this.showSheetTabs,\n      locale: this.activeLocale.asReadonly(),\n    };\n  }\n\n  private setLocale(locale: T_spreadsheet_locale) {\n    if (locale === this.activeLocale()) return;\n    this.activeLocale.set(locale);\n    this.reinitUniver();\n  }\n\n  private loadData(data: Record<string, unknown>) {\n    const decorated = this.decorateSnapshot(data);\n    if (this.pendingInitTimer !== null) {\n      clearTimeout(this.pendingInitTimer);\n      this.pendingInitTimer = null;\n      this.initUniver(decorated);\n      return;\n    }\n    this.destroyUniver();\n    setTimeout(() => this.initUniver(decorated));\n  }\n\n  /** Snapshot thô từ Univer (CÓ thể còn indicator). Dùng nội bộ cho re-apply. */\n  private saveRaw(): Record<string, unknown> {\n    return (this.univerAPI?.getActiveWorkbook()?.save() ?? {}) as Record<string, unknown>;\n  }\n\n  /** Snapshot trả cho consumer — tự gỡ indicator nếu luồng auto đang bật. */\n  private saveData(): Record<string, unknown> {\n    const config = this.mappingIndicatorConfig();\n    if (!config) return this.saveRaw();\n    return stripMappingIndicators(this.saveRaw(), config);\n  }\n\n  /** Áp indicator vào snapshot trước khi load — chỉ khi luồng auto đang bật. Lưu baseline để diff. */\n  private decorateSnapshot(data: Record<string, unknown>): Record<string, unknown> {\n    const config = this.mappingIndicatorConfig();\n    if (!config) return data;\n    const decorated = applyMappingIndicators(data, this.mappingTargets(), config);\n    this.lastDecorated = decorated;\n    return decorated;\n  }\n\n  /**\n   * Vẽ lại indicator KHÔNG reinit Univer: tính snapshot đích rồi CHỈ ghi đè đúng các ô header\n   * khác so với baseline trước đó (style + prefix + width) lên instance live qua facade.\n   * Diff theo baseline (style id ổn định 'h'/'m') → chỉ các cột vừa map/bỏ map mới được vẽ lại.\n   */\n  private reapplyIndicators() {\n    const config = this.mappingIndicatorConfig();\n    const wb = this.univerAPI?.getActiveWorkbook();\n    const prev = this.lastDecorated;\n    if (!config || !wb || !prev) return;\n\n    const next = applyMappingIndicators(this.saveRaw(), this.mappingTargets(), config);\n    this.lastDecorated = next;\n\n    type T_cell = { v?: unknown; s?: unknown };\n    type T_sheet = { cellData?: Record<string, Record<string, T_cell>>; columnData?: Record<string, { w?: number }> };\n    const headerKey = String(config.headerRowIndex ?? 0);\n    const headerRow = Number(headerKey);\n    const stylesNext = (next['styles'] ?? {}) as Record<string, unknown>;\n    const sheetsNext = (next['sheets'] ?? {}) as Record<string, T_sheet>;\n    const sheetsPrev = (prev['sheets'] ?? {}) as Record<string, T_sheet>;\n\n    for (const sheetId of Object.keys(sheetsNext)) {\n      const ws = wb.getSheetBySheetId(sheetId);\n      if (!ws) continue;\n      const nextRow = sheetsNext[sheetId]?.cellData?.[headerKey] ?? {};\n      const prevRow = sheetsPrev[sheetId]?.cellData?.[headerKey] ?? {};\n      const colData = sheetsNext[sheetId]?.columnData ?? {};\n      for (const colKey of Object.keys(nextRow)) {\n        const cellNext = nextRow[colKey];\n        const cellPrev = prevRow[colKey];\n        // Ô không đổi cả value lẫn style → bỏ qua (mấu chốt: chỉ vẽ lại cột vừa map/bỏ map).\n        if (!cellNext || (cellNext.v === cellPrev?.v && cellNext.s === cellPrev?.s)) continue;\n        const style = (typeof cellNext.s === 'string' ? stylesNext[cellNext.s] : cellNext.s) as IStyleData;\n        const cell: ICellData = { v: cellNext.v as CellValue, s: style };\n        void ws.getRange(headerRow, Number(colKey)).setValue(cell);\n        const width = colData[colKey]?.w;\n        if (typeof width === 'number') void ws.setColumnWidth(Number(colKey), width);\n      }\n    }\n  }\n\n  private toggleToolbar() {\n    this.showToolbar.update((v) => !v);\n    this.reinitUniver();\n  }\n\n  private toggleSheetTabs() {\n    this.showSheetTabs.update((v) => !v);\n    this.reinitUniver();\n  }\n\n  private reset(data?: Record<string, unknown>) {\n    this.destroyUniver();\n    this.initUniver(this.decorateSnapshot(data ?? this.buildEmptyWorkbook()));\n  }\n\n  private executeCommand(commandId: string, params: unknown) {\n    // CONVENTION-EXCEPT: any — FUniver.executeCommand không expose typing\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    void (this.univerAPI as any)?.executeCommand?.(commandId, params);\n  }\n\n  private applyNumfmt(row: number, col: number, numRows: number, numCols: number, pattern: string) {\n    // CONVENTION-EXCEPT: any — FWorkbook.getId / FWorksheet.getSheetId not exposed in public types\n    // Note: FRange.setNumberFormat() has a Univer facade bug — it builds `values` but never passes\n    // them to executeCommand. We call the command directly with the correct params instead.\n    // FWorkbook uses getId() (not getUnitId()) and FWorksheet uses getSheetId() for subUnitId.\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const wb = this.univerAPI?.getActiveWorkbook() as any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const ws = wb?.getActiveSheet?.() as any;\n    if (!wb || !ws) return;\n    const unitId = (wb.getId?.() ?? '') as string;\n    const subUnitId = (ws.getSheetId?.() ?? '') as string;\n    const values: { pattern: string; row: number; col: number }[] = [];\n    for (let r = row; r < row + numRows; r++) {\n      for (let c = col; c < col + numCols; c++) {\n        values.push({ pattern, row: r, col: c });\n      }\n    }\n    this.executeCommand('sheet.command.numfmt.set.numfmt', { unitId, subUnitId, values });\n  }\n\n  private getActiveSheetInfo(): { sheetId: string; sheetName: string } | null {\n    // CONVENTION-EXCEPT: any — FWorksheet public types chưa expose getSheetId/getName\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const sheet = this.univerAPI?.getActiveWorkbook()?.getActiveSheet() as any;\n    if (!sheet) return null;\n    return {\n      sheetId: (sheet.getSheetId?.() ?? '') as string,\n      sheetName: (sheet.getSheetName?.() ?? sheet.getName?.() ?? '') as string,\n    };\n  }\n\n  /** Đọc numfmt pattern của một cell từ workbook snapshot. */\n  private readCellNumfmt(sheetId: string, row: number, col: number): string {\n    try {\n      // CONVENTION-EXCEPT: any — FWorkbook.save() không expose typing\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const ss = this.univerAPI?.getActiveWorkbook()?.save() as any;\n      type StyleEntry = { n?: { pattern?: string }; nf?: { pattern?: string } };\n      const styles = ss?.styles as Record<string, StyleEntry> | undefined;\n      const cells = (ss?.sheets as Record<string, { cellData?: Record<string, Record<string, { s?: string }>> }>)?.[sheetId]?.cellData;\n      const styleId = cells?.[String(row)]?.[String(col)]?.s;\n      if (!styleId || !styles) return 'General';\n      return styles[styleId]?.n?.pattern ?? styles[styleId]?.nf?.pattern ?? 'General';\n    } catch {\n      return 'General';\n    }\n  }\n\n  /** Đọc giá trị số (Excel serial) của một ô; null nếu ô rỗng/không phải số. */\n  private readCellValue(sheetId: string, row: number, col: number): number | null {\n    try {\n      // CONVENTION-EXCEPT: any — FWorkbook.save() không expose typing\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const ss = this.univerAPI?.getActiveWorkbook()?.save() as any;\n      const cells = (ss?.sheets as Record<string, { cellData?: Record<string, Record<string, { v?: unknown }>> }>)?.[sheetId]?.cellData;\n      const value = cells?.[String(row)]?.[String(col)]?.v;\n      return typeof value === 'number' && isFinite(value) ? value : null;\n    } catch {\n      return null;\n    }\n  }\n\n  private getColumnNumfmt(sheetId: string, colIndex: number): string {\n    for (const row of [1, 2, 3]) {\n      const pattern = this.readCellNumfmt(sheetId, row, colIndex);\n      if (pattern !== 'General') return pattern;\n    }\n    return 'General';\n  }\n\n  /** Chụp numfmt gốc từng ô của vùng chọn (giới hạn 500 dòng như applyFormat) để Cancel khôi phục đúng. */\n  private captureRangeNumfmt(snap: T_rangeSnapshot | null): { pattern: string; row: number; col: number }[] | null {\n    if (!snap) return null;\n    const values: { pattern: string; row: number; col: number }[] = [];\n    const maxRow = Math.min(snap.endRow, snap.startRow + 499);\n    for (let r = snap.startRow; r <= maxRow; r++) {\n      for (let c = snap.startColumn; c <= snap.endColumn; c++) {\n        values.push({ pattern: this.readCellNumfmt(snap.subUnitId, r, c), row: r, col: c });\n      }\n    }\n    return values.length ? values : null;\n  }\n\n  private extractAllColumnFormats(snapshot: Record<string, unknown>): T_cellFormatResult[] {\n    type StyleEntry = { n?: { pattern?: string }; nf?: { pattern?: string } };\n    type StyleMap = Record<string, StyleEntry>;\n    type SheetMap = Record<string, { name?: string; cellData?: Record<string, Record<string, { s?: string; v?: unknown }>> }>;\n\n    const styles = snapshot['styles'] as StyleMap | undefined;\n    const sheets = snapshot['sheets'] as SheetMap | undefined;\n    const order = snapshot['sheetOrder'] as string[] | undefined;\n    if (!styles || !sheets) return [];\n\n    const results: T_cellFormatResult[] = [];\n    const seen = new Set<string>();\n\n    for (const sheetId of order ?? Object.keys(sheets)) {\n      const sheetData = sheets[sheetId];\n      if (!sheetData?.cellData) continue;\n\n      const sheetName = sheetData.name ?? sheetId;\n      const headerRow = sheetData.cellData['0'] ?? {};\n\n      for (const rowKey of ['1', '2', '3']) {\n        const row = sheetData.cellData[rowKey];\n        if (!row) continue;\n\n        for (const colKey of Object.keys(row)) {\n          const key = `${sheetId}:${colKey}`;\n          if (seen.has(key)) continue;\n\n          const styleId = row[colKey]?.s;\n          if (!styleId) continue;\n\n          const pattern = styles[styleId]?.n?.pattern ?? styles[styleId]?.nf?.pattern;\n          if (!pattern) continue;\n\n          seen.add(key);\n          const colIndex = parseInt(colKey, 10);\n          const colLetter = this.toColLetter(colIndex);\n          const headerV = headerRow[colKey]?.v;\n\n          results.push({\n            sheet: sheetName,\n            col: colLetter,\n            colIndex,\n            header: headerV ? String(headerV) : colLetter,\n            numfmt: pattern,\n          });\n        }\n      }\n    }\n    return results;\n  }\n\n  private toColLetter(index: number): string {\n    let result = '';\n    let n = index;\n    do {\n      result = String.fromCharCode(65 + (n % 26)) + result;\n      n = Math.floor(n / 26) - 1;\n    } while (n >= 0);\n    return result;\n  }\n\n  private buildEmptyWorkbook(): Record<string, unknown> {\n    return {\n      id: 'workbook-default',\n      locale: this.resolveLocaleType(),\n      name: 'Sheet',\n      sheetOrder: ['sheet1'],\n      appVersion: '3.0.0-alpha',\n      sheets: {\n        sheet1: { id: 'sheet1', name: 'Sheet1', rowCount: 30, columnCount: 26, cellData: {} },\n      },\n    };\n  }\n\n  private resolveLocaleType(): LocaleType {\n    return this.activeLocale() === 'vi' ? LocaleType.VI_VN : LocaleType.EN_US;\n  }\n\n  private registerColumnClickListener() {\n    const wrapper = this.containerRef()?.nativeElement as HTMLElement | undefined;\n    if (!wrapper) return;\n\n    this.listenEnableTimer = setTimeout(() => {\n      this.listenEnabled = true;\n    }, 600);\n\n    const handleDblClick = (event: MouseEvent) => {\n      if (!this.listenEnabled) return;\n      if ((event.target as HTMLElement).tagName !== 'CANVAS') return;\n\n      setTimeout(() => {\n        this.ngZone.run(() => {\n          const range = this.univerAPI?.getActiveWorkbook()?.getActiveSheet()?.getActiveRange();\n          if (!range) return;\n\n          const { startRow, endRow, startColumn, rangeType } = range.getRange();\n          const isColHeader = rangeType === 2 || (startRow === 0 && endRow >= 29);\n          const isFirstRow = startRow === 0 && endRow === 0;\n\n          if (!isColHeader && !isFirstRow) return;\n          this.outColumnDblClick.emit(startColumn);\n        });\n      }, 50);\n    };\n\n    wrapper.addEventListener('dblclick', handleDblClick);\n    this.columnClickDisposable = { dispose: () => wrapper.removeEventListener('dblclick', handleDblClick) };\n  }\n\n  /**\n   * Lắng nghe MUTATION cột (insert/remove/move) — mức mutation để bắt cả undo/redo, một lần/thao tác.\n   * Chuẩn hoá thành `T_columnStructureChange` rồi phát ra ngoài cho consumer remap mapping.\n   */\n  private registerColumnOpListener() {\n    // CONVENTION-EXCEPT: any — FUniver.onCommandExecuted / commandInfo không expose trong public types\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const api = this.univerAPI as any;\n    if (typeof api?.onCommandExecuted !== 'function') return;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    this.columnOpDisposable = api.onCommandExecuted((commandInfo: any) => {\n      const change = this.toColumnStructureChange(commandInfo?.id, commandInfo?.params);\n      if (change) this.ngZone.run(() => this.outColumnStructureChange.emit(change));\n    });\n  }\n\n  private toColumnStructureChange(id: unknown, params: unknown): T_columnStructureChange | null {\n    type T_range = { startColumn: number; endColumn: number };\n    type T_colParams = { subUnitId?: string; range?: T_range; sourceRange?: T_range; targetRange?: T_range };\n    const p = params as T_colParams | undefined;\n    const sheetId = p?.subUnitId ?? '';\n\n    if (id === InsertColMutation.id || id === RemoveColMutation.id) {\n      if (!p?.range) return null;\n      const type = id === InsertColMutation.id ? 'insert' : 'remove';\n      return { sheetId, type, startColumn: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 };\n    }\n    if (id === MoveColsMutation.id) {\n      if (!p?.sourceRange || !p?.targetRange) return null;\n      return {\n        sheetId,\n        type: 'move',\n        startColumn: p.sourceRange.startColumn,\n        count: p.sourceRange.endColumn - p.sourceRange.startColumn + 1,\n        toColumn: p.targetRange.startColumn,\n      };\n    }\n    return null;\n  }\n\n  private registerFormatListener() {\n    // CONVENTION-EXCEPT: any — FUniver.onCommandExecuted / commandInfo không expose trong public types\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const api = this.univerAPI as any;\n    if (typeof api?.onCommandExecuted !== 'function') return;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    this.formatDisposable = api.onCommandExecuted((commandInfo: any) => {\n      this.ngZone.run(() => {\n        if (commandInfo?.id === 'sheet.operation.open.numfmt.panel') {\n          this.numfmtPanelOpen = true;\n          this.numfmtConfirmed = false; // reset cờ — phiên mới mặc định chưa Confirm\n          this.numfmtDateActive = false; // chưa chọn Type=Date → chưa kích hoạt luồng custom\n          // Lưu numfmt gốc từng ô để Cancel khôi phục đúng (vùng chọn có thể nhiều format khác nhau)\n          this.originalCellFormats = this.captureRangeNumfmt(this.lastRangeSnapshot);\n          // Chỉ bật observer khi panel mở (tránh chạy liên tục theo mọi mutation toàn trang)\n          this.numfmtObserver?.observe(document.body, { childList: true, subtree: true });\n          // Reopen: Univer hiện lại panel cũ bằng CSS (không mutation) → observer không fire. Chủ động\n          // thử inject sau 1 nhịp để bắt trường hợp list ngày đã sẵn trong DOM tái dùng.\n          setTimeout(() => {\n            if (this.numfmtPanelOpen) this.processNumfmtPanel();\n          }, 60);\n          return;\n        }\n\n        if (commandInfo?.id === 'sheet.operation.close.numfmt.panel') {\n          this.numfmtPanelOpen = false;\n          // Tắt observer khi đóng (perf). KHÔNG gỡ listener: Univer tái dùng DOM panel, gỡ sẽ làm\n          // option chết khi mở lại. cleanup chạy trước lần inject mới (DOM mới) hoặc khi destroy.\n          this.numfmtObserver?.disconnect();\n          // Univer TÁI DÙNG DOM panel khi reopen (nhớ cả Type=Date) → guard data-custom-dates còn sót sẽ\n          // chặn re-inject ở lần mở sau, khiến highlight stale + dateActive=false (mất revert). Xoá guard\n          // để lần mở kế tiếp inject lại + resync highlight/auto-apply theo cột hiện tại.\n          document.querySelector('.numfmt-panel ul.univer-select-list')?.removeAttribute('data-custom-dates');\n          // Chỉ khi bấm CONFIRM (numfmtConfirmed=true) mới GIỮ pattern đã chọn cho cả vùng.\n          // Cancel / X / click-ngoài đều KHÔNG set cờ → KHÔI PHỤC numfmt GỐC TỪNG Ô (đã chụp khi mở panel).\n          const dateActive = this.numfmtDateActive;\n          const confirmed = this.numfmtConfirmed;\n          const pending = this.pendingNumfmtPattern;\n          const originalCells = this.originalCellFormats;\n          this.numfmtConfirmed = false;\n          this.pendingNumfmtPattern = null;\n          this.originalCellFormats = null;\n          this.numfmtDateActive = false;\n\n          // Type khác Date (Số/Tiền tệ/%/Text…) do Univer tự apply/cancel → KHÔNG can thiệp,\n          // nếu không sẽ revert nhầm format mà user vừa áp qua luồng native của Univer.\n          if (!dateActive) {\n            this.clearNumfmtPreview();\n            return;\n          }\n\n          const snap = this.lastRangeSnapshot;\n          if (!snap) return;\n\n          let values: { pattern: string; row: number; col: number }[];\n          if (confirmed && pending) {\n            values = [];\n            for (let r = snap.startRow; r <= Math.min(snap.endRow, snap.startRow + 499); r++) {\n              for (let c = snap.startColumn; c <= snap.endColumn; c++) {\n                values.push({ pattern: pending, row: r, col: c });\n              }\n            }\n          } else if (!confirmed && originalCells) {\n            values = originalCells;\n          } else {\n            return;\n          }\n          if (!values.length) return;\n          // CONVENTION-EXCEPT: any — FUniver.executeCommand không expose typing\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          void (this.univerAPI as any)?.executeCommand?.('sheet.command.numfmt.set.numfmt', {\n            unitId: snap.unitId,\n            subUnitId: snap.subUnitId,\n            values,\n          });\n          this.clearNumfmtPreview();\n          return;\n        }\n\n        // Khi panel đang mở: CHỈ user đổi vùng chọn trên grid (set-selections) mới được cập nhật snapshot\n        // để re-target panel sang cột/cell mới. Command nội bộ panel (numfmt.set, mutation…) KHÔNG đụng snapshot.\n        const isUserSelection = commandInfo?.id === 'sheet.operation.set-selections';\n        if (this.numfmtPanelOpen && !isUserSelection) return;\n\n        const wb = this.univerAPI?.getActiveWorkbook();\n        const ws = wb?.getActiveSheet();\n        const range = ws?.getActiveRange();\n        if (!range || !wb || !ws) return;\n\n        const rangeData = range.getRange();\n        this.activeCellRef.set(`${this.toColLetter(rangeData.startColumn)}${rangeData.startRow + 1}`);\n\n        // CONVENTION-EXCEPT: any — FWorkbook.getId / FWorksheet.getSheetId chưa expose trong types\n        /* eslint-disable @typescript-eslint/no-explicit-any */\n        const wbAny = wb as any;\n        const wsAny = ws as any;\n        /* eslint-enable @typescript-eslint/no-explicit-any */\n        this.lastRangeSnapshot = {\n          unitId: (wbAny.getId?.() ?? wbAny.getUnitId?.() ?? '') as string,\n          subUnitId: (wsAny.getSheetId?.() ?? wsAny.getUnitId?.() ?? '') as string,\n          startRow: rangeData.startRow,\n          endRow: rangeData.endRow,\n          startColumn: rangeData.startColumn,\n          endColumn: rangeData.endColumn,\n        };\n\n        // CONVENTION-EXCEPT: any — FRange.getCellStyleData chưa expose trong types\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const rangeAny = range as any;\n        const style = rangeAny.getCellStyleData?.();\n        const numFmt = style?.n?.pattern ?? style?.nf?.pattern;\n        this.activeCellFormat.set(numFmt && numFmt !== '0' ? numFmt : 'General');\n\n        // User đổi vùng chọn LÚC panel Date đang mở → tích luỹ numfmt gốc của vùng mới (để Cancel\n        // revert đúng mọi ô đã chạm) rồi đồng bộ lại panel (label + highlight + auto-apply) theo cột mới.\n        if (this.numfmtPanelOpen && this.numfmtDateActive) {\n          this.mergeOriginalCellFormats(this.captureRangeNumfmt(this.lastRangeSnapshot));\n          this.numfmtResync?.();\n        }\n      });\n    });\n  }\n\n  /** Gộp numfmt gốc của vùng vừa chọn vào snapshot revert, giữ giá trị GỐC ĐẦU TIÊN cho mỗi ô. */\n  private mergeOriginalCellFormats(extra: { pattern: string; row: number; col: number }[] | null) {\n    if (!extra) return;\n    if (!this.originalCellFormats) {\n      this.originalCellFormats = extra;\n      return;\n    }\n    const seen = new Set(this.originalCellFormats.map((v) => `${v.row}:${v.col}`));\n    for (const cell of extra) {\n      if (seen.has(`${cell.row}:${cell.col}`)) continue;\n      this.originalCellFormats.push(cell);\n    }\n  }\n\n  /**\n   * Xoá live-preview overlay của Univer numfmt panel.\n   *\n   * Khi panel numfmt mở, `NumfmtController._previewPattern` được Univer dùng để vẽ đè\n   * (preview) lên hiển thị thật của vùng chọn. Vì các option date custom ghi numfmt\n   * trực tiếp vào model (không đi qua panel gốc của Univer), preview này không bao giờ\n   * khớp model → cột không đổi hiển thị ngay. Set `_previewPattern = null` + force re-render\n   * (`_forceUpdate`) để canvas vẽ đúng giá trị model tức thì.\n   *\n   * NumfmtController không export khỏi `@univerjs/sheets-numfmt` nên phải tìm instance\n   * qua injector của Univer (cache lại sau lần đầu).\n   */\n  private clearNumfmtPreview() {\n    const controller = this.resolveNumfmtController();\n    if (!controller) return;\n    if (controller._previewPattern != null) controller._previewPattern = null;\n    // LUÔN force re-render: numfmt vừa áp vào model cần vẽ lại canvas ngay (kể cả khi không có preview).\n    controller._forceUpdate?.();\n  }\n\n  // CONVENTION-EXCEPT: any — truy cập injector + NumfmtController nội bộ của Univer (không có public API)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private resolveNumfmtController(): any {\n    if (this.numfmtController) return this.numfmtController;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const injector = (this.univer as any)?.__getInjector?.();\n    if (!injector) return null;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const scanMap = (map: unknown): any => {\n      if (!(map instanceof Map)) return null;\n      for (const value of map.values()) {\n        const candidates = Array.isArray(value) ? value : [value];\n        for (const candidate of candidates) {\n          const instance = candidate?.instance !== undefined ? candidate.instance : candidate;\n          if (instance && typeof instance === 'object' && '_previewPattern' in instance) return instance;\n        }\n      }\n      return null;\n    };\n\n    // Các instance của redi nằm trong Map lồng 1 cấp (vd injector.resolvedDependencyCollection.resolvedDependencies)\n    for (const key of Object.keys(injector)) {\n      const value = injector[key];\n      let found = scanMap(value);\n      if (!found && value && typeof value === 'object') {\n        for (const nestedKey of Object.keys(value)) {\n          found = scanMap(value[nestedKey]);\n          if (found) break;\n        }\n      }\n      if (found) {\n        this.numfmtController = found;\n        return found;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Tạo observer để inject option ngày custom + highlight khi panel numfmt render.\n   * Observer CHỈ được bật/tắt theo vòng đời panel (xem open/close.numfmt.panel handler) để\n   * không chạy liên tục theo mọi mutation DOM toàn trang.\n   */\n  private registerNumfmtDropdownObserver() {\n    this.numfmtObserver = new MutationObserver(() => this.processNumfmtPanel());\n  }\n\n  /**\n   * Thử inject option ngày custom + highlight cho panel numfmt hiện tại.\n   * Gọi từ 2 nguồn: (1) MutationObserver khi Univer render list ngày; (2) trực tiếp lúc mở panel —\n   * vì Univer TÁI DÙNG DOM panel khi reopen (hiện lại bằng CSS, không phát sinh mutation) nên observer\n   * không kích hoạt, phải chủ động gọi để re-inject + resync theo cột hiện tại.\n   */\n  private processNumfmtPanel() {\n    syncActiveNumfmtHighlight();\n    const result = injectCustomDateFormats(\n        () => this.lastRangeSnapshot,\n        // CONVENTION-EXCEPT: any — FUniver.executeCommand không expose typing\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (cmdId, params) => void (this.univerAPI as any).executeCommand?.(cmdId, params),\n        (pattern) => {\n          this.pendingNumfmtPattern = pattern;\n        },\n        () => {\n          const snap = this.lastRangeSnapshot;\n          if (!snap) return this.activeCellFormat();\n          // Quét vài dòng đầu của vùng chọn, bỏ qua header/General để lấy format ĐẠI DIỆN của dữ liệu.\n          // Khi chọn cả cột, startRow = 0 là header (thường General) → nếu chỉ đọc dòng đó sẽ highlight sai option.\n          const maxScan = Math.min(snap.endRow, snap.startRow + 4);\n          for (let r = snap.startRow; r <= maxScan; r++) {\n            const fmt = this.readCellNumfmt(snap.subUnitId, r, snap.startColumn);\n            if (fmt !== 'General') return fmt;\n          }\n          return this.activeCellFormat();\n        },\n        () => this.clearNumfmtPreview(),\n        () => {\n          // Giá trị thực của ô đại diện (dòng dữ liệu đầu có số) → label option khớp dữ liệu cột.\n          const snap = this.lastRangeSnapshot;\n          if (!snap) return null;\n          const maxScan = Math.min(snap.endRow, snap.startRow + 4);\n          for (let r = snap.startRow; r <= maxScan; r++) {\n            const value = this.readCellValue(snap.subUnitId, r, snap.startColumn);\n            if (value !== null) return value;\n          }\n          return null;\n        },\n        () => {\n          this.numfmtConfirmed = true;\n        }\n      );\n      // result chỉ truthy khi THỰC SỰ inject trên 1 listContainer Date mới (guard data-custom-dates chặn\n      // các lần gọi thừa). Gỡ listener của lần inject trước trước khi giữ cleanup mới → tránh tích tụ.\n      // Đồng thời lưu resync để re-target panel khi user đổi cột, và đánh dấu luồng Date đang hoạt động.\n    if (result) {\n      this.numfmtCleanup?.();\n      this.numfmtCleanup = result.cleanup;\n      this.numfmtResync = result.resync;\n      this.numfmtDateActive = true;\n    }\n  }\n\n  private initUniver(data: Record<string, unknown>) {\n    const wrapper = this.containerRef()?.nativeElement as HTMLElement | undefined;\n    if (!wrapper) return;\n\n    wrapper.replaceChildren();\n    const container = document.createElement('div');\n    container.style.cssText = 'width:100%;height:100%';\n    wrapper.appendChild(container);\n\n    const univer = new Univer({\n      locale: this.resolveLocaleType(),\n      locales: {\n        [LocaleType.EN_US]: univerLocaleEn,\n        [LocaleType.VI_VN]: univerLocaleVi,\n      },\n      theme: defaultTheme,\n    });\n    this.univer = univer;\n\n    univer.registerPlugin(UniverRenderEnginePlugin);\n    univer.registerPlugin(UniverFormulaEnginePlugin);\n    univer.registerPlugin(UniverUIPlugin, { container, header: this.showToolbar(), footer: this.showSheetTabs() });\n    univer.registerPlugin(UniverDocsPlugin, { hasScroll: false });\n    univer.registerPlugin(UniverDocsUIPlugin);\n    univer.registerPlugin(UniverSheetsPlugin);\n    univer.registerPlugin(UniverSheetsUIPlugin, { menu: this.toolbarMenuConfig() });\n    univer.registerPlugin(UniverSheetsNumfmtPlugin);\n    univer.registerPlugin(UniverSheetsFormulaPlugin);\n    univer.registerPlugin(UniverSheetsFormulaUIPlugin);\n    univer.createUnit(UniverInstanceType.UNIVER_SHEET, data);\n\n    this.univerAPI = FUniver.newAPI(univer);\n    if (this.pendingReadyCb) {\n      // Wait for .more-numfmt-type to appear in DOM — this signals that UniverSheetsUIPlugin\n      // has fully rendered the toolbar and UniverSheetsNumfmtPlugin's INumfmtModel is ready.\n      const wrapper = this.containerRef()?.nativeElement as HTMLElement | undefined;\n      if (wrapper) {\n        this.readyObserver = new MutationObserver(() => {\n          if (!wrapper.querySelector('.more-numfmt-type')) return;\n          this.readyObserver?.disconnect();\n          this.readyObserver = null;\n          const cb = this.pendingReadyCb;\n          this.pendingReadyCb = null;\n          cb?.();\n        });\n        this.readyObserver.observe(wrapper, { childList: true, subtree: true });\n      }\n    }\n    this.registerColumnClickListener();\n    this.registerColumnOpListener();\n    this.registerFormatListener();\n    this.registerNumfmtDropdownObserver();\n    this.registerToolbarWidthSync();\n    this.registerNumfmtClickInterceptor();\n  }\n\n  /**\n   * Khắc phục lỗi toolbar collapse sai (gom item vào menu ⋮ dù còn khoảng trắng).\n   *\n   * Univer (component Ribbon) quyết định overflow bằng 1 container ĐO off-screen (con trực tiếp của\n   * header, position:absolute). Thuật toán: `total = 90; cho mỗi ITEM total += item.clientWidth + 8;\n   * nếu total > measuringContainer.clientWidth → collapse item`. Công thức này OVER-COUNT 2 chỗ:\n   *   • +90px reserve cho nút ⋮ (cộng kể cả khi không cần collapse).\n   *   • +8px MỖI item, trong khi khoảng cách (gap) thực tế chỉ nằm giữa các GROUP.\n   * Nếu set bề rộng container đo = đúng headerW thì `total` (vd 961) > headerW (vd 900) → Univer tưởng\n   * tràn và gom item vào ⋮ dù content thật chỉ ~829px (còn ~70px trống).\n   *\n   * Fix (triệt để, không phụ thuộc timing): pin bề rộng container ĐO = HẰNG SỐ rất lớn qua CSS RULE trong\n   * 1 <style> riêng. Khi đó `total` của Univer KHÔNG BAO GIỜ vượt → KHÔNG gom item vào ⋮ → luôn hiển thị\n   * ĐỦ option (đúng yêu cầu). Vì sao chọn cách này thay vì khớp width = headerW:\n   *   • Thuật toán Univer over-count (90 reserve ⋮ + 8px/item) → khớp sát headerW vẫn collapse sai khi còn chỗ.\n   *   • ResizeObserver của Univer hay KẸT STALE: 1 transient lúc load (icon/font làm item rộng nhất thời) đặt\n   *     collapsedIds rồi KHÔNG re-fire → kẹt ⋮ vĩnh viễn dù sau đó còn chỗ (đúng triệu chứng reload luôn ⋮).\n   *   • Set inline lại bị React re-render strip → oscillation. CSS rule !important React không strip được.\n   * Container đo vốn off-screen (position:absolute, opacity:0) nên width khổng lồ hoàn toàn vô hình. Khi\n   * vùng chứa quá hẹp (hiếm với spreadsheet) toolbar cuộn ngang — xem SCSS `.univer-toolbar` overflow-x.\n   */\n  private registerToolbarWidthSync() {\n    const wrapper = this.containerRef()?.nativeElement as HTMLElement | undefined;\n    if (!wrapper) return;\n    wrapper.classList.add(this.toolbarScopeClass);\n    const styleEl = document.createElement('style');\n    this.toolbarStyleEl = styleEl;\n    styleEl.textContent = `.${this.toolbarScopeClass} .univer-workbench-container-header > .univer-toolbar-container{width:100000px !important;max-width:none !important;}`;\n    document.head.appendChild(styleEl);\n  }\n\n  private registerNumfmtClickInterceptor() {\n    const clickHandler = (e: MouseEvent) => {\n      const target = e.target as HTMLElement;\n      if (target.closest('.numfmt-panel') ?? target.closest('.more-numfmt-type-options')) return;\n\n      const numfmtText = target.closest('.more-numfmt-type') as HTMLElement | null;\n      const numfmtSelect = target.closest('.univer-toolbar-item-select') as HTMLElement | null;\n      const isNumfmtBtn = numfmtText ?? (numfmtSelect?.querySelector('.more-numfmt-type') ? numfmtSelect : null);\n\n      if (!isNumfmtBtn) return;\n      e.preventDefault();\n      e.stopPropagation();\n      this.executeCommand('sheet.operation.open.numfmt.panel', undefined);\n    };\n\n    document.body.addEventListener('click', clickHandler, true);\n    this.numfmtClickDisposable = { dispose: () => document.body.removeEventListener('click', clickHandler, true) };\n  }\n\n  private destroyUniver() {\n    if (this.pendingInitTimer !== null) {\n      clearTimeout(this.pendingInitTimer);\n      this.pendingInitTimer = null;\n    }\n    this.columnClickDisposable?.dispose();\n    this.columnClickDisposable = null;\n    this.columnOpDisposable?.dispose();\n    this.columnOpDisposable = null;\n    this.formatDisposable?.dispose();\n    this.formatDisposable = null;\n    this.numfmtObserver?.disconnect();\n    this.numfmtObserver = null;\n    this.toolbarResizeObserver?.disconnect();\n    this.toolbarResizeObserver = null;\n    this.toolbarStyleEl?.remove();\n    this.toolbarStyleEl = null;\n    this.numfmtClickDisposable?.dispose();\n    this.numfmtClickDisposable = null;\n    this.numfmtCleanup?.();\n    this.numfmtCleanup = null;\n    this.numfmtResync = null;\n    this.numfmtDateActive = false;\n    this.readyObserver?.disconnect();\n    this.readyObserver = null;\n    this.activeCellFormat.set('General');\n    this.activeCellRef.set('');\n    this.lastRangeSnapshot = null;\n    this.pendingNumfmtPattern = null;\n    this.numfmtConfirmed = false;\n    this.originalCellFormats = null;\n    this.numfmtPanelOpen = false;\n    this.listenEnabled = false;\n    if (this.listenEnableTimer !== null) {\n      clearTimeout(this.listenEnableTimer);\n      this.listenEnableTimer = null;\n    }\n    this.numfmtController = null;\n    this.univer?.dispose();\n    this.univer = null;\n    this.univerAPI = null;\n  }\n\n  private reinitUniver() {\n    const currentData = this.univerAPI?.getActiveWorkbook()?.save() as unknown as Record<string, unknown> | undefined;\n    this.destroyUniver();\n    setTimeout(() => this.initUniver(currentData ?? this.buildEmptyWorkbook()));\n  }\n\n  ngOnDestroy() {\n    this.destroyUniver();\n  }\n}\n","<div #containerRef class=\"libs-ui-components-spreadsheet-container\"></div>\n"]}