@yuanliwei/exceljs 4.4.0

package/lib/utils/shared-formula.js

@@ -0,0 +1,44 @@
+const colCache = require('./col-cache');
+
+// const cellRefRegex = /(([a-z_\-0-9]*)!)?[$]?([a-z]+)[$]?([1-9][0-9]*)/i;
+const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
+const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
+
+function slideFormula(formula, fromCell, toCell) {
+  const offset = colCache.decode(fromCell);
+  const to = colCache.decode(toCell);
+  return formula.replace(
+    replacementCandidateRx,
+    (refMatch, sheet, sheetMaybe, addrPart, trailingParen) => {
+      if (trailingParen) {
+        return refMatch;
+      }
+      const match = CRrx.exec(addrPart);
+      if (match) {
+        const colDollar = match[1];
+        const colStr = match[2].toUpperCase();
+        const rowDollar = match[3];
+        const rowStr = match[4];
+        if (colStr.length > 3 || (colStr.length === 3 && colStr > 'XFD')) {
+          // > XFD is the highest col number in excel 2007 and beyond, so this is a named range
+          return refMatch;
+        }
+        let col = colCache.l2n(colStr);
+        let row = parseInt(rowStr, 10);
+        if (!colDollar) {
+          col += to.col - offset.col;
+        }
+        if (!rowDollar) {
+          row += to.row - offset.row;
+        }
+        const res = (sheet || '') + (colDollar || '') + colCache.n2l(col) + (rowDollar || '') + row;
+        return res;
+      }
+      return refMatch;
+    }
+  );
+}
+
+module.exports = {
+  slideFormula,
+};

package/lib/utils/shared-strings.js

@@ -0,0 +1,35 @@
+class SharedStrings {
+  constructor() {
+    this._values = [];
+    this._totalRefs = 0;
+    this._hash = Object.create(null);
+  }
+
+  get count() {
+    return this._values.length;
+  }
+
+  get values() {
+    return this._values;
+  }
+
+  get totalRefs() {
+    return this._totalRefs;
+  }
+
+  getString(index) {
+    return this._values[index];
+  }
+
+  add(value) {
+    let index = this._hash[value];
+    if (index === undefined) {
+      index = this._hash[value] = this._values.length;
+      this._values.push(value);
+    }
+    this._totalRefs++;
+    return index;
+  }
+}
+
+module.exports = SharedStrings;

package/lib/utils/stream-base64.js

@@ -0,0 +1,72 @@
+const Stream = require('readable-stream');
+
+// =============================================================================
+// StreamBase64 - A utility to convert to/from base64 stream
+// Note: does not buffer data, must be piped
+class StreamBase64 extends Stream.Duplex {
+  constructor() {
+    super();
+
+    // consuming pipe streams go here
+    this.pipes = [];
+  }
+
+  // writable
+  // event drain - if write returns false (which it won't), indicates when safe to write again.
+  // finish - end() has been called
+  // pipe(src) - pipe() has been called on readable
+  // unpipe(src) - unpipe() has been called on readable
+  // error - duh
+
+  write(/* data, encoding */) {
+    return true;
+  }
+
+  cork() {}
+
+  uncork() {}
+
+  end(/* chunk, encoding, callback */) {}
+
+  // readable
+  // event readable - some data is now available
+  // event data - switch to flowing mode - feeds chunks to handler
+  // event end - no more data
+  // event close - optional, indicates upstream close
+  // event error - duh
+  read(/* size */) {}
+
+  setEncoding(encoding) {
+    // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
+    this.encoding = encoding;
+  }
+
+  pause() {}
+
+  resume() {}
+
+  isPaused() {}
+
+  pipe(destination) {
+    // add destination to pipe list & write current buffer
+    this.pipes.push(destination);
+  }
+
+  unpipe(destination) {
+    // remove destination from pipe list
+    this.pipes = this.pipes.filter(pipe => pipe !== destination);
+  }
+
+  unshift(/* chunk */) {
+    // some numpty has read some data that's not for them and they want to put it back!
+    // Might implement this some day
+    throw new Error('Not Implemented');
+  }
+
+  wrap(/* stream */) {
+    // not implemented
+    throw new Error('Not Implemented');
+  }
+}
+
+module.exports = StreamBase64;

package/lib/utils/stream-buf.js

@@ -0,0 +1,364 @@
+/* eslint-disable max-classes-per-file */
+const Stream = require('readable-stream');
+
+const utils = require('./utils');
+const StringBuf = require('./string-buf');
+
+// =============================================================================
+// data chunks - encapsulating incoming data
+class StringChunk {
+  constructor(data, encoding) {
+    this._data = data;
+    this._encoding = encoding;
+  }
+
+  get length() {
+    return this.toBuffer().length;
+  }
+
+  // copy to target buffer
+  copy(target, targetOffset, offset, length) {
+    return this.toBuffer().copy(target, targetOffset, offset, length);
+  }
+
+  toBuffer() {
+    if (!this._buffer) {
+      this._buffer = Buffer.from(this._data, this._encoding);
+    }
+    return this._buffer;
+  }
+}
+
+class StringBufChunk {
+  constructor(data) {
+    this._data = data;
+  }
+
+  get length() {
+    return this._data.length;
+  }
+
+  // copy to target buffer
+  copy(target, targetOffset, offset, length) {
+    // eslint-disable-next-line no-underscore-dangle
+    return this._data._buf.copy(target, targetOffset, offset, length);
+  }
+
+  toBuffer() {
+    return this._data.toBuffer();
+  }
+}
+
+class BufferChunk {
+  constructor(data) {
+    this._data = data;
+  }
+
+  get length() {
+    return this._data.length;
+  }
+
+  // copy to target buffer
+  copy(target, targetOffset, offset, length) {
+    this._data.copy(target, targetOffset, offset, length);
+  }
+
+  toBuffer() {
+    return this._data;
+  }
+}
+
+// =============================================================================
+// ReadWriteBuf - a single buffer supporting simple read-write
+class ReadWriteBuf {
+  constructor(size) {
+    this.size = size;
+    // the buffer
+    this.buffer = Buffer.alloc(size);
+    // read index
+    this.iRead = 0;
+    // write index
+    this.iWrite = 0;
+  }
+
+  toBuffer() {
+    if (this.iRead === 0 && this.iWrite === this.size) {
+      return this.buffer;
+    }
+
+    const buf = Buffer.alloc(this.iWrite - this.iRead);
+    this.buffer.copy(buf, 0, this.iRead, this.iWrite);
+    return buf;
+  }
+
+  get length() {
+    return this.iWrite - this.iRead;
+  }
+
+  get eod() {
+    return this.iRead === this.iWrite;
+  }
+
+  get full() {
+    return this.iWrite === this.size;
+  }
+
+  read(size) {
+    let buf;
+    // read size bytes from buffer and return buffer
+    if (size === 0) {
+      // special case - return null if no data requested
+      return null;
+    }
+
+    if (size === undefined || size >= this.length) {
+      // if no size specified or size is at least what we have then return all of the bytes
+      buf = this.toBuffer();
+      this.iRead = this.iWrite;
+      return buf;
+    }
+
+    // otherwise return a chunk
+    buf = Buffer.alloc(size);
+    this.buffer.copy(buf, 0, this.iRead, size);
+    this.iRead += size;
+    return buf;
+  }
+
+  write(chunk, offset, length) {
+    // write as many bytes from data from optional source offset
+    // and return number of bytes written
+    const size = Math.min(length, this.size - this.iWrite);
+    chunk.copy(this.buffer, this.iWrite, offset, offset + size);
+    this.iWrite += size;
+    return size;
+  }
+}
+
+// =============================================================================
+// StreamBuf - a multi-purpose read-write stream
+//  As MemBuf - write as much data as you like. Then call toBuffer() to consolidate
+//  As StreamHub - pipe to multiple writables
+//  As readable stream - feed data into the writable part and have some other code read from it.
+
+// Note: Not sure why but StreamBuf does not like JS "class" sugar. It fails the
+// integration tests
+const StreamBuf = function(options) {
+  options = options || {};
+  this.bufSize = options.bufSize || 1024 * 1024;
+  this.buffers = [];
+
+  // batch mode fills a buffer completely before passing the data on
+  // to pipes or 'readable' event listeners
+  this.batch = options.batch || false;
+
+  this.corked = false;
+  // where in the current writable buffer we're up to
+  this.inPos = 0;
+
+  // where in the current readable buffer we've read up to
+  this.outPos = 0;
+
+  // consuming pipe streams go here
+  this.pipes = [];
+
+  // controls emit('data')
+  this.paused = false;
+
+  this.encoding = null;
+};
+
+utils.inherits(StreamBuf, Stream.Duplex, {
+  toBuffer() {
+    switch (this.buffers.length) {
+      case 0:
+        return null;
+      case 1:
+        return this.buffers[0].toBuffer();
+      default:
+        return Buffer.concat(this.buffers.map(rwBuf => rwBuf.toBuffer()));
+    }
+  },
+
+  // writable
+  // event drain - if write returns false (which it won't), indicates when safe to write again.
+  // finish - end() has been called
+  // pipe(src) - pipe() has been called on readable
+  // unpipe(src) - unpipe() has been called on readable
+  // error - duh
+
+  _getWritableBuffer() {
+    if (this.buffers.length) {
+      const last = this.buffers[this.buffers.length - 1];
+      if (!last.full) {
+        return last;
+      }
+    }
+    const buf = new ReadWriteBuf(this.bufSize);
+    this.buffers.push(buf);
+    return buf;
+  },
+
+  async _pipe(chunk) {
+    const write = function(pipe) {
+      return new Promise(resolve => {
+        pipe.write(chunk.toBuffer(), () => {
+          resolve();
+        });
+      });
+    };
+    await Promise.all(this.pipes.map(write));
+  },
+  _writeToBuffers(chunk) {
+    let inPos = 0;
+    const inLen = chunk.length;
+    while (inPos < inLen) {
+      // find writable buffer
+      const buffer = this._getWritableBuffer();
+
+      // write some data
+      inPos += buffer.write(chunk, inPos, inLen - inPos);
+    }
+  },
+  async write(data, encoding, callback) {
+    if (encoding instanceof Function) {
+      callback = encoding;
+      encoding = 'utf8';
+    }
+    callback = callback || utils.nop;
+
+    // encapsulate data into a chunk
+    let chunk;
+    if (data instanceof StringBuf) {
+      chunk = new StringBufChunk(data);
+    } else if (data instanceof Buffer) {
+      chunk = new BufferChunk(data);
+    } else if (typeof data === 'string' || data instanceof String || data instanceof ArrayBuffer) {
+      chunk = new StringChunk(data, encoding);
+    } else {
+      throw new Error('Chunk must be one of type String, Buffer or StringBuf.');
+    }
+
+    // now, do something with the chunk
+    if (this.pipes.length) {
+      if (this.batch) {
+        this._writeToBuffers(chunk);
+        while (!this.corked && this.buffers.length > 1) {
+          this._pipe(this.buffers.shift());
+        }
+      } else if (!this.corked) {
+        await this._pipe(chunk);
+        callback();
+      } else {
+        this._writeToBuffers(chunk);
+        process.nextTick(callback);
+      }
+    } else {
+      if (!this.paused) {
+        this.emit('data', chunk.toBuffer());
+      }
+
+      this._writeToBuffers(chunk);
+      this.emit('readable');
+    }
+
+    return true;
+  },
+  cork() {
+    this.corked = true;
+  },
+  _flush(/* destination */) {
+    // if we have comsumers...
+    if (this.pipes.length) {
+      // and there's stuff not written
+      while (this.buffers.length) {
+        this._pipe(this.buffers.shift());
+      }
+    }
+  },
+  uncork() {
+    this.corked = false;
+    this._flush();
+  },
+  end(chunk, encoding, callback) {
+    const writeComplete = error => {
+      if (error) {
+        callback(error);
+      } else {
+        this._flush();
+        this.pipes.forEach(pipe => {
+          pipe.end();
+        });
+        this.emit('finish');
+      }
+    };
+    if (chunk) {
+      this.write(chunk, encoding, writeComplete);
+    } else {
+      writeComplete();
+    }
+  },
+
+  // readable
+  // event readable - some data is now available
+  // event data - switch to flowing mode - feeds chunks to handler
+  // event end - no more data
+  // event close - optional, indicates upstream close
+  // event error - duh
+  read(size) {
+    let buffers;
+    // read min(buffer, size || infinity)
+    if (size) {
+      buffers = [];
+      while (size && this.buffers.length && !this.buffers[0].eod) {
+        const first = this.buffers[0];
+        const buffer = first.read(size);
+        size -= buffer.length;
+        buffers.push(buffer);
+        if (first.eod && first.full) {
+          this.buffers.shift();
+        }
+      }
+      return Buffer.concat(buffers);
+    }
+
+    buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
+    this.buffers = [];
+    return Buffer.concat(buffers);
+  },
+  setEncoding(encoding) {
+    // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
+    this.encoding = encoding;
+  },
+  pause() {
+    this.paused = true;
+  },
+  resume() {
+    this.paused = false;
+  },
+  isPaused() {
+    return !!this.paused;
+  },
+  pipe(destination) {
+    // add destination to pipe list & write current buffer
+    this.pipes.push(destination);
+    if (!this.paused && this.buffers.length) {
+      this.end();
+    }
+  },
+  unpipe(destination) {
+    // remove destination from pipe list
+    this.pipes = this.pipes.filter(pipe => pipe !== destination);
+  },
+  unshift(/* chunk */) {
+    // some numpty has read some data that's not for them and they want to put it back!
+    // Might implement this some day
+    throw new Error('Not Implemented');
+  },
+  wrap(/* stream */) {
+    // not implemented
+    throw new Error('Not Implemented');
+  },
+});
+
+module.exports = StreamBuf;

package/lib/utils/string-buf.js

@@ -0,0 +1,82 @@
+// StringBuf - a way to keep string memory operations to a minimum
+// while building the strings for the xml files
+class StringBuf {
+  constructor(options) {
+    this._buf = Buffer.alloc((options && options.size) || 16384);
+    this._encoding = (options && options.encoding) || 'utf8';
+
+    // where in the buffer we are at
+    this._inPos = 0;
+
+    // for use by toBuffer()
+    this._buffer = undefined;
+  }
+
+  get length() {
+    return this._inPos;
+  }
+
+  get capacity() {
+    return this._buf.length;
+  }
+
+  get buffer() {
+    return this._buf;
+  }
+
+  toBuffer() {
+    // return the current data as a single enclosing buffer
+    if (!this._buffer) {
+      this._buffer = Buffer.alloc(this.length);
+      this._buf.copy(this._buffer, 0, 0, this.length);
+    }
+    return this._buffer;
+  }
+
+  reset(position) {
+    position = position || 0;
+    this._buffer = undefined;
+    this._inPos = position;
+  }
+
+  _grow(min) {
+    let size = this._buf.length * 2;
+    while (size < min) {
+      size *= 2;
+    }
+    const buf = Buffer.alloc(size);
+    this._buf.copy(buf, 0);
+    this._buf = buf;
+  }
+
+  addText(text) {
+    this._buffer = undefined;
+
+    let inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
+
+    // if we've hit (or nearing capacity), grow the buf
+    while (inPos >= this._buf.length - 4) {
+      this._grow(this._inPos + text.length);
+
+      // keep trying to write until we've completely written the text
+      inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
+    }
+
+    this._inPos = inPos;
+  }
+
+  addStringBuf(inBuf) {
+    if (inBuf.length) {
+      this._buffer = undefined;
+
+      if (this.length + inBuf.length > this.capacity) {
+        this._grow(this.length + inBuf.length);
+      }
+      // eslint-disable-next-line no-underscore-dangle
+      inBuf._buf.copy(this._buf, this._inPos, 0, inBuf.length);
+      this._inPos += inBuf.length;
+    }
+  }
+}
+
+module.exports = StringBuf;

package/lib/utils/string-builder.js

@@ -0,0 +1,35 @@
+// StringBuilder - a way to keep string memory operations to a minimum
+// while building the strings for the xml files
+class StringBuilder {
+  constructor() {
+    this.reset();
+  }
+
+  get length() {
+    return this._buf.length;
+  }
+
+  toString() {
+    return this._buf.join('');
+  }
+
+  reset(position) {
+    if (position) {
+      while (this._buf.length > position) {
+        this._buf.pop();
+      }
+    } else {
+      this._buf = [];
+    }
+  }
+
+  addText(text) {
+    this._buf.push(text);
+  }
+
+  addStringBuf(inBuf) {
+    this._buf.push(inBuf.toString());
+  }
+}
+
+module.exports = StringBuilder;

package/lib/utils/stuttered-pipe.js

@@ -0,0 +1,67 @@
+const events = require('events');
+
+// =============================================================================
+// StutteredPipe - Used to slow down streaming so GC can get a look in
+class StutteredPipe extends events.EventEmitter {
+  constructor(readable, writable, options) {
+    super();
+
+    options = options || {};
+
+    this.readable = readable;
+    this.writable = writable;
+    this.bufSize = options.bufSize || 16384;
+    this.autoPause = options.autoPause || false;
+
+    this.paused = false;
+    this.eod = false;
+    this.scheduled = null;
+
+    readable.on('end', () => {
+      this.eod = true;
+      writable.end();
+    });
+
+    // need to have some way to communicate speed of stream
+    // back from the consumer
+    readable.on('readable', () => {
+      if (!this.paused) {
+        this.resume();
+      }
+    });
+    this._schedule();
+  }
+
+  pause() {
+    this.paused = true;
+  }
+
+  resume() {
+    if (!this.eod) {
+      if (this.scheduled !== null) {
+        clearImmediate(this.scheduled);
+      }
+      this._schedule();
+    }
+  }
+
+  _schedule() {
+    this.scheduled = setImmediate(() => {
+      this.scheduled = null;
+      if (!this.eod && !this.paused) {
+        const data = this.readable.read(this.bufSize);
+        if (data && data.length) {
+          this.writable.write(data);
+
+          if (!this.paused && !this.autoPause) {
+            this._schedule();
+          }
+        } else if (!this.paused) {
+          this._schedule();
+        }
+      }
+    });
+  }
+}
+
+module.exports = StutteredPipe;