exceljs-lts 4.5.1 → 4.5.3

package/lib/doc/table.js

@@ -142,8 +142,9 @@ class Table {
   }
 
   get height() {
-    // height of the table data
-    return this.table.rows.length;
+    // height of the table data. Excel needs at least one data row, so an empty table
+    // keeps one blank row on the sheet (it is not added to table.rows)
+    return Math.max(this.table.rows.length, 1);
   }
 
   get filterHeight() {
@@ -246,6 +247,15 @@ class Table {
         assignStyle(cell, table.columns[j].style);
       });
     });
+    if (!table.rows.length) {
+      // blank placeholder row so the table keeps a valid ref
+      const r = worksheet.getRow(row + count++);
+      table.columns.forEach((column, j) => {
+        const cell = r.getCell(col + j);
+        cell.value = null;
+        assignStyle(cell, column.style);
+      });
+    }
 
     if (table.totalsRow) {
       const r = worksheet.getRow(row + count++);
@@ -289,6 +299,10 @@ class Table {
         cell.value = value;
       });
     });
+    if (!table.rows.length) {
+      // skip the blank placeholder row of an empty table
+      count++;
+    }
 
     if (table.totalsRow) {
       const r = worksheet.getRow(row + count++);
@@ -315,6 +329,79 @@ class Table {
 
   set model(value) {
     this.table = value;
+    if (this.worksheet && !value.rows) {
+      // a table parsed from a file has no rows: read them from the sheet cells
+      this.loadRows();
+    }
+  }
+
+  loadRows() {
+    // rebuild ref, column names, rows and totals row formulas of a table parsed from a file
+    // from the cells inside its tableRef. This only reads the sheet, it never writes to it.
+    const {worksheet, table} = this;
+    if (table.headerRow === undefined) {
+      table.headerRow = true;
+    }
+    if (table.totalsRow === undefined) {
+      table.totalsRow = false;
+    }
+    if (!table.style) {
+      table.style = {};
+    }
+    table.columns = table.columns || [];
+    const range = colCache.decode(table.tableRef || table.ref);
+    const top = range.top || range.row;
+    const left = range.left || range.col;
+    const bottom = range.bottom || top;
+    if (!table.ref) {
+      table.ref = colCache.encodeAddress(top, left);
+    }
+    const cellValue = (r, c) => {
+      const cell = worksheet.findCell(r, c);
+      return cell ? cell.value : null;
+    };
+
+    let first = top;
+    let last = bottom;
+    if (table.headerRow) {
+      table.columns.forEach((column, j) => {
+        if (!column.name) {
+          const value = cellValue(top, left + j);
+          column.name = value === null || value === undefined ? `Column${j + 1}` : `${value}`;
+        }
+      });
+      first++;
+    }
+    if (table.totalsRow) {
+      table.columns.forEach((column, j) => {
+        const cell = worksheet.findCell(bottom, left + j);
+        if (!cell) {
+          return;
+        }
+        if (j === 0) {
+          if (column.totalsRowLabel === undefined && typeof cell.value === 'string') {
+            column.totalsRowLabel = cell.value;
+          }
+        } else if (cell.formula) {
+          if (column.totalsRowFunction === 'custom' && column.totalsRowFormula === undefined) {
+            column.totalsRowFormula = cell.formula;
+          }
+          if (column.totalsRowResult === undefined) {
+            column.totalsRowResult = cell.result;
+          }
+        }
+      });
+      last--;
+    }
+
+    table.rows = [];
+    for (let r = first; r <= last; r++) {
+      table.rows.push(table.columns.map((column, j) => cellValue(r, left + j)));
+    }
+    if (table.rows.length === 1 && table.rows[0].every(v => v === null || v === undefined)) {
+      // the blank placeholder row of an empty table
+      table.rows = [];
+    }
   }
 
   // ================================================================

package/lib/doc/worksheet.js

@@ -660,12 +660,21 @@ class Worksheet {
   }
 
   _mergeCellsInternal(dimensions, ignoreStyle) {
-    // check cells aren't already merged
-    _.each(this._merges, merge => {
-      if (merge.intersects(dimensions)) {
-        throw new Error('Cannot merge already merged cells');
+    // check cells aren't already merged. Any existing merge that intersects the range has a
+    // cell inside it that is either a merged (slave) cell or a master indexed in this._merges,
+    // so this is O(cells in range) rather than O(existing merges).
+    // Check everything before changing anything so a rejected merge leaves the sheet untouched.
+    for (let i = dimensions.top; i <= dimensions.bottom; i++) {
+      for (let j = dimensions.left; j <= dimensions.right; j++) {
+        const cell = this.findCell(i, j);
+        if (
+          (cell && cell.type === Enums.ValueType.Merge) ||
+          this._merges[colCache.encodeAddress(i, j)]
+        ) {
+          throw new Error('Cannot merge already merged cells');
+        }
       }
-    });
+    }
 
     // apply merge
     const master = this.getCell(dimensions.top, dimensions.left);
@@ -983,7 +992,7 @@ Please leave feedback at https://github.com/exceljs/exceljs/discussions/2575`
     this._media = value.media.map(medium => new Image(this, medium));
     this.sheetProtection = value.sheetProtection;
     this.tables = value.tables.reduce((tables, table) => {
-      const t = new Table();
+      const t = new Table(this);
       t.model = table;
       tables[table.name] = t;
       return tables;

package/lib/stream/xlsx/workbook-reader.js

@@ -85,67 +85,77 @@ class WorkbookReader extends EventEmitter {
     // worksheets, deferred for parsing after shared strings reading
     const waitingWorkSheets = [];
 
-    for await (const entry of iterateStream(zip)) {
-      let match;
-      let sheetNo;
-      switch (entry.path) {
-        case '_rels/.rels':
-          break;
-        case 'xl/_rels/workbook.xml.rels':
-          await this._parseRels(entry);
-          break;
-        case 'xl/workbook.xml':
-          await this._parseWorkbook(entry);
-          break;
-        case 'xl/sharedStrings.xml':
-          yield* this._parseSharedStrings(entry);
-          break;
-        case 'xl/styles.xml':
-          await this._parseStyles(entry);
-          break;
-        default:
-          if (entry.path.match(/xl\/worksheets\/sheet\d+[.]xml/)) {
-            match = entry.path.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
-            sheetNo = match[1];
-            if (this.sharedStrings && this.workbookRels) {
-              yield* this._parseWorksheet(iterateStream(entry), sheetNo);
-            } else {
-              // create temp file for each worksheet
-              await new Promise((resolve, reject) => {
-                tmp.file((err, path, fd, tempFileCleanupCallback) => {
-                  if (err) {
-                    return reject(err);
-                  }
-                  waitingWorkSheets.push({sheetNo, path, tempFileCleanupCallback});
+    try {
+      for await (const entry of iterateStream(zip)) {
+        let match;
+        let sheetNo;
+        switch (entry.path) {
+          case '_rels/.rels':
+            break;
+          case 'xl/_rels/workbook.xml.rels':
+            await this._parseRels(entry);
+            break;
+          case 'xl/workbook.xml':
+            await this._parseWorkbook(entry);
+            break;
+          case 'xl/sharedStrings.xml':
+            yield* this._parseSharedStrings(entry);
+            break;
+          case 'xl/styles.xml':
+            await this._parseStyles(entry);
+            break;
+          default:
+            if (entry.path.match(/xl\/worksheets\/sheet\d+[.]xml/)) {
+              match = entry.path.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
+              sheetNo = match[1];
+              if (this.sharedStrings && this.workbookRels) {
+                yield* this._parseWorksheet(iterateStream(entry), sheetNo);
+              } else {
+                // create temp file for each worksheet
+                await new Promise((resolve, reject) => {
+                  tmp.file((err, path, fd, tempFileCleanupCallback) => {
+                    if (err) {
+                      return reject(err);
+                    }
+                    waitingWorkSheets.push({sheetNo, path, tempFileCleanupCallback, cleanedUp: false});
 
-                  const tempStream = fs.createWriteStream(path);
-                  tempStream.on('error', reject);
-                  entry.pipe(tempStream);
-                  return tempStream.on('finish', () => {
-                    return resolve();
+                    const tempStream = fs.createWriteStream(path);
+                    tempStream.on('error', reject);
+                    entry.pipe(tempStream);
+                    return tempStream.on('finish', () => {
+                      return resolve();
+                    });
                   });
                 });
-              });
+              }
+            } else if (entry.path.match(/xl\/worksheets\/_rels\/sheet\d+[.]xml.rels/)) {
+              match = entry.path.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml.rels/);
+              sheetNo = match[1];
+              yield* this._parseHyperlinks(iterateStream(entry), sheetNo);
             }
-          } else if (entry.path.match(/xl\/worksheets\/_rels\/sheet\d+[.]xml.rels/)) {
-            match = entry.path.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml.rels/);
-            sheetNo = match[1];
-            yield* this._parseHyperlinks(iterateStream(entry), sheetNo);
-          }
-          break;
+            break;
+        }
+        entry.autodrain();
       }
-      entry.autodrain();
-    }
 
-    for (const {sheetNo, path, tempFileCleanupCallback} of waitingWorkSheets) {
-      let fileStream = fs.createReadStream(path);
-      // TODO: Remove once node v8 is deprecated
-      // Detect and upgrade old fileStreams
-      if (!fileStream[Symbol.asyncIterator]) {
-        fileStream = fileStream.pipe(new PassThrough());
+      for (const waitingWorkSheet of waitingWorkSheets) {
+        let fileStream = fs.createReadStream(waitingWorkSheet.path);
+        // TODO: Remove once node v8 is deprecated
+        // Detect and upgrade old fileStreams
+        if (!fileStream[Symbol.asyncIterator]) {
+          fileStream = fileStream.pipe(new PassThrough());
+        }
+        yield* this._parseWorksheet(fileStream, waitingWorkSheet.sheetNo);
+        waitingWorkSheet.tempFileCleanupCallback();
+        waitingWorkSheet.cleanedUp = true;
+      }
+    } finally {
+      for (const waitingWorkSheet of waitingWorkSheets) {
+        if (!waitingWorkSheet.cleanedUp) {
+          waitingWorkSheet.tempFileCleanupCallback();
+          waitingWorkSheet.cleanedUp = true;
+        }
       }
-      yield* this._parseWorksheet(fileStream, sheetNo);
-      tempFileCleanupCallback();
     }
   }
 

package/lib/xlsx/xform/book/workbook-xform.js

@@ -48,15 +48,18 @@ class WorkbookXform extends BaseXform {
     let index = 0; // sheets is sparse array - calc index manually
     model.sheets.forEach(sheet => {
       if (sheet.pageSetup && sheet.pageSetup.printArea) {
-        sheet.pageSetup.printArea.split('&&').forEach(printArea => {
-          const printAreaComponents = printArea.split(':');
-          const definedName = {
+        // Excel allows only one Print_Area per sheet; multiple areas are comma separated ranges
+        const ranges = sheet.pageSetup.printArea
+          .split('&&')
+          .filter(printArea => printArea)
+          .map(printArea => `'${sheet.name}'!${toAbsoluteRange(printArea)}`);
+        if (ranges.length) {
+          printAreas.push({
             name: '_xlnm.Print_Area',
-            ranges: [`'${sheet.name}'!$${printAreaComponents[0]}:$${printAreaComponents[1]}`],
+            ranges,
             localSheetId: index,
-          };
-          printAreas.push(definedName);
-        });
+          });
+        }
       }
 
       if (sheet.pageSetup && (sheet.pageSetup.printTitlesRow || sheet.pageSetup.printTitlesColumn)) {
@@ -197,10 +200,12 @@ class WorkbookXform extends BaseXform {
           if (!worksheet.pageSetup) {
             worksheet.pageSetup = {};
           }
-          const range = colCache.decodeEx(definedName.ranges[0]);
-          worksheet.pageSetup.printArea = worksheet.pageSetup.printArea
-            ? `${worksheet.pageSetup.printArea}&&${range.dimensions}`
-            : range.dimensions;
+          const printArea = definedName.ranges.map(fromDefinedNameRange).join('&&');
+          if (printArea) {
+            worksheet.pageSetup.printArea = worksheet.pageSetup.printArea
+              ? `${worksheet.pageSetup.printArea}&&${printArea}`
+              : printArea;
+          }
         }
       } else if (definedName.name === '_xlnm.Print_Titles') {
         worksheet = worksheets[definedName.localSheetId];
@@ -242,6 +247,32 @@ class WorkbookXform extends BaseXform {
   }
 }
 
+// convert a print area such as A1:B2, A:B, 1:3 or C3 into an absolute reference
+// ($A$1:$B$2, $A:$B, $1:$3, $C$3)
+function toAbsoluteRange(range) {
+  return range
+    .split(':')
+    .map(part => {
+      const match = part.trim().match(/^\$?([A-Za-z]*)\$?(\d*)$/);
+      if (!match) {
+        return part;
+      }
+      const [, col, row] = match;
+      return `${col ? `$${col.toUpperCase()}` : ''}${row ? `$${row}` : ''}`;
+    })
+    .join(':');
+}
+
+// convert a defined name range such as 'Sheet'!$A$1:$B$2 or Sheet!$A:$B into a print area
+// (A1:B2, A:B)
+function fromDefinedNameRange(range) {
+  const reference = range.match(/^(?:(?:'(?:[^']|'')*'|[^'!]*)!)?(.*)$/)[1];
+  if (/^\$?[A-Za-z]+\$?\d+:\$?[A-Za-z]+\$?\d+$/.test(reference)) {
+    return colCache.decodeEx(reference).dimensions;
+  }
+  return reference.replace(/\$/g, '');
+}
+
 WorkbookXform.WORKBOOK_ATTRIBUTES = {
   xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
   'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',

package/lib/xlsx/xform/sheet/cf/cf-rule-xform.js

@@ -113,6 +113,10 @@ class CfRuleXform extends CompositeXform {
         return false;
       }
     }
+    if (rule.type === 'expression' && rule.x14Id) {
+      // read from x14:cfRule, rendered by CfRuleExtXform
+      return false;
+    }
     return true;
   }
 

package/lib/xlsx/xform/sheet/cf/conditional-formattings-xform.js

@@ -1,6 +1,7 @@
 const BaseXform = require('../../base-xform');
 
 const ConditionalFormattingXform = require('./conditional-formatting-xform');
+const CfRuleXform = require('./cf-rule-xform');
 
 class ConditionalFormattingsXform extends BaseXform {
   constructor() {
@@ -29,7 +30,8 @@ class ConditionalFormattingsXform extends BaseXform {
           rule.priority = nextPriority++;
         }
 
-        if (rule.style) {
+        // ext (x14) rules write their style inline as <x14:dxf>, not as a dxfId
+        if (rule.style && CfRuleXform.isPrimitive(rule)) {
           rule.dxfId = options.styles.addDxfStyle(rule.style);
         }
       });

package/lib/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform.js

@@ -4,6 +4,8 @@ const CompositeXform = require('../../composite-xform');
 
 const DatabarExtXform = require('./databar-ext-xform');
 const IconSetExtXform = require('./icon-set-ext-xform');
+const FExtXform = require('./f-ext-xform');
+const DxfExtXform = require('../../style/dxf-ext-xform');
 
 const extIcons = {
   '3Triangles': true,
@@ -18,6 +20,8 @@ class CfRuleExtXform extends CompositeXform {
     this.map = {
       'x14:dataBar': (this.databarXform = new DatabarExtXform()),
       'x14:iconSet': (this.iconSetXform = new IconSetExtXform()),
+      'xm:f': (this.fXform = new FExtXform()),
+      'x14:dxf': (this.dxfXform = new DxfExtXform()),
     };
   }
 
@@ -35,6 +39,11 @@ class CfRuleExtXform extends CompositeXform {
         return true;
       }
     }
+    if (rule.type === 'expression') {
+      // expression rules read from x14:cfRule (e.g. formulas that reference other sheets)
+      // keep their x14Id and are written back to the extLst
+      return !!rule.x14Id;
+    }
     return false;
   }
 
@@ -56,6 +65,9 @@ class CfRuleExtXform extends CompositeXform {
       case 'iconSet':
         this.renderIconSet(xmlStream, model);
         break;
+      case 'expression':
+        this.renderExpression(xmlStream, model);
+        break;
     }
   }
 
@@ -82,6 +94,23 @@ class CfRuleExtXform extends CompositeXform {
     xmlStream.closeNode();
   }
 
+  renderExpression(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'expression',
+      priority: model.priority,
+      id: model.x14Id,
+    });
+
+    if (model.formulae && model.formulae[0]) {
+      this.fXform.render(xmlStream, model.formulae[0]);
+    }
+    if (model.style) {
+      this.dxfXform.render(xmlStream, model.style);
+    }
+
+    xmlStream.closeNode();
+  }
+
   createNewModel({attributes}) {
     return {
       type: attributes.type,
@@ -91,7 +120,19 @@ class CfRuleExtXform extends CompositeXform {
   }
 
   onParserClose(name, parser) {
-    Object.assign(this.model, parser.model);
+    switch (name) {
+      case 'xm:f':
+        this.model.formulae = this.model.formulae || [];
+        this.model.formulae.push(parser.model);
+        break;
+      case 'x14:dxf':
+        // same shape as the style of a regular cfRule (reconciled from its dxfId)
+        this.model.style = parser.model;
+        break;
+      default:
+        Object.assign(this.model, parser.model);
+        break;
+    }
   }
 }
 

package/lib/xlsx/xform/style/dxf-ext-xform.js

@@ -0,0 +1,19 @@
+const DxfXform = require('./dxf-xform');
+
+// <x14:dxf> holds a differential format inline in an x14:cfRule (extLst).
+// It has the same children as <dxf> in styles.xml.
+class DxfExtXform extends DxfXform {
+  get tag() {
+    return 'x14:dxf';
+  }
+
+  render(xmlStream, model) {
+    // a dxf read from a file holds numFmt as a NumFmtXform model ({id, formatCode})
+    if (model.numFmt && typeof model.numFmt === 'object') {
+      model = {...model, numFmtId: model.numFmt.id, numFmt: model.numFmt.formatCode};
+    }
+    super.render(xmlStream, model);
+  }
+}
+
+module.exports = DxfExtXform;

package/lib/xlsx/xform/table/table-xform.js

@@ -66,7 +66,8 @@ class TableXform extends BaseXform {
           displayName: attributes.displayName || attributes.name,
           tableRef: attributes.ref,
           totalsRow: attributes.totalsRowCount === '1',
-          headerRow: attributes.headerRowCount === '1',
+          // headerRowCount defaults to 1 and Excel usually omits it
+          headerRow: attributes.headerRowCount !== '0',
         };
         break;
       default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exceljs-lts",
-  "version": "4.5.1",
+  "version": "4.5.3",
   "description": "Maintained fork of exceljs — drop-in replacement, fixes Excel \"We found a problem with some content\" repair prompts, the TypeError crash on rich-text shared strings, and lost formula results (0, false, ''). Read and write xlsx and csv files.",
   "private": false,
   "license": "MIT",