@libs-ui/components-spreadsheet 0.2.356-43

package/esm2022/spreadsheet.indicator.mjs

@@ -0,0 +1,204 @@
+import { BooleanNumber } from '@univerjs/core';
+/** Style mặc định cho cột đã map: nền xanh, chữ trắng, bold, canh giữa. */
+const DEFAULT_MAPPED_STYLE = {
+    bg: { rgb: '#389E0D' },
+    cl: { rgb: '#FFFFFF' },
+    bl: BooleanNumber.TRUE,
+    ht: 2,
+    vt: 2,
+    fs: 11,
+};
+/**
+ * Config mặc định của lib — consumer có thể dùng trực tiếp hoặc spread-override:
+ * `{ ...defaultMappingIndicatorConfig(), prefix: '★ ' }`.
+ */
+export const defaultMappingIndicatorConfig = () => ({
+    mappedStyleId: 'm',
+    mappedStyle: { ...DEFAULT_MAPPED_STYLE },
+    defaultHeaderStyleId: 'h',
+    prefix: '● ',
+    headerRowIndex: 0,
+    autoResize: true,
+    charWidth: 7.5,
+    padding: 16,
+});
+const DEFAULT_PREFIX = '● ';
+const DEFAULT_CHAR_W = 7.5;
+const DEFAULT_PADDING = 16;
+const DEFAULT_COL_W = 80;
+const DEFAULT_MAPPED_STYLE_ID = 'm';
+const DEFAULT_HEADER_STYLE_ID = 'h';
+/** Workbook snapshot là plain JSON — clone an toàn nhất bằng JSON. */
+const cloneSnapshot = (snapshot) => JSON.parse(JSON.stringify(snapshot));
+const resolveOpts = (config) => ({
+    mappedStyleId: config.mappedStyleId ?? DEFAULT_MAPPED_STYLE_ID,
+    mappedStyle: config.mappedStyle ?? DEFAULT_MAPPED_STYLE,
+    defaultHeaderStyleId: config.defaultHeaderStyleId ?? DEFAULT_HEADER_STYLE_ID,
+    prefix: config.prefix ?? DEFAULT_PREFIX,
+    headerRowKey: String(config.headerRowIndex ?? 0),
+    autoResize: config.autoResize ?? true,
+    charWidth: config.charWidth ?? DEFAULT_CHAR_W,
+    padding: config.padding ?? DEFAULT_PADDING,
+});
+const estimateWidth = (text, opts) => Math.ceil(text.length * opts.charWidth + opts.padding);
+/** Mở rộng width cột cho vừa text (không thu nhỏ hơn width hiện tại). */
+const expandColWidth = (sheet, colKey, text, opts) => {
+    const colData = sheet.columnData;
+    if (!colData)
+        return;
+    const current = colData[colKey]?.w ?? DEFAULT_COL_W;
+    colData[colKey] = { ...(colData[colKey] ?? {}), w: Math.max(current, estimateWidth(text, opts)) };
+};
+/**
+ * Dọn header row của 1 sheet: revert style về mặc định, xóa prefix, khôi phục width.
+ * @param onlyMapped true → chỉ revert ô đang là `mappedStyleId`; false → revert mọi ô có style.
+ */
+const resetHeaderRow = (sheet, opts, onlyMapped) => {
+    const headerRow = sheet?.cellData?.[opts.headerRowKey];
+    if (!headerRow || !sheet)
+        return;
+    for (const colKey of Object.keys(headerRow)) {
+        const cell = headerRow[colKey];
+        if (!cell)
+            continue;
+        if (onlyMapped) {
+            if (cell.s === opts.mappedStyleId)
+                cell.s = opts.defaultHeaderStyleId;
+        }
+        else if (cell.s) {
+            cell.s = opts.defaultHeaderStyleId;
+        }
+        if (typeof cell.v === 'string' && cell.v.startsWith(opts.prefix)) {
+            const original = cell.v.slice(opts.prefix.length);
+            cell.v = original;
+            if (opts.autoResize && sheet.columnData?.[colKey]) {
+                sheet.columnData[colKey].w = estimateWidth(original, opts);
+            }
+        }
+    }
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Public API
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Đánh dấu header các cột đã map: gắn style `mappedStyleId`, thêm prefix icon và
+ * (tùy chọn) tự nới width. Tự reset các sheet trong scope trước để mapping cũ không sót lại.
+ *
+ * @param snapshot Workbook snapshot (plain JSON). Không bị mutate — trả về bản clone.
+ * @param targets  Danh sách cột cần đánh dấu (`{ sheetId, colIndex }`).
+ * @param config   Cấu hình style / prefix / scope. Bỏ trống = dùng default của lib.
+ */
+export const applyMappingIndicators = (snapshot, targets, config = {}) => {
+    const data = cloneSnapshot(snapshot);
+    const opts = resolveOpts(config);
+    const styles = data['styles'];
+    if (styles && !styles[opts.mappedStyleId]) {
+        styles[opts.mappedStyleId] = { ...opts.mappedStyle };
+    }
+    const sheets = data['sheets'];
+    if (!sheets)
+        return data;
+    const scope = config.scopeSheetIds ?? Object.keys(sheets);
+    for (const sheetId of scope) {
+        resetHeaderRow(sheets[sheetId], opts, false);
+    }
+    for (const target of targets) {
+        const sheet = sheets[target.sheetId];
+        const cell = sheet?.cellData?.[opts.headerRowKey]?.[String(target.colIndex)];
+        if (!cell || !sheet)
+            continue;
+        cell.s = opts.mappedStyleId;
+        if (typeof cell.v === 'string' && !cell.v.startsWith(opts.prefix)) {
+            const withIcon = `${opts.prefix}${cell.v}`;
+            cell.v = withIcon;
+            if (opts.autoResize)
+                expandColWidth(sheet, String(target.colIndex), withIcon, opts);
+        }
+    }
+    return data;
+};
+/**
+ * Gỡ toàn bộ indicator ('m' → default style, xóa prefix, khôi phục width) khỏi snapshot
+ * — dùng trước khi gửi workbook lên server để data sạch, không chứa style UI nội bộ.
+ *
+ * @param snapshot Workbook snapshot (plain JSON). Không bị mutate — trả về bản clone.
+ * @param config   Dùng chung config với `applyMappingIndicators` để gỡ đúng style/prefix.
+ *                 Bỏ trống = dùng default của lib.
+ */
+export const stripMappingIndicators = (snapshot, config = {}) => {
+    const data = cloneSnapshot(snapshot);
+    const opts = resolveOpts(config);
+    const sheets = data['sheets'];
+    if (!sheets)
+        return data;
+    const scope = config.scopeSheetIds ?? Object.keys(sheets);
+    for (const sheetId of scope) {
+        resetHeaderRow(sheets[sheetId], opts, true);
+    }
+    return data;
+};
+/** Chuyển colIndex (0-based) → chữ cái cột kiểu Excel: 0→'A', 25→'Z', 26→'AA'… */
+export const toColumnLetter = (index) => {
+    let letter = '';
+    let n = index;
+    do {
+        letter = String.fromCharCode(65 + (n % 26)) + letter;
+        n = Math.floor(n / 26) - 1;
+    } while (n >= 0);
+    return letter;
+};
+/** Tính index mới của 1 cột sau thao tác; trả null nếu cột đó bị xóa. */
+const shiftColumnIndex = (col, change) => {
+    const { type, startColumn: start, count } = change;
+    if (type === 'insert')
+        return col >= start ? col + count : col;
+    if (type === 'remove') {
+        if (col >= start && col < start + count)
+            return null; // cột nằm trong vùng bị xóa
+        return col >= start + count ? col - count : col;
+    }
+    // move: khối [start, start+count) chèn TRƯỚC toColumn (toạ độ gốc) = rút khối rồi chèn lại.
+    const end = start + count;
+    const dest = change.toColumn ?? start;
+    const newStart = dest <= start ? dest : dest - count;
+    if (col >= start && col < end)
+        return newStart + (col - start); // cột thuộc khối di chuyển
+    let shifted = col >= end ? col - count : col; // bước rút khối
+    if (shifted >= newStart)
+        shifted += count; // bước chèn lại
+    return shifted;
+};
+/**
+ * Remap colIndex của danh sách mapping theo 1 `T_columnStructureChange`.
+ * - Item khác `sheetId` giữ nguyên.
+ * - Item nằm trong vùng cột bị XÓA → loại khỏi kết quả.
+ * - Các item còn lại được dịch index cho khớp vị trí mới.
+ *
+ * Tự cập nhật cả `colLetter` (nếu item có field này) cho khớp `colIndex` mới — consumer
+ * không cần map lại thủ công.
+ *
+ * @example
+ * this.mappings.update((list) => remapColumnIndexes(list, change));
+ */
+export const remapColumnIndexes = (items, change) => {
+    const result = [];
+    for (const item of items) {
+        if (item.sheetId !== change.sheetId) {
+            result.push(item);
+            continue;
+        }
+        const next = shiftColumnIndex(item.colIndex, change);
+        if (next === null)
+            continue;
+        if (next === item.colIndex) {
+            result.push(item);
+            continue;
+        }
+        const updated = { ...item, colIndex: next };
+        if (typeof item.colLetter === 'string')
+            updated.colLetter = toColumnLetter(next);
+        result.push(updated);
+    }
+    return result;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.indicator.js","sourceRoot":"","sources":["../../../../../libs-ui/components/spreadsheet/src/spreadsheet.indicator.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanNumber } from '@univerjs/core';\n\n/**\n * Mapping Indicators — đánh dấu (highlight) header của các cột đã được \"map\" theo\n * một nghiệp vụ bất kỳ, để người dùng nhìn thấy ngay cột nào đang gắn với field nào.\n *\n * Toàn bộ logic chạy trên workbook snapshot (plain JSON của Univer) — KHÔNG phụ thuộc\n * vào instance Univer đang chạy. Vì vậy có thể gọi trước khi load, hoặc trên data đã save.\n *\n * Cách dùng: tự định nghĩa 1 `T_mappingIndicatorConfig` (style, prefix, scope…) rồi\n * truyền vào cả `applyMappingIndicators` (để hiện) và `stripMappingIndicators` (để dọn\n * trước khi gửi server). Không cần viết lại logic highlight cho từng nghiệp vụ.\n */\n\n/** Một cột cần đánh dấu — chỉ cần biết sheet và vị trí cột (0-indexed). */\nexport type T_indicatorTarget = {\n  sheetId: string;\n  colIndex: number;\n};\n\n/** Định nghĩa style highlight (đúng shape style object của Univer). */\nexport type T_indicatorStyle = {\n  /** Màu nền — vd `{ rgb: '#389E0D' }` */\n  bg?: { rgb: string };\n  /** Màu chữ — vd `{ rgb: '#FFFFFF' }` */\n  cl?: { rgb: string };\n  /** Bold */\n  bl?: BooleanNumber;\n  /** Horizontal align (0 left, 1 right, 2 center) */\n  ht?: number;\n  /** Vertical align (0 top, 1 bottom, 2 middle) */\n  vt?: number;\n  /** Font size */\n  fs?: number;\n};\n\n/**\n * Cấu hình cách highlight cột đã map. MỌI field đều optional — lib có default sẵn\n * (xem `defaultMappingIndicatorConfig`), consumer chỉ override phần cần. Dùng chung cho\n * cả apply & strip để đảm bảo đối xứng (đánh dấu rồi gỡ đúng style/prefix đã thêm).\n */\nexport type T_mappingIndicatorConfig = {\n  /** Key style đánh dấu cột đã map. Tự inject vào `styles` nếu chưa có. @default 'm' */\n  mappedStyleId?: string;\n  /** Định nghĩa style cho `mappedStyleId` — chỉ dùng khi cần inject lần đầu. @default xanh #389E0D, chữ trắng, bold */\n  mappedStyle?: T_indicatorStyle;\n  /** Key style header mặc định để revert về khi gỡ đánh dấu. @default 'h' */\n  defaultHeaderStyleId?: string;\n  /**\n   * Phạm vi sheet xử lý (reset trước khi đánh dấu / dọn). Bỏ trống = đọc từ dữ liệu:\n   * xử lý TẤT CẢ sheet có trong snapshot. Chỉ truyền khi muốn giới hạn để tối ưu.\n   * @default mọi sheet trong snapshot\n   */\n  scopeSheetIds?: string[];\n  /** Prefix icon thêm vào đầu header của cột đã map. @default '● ' */\n  prefix?: string;\n  /** Row index của header. @default 0 */\n  headerRowIndex?: number;\n  /** Tự co giãn width cột theo độ dài text (gồm prefix). @default true */\n  autoResize?: boolean;\n  /** Px trung bình mỗi ký tự khi auto-resize. @default 7.5 */\n  charWidth?: number;\n  /** Padding 2 bên (px) khi auto-resize. @default 16 */\n  padding?: number;\n};\n\n/** Style mặc định cho cột đã map: nền xanh, chữ trắng, bold, canh giữa. */\nconst DEFAULT_MAPPED_STYLE: T_indicatorStyle = {\n  bg: { rgb: '#389E0D' },\n  cl: { rgb: '#FFFFFF' },\n  bl: BooleanNumber.TRUE,\n  ht: 2,\n  vt: 2,\n  fs: 11,\n};\n\n/**\n * Config mặc định của lib — consumer có thể dùng trực tiếp hoặc spread-override:\n * `{ ...defaultMappingIndicatorConfig(), prefix: '★ ' }`.\n */\nexport const defaultMappingIndicatorConfig = (): T_mappingIndicatorConfig => ({\n  mappedStyleId: 'm',\n  mappedStyle: { ...DEFAULT_MAPPED_STYLE },\n  defaultHeaderStyleId: 'h',\n  prefix: '● ',\n  headerRowIndex: 0,\n  autoResize: true,\n  charWidth: 7.5,\n  padding: 16,\n});\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Internal types & helpers\n// ─────────────────────────────────────────────────────────────────────────────\n\ntype T_cell = { v?: unknown; s?: string };\ntype T_colData = Record<string, { w?: number }>;\ntype T_sheet = { cellData?: Record<string, Record<string, T_cell>>; columnData?: T_colData };\ntype T_sheetMap = Record<string, T_sheet>;\n\ntype T_resolvedOpts = {\n  mappedStyleId: string;\n  mappedStyle: T_indicatorStyle;\n  defaultHeaderStyleId: string;\n  prefix: string;\n  headerRowKey: string;\n  autoResize: boolean;\n  charWidth: number;\n  padding: number;\n};\n\nconst DEFAULT_PREFIX = '● ';\nconst DEFAULT_CHAR_W = 7.5;\nconst DEFAULT_PADDING = 16;\nconst DEFAULT_COL_W = 80;\nconst DEFAULT_MAPPED_STYLE_ID = 'm';\nconst DEFAULT_HEADER_STYLE_ID = 'h';\n\n/** Workbook snapshot là plain JSON — clone an toàn nhất bằng JSON. */\nconst cloneSnapshot = (snapshot: Record<string, unknown>): Record<string, unknown> =>\n  JSON.parse(JSON.stringify(snapshot)) as Record<string, unknown>;\n\nconst resolveOpts = (config: T_mappingIndicatorConfig): T_resolvedOpts => ({\n  mappedStyleId: config.mappedStyleId ?? DEFAULT_MAPPED_STYLE_ID,\n  mappedStyle: config.mappedStyle ?? DEFAULT_MAPPED_STYLE,\n  defaultHeaderStyleId: config.defaultHeaderStyleId ?? DEFAULT_HEADER_STYLE_ID,\n  prefix: config.prefix ?? DEFAULT_PREFIX,\n  headerRowKey: String(config.headerRowIndex ?? 0),\n  autoResize: config.autoResize ?? true,\n  charWidth: config.charWidth ?? DEFAULT_CHAR_W,\n  padding: config.padding ?? DEFAULT_PADDING,\n});\n\nconst estimateWidth = (text: string, opts: T_resolvedOpts): number =>\n  Math.ceil(text.length * opts.charWidth + opts.padding);\n\n/** Mở rộng width cột cho vừa text (không thu nhỏ hơn width hiện tại). */\nconst expandColWidth = (sheet: T_sheet, colKey: string, text: string, opts: T_resolvedOpts): void => {\n  const colData = sheet.columnData;\n  if (!colData) return;\n  const current = colData[colKey]?.w ?? DEFAULT_COL_W;\n  colData[colKey] = { ...(colData[colKey] ?? {}), w: Math.max(current, estimateWidth(text, opts)) };\n};\n\n/**\n * Dọn header row của 1 sheet: revert style về mặc định, xóa prefix, khôi phục width.\n * @param onlyMapped true → chỉ revert ô đang là `mappedStyleId`; false → revert mọi ô có style.\n */\nconst resetHeaderRow = (sheet: T_sheet | undefined, opts: T_resolvedOpts, onlyMapped: boolean): void => {\n  const headerRow = sheet?.cellData?.[opts.headerRowKey];\n  if (!headerRow || !sheet) return;\n  for (const colKey of Object.keys(headerRow)) {\n    const cell = headerRow[colKey];\n    if (!cell) continue;\n    if (onlyMapped) {\n      if (cell.s === opts.mappedStyleId) cell.s = opts.defaultHeaderStyleId;\n    } else if (cell.s) {\n      cell.s = opts.defaultHeaderStyleId;\n    }\n    if (typeof cell.v === 'string' && cell.v.startsWith(opts.prefix)) {\n      const original = cell.v.slice(opts.prefix.length);\n      cell.v = original;\n      if (opts.autoResize && sheet.columnData?.[colKey]) {\n        sheet.columnData[colKey].w = estimateWidth(original, opts);\n      }\n    }\n  }\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Public API\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Đánh dấu header các cột đã map: gắn style `mappedStyleId`, thêm prefix icon và\n * (tùy chọn) tự nới width. Tự reset các sheet trong scope trước để mapping cũ không sót lại.\n *\n * @param snapshot Workbook snapshot (plain JSON). Không bị mutate — trả về bản clone.\n * @param targets  Danh sách cột cần đánh dấu (`{ sheetId, colIndex }`).\n * @param config   Cấu hình style / prefix / scope. Bỏ trống = dùng default của lib.\n */\nexport const applyMappingIndicators = (\n  snapshot: Record<string, unknown>,\n  targets: T_indicatorTarget[],\n  config: T_mappingIndicatorConfig = {},\n): Record<string, unknown> => {\n  const data = cloneSnapshot(snapshot);\n  const opts = resolveOpts(config);\n\n  const styles = data['styles'] as Record<string, unknown> | undefined;\n  if (styles && !styles[opts.mappedStyleId]) {\n    styles[opts.mappedStyleId] = { ...opts.mappedStyle };\n  }\n\n  const sheets = data['sheets'] as T_sheetMap | undefined;\n  if (!sheets) return data;\n\n  const scope = config.scopeSheetIds ?? Object.keys(sheets);\n  for (const sheetId of scope) {\n    resetHeaderRow(sheets[sheetId], opts, false);\n  }\n\n  for (const target of targets) {\n    const sheet = sheets[target.sheetId];\n    const cell = sheet?.cellData?.[opts.headerRowKey]?.[String(target.colIndex)];\n    if (!cell || !sheet) continue;\n    cell.s = opts.mappedStyleId;\n    if (typeof cell.v === 'string' && !cell.v.startsWith(opts.prefix)) {\n      const withIcon = `${opts.prefix}${cell.v}`;\n      cell.v = withIcon;\n      if (opts.autoResize) expandColWidth(sheet, String(target.colIndex), withIcon, opts);\n    }\n  }\n\n  return data;\n};\n\n/**\n * Gỡ toàn bộ indicator ('m' → default style, xóa prefix, khôi phục width) khỏi snapshot\n * — dùng trước khi gửi workbook lên server để data sạch, không chứa style UI nội bộ.\n *\n * @param snapshot Workbook snapshot (plain JSON). Không bị mutate — trả về bản clone.\n * @param config   Dùng chung config với `applyMappingIndicators` để gỡ đúng style/prefix.\n *                 Bỏ trống = dùng default của lib.\n */\nexport const stripMappingIndicators = (\n  snapshot: Record<string, unknown>,\n  config: T_mappingIndicatorConfig = {},\n): Record<string, unknown> => {\n  const data = cloneSnapshot(snapshot);\n  const opts = resolveOpts(config);\n\n  const sheets = data['sheets'] as T_sheetMap | undefined;\n  if (!sheets) return data;\n\n  const scope = config.scopeSheetIds ?? Object.keys(sheets);\n  for (const sheetId of scope) {\n    resetHeaderRow(sheets[sheetId], opts, true);\n  }\n\n  return data;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Column structure change — remap mapping khi user insert / remove / move cột\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Mô tả 1 thao tác cấu trúc cột (do component phát qua `outColumnStructureChange`).\n * `count` đã gộp trường hợp chọn NHIỀU cột cùng lúc (range span).\n */\nexport type T_columnStructureChange = {\n  /** Sheet xảy ra thao tác. */\n  sheetId: string;\n  /** Loại thao tác. */\n  type: 'insert' | 'remove' | 'move';\n  /** Cột bắt đầu bị tác động (0-indexed). Với `move` = cạnh trái khối nguồn. */\n  startColumn: number;\n  /** Số cột bị tác động (≥ 1; >1 khi chọn nhiều cột). */\n  count: number;\n  /** Cột đích (cạnh trái, toạ độ GỐC trước khi dời) — CHỈ có với `move`. */\n  toColumn?: number;\n};\n\n/** Chuyển colIndex (0-based) → chữ cái cột kiểu Excel: 0→'A', 25→'Z', 26→'AA'… */\nexport const toColumnLetter = (index: number): string => {\n  let letter = '';\n  let n = index;\n  do {\n    letter = String.fromCharCode(65 + (n % 26)) + letter;\n    n = Math.floor(n / 26) - 1;\n  } while (n >= 0);\n  return letter;\n};\n\n/** Tính index mới của 1 cột sau thao tác; trả null nếu cột đó bị xóa. */\nconst shiftColumnIndex = (col: number, change: T_columnStructureChange): number | null => {\n  const { type, startColumn: start, count } = change;\n  if (type === 'insert') return col >= start ? col + count : col;\n  if (type === 'remove') {\n    if (col >= start && col < start + count) return null; // cột nằm trong vùng bị xóa\n    return col >= start + count ? col - count : col;\n  }\n  // move: khối [start, start+count) chèn TRƯỚC toColumn (toạ độ gốc) = rút khối rồi chèn lại.\n  const end = start + count;\n  const dest = change.toColumn ?? start;\n  const newStart = dest <= start ? dest : dest - count;\n  if (col >= start && col < end) return newStart + (col - start); // cột thuộc khối di chuyển\n  let shifted = col >= end ? col - count : col; // bước rút khối\n  if (shifted >= newStart) shifted += count; // bước chèn lại\n  return shifted;\n};\n\n/**\n * Remap colIndex của danh sách mapping theo 1 `T_columnStructureChange`.\n * - Item khác `sheetId` giữ nguyên.\n * - Item nằm trong vùng cột bị XÓA → loại khỏi kết quả.\n * - Các item còn lại được dịch index cho khớp vị trí mới.\n *\n * Tự cập nhật cả `colLetter` (nếu item có field này) cho khớp `colIndex` mới — consumer\n * không cần map lại thủ công.\n *\n * @example\n * this.mappings.update((list) => remapColumnIndexes(list, change));\n */\nexport const remapColumnIndexes = <T extends { sheetId: string; colIndex: number; colLetter?: string }>(\n  items: T[],\n  change: T_columnStructureChange,\n): T[] => {\n  const result: T[] = [];\n  for (const item of items) {\n    if (item.sheetId !== change.sheetId) {\n      result.push(item);\n      continue;\n    }\n    const next = shiftColumnIndex(item.colIndex, change);\n    if (next === null) continue;\n    if (next === item.colIndex) {\n      result.push(item);\n      continue;\n    }\n    const updated: T = { ...item, colIndex: next };\n    if (typeof item.colLetter === 'string') updated.colLetter = toColumnLetter(next);\n    result.push(updated);\n  }\n  return result;\n};\n"]}

package/esm2022/spreadsheet.locale.mjs

@@ -0,0 +1,67 @@
+import { Tools } from '@univerjs/core';
+import DesignEnUS from '@univerjs/design/lib/locale/en-US.json';
+import DesignViVN from '@univerjs/design/lib/locale/vi-VN.json';
+import DocsUIEnUS from '@univerjs/docs-ui/lib/locale/en-US.json';
+import DocsUIViVN from '@univerjs/docs-ui/lib/locale/vi-VN.json';
+import SheetsEnUS from '@univerjs/sheets/lib/locale/en-US.json';
+import SheetsViVN from '@univerjs/sheets/lib/locale/vi-VN.json';
+import SheetsFormulaUIEnUS from '@univerjs/sheets-formula-ui/lib/locale/en-US.json';
+import SheetsFormulaUIViVN from '@univerjs/sheets-formula-ui/lib/locale/vi-VN.json';
+import SheetsUIEnUS from '@univerjs/sheets-ui/lib/locale/en-US.json';
+import SheetsUIViVN from '@univerjs/sheets-ui/lib/locale/vi-VN.json';
+import UIEnUS from '@univerjs/ui/lib/locale/en-US.json';
+import UIViVN from '@univerjs/ui/lib/locale/vi-VN.json';
+// Numfmt locale embedded directly — avoids TS module resolution issues with JSON in package exports
+const sheetsNumfmtLocaleEn = {
+    sheet: {
+        numfmt: {
+            percent: 'Percentage', title: 'Number format', numfmtType: 'Format types',
+            cancel: 'Cancel', confirm: 'Confirm', general: 'General',
+            accounting: 'Accounting', text: 'Text', number: 'Number',
+            currency: 'Currency', date: 'Date', time: 'Time',
+            thousandthPercentile: 'Thousands separator', preview: 'Preview',
+            dateTime: 'Date and time', decimalLength: 'Decimal places',
+            currencyType: 'Currency Symbol', moreFmt: 'Formats',
+            financialValue: 'Financial value', roundingCurrency: 'Rounding up the currency',
+            timeDuration: 'Duration Time', addDecimal: 'Increase decimal places',
+            subtractDecimal: 'Decreasing decimal places', customFormat: 'Custom Format',
+            // Additional keys from en-US.json
+            negType: 'A negative number type',
+            currencyDes: 'The currency format is used to represent general currency values. The accounting format aligns a column of values with decimal points.',
+            accountingDes: 'The accounting number format aligns a column of values with currency symbols and decimal points.',
+            dateType: 'Date Type',
+            dateDes: 'The date format presents date and time series values as date values.',
+            generalDes: 'The regular format does not contain any specific number format.',
+            thousandthPercentileDes: 'The percentile format is used for the representation of ordinary numbers.',
+            customFormatDes: 'Generate custom number formats based on existing formats.',
+        },
+    },
+};
+// Numfmt locale tiếng Việt — nhúng trực tiếp cùng lý do như bản en ở trên
+const sheetsNumfmtLocaleVi = {
+    sheet: {
+        numfmt: {
+            percent: 'Phần trăm', title: 'Định dạng số', numfmtType: 'Loại định dạng',
+            cancel: 'Hủy bỏ', confirm: 'Xác nhận', general: 'Chung',
+            accounting: 'Kế toán', text: 'Văn bản', number: 'Số',
+            currency: 'Tiền tệ', date: 'Ngày', time: 'Thời gian',
+            thousandthPercentile: 'Phân vị phần nghìn', preview: 'Xem trước',
+            dateTime: 'Ngày giờ', decimalLength: 'Số chữ số thập phân',
+            currencyType: 'Loại tiền tệ', moreFmt: 'Nhiều định dạng hơn',
+            financialValue: 'Giá trị tài chính', roundingCurrency: 'Tiền tệ làm tròn',
+            timeDuration: 'Thời lượng', addDecimal: 'Thêm chữ số thập phân',
+            subtractDecimal: 'Giảm chữ số thập phân', customFormat: 'Định dạng tùy chỉnh',
+            negType: 'Loại số âm',
+            currencyDes: 'Định dạng tiền tệ được sử dụng để biểu thị các giá trị tiền tệ thông thường. Định dạng kế toán có thể căn chỉnh các giá trị trong một cột với dấu thập phân.',
+            accountingDes: 'Định dạng số kế toán có thể căn chỉnh các ký hiệu tiền tệ và dấu thập phân trong một cột các giá trị.',
+            dateType: 'Loại ngày',
+            dateDes: 'Định dạng ngày biểu thị các giá trị chuỗi ngày và thời gian dưới dạng giá trị ngày.',
+            generalDes: 'Định dạng chung không chứa bất kỳ định dạng số cụ thể nào.',
+            thousandthPercentileDes: 'Định dạng phân vị phần nghìn được sử dụng để biểu thị các số thông thường.',
+            customFormatDes: 'Tạo định dạng số tùy chỉnh dựa trên các định dạng hiện có.',
+        },
+    },
+};
+export const univerLocaleEn = Tools.deepMerge(SheetsEnUS, DocsUIEnUS, SheetsUIEnUS, SheetsFormulaUIEnUS, sheetsNumfmtLocaleEn, UIEnUS, DesignEnUS);
+export const univerLocaleVi = Tools.deepMerge(SheetsViVN, DocsUIViVN, SheetsUIViVN, SheetsFormulaUIViVN, sheetsNumfmtLocaleVi, UIViVN, DesignViVN);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.locale.js","sourceRoot":"","sources":["../../../../../libs-ui/components/spreadsheet/src/spreadsheet.locale.ts"],"names":[],"mappings":"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","sourcesContent":["import { Tools } from '@univerjs/core';\nimport DesignEnUS from '@univerjs/design/lib/locale/en-US.json';\nimport DesignViVN from '@univerjs/design/lib/locale/vi-VN.json';\nimport DocsUIEnUS from '@univerjs/docs-ui/lib/locale/en-US.json';\nimport DocsUIViVN from '@univerjs/docs-ui/lib/locale/vi-VN.json';\nimport SheetsEnUS from '@univerjs/sheets/lib/locale/en-US.json';\nimport SheetsViVN from '@univerjs/sheets/lib/locale/vi-VN.json';\nimport SheetsFormulaUIEnUS from '@univerjs/sheets-formula-ui/lib/locale/en-US.json';\nimport SheetsFormulaUIViVN from '@univerjs/sheets-formula-ui/lib/locale/vi-VN.json';\nimport SheetsUIEnUS from '@univerjs/sheets-ui/lib/locale/en-US.json';\nimport SheetsUIViVN from '@univerjs/sheets-ui/lib/locale/vi-VN.json';\nimport UIEnUS from '@univerjs/ui/lib/locale/en-US.json';\nimport UIViVN from '@univerjs/ui/lib/locale/vi-VN.json';\n\n// Numfmt locale embedded directly — avoids TS module resolution issues with JSON in package exports\nconst sheetsNumfmtLocaleEn = {\n  sheet: {\n    numfmt: {\n      percent: 'Percentage', title: 'Number format', numfmtType: 'Format types',\n      cancel: 'Cancel', confirm: 'Confirm', general: 'General',\n      accounting: 'Accounting', text: 'Text', number: 'Number',\n      currency: 'Currency', date: 'Date', time: 'Time',\n      thousandthPercentile: 'Thousands separator', preview: 'Preview',\n      dateTime: 'Date and time', decimalLength: 'Decimal places',\n      currencyType: 'Currency Symbol', moreFmt: 'Formats',\n      financialValue: 'Financial value', roundingCurrency: 'Rounding up the currency',\n      timeDuration: 'Duration Time', addDecimal: 'Increase decimal places',\n      subtractDecimal: 'Decreasing decimal places', customFormat: 'Custom Format',\n      // Additional keys from en-US.json\n      negType: 'A negative number type',\n      currencyDes: 'The currency format is used to represent general currency values. The accounting format aligns a column of values with decimal points.',\n      accountingDes: 'The accounting number format aligns a column of values with currency symbols and decimal points.',\n      dateType: 'Date Type',\n      dateDes: 'The date format presents date and time series values as date values.',\n      generalDes: 'The regular format does not contain any specific number format.',\n      thousandthPercentileDes: 'The percentile format is used for the representation of ordinary numbers.',\n      customFormatDes: 'Generate custom number formats based on existing formats.',\n    },\n  },\n};\n\n// Numfmt locale tiếng Việt — nhúng trực tiếp cùng lý do như bản en ở trên\nconst sheetsNumfmtLocaleVi = {\n  sheet: {\n    numfmt: {\n      percent: 'Phần trăm', title: 'Định dạng số', numfmtType: 'Loại định dạng',\n      cancel: 'Hủy bỏ', confirm: 'Xác nhận', general: 'Chung',\n      accounting: 'Kế toán', text: 'Văn bản', number: 'Số',\n      currency: 'Tiền tệ', date: 'Ngày', time: 'Thời gian',\n      thousandthPercentile: 'Phân vị phần nghìn', preview: 'Xem trước',\n      dateTime: 'Ngày giờ', decimalLength: 'Số chữ số thập phân',\n      currencyType: 'Loại tiền tệ', moreFmt: 'Nhiều định dạng hơn',\n      financialValue: 'Giá trị tài chính', roundingCurrency: 'Tiền tệ làm tròn',\n      timeDuration: 'Thời lượng', addDecimal: 'Thêm chữ số thập phân',\n      subtractDecimal: 'Giảm chữ số thập phân', customFormat: 'Định dạng tùy chỉnh',\n      negType: 'Loại số âm',\n      currencyDes: 'Định dạng tiền tệ được sử dụng để biểu thị các giá trị tiền tệ thông thường. Định dạng kế toán có thể căn chỉnh các giá trị trong một cột với dấu thập phân.',\n      accountingDes: 'Định dạng số kế toán có thể căn chỉnh các ký hiệu tiền tệ và dấu thập phân trong một cột các giá trị.',\n      dateType: 'Loại ngày',\n      dateDes: 'Định dạng ngày biểu thị các giá trị chuỗi ngày và thời gian dưới dạng giá trị ngày.',\n      generalDes: 'Định dạng chung không chứa bất kỳ định dạng số cụ thể nào.',\n      thousandthPercentileDes: 'Định dạng phân vị phần nghìn được sử dụng để biểu thị các số thông thường.',\n      customFormatDes: 'Tạo định dạng số tùy chỉnh dựa trên các định dạng hiện có.',\n    },\n  },\n};\n\nexport const univerLocaleEn = Tools.deepMerge(\n  SheetsEnUS,\n  DocsUIEnUS,\n  SheetsUIEnUS,\n  SheetsFormulaUIEnUS,\n  sheetsNumfmtLocaleEn,\n  UIEnUS,\n  DesignEnUS,\n);\n\nexport const univerLocaleVi = Tools.deepMerge(\n  SheetsViVN,\n  DocsUIViVN,\n  SheetsUIViVN,\n  SheetsFormulaUIViVN,\n  sheetsNumfmtLocaleVi,\n  UIViVN,\n  DesignViVN,\n);"]}

package/esm2022/spreadsheet.numfmt.mjs

@@ -0,0 +1,209 @@
+import { getPatternPreview } from '@univerjs/sheets-numfmt';
+import { fromEvent } from 'rxjs';
+/**
+ * Giá trị mẫu MẶC ĐỊNH để sinh preview = 2021-03-14 13:45:30 (Excel serial).
+ * Chọn ngày 14 (>12) để phân biệt dd↔mm, giờ 13 để phân biệt 24h↔AM/PM, có cả giây.
+ * CHỈ dùng khi ô đang chọn không có giá trị ngày hợp lệ — nếu có, ưu tiên giá trị THỰC của ô
+ * để label option khớp đúng dữ liệu hiển thị trong cột (giống Excel).
+ */
+const SAMPLE_SERIAL = 44269 + 49530 / 86400;
+/**
+ * Danh sách định dạng ngày/giờ kiểu Excel (ordered: Ngày → Ngày+Giờ → Giờ).
+ * Label hiển thị cho người dùng là PREVIEW của SAMPLE (vd 'dd/mm/yyyy' → "14/03/2021"),
+ * trực quan giống hộp "Type" của Excel; pattern thực được lưu ở data-pattern để áp.
+ */
+const CUSTOM_DATE_PATTERNS = [
+    // ── Ngày ──
+    'dd/mm/yyyy',
+    'd/m/yyyy',
+    'dd/mm/yy',
+    'mm/dd/yyyy',
+    'yyyy-mm-dd',
+    'dd-mmm-yyyy',
+    'dd-mmm-yy',
+    'd mmmm yyyy',
+    'mmm yyyy',
+    'mmmm yyyy',
+    'dddd, d mmmm yyyy',
+    // ── Ngày + giờ ──
+    'dd/mm/yyyy hh:mm',
+    'dd/mm/yyyy h:mm AM/PM',
+    'dd/mm/yyyy hh:mm:ss',
+    'yyyy-mm-dd hh:mm:ss',
+    // ── Giờ ──
+    'hh:mm',
+    'hh:mm:ss',
+    'h:mm AM/PM',
+    'h:mm:ss AM/PM',
+    'mm:ss',
+    '[h]:mm:ss',
+];
+/** Sinh chuỗi preview (giá trị mẫu đã format) cho 1 pattern; fallback về pattern nếu lỗi. */
+const previewOf = (pattern, sample) => {
+    try {
+        return getPatternPreview(pattern, sample).result || pattern;
+    }
+    catch {
+        return pattern;
+    }
+};
+/**
+ * Re-assert highlight cho option đang chọn sau khi Univer re-render panel (React có thể xoá class).
+ * Dựa trên cờ data-numfmt-selected (do setActive đặt) — không suy diễn từ DOM label.
+ */
+export const syncActiveNumfmtHighlight = () => {
+    const panel = document.querySelector('.numfmt-panel');
+    if (!panel)
+        return;
+    panel.querySelectorAll('.univer-numfmt-custom-item').forEach((item) => {
+        item.classList.toggle('univer-numfmt-active', item.hasAttribute('data-numfmt-selected'));
+    });
+};
+/**
+ * Thay danh sách định dạng ngày mặc định của Univer bằng các option custom (CUSTOM_DATE_PATTERNS),
+ * hiển thị dưới dạng PREVIEW trực quan. Univer render panel numfmt bằng React và không expose API
+ * nên phải thao tác DOM trực tiếp.
+ *
+ * @param getSnapshot         Lấy vùng chọn hiện tại (để áp numfmt).
+ * @param executeCmd          Chạy Univer command.
+ * @param onPatternSelected   Báo component pattern vừa chọn (Confirm) hoặc null (Cancel) để đồng bộ.
+ * @param getActiveCellFormat Đọc pattern hiện tại của cell — dùng highlight option khớp khi mở.
+ * @param clearPreview        Xoá live-preview overlay của Univer để canvas vẽ đúng model ngay.
+ * @param getSampleValue      Lấy giá trị THỰC (serial) của ô đại diện để label preview khớp dữ liệu cột;
+ *                            null → dùng SAMPLE_SERIAL mặc định.
+ * @returns hàm cleanup (gỡ mọi listener) — gọi khi teardown hoặc trước lần inject mới.
+ */
+export const injectCustomDateFormats = (getSnapshot, executeCmd, onPatternSelected, getActiveCellFormat, clearPreview, getSampleValue, onConfirm) => {
+    const panel = document.querySelector('.numfmt-panel');
+    if (!panel)
+        return;
+    // Guard: chỉ inject 1 lần / phiên (component xoá data-custom-dates khi đóng panel để reopen re-inject).
+    const listContainer = panel.querySelector('ul.univer-select-list');
+    if (!listContainer || listContainer.hasAttribute('data-custom-dates'))
+        return;
+    // Nhận diện panel Date theo 2 trường hợp:
+    //   1. Univer vừa render list ngày GỐC (li dạng yyyy-mm-dd) — lần đầu chọn Type=Date.
+    //   2. Univer TÁI DÙNG DOM panel cũ (reopen) → list đang chứa sẵn custom item của ta từ phiên trước.
+    const hasUniverDateItems = Array.from(listContainer.querySelectorAll('li')).some((el) => /^\d{4}[-/]\d{2}[-/]\d{2}$/.test(el.textContent?.trim() ?? ''));
+    const hasOurItems = !!listContainer.querySelector('.univer-numfmt-custom-item');
+    if (!hasUniverDateItems && !hasOurItems)
+        return;
+    listContainer.setAttribute('data-custom-dates', 'true');
+    const itemTemplate = listContainer.querySelector('li');
+    const defaultItems = Array.from(listContainer.children);
+    const applyFormat = (pattern) => {
+        const snap = getSnapshot();
+        if (!snap)
+            return;
+        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, row: r, col: c });
+            }
+        }
+        if (!values.length)
+            return;
+        executeCmd('sheet.command.numfmt.set.numfmt', { unitId: snap.unitId, subUnitId: snap.subUnitId, values });
+        // Univer giữ live-preview overlay (NumfmtController._previewPattern) che hiển thị model của
+        // vùng chọn khi panel mở. Ta đã ghi model trực tiếp nên phải xoá preview để canvas vẽ đúng ngay.
+        clearPreview?.();
+    };
+    let pendingPattern = null;
+    let activeItem = null;
+    const setActive = (item) => {
+        if (activeItem) {
+            activeItem.classList.remove('univer-numfmt-active');
+            activeItem.removeAttribute('data-numfmt-selected');
+        }
+        item.classList.add('univer-numfmt-active');
+        item.setAttribute('data-numfmt-selected', 'true');
+        activeItem = item;
+    };
+    const subs = [];
+    const cleanup = () => {
+        subs.forEach((s) => s.unsubscribe());
+        subs.length = 0;
+    };
+    // Nhận diện nút theo CLASS (không phụ thuộc ngôn ngữ): Univer render Confirm = button-primary,
+    // Cancel = button-default. KHÔNG match theo text ('Confirm'/'Cancel') vì sẽ vỡ khi locale là tiếng Việt.
+    const panelButtons = Array.from(panel.querySelectorAll('button'));
+    const confirmBtn = panelButtons.find((b) => b.classList.contains('univer-button-primary'));
+    const cancelBtn = panelButtons.find((b) => b.classList.contains('univer-button-default'));
+    // Capture phase: chạy trước Univer handler. KHÔNG cleanup() trong handler vì Univer tái dùng DOM panel —
+    // gỡ listener sẽ làm option không click được khi mở lại. cleanup chỉ chạy khi teardown thật.
+    if (confirmBtn) {
+        subs.push(fromEvent(confirmBtn, 'click', { capture: true }).subscribe(() => {
+            // Đánh dấu Confirm → component GIỮ format. Cancel/X/click-ngoài KHÔNG gọi → mặc định revert.
+            onConfirm?.();
+            if (!pendingPattern)
+                return;
+            applyFormat(pendingPattern);
+            onPatternSelected?.(pendingPattern);
+        }));
+    }
+    if (cancelBtn) {
+        subs.push(fromEvent(cancelBtn, 'click', { capture: true }).subscribe(() => {
+            if (activeItem) {
+                activeItem.classList.remove('univer-numfmt-active');
+                activeItem.removeAttribute('data-numfmt-selected');
+                activeItem = null;
+            }
+            // pendingPattern = null → component khôi phục numfmt gốc từng ô (xem close.numfmt.panel handler).
+            pendingPattern = null;
+            onPatternSelected?.(null);
+        }));
+    }
+    for (const pattern of CUSTOM_DATE_PATTERNS) {
+        const item = (itemTemplate ?? document.createElement('div')).cloneNode(false);
+        // Khi reopen, itemTemplate là custom item cũ → xoá cờ highlight/selected sao chép theo để tránh stale.
+        item.removeAttribute('data-numfmt-selected');
+        item.classList.remove('univer-numfmt-active');
+        item.textContent = previewOf(pattern, getSampleValue?.() ?? SAMPLE_SERIAL);
+        item.dataset['pattern'] = pattern;
+        item.style.cursor = 'pointer';
+        item.classList.add('univer-numfmt-custom-item');
+        subs.push(fromEvent(item, 'mousedown').subscribe((e) => e.preventDefault()));
+        subs.push(fromEvent(item, 'click').subscribe((e) => {
+            e.stopPropagation();
+            setActive(item);
+            pendingPattern = pattern;
+            applyFormat(pattern);
+            onPatternSelected?.(pattern);
+        }));
+        listContainer.appendChild(item);
+    }
+    defaultItems.forEach((el) => el.remove());
+    /**
+     * Đồng bộ panel theo vùng chọn HIỆN TẠI (getSnapshot/getActiveCellFormat/getSampleValue đọc fresh):
+     *   1. Sinh lại label preview theo giá trị THỰC của ô đại diện cột mới (khớp dữ liệu, giống Excel).
+     *   2. Highlight option khớp format hiện có; nếu cột chưa có format → chọn option ĐẦU TIÊN.
+     *   3. ÁP LUÔN pattern đó lên cả vùng → dữ liệu đổi hiển thị ngay; set pending để Confirm giữ.
+     * Gọi khi mở panel VÀ mỗi khi user đổi cột/cell trên grid lúc panel đang mở.
+     * Cancel / X → component khôi phục giá trị gốc (originalCellFormats đã chụp/tích luỹ khi mở/đổi vùng).
+     */
+    const resync = () => {
+        const sample = getSampleValue?.() ?? SAMPLE_SERIAL;
+        const items = Array.from(listContainer.querySelectorAll('.univer-numfmt-custom-item'));
+        items.forEach((el) => { el.textContent = previewOf(el.dataset['pattern'] ?? '', sample); });
+        const activeFmt = (getActiveCellFormat?.() ?? '').toLowerCase();
+        const matched = activeFmt && activeFmt !== 'general'
+            ? items.find((el) => (el.dataset['pattern'] ?? '').toLowerCase() === activeFmt)
+            : undefined;
+        const initial = matched ?? items[0];
+        if (!initial)
+            return;
+        setActive(initial);
+        pendingPattern = initial.dataset['pattern'] ?? null;
+        if (!pendingPattern)
+            return;
+        applyFormat(pendingPattern);
+        onPatternSelected?.(pendingPattern);
+    };
+    resync();
+    // Net chống race: nếu Univer set lại preview overlay NGAY SAU khi panel render (sau applyFormat ở trên),
+    // xoá lần nữa sau 1 nhịp để canvas hiển thị numfmt THẬT của model. (applyFormat đã clearPreview đồng bộ.)
+    setTimeout(() => clearPreview?.(), 60);
+    return { cleanup, resync };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.numfmt.js","sourceRoot":"","sources":["../../../../../libs-ui/components/spreadsheet/src/spreadsheet.numfmt.ts"],"names":[],"mappings":"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","sourcesContent":["import { getPatternPreview } from '@univerjs/sheets-numfmt';\nimport { Subscription, fromEvent } from 'rxjs';\n\nimport type { T_rangeSnapshot } from './spreadsheet.type';\n\n/**\n * Giá trị mẫu MẶC ĐỊNH để sinh preview = 2021-03-14 13:45:30 (Excel serial).\n * Chọn ngày 14 (>12) để phân biệt dd↔mm, giờ 13 để phân biệt 24h↔AM/PM, có cả giây.\n * CHỈ dùng khi ô đang chọn không có giá trị ngày hợp lệ — nếu có, ưu tiên giá trị THỰC của ô\n * để label option khớp đúng dữ liệu hiển thị trong cột (giống Excel).\n */\nconst SAMPLE_SERIAL = 44269 + 49530 / 86400;\n\n/**\n * Danh sách định dạng ngày/giờ kiểu Excel (ordered: Ngày → Ngày+Giờ → Giờ).\n * Label hiển thị cho người dùng là PREVIEW của SAMPLE (vd 'dd/mm/yyyy' → \"14/03/2021\"),\n * trực quan giống hộp \"Type\" của Excel; pattern thực được lưu ở data-pattern để áp.\n */\nconst CUSTOM_DATE_PATTERNS: string[] = [\n  // ── Ngày ──\n  'dd/mm/yyyy',\n  'd/m/yyyy',\n  'dd/mm/yy',\n  'mm/dd/yyyy',\n  'yyyy-mm-dd',\n  'dd-mmm-yyyy',\n  'dd-mmm-yy',\n  'd mmmm yyyy',\n  'mmm yyyy',\n  'mmmm yyyy',\n  'dddd, d mmmm yyyy',\n  // ── Ngày + giờ ──\n  'dd/mm/yyyy hh:mm',\n  'dd/mm/yyyy h:mm AM/PM',\n  'dd/mm/yyyy hh:mm:ss',\n  'yyyy-mm-dd hh:mm:ss',\n  // ── Giờ ──\n  'hh:mm',\n  'hh:mm:ss',\n  'h:mm AM/PM',\n  'h:mm:ss AM/PM',\n  'mm:ss',\n  '[h]:mm:ss',\n];\n\n/** Sinh chuỗi preview (giá trị mẫu đã format) cho 1 pattern; fallback về pattern nếu lỗi. */\nconst previewOf = (pattern: string, sample: number): string => {\n  try {\n    return getPatternPreview(pattern, sample).result || pattern;\n  } catch {\n    return pattern;\n  }\n};\n\n/**\n * Re-assert highlight cho option đang chọn sau khi Univer re-render panel (React có thể xoá class).\n * Dựa trên cờ data-numfmt-selected (do setActive đặt) — không suy diễn từ DOM label.\n */\nexport const syncActiveNumfmtHighlight = () => {\n  const panel = document.querySelector('.numfmt-panel');\n  if (!panel) return;\n  panel.querySelectorAll<HTMLElement>('.univer-numfmt-custom-item').forEach((item) => {\n    item.classList.toggle('univer-numfmt-active', item.hasAttribute('data-numfmt-selected'));\n  });\n};\n\n/**\n * Thay danh sách định dạng ngày mặc định của Univer bằng các option custom (CUSTOM_DATE_PATTERNS),\n * hiển thị dưới dạng PREVIEW trực quan. Univer render panel numfmt bằng React và không expose API\n * nên phải thao tác DOM trực tiếp.\n *\n * @param getSnapshot         Lấy vùng chọn hiện tại (để áp numfmt).\n * @param executeCmd          Chạy Univer command.\n * @param onPatternSelected   Báo component pattern vừa chọn (Confirm) hoặc null (Cancel) để đồng bộ.\n * @param getActiveCellFormat Đọc pattern hiện tại của cell — dùng highlight option khớp khi mở.\n * @param clearPreview        Xoá live-preview overlay của Univer để canvas vẽ đúng model ngay.\n * @param getSampleValue      Lấy giá trị THỰC (serial) của ô đại diện để label preview khớp dữ liệu cột;\n *                            null → dùng SAMPLE_SERIAL mặc định.\n * @returns hàm cleanup (gỡ mọi listener) — gọi khi teardown hoặc trước lần inject mới.\n */\nexport const injectCustomDateFormats = (\n  getSnapshot: () => T_rangeSnapshot | null,\n  executeCmd: (cmdId: string, params: unknown) => void,\n  onPatternSelected?: (pattern: string | null) => void,\n  getActiveCellFormat?: () => string,\n  clearPreview?: () => void,\n  getSampleValue?: () => number | null,\n  onConfirm?: () => void\n) => {\n  const panel = document.querySelector<HTMLElement>('.numfmt-panel');\n  if (!panel) return;\n\n  // Guard: chỉ inject 1 lần / phiên (component xoá data-custom-dates khi đóng panel để reopen re-inject).\n  const listContainer = panel.querySelector<HTMLElement>('ul.univer-select-list');\n  if (!listContainer || listContainer.hasAttribute('data-custom-dates')) return;\n  // Nhận diện panel Date theo 2 trường hợp:\n  //   1. Univer vừa render list ngày GỐC (li dạng yyyy-mm-dd) — lần đầu chọn Type=Date.\n  //   2. Univer TÁI DÙNG DOM panel cũ (reopen) → list đang chứa sẵn custom item của ta từ phiên trước.\n  const hasUniverDateItems = Array.from(listContainer.querySelectorAll<HTMLElement>('li')).some((el) => /^\\d{4}[-/]\\d{2}[-/]\\d{2}$/.test(el.textContent?.trim() ?? ''));\n  const hasOurItems = !!listContainer.querySelector('.univer-numfmt-custom-item');\n  if (!hasUniverDateItems && !hasOurItems) return;\n\n  listContainer.setAttribute('data-custom-dates', 'true');\n  const itemTemplate = listContainer.querySelector<HTMLElement>('li');\n  const defaultItems = Array.from(listContainer.children);\n\n  const applyFormat = (pattern: string) => {\n    const snap = getSnapshot();\n    if (!snap) return;\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, row: r, col: c });\n      }\n    }\n    if (!values.length) return;\n    executeCmd('sheet.command.numfmt.set.numfmt', { unitId: snap.unitId, subUnitId: snap.subUnitId, values });\n    // Univer giữ live-preview overlay (NumfmtController._previewPattern) che hiển thị model của\n    // vùng chọn khi panel mở. Ta đã ghi model trực tiếp nên phải xoá preview để canvas vẽ đúng ngay.\n    clearPreview?.();\n  };\n\n  let pendingPattern: string | null = null;\n  let activeItem: HTMLElement | null = null;\n\n  const setActive = (item: HTMLElement) => {\n    if (activeItem) {\n      activeItem.classList.remove('univer-numfmt-active');\n      activeItem.removeAttribute('data-numfmt-selected');\n    }\n    item.classList.add('univer-numfmt-active');\n    item.setAttribute('data-numfmt-selected', 'true');\n    activeItem = item;\n  };\n\n  const subs: Subscription[] = [];\n  const cleanup = () => {\n    subs.forEach((s) => s.unsubscribe());\n    subs.length = 0;\n  };\n\n  // Nhận diện nút theo CLASS (không phụ thuộc ngôn ngữ): Univer render Confirm = button-primary,\n  // Cancel = button-default. KHÔNG match theo text ('Confirm'/'Cancel') vì sẽ vỡ khi locale là tiếng Việt.\n  const panelButtons = Array.from(panel.querySelectorAll<HTMLElement>('button'));\n  const confirmBtn = panelButtons.find((b) => b.classList.contains('univer-button-primary'));\n  const cancelBtn = panelButtons.find((b) => b.classList.contains('univer-button-default'));\n\n  // Capture phase: chạy trước Univer handler. KHÔNG cleanup() trong handler vì Univer tái dùng DOM panel —\n  // gỡ listener sẽ làm option không click được khi mở lại. cleanup chỉ chạy khi teardown thật.\n  if (confirmBtn) {\n    subs.push(\n      fromEvent<MouseEvent>(confirmBtn, 'click', { capture: true }).subscribe(() => {\n        // Đánh dấu Confirm → component GIỮ format. Cancel/X/click-ngoài KHÔNG gọi → mặc định revert.\n        onConfirm?.();\n        if (!pendingPattern) return;\n        applyFormat(pendingPattern);\n        onPatternSelected?.(pendingPattern);\n      })\n    );\n  }\n\n  if (cancelBtn) {\n    subs.push(\n      fromEvent<MouseEvent>(cancelBtn, 'click', { capture: true }).subscribe(() => {\n        if (activeItem) {\n          activeItem.classList.remove('univer-numfmt-active');\n          activeItem.removeAttribute('data-numfmt-selected');\n          activeItem = null;\n        }\n        // pendingPattern = null → component khôi phục numfmt gốc từng ô (xem close.numfmt.panel handler).\n        pendingPattern = null;\n        onPatternSelected?.(null);\n      })\n    );\n  }\n\n  for (const pattern of CUSTOM_DATE_PATTERNS) {\n    const item = (itemTemplate ?? document.createElement('div')).cloneNode(false) as HTMLElement;\n    // Khi reopen, itemTemplate là custom item cũ → xoá cờ highlight/selected sao chép theo để tránh stale.\n    item.removeAttribute('data-numfmt-selected');\n    item.classList.remove('univer-numfmt-active');\n    item.textContent = previewOf(pattern, getSampleValue?.() ?? SAMPLE_SERIAL);\n    item.dataset['pattern'] = pattern;\n    item.style.cursor = 'pointer';\n    item.classList.add('univer-numfmt-custom-item');\n\n    subs.push(fromEvent<MouseEvent>(item, 'mousedown').subscribe((e) => e.preventDefault()));\n    subs.push(\n      fromEvent<MouseEvent>(item, 'click').subscribe((e) => {\n        e.stopPropagation();\n        setActive(item);\n        pendingPattern = pattern;\n        applyFormat(pattern);\n        onPatternSelected?.(pattern);\n      })\n    );\n\n    listContainer.appendChild(item);\n  }\n\n  defaultItems.forEach((el) => el.remove());\n\n  /**\n   * Đồng bộ panel theo vùng chọn HIỆN TẠI (getSnapshot/getActiveCellFormat/getSampleValue đọc fresh):\n   *   1. Sinh lại label preview theo giá trị THỰC của ô đại diện cột mới (khớp dữ liệu, giống Excel).\n   *   2. Highlight option khớp format hiện có; nếu cột chưa có format → chọn option ĐẦU TIÊN.\n   *   3. ÁP LUÔN pattern đó lên cả vùng → dữ liệu đổi hiển thị ngay; set pending để Confirm giữ.\n   * Gọi khi mở panel VÀ mỗi khi user đổi cột/cell trên grid lúc panel đang mở.\n   * Cancel / X → component khôi phục giá trị gốc (originalCellFormats đã chụp/tích luỹ khi mở/đổi vùng).\n   */\n  const resync = () => {\n    const sample = getSampleValue?.() ?? SAMPLE_SERIAL;\n    const items = Array.from(listContainer.querySelectorAll<HTMLElement>('.univer-numfmt-custom-item'));\n    items.forEach((el) => { el.textContent = previewOf(el.dataset['pattern'] ?? '', sample); });\n\n    const activeFmt = (getActiveCellFormat?.() ?? '').toLowerCase();\n    const matched = activeFmt && activeFmt !== 'general'\n      ? items.find((el) => (el.dataset['pattern'] ?? '').toLowerCase() === activeFmt)\n      : undefined;\n    const initial = matched ?? items[0];\n    if (!initial) return;\n    setActive(initial);\n    pendingPattern = initial.dataset['pattern'] ?? null;\n    if (!pendingPattern) return;\n    applyFormat(pendingPattern);\n    onPatternSelected?.(pendingPattern);\n  };\n\n  resync();\n\n  // Net chống race: nếu Univer set lại preview overlay NGAY SAU khi panel render (sau applyFormat ở trên),\n  // xoá lần nữa sau 1 nhịp để canvas hiển thị numfmt THẬT của model. (applyFormat đã clearPreview đồng bộ.)\n  setTimeout(() => clearPreview?.(), 60);\n\n  return { cleanup, resync };\n};\n"]}

package/esm2022/spreadsheet.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.type.js","sourceRoot":"","sources":["../../../../../libs-ui/components/spreadsheet/src/spreadsheet.type.ts"],"names":[],"mappings":"","sourcesContent":["/** Ngôn ngữ hiển thị của spreadsheet (toolbar, menu, numfmt panel). */\nexport type T_spreadsheet_locale = 'en' | 'vi';\n\nexport type T_cellFormatResult = {\n  sheet: string;\n  col: string;\n  colIndex: number;\n  header: string;\n  numfmt: string;\n};\n\nexport type T_rangeSnapshot = {\n  unitId: string;\n  subUnitId: string;\n  startRow: number;\n  endRow: number;\n  startColumn: number;\n  endColumn: number;\n};\n\n/**\n * ID của từng toolbar item trong Univer.\n * Dùng làm key trong T_toolbar_menu_config để ẩn/vô hiệu hoá item.\n * Tìm ID thực tế bằng cách inspect attribute `data-u-command` trên DOM element.\n */\nexport type T_toolbar_item_id =\n  // ── History ──────────────────────────────────────────────────────────────\n  | 'univer.command.undo'\n  | 'univer.command.redo'\n  // ── Format ───────────────────────────────────────────────────────────────\n  | 'sheet.command.set-once-format-painter'\n  | 'sheet.command.set-range-bold'\n  | 'sheet.command.set-range-italic'\n  | 'sheet.command.set-range-underline'\n  | 'sheet.command.set-range-stroke'\n  | 'sheet.command.set-range-font-family'\n  | 'sheet.command.set-range-fontsize'\n  | 'sheet.command.set-range-text-color'\n  | 'sheet.command.set-background-color'\n  | 'sheet.command.set-border-basic'\n  | 'sheet.command.set-horizontal-text-align'\n  | 'sheet.command.set-vertical-text-align'\n  | 'sheet.command.set-text-wrap'\n  | 'sheet.command.set-text-rotation'\n  // ── Merge ────────────────────────────────────────────────────────────────\n  | 'sheet.command.add-worksheet-merge'\n  | 'sheet.command.add-worksheet-merge-all'\n  | 'sheet.command.add-worksheet-merge-vertical'\n  | 'sheet.command.add-worksheet-merge-horizontal'\n  | 'sheet.command.remove-worksheet-merge'\n  // ── Number format ─────────────────────────────────────────────────────────\n  | 'sheet.command.numfmt.set.currency'\n  | 'sheet.command.numfmt.add.decimal.command'\n  | 'sheet.command.numfmt.subtract.decimal.command'\n  | 'sheet.command.numfmt.set.percent'\n  | 'sheet.operation.open.numfmt.panel'\n  // ── Formula / Function ───────────────────────────────────────────────────\n  | 'formula-ui.operation.insert-function'\n  | 'formula-ui.operation.more-functions'\n  // ── Sort ─────────────────────────────────────────────────────────────────\n  | 'sheet.menu.sheets-sort'\n  | 'sheet.command.sort-range-asc'\n  | 'sheet.command.sort-range-asc-ext'\n  | 'sheet.command.sort-range-desc'\n  | 'sheet.command.sort-range-desc-ext'\n  | 'sheet.command.sort-range-custom'\n  // ── Filter ───────────────────────────────────────────────────────────────\n  | 'sheet.command.smart-toggle-filter'\n  | 'sheet.command.clear-filter-criteria'\n  | 'sheet.command.re-calc-filter'\n  // ── Data validation ───────────────────────────────────────────────────────\n  | 'sheet.menu.data-validation'\n  | 'data-validation.operation.open-validation-panel'\n  | 'data-validation.command.addRuleAndOpen'\n  // ── Conditional formatting ────────────────────────────────────────────────\n  | 'sheet.operation.open.conditional.formatting.panel'\n  // ── Image ─────────────────────────────────────────────────────────────────\n  | 'sheet.menu.image'\n  | 'sheet.command.insert-float-image'\n  | 'sheet.command.insert-cell-image'\n  // ── Print ─────────────────────────────────────────────────────────────────\n  | 'sheet.menu.print'\n  | 'sheet.operation.print-open'\n  | 'sheet.operation.open-print-grid-sidebar'\n  // ── File (import/export) ──────────────────────────────────────────────────\n  | 'sheets-exchange-client.operation.exchange'\n  | 'exchange-client.operation.import-xlsx'\n  | 'exchange-client.operation.export-xlsx'\n  // ── Misc ──────────────────────────────────────────────────────────────────\n  | 'sheet.command.add-range-protection-from-toolbar'\n  | 'sheet.operation.toggle-comment-panel'\n  | 'sheet.operation.insert-hyper-link-toolbar'\n  | 'ui.operation.open-find-dialog'\n  | 'base-ui.operation.toggle-shortcut-panel'\n  | 'sheet.toolbar.text-to-number';\n\n/**\n * Cấu hình ẩn / vô hiệu hoá từng toolbar item.\n * @example\n * // Ẩn bold, italic; vô hiệu hoá sort\n * const config: T_toolbar_menu_config = {\n *   'sheet.command.set-range-bold':  { hidden: true },\n *   'sheet.command.set-range-italic': { hidden: true },\n *   'sheet.menu.sheets-sort':        { disabled: true },\n * };\n */\n/**\n * Compatible với Univer's MenuConfig = Record<string, MenuItemConfig>.\n * Dùng T_toolbar_item_id làm reference để biết các ID hợp lệ.\n */\nexport type T_toolbar_menu_config = Record<string, {\n  /** Ẩn hoàn toàn item khỏi toolbar */\n  hidden?: boolean;\n  /** Vô hiệu hoá item (hiển thị nhưng không click được) */\n  disabled?: boolean;\n}>;\n"]}