exceljs-lts 4.5.3 → 4.5.5

package/dist/exceljs.bare.js

@@ -286,6 +286,9 @@ const {
   slideFormula
 } = require('../utils/shared-formula');
 const Note = require('./note');
+const {
+  copyStyle
+} = require('../utils/copy-style');
 // Cell requirements
 //  Operate inside a worksheet
 //  Store and retrieve a value with a range of types: text, number, date, hyperlink, reference, formula, etc.
@@ -315,7 +318,8 @@ class Cell {
 
   // help GC by removing cyclic (and other) references
   destroy() {
-    delete this.style;
+    delete this._style;
+    delete this._styleShared;
     delete this._value;
     delete this._row;
     delete this._column;
@@ -324,38 +328,59 @@ class Cell {
 
   // =========================================================================
   // Styles stuff
+
+  // Cells loaded from a file share one style object per xf. The object is only
+  // copied when the style is handed out (cell.style), so code that mutates it
+  // in place (cell.style.fill = ...) changes this cell alone.
+  get style() {
+    if (this._styleShared) {
+      this._style = copyStyle(this._style);
+      this._styleShared = false;
+    }
+    return this._style;
+  }
+  set style(value) {
+    this._style = value;
+    this._styleShared = false;
+  }
+
+  // use a style object that other cells may share (e.g. a cached xf style)
+  _setSharedStyle(style) {
+    this._style = style;
+    this._styleShared = true;
+  }
   get numFmt() {
-    return this.style.numFmt;
+    return this._style.numFmt;
   }
   set numFmt(value) {
     this._setStyle('numFmt', value);
   }
   get font() {
-    return this.style.font;
+    return this._style.font;
   }
   set font(value) {
     this._setStyle('font', value);
   }
   get alignment() {
-    return this.style.alignment;
+    return this._style.alignment;
   }
   set alignment(value) {
     this._setStyle('alignment', value);
   }
   get border() {
-    return this.style.border;
+    return this._style.border;
   }
   set border(value) {
     this._setStyle('border', value);
   }
   get fill() {
-    return this.style.fill;
+    return this._style.fill;
   }
   set fill(value) {
     this._setStyle('fill', value);
   }
   get protection() {
-    return this.style.protection;
+    return this._style.protection;
   }
   set protection(value) {
     this._setStyle('protection', value);
@@ -363,7 +388,7 @@ class Cell {
   _setStyle(name, value) {
     // style objects can be shared (e.g. by every cell loaded with the same xf),
     // so never mutate one in place; give this cell a new object instead
-    const oldStyle = this.style;
+    const oldStyle = this._style;
     const style = {
       ...oldStyle,
       [name]: value
@@ -375,12 +400,12 @@ class Cell {
     const merges = master._mergeCount > 0 && this.worksheet._merges;
     // the streaming WorksheetWriter keeps its merges in an array
     const range = merges && (Array.isArray(merges) ? merges.find(merge => merge.top === master.row && merge.left === master.col) : merges[master.address]);
-    if (range && (master === this || master.style === oldStyle)) {
+    if (range && (master === this || master._style === oldStyle)) {
       for (let r = range.top; r <= range.bottom; r++) {
         const row = this.worksheet.findRow(r);
         for (let c = range.left; row && c <= range.right; c++) {
           const cell = row.findCell(c);
-          if (cell && cell.style === oldStyle) {
+          if (cell && cell._style === oldStyle) {
             cell.style = style;
           }
         }
@@ -588,7 +613,7 @@ class Cell {
     const {
       model
     } = this._value;
-    model.style = this.style;
+    model.style = this._style;
     if (this._comment) {
       model.comment = this._comment.model;
     }
@@ -606,7 +631,7 @@ class Cell {
       }
     }
     if (value.style) {
-      this.style = value.style;
+      this._setSharedStyle(value.style);
     } else {
       this.style = {};
     }
@@ -1263,7 +1288,7 @@ const Value = {
 };
 module.exports = Cell;
 
-},{"../utils/col-cache":20,"../utils/shared-formula":24,"../utils/under-dash":27,"./enums":7,"./note":9}],4:[function(require,module,exports){
+},{"../utils/col-cache":20,"../utils/copy-style":21,"../utils/shared-formula":24,"../utils/under-dash":27,"./enums":7,"./note":9}],4:[function(require,module,exports){
 'use strict';
 
 const _ = require('../utils/under-dash');
@@ -1544,23 +1569,116 @@ module.exports = Column;
 },{"../utils/col-cache":20,"../utils/under-dash":27,"./enums":7}],5:[function(require,module,exports){
 "use strict";
 
+const colCache = require('../utils/col-cache');
+function isRange(address) {
+  return typeof address === 'string' && address.includes(':');
+}
 class DataValidations {
   constructor(model) {
     this.model = model || {};
+    // Range-keyed entries (e.g. 'A2:A1048576', kept intact when a file is loaded) are tracked
+    // separately so per-cell add/find stay O(1) when there are none (exceljs#1842).
+    this._ranges = new Map();
+    Object.keys(this.model).forEach(key => {
+      if (isRange(key)) {
+        this._addRange(key);
+      }
+    });
   }
   add(address, validation) {
+    if (isRange(address)) {
+      this._addRange(address);
+    } else {
+      this._splitRangeAt(address);
+    }
     return this.model[address] = validation;
   }
   find(address) {
-    return this.model[address];
+    const validation = this.model[address];
+    if (validation !== undefined || isRange(address) || !this._ranges.size) {
+      return validation;
+    }
+    // fall back to range-keyed entries that contain the address
+    const key = this._findRangeKey(address);
+    return key ? this.model[key] : undefined;
   }
   remove(address) {
+    if (isRange(address)) {
+      this._ranges.delete(address);
+    } else {
+      this._splitRangeAt(address);
+    }
     this.model[address] = undefined;
   }
+  _addRange(key) {
+    if (!this._ranges.has(key)) {
+      this._ranges.set(key, colCache.decodeEx(key));
+    }
+  }
+  _findRangeKey(address) {
+    if (!this._ranges.size) {
+      return undefined;
+    }
+    const {
+      row,
+      col
+    } = colCache.decodeAddress(address);
+    for (const [key, {
+      top,
+      left,
+      bottom,
+      right
+    }] of this._ranges) {
+      if (this.model[key] && row >= top && row <= bottom && col >= left && col <= right) {
+        return key;
+      }
+    }
+    return undefined;
+  }
+
+  // If a single cell lies inside a range-keyed entry, replace that entry with up to four
+  // rectangles covering the rest of the range, so the cell can get its own validation
+  // (or none) without overlapping sqrefs.
+  _splitRangeAt(address) {
+    const key = this._findRangeKey(address);
+    if (!key) {
+      return;
+    }
+    const validation = this.model[key];
+    const {
+      row,
+      col
+    } = colCache.decodeAddress(address);
+    const {
+      top,
+      left,
+      bottom,
+      right
+    } = this._ranges.get(key);
+    delete this.model[key];
+    this._ranges.delete(key);
+    const addRect = (t, l, b, r) => {
+      if (t > b || l > r) {
+        return;
+      }
+      const tl = colCache.encodeAddress(t, l);
+      if (t === b && l === r) {
+        this.model[tl] = validation;
+      } else {
+        const rangeKey = `${tl}:${colCache.encodeAddress(b, r)}`;
+        this.model[rangeKey] = validation;
+        this._addRange(rangeKey);
+      }
+    };
+    addRect(top, left, row - 1, right); // rows above
+    addRect(row + 1, left, bottom, right); // rows below
+    addRect(row, left, row, col - 1); // left of the cell
+    addRect(row, col + 1, row, right); // right of the cell
+  }
 }
 module.exports = DataValidations;
 
-},{}],6:[function(require,module,exports){
+},{"../utils/col-cache":20}],6:[function(require,module,exports){
 'use strict';
 
 const _ = require('../utils/under-dash');
@@ -1851,6 +1969,34 @@ class Image {
     }
   }
 }
+function isFiniteNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value);
+}
+Image.validateRange = function validateRange(range) {
+  if (typeof range === 'string') {
+    let decoded;
+    try {
+      decoded = colCache.decode(range);
+    } catch (e) {
+      decoded = {};
+    }
+    const isRange = ['top', 'left', 'bottom', 'right'].every(key => isFiniteNumber(decoded[key]));
+    const isAddress = isFiniteNumber(decoded.row) && isFiniteNumber(decoded.col);
+    if (!isRange && !isAddress) {
+      throw new Error(`Invalid image range "${range}": expected a cell range such as "B2:D6"`);
+    }
+    return;
+  }
+  if (!range || typeof range !== 'object') {
+    throw new Error('Invalid image range: expected a cell range string or an object with tl and br or ext');
+  }
+  if (!range.br && !range.ext) {
+    throw new Error('Invalid image range: an object range needs either br or ext');
+  }
+  if (range.ext && typeof range.ext !== 'object') {
+    throw new Error('Invalid image range: ext must be an object with width and height');
+  }
+};
 module.exports = Image;
 
 },{"../utils/col-cache":20,"./anchor":2}],9:[function(require,module,exports){
@@ -4177,7 +4323,14 @@ class Worksheet {
 
   // =========================================================================
   // Images
+  _validateImageId(imageId) {
+    if (imageId === undefined || imageId === null || !this._workbook.getImage(imageId)) {
+      throw new Error(`Image with id ${imageId} not found. Add it with workbook.addImage() first`);
+    }
+  }
   addImage(imageId, range) {
+    this._validateImageId(imageId);
+    Image.validateRange(range);
     const model = {
       type: 'image',
       imageId,
@@ -4189,6 +4342,7 @@ class Worksheet {
     return this._media.filter(m => m.type === 'image');
   }
   addBackgroundImage(imageId) {
+    this._validateImageId(imageId);
     const model = {
       type: 'background',
       imageId
@@ -6365,6 +6519,7 @@ module.exports = {
   CoreProperties: 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties',
   ExtenderProperties: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties',
   Comments: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments',
+  Drawing: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing',
   VmlDrawing: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing',
   Table: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table',
   PivotCacheDefinition: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
@@ -9630,18 +9785,66 @@ class AutoFilterXform extends BaseXform {
         const firstAddress = getAddress(model.from);
         const secondAddress = getAddress(model.to);
         if (firstAddress && secondAddress) {
-          xmlStream.leafNode('autoFilter', {
-            ref: `${firstAddress}:${secondAddress}`
-          });
+          const ref = `${firstAddress}:${secondAddress}`;
+          if (model.exclude && model.exclude.length) {
+            // hide the filter button on the excluded columns (0 = leftmost column of the range)
+            xmlStream.openNode('autoFilter', {
+              ref
+            });
+            model.exclude.forEach(colId => {
+              xmlStream.leafNode('filterColumn', {
+                colId,
+                hiddenButton: '1'
+              });
+            });
+            xmlStream.closeNode();
+          } else {
+            xmlStream.leafNode('autoFilter', {
+              ref
+            });
+          }
         }
       }
     }
   }
   parseOpen(node) {
-    if (node.name === 'autoFilter') {
-      this.model = node.attributes.ref;
+    switch (node.name) {
+      case 'autoFilter':
+        this.ref = node.attributes.ref;
+        this.exclude = [];
+        this.model = this.ref;
+        return true;
+      case 'filterColumn':
+        {
+          const {
+            colId,
+            hiddenButton,
+            showButton
+          } = node.attributes;
+          const hidden = hiddenButton === '1' || hiddenButton === 'true' || showButton === '0' || showButton === 'false';
+          if (hidden && colId !== undefined) {
+            this.exclude.push(parseInt(colId, 10));
+          }
+          return true;
+        }
+      default:
+        return true;
     }
   }
+  parseClose(name) {
+    if (name === 'autoFilter') {
+      if (this.exclude.length && this.ref) {
+        const [from, to] = this.ref.split(':');
+        this.model = {
+          from,
+          to: to || from,
+          exclude: this.exclude
+        };
+      }
+      return false;
+    }
+    return true;
+  }
 }
 module.exports = AutoFilterXform;
 
@@ -11323,6 +11526,9 @@ const utils = require('../../../utils/utils');
 const colCache = require('../../../utils/col-cache');
 const BaseXform = require('../base-xform');
 const Range = require('../../../doc/range');
+
+// sqref ranges with more cells than this are kept as a single range-keyed model entry
+const MAX_EXPANDED_RANGE_CELLS = 1000;
 function assign(definedName, attributes, name, defaultValue) {
   const value = attributes[name];
   if (value !== undefined) {
@@ -11522,12 +11728,20 @@ class DataValidationsXform extends BaseXform {
           }
           // The four known cases: 1. E4:L9 N4:U9  2.E4 L9  3. N4:U9  4. E4
           const list = this._address.split(/\s+/g) || [];
+          // Large ranges (e.g. a whole column 'A2:A1048576') are kept as one range-keyed entry
+          // instead of being expanded into one entry per cell, which could take minutes and
+          // gigabytes (exceljs#1842). DataValidations.find() resolves them. Small ranges are
+          // still expanded so the model keeps its per-cell shape and lookups stay O(1).
           list.forEach(addr => {
             if (addr.includes(':')) {
               const range = new Range(addr);
-              range.forEachAddress(address => {
-                this.model[address] = this._dataValidation;
-              });
+              if (range.count > MAX_EXPANDED_RANGE_CELLS) {
+                this.model[range.range] = this._dataValidation;
+              } else {
+                range.forEachAddress(address => {
+                  this.model[address] = this._dataValidation;
+                });
+              }
             } else {
               this.model[addr] = this._dataValidation;
             }