xlkit 1.0.5 → 1.2.0

package/dist/index.cjs

@@ -0,0 +1,1183 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  read: () => read,
+  xlkit: () => xlkit
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/engine/writer.ts
+var import_exceljs = __toESM(require("exceljs"), 1);
+
+// src/engine/sheet-writer.ts
+var import_node_fs = require("fs");
+
+// src/styles/converter.ts
+function convertToExcelJSStyle(style) {
+  if (!style) return {};
+  const excelStyle = {};
+  if (hasFont(style)) {
+    excelStyle.font = convertFont(style);
+  }
+  if (style.fill) {
+    excelStyle.fill = convertFill(style.fill);
+  }
+  if (style.align) {
+    excelStyle.alignment = convertAlignment(style.align);
+  }
+  if (style.format) {
+    excelStyle.numFmt = convertNumFmt(style);
+  }
+  return excelStyle;
+}
+function hasFont(style) {
+  return !!(style.fontFamily || style.fontSize || style.bold || style.italic || style.underline || style.strike || style.color);
+}
+function convertFont(style) {
+  const font = {};
+  if (style.fontFamily) font.name = style.fontFamily;
+  if (style.fontSize) font.size = style.fontSize;
+  if (style.bold) font.bold = true;
+  if (style.italic) font.italic = true;
+  if (style.underline) font.underline = true;
+  if (style.strike) font.strike = true;
+  if (style.color) {
+    font.color = { argb: hexToArgb(style.color) };
+  }
+  return font;
+}
+function convertFill(hexColor) {
+  return {
+    type: "pattern",
+    pattern: "solid",
+    fgColor: { argb: hexToArgb(hexColor) }
+  };
+}
+function convertAlignment(align) {
+  return {
+    horizontal: align,
+    vertical: "middle"
+    // 垂直方向は常に中央
+  };
+}
+function convertNumFmt(style) {
+  if (style.format === "date") {
+    return "yyyy-mm-dd";
+  }
+  if (style.format === "number") {
+    const { decimalPlaces = 0, thousandsSeparator = false } = style;
+    const base = thousandsSeparator ? "#,##0" : "#0";
+    if (decimalPlaces > 0) {
+      const decimals = "0".repeat(decimalPlaces);
+      return `${base}.${decimals}`;
+    }
+    return base;
+  }
+  return "@";
+}
+function hexToArgb(hex) {
+  return `FF${hex.slice(1).toUpperCase()}`;
+}
+function argbToHex(argb) {
+  return `#${argb.slice(2).toUpperCase()}`;
+}
+function createBorder(style, color) {
+  const border = { style };
+  if (color) {
+    border.color = { argb: hexToArgb(color) };
+  }
+  return border;
+}
+function createHeaderCellBorder(border, position, isLastHeaderRow) {
+  if (!border) return void 0;
+  const { outline, headerBody, headerInner, borderColor } = border;
+  const borders = {};
+  if (position.isFirstRow && outline) {
+    borders.top = createBorder(outline, borderColor);
+  } else if (!position.isFirstRow && headerInner) {
+    borders.top = createBorder(headerInner, borderColor);
+  }
+  if (isLastHeaderRow && headerBody) {
+    borders.bottom = createBorder(headerBody, borderColor);
+  } else if (!isLastHeaderRow && headerInner) {
+    borders.bottom = createBorder(headerInner, borderColor);
+  }
+  if (position.isFirstCol && outline) {
+    borders.left = createBorder(outline, borderColor);
+  } else if (!position.isFirstCol && headerInner) {
+    borders.left = createBorder(headerInner, borderColor);
+  }
+  if (position.isLastCol && outline) {
+    borders.right = createBorder(outline, borderColor);
+  } else if (!position.isLastCol && headerInner) {
+    borders.right = createBorder(headerInner, borderColor);
+  }
+  return Object.keys(borders).length > 0 ? borders : void 0;
+}
+function createBodyCellBorder(border, position) {
+  if (!border) return void 0;
+  const { outline, bodyInner, borderColor } = border;
+  const borders = {};
+  if (!position.isFirstRow && bodyInner) {
+    borders.top = createBorder(bodyInner, borderColor);
+  }
+  if (position.isLastRow && outline) {
+    borders.bottom = createBorder(outline, borderColor);
+  } else if (!position.isLastRow && bodyInner) {
+    borders.bottom = createBorder(bodyInner, borderColor);
+  }
+  if (position.isFirstCol && outline) {
+    borders.left = createBorder(outline, borderColor);
+  } else if (!position.isFirstCol && bodyInner) {
+    borders.left = createBorder(bodyInner, borderColor);
+  }
+  if (position.isLastCol && outline) {
+    borders.right = createBorder(outline, borderColor);
+  } else if (!position.isLastCol && bodyInner) {
+    borders.right = createBorder(bodyInner, borderColor);
+  }
+  return Object.keys(borders).length > 0 ? borders : void 0;
+}
+
+// src/styles/merger.ts
+function mergeStyles(...styles) {
+  const merged = {};
+  for (const style of styles) {
+    if (!style) continue;
+    Object.assign(merged, style);
+  }
+  return merged;
+}
+
+// src/styles/presets.ts
+var TABLE_PRESETS = {
+  basic: {
+    style: {
+      header: {
+        bold: true,
+        fill: "#4472C4",
+        // Excelの標準青
+        color: "#FFFFFF",
+        // 白文字
+        align: "center"
+      },
+      body: {
+        align: "left"
+      }
+    },
+    border: {
+      outline: "thin",
+      headerBody: "thin",
+      headerInner: "thin",
+      bodyInner: "thin"
+    }
+  },
+  minimal: {
+    style: {
+      header: {
+        bold: true,
+        align: "left"
+      },
+      body: {
+        align: "left"
+      }
+    }
+    // 罫線なし
+  },
+  striped: {
+    style: {
+      header: {
+        bold: true,
+        fill: "#4472C4",
+        color: "#FFFFFF",
+        align: "center"
+      },
+      body: {
+        align: "left"
+      }
+    },
+    border: {
+      outline: "thin",
+      headerBody: "thin",
+      headerInner: "thin",
+      bodyInner: "thin"
+    },
+    stripedRowColor: "#F2F2F2"
+    // 奇数行の背景色（薄いグレー）
+  }
+};
+function getPreset(presetName) {
+  const preset = TABLE_PRESETS[presetName];
+  if (!preset) {
+    throw new Error(`\u4E0D\u660E\u306A\u30D7\u30EA\u30BB\u30C3\u30C8\u540D: ${presetName}`);
+  }
+  return preset;
+}
+
+// src/types/text.ts
+function isStyledCell(input) {
+  return typeof input === "object" && "value" in input;
+}
+
+// src/types/workbook.ts
+function isTableBlock(block) {
+  return block.type === "table";
+}
+function isTextBlock(block) {
+  return block.type === "text";
+}
+function isImageBlock(block) {
+  return block.type === "image";
+}
+function isSpaceBlock(block) {
+  return block.type === "space";
+}
+
+// src/types/column.ts
+function isLeafColumn(column) {
+  return "key" in column;
+}
+
+// src/utils/column.ts
+function flattenColumns(columns) {
+  const result = [];
+  for (const col of columns) {
+    if (isLeafColumn(col)) {
+      result.push(col);
+    } else {
+      result.push(...flattenColumns(col.children));
+    }
+  }
+  return result;
+}
+function getColumnSpan(column) {
+  if (isLeafColumn(column)) {
+    return 1;
+  }
+  return column.children.reduce((sum, child) => sum + getColumnSpan(child), 0);
+}
+function getHeaderDepth(columns) {
+  let maxDepth = 1;
+  for (const col of columns) {
+    if (!isLeafColumn(col)) {
+      const childDepth = getHeaderDepth(col.children);
+      maxDepth = Math.max(maxDepth, childDepth + 1);
+    }
+  }
+  return maxDepth;
+}
+function buildHeaderRows(columns, totalDepth) {
+  const rows = Array.from({ length: totalDepth }, () => []);
+  function processColumn(col, currentDepth) {
+    if (isLeafColumn(col)) {
+      const rowSpan = totalDepth - currentDepth;
+      rows[currentDepth].push({
+        label: col.label,
+        colSpan: 1,
+        rowSpan,
+        style: col.style
+      });
+    } else {
+      const colSpan = getColumnSpan(col);
+      rows[currentDepth].push({
+        label: col.label,
+        colSpan,
+        rowSpan: 1,
+        style: void 0
+        // ParentColumnにはstyleがない
+      });
+      for (const child of col.children) {
+        processColumn(child, currentDepth + 1);
+      }
+    }
+  }
+  for (const col of columns) {
+    processColumn(col, 0);
+  }
+  return rows;
+}
+
+// src/engine/cell-writer.ts
+function writeCell(cell, value, style) {
+  cell.value = value;
+  if (style) {
+    const excelStyle = convertToExcelJSStyle(style);
+    cell.style = excelStyle;
+  }
+}
+function mergeCells(worksheet, startRow, startCol, endRow, endCol) {
+  worksheet.mergeCells(startRow, startCol, endRow, endCol);
+}
+function getOrCreateRow(worksheet, rowNumber) {
+  const row = worksheet.getRow(rowNumber);
+  return row;
+}
+
+// src/engine/width-calculator.ts
+function calculateTextWidth(text) {
+  let width = 0;
+  for (const char of text) {
+    const code = char.charCodeAt(0);
+    const isFullWidth = code >= 12288 && code <= 40959 || // CJK統合漢字、ひらがな、カタカナ
+    code >= 65280 && code <= 65519;
+    width += isFullWidth ? 2 : 1;
+  }
+  return width;
+}
+function calculateCellWidth(value) {
+  if (value == null) return 0;
+  if (typeof value === "string") {
+    const textWidth = calculateTextWidth(value);
+    return textWidth * 1.2 + 2;
+  }
+  if (typeof value === "number") {
+    const str = value.toString();
+    return calculateTextWidth(str) * 1.2 + 2;
+  }
+  if (typeof value === "boolean") {
+    return 6;
+  }
+  return 10;
+}
+function calculateColumnWidths(columnCount, rows) {
+  const widths = new Array(columnCount).fill(0);
+  for (const row of rows) {
+    for (let col = 0; col < columnCount; col++) {
+      const cellValue = row[col];
+      const width = calculateCellWidth(cellValue);
+      if (width > widths[col]) {
+        widths[col] = width;
+      }
+    }
+  }
+  return widths.map((w) => Math.max(8, Math.min(w, 60)));
+}
+
+// src/engine/sheet-writer.ts
+var SheetWriter = class {
+  constructor(workbook, worksheet) {
+    this.workbook = workbook;
+    this.worksheet = worksheet;
+    this.currentRow = 1;
+  }
+  /**
+   * SheetStateを書き込む
+   */
+  writeSheet(sheetState) {
+    for (const block of sheetState.blocks) {
+      this.writeBlock(block);
+    }
+  }
+  /**
+   * ブロックを書き込む
+   */
+  writeBlock(block) {
+    if (isTableBlock(block)) {
+      this.writeTable(block.options);
+    } else if (isTextBlock(block)) {
+      this.writeText(block.input);
+    } else if (isImageBlock(block)) {
+      this.writeImage(block.options);
+    } else if (isSpaceBlock(block)) {
+      this.writeSpace(block.lines);
+    }
+  }
+  /**
+   * テーブルを書き込む
+   */
+  writeTable(options) {
+    const { preset, columns, data, autoWidth, style, border, mergeSameValues } = options;
+    const presetConfig = preset ? getPreset(preset) : void 0;
+    const effectiveBorder = border ?? presetConfig?.border;
+    const leafColumns = flattenColumns(columns);
+    if (autoWidth !== false && autoWidth !== void 0) {
+      this.setColumnWidths(leafColumns, data, autoWidth);
+    }
+    const headerDepth = getHeaderDepth(columns);
+    this.writeHeaders(columns, leafColumns, headerDepth, presetConfig, style, effectiveBorder);
+    this.writeDataRows(leafColumns, data, presetConfig, style, effectiveBorder, mergeSameValues);
+  }
+  /**
+   * ヘッダーを書き込む（マルチヘッダー対応）
+   */
+  writeHeaders(columns, leafColumns, depth, presetConfig, tableStyle, borderStyle) {
+    const headerRows = buildHeaderRows(columns, depth);
+    const colCount = leafColumns.length;
+    const startRow = this.currentRow;
+    for (let rowIndex = 0; rowIndex < headerRows.length; rowIndex++) {
+      const headerRow = headerRows[rowIndex];
+      const row = getOrCreateRow(this.worksheet, this.currentRow);
+      let colPosition = 1;
+      for (const headerCell of headerRow) {
+        const cell = row.getCell(colPosition);
+        const finalStyle = mergeStyles(presetConfig?.style?.header, headerCell.style, tableStyle?.header);
+        writeCell(cell, headerCell.label, finalStyle);
+        if (headerCell.colSpan > 1 || headerCell.rowSpan > 1) {
+          const endCol = colPosition + headerCell.colSpan - 1;
+          const endRow = this.currentRow + headerCell.rowSpan - 1;
+          mergeCells(this.worksheet, this.currentRow, colPosition, endRow, endCol);
+        }
+        const isLastHeaderRow = rowIndex === headerRows.length - 1;
+        const border = createHeaderCellBorder(
+          borderStyle,
+          {
+            isFirstCol: colPosition === 1,
+            isLastCol: colPosition + headerCell.colSpan - 1 === colCount,
+            isFirstRow: rowIndex === 0
+          },
+          isLastHeaderRow && headerCell.rowSpan === 1
+        );
+        if (border) {
+          cell.border = border;
+        }
+        colPosition += headerCell.colSpan;
+      }
+      this.currentRow++;
+    }
+    this.applyMergedCellBorders(headerRows, startRow, colCount, borderStyle);
+  }
+  /**
+   * マージされたセルの罫線を補完
+   */
+  applyMergedCellBorders(headerRows, startRow, colCount, borderStyle) {
+    const totalRows = headerRows.length;
+    for (let rowIndex = 0; rowIndex < totalRows; rowIndex++) {
+      const headerRow = headerRows[rowIndex];
+      let colPosition = 1;
+      for (const headerCell of headerRow) {
+        if (headerCell.rowSpan > 1) {
+          const lastRowOfMerge = startRow + rowIndex + headerCell.rowSpan - 1;
+          const isLastHeaderRow = lastRowOfMerge === startRow + totalRows - 1;
+          for (let col = colPosition; col < colPosition + headerCell.colSpan; col++) {
+            const targetCell = this.worksheet.getCell(lastRowOfMerge, col);
+            const border = createHeaderCellBorder(
+              borderStyle,
+              {
+                isFirstCol: col === 1,
+                isLastCol: col === colCount,
+                isFirstRow: false
+                // マージ補完は常に2行目以降
+              },
+              isLastHeaderRow
+            );
+            if (border) {
+              delete border.top;
+              if (Object.keys(border).length > 0) {
+                targetCell.border = { ...targetCell.border, ...border };
+              }
+            }
+          }
+        }
+        colPosition += headerCell.colSpan;
+      }
+    }
+  }
+  /**
+   * データ行を書き込む
+   */
+  writeDataRows(leafColumns, data, presetConfig, tableStyle, borderStyle, tableMergeSameValues) {
+    const dataLength = data.length;
+    const colCount = leafColumns.length;
+    const startRow = this.currentRow;
+    const mergeRanges = leafColumns.map(() => []);
+    const shouldMergeColumn = leafColumns.map((col) => tableMergeSameValues === true || col.mergeSameValues === true);
+    const currentMergeStart = leafColumns.map(() => 0);
+    const currentMergeValue = leafColumns.map(() => void 0);
+    for (const [rowIndex, rowData] of data.entries()) {
+      const row = getOrCreateRow(this.worksheet, this.currentRow);
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        const col = leafColumns[colIndex];
+        const cell = row.getCell(colIndex + 1);
+        const value = rowData[col.key];
+        const baseStyle = presetConfig?.style?.body;
+        const columnStyle = col.style;
+        const rowStyle = tableStyle?.body;
+        const cellStyle = rowData._style?.[col.key];
+        const isOddRow = rowIndex % 2 === 0;
+        const stripeStyle = isOddRow && presetConfig?.stripedRowColor ? { fill: presetConfig.stripedRowColor } : void 0;
+        const finalStyle = mergeStyles(baseStyle, stripeStyle, columnStyle, rowStyle, cellStyle);
+        writeCell(cell, value, finalStyle);
+        const border = createBodyCellBorder(borderStyle, {
+          isFirstCol: colIndex === 0,
+          isLastCol: colIndex === colCount - 1,
+          isFirstRow: rowIndex === 0,
+          isLastRow: rowIndex === dataLength - 1
+        });
+        if (border) {
+          cell.border = border;
+        }
+        if (shouldMergeColumn[colIndex]) {
+          if (rowIndex === 0) {
+            currentMergeStart[colIndex] = rowIndex;
+            currentMergeValue[colIndex] = value;
+          } else if (value !== currentMergeValue[colIndex]) {
+            const start = currentMergeStart[colIndex];
+            if (rowIndex - 1 > start) {
+              mergeRanges[colIndex].push({
+                colIndex,
+                startRow: startRow + start,
+                endRow: startRow + rowIndex - 1
+              });
+            }
+            currentMergeStart[colIndex] = rowIndex;
+            currentMergeValue[colIndex] = value;
+          }
+          if (rowIndex === dataLength - 1) {
+            const start = currentMergeStart[colIndex];
+            if (rowIndex > start) {
+              mergeRanges[colIndex].push({
+                colIndex,
+                startRow: startRow + start,
+                endRow: startRow + rowIndex
+              });
+            }
+          }
+        }
+      }
+      this.currentRow++;
+    }
+    for (let colIndex = 0; colIndex < colCount; colIndex++) {
+      for (const range of mergeRanges[colIndex]) {
+        mergeCells(this.worksheet, range.startRow, colIndex + 1, range.endRow, colIndex + 1);
+      }
+    }
+    this.applyBodyMergedCellBorders(mergeRanges, colCount, dataLength, startRow, borderStyle);
+  }
+  /**
+   * ボディのマージセルの罫線を補完
+   * マージ範囲内の各行に「見える辺のみ」罫線を設定
+   */
+  applyBodyMergedCellBorders(mergeRanges, colCount, dataLength, dataStartRow, borderStyle) {
+    if (!borderStyle) return;
+    for (let colIndex = 0; colIndex < colCount; colIndex++) {
+      for (const range of mergeRanges[colIndex]) {
+        for (let row = range.startRow; row <= range.endRow; row++) {
+          const cell = this.worksheet.getCell(row, colIndex + 1);
+          const isLastRow = row === dataStartRow + dataLength - 1;
+          const isFirstRowOfMerge = row === range.startRow;
+          const isLastRowOfMerge = row === range.endRow;
+          const border = createBodyCellBorder(borderStyle, {
+            isFirstCol: colIndex === 0,
+            isLastCol: colIndex === colCount - 1,
+            isFirstRow: row === dataStartRow,
+            isLastRow
+          });
+          if (border) {
+            if (!isFirstRowOfMerge) {
+              delete border.top;
+            }
+            if (!isLastRowOfMerge) {
+              delete border.bottom;
+            }
+            if (Object.keys(border).length > 0) {
+              cell.border = { ...cell.border, ...border };
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 列幅を設定
+   */
+  setColumnWidths(leafColumns, data, autoWidth) {
+    const rows = [];
+    if (autoWidth === "all") {
+      rows.push(leafColumns.map((col) => col.label));
+    }
+    for (const rowData of data) {
+      const row = leafColumns.map((col) => rowData[col.key]);
+      rows.push(row);
+    }
+    const widths = calculateColumnWidths(leafColumns.length, rows);
+    for (let i = 0; i < widths.length; i++) {
+      this.worksheet.getColumn(i + 1).width = widths[i];
+    }
+  }
+  /**
+   * テキストを書き込む
+   */
+  writeText(input) {
+    const row = getOrCreateRow(this.worksheet, this.currentRow);
+    const cell = row.getCell(1);
+    if (isStyledCell(input)) {
+      writeCell(cell, input.value, input.style);
+    } else {
+      writeCell(cell, input);
+    }
+    this.currentRow++;
+  }
+  /**
+   * 画像を書き込む
+   */
+  writeImage(options) {
+    const { source, width = 100, height = 100, row, col = 0 } = options;
+    let imageBuffer;
+    if (Buffer.isBuffer(source)) {
+      imageBuffer = source;
+    } else {
+      imageBuffer = (0, import_node_fs.readFileSync)(source);
+    }
+    const imageId = this.workbook.addImage({
+      buffer: imageBuffer,
+      extension: "png"
+    });
+    const targetRow = row ?? this.currentRow;
+    this.worksheet.addImage(imageId, {
+      tl: { col, row: targetRow - 1 },
+      // 0-indexedに変換
+      ext: { width, height }
+    });
+    const rowsToSkip = Math.ceil(height / 20);
+    this.currentRow += rowsToSkip;
+  }
+  /**
+   * 空行を追加
+   */
+  writeSpace(lines) {
+    this.currentRow += lines;
+  }
+};
+
+// src/engine/writer.ts
+async function writeWorkbook(state) {
+  const workbook = new import_exceljs.default.Workbook();
+  for (const sheetState of state.sheets) {
+    const worksheet = workbook.addWorksheet(sheetState.name);
+    const writer = new SheetWriter(workbook, worksheet);
+    writer.writeSheet(sheetState);
+  }
+  return workbook;
+}
+
+// src/output/browser.ts
+var BrowserOutput = class {
+  constructor(workbook) {
+    this.workbook = workbook;
+  }
+  /**
+   * ブラウザでダウンロード
+   */
+  async download(fileName) {
+    const buffer = await this.workbook.xlsx.writeBuffer();
+    const blob = new Blob([buffer], {
+      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);
+  }
+};
+
+// src/output/node.ts
+var NodeOutput = class {
+  constructor(workbook) {
+    this.workbook = workbook;
+  }
+  /**
+   * ファイルに保存
+   */
+  async saveToFile(filePath) {
+    await this.workbook.xlsx.writeFile(filePath);
+  }
+  /**
+   * Bufferとして取得
+   */
+  async toBuffer() {
+    const buffer = await this.workbook.xlsx.writeBuffer();
+    return Buffer.from(buffer);
+  }
+};
+
+// src/validators/excel-constraints.ts
+var EXCEL_LIMITS = {
+  SHEET_NAME_MAX_LENGTH: 31,
+  SHEET_NAME_INVALID_CHARS: [":", "\\", "/", "?", "*", "[", "]"],
+  MAX_ROWS: 1048576,
+  MAX_COLUMNS: 16384
+};
+function validateSheetName(name) {
+  if (name.length > EXCEL_LIMITS.SHEET_NAME_MAX_LENGTH) {
+    throw new Error("\u30B7\u30FC\u30C8\u540D\u306F31\u6587\u5B57\u4EE5\u5185\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
+  }
+  for (const char of EXCEL_LIMITS.SHEET_NAME_INVALID_CHARS) {
+    if (name.includes(char)) {
+      throw new Error(`\u30B7\u30FC\u30C8\u540D\u306B\u4F7F\u7528\u3067\u304D\u306A\u3044\u6587\u5B57\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u3059: ${char}`);
+    }
+  }
+  if (name.trim().length === 0) {
+    throw new Error("\u30B7\u30FC\u30C8\u540D\u3092\u7A7A\u767D\u306E\u307F\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093");
+  }
+}
+function validateDataSize(rowCount, columnCount) {
+  if (rowCount > EXCEL_LIMITS.MAX_ROWS) {
+    throw new Error("\u30C7\u30FC\u30BF\u884C\u6570\u304CExcel\u306E\u4E0A\u9650(1,048,576\u884C)\u3092\u8D85\u3048\u3066\u3044\u307E\u3059");
+  }
+  if (columnCount > EXCEL_LIMITS.MAX_COLUMNS) {
+    throw new Error("\u5217\u6570\u304CExcel\u306E\u4E0A\u9650(16,384\u5217)\u3092\u8D85\u3048\u3066\u3044\u307E\u3059");
+  }
+}
+
+// src/schemas/image.ts
+var import_zod = require("zod");
+var imageSourceSchema = import_zod.z.union([
+  import_zod.z.instanceof(Buffer),
+  import_zod.z.string().url(),
+  // URL形式
+  import_zod.z.string().min(1)
+  // ファイルパス
+]);
+var imageOptionsSchema = import_zod.z.object({
+  source: imageSourceSchema,
+  width: import_zod.z.number().positive().optional(),
+  height: import_zod.z.number().positive().optional(),
+  row: import_zod.z.number().int().min(0).optional(),
+  col: import_zod.z.number().int().min(0).optional()
+}).strict();
+
+// src/schemas/table.ts
+var import_zod4 = require("zod");
+
+// src/schemas/column.ts
+var import_zod3 = require("zod");
+
+// src/schemas/style.ts
+var import_zod2 = require("zod");
+var hexColorRegex = /^#[\dA-Fa-f]{6}$/;
+var hexColorSchema = import_zod2.z.string().regex(hexColorRegex, "\u8272\u306F #RRGGBB \u5F62\u5F0F\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044");
+var alignTypeSchema = import_zod2.z.enum(["left", "center", "right"]);
+var formatTypeSchema = import_zod2.z.enum(["string", "number", "date"]);
+var cellStyleSchema = import_zod2.z.object({
+  fontFamily: import_zod2.z.string().optional(),
+  fontSize: import_zod2.z.number().positive().optional(),
+  bold: import_zod2.z.boolean().optional(),
+  italic: import_zod2.z.boolean().optional(),
+  underline: import_zod2.z.boolean().optional(),
+  strike: import_zod2.z.boolean().optional(),
+  color: hexColorSchema.optional(),
+  fill: hexColorSchema.optional(),
+  align: alignTypeSchema.optional(),
+  format: formatTypeSchema.optional(),
+  decimalPlaces: import_zod2.z.number().int().min(0).optional(),
+  thousandsSeparator: import_zod2.z.boolean().optional()
+}).strict();
+var lineStyleSchema = import_zod2.z.enum(["thin", "medium", "thick", "dotted", "dashed", "double"]);
+var borderStyleSchema = import_zod2.z.object({
+  outline: lineStyleSchema.optional(),
+  headerBody: lineStyleSchema.optional(),
+  headerInner: lineStyleSchema.optional(),
+  bodyInner: lineStyleSchema.optional(),
+  borderColor: hexColorSchema.optional()
+}).strict();
+var tableStyleSchema = import_zod2.z.object({
+  header: cellStyleSchema.optional(),
+  body: cellStyleSchema.optional()
+}).strict();
+
+// src/schemas/column.ts
+var leafColumnSchema = import_zod3.z.object({
+  key: import_zod3.z.string(),
+  label: import_zod3.z.string(),
+  style: cellStyleSchema.optional(),
+  mergeSameValues: import_zod3.z.boolean().optional()
+}).strict();
+var parentColumnSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    label: import_zod3.z.string(),
+    children: import_zod3.z.array(columnSchema).nonempty()
+  }).strict()
+);
+var columnSchema = import_zod3.z.union([leafColumnSchema, parentColumnSchema]);
+var columnsSchema = import_zod3.z.array(columnSchema).nonempty();
+
+// src/schemas/table.ts
+var tablePresetSchema = import_zod4.z.enum(["basic", "minimal", "striped"]);
+var autoWidthOptionSchema = import_zod4.z.union([import_zod4.z.enum(["all", "body"]), import_zod4.z.literal(false)]);
+var tableOptionsSchema = import_zod4.z.object({
+  preset: tablePresetSchema.optional(),
+  columns: columnsSchema,
+  data: import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.any())),
+  autoWidth: autoWidthOptionSchema.optional(),
+  mergeSameValues: import_zod4.z.boolean().optional(),
+  style: tableStyleSchema.optional(),
+  border: borderStyleSchema.optional(),
+  conditionalStyle: import_zod4.z.function().optional()
+}).strict();
+
+// src/schemas/text.ts
+var import_zod5 = require("zod");
+var styledCellSchema = import_zod5.z.object({
+  value: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.number(), import_zod5.z.boolean()]),
+  style: cellStyleSchema.optional()
+}).strict();
+var textInputSchema = import_zod5.z.union([import_zod5.z.string(), styledCellSchema]);
+
+// src/core/sheet-builder.ts
+var SheetBuilder = class {
+  constructor(workbook, sheetState) {
+    this.workbook = workbook;
+    this.sheetState = sheetState;
+  }
+  /**
+   * テーブルを追加
+   */
+  table(options) {
+    const result = tableOptionsSchema.safeParse(options);
+    if (!result.success) {
+      throw new Error(`Invalid table options: ${result.error.message}`);
+    }
+    const leafColumns = flattenColumns(options.columns);
+    validateDataSize(options.data.length, leafColumns.length);
+    const block = { type: "table", options };
+    this.sheetState.blocks.push(block);
+    return this;
+  }
+  /**
+   * テキストを追加
+   */
+  text(input) {
+    const result = textInputSchema.safeParse(input);
+    if (!result.success) {
+      throw new Error(`Invalid text input: ${result.error.message}`);
+    }
+    const block = { type: "text", input };
+    this.sheetState.blocks.push(block);
+    return this;
+  }
+  /**
+   * 画像を追加
+   */
+  image(options) {
+    const result = imageOptionsSchema.safeParse(options);
+    if (!result.success) {
+      throw new Error(`Invalid image options: ${result.error.message}`);
+    }
+    const block = { type: "image", options };
+    this.sheetState.blocks.push(block);
+    return this;
+  }
+  /**
+   * 空行を追加
+   */
+  space(lines = 1) {
+    if (lines <= 0) {
+      throw new Error("space() \u306E\u5F15\u6570\u306F\u6B63\u306E\u6574\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
+    }
+    const block = { type: "space", lines };
+    this.sheetState.blocks.push(block);
+    return this;
+  }
+  /**
+   * 新しいシートを追加（WorkbookBuilderに委譲）
+   */
+  sheet(name) {
+    return this.workbook.sheet(name);
+  }
+  /**
+   * ブラウザ向け出力オブジェクトを取得（WorkbookBuilderに委譲）
+   */
+  getBrowser() {
+    return this.workbook.getBrowser();
+  }
+  /**
+   * Node.js向け出力オブジェクトを取得（WorkbookBuilderに委譲）
+   */
+  getNode() {
+    return this.workbook.getNode();
+  }
+};
+
+// src/core/workbook-builder.ts
+var WorkbookBuilder = class {
+  constructor() {
+    this.state = {
+      sheets: []
+    };
+  }
+  /**
+   * シートを追加する
+   * @param name シート名（省略時は "Sheet1", "Sheet2", ...）
+   */
+  sheet(name) {
+    const sheetName = name ?? `Sheet${this.state.sheets.length + 1}`;
+    validateSheetName(sheetName);
+    if (this.state.sheets.some((s) => s.name === sheetName)) {
+      throw new Error(`\u30B7\u30FC\u30C8\u540D "${sheetName}" \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059`);
+    }
+    const sheetState = { name: sheetName, blocks: [] };
+    this.state.sheets.push(sheetState);
+    return new SheetBuilder(this, sheetState);
+  }
+  /**
+   * ワークブックの状態を取得（内部用）
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * ブラウザ向け出力オブジェクトを取得
+   */
+  async getBrowser() {
+    const workbook = await writeWorkbook(this.state);
+    return new BrowserOutput(workbook);
+  }
+  /**
+   * Node.js向け出力オブジェクトを取得
+   */
+  async getNode() {
+    const workbook = await writeWorkbook(this.state);
+    return new NodeOutput(workbook);
+  }
+};
+function xlkit() {
+  return new WorkbookBuilder();
+}
+
+// src/reader/workbook-reader.ts
+var import_exceljs2 = __toESM(require("exceljs"), 1);
+
+// src/reader/cell-reader.ts
+var CellReader = class {
+  constructor(cell) {
+    this.cell = cell;
+  }
+  /**
+   * セルの値を取得
+   */
+  get value() {
+    const val = this.cell.value;
+    if (val && typeof val === "object" && "richText" in val) {
+      return val.richText.map((rt) => rt.text).join("");
+    }
+    if (val && typeof val === "object" && "result" in val) {
+      const result = val.result;
+      if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
+        return result;
+      }
+      return null;
+    }
+    if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+      return val;
+    }
+    return null;
+  }
+  /**
+   * セルのスタイルを取得
+   */
+  get style() {
+    const cellStyle = this.cell.style;
+    if (!cellStyle) return void 0;
+    const xlkitStyle = {};
+    if (cellStyle.font) {
+      if (cellStyle.font.name) xlkitStyle.fontFamily = cellStyle.font.name;
+      if (cellStyle.font.size) xlkitStyle.fontSize = cellStyle.font.size;
+      if (cellStyle.font.bold) xlkitStyle.bold = true;
+      if (cellStyle.font.italic) xlkitStyle.italic = true;
+      if (cellStyle.font.underline) xlkitStyle.underline = true;
+      if (cellStyle.font.strike) xlkitStyle.strike = true;
+      if (cellStyle.font.color?.argb) {
+        xlkitStyle.color = argbToHex(cellStyle.font.color.argb);
+      }
+    }
+    if (cellStyle.fill?.type === "pattern" && cellStyle.fill.fgColor?.argb) {
+      xlkitStyle.fill = argbToHex(cellStyle.fill.fgColor.argb);
+    }
+    if (cellStyle.alignment?.horizontal) {
+      const align = cellStyle.alignment.horizontal;
+      if (align === "left" || align === "center" || align === "right") {
+        xlkitStyle.align = align;
+      }
+    }
+    if (cellStyle.numFmt) {
+      xlkitStyle.format = this.detectFormat(cellStyle.numFmt);
+      if (xlkitStyle.format === "number") {
+        const match = cellStyle.numFmt.match(/\.(\d+)/);
+        if (match) {
+          xlkitStyle.decimalPlaces = match[1].length;
+        }
+        if (cellStyle.numFmt.includes(",")) {
+          xlkitStyle.thousandsSeparator = true;
+        }
+      }
+    }
+    return Object.keys(xlkitStyle).length > 0 ? xlkitStyle : void 0;
+  }
+  /**
+   * 数値フォーマットから format を検出
+   */
+  detectFormat(numFmt) {
+    if (numFmt === "@") return "string";
+    if (numFmt.includes("yyyy") || numFmt.includes("mm") || numFmt.includes("dd")) {
+      return "date";
+    }
+    if (numFmt.includes("#") || numFmt.includes("0")) {
+      return "number";
+    }
+    return void 0;
+  }
+  /**
+   * セルの罫線情報を取得
+   */
+  get border() {
+    const cellBorder = this.cell.border;
+    if (!cellBorder) return void 0;
+    const result = {};
+    if (cellBorder.top?.style) {
+      result.top = {
+        style: cellBorder.top.style,
+        color: cellBorder.top.color?.argb ? argbToHex(cellBorder.top.color.argb) : void 0
+      };
+    }
+    if (cellBorder.bottom?.style) {
+      result.bottom = {
+        style: cellBorder.bottom.style,
+        color: cellBorder.bottom.color?.argb ? argbToHex(cellBorder.bottom.color.argb) : void 0
+      };
+    }
+    if (cellBorder.left?.style) {
+      result.left = {
+        style: cellBorder.left.style,
+        color: cellBorder.left.color?.argb ? argbToHex(cellBorder.left.color.argb) : void 0
+      };
+    }
+    if (cellBorder.right?.style) {
+      result.right = {
+        style: cellBorder.right.style,
+        color: cellBorder.right.color?.argb ? argbToHex(cellBorder.right.color.argb) : void 0
+      };
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+};
+
+// src/reader/sheet-reader.ts
+var SheetReader = class {
+  constructor(worksheet) {
+    this.worksheet = worksheet;
+  }
+  /**
+   * シート名を取得
+   */
+  get name() {
+    return this.worksheet.name;
+  }
+  /**
+   * セルを取得（A1形式）
+   */
+  cell(address) {
+    const cell = this.worksheet.getCell(address);
+    return new CellReader(cell);
+  }
+  /**
+   * セルを取得（行・列番号）
+   */
+  cellAt(row, col) {
+    const cell = this.worksheet.getCell(row, col);
+    return new CellReader(cell);
+  }
+  /**
+   * マージされたセル範囲を取得
+   */
+  get mergedCells() {
+    const model = this.worksheet.model;
+    return model?.merges || [];
+  }
+  /**
+   * 行数を取得
+   */
+  get rowCount() {
+    return this.worksheet.rowCount;
+  }
+  /**
+   * 列数を取得
+   */
+  get columnCount() {
+    return this.worksheet.columnCount;
+  }
+};
+
+// src/reader/workbook-reader.ts
+var WorkbookReader = class {
+  constructor(workbook) {
+    this.workbook = workbook;
+  }
+  /**
+   * シート名の配列を取得
+   */
+  get sheetNames() {
+    return this.workbook.worksheets.map((ws) => ws.name);
+  }
+  /**
+   * シートを取得（名前指定）
+   */
+  sheet(name) {
+    const worksheet = this.workbook.getWorksheet(name);
+    if (!worksheet) {
+      throw new Error(`\u30B7\u30FC\u30C8 "${name}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+    }
+    return new SheetReader(worksheet);
+  }
+  /**
+   * シートを取得（インデックス指定、0-indexed）
+   */
+  sheetAt(index) {
+    const worksheet = this.workbook.worksheets[index];
+    if (!worksheet) {
+      throw new Error(`\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9 ${index} \u306E\u30B7\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+    }
+    return new SheetReader(worksheet);
+  }
+  /**
+   * シート数を取得
+   */
+  get sheetCount() {
+    return this.workbook.worksheets.length;
+  }
+};
+async function read(source) {
+  const workbook = new import_exceljs2.default.Workbook();
+  if (Buffer.isBuffer(source)) {
+    await workbook.xlsx.load(source);
+  } else {
+    await workbook.xlsx.readFile(source);
+  }
+  return new WorkbookReader(workbook);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  read,
+  xlkit
+});
+//# sourceMappingURL=index.cjs.map