@vdhewei/xlsx-template-lib 1.6.5 → 1.6.7

package/dist/bin.js

@@ -4289,11 +4289,9 @@ var XlsxRender = class _XlsxRender extends Workbook {
 
 // src/bin-helpers.ts
 var path2 = __toESM(require("path"));
-var url = __toESM(require("url"));
 var import_node_fs = require("fs");
 var fs3 = __toESM(require("fs/promises"));
 var import_chalk = __toESM(require("chalk"));
-var import_meta = {};
 function generateOutputFilename(inputFile) {
   const basename3 = path2.basename(inputFile, path2.extname(inputFile));
   const timestamp = Date.now();
@@ -4304,7 +4302,7 @@ async function resolveFilePath(filePath) {
   if ((0, import_node_fs.existsSync)(resolvedPath)) {
     return resolvedPath;
   }
-  const scriptDir = path2.dirname(url.fileURLToPath(import_meta.url));
+  const scriptDir = path2.dirname(process.cwd());
   const relativePath = path2.resolve(scriptDir, filePath);
   if ((0, import_node_fs.existsSync)(relativePath)) {
     return relativePath;
@@ -4349,43 +4347,70 @@ function checkSheetAndPlaceholders(xlsx, sheetName) {
     throw new Error(`Sheet "${sheetName}" not found in Excel file`);
   }
 }
-async function addRuleToSheet(xlsxBuffer, ruleType, ruleExpr, sheetName = "export_metadata.config") {
-  const workbook = await loadWorkbook(xlsxBuffer);
+async function addRuleToSheet(workbook, ruleType, ruleExpr, sheetName = "export_metadata.config") {
   let worksheet = workbook.getWorksheet(sheetName);
   if (!worksheet) {
     worksheet = workbook.addWorksheet(sheetName);
     console.log(import_chalk.default.gray(`Created new sheet: ${sheetName}`));
   }
   let startRow = 1;
-  let currentRow = 1;
-  let columnCount = 0;
-  worksheet.eachRow((row, rowNumber) => {
-    const cell = row.getCell(1);
-    const cellValue = cell.value?.toString().trim();
-    if (!cellValue) {
-      return;
-    }
-    if (cellValue.toLowerCase() === ruleType.toLowerCase()) {
-      let col = 2;
-      while (col <= 4) {
-        const ruleCell = row.getCell(col);
-        if (ruleCell.value) {
-          columnCount++;
-        }
-        col++;
+  let currentRow = NaN;
+  if (worksheet.rowCount > 0) {
+    let stop = false;
+    worksheet.eachRow((row, rowNumber) => {
+      let columnCount = 0;
+      const cell = row.getCell(1);
+      const cellValue = cell.value;
+      if (!cellValue || stop) {
+        return;
       }
-      if (columnCount < 4) {
-        currentRow = rowNumber;
-        startRow = rowNumber;
-      } else {
-        currentRow = rowNumber + 1;
+      const value = toCellValue(cellValue).trim();
+      if (value.toLowerCase() === ruleType.toLowerCase()) {
+        for (let col = 2; col < 5; col++) {
+          const ruleCell2 = row.getCell(col);
+          if (ruleCell2.value) {
+            columnCount++;
+          } else {
+            break;
+          }
+        }
+        if (columnCount < 3) {
+          currentRow = rowNumber;
+          startRow = rowNumber;
+        } else {
+          currentRow = rowNumber + 1;
+        }
+        const cell2 = worksheet.getRow(currentRow).getCell(1);
+        if (cell2 === void 0 || cell2.value === null || cell2.value === void 0) {
+          stop = true;
+          return;
+        }
+        if (toCellValue(cell2.value).toLowerCase() !== ruleType.toLowerCase()) {
+          worksheet.insertRow(currentRow, []);
+          currentRow = currentRow + 1;
+          stop = true;
+          return;
+        }
+        if (toCellValue(cell2.value).toLowerCase() === ruleType.toLowerCase() && columnCount < 3) {
+          stop = true;
+          return;
+        }
       }
-    }
-  });
+    });
+  }
+  if (isNaN(currentRow)) {
+    currentRow = worksheet.rowCount + 1;
+    worksheet.insertRow(currentRow, []);
+  }
   if (startRow === 1 && currentRow === 1 && worksheet.rowCount === 0) {
     currentRow = 1;
   }
   let targetRow = worksheet.getRow(currentRow);
+  let lastCell = targetRow.getCell(4);
+  if (lastCell !== void 0 && lastCell.value !== void 0 && lastCell.value !== null && lastCell.value !== "") {
+    currentRow = worksheet.rowCount + 1;
+    targetRow = worksheet.insertRow(currentRow, []);
+  }
   if (!targetRow.getCell(1).value) {
     const typeCell = targetRow.getCell(1);
     typeCell.value = ruleType;
@@ -4395,23 +4420,21 @@ async function addRuleToSheet(xlsxBuffer, ruleType, ruleExpr, sheetName = "expor
   let ruleCol = 2;
   while (ruleCol <= 4) {
     const existingCell = targetRow.getCell(ruleCol);
-    if (!existingCell.value) {
+    if (existingCell === void 0 || (existingCell.value === void 0 || existingCell.value === null || existingCell.value === "")) {
       break;
     }
     ruleCol++;
   }
-  if (ruleCol <= 4) {
-    const ruleCell = targetRow.getCell(ruleCol);
-    ruleCell.value = ruleExpr;
-    ruleCell.alignment = { vertical: "middle" };
-    const column = worksheet.getColumn(ruleCol);
-    column.width = Math.max(column.width || 10, ruleExpr.length + 2);
-    console.log(import_chalk.default.gray(`Added rule ${ruleType} at row ${currentRow}, column ${ruleCol}`));
-  } else {
-    throw new Error(`Cannot add more than 4 rules for type: ${ruleType}`);
+  const ruleCell = targetRow.getCell(ruleCol);
+  ruleCell.value = ruleExpr;
+  ruleCell.alignment = { vertical: "middle", horizontal: "center" };
+  const column = worksheet.getColumn(ruleCol);
+  column.width = Math.max(column.width || 10, ruleExpr.length + 2);
+  if (currentRow === 1 && ruleCol === 2) {
+    const column2 = worksheet.getColumn(1);
+    column2.width = Math.max(column2.width || 10, ruleExpr.length + 2);
   }
-  const buffer = await workbook.xlsx.writeBuffer();
-  return Buffer.from(buffer);
+  return workbook;
 }
 async function parseRulesFromFile(filePath) {
   const resolvedPath = await resolveFilePath(filePath);
@@ -4419,6 +4442,7 @@ async function parseRulesFromFile(filePath) {
   const lines = fileContent.split("\n");
   const rules = [];
   const validTypes = ["cell", "alias", "rowCell", "mergeCell"];
+  const validRulesSet = /* @__PURE__ */ new Set();
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     if (!line || line.startsWith("#")) {
@@ -4429,17 +4453,41 @@ async function parseRulesFromFile(filePath) {
       console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Invalid format. Expected "<type> ruleExpr"`));
       continue;
     }
+    let items = [];
     const type = line.substring(0, spaceIndex).trim();
-    const rule = line.substring(spaceIndex + 1).trim();
-    if (!type || !rule) {
+    const values = line.substring(spaceIndex + 1).trim();
+    if (values.indexOf(" ") >= 0) {
+      items = values.split(" ");
+    } else if (values.indexOf("	") >= 0) {
+      items = values.split("	");
+    } else {
+      items = [values];
+    }
+    items = items.filter((item) => item.trim() !== "" && item.indexOf("=") > 0);
+    if (!type) {
       console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Invalid format. Expected "<type> ruleExpr"`));
       continue;
     }
+    if (!items || items.length === 0) {
+      continue;
+    }
     if (!validTypes.includes(type)) {
       console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Invalid rule type "${type}". Must be one of: ${validTypes.join(", ")}`));
       continue;
     }
-    rules.push({ type, rule });
+    for (const rule of items) {
+      let str = rule.trim();
+      if (str === void 0 || str === null || str === "" || str === "	") {
+        continue;
+      }
+      let key = `${type}:${str}`;
+      if (validRulesSet.has(key)) {
+        console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Duplicate rule "${str}"`));
+        continue;
+      }
+      validRulesSet.add(key);
+      rules.push({ type, rule: str });
+    }
   }
   if (rules.length === 0) {
     throw new Error("No valid rules found in file");
@@ -4447,12 +4495,12 @@ async function parseRulesFromFile(filePath) {
   return rules;
 }
 async function addMultipleRulesToSheet(xlsxBuffer, rules) {
-  let buffer = xlsxBuffer;
+  let workbook = await loadWorkbook(xlsxBuffer);
   for (const { type, rule } of rules) {
-    console.log(import_chalk.default.gray(`Adding ${type} rule: ${rule}`));
-    buffer = await addRuleToSheet(buffer, type, rule);
+    workbook = await addRuleToSheet(workbook, type, rule);
   }
-  return buffer;
+  const buffer = await workbook.xlsx.writeBuffer();
+  return Buffer.from(buffer);
 }
 
 // src/bin.ts