@js-ak/excel-toolbox 1.1.0 → 1.2.1

package/README.md

@@ -1 +1,101 @@
 # excel-toolbox
+
+![ci-cd](https://github.com/JS-AK/excel-toolbox/actions/workflows/ci-cd-master.yml/badge.svg)
+
+A lightweight toolkit for merging sheets from multiple `.xlsx` Excel files without dependencies.
+
+## Installation
+
+You can install the package via npm:
+
+```bash
+npm install @js-ak/excel-toolbox
+```
+
+## Getting Started
+
+To merge rows from multiple Excel files into one:
+
+```ts
+import fs from "node:fs";
+import { mergeSheetsToBaseFileSync } from "@js-ak/excel-toolbox";
+
+const baseFile = fs.readFileSync("base.xlsx");
+const otherFile = fs.readFileSync("data.xlsx");
+
+const resultBuffer = mergeSheetsToBaseFileSync({
+  baseFile,
+  additions: [
+    { file: otherFile, sheetIndexes: [1] }
+  ],
+  gap: 2,
+});
+
+fs.writeFileSync("output.xlsx", resultBuffer);
+```
+
+## Features
+
+- 🧩 **Merge sheets** from multiple Excel files
+- 🧼 **Clean sheet removal** — by name or index
+- 📎 **Keeps styles and merged cells**
+- 🪶 **Lightweight ZIP and XML handling**
+
+## API
+
+### `mergeSheetsToBaseFileSync(options)`
+
+#### Parameters
+
+| Name                  | Type                                                               | Description                                    |
+|-----------------------|--------------------------------------------------------------------|------------------------------------------------|
+| `baseFile`            | `Buffer`                                                           | The base Excel file.                           |
+| `additions`           | `{ file: Buffer; sheetIndexes: number[]; isBaseFile?: boolean }[]` | Files and sheet indices to merge.              |
+| `baseSheetIndex`      | `number` (default: `1`)                                            | The sheet index in the base file to append to. |
+| `gap`                 | `number` (default: `0`)                                            | Empty rows inserted between merged blocks.     |
+| `sheetNamesToRemove`  | `string[]` (default: `[]`)                                         | Sheets to remove by name.                      |
+| `sheetsToRemove`      | `number[]` (default: `[]`)                                         | Sheets to remove by index (1-based).           |
+
+#### Returns
+
+`Buffer` — the merged Excel file.
+
+### `mergeSheetsToBaseFile(options): Promise<Buffer>`
+
+Asynchronous version of `mergeSheetsToBaseFileSync`.
+
+#### Parameters
+
+Same as [`mergeSheetsToBaseFileSync`](#mergesheetstobasefilesyncoptions).
+
+#### Returns
+
+`Promise<Buffer>` — resolves with the merged Excel file.
+
+#### Example
+
+```ts
+import fs from "node:fs/promises";
+import { mergeSheetsToBaseFile } from "@js-ak/excel-toolbox";
+
+const baseFile = await fs.readFile("base.xlsx");
+const otherFile = await fs.readFile("data.xlsx");
+
+const output = await mergeSheetsToBaseFile({
+  baseFile,
+  additions: [
+    { file: otherFile, sheetIndexes: [1] }
+  ],
+  gap: 1,
+});
+
+await fs.writeFile("output.xlsx", output);
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to open an issue or submit a pull request if you have ideas or encounter bugs.
+
+## License
+
+MIT — see [LICENSE](./LICENSE) for details.

package/build/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/index.js"), exports);

package/build/cjs/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./merge-sheets-to-base-file-sync.js"), exports);
+__exportStar(require("./merge-sheets-to-base-file.js"), exports);

package/build/cjs/lib/merge-sheets-to-base-file-process.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSheetsToBaseFileProcess = void 0;
+const Utils = __importStar(require("./utils/index.js"));
+const Xml = __importStar(require("./xml/index.js"));
+/**
+ * Merges rows from other Excel files into a base Excel file.
+ *
+ * This function is a process-friendly version of mergeSheetsToBaseFile.
+ * It takes a single object with the following properties:
+ * - additions: An array of objects with two properties:
+ *   - files: A dictionary of file paths to their corresponding XML content
+ *   - sheetIndexes: The 1-based indexes of the sheet to extract rows from
+ * - baseFiles: A dictionary of file paths to their corresponding XML content
+ * - baseSheetIndex: The 1-based index of the sheet in the base file to add rows to
+ * - gap: The number of empty rows to insert between each added section
+ * - sheetNamesToRemove: The names of sheets to remove from the output file
+ * - sheetsToRemove: The 1-based indices of sheets to remove from the output file
+ *
+ * The function returns a dictionary of file paths to their corresponding XML content.
+ */
+function mergeSheetsToBaseFileProcess(data) {
+    const { additions, baseFiles, baseSheetIndex, gap, sheetNamesToRemove, sheetsToRemove, } = data;
+    const basePath = `xl/worksheets/sheet${baseSheetIndex}.xml`;
+    if (!baseFiles[basePath]) {
+        throw new Error(`Base file does not contain ${basePath}`);
+    }
+    const { lastRowNumber, mergeCells: baseMergeCells, rows: baseRows, } = Xml.extractRowsFromSheet(baseFiles[basePath]);
+    const allRows = [...baseRows];
+    const allMergeCells = [...baseMergeCells];
+    let currentRowOffset = lastRowNumber + gap;
+    for (const { files, sheetIndexes } of additions) {
+        for (const sheetIndex of sheetIndexes) {
+            const sheetPath = `xl/worksheets/sheet${sheetIndex}.xml`;
+            if (!files[sheetPath]) {
+                throw new Error(`File does not contain ${sheetPath}`);
+            }
+            const { mergeCells, rows } = Xml.extractRowsFromSheet(files[sheetPath]);
+            const shiftedRows = Xml.shiftRowIndices(rows, currentRowOffset);
+            const shiftedMergeCells = mergeCells.map(cell => {
+                const [start, end] = cell.ref.split(":");
+                if (!start || !end) {
+                    return cell;
+                }
+                const shiftedStart = Utils.shiftCellRef(start, currentRowOffset);
+                const shiftedEnd = Utils.shiftCellRef(end, currentRowOffset);
+                return { ...cell, ref: `${shiftedStart}:${shiftedEnd}` };
+            });
+            allRows.push(...shiftedRows);
+            allMergeCells.push(...shiftedMergeCells);
+            currentRowOffset += Utils.getMaxRowNumber(rows) + gap;
+        }
+    }
+    const mergedXml = Xml.buildMergedSheet(baseFiles[basePath], allRows, allMergeCells);
+    baseFiles[basePath] = mergedXml;
+    for (const sheetIndex of sheetsToRemove) {
+        const sheetPath = `xl/worksheets/sheet${sheetIndex}.xml`;
+        delete baseFiles[sheetPath];
+        if (baseFiles["xl/workbook.xml"]) {
+            baseFiles["xl/workbook.xml"] = Utils.removeSheetFromWorkbook(baseFiles["xl/workbook.xml"], sheetIndex);
+        }
+        if (baseFiles["xl/_rels/workbook.xml.rels"]) {
+            baseFiles["xl/_rels/workbook.xml.rels"] = Utils.removeSheetFromRels(baseFiles["xl/_rels/workbook.xml.rels"], sheetIndex);
+        }
+        if (baseFiles["[Content_Types].xml"]) {
+            baseFiles["[Content_Types].xml"] = Utils.removeSheetFromContentTypes(baseFiles["[Content_Types].xml"], sheetIndex);
+        }
+    }
+    for (const sheetName of sheetNamesToRemove) {
+        Utils.removeSheetByName(baseFiles, sheetName);
+    }
+}
+exports.mergeSheetsToBaseFileProcess = mergeSheetsToBaseFileProcess;

package/build/cjs/lib/merge-sheets-to-base-file-sync.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSheetsToBaseFileSync = void 0;
+const Utils = __importStar(require("./utils/index.js"));
+const Zip = __importStar(require("./zip/index.js"));
+const merge_sheets_to_base_file_process_js_1 = require("./merge-sheets-to-base-file-process.js");
+/**
+ * Merge rows from other Excel files into a base Excel file.
+ * The output is a new Excel file with the merged content.
+ *
+ * @param {Object} data
+ * @param {Object[]} data.additions
+ * @param {Buffer} data.additions.file - The file to extract rows from
+ * @param {number[]} data.additions.sheetIndexes - The 1-based indexes of the sheet to extract rows from
+ * @param {Buffer} data.baseFile - The base file to add rows to
+ * @param {number} [data.baseSheetIndex=1] - The 1-based index of the sheet in the base file to add rows to
+ * @param {number} [data.gap=0] - The number of empty rows to insert between each added section
+ * @param {string[]} [data.sheetNamesToRemove=[]] - The names of sheets to remove from the output file
+ * @param {number[]} [data.sheetsToRemove=[]] - The 1-based indices of sheets to remove from the output file
+ * @returns {Buffer} - The merged Excel file
+ */
+function mergeSheetsToBaseFileSync(data) {
+    const { additions = [], baseFile, baseSheetIndex = 1, gap = 0, sheetNamesToRemove = [], sheetsToRemove = [], } = data;
+    const baseFiles = Zip.readSync(baseFile);
+    const additionsUpdated = [];
+    for (const { file, isBaseFile, sheetIndexes } of additions) {
+        const files = (isBaseFile || Utils.isSameBuffer(file, baseFile))
+            ? baseFiles
+            : Zip.readSync(file);
+        additionsUpdated.push({
+            files,
+            sheetIndexes,
+        });
+    }
+    (0, merge_sheets_to_base_file_process_js_1.mergeSheetsToBaseFileProcess)({
+        additions: additionsUpdated,
+        baseFiles,
+        baseSheetIndex,
+        gap,
+        sheetNamesToRemove,
+        sheetsToRemove,
+    });
+    return Zip.createSync(baseFiles);
+}
+exports.mergeSheetsToBaseFileSync = mergeSheetsToBaseFileSync;

package/build/cjs/lib/merge-sheets-to-base-file.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSheetsToBaseFile = void 0;
+const Utils = __importStar(require("./utils/index.js"));
+const Zip = __importStar(require("./zip/index.js"));
+const merge_sheets_to_base_file_process_js_1 = require("./merge-sheets-to-base-file-process.js");
+/**
+ * Merge rows from other Excel files into a base Excel file.
+ * The output is a new Excel file with the merged content.
+ *
+ * @param {Object} data
+ * @param {Object[]} data.additions
+ * @param {Buffer} data.additions.file - The file to extract rows from
+ * @param {number[]} data.additions.sheetIndexes - The 1-based indexes of the sheet to extract rows from
+ * @param {Buffer} data.baseFile - The base file to add rows to
+ * @param {number} [data.baseSheetIndex=1] - The 1-based index of the sheet in the base file to add rows to
+ * @param {number} [data.gap=0] - The number of empty rows to insert between each added section
+ * @param {string[]} [data.sheetNamesToRemove=[]] - The names of sheets to remove from the output file
+ * @param {number[]} [data.sheetsToRemove=[]] - The 1-based indices of sheets to remove from the output file
+ * @returns {Promise<Buffer>} - The merged Excel file
+ */
+async function mergeSheetsToBaseFile(data) {
+    const { additions = [], baseFile, baseSheetIndex = 1, gap = 0, sheetNamesToRemove = [], sheetsToRemove = [], } = data;
+    const baseFiles = await Zip.read(baseFile);
+    const additionsUpdated = [];
+    for (const { file, isBaseFile, sheetIndexes } of additions) {
+        const files = (isBaseFile || Utils.isSameBuffer(file, baseFile))
+            ? baseFiles
+            : await Zip.read(file);
+        additionsUpdated.push({
+            files,
+            sheetIndexes,
+        });
+    }
+    (0, merge_sheets_to_base_file_process_js_1.mergeSheetsToBaseFileProcess)({
+        additions: additionsUpdated,
+        baseFiles,
+        baseSheetIndex,
+        gap,
+        sheetNamesToRemove,
+        sheetsToRemove,
+    });
+    return Zip.create(baseFiles);
+}
+exports.mergeSheetsToBaseFile = mergeSheetsToBaseFile;

package/build/cjs/lib/utils/get-max-row-number.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxRowNumber = void 0;
+/**
+ * Finds the maximum row number in a list of <row> elements.
+ * @param {string[]} rows - An array of strings, each representing a <row> element.
+ * @returns {number} - The maximum row number.
+ */
+function getMaxRowNumber(rows) {
+    let max = 0;
+    for (const row of rows) {
+        const match = row.match(/<row[^>]* r="(\d+)"/);
+        if (match) {
+            if (!match[1])
+                continue;
+            const num = parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return max;
+}
+exports.getMaxRowNumber = getMaxRowNumber;

package/build/cjs/lib/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-max-row-number.js"), exports);
+__exportStar(require("./is-same-buffer.js"), exports);
+__exportStar(require("./remove-sheet-by-name.js"), exports);
+__exportStar(require("./remove-sheet-from-content-types.js"), exports);
+__exportStar(require("./remove-sheet-from-rels.js"), exports);
+__exportStar(require("./remove-sheet-from-workbook.js"), exports);
+__exportStar(require("./shift-cell-ref.js"), exports);

package/build/cjs/lib/utils/is-same-buffer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameBuffer = void 0;
+/**
+ * Checks if two Buffers are the same
+ * @param {Buffer} buf1 - the first Buffer
+ * @param {Buffer} buf2 - the second Buffer
+ * @returns {boolean} - true if the Buffers are the same, false otherwise
+ */
+function isSameBuffer(buf1, buf2) {
+    return buf1.equals(buf2);
+}
+exports.isSameBuffer = isSameBuffer;

package/build/cjs/lib/utils/remove-sheet-by-name.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSheetByName = void 0;
+/**
+ * Removes a sheet from the Excel workbook by name.
+ * @param {Object.<string, string | Buffer>} files - The dictionary of files in the workbook.
+ * @param {string} sheetName - The name of the sheet to remove.
+ * @returns {void}
+ */
+function removeSheetByName(files, sheetName) {
+    const workbookXml = files["xl/workbook.xml"];
+    const relsXml = files["xl/_rels/workbook.xml.rels"];
+    if (!workbookXml || !relsXml) {
+        return;
+    }
+    const sheetMatch = workbookXml.match(new RegExp(`<sheet[^>]+name=["']${sheetName}["'][^>]*/>`));
+    if (!sheetMatch) {
+        return;
+    }
+    const sheetTag = sheetMatch[0];
+    const sheetIdMatch = sheetTag.match(/sheetId=["'](\d+)["']/);
+    const ridMatch = sheetTag.match(/r:id=["'](rId\d+)["']/);
+    if (!sheetIdMatch || !ridMatch) {
+        return;
+    }
+    const relId = ridMatch[1];
+    const relMatch = relsXml.match(new RegExp(`<Relationship[^>]+Id=["']${relId}["'][^>]+Target=["']([^"']+)["'][^>]*/>`));
+    if (!relMatch) {
+        return;
+    }
+    const relTag = relMatch[0];
+    const targetMatch = relTag.match(/Target=["']([^"']+)["']/);
+    if (!targetMatch) {
+        return;
+    }
+    const targetPath = `xl/${targetMatch[1]}`.replace(/\\/g, "/");
+    delete files[targetPath];
+    files["xl/workbook.xml"] = workbookXml.replace(sheetTag, "");
+    files["xl/_rels/workbook.xml.rels"] = relsXml.replace(relTag, "");
+    const contentTypes = files["[Content_Types].xml"];
+    if (contentTypes) {
+        files["[Content_Types].xml"] = contentTypes.replace(new RegExp(`<Override[^>]+PartName=["']/${targetPath}["'][^>]*/>`, "g"), "");
+    }
+}
+exports.removeSheetByName = removeSheetByName;

package/build/cjs/lib/utils/remove-sheet-from-content-types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSheetFromContentTypes = void 0;
+/**
+ * Removes the specified sheet from the Content_Types.xml file.
+ * @param {string} xml - The Content_Types.xml file contents as a string
+ * @param {number} sheetIndex - The 1-based index of the sheet to remove
+ * @returns {string} - The modified Content_Types.xml file contents
+ */
+function removeSheetFromContentTypes(xml, sheetIndex) {
+    return xml.replace(new RegExp(`<Override[^>]+PartName=["']/xl/worksheets/sheet${sheetIndex}\\.xml["'][^>]*/>`, "g"), "");
+}
+exports.removeSheetFromContentTypes = removeSheetFromContentTypes;

package/build/cjs/lib/utils/remove-sheet-from-rels.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSheetFromRels = void 0;
+/**
+ * Removes the specified sheet from the workbook relationships file (xl/_rels/workbook.xml.rels).
+ * @param {string} xml - The workbook relationships file contents as a string
+ * @param {number} sheetIndex - The 1-based index of the sheet to remove
+ * @returns {string} - The modified workbook relationships file contents
+ */
+function removeSheetFromRels(xml, sheetIndex) {
+    return xml.replace(new RegExp(`<Relationship[^>]+Target=["']worksheets/sheet${sheetIndex}\\.xml["'][^>]*/>`, "g"), "");
+}
+exports.removeSheetFromRels = removeSheetFromRels;

package/build/cjs/lib/utils/remove-sheet-from-workbook.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSheetFromWorkbook = void 0;
+/**
+ * Removes the specified sheet from the workbook (xl/workbook.xml).
+ * @param {string} xml - The workbook file contents as a string
+ * @param {number} sheetIndex - The 1-based index of the sheet to remove
+ * @returns {string} - The modified workbook file contents
+ */
+function removeSheetFromWorkbook(xml, sheetIndex) {
+    return xml.replace(new RegExp(`<sheet[^>]+sheetId=["']${sheetIndex}["'][^>]*/>`, "g"), "");
+}
+exports.removeSheetFromWorkbook = removeSheetFromWorkbook;

package/build/cjs/lib/utils/shift-cell-ref.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shiftCellRef = void 0;
+/**
+ * Shifts the row number in a cell reference by the specified number of rows.
+ * The function takes a cell reference string in the format "A1" and a row shift value.
+ * It returns the shifted cell reference string.
+ *
+ * @example
+ * // Shifts the cell reference "A1" down by 2 rows, resulting in "A3"
+ * shiftCellRef('A1', 2);
+ * @param {string} cellRef - The cell reference string to be shifted
+ * @param {number} rowShift - The number of rows to shift the reference by
+ * @returns {string} - The shifted cell reference string
+ */
+function shiftCellRef(cellRef, rowShift) {
+    const match = cellRef.match(/^([A-Z]+)(\d+)$/);
+    if (!match)
+        return cellRef;
+    const col = match[1];
+    if (!match[2])
+        return cellRef;
+    const row = parseInt(match[2], 10);
+    return `${col}${row + rowShift}`;
+}
+exports.shiftCellRef = shiftCellRef;

package/build/cjs/lib/xml/build-merged-sheet.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMergedSheet = void 0;
+/**
+ * Builds a new XML string for a merged Excel sheet by combining the original XML
+ * with merged rows and optional cell merge information.
+ *
+ * This function replaces the <sheetData> section in the original XML with the provided merged rows,
+ * and optionally adds <mergeCells> definitions after the </sheetData> tag.
+ *
+ * @param {string} originalXml - The original XML string of the Excel worksheet.
+ * @param {string[]} mergedRows - Array of XML strings representing each row in the merged sheet.
+ * @param {Object[]} [mergeCells] - Optional array of merge cell definitions.
+ *        Each object should have a 'ref' property specifying the merge range (e.g., "A1:B2").
+ * @returns {string} - The reconstructed XML string with merged content.
+ */
+function buildMergedSheet(originalXml, mergedRows, mergeCells = []) {
+    // Remove any existing <mergeCells> section from the XML
+    let xmlData = originalXml.replace(/<mergeCells[^>]*>[\s\S]*?<\/mergeCells>/g, "");
+    // Construct a new <sheetData> section with the provided rows
+    const sheetDataXml = `<sheetData>${mergedRows.join("")}</sheetData>`;
+    // Replace the existing <sheetData> section with the new one
+    xmlData = xmlData.replace(/<sheetData[^>]*>[\s\S]*?<\/sheetData>/, sheetDataXml);
+    if (mergeCells.length > 0) {
+        // Construct a new <mergeCells> section with the provided merge references
+        const mergeCellsXml = `<mergeCells count="${mergeCells.length}">${mergeCells.map(mc => `<mergeCell ref="${mc.ref}"/>`).join("")}</mergeCells>`;
+        // Insert <mergeCells> after </sheetData> and before the next XML tag
+        xmlData = xmlData.replace(/(<\/sheetData>)(\s*<)/, `$1\n${mergeCellsXml}\n$2`);
+    }
+    return xmlData;
+}
+exports.buildMergedSheet = buildMergedSheet;

package/build/cjs/lib/xml/extract-rows-from-sheet.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRowsFromSheet = void 0;
+const extract_xml_from_sheet_js_1 = require("./extract-xml-from-sheet.js");
+/**
+ * Parses a worksheet (either as Buffer or string) to extract row data,
+ * last row number, and merge cell information from Excel XML format.
+ *
+ * This function is particularly useful for processing Excel files in
+ * Open XML Spreadsheet format (.xlsx).
+ *
+ * @param {Buffer|string} sheet - The worksheet content to parse, either as:
+ *                               - Buffer (binary Excel sheet)
+ *                               - string (raw XML content)
+ * @returns {{
+ *   rows: string[],
+ *   lastRowNumber: number,
+ *   mergeCells: {ref: string}[]
+ * }} An object containing:
+ *   - rows: Array of raw XML strings for each <row> element
+ *   - lastRowNumber: Highest row number found in the sheet (1-based)
+ *   - mergeCells: Array of merged cell ranges (e.g., [{ref: "A1:B2"}])
+ * @throws {Error} If the sheetData section is not found in the XML
+ */
+function extractRowsFromSheet(sheet) {
+    // Convert Buffer input to XML string if needed
+    const xml = typeof sheet === "string" ? sheet : (0, extract_xml_from_sheet_js_1.extractXmlFromSheet)(sheet);
+    // Extract the sheetData section containing all rows
+    const sheetDataMatch = xml.match(/<sheetData[^>]*>([\s\S]*?)<\/sheetData>/);
+    if (!sheetDataMatch) {
+        throw new Error("sheetData not found in worksheet XML");
+    }
+    const sheetDataContent = sheetDataMatch[1] || "";
+    // Extract all <row> elements using regex
+    const rowMatches = [...sheetDataContent.matchAll(/<row\b[^>]*\/>|<row\b[^>]*>[\s\S]*?<\/row>/g)];
+    const rows = rowMatches.map(match => match[0]);
+    // Calculate the highest row number present in the sheet
+    const lastRowNumber = rowMatches
+        .map(match => {
+        // Extract row number from r="..." attribute (1-based)
+        const rowNumMatch = match[0].match(/r="(\d+)"/);
+        return rowNumMatch?.[1] ? parseInt(rowNumMatch[1], 10) : null;
+    })
+        .filter((row) => row !== null) // Type guard to filter out nulls
+        .reduce((max, current) => Math.max(max, current), 0); // Find maximum row number
+    // Extract all merged cell ranges from the worksheet
+    const mergeCells = [];
+    const mergeCellsMatch = xml.match(/<mergeCells[^>]*>([\s\S]*?)<\/mergeCells>/);
+    if (mergeCellsMatch) {
+        // Find all mergeCell entries with ref attributes
+        const mergeCellMatches = mergeCellsMatch[1]?.match(/<mergeCell[^>]+ref="([^"]+)"[^>]*>/g) || [];
+        mergeCellMatches.forEach(match => {
+            const refMatch = match.match(/ref="([^"]+)"/);
+            if (refMatch?.[1]) {
+                mergeCells.push({ ref: refMatch[1] }); // Store the cell range (e.g., "A1:B2")
+            }
+        });
+    }
+    return {
+        lastRowNumber,
+        mergeCells,
+        rows,
+    };
+}
+exports.extractRowsFromSheet = extractRowsFromSheet;