Files
lg-cxdash-front/src/lib/lg-export-excel.ts

830 lines
24 KiB
TypeScript

// exportDashboardExcel.ts
"use client";
import {formatRowLabel} from "@/lib/lg-dashboard";
import {DataColumn} from "@/components/lge-dashboard";
/**
* 요구사항:
* - 한 파일에 (1) PRODUCT_KEY_MAP 헤더, (2) LIFE_STAGE_COLUMNS 헤더(그룹 머지), (3) BANNER_GROUP 헤더(좌측 2칸 rowspan2 + 그룹 머지)
* - Excel export (한 시트, 섹션 간 1행 띄움)
* - 헤더 스타일:
* group: background = --lg-gray-400
* header: background = --lg-gray-600
* font: #fff, bold
*/
type HeaderStyleKey = "group" | "header";
type HeaderCell = {
text: string;
styleKey: HeaderStyleKey;
rowSpan?: number; // default 1
colSpan?: number; // default 1
align?: "left" | "center" | "right";
};
type HeaderBlock = {
headerRows: HeaderCell[][];
leafKeys: string[]; // 실제 데이터 컬럼 key 순서(좌->우)
totalCols: number;
};
export type Section<T extends Record<string, any>> = {
title?: string;
header: HeaderBlock;
rows: T[];
rowGap?: number; // default 1
// 옵션
colWidthByKey?: Record<string, number>;
numFmtByKey?: Record<string, string>; // 예: "#,##0", "0.0", "0%"
alignByKey?: Record<string, "left" | "center" | "right">;
valueGetter?: (row: T, key: string) => any;
};
type ExportOptions<T extends Record<string, any>> = {
fileName?: string;
sheetName?: string;
sections: Section<T>[];
// CSS 변수(없으면 기본값)
groupBgVar?: string; // default "--lg-gray-400"
headerBgVar?: string; // default "--lg-gray-600"
borderVar?: string; // default "--lg-gray-300"
};
/* =========================================================
* 0) Object.entries 타입 보존
* ========================================================= */
const typedEntries = <T extends Record<string, any>>(obj: T) =>
Object.entries(obj) as Array<[keyof T, T[keyof T]]>;
/* =========================================================
* 1) CSS var -> Excel ARGB (HSL 토큰 "H S% L%" 지원)
* ========================================================= */
type RGB = { r: number; g: number; b: number };
function clamp255(n: number) {
return Math.max(0, Math.min(255, Math.round(n)));
}
function hslTokenToRgb(token: string): RGB | null {
const m = token.trim().match(/^([\d.]+)\s+([\d.]+)%\s+([\d.]+)%$/);
if (!m) return null;
const h = parseFloat(m[1]) % 360;
const s = parseFloat(m[2]) / 100;
const l = parseFloat(m[3]) / 100;
const C = (1 - Math.abs(2 * l - 1)) * s;
const hh = h / 60;
const X = C * (1 - Math.abs((hh % 2) - 1));
let r1 = 0, g1 = 0, b1 = 0;
if (0 <= hh && hh < 1) [r1, g1, b1] = [C, X, 0];
else if (1 <= hh && hh < 2) [r1, g1, b1] = [X, C, 0];
else if (2 <= hh && hh < 3) [r1, g1, b1] = [0, C, X];
else if (3 <= hh && hh < 4) [r1, g1, b1] = [0, X, C];
else if (4 <= hh && hh < 5) [r1, g1, b1] = [X, 0, C];
else if (5 <= hh && hh < 6) [r1, g1, b1] = [C, 0, X];
const m2 = l - C / 2;
return {
r: clamp255((r1 + m2) * 255),
g: clamp255((g1 + m2) * 255),
b: clamp255((b1 + m2) * 255),
};
}
function hexToRgb(hex: string): RGB | null {
const v = hex.trim();
if (!v.startsWith("#")) return null;
const h = v.slice(1);
const full = h.length === 3 ? h.split("").map((c) => c + c).join("") : h;
if (full.length !== 6) return null;
return {
r: parseInt(full.slice(0, 2), 16),
g: parseInt(full.slice(2, 4), 16),
b: parseInt(full.slice(4, 6), 16),
};
}
function rgbToArgb(rgb: RGB) {
const toHex2 = (n: number) => n.toString(16).padStart(2, "0").toUpperCase();
return `FF${toHex2(rgb.r)}${toHex2(rgb.g)}${toHex2(rgb.b)}`;
}
function cssVarToExcelArgb(varName: string, fallbackHex = "#DDDDDD") {
const raw = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
const rgb = hslTokenToRgb(raw) ?? hexToRgb(raw) ?? hexToRgb(fallbackHex)!;
return rgbToArgb(rgb);
}
/* =========================================================
* 2) 헤더 렌더러 (row/col merge + 스타일)
* ========================================================= */
type StylePack = {
groupBg: string; // ARGB
headerBg: string; // ARGB
headerFont: string; // ARGB (white)
border: string; // ARGB
};
function writeMergedHeader(
ws: any, // ExcelJS.Worksheet
startRow: number,
headerRows: HeaderCell[][],
styles: StylePack
) {
const occupied = new Set<string>(); // "r,c" (0-based within header block)
const isOcc = (r: number, c: number) => occupied.has(`${r},${c}`);
const markOcc = (r: number, c: number) => occupied.add(`${r},${c}`);
const styleOf = (styleKey: HeaderStyleKey) => {
const bg = styleKey === "group" ? styles.groupBg : styles.headerBg;
return {
fill: { type: "pattern", pattern: "solid", fgColor: { argb: bg } },
font: { color: { argb: styles.headerFont }, bold: true },
alignment: { vertical: "middle", wrapText: true },
border: {
top: { style: "thin", color: { argb: styles.border } },
left: { style: "thin", color: { argb: styles.border } },
bottom: { style: "thin", color: { argb: styles.border } },
right: { style: "thin", color: { argb: styles.border } },
},
};
};
const applyStyleRange = (r1: number, c1: number, r2: number, c2: number, st: any) => {
for (let rr = r1; rr <= r2; rr++) {
const row = ws.getRow(rr);
for (let cc = c1; cc <= c2; cc++) {
const cell = row.getCell(cc);
cell.style = { ...(cell.style ?? {}), ...st };
}
}
};
for (let hr = 0; hr < headerRows.length; hr++) {
const rowCells = headerRows[hr];
let colCursor = 0;
for (const hc of rowCells) {
const rs = hc.rowSpan ?? 1;
const cs = hc.colSpan ?? 1;
while (isOcc(hr, colCursor)) colCursor++;
const topRow = startRow + hr;
const leftCol = colCursor + 1; // excel 1-based
const bottomRow = topRow + rs - 1;
const rightCol = leftCol + cs - 1;
const cell = ws.getRow(topRow).getCell(leftCol);
cell.value = hc.text;
const st = styleOf(hc.styleKey);
const horiz = hc.align ?? "center";
cell.alignment = { ...(st.alignment ?? {}), horizontal: horiz };
if (rs > 1 || cs > 1) ws.mergeCells(topRow, leftCol, bottomRow, rightCol);
applyStyleRange(topRow, leftCol, bottomRow, rightCol, {
...st,
alignment: { ...(st.alignment ?? {}), horizontal: horiz },
});
for (let r = hr; r < hr + rs; r++) {
for (let c = colCursor; c < colCursor + cs; c++) {
markOcc(r, c);
}
}
colCursor += cs;
}
ws.getRow(startRow + hr).height = 20;
}
return startRow + headerRows.length;
}
type AutoFitOpt = {
minColWidth?: number; // Excel column width units
maxColWidth?: number;
padding?: number; // width 여유(문자수 기준)
baseRowHeight?: number; // pt
maxRowHeight?: number; // pt
useCanvasMeasure?: boolean; // 브라우저에서 measureText로 더 정확하게
};
function autoFitApprox(ws: any, opt: AutoFitOpt = {}) {
const o: Required<AutoFitOpt> = {
minColWidth: opt.minColWidth ?? 8,
maxColWidth: opt.maxColWidth ?? 60,
padding: opt.padding ?? 2,
baseRowHeight: opt.baseRowHeight ?? 15,
maxRowHeight: opt.maxRowHeight ?? 120,
useCanvasMeasure: opt.useCanvasMeasure ?? true,
};
// 1) 머지 정보(내부 필드 사용: ExcelJS에서 공식 API가 없어서 근사 구현용)
const mergeMap = buildMergeMap(ws);
// 2) 컬럼 폭 먼저 계산
fitColumns(ws, mergeMap, o);
// 3) 그 다음 row height 계산 (wrapText/줄바꿈 고려)
fitRows(ws, mergeMap, o);
}
/* ---------------------------
* Column fit
* --------------------------- */
function fitColumns(ws: any, mergeMap: Map<string, MergeInfo>, o: Required<AutoFitOpt>) {
const colCount = ws.columnCount ?? (ws.columns?.length ?? 0);
const widths = new Array<number>(colCount + 1).fill(o.minColWidth);
ws.eachRow({ includeEmpty: false }, (row: any) => {
row.eachCell({ includeEmpty: false }, (cell: any, colNumber: number) => {
const text = getCellText(cell);
if (!text) return;
// merged cell의 "master"만 처리 (중복 방지)
const masterAddr = getMasterAddress(cell);
const mi = mergeMap.get(masterAddr);
if (mi && cell.address !== masterAddr) return;
const w = estimateWidth(text, cell, o); // width in "excel-char-like units"
if (mi && mi.colSpan > 1) {
// 머지된 텍스트는 span만큼 나눠서 분배(머지 텍스트 때문에 한 컬럼이 과대해지는 현상 방지)
const perCol = w / mi.colSpan;
for (let c = mi.leftCol; c <= mi.rightCol; c++) {
widths[c] = Math.max(widths[c], perCol);
}
} else {
widths[colNumber] = Math.max(widths[colNumber], w);
}
});
});
for (let c = 1; c <= colCount; c++) {
ws.getColumn(c).width = clamp(widths[c] + o.padding, o.minColWidth, o.maxColWidth);
}
}
/* ---------------------------
* Row fit
* --------------------------- */
function fitRows(ws: any, mergeMap: Map<string, MergeInfo>, o: Required<AutoFitOpt>) {
ws.eachRow({ includeEmpty: false }, (row: any) => {
let maxLines = 1;
row.eachCell({ includeEmpty: false }, (cell: any, colNumber: number) => {
const text = getCellText(cell);
if (!text) return;
const masterAddr = getMasterAddress(cell);
const mi = mergeMap.get(masterAddr);
if (mi && cell.address !== masterAddr) return;
const wrap = !!cell.alignment?.wrapText;
const explicitLines = text.split(/\r?\n/);
if (!wrap && explicitLines.length <= 1) return;
// 해당 셀의 사용 가능한 폭(머지면 합산)
const availableWidth = mi
? sumColumnWidth(ws, mi.leftCol, mi.rightCol, o)
: getColumnWidth(ws, colNumber, o);
// 각 라인 별로 "줄바꿈이 몇 줄로 늘어나는지" 근사
let cellLines = 0;
for (const line of explicitLines) {
const lineW = estimateWidth(line, cell, o);
const needed = Math.max(1, Math.ceil(lineW / Math.max(1, availableWidth)));
cellLines += needed;
}
maxLines = Math.max(maxLines, cellLines);
});
const h = clamp(o.baseRowHeight * maxLines, o.baseRowHeight, o.maxRowHeight);
row.height = Math.max(row.height, h);
});
}
/* ---------------------------
* Width estimation
* --------------------------- */
function estimateWidth(text: string, cell: any, o: Required<AutoFitOpt>) {
// 줄바꿈이면 가장 긴 라인 기준(컬럼 폭은 max line)
const lines = text.split(/\r?\n/);
const maxLine = lines.reduce((m, s) => (s.length > m.length ? s : m), "");
if (o.useCanvasMeasure && typeof document !== "undefined") {
const px = measureTextPx(maxLine, cell);
// Excel column width 단위는 폰트마다 다르지만 Calibri 11 기준으로 px/7 정도가 근사치로 많이 씀
return px / 7;
}
// canvas 못 쓰는 환경(또는 성능 이유) -> 문자폭 가중치 근사
return estimateByCharWeight(maxLine);
}
function measureTextPx(text: string, cell: any) {
const canvas = getMeasureCanvas();
const ctx = canvas.getContext("2d")!;
const fontName = cell.font?.name ?? "Calibri";
const size = cell.font?.size ?? 11;
const bold = cell.font?.bold ? "bold " : "";
ctx.font = `${bold}${size}pt ${fontName}`;
return ctx.measureText(text).width;
}
let __canvas: HTMLCanvasElement | null = null;
function getMeasureCanvas() {
if (!__canvas) __canvas = document.createElement("canvas");
return __canvas;
}
// 한글/중국어/일본어 등 wide char 가중치 + 숫자/영문 가중치
function estimateByCharWeight(s: string) {
let w = 0;
for (const ch of s) {
if (isWideChar(ch)) w += 1.7; // 한글/한자/가나 등
else if (ch === " ") w += 0.6;
else if (/[A-Z]/.test(ch)) w += 1.1;
else if (/[0-9]/.test(ch)) w += 1.0;
else w += 0.9;
}
return w;
}
function isWideChar(ch: string) {
const code = ch.codePointAt(0) ?? 0;
// 대략적인 CJK 범위
return (
(code >= 0x1100 && code <= 0x11ff) || // Hangul Jamo
(code >= 0x2e80 && code <= 0x9fff) || // CJK, radicals
(code >= 0xac00 && code <= 0xd7af) || // Hangul syllables
(code >= 0x3040 && code <= 0x30ff) || // Hiragana/Katakana
(code >= 0xff00 && code <= 0xffef) // Fullwidth forms
);
}
/* ---------------------------
* Helpers: cell text
* --------------------------- */
function getCellText(cell: any): string {
const v = cell?.value;
if (v === null || v === undefined) return "";
if (typeof v === "string") return v;
if (typeof v === "number" || typeof v === "boolean") return String(v);
if (v instanceof Date) return v.toISOString().slice(0, 10);
// ExcelJS value object types
if (typeof v === "object") {
if (v.richText) return v.richText.map((t: any) => t.text).join("");
if (v.text) return String(v.text);
if (v.formula) return v.result != null ? String(v.result) : "";
if (v.hyperlink) return String(v.text ?? v.hyperlink);
}
return String(v);
}
function getMasterAddress(cell: any) {
// merged cell이면 master가 존재
if (cell?.isMerged && cell?.master?.address) return cell.master.address;
return cell.address;
}
/* ---------------------------
* Helpers: widths
* --------------------------- */
function getColumnWidth(ws: any, col: number, o: Required<AutoFitOpt>) {
const w = ws.getColumn(col)?.width;
return typeof w === "number" ? w : o.minColWidth;
}
function sumColumnWidth(ws: any, left: number, right: number, o: Required<AutoFitOpt>) {
let sum = 0;
for (let c = left; c <= right; c++) sum += getColumnWidth(ws, c, o);
return sum;
}
function clamp(v: number, min: number, max: number) {
return Math.max(min, Math.min(max, v));
}
/* ---------------------------
* Merge map (internal _merges parsing)
* --------------------------- */
type MergeInfo = {
leftCol: number;
rightCol: number;
topRow: number;
bottomRow: number;
colSpan: number;
};
function buildMergeMap(ws: any) {
const map = new Map<string, MergeInfo>();
const merges = ws?._merges;
if (!merges) return map;
// ws._merges: Map<string, any> 형태인 경우가 많음. key가 "A1:C1" 같은 range
const keys: string[] =
merges instanceof Map ? Array.from(merges.keys()) : Object.keys(merges);
for (const range of keys) {
const parsed = parseRange(range);
if (!parsed) continue;
const masterAddr = toA1(parsed.leftCol, parsed.topRow);
map.set(masterAddr, {
...parsed,
colSpan: parsed.rightCol - parsed.leftCol + 1,
});
}
return map;
}
// "A1:C3" -> 좌표
function parseRange(range: string): Omit<MergeInfo, "colSpan"> | null {
const parts = range.split(":");
if (parts.length !== 2) return null;
const a = parseA1(parts[0]);
const b = parseA1(parts[1]);
if (!a || !b) return null;
return {
leftCol: Math.min(a.col, b.col),
rightCol: Math.max(a.col, b.col),
topRow: Math.min(a.row, b.row),
bottomRow: Math.max(a.row, b.row),
};
}
function parseA1(a1: string): { col: number; row: number } | null {
const m = a1.match(/^([A-Z]+)(\d+)$/i);
if (!m) return null;
const col = lettersToCol(m[1].toUpperCase());
const row = parseInt(m[2], 10);
return { col, row };
}
function lettersToCol(letters: string) {
let n = 0;
for (const ch of letters) {
n = n * 26 + (ch.charCodeAt(0) - 64);
}
return n;
}
function toA1(col: number, row: number) {
return `${colToLetters(col)}${row}`;
}
function colToLetters(col: number) {
let n = col;
let s = "";
while (n > 0) {
const r = (n - 1) % 26;
s = String.fromCharCode(65 + r) + s;
n = Math.floor((n - 1) / 26);
}
return s;
}
/* =========================================================
* 3) 헤더 빌더 3종
* ========================================================= */
/**
* (1) PRODUCT_KEY_MAP:
* - 첫 칸 비움
* - 나머지는 일반 헤더
*/
export function buildHeader_ProductKeyMap(
productKeyMap: Record<string, string>,
rowHeadKey = "rowLabel"
): HeaderBlock {
const entries = typedEntries(productKeyMap);
const headerRow: HeaderCell[] = [
{ text: "", styleKey: "header", align: "center" },
...entries.map(([, label]) => ({
text: String(label),
styleKey: "header" as const,
align: "center" as const,
})),
];
const leafKeys = [rowHeadKey, ...entries.map(([k]) => String(k))];
return { headerRows: [headerRow], leafKeys, totalCols: headerRow.length };
}
/**
* (2) LIFE_STAGE_COLUMNS:
* - 1행: group 머지(같은 group 연속 구간)
* - 2행: header 텍스트
*
* group 없는 컬럼은 1행에 빈 셀(그룹 스타일) 1칸 채움
*/
export type GaugeColumn = {
key: string;
header: string;
rowHead?: boolean;
group?: string;
align?: "left" | "center" | "right";
};
export function buildHeader_LifeStageColumns(cols: GaugeColumn[]): HeaderBlock {
const row1: HeaderCell[] = [];
const row2: HeaderCell[] = [];
const leafKeys = cols.map((c) => c.key);
let i = 0;
while (i < cols.length) {
const c = cols[i];
const g = c.group;
if (!g) {
row1.push({ text: "", styleKey: "group", colSpan: 1, align: "center" });
i += 1;
continue;
}
let j = i + 1;
while (j < cols.length && cols[j].group === g) j += 1;
const span = j - i;
row1.push({ text: g, styleKey: "group", colSpan: span, align: "center" });
i = j;
}
for (const c of cols) {
row2.push({ text: c.header ?? "", styleKey: "header", colSpan: 1, align: "center" });
}
return { headerRows: [row1, row2], leafKeys, totalCols: cols.length };
}
export function buildHeader_DataColumn<T>(cols: DataColumn<T>[]): HeaderBlock {
const row1: HeaderCell[] = [];
const row2: HeaderCell[] = [];
const leafKeys = cols.map((c) => String(c.key));
// 1행: 그룹 머지 / rowspan 처리
let i = 0;
while (i < cols.length) {
const c = cols[i];
const rs = c.headRowSpan ?? 1;
// (A) rowspan=2면: 1행에 header를 올리고(세로머지), 2행은 빈 칸(placeholder)
if (rs === 2) {
row1.push({
text: c.header ?? "",
styleKey: "header",
colSpan: 1,
rowSpan: 2,
align: c.align ?? "center",
});
i += 1;
continue;
}
// (B) 그룹 구간 처리
const gKey = c.groupKey ?? c.group;
if (gKey) {
let j = i + 1;
while (j < cols.length) {
const cj = cols[j];
const rsj = cj.headRowSpan ?? 1;
const gKeyJ = cj.groupKey ?? cj.group;
// rowspan=2가 섞이면 그룹 머지 끊음(안정성)
if (rsj === 2) break;
if (gKeyJ !== gKey) break;
j += 1;
}
const span = j - i;
row1.push({
text: c.group ?? "",
styleKey: "group",
colSpan: span,
align: "center",
});
// 2행: 그룹 구간의 각 컬럼 header
for (let k = i; k < j; k++) {
const ck = cols[k];
row2.push({
text: ck.header ?? "",
styleKey: "header",
colSpan: 1,
align: ck.align ?? "center",
});
}
i = j;
continue;
}
// (C) 그룹도 없고 rowspan도 아니면: 1행에 빈 group 셀 1개, 2행에 header
row1.push({
text: "",
styleKey: "group",
colSpan: 1,
align: "center",
});
row2.push({
text: c.header ?? "",
styleKey: "header",
colSpan: 1,
align: c.align ?? "center",
});
i += 1;
}
return {
headerRows: [row1, row2],
leafKeys,
totalCols: cols.length,
};
}
/**
* (3) BANNER_GROUP + BANNER_KEY_MAP:
* - A1: "" (rowspan2)
* - B1: "전체" (rowspan2) key=total
* - C1~: group(label) (colSpan = keys.ts.length)
* - 2행: 각 key의 라벨(BANNER_KEY_MAP[key])
*/
export function buildHeader_Banner<K extends string>(
bannerGroup: Record<string, { label: string; keys: readonly K[] }>,
bannerKeyMap: Record<K, string>,
rowHeadKey = "rowLabel",
totalKey = "total"
): HeaderBlock {
const groups = Object.values(bannerGroup);
const row1: HeaderCell[] = [
{ text: "", styleKey: "header", rowSpan: 2, colSpan: 1, align: "center" },
{ text: "전체", styleKey: "header", rowSpan: 2, colSpan: 1, align: "center" },
];
const row2: HeaderCell[] = [];
const leafKeys: string[] = [rowHeadKey, totalKey];
for (const g of groups) {
row1.push({ text: g.label, styleKey: "group", colSpan: g.keys.length, align: "center" });
for (const k of g.keys) {
row2.push({ text: bannerKeyMap[k] ?? k, styleKey: "header", colSpan: 1, align: "center" });
leafKeys.push(k);
}
}
const totalCols = 2 + groups.reduce((acc, g) => acc + g.keys.length, 0);
return { headerRows: [row1, row2], leafKeys, totalCols };
}
/* =========================================================
* 4) Export (one sheet, 섹션 간 1행 띄움)
* ========================================================= */
export async function exportDashboardExcel<T extends Record<string, any>>(opts: ExportOptions<T>) {
const {
fileName = "export.xlsx",
sheetName = "Export",
sections,
groupBgVar = "--lg-gray-400",
headerBgVar = "--lg-gray-600",
borderVar = "--lg-gray-300",
} = opts;
// ExcelJS import (환경에 따라 min 빌드가 더 잘 먹는 경우가 있음)
const ExcelJS = await import("exceljs");
const wb = new ExcelJS.Workbook();
const ws = wb.addWorksheet(sheetName);
const stylePack: StylePack = {
groupBg: cssVarToExcelArgb(groupBgVar, "#9CA3AF"),
headerBg: cssVarToExcelArgb(headerBgVar, "#4B5563"),
headerFont: "FFFFFFFF", // #fff
border: cssVarToExcelArgb(borderVar, "#D1D5DB"),
};
let rowCursor = 1;
for (const sec of sections) {
const gap = sec.rowGap ?? 1;
const { header, rows } = sec;
// (선택) 섹션 타이틀
if (sec.title) {
const r = ws.getRow(rowCursor);
const c = r.getCell(1);
c.value = sec.title;
c.font = { bold: true, size: 13 };
r.height = 22;
if (header.totalCols > 1) ws.mergeCells(rowCursor, 1, rowCursor, header.totalCols);
rowCursor += 1;
}
// 헤더
rowCursor = writeMergedHeader(ws, rowCursor, header.headerRows, stylePack);
// 컬럼 width
if (sec.colWidthByKey) {
header.leafKeys.forEach((k, idx) => {
const w = sec.colWidthByKey?.[k];
if (w) ws.getColumn(idx + 1).width = w;
});
} else {
// 기본: 첫 컬럼 넓게, 나머지 적당히
header.leafKeys.forEach((_k, idx) => {
ws.getColumn(idx + 1).width = idx === 0 ? 22 : 14;
});
}
const valueGetter = sec.valueGetter ?? ((r: T, k: string) => (r as any)[k]);
// 데이터
for (const row of rows) {
const excelRow = ws.getRow(rowCursor);
//const sampleRow = isSampleRow(valueGetter(row, header.leafKeys.at(0) ?? ""));
header.leafKeys.forEach((key, idx) => {
const cell = excelRow.getCell(idx + 1);
const v = valueGetter(row, key);
const isColHeader = idx === 0;
if (v === null || v === undefined || v === "") cell.value = null;
else if (typeof v === "number") cell.value = v;
else if (isColHeader) cell.value = formatRowLabel(String(v));
//else if (sampleRow) cell.value = `(${String(v)})`;
else cell.value = String(v);
const align =
sec.alignByKey?.[key] ??
(typeof v === "number" ? "right" : "left");
cell.alignment = { vertical: "middle", horizontal: align, wrapText: true };
const numFmt = sec.numFmtByKey?.[key];
if (numFmt) cell.numFmt = numFmt;
cell.border = {
top: { style: "thin", color: { argb: stylePack.border } },
left: { style: "thin", color: { argb: stylePack.border } },
bottom: { style: "thin", color: { argb: stylePack.border } },
right: { style: "thin", color: { argb: stylePack.border } },
};
if(isColHeader){
cell.font = { bold: true };
}
});
excelRow.height = 18;
rowCursor += 1;
}
rowCursor += gap;
}
autoFitApprox(ws, {
minColWidth: 8,
maxColWidth: 55,
baseRowHeight: 15,
maxRowHeight: 120,
useCanvasMeasure: true,
});
// 다운로드
const buf = await wb.xlsx.writeBuffer();
const blob = new Blob([buf], {
type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
});
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url;
a.download = fileName;
a.click();
URL.revokeObjectURL(url);
}