Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

exceljs-fork-pg

Package Overview
Dependencies
Maintainers
1
Versions
3
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

exceljs-fork-pg

Excel Workbook Manager - Read and Write xlsx and csv Files.

  • 3.8.1
  • latest
  • Source
  • npm
  • Socket score

Version published
Weekly downloads
29
decreased by-49.12%
Maintainers
1
Weekly downloads
 
Created
Source

ExcelJS

Build Status Code Quality: Javascript Total Alerts

Read, manipulate and write spreadsheet data and styles to XLSX and JSON.

Reverse engineered from Excel spreadsheet files as a project.

Translations

Installation

npm install exceljs

New Features!

Contributions

Contributions are very welcome! It helps me know what features are desired or what bugs are causing the most pain.

I have just one request; If you submit a pull request for a bugfix, please add a unit-test or integration-test (in the spec folder) that catches the problem. Even a PR that just has a failing test is fine - I can analyse what the test is doing and fix the code from that.

Note: Please try to avoid modifying the package version in a PR. Versions are updated on release and any change will most likely result in merge collisions.

To be clear, all contributions added to this library will be included in the library's MIT licence.

Contents

Importing

const ExcelJS = require('exceljs');

ES5 Imports

To use the ES5 transpiled code, use the dist/es5 path.

const ExcelJS = require('exceljs/dist/es5');

Note: The ES5 build has an implicit dependency on a number of polyfills which are no longer explicitly added by exceljs. You will need to add "core-js" and "regenerator-runtime" to your dependencies and include the following requires in your code before the exceljs import:

// polyfills required by exceljs
require('core-js/modules/es.promise');
require('core-js/modules/es.object.assign');
require('core-js/modules/es.object.keys');
require('regenerator-runtime/runtime');

// ...

const ExcelJS = require('exceljs/dist/es5');

Browserify

ExcelJS publishes two browserified bundles inside the dist/ folder:

One with implicit dependencies on core-js polyfills...

<script src="https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/6.26.0/polyfill.js"></script>
<script src="exceljs.js"></script>

And one without...

<script src="--your-project's-pollyfills-here--"></script>
<script src="exceljs.bare.js"></script>

Interface

Create a Workbook

var workbook = new Excel.Workbook();

Set Workbook Properties

workbook.creator = 'Me';
workbook.lastModifiedBy = 'Her';
workbook.created = new Date(1985, 8, 30);
workbook.modified = new Date();
workbook.lastPrinted = new Date(2016, 9, 27);
// Set workbook dates to 1904 date system
workbook.properties.date1904 = true;

Set Calculation Properties

// Force workbook calculation on load
workbook.calcProperties.fullCalcOnLoad = true;

Workbook Views

The Workbook views controls how many separate windows Excel will open when viewing the workbook.

workbook.views = [
  {
    x: 0, y: 0, width: 10000, height: 20000,
    firstSheet: 0, activeTab: 1, visibility: 'visible'
  }
]

Add a Worksheet

var sheet = workbook.addWorksheet('My Sheet');

Use the second parameter of the addWorksheet function to specify options for the worksheet.

For Example:

// create a sheet with red tab colour
var sheet = workbook.addWorksheet('My Sheet', {properties:{tabColor:{argb:'FFC0000'}}});

// create a sheet where the grid lines are hidden
var sheet = workbook.addWorksheet('My Sheet', {views: [{showGridLines: false}]});

// create a sheet with the first row and column frozen
var sheet = workbook.addWorksheet('My Sheet', {views:[{state: 'frozen', xSplit: 1, ySplit:1}]});

Remove a Worksheet

Use the worksheet id to remove the sheet from workbook.

For Example:

// Create a worksheet
var sheet = workbook.addWorksheet('My Sheet');

// Remove the worksheet using worksheet id
workbook.removeWorksheet(sheet.id)

Access Worksheets

// Iterate over all sheets
// Note: workbook.worksheets.forEach will still work but this is better
workbook.eachSheet(function(worksheet, sheetId) {
  // ...
});

// fetch sheet by name
var worksheet = workbook.getWorksheet('My Sheet');

// fetch sheet by id
var worksheet = workbook.getWorksheet(1);

Worksheet State

// make worksheet visible
worksheet.state = 'visible';

// make worksheet hidden
worksheet.state = 'hidden';

// make worksheet hidden from 'hide/unhide' dialog
worksheet.state = 'veryHidden';

Worksheet Properties

Worksheets support a property bucket to allow control over some features of the worksheet.

// create new sheet with properties
var worksheet = workbook.addWorksheet('sheet', {properties:{tabColor:{argb:'FF00FF00'}}});

// create a new sheet writer with properties
var worksheetWriter = workbookWriter.addSheet('sheet', {properties:{outlineLevelCol:1}});

// adjust properties afterwards (not supported by worksheet-writer)
worksheet.properties.outlineLevelCol = 2;
worksheet.properties.defaultRowHeight = 15;

Supported Properties

NameDefaultDescription
tabColorundefinedColor of the tabs
outlineLevelCol0The worksheet column outline level
outlineLevelRow0The worksheet row outline level
defaultRowHeight15Default row height
defaultColWidth(optional)Default column width
dyDescent55TBD

Worksheet Metrics

Some new metrics have been added to Worksheet...

NameDescription
rowCountThe total row size of the document. Equal to the row number of the last row that has values.
actualRowCountA count of the number of rows that have values. If a mid-document row is empty, it will not be included in the count.
columnCountThe total column size of the document. Equal to the maximum cell count from all of the rows
actualColumnCountA count of the number of columns that have values.

Page Setup

All properties that can affect the printing of a sheet are held in a pageSetup object on the sheet.

// create new sheet with pageSetup settings for A4 - landscape
var worksheet =  workbook.addWorksheet('sheet', {
  pageSetup:{paperSize: 9, orientation:'landscape'}
});

// create a new sheet writer with pageSetup settings for fit-to-page
var worksheetWriter = workbookWriter.addSheet('sheet', {
  pageSetup:{fitToPage: true, fitToHeight: 5, fitToWidth: 7}
});

// adjust pageSetup settings afterwards
worksheet.pageSetup.margins = {
  left: 0.7, right: 0.7,
  top: 0.75, bottom: 0.75,
  header: 0.3, footer: 0.3
};

// Set Print Area for a sheet
worksheet.pageSetup.printArea = 'A1:G20';

// Set multiple Print Areas by separating print areas with '&&'
worksheet.pageSetup.printArea = 'A1:G10&&A11:G20';

// Repeat specific rows on every printed page
worksheet.pageSetup.printTitlesRow = '1:3';

// Repeat specific columns on every printed page
worksheet.pageSetup.printTitlesColumn = 'A:C';

Supported pageSetup settings

NameDefaultDescription
marginsWhitespace on the borders of the page. Units are inches.
orientation'portrait'Orientation of the page - i.e. taller (portrait) or wider (landscape)
horizontalDpi4294967295Horizontal Dots per Inch. Default value is -1
verticalDpi4294967295Vertical Dots per Inch. Default value is -1
fitToPageWhether to use fitToWidth and fitToHeight or scale settings. Default is based on presence of these settings in the pageSetup object - if both are present, scale wins (i.e. default will be false)
pageOrder'downThenOver'Which order to print the pages - one of ['downThenOver', 'overThenDown']
blackAndWhitefalsePrint without colour
draftfalsePrint with less quality (and ink)
cellComments'None'Where to place comments - one of ['atEnd', 'asDisplayed', 'None']
errors'displayed'Where to show errors - one of ['dash', 'blank', 'NA', 'displayed']
scale100Percentage value to increase or reduce the size of the print. Active when fitToPage is false
fitToWidth1How many pages wide the sheet should print on to. Active when fitToPage is true
fitToHeight1How many pages high the sheet should print on to. Active when fitToPage is true
paperSizeWhat paper size to use (see below)
showRowColHeadersfalseWhether to show the row numbers and column letters
showGridLinesfalseWhether to show grid lines
firstPageNumberWhich number to use for the first page
horizontalCenteredfalseWhether to center the sheet data horizontally
verticalCenteredfalseWhether to center the sheet data vertically

Example Paper Sizes

NameValue
Letterundefined
Legal5
Executive7
A49
A511
B5 (JIS)13
Envelope #1020
Envelope DL27
Envelope C528
Envelope B534
Envelope Monarch37
Double Japan Postcard Rotated82
16K 197x273 mm119

Headers and Footers

Here's how to add headers and footers. The added content is mainly text, such as time, introduction, file information, etc., and you can set the style of the text. In addition, you can set different texts for the first page and even page.

Note: Images are not currently supported.

// Set footer (default centered), result: "Page 2 of 16"
worksheet.headerFooter.oddFooter = "Page &P of &N";

// Set the footer (default centered) to bold, resulting in: "Page 2 of 16"
worksheet.headerFooter.oddFooter = "Page &P of &N";

// Set the left footer to 18px and italicize. Result: "Page 2 of 16"
worksheet.headerFooter.oddFooter = "&LPage &P of &N";

// Set the middle header to gray Aril, the result: "52 exceljs"
worksheet.headerFooter.oddHeader = "&C&KCCCCCC&\"Aril\"52 exceljs";

// Set the left, center, and right text of the footer. Result: “Exceljs” in the footer left. “demo.xlsx” in the footer center. “Page 2” in the footer right
worksheet.headerFooter.oddFooter = "&Lexceljs&C&F&RPage &P";

// Add different header & footer for the first page
worksheet.headerFooter.differentFirst = true;
worksheet.headerFooter.firstHeader = "Hello Exceljs";
worksheet.headerFooter.firstFooter = "Hello World"

Supported headerFooter settings

NameDefaultDescription
differentFirstfalseSet the value of differentFirst as true, which indicates that headers/footers for first page are different from the other pages
differentOddEvenfalseSet the value of differentOddEven as true, which indicates that headers/footers for odd and even pages are different
oddHeadernullSet header string for odd(default) pages, could format the string
oddFooternullSet footer string for odd(default) pages, could format the string
evenHeadernullSet header string for even pages, could format the string
evenFooternullSet footer string for even pages, could format the string
firstHeadernullSet header string for the first page, could format the string
firstFooternullSet footer string for the first page, could format the string

Script Commands

CommandsDescription
&LSet position to the left
&CSet position to the center
&RSet position to the right
&PThe current page number
&NThe total number of pages
&DThe current date
&TThe current time
&GA picture
&AThe worksheet name
&FThe file name
&BMake text bold
&IItalicize text
&UUnderline text
&"font name"font name, for example &"Aril"
&font sizefont size, for example 12
&KHEXCodefont color, for example &KCCCCCC

Worksheet Views

Worksheets now support a list of views, that control how Excel presents the sheet:

  • frozen - where a number of rows and columns to the top and left are frozen in place. Only the bottom right section will scroll
  • split - where the view is split into 4 sections, each semi-independently scrollable.

Each view also supports various properties:

NameDefaultDescription
state'normal'Controls the view state - one of normal, frozen or split
rightToLeftfalseSets the worksheet view's orientation to right-to-left
activeCellundefinedThe currently selected cell
showRulertrueShows or hides the ruler in Page Layout
showRowColHeaderstrueShows or hides the row and column headers (e.g. A1, B1 at the top and 1,2,3 on the left
showGridLinestrueShows or hides the gridlines (shown for cells where borders have not been defined)
zoomScale100Percentage zoom to use for the view
zoomScaleNormal100Normal zoom for the view
styleundefinedPresentation style - one of pageBreakPreview or pageLayout. Note pageLayout is not compatible with frozen views

Frozen Views

Frozen views support the following extra properties:

NameDefaultDescription
xSplit0How many columns to freeze. To freeze rows only, set this to 0 or undefined
ySplit0How many rows to freeze. To freeze columns only, set this to 0 or undefined
topLeftCellspecialWhich cell will be top-left in the bottom-right pane. Note: cannot be a frozen cell. Defaults to first unfrozen cell
worksheet.views = [
  {state: 'frozen', xSplit: 2, ySplit: 3, topLeftCell: 'G10', activeCell: 'A1'}
];

Split Views

Split views support the following extra properties:

NameDefaultDescription
xSplit0How many points from the left to place the splitter. To split vertically, set this to 0 or undefined
ySplit0How many points from the top to place the splitter. To split horizontally, set this to 0 or undefined
topLeftCellundefinedWhich cell will be top-left in the bottom-right pane.
activePaneundefinedWhich pane will be active - one of topLeft, topRight, bottomLeft and bottomRight
worksheet.views = [
  {state: 'split', xSplit: 2000, ySplit: 3000, topLeftCell: 'G10', activeCell: 'A1'}
];

Auto filters

It is possible to apply an auto filter to your worksheet.

worksheet.autoFilter = 'A1:C1';

While the range string is the standard form of the autoFilter, the worksheet will also support the following values:

// Set an auto filter from A1 to C1
worksheet.autoFilter = {
  from: 'A1',
  to: 'C1',
}

// Set an auto filter from the cell in row 3 and column 1
// to the cell in row 5 and column 12
worksheet.autoFilter = {
  from: {
    row: 3,
    column: 1
  },
  to: {
    row: 5,
    column: 12
  }
}

// Set an auto filter from D3 to the
// cell in row 7 and column 5
worksheet.autoFilter = {
  from: 'D3',
  to: {
    row: 7,
    column: 5
  }
}

Columns

// Add column headers and define column keys and widths
// Note: these column structures are a workbook-building convenience only,
// apart from the column width, they will not be fully persisted.
worksheet.columns = [
  { header: 'Id', key: 'id', width: 10 },
  { header: 'Name', key: 'name', width: 32 },
  { header: 'D.O.B.', key: 'DOB', width: 10, outlineLevel: 1 }
];

// Access an individual columns by key, letter and 1-based column number
var idCol = worksheet.getColumn('id');
var nameCol = worksheet.getColumn('B');
var dobCol = worksheet.getColumn(3);

// set column properties

// Note: will overwrite cell value C1
dobCol.header = 'Date of Birth';

// Note: this will overwrite cell values C1:C2
dobCol.header = ['Date of Birth', 'A.K.A. D.O.B.'];

// from this point on, this column will be indexed by 'dob' and not 'DOB'
dobCol.key = 'dob';

dobCol.width = 15;

// Hide the column if you'd like
dobCol.hidden = true;

// set an outline level for columns
worksheet.getColumn(4).outlineLevel = 0;
worksheet.getColumn(5).outlineLevel = 1;

// columns support a readonly field to indicate the collapsed state based on outlineLevel
expect(worksheet.getColumn(4).collapsed).to.equal(false);
expect(worksheet.getColumn(5).collapsed).to.equal(true);

// iterate over all current cells in this column
dobCol.eachCell(function(cell, rowNumber) {
  // ...
});

// iterate over all current cells in this column including empty cells
dobCol.eachCell({ includeEmpty: true }, function(cell, rowNumber) {
  // ...
});

// add a column of new values
worksheet.getColumn(6).values = [1,2,3,4,5];

// add a sparse column of values
worksheet.getColumn(7).values = [,,2,3,,5,,7,,,,11];

// cut one or more columns (columns to the right are shifted left)
// If column properties have been defined, they will be cut or moved accordingly
// Known Issue: If a splice causes any merged cells to move, the results may be unpredictable
worksheet.spliceColumns(3,2);

// remove one column and insert two more.
// Note: columns 4 and above will be shifted right by 1 column.
// Also: If the worksheet has more rows than values in the column inserts,
//  the rows will still be shifted as if the values existed
var newCol3Values = [1,2,3,4,5];
var newCol4Values = ['one', 'two', 'three', 'four', 'five'];
worksheet.spliceColumns(3, 1, newCol3Values, newCol4Values);

Rows

// Add a couple of Rows by key-value, after the last current row, using the column keys
worksheet.addRow({id: 1, name: 'John Doe', dob: new Date(1970,1,1)});
worksheet.addRow({id: 2, name: 'Jane Doe', dob: new Date(1965,1,7)});

// Add a row by contiguous Array (assign to columns A, B & C)
worksheet.addRow([3, 'Sam', new Date()]);

// Add a row by sparse Array (assign to columns A, E & I)
var rowValues = [];
rowValues[1] = 4;
rowValues[5] = 'Kyle';
rowValues[9] = new Date();
worksheet.addRow(rowValues);

// Add an array of rows
var rows = [
  [5,'Bob',new Date()], // row by array
  {id:6, name: 'Barbara', dob: new Date()}
];
worksheet.addRows(rows);

// Get a row object. If it doesn't already exist, a new empty one will be returned
var row = worksheet.getRow(5);

// Get the last editable row in a worksheet (or undefined if there are none)
var row = worksheet.lastRow;

// Set a specific row height
row.height = 42.5;

// make row hidden
row.hidden = true;

// set an outline level for rows
worksheet.getRow(4).outlineLevel = 0;
worksheet.getRow(5).outlineLevel = 1;

// rows support a readonly field to indicate the collapsed state based on outlineLevel
expect(worksheet.getRow(4).collapsed).to.equal(false);
expect(worksheet.getRow(5).collapsed).to.equal(true);


row.getCell(1).value = 5; // A5's value set to 5
row.getCell('name').value = 'Zeb'; // B5's value set to 'Zeb' - assuming column 2 is still keyed by name
row.getCell('C').value = new Date(); // C5's value set to now

// Get a row as a sparse array
// Note: interface change: worksheet.getRow(4) ==> worksheet.getRow(4).values
row = worksheet.getRow(4).values;
expect(row[5]).toEqual('Kyle');

// assign row values by contiguous array (where array element 0 has a value)
row.values = [1,2,3];
expect(row.getCell(1).value).toEqual(1);
expect(row.getCell(2).value).toEqual(2);
expect(row.getCell(3).value).toEqual(3);

// assign row values by sparse array  (where array element 0 is undefined)
var values = []
values[5] = 7;
values[10] = 'Hello, World!';
row.values = values;
expect(row.getCell(1).value).toBeNull();
expect(row.getCell(5).value).toEqual(7);
expect(row.getCell(10).value).toEqual('Hello, World!');

// assign row values by object, using column keys
row.values = {
  id: 13,
  name: 'Thing 1',
  dob: new Date()
};

// Insert a page break below the row
row.addPageBreak();

// Iterate over all rows that have values in a worksheet
worksheet.eachRow(function(row, rowNumber) {
  console.log('Row ' + rowNumber + ' = ' + JSON.stringify(row.values));
});

// Iterate over all rows (including empty rows) in a worksheet
worksheet.eachRow({ includeEmpty: true }, function(row, rowNumber) {
  console.log('Row ' + rowNumber + ' = ' + JSON.stringify(row.values));
});

// Iterate over all non-null cells in a row
row.eachCell(function(cell, colNumber) {
  console.log('Cell ' + colNumber + ' = ' + cell.value);
});

// Iterate over all cells in a row (including empty cells)
row.eachCell({ includeEmpty: true }, function(cell, colNumber) {
  console.log('Cell ' + colNumber + ' = ' + cell.value);
});

// Cut one or more rows (rows below are shifted up)
// Known Issue: If a splice causes any merged cells to move, the results may be unpredictable
worksheet.spliceRows(4,3);

// remove one row and insert two more.
// Note: rows 4 and below will be shifted down by 1 row.
var newRow3Values = [1,2,3,4,5];
var newRow4Values = ['one', 'two', 'three', 'four', 'five'];
worksheet.spliceRows(3, 1, newRow3Values, newRow4Values);

// Cut one or more cells (cells to the right are shifted left)
// Note: this operation will not affect other rows
row.splice(3,2);

// remove one cell and insert two more (cells to the right of the cut cell will be shifted right)
row.splice(4,1,'new value 1', 'new value 2');

// Commit a completed row to stream
row.commit();

// row metrics
var rowSize = row.cellCount;
var numValues = row.actualCellCount;

Handling Individual Cells

var cell = worksheet.getCell('C3');

// Modify/Add individual cell
cell.value = new Date(1968, 5, 1);

// query a cell's type
expect(cell.type).toEqual(Excel.ValueType.Date);

// use string value of cell
myInput.value = cell.text;

// use html-safe string for rendering...
var html = '<div>' + cell.html + '</div>';

Merged Cells

// merge a range of cells
worksheet.mergeCells('A4:B5');

// ... merged cells are linked
worksheet.getCell('B5').value = 'Hello, World!';
expect(worksheet.getCell('B5').value).toBe(worksheet.getCell('A4').value);
expect(worksheet.getCell('B5').master).toBe(worksheet.getCell('A4'));

// ... merged cells share the same style object
expect(worksheet.getCell('B5').style).toBe(worksheet.getCell('A4').style);
worksheet.getCell('B5').style.font = myFonts.arial;
expect(worksheet.getCell('A4').style.font).toBe(myFonts.arial);

// unmerging the cells breaks the style links
worksheet.unMergeCells('A4');
expect(worksheet.getCell('B5').style).not.toBe(worksheet.getCell('A4').style);
expect(worksheet.getCell('B5').style.font).not.toBe(myFonts.arial);

// merge by top-left, bottom-right
worksheet.mergeCells('K10', 'M12');

// merge by start row, start column, end row, end column (equivalent to K10:M12)
worksheet.mergeCells(10,11,12,13);

Duplicate a Row

duplicateRow(start, amount = 1, insert = true)

const wb = new ExcelJS.Workbook();
const ws = wb.addWorksheet('duplicateTest');
ws.getCell('A1').value = 'One';
ws.getCell('A2').value = 'Two';
ws.getCell('A3').value = 'Three';
ws.getCell('A4').value = 'Four';

// This line will duplicate the row 'One' twice but it will replace rows 'Two' and 'Three'
// if third param was true so it would insert 2 new rows with the values and styles of row 'One'
ws.duplicateRow(1,2,false);
ParameterDescriptionDefault Value
startRow number you want to duplicate (first in excel is 1)
amountThe times you want to duplicate the row1
inserttrue if you want to insert new rows for the duplicates, or false if you want to replace themtrue

Defined Names

Individual cells (or multiple groups of cells) can have names assigned to them. The names can be used in formulas and data validation (and probably more).

// assign (or get) a name for a cell (will overwrite any other names that cell had)
worksheet.getCell('A1').name = 'PI';
expect(worksheet.getCell('A1').name).to.equal('PI');

// assign (or get) an array of names for a cell (cells can have more than one name)
worksheet.getCell('A1').names = ['thing1', 'thing2'];
expect(worksheet.getCell('A1').names).to.have.members(['thing1', 'thing2']);

// remove a name from a cell
worksheet.getCell('A1').removeName('thing1');
expect(worksheet.getCell('A1').names).to.have.members(['thing2']);

Data Validations

Cells can define what values are valid or not and provide prompting to the user to help guide them.

Validation types can be one of the following:

TypeDescription
listDefine a discrete set of valid values. Excel will offer these in a dropdown for easy entry
wholeThe value must be a whole number
decimalThe value must be a decimal number
textLengthThe value may be text but the length is controlled
customA custom formula controls the valid values

For types other than list or custom, the following operators affect the validation:

OperatorDescription
betweenValues must lie between formula results
notBetweenValues must not lie between formula results
equalValue must equal formula result
notEqualValue must not equal formula result
greaterThanValue must be greater than formula result
lessThanValue must be less than formula result
greaterThanOrEqualValue must be greater than or equal to formula result
lessThanOrEqualValue must be less than or equal to formula result
// Specify list of valid values (One, Two, Three, Four).
// Excel will provide a dropdown with these values.
worksheet.getCell('A1').dataValidation = {
  type: 'list',
  allowBlank: true,
  formulae: ['"One,Two,Three,Four"']
};

// Specify list of valid values from a range.
// Excel will provide a dropdown with these values.
worksheet.getCell('A1').dataValidation = {
  type: 'list',
  allowBlank: true,
  formulae: ['$D$5:$F$5']
};

// Specify Cell must be a whole number that is not 5.
// Show the user an appropriate error message if they get it wrong
worksheet.getCell('A1').dataValidation = {
  type: 'whole',
  operator: 'notEqual',
  showErrorMessage: true,
  formulae: [5],
  errorStyle: 'error',
  errorTitle: 'Five',
  error: 'The value must not be Five'
};

// Specify Cell must be a decimal number between 1.5 and 7.
// Add 'tooltip' to help guid the user
worksheet.getCell('A1').dataValidation = {
  type: 'decimal',
  operator: 'between',
  allowBlank: true,
  showInputMessage: true,
  formulae: [1.5, 7],
  promptTitle: 'Decimal',
  prompt: 'The value must between 1.5 and 7'
};

// Specify Cell must have a text length less than 15
worksheet.getCell('A1').dataValidation = {
  type: 'textLength',
  operator: 'lessThan',
  showErrorMessage: true,
  allowBlank: true,
  formulae: [15]
};

// Specify Cell must be a date before 1st Jan 2016
worksheet.getCell('A1').dataValidation = {
  type: 'date',
  operator: 'lessThan',
  showErrorMessage: true,
  allowBlank: true,
  formulae: [new Date(2016,0,1)]
};

Cell Comments

Add old style comment to a cell

// plain text note
worksheet.getCell('A1').note = 'Hello, ExcelJS!';

// colourful formatted note
ws.getCell('B1').note = {
  texts: [
    {'font': {'size': 12, 'color': {'theme': 0}, 'name': 'Calibri', 'family': 2, 'scheme': 'minor'}, 'text': 'This is '},
    {'font': {'italic': true, 'size': 12, 'color': {'theme': 0}, 'name': 'Calibri', 'scheme': 'minor'}, 'text': 'a'},
    {'font': {'size': 12, 'color': {'theme': 1}, 'name': 'Calibri', 'family': 2, 'scheme': 'minor'}, 'text': ' '},
    {'font': {'size': 12, 'color': {'argb': 'FFFF6600'}, 'name': 'Calibri', 'scheme': 'minor'}, 'text': 'colorful'},
    {'font': {'size': 12, 'color': {'theme': 1}, 'name': 'Calibri', 'family': 2, 'scheme': 'minor'}, 'text': ' text '},
    {'font': {'size': 12, 'color': {'argb': 'FFCCFFCC'}, 'name': 'Calibri', 'scheme': 'minor'}, 'text': 'with'},
    {'font': {'size': 12, 'color': {'theme': 1}, 'name': 'Calibri', 'family': 2, 'scheme': 'minor'}, 'text': ' in-cell '},
    {'font': {'bold': true, 'size': 12, 'color': {'theme': 1}, 'name': 'Calibri', 'family': 2, 'scheme': 'minor'}, 'text': 'format'},
  ],
};

Tables

Tables allow for in-sheet manipulation of tabular data.

To add a table to a worksheet, define a table model and call addTable:

// add a table to a sheet
ws.addTable({
  name: 'MyTable',
  ref: 'A1',
  headerRow: true,
  totalsRow: true,
  style: {
    theme: 'TableStyleDark3',
    showRowStripes: true,
  },
  columns: [
    {name: 'Date', totalsRowLabel: 'Totals:', filterButton: true},
    {name: 'Amount', totalsRowFunction: 'sum', filterButton: false},
  ],
  rows: [
    [new Date('2019-07-20'), 70.10],
    [new Date('2019-07-21'), 70.60],
    [new Date('2019-07-22'), 70.10],
  ],
});

Note: Adding a table to a worksheet will modify the sheet by placing headers and row data to the sheet. Any data on the sheet covered by the resulting table (including headers and totals) will be overwritten.

Table Properties

The following table defines the properties supported by tables.

Table PropertyDescriptionRequiredDefault Value
nameThe name of the tableY
displayNameThe display name of the tableNname
refTop left cell of the tableY
headerRowShow headers at top of tableNtrue
totalsRowShow totals at bottom of tableNfalse
styleExtra style propertiesN{}
columnsColumn definitionsY
rowsRows of dataY

Table Style Properties

The following table defines the properties supported within the table style property.

Style PropertyDescriptionRequiredDefault Value
themeThe colour theme of the tableN'TableStyleMedium2'
showFirstColumnHighlight the first column (bold)Nfalse
showLastColumnHighlight the last column (bold)Nfalse
showRowStripesAlternate rows shown with background colourNfalse
showColumnStripesAlternate rows shown with background colourNfalse

Table Column Properties

The following table defines the properties supported within each table column.

Column PropertyDescriptionRequiredDefault Value
nameThe name of the column, also used in the headerY
filterButtonSwitches the filter control in the headerNfalse
totalsRowLabelLabel to describe the totals row (first column)N'Total'
totalsRowFunctionName of the totals functionN'none'
totalsRowFormulaOptional formula for custom functionsN

Totals Functions

The following table list the valid values for the totalsRowFunction property defined by columns. If any value other than 'custom' is used, it is not necessary to include the associated formula as this will be inserted by the table.

Totals FunctionsDescription
noneNo totals function for this column
averageCompute average for the column
countNumsCount the entries that are numbers
countCount of entries
maxThe maximum value in this column
minThe minimum value in this column
stdDevThe standard deviation for this column
varThe variance for this column
sumThe sum of entries for this column
customA custom formula. Requires an associated totalsRowFormula value.

Table Style Themes

Valid theme names follow the following pattern:

  • "TableStyle[Shade][Number]"

Shades, Numbers can be one of:

  • Light, 1-21
  • Medium, 1-28
  • Dark, 1-11

For no theme, use the value null.

Note: custom table themes are not supported by exceljs yet.

Modifying Tables

Tables support a set of manipulation functions that allow data to be added or removed and some properties to be changed. Since many of these operations may have on-sheet effects, the changes must be committed once complete.

All index values in the table are zero based, so the first row number and first column number is 0.

Adding or Removing Headers and Totals

const table = ws.getTable('MyTable');

// turn header row on
table.headerRow = true;

// turn totals row off
table.totalsRow = false;

// commit the table changes into the sheet
table.commit();

Relocating a Table

const table = ws.getTable('MyTable');

// table top-left move to D4
table.ref = 'D4';

// commit the table changes into the sheet
table.commit();

Adding and Removing Rows

const table = ws.getTable('MyTable');

// remove first two rows
table.removeRows(0, 2);

// insert new rows at index 5
table.addRow([new Date('2019-08-05'), 5, 'Mid'], 5);

// append new row to bottom of table
table.addRow([new Date('2019-08-10'), 10, 'End']);

// commit the table changes into the sheet
table.commit();

Adding and Removing Columns

const table = ws.getTable('MyTable');

// remove second column
table.removeColumns(1, 1);

// insert new column (with data) at index 1
table.addColumn(
  {name: 'Letter', totalsRowFunction: 'custom', totalsRowFormula: 'ROW()', totalsRowResult: 6, filterButton: true},
  ['a', 'b', 'c', 'd'],
  2
);

// commit the table changes into the sheet
table.commit();

Change Column Properties

const table = ws.getTable('MyTable');

// Get Column Wrapper for second column
const column = table.getColumn(1);

// set some properties
column.name = 'Code';
column.filterButton = true;
column.style = {font:{bold: true, name: 'Comic Sans MS'}};
column.totalsRowLabel = 'Totals';
column.totalsRowFunction = 'custom';
column.totalsRowFormula = 'ROW()';
column.totalsRowResult = 10;

// commit the table changes into the sheet
table.commit();

Styles

Cells, Rows and Columns each support a rich set of styles and formats that affect how the cells are displayed.

Styles are set by assigning the following properties:

// assign a style to a cell
ws.getCell('A1').numFmt = '0.00%';

// Apply styles to worksheet columns
ws.columns = [
  { header: 'Id', key: 'id', width: 10 },
  { header: 'Name', key: 'name', width: 32, style: { font: { name: 'Arial Black' } } },
  { header: 'D.O.B.', key: 'DOB', width: 10, style: { numFmt: 'dd/mm/yyyy' } }
];

// Set Column 3 to Currency Format
ws.getColumn(3).numFmt = '"£"#,##0.00;[Red]\-"£"#,##0.00';

// Set Row 2 to Comic Sans.
ws.getRow(2).font = { name: 'Comic Sans MS', family: 4, size: 16, underline: 'double', bold: true };

When a style is applied to a row or column, it will be applied to all currently existing cells in that row or column. Also, any new cell that is created will inherit its initial styles from the row and column it belongs to.

If a cell's row and column both define a specific style (e.g. font), the cell will use the row style over the column style. However if the row and column define different styles (e.g. column.numFmt and row.font), the cell will inherit the font from the row and the numFmt from the column.

Caveat: All the above properties (with the exception of numFmt, which is a string), are JS object structures. If the same style object is assigned to more than one spreadsheet entity, then each entity will share the same style object. If the style object is later modified before the spreadsheet is serialized, then all entities referencing that style object will be modified too. This behaviour is intended to prioritize performance by reducing the number of JS objects created. If you want the style objects to be independent, you will need to clone them before assigning them. Also, by default, when a document is read from file (or stream) if spreadsheet entities share similar styles, then they will reference the same style object too.

Number Formats

// display value as '1 3/5'
ws.getCell('A1').value = 1.6;
ws.getCell('A1').numFmt = '# ?/?';

// display value as '1.60%'
ws.getCell('B1').value = 0.016;
ws.getCell('B1').numFmt = '0.00%';

Fonts


// for the wannabe graphic designers out there
ws.getCell('A1').font = {
  name: 'Comic Sans MS',
  family: 4,
  size: 16,
  underline: true,
  bold: true
};

// for the graduate graphic designers...
ws.getCell('A2').font = {
  name: 'Arial Black',
  color: { argb: 'FF00FF00' },
  family: 2,
  size: 14,
  italic: true
};

// for the vertical align
ws.getCell('A3').font = {
  vertAlign: 'superscript'
};

// note: the cell will store a reference to the font object assigned.
// If the font object is changed afterwards, the cell font will change also...
var font = { name: 'Arial', size: 12 };
ws.getCell('A3').font = font;
font.size = 20; // Cell A3 now has font size 20!

// Cells that share similar fonts may reference the same font object after
// the workbook is read from file or stream
Font PropertyDescriptionExample Value(s)
nameFont name.'Arial', 'Calibri', etc.
familyFont family for fallback. An integer value.1 - Serif, 2 - Sans Serif, 3 - Mono, Others - unknown
schemeFont scheme.'minor', 'major', 'none'
charsetFont charset. An integer value.1, 2, etc.
sizeFont size. An integer value.9, 10, 12, 16, etc.
colorColour description, an object containing an ARGB value.{ argb: 'FFFF0000'}
boldFont weighttrue, false
italicFont slopetrue, false
underlineFont underline styletrue, false, 'none', 'single', 'double', 'singleAccounting', 'doubleAccounting'
strikeFont strikethroughtrue, false
outlineFont outlinetrue, false
vertAlignVertical align'superscript', 'subscript'

Alignment

// set cell alignment to top-left, middle-center, bottom-right
ws.getCell('A1').alignment = { vertical: 'top', horizontal: 'left' };
ws.getCell('B1').alignment = { vertical: 'middle', horizontal: 'center' };
ws.getCell('C1').alignment = { vertical: 'bottom', horizontal: 'right' };

// set cell to wrap-text
ws.getCell('D1').alignment = { wrapText: true };

// set cell indent to 1
ws.getCell('E1').alignment = { indent: 1 };

// set cell text rotation to 30deg upwards, 45deg downwards and vertical text
ws.getCell('F1').alignment = { textRotation: 30 };
ws.getCell('G1').alignment = { textRotation: -45 };
ws.getCell('H1').alignment = { textRotation: 'vertical' };

Valid Alignment Property Values

horizontalverticalwrapTextshrinkToFitindentreadingOrdertextRotation
lefttoptruetrueintegerrtl0 to 90
centermiddlefalsefalseltr-1 to -90
rightbottomvertical
filldistributed
justifyjustify
centerContinuous
distributed

Borders

// set single thin border around A1
ws.getCell('A1').border = {
  top: {style:'thin'},
  left: {style:'thin'},
  bottom: {style:'thin'},
  right: {style:'thin'}
};

// set double thin green border around A3
ws.getCell('A3').border = {
  top: {style:'double', color: {argb:'FF00FF00'}},
  left: {style:'double', color: {argb:'FF00FF00'}},
  bottom: {style:'double', color: {argb:'FF00FF00'}},
  right: {style:'double', color: {argb:'FF00FF00'}}
};

// set thick red cross in A5
ws.getCell('A5').border = {
  diagonal: {up: true, down: true, style:'thick', color: {argb:'FFFF0000'}}
};

Valid Border Styles

  • thin
  • dotted
  • dashDot
  • hair
  • dashDotDot
  • slantDashDot
  • mediumDashed
  • mediumDashDotDot
  • mediumDashDot
  • medium
  • double
  • thick

Fills

// fill A1 with red darkVertical stripes
ws.getCell('A1').fill = {
  type: 'pattern',
  pattern:'darkVertical',
  fgColor:{argb:'FFFF0000'}
};

// fill A2 with yellow dark trellis and blue behind
ws.getCell('A2').fill = {
  type: 'pattern',
  pattern:'darkTrellis',
  fgColor:{argb:'FFFFFF00'},
  bgColor:{argb:'FF0000FF'}
};

// fill A3 with blue-white-blue gradient from left to right
ws.getCell('A3').fill = {
  type: 'gradient',
  gradient: 'angle',
  degree: 0,
  stops: [
    {position:0, color:{argb:'FF0000FF'}},
    {position:0.5, color:{argb:'FFFFFFFF'}},
    {position:1, color:{argb:'FF0000FF'}}
  ]
};


// fill A4 with red-green gradient from center
ws.getCell('A4').fill = {
  type: 'gradient',
  gradient: 'path',
  center:{left:0.5,top:0.5},
  stops: [
    {position:0, color:{argb:'FFFF0000'}},
    {position:1, color:{argb:'FF00FF00'}}
  ]
};
Pattern Fills
PropertyRequiredDescription
typeYValue: 'pattern'
Specifies this fill uses patterns
patternYSpecifies type of pattern (see Valid Pattern Types below)
fgColorNSpecifies the pattern foreground color. Default is black.
bgColorNSpecifies the pattern background color. Default is white.

Valid Pattern Types

  • none
  • solid
  • darkGray
  • mediumGray
  • lightGray
  • gray125
  • gray0625
  • darkHorizontal
  • darkVertical
  • darkDown
  • darkUp
  • darkGrid
  • darkTrellis
  • lightHorizontal
  • lightVertical
  • lightDown
  • lightUp
  • lightGrid
  • lightTrellis
Gradient Fills
PropertyRequiredDescription
typeYValue: 'gradient'
Specifies this fill uses gradients
gradientYSpecifies gradient type. One of ['angle', 'path']
degreeangleFor 'angle' gradient, specifies the direction of the gradient. 0 is from the left to the right. Values from 1 - 359 rotates the direction clockwise
centerpathFor 'path' gradient. Specifies the relative coordinates for the start of the path. 'left' and 'top' values range from 0 to 1
stopsYSpecifies the gradient colour sequence. Is an array of objects containing position and color starting with position 0 and ending with position 1. Intermediary positions may be used to specify other colours on the path.

Caveats

Using the interface above it may be possible to create gradient fill effects not possible using the XLSX editor program. For example, Excel only supports angle gradients of 0, 45, 90 and 135. Similarly the sequence of stops may also be limited by the UI with positions [0,1] or [0,0.5,1] as the only options. Take care with this fill to be sure it is supported by the target XLSX viewers.

Rich Text

Individual cells now support rich text or in-cell formatting. Rich text values can control the font properties of any number of sub-strings within the text value. See Fonts for a complete list of details on what font properties are supported.


ws.getCell('A1').value = {
  'richText': [
    {'font': {'size': 12,'color': {'theme': 0},'name': 'Calibri','family': 2,'scheme': 'minor'},'text': 'This is '},
    {'font': {'italic': true,'size': 12,'color': {'theme': 0},'name': 'Calibri','scheme': 'minor'},'text': 'a'},
    {'font': {'size': 12,'color': {'theme': 1},'name': 'Calibri','family': 2,'scheme': 'minor'},'text': ' '},
    {'font': {'size': 12,'color': {'argb': 'FFFF6600'},'name': 'Calibri','scheme': 'minor'},'text': 'colorful'},
    {'font': {'size': 12,'color': {'theme': 1},'name': 'Calibri','family': 2,'scheme': 'minor'},'text': ' text '},
    {'font': {'size': 12,'color': {'argb': 'FFCCFFCC'},'name': 'Calibri','scheme': 'minor'},'text': 'with'},
    {'font': {'size': 12,'color': {'theme': 1},'name': 'Calibri','family': 2,'scheme': 'minor'},'text': ' in-cell '},
    {'font': {'bold': true,'size': 12,'color': {'theme': 1},'name': 'Calibri','family': 2,'scheme': 'minor'},'text': 'format'}
  ]
};

expect(ws.getCell('A1').text).to.equal('This is a colorful text with in-cell format');
expect(ws.getCell('A1').type).to.equal(Excel.ValueType.RichText);

Cell Protection

Cell level protection can be modified using the protection property.

ws.getCell('A1').protection = {
  locked: false,
  hidden: true,
};

Supported Protection Properties

PropertyDefaultDescription
lockedtrueSpecifies whether a cell will be locked if the sheet is protected.
hiddenfalseSpecifies whether a cell's formula will be visible if the sheet is protected.

Conditional Formatting

Conditional formatting allows a sheet to show specific styles, icons, etc depending on cell values or any arbitrary formula.

Conditional formatting rules are added at the sheet level and will typically cover a range of cells.

Multiple rules can be applied to a given cell range and each rule will apply its own style.

If multiple rules affect a given cell, the rule priority value will determine which rule wins out if competing styles collide. The rule with the lower priority value wins. If priority values are not specified for a given rule, ExcelJS will assign them in ascending order.

Note: at present, only a subset of conditional formatting rules are supported. Specifically, only the formatting rules that do not require XML rendering inside an <extLst> element. This means that datasets and three specific icon sets (3Triangles, 3Stars, 5Boxes) are not supported.

// add a checkerboard pattern to A1:E7 based on row + col being even or odd
worksheet.addConditionalFormatting({
  ref: 'A1:E7',
  rules: [
    {
      type: 'expression',
      formulae: ['MOD(ROW()+COLUMN(),2)=0'],
      style: {fill: {type: 'pattern', pattern: 'solid', bgColor: {argb: 'FF00FF00'}}},
    }
  ]
})

Supported Conditional Formatting Rule Types

TypeDescription
expressionAny custom function may be used to activate the rule.
cellIsCompares cell value with supplied formula using specified operator
top10Applies formatting to cells with values in top (or bottom) ranges
aboveAverageApplies formatting to cells with values above (or below) average
colorScaleApplies a coloured background to cells based on where their values lie in the range
iconSetAdds one of a range of icons to cells based on value
containsTextApplies formatting based on whether cell a specific text
timePeriodApplies formatting based on whether cell datetime value lies within a specified range

Expression

FieldOptionalDefaultDescription
type'expression'
priorityY<auto>determines priority ordering of styles
formulaearray of 1 formula string that returns a true/false value. To reference the cell value, use the top-left cell address
stylestyle structure to apply if the formula returns true

Cell Is

FieldOptionalDefaultDescription
type'cellIs'
priorityY<auto>determines priority ordering of styles
operatorhow to compare cell value with formula result
formulaearray of 1 formula string that returns the value to compare against each cell
stylestyle structure to apply if the comparison returns true

Cell Is Operators

OperatorDescription
equalApply format if cell value equals formula value
greaterThanApply format if cell value is greater than formula value
lessThanApply format if cell value is less than formula value
betweenApply format if cell value is between two formula values (inclusive)

Top 10

FieldOptionalDefaultDescription
type'top10'
priorityY<auto>determines priority ordering of styles
rankY10specifies how many top (or bottom) values are included in the formatting
percentYfalseif true, the rank field is a percentage, not an absolute
bottomYfalseif true, the bottom values are included instead of the top
stylestyle structure to apply if the comparison returns true

Above Average

FieldOptionalDefaultDescription
type'aboveAverage'
priorityY<auto>determines priority ordering of styles
aboveAverageYfalseif true, the rank field is a percentage, not an absolute
stylestyle structure to apply if the comparison returns true

Colour Scale

FieldOptionalDefaultDescription
type'colorScale'
priorityY<auto>determines priority ordering of styles
cfvoarray of 2 to 5 Conditional Formatting Value Objects specifying way-points in the value range
colorcorresponding array of colours to use at given way points
stylestyle structure to apply if the comparison returns true

Icon Set

FieldOptionalDefaultDescription
type'iconSet'
priorityY<auto>determines priority ordering of styles
iconSetY3TrafficLightsname of icon set to use
cfvoarray of 2 to 5 Conditional Formatting Value Objects specifying way-points in the value range
stylestyle structure to apply if the comparison returns true

Contains Text

FieldOptionalDefaultDescription
type'containsText'
priorityY<auto>determines priority ordering of styles
operatortype of text comparison
texttext to search for
stylestyle structure to apply if the comparison returns true

Contains Text Operators

OperatorDescription
containsTextApply format if cell value contains the value specified in the 'text' field
containsBlanksApply format if cell value contains blanks
notContainsBlanksApply format if cell value does not contain blanks
containsErrorsApply format if cell value contains errors
notContainsErrorsApply format if cell value does not contain errors

Time Period

FieldOptionalDefaultDescription
type'timePeriod'
priorityY<auto>determines priority ordering of styles
timePeriodwhat time period to compare cell value to
stylestyle structure to apply if the comparison returns true

Time Periods

Time PeriodDescription
lastWeekApply format if cell value falls within the last week
thisWeekApply format if cell value falls in this week
nextWeekApply format if cell value falls in the next week
yesterdayApply format if cell value is equal to yesterday
todayApply format if cell value is equal to today
tomorrowApply format if cell value is equal to tomorrow
last7DaysApply format if cell value falls within the last 7 days
lastMonthApply format if cell value falls in last month
thisMonthApply format if cell value falls in this month
nextMonthApply format if cell value falls in next month

Outline Levels

Excel supports outlining; where rows or columns can be expanded or collapsed depending on what level of detail the user wishes to view.

Outline levels can be defined in column setup:

worksheet.columns = [
  { header: 'Id', key: 'id', width: 10 },
  { header: 'Name', key: 'name', width: 32 },
  { header: 'D.O.B.', key: 'DOB', width: 10, outlineLevel: 1 }
];

Or directly on the row or column

worksheet.getColumn(3).outlineLevel = 1;
worksheet.getRow(3).outlineLevel = 1;

The sheet outline levels can be set on the worksheet

// set column outline level
worksheet.properties.outlineLevelCol = 1;

// set row outline level
worksheet.properties.outlineLevelRow = 1;

Note: adjusting outline levels on rows or columns or the outline levels on the worksheet will incur a side effect of also modifying the collapsed property of all rows or columns affected by the property change. E.g.:

worksheet.properties.outlineLevelCol = 1;

worksheet.getColumn(3).outlineLevel = 1;
expect(worksheet.getColumn(3).collapsed).to.be.true;

worksheet.properties.outlineLevelCol = 2;
expect(worksheet.getColumn(3).collapsed).to.be.false;

The outline properties can be set on the worksheet

worksheet.properties.outlineProperties = {
  summaryBelow: false,
  summaryRight: false,
};

Images

Adding images to a worksheet is a two-step process. First, the image is added to the workbook via the addImage() function which will also return an imageId value. Then, using the imageId, the image can be added to the worksheet either as a tiled background or covering a cell range.

Note: As of this version, adjusting or transforming the image is not supported.

Add Image to Workbook

The Workbook.addImage function supports adding images by filename or by Buffer. Note that in both cases, the extension must be specified. Valid extension values include 'jpeg', 'png', 'gif'.

// add image to workbook by filename
var imageId1 = workbook.addImage({
  filename: 'path/to/image.jpg',
  extension: 'jpeg',
});

// add image to workbook by buffer
var imageId2 = workbook.addImage({
  buffer: fs.readFileSync('path/to.image.png'),
  extension: 'png',
});

// add image to workbook by base64
var myBase64Image = "data:image/png;base64,iVBORw0KG...";
var imageId2 = workbook.addImage({
  base64: myBase64Image,
  extension: 'png',
});

Add image background to worksheet

Using the image id from Workbook.addImage, the background to a worksheet can be set using the addBackgroundImage function

// set background
worksheet.addBackgroundImage(imageId1);

Add image over a range

Using the image id from Workbook.addImage, an image can be embedded within the worksheet to cover a range. The coordinates calculated from the range will cover from the top-left of the first cell to the bottom right of the second.

// insert an image over B2:D6
worksheet.addImage(imageId2, 'B2:D6');

Using a structure instead of a range string, it is possible to partially cover cells.

Note that the coordinate system used for this is zero based, so the top-left of A1 will be { col: 0, row: 0 }. Fractions of cells can be specified by using floating point numbers, e.g. the midpoint of A1 is { col: 0.5, row: 0.5 }.

// insert an image over part of B2:D6
worksheet.addImage(imageId2, {
  tl: { col: 1.5, row: 1.5 },
  br: { col: 3.5, row: 5.5 }
});

The cell range can also have the property 'editAs' which will control how the image is anchored to the cell(s) It can have one of the following values:

ValueDescription
undefinedIt specifies the image will be moved and sized with cells
oneCellThis is the default. Image will be moved with cells but not sized
absoluteImage will not be moved or sized with cells
ws.addImage(imageId, {
  tl: { col: 0.1125, row: 0.4 },
  br: { col: 2.101046875, row: 3.4 },
  editAs: 'oneCell'
});

Add image to a cell

You can add an image to a cell and then define its width and height in pixels at 96dpi.

worksheet.addImage(imageId2, {
  tl: { col: 0, row: 0 },
  ext: { width: 500, height: 200 }
});

You can add an image with hyperlinks to a cell, and defines the hyperlinks in image range.

worksheet.addImage(imageId2, {
  tl: { col: 0, row: 0 },
  ext: { width: 500, height: 200 },
  hyperlinks: {
    hyperlink: 'http://www.somewhere.com',
    tooltip: 'http://www.somewhere.com'
  }
});

Sheet Protection

Worksheets can be protected from modification by adding a password.

await worksheet.protect('the-password', options);

Worksheet protection can also be removed:

worksheet.unprotect();

See Cell Protection for details on how to modify individual cell protection.

Note: While the protect() function returns a Promise indicating that it is async, the current implementation runs on the main thread and will use approx 600ms on an average CPU.

Sheet Protection Options

FieldDefaultDescription
selectLockedCellstrueLets the user select locked cells
selectUnlockedCellstrueLets the user select unlocked cells
formatCellsfalseLets the user format cells
formatColumnsfalseLets the user format columns
formatRowsfalseLets the user format rows
insertRowsfalseLets the user insert rows
insertColumnsfalseLets the user insert columns
insertHyperlinksfalseLets the user insert hyperlinks
deleteRowsfalseLets the user delete rows
deleteColumnsfalseLets the user delete columns
sortfalseLets the user sort data
autoFilterfalseLets the user filter data in tables
pivotTablesfalseLets the user use pivot tables

File I/O

XLSX

Reading XLSX
// read from a file
var workbook = new Excel.Workbook();
workbook.xlsx.readFile(filename)
  .then(function() {
    // use workbook
  });

// pipe from stream
var workbook = new Excel.Workbook();
stream.pipe(workbook.xlsx.createInputStream());

// load from buffer
var workbook = new Excel.Workbook();
workbook.xlsx.load(data)
  .then(function() {
    // use workbook
  });
Writing XLSX
// write to a file
var workbook = createAndFillWorkbook();
workbook.xlsx.writeFile(filename)
  .then(function() {
    // done
  });

// write to a stream
workbook.xlsx.write(stream)
  .then(function() {
    // done
  });

// write to a new buffer
workbook.xlsx.writeBuffer()
  .then(function(buffer) {
    // done
  });

CSV

Reading CSV

Options supported when reading CSV files.

FieldRequiredTypeDescription
dateFormatsNArraySpecify the date encoding format of dayjs.
mapNFunctionCustom Array.prototype.map() callback function for processing data.
sheetNameNStringSpecify worksheet name.
parserOptionsNObjectparseOptions options @fast-csv/format module to write csv data.
// read from a file
var workbook = new Excel.Workbook();
workbook.csv.readFile(filename)
  .then(worksheet => {
    // use workbook or worksheet
  });

// read from a stream
var workbook = new Excel.Workbook();
workbook.csv.read(stream)
  .then(worksheet => {
    // use workbook or worksheet
  });

// pipe from stream
var workbook = new Excel.Workbook();
stream.pipe(workbook.csv.createInputStream());

// read from a file with European Dates
var workbook = new Excel.Workbook();
var options = {
  dateFormats: ['DD/MM/YYYY']
};
workbook.csv.readFile(filename, options)
  .then(worksheet => {
    // use workbook or worksheet
  });

// read from a file with custom value parsing
var workbook = new Excel.Workbook();
var options = {
  map(value, index) {
    switch(index) {
      case 0:
        // column 1 is string
        return value;
      case 1:
        // column 2 is a date
        return new Date(value);
      case 2:
        // column 3 is JSON of a formula value
        return JSON.parse(value);
      default:
        // the rest are numbers
        return parseFloat(value);
    }
  },
  // https://c2fo.io/fast-csv/docs/parsing/options
  parserOptions: {
    delimiter: '\t',
    quote: false,
  },
};
workbook.csv.readFile(filename, options)
  .then(function(worksheet) {
    // use workbook or worksheet
  });

The CSV parser uses fast-csv to read the CSV file. The formatterOptions in the options passed to the above write function will be passed to the @fast-csv/format module to write csv data. Please refer to the fast-csv README.md for details.

Dates are parsed using the npm module dayjs. If a dateFormats array is not supplied, the following dateFormats are used:

  • 'YYYY-MM-DD[T]HH:mm:ss'
  • 'MM-DD-YYYY'
  • 'YYYY-MM-DD'

Please refer to the dayjs CustomParseFormat plugin for details on how to structure a dateFormat.

Writing CSV

Options supported when writing to a CSV file.

FieldRequiredTypeDescription
dateFormatNStringSpecify the date encoding format of dayjs.
dateUTCNBooleanSpecify whether ExcelJS uses dayjs.utc () to convert time zone for parsing dates.
encodingNStringSpecify file encoding format.
includeEmptyRowsNBooleanSpecifies whether empty rows can be written.
mapNFunctionCustom Array.prototype.map() callback function for processing row values.
sheetNameNStringSpecify worksheet name.
sheetIdNNumberSpecify worksheet ID.
formatterOptionsNObjectformatterOptions options @fast-csv/format module to write csv data.

// write to a file
var workbook = createAndFillWorkbook();
workbook.csv.writeFile(filename)
  .then(() => {
    // done
  });

// write to a stream
// Be careful that you need to provide sheetName or
// sheetId for correct import to csv.
workbook.csv.write(stream, { sheetName: 'Page name' })
  .then(() => {
    // done
  });

// write to a file with European Date-Times
var workbook = new Excel.Workbook();
var options = {
  dateFormat: 'DD/MM/YYYY HH:mm:ss',
  dateUTC: true, // use utc when rendering dates
};
workbook.csv.writeFile(filename, options)
  .then(() => {
    // done
  });


// write to a file with custom value formatting
var workbook = new Excel.Workbook();
var options = {
  map(value, index) {
    switch(index) {
      case 0:
        // column 1 is string
        return value;
      case 1:
        // column 2 is a date
        return moment(value).format('YYYY-MM-DD');
      case 2:
        // column 3 is a formula, write just the result
        return value.result;
      default:
        // the rest are numbers
        return value;
    }
  },
  // https://c2fo.io/fast-csv/docs/formatting/options
  formatterOptions: {
    delimiter: '\t',
    quote: false,
  },
};
workbook.csv.writeFile(filename, options)
  .then(() => {
    // done
  });

// write to a new buffer
workbook.csv.writeBuffer()
  .then(function(buffer) {
    // done
  });

The CSV parser uses fast-csv to write the CSV file. The formatterOptions in the options passed to the above write function will be passed to the @fast-csv/format module to write csv data. Please refer to the fast-csv README.md for details.

Dates are formatted using the npm module moment. If no dateFormat is supplied, moment.ISO_8601 is used. When writing a CSV you can supply the boolean dateUTC as true to have ExcelJS parse the date without automatically converting the timezone using moment.utc().

Streaming I/O

The File I/O documented above requires that an entire workbook is built up in memory before the file can be written. While convenient, it can limit the size of the document due to the amount of memory required.

A streaming writer (or reader) processes the workbook or worksheet data as it is generated, converting it into file form as it goes. Typically this is much more efficient on memory as the final memory footprint and even intermediate memory footprints are much more compact than with the document version, especially when you consider that the row and cell objects are disposed once they are committed.

The interface to the streaming workbook and worksheet is almost the same as the document versions with a few minor practical differences:

  • Once a worksheet is added to a workbook, it cannot be removed.
  • Once a row is committed, it is no longer accessible since it will have been dropped from the worksheet.
  • unMergeCells() is not supported.

Note that it is possible to build the entire workbook without committing any rows. When the workbook is committed, all added worksheets (including all uncommitted rows) will be automatically committed. However in this case, little will have been gained over the Document version.

Streaming XLSX
Streaming XLSX Writer

The streaming XLSX writer is available in the ExcelJS.stream.xlsx namespace.

The constructor takes an optional options object with the following fields:

FieldDescription
streamSpecifies a writable stream to write the XLSX workbook to.
filenameIf stream not specified, this field specifies the path to a file to write the XLSX workbook to.
useSharedStringsSpecifies whether to use shared strings in the workbook. Default is false
useStylesSpecifies whether to add style information to the workbook. Styles can add some performance overhead. Default is false
zipZip options that ExcelJS internally passes to Archiver. Default is undefined

If neither stream nor filename is specified in the options, the workbook writer will create a StreamBuf object that will store the contents of the XLSX workbook in memory. This StreamBuf object, which can be accessed via the property workbook.stream, can be used to either access the bytes directly by stream.read() or to pipe the contents to another stream.

// construct a streaming XLSX workbook writer with styles and shared strings
var options = {
  filename: './streamed-workbook.xlsx',
  useStyles: true,
  useSharedStrings: true
};
var workbook = new Excel.stream.xlsx.WorkbookWriter(options);

In general, the interface to the streaming XLSX writer is the same as the Document workbook (and worksheets) described above, in fact the row, cell and style objects are the same.

However there are some differences...

Construction

As seen above, the WorkbookWriter will typically require the output stream or file to be specified in the constructor.

Committing Data

When a worksheet row is ready, it should be committed so that the row object and contents can be freed. Typically this would be done as each row is added...

worksheet.addRow({
   id: i,
   name: theName,
   etc: someOtherDetail
}).commit();

The reason the WorksheetWriter does not commit rows as they are added is to allow cells to be merged across rows:

worksheet.mergeCells('A1:B2');
worksheet.getCell('A1').value = 'I am merged';
worksheet.getCell('C1').value = 'I am not';
worksheet.getCell('C2').value = 'Neither am I';
worksheet.getRow(2).commit(); // now rows 1 and two are committed.

As each worksheet is completed, it must also be committed:

// Finished adding data. Commit the worksheet
worksheet.commit();

To complete the XLSX document, the workbook must be committed. If any worksheet in a workbook are uncommitted, they will be committed automatically as part of the workbook commit.

// Finished the workbook.
workbook.commit()
  .then(function() {
    // the stream has been written
  });

Browser

A portion of this library has been isolated and tested for use within a browser environment.

Due to the streaming nature of the workbook reader and workbook writer, these have not been included. Only the document based workbook may be used (see Create a Workbook for details).

For example code using ExcelJS in the browser take a look at the spec/browser folder in the github repo.

Prebundled

The following files are pre-bundled and included inside the dist folder.

  • exceljs.js
  • exceljs.min.js

Value Types

The following value types are supported.

Null Value

Enum: Excel.ValueType.Null

A null value indicates an absence of value and will typically not be stored when written to file (except for merged cells). It can be used to remove the value from a cell.

E.g.

worksheet.getCell('A1').value = null;

Merge Cell

Enum: Excel.ValueType.Merge

A merge cell is one that has its value bound to another 'master' cell. Assigning to a merge cell will cause the master's cell to be modified.

Number Value

Enum: Excel.ValueType.Number

A numeric value.

E.g.

worksheet.getCell('A1').value = 5;
worksheet.getCell('A2').value = 3.14159;

String Value

Enum: Excel.ValueType.String

A simple text string.

E.g.

worksheet.getCell('A1').value = 'Hello, World!';

Date Value

Enum: Excel.ValueType.Date

A date value, represented by the JavaScript Date type.

E.g.

worksheet.getCell('A1').value = new Date(2017, 2, 15);

Enum: Excel.ValueType.Hyperlink

A URL with both text and link value.

E.g.

// link to web
worksheet.getCell('A1').value = {
  text: 'www.mylink.com',
  hyperlink: 'http://www.mylink.com',
  tooltip: 'www.mylink.com'
};

// internal link
worksheet.getCell('A1').value = { text: 'Sheet2', hyperlink: '#\'Sheet2\'!A1' };

Formula Value

Enum: Excel.ValueType.Formula

An Excel formula for calculating values on the fly. Note that while the cell type will be Formula, the cell may have an effectiveType value that will be derived from the result value.

Note that ExcelJS cannot process the formula to generate a result, it must be supplied.

E.g.

worksheet.getCell('A3').value = { formula: 'A1+A2', result: 7 };

Cells also support convenience getters to access the formula and result:

worksheet.getCell('A3').formula === 'A1+A2';
worksheet.getCell('A3').result === 7;

Shared Formula

Shared formulae enhance the compression of the xlsx document by decreasing the repetition of text within the worksheet xml. The top-left cell in a range is the designated master and will hold the formula that all the other cells in the range will derive from. The other 'slave' cells can then refer to this master cell instead of redefining the whole formula again. Note that the master formula will be translated to the slave cells in the usual Excel fashion so that references to other cells will be shifted down and to the right depending on the slave's offset to the master. For example: if the master cell A2 has a formula referencing A1 then if cell B2 shares A2's formula, then it will reference B1.

A master formula can be assigned to a cell along with the slave cells in its range

worksheet.getCell('A2').value = {
  formula: 'A1',
  result: 10,
  shareType: 'shared',
  ref: 'A2:B3'
};

A shared formula can be assigned to a cell using a new value form:

worksheet.getCell('B2').value = { sharedFormula: 'A2', result: 10 };

This specifies that the cell B2 is a formula that will be derived from the formula in A2 and its result is 10.

The formula convenience getter will translate the formula in A2 to what it should be in B2:

expect(worksheet.getCell('B2').formula).to.equal('B1');

Shared formulae can be assigned into a sheet using the 'fillFormula' function:

// set A1 to starting number
worksheet.getCell('A1').value = 1;

// fill A2 to A10 with ascending count starting from A1
worksheet.fillFormula('A2:A10', 'A1+1', [2,3,4,5,6,7,8,9,10]);

fillFormula can also use a callback function to calculate the value at each cell

// fill A2 to A100 with ascending count starting from A1
worksheet.fillFormula('A2:A100', 'A1+1', (row, col) => row);

Formula Type

To distinguish between real and translated formula cells, use the formulaType getter:

worksheet.getCell('A3').formulaType === Enums.FormulaType.Master;
worksheet.getCell('B3').formulaType === Enums.FormulaType.Shared;

Formula type has the following values:

NameValue
Enums.FormulaType.None0
Enums.FormulaType.Master1
Enums.FormulaType.Shared2

Array Formula

A new way of expressing shared formulae in Excel is the array formula. In this form, the master cell is the only cell that contains any information relating to a formula. It contains the shareType 'array' along with the range of cells it applies to and the formula that will be copied. The rest of the cells are regular cells with regular values.

Note: array formulae are not translated in the way shared formulae are. So if master cell A2 refers to A1, then slave cell B2 will also refer to A1.

E.g.

// assign array formula to A2:B3
worksheet.getCell('A2').value = {
  formula: 'A1',
  result: 10,
  shareType: 'array',
  ref: 'A2:B3'
};

// it may not be necessary to fill the rest of the values in the sheet

The fillFormula function can also be used to fill an array formula

// fill A2:B3 with array formula "A1"
worksheet.fillFormula('A2:B3', 'A1', [1,1,1,1], 'array');

Rich Text Value

Enum: Excel.ValueType.RichText

Rich, styled text.

E.g.

worksheet.getCell('A1').value = {
  richText: [
    { text: 'This is '},
    {font: {italic: true}, text: 'italic'},
  ]
};

Boolean Value

Enum: Excel.ValueType.Boolean

E.g.

worksheet.getCell('A1').value = true;
worksheet.getCell('A2').value = false;

Error Value

Enum: Excel.ValueType.Error

E.g.

worksheet.getCell('A1').value = { error: '#N/A' };
worksheet.getCell('A2').value = { error: '#VALUE!' };

The current valid Error text values are:

NameValue
Excel.ErrorValue.NotApplicable#N/A
Excel.ErrorValue.Ref#REF!
Excel.ErrorValue.Name#NAME?
Excel.ErrorValue.DivZero#DIV/0!
Excel.ErrorValue.Null#NULL!
Excel.ErrorValue.Value#VALUE!
Excel.ErrorValue.Num#NUM!

Interface Changes

Every effort is made to make a good consistent interface that doesn't break through the versions but regrettably, now and then some things have to change for the greater good.

0.1.0

Worksheet.eachRow

The arguments in the callback function to Worksheet.eachRow have been swapped and changed; it was function(rowNumber,rowValues), now it is function(row, rowNumber) which gives it a look and feel more like the underscore (_.each) function and priorities the row object over the row number.

Worksheet.getRow

This function has changed from returning a sparse array of cell values to returning a Row object. This enables accessing row properties and will facilitate managing row styles and so on.

The sparse array of cell values is still available via Worksheet.getRow(rowNumber).values;

0.1.1

cell.model

cell.styles renamed to cell.style

0.2.44

Promises returned from functions switched from Bluebird to native node Promise which can break calling code if they rely on Bluebird's extra features.

To mitigate this the following two changes were added to 0.3.0:

  • A more fully featured and still browser compatible promise lib is used by default. This lib supports many of the features of Bluebird but with a much lower footprint.
  • An option to inject a different Promise implementation. See Config section for more details.

Config

ExcelJS now supports dependency injection for the promise library. You can restore Bluebird promises by including the following code in your module...

ExcelJS.config.setValue('promise', require('bluebird'));

Please note: I have tested ExcelJS with bluebird specifically (since up until recently this was the library it used). From the tests I have done it will not work with Q.

Caveats

Dist Folder

Before publishing this module, the source code is transpiled and otherwise processed before being placed in a dist/ folder. This README identifies two files - a browserified bundle and minified version. No other contents of the dist/ folder are guaranteed in any way other than the file specified as "main" in the package.json

Known Issues

Testing with Puppeteer

The test suite included in this lib includes a small script executed in a headless browser to validate the bundled packages. At the time of this writing, it appears that this test does not play nicely in the Windows Linux subsystem.

For this reason, the browser test can be disabled by the existence of a file named .disable-test-browser

sudo apt-get install libfontconfig

Splice vs Merge

If any splice operation affects a merged cell, the merge group will not be moved correctly

Release History

VersionChanges
0.0.9
0.1.0
0.1.1
  • Bug Fixes
    • More textual data written properly to xml (including text, hyperlinks, formula results and format codes)
    • Better date format code recognition
  • Cell Font Style
0.1.2
  • Fixed potential race condition on zip write
0.1.3
0.1.5
  • Bug Fixes
    • Now handles 10 or more worksheets in one workbook
    • theme1.xml file properly added and referenced
  • Cell Borders
0.1.6
  • Bug Fixes
    • More compatible theme1.xml included in XLSX file
  • Cell Fills
0.1.8
  • Bug Fixes
    • More compatible theme1.xml included in XLSX file
    • Fixed filename case issue
  • Cell Fills
0.1.9
  • Bug Fixes
    • Added docProps files to satisfy Mac Excel users
    • Fixed filename case issue
    • Fixed worksheet id issue
  • Core Workbook Properties
0.1.10
  • Bug Fixes
    • Handles File Not Found error
  • CSV Files
0.1.11
0.2.0
  • Streaming XLSX Writer
    • At long last ExcelJS can support writing massive XLSX files in a scalable memory efficient manner. Performance has been optimised and even smaller spreadsheets can be faster to write than the document writer. Options have been added to control the use of shared strings and styles as these can both have a considerable effect on performance
  • Worksheet.lastRow
    • Access the last editable row in a worksheet.
  • Row.commit()
    • For streaming writers, this method commits the row (and any previous rows) to the stream. Committed rows will no longer be editable (and are typically deleted from the worksheet object). For Document type workbooks, this method has no effect.
0.2.2
  • One Billion Cells
    • Achievement Unlocked: A simple test using ExcelJS has created a spreadsheet with 1,000,000,000 cells. Made using random data with 100,000,000 rows of 10 cells per row. I cannot validate the file yet as Excel will not open it and I have yet to implement the streaming reader but I have every confidence that it is good since 1,000,000 rows loads ok.
0.2.3
  • Bug Fixes
  • Streaming XLSX Writer
    • At long last ExcelJS can support writing massive XLSX files in a scalable memory efficient manner. Performance has been optimised and even smaller spreadsheets can be faster to write than the document writer. Options have been added to control the use of shared strings and styles as these can both have a considerable effect on performance
  • Worksheet.lastRow
    • Access the last editable row in a worksheet.
  • Row.commit()
    • For streaming writers, this method commits the row (and any previous rows) to the stream. Committed rows will no longer be editable (and are typically deleted from the worksheet object). For Document type workbooks, this method has no effect.
0.2.4
0.2.6
0.2.7
  • Data Validations
    • Cells can now define validations that controls the valid values the cell can have
0.2.8
0.2.9
  • Fixed "read property 'richText' of undefined error. Thanks to james075
0.2.10
  • Refactoring Complete. All unit and integration tests pass.
0.2.11
0.2.12
0.2.13
0.2.14
0.2.15
0.2.16
0.2.17
0.2.18
0.2.19
0.2.20
0.2.21
0.2.22
0.2.23
  • Merged Fall back to JSON.stringify() if unknown Cell.Type #137 with some modification. If a cell value is assigned to an unrecognisable javascript object, the stored value in xlsx and csv files will be JSON stringified. Note that if the file is read again, no attempt will be made to parse the stringified JSON text. Thanks to wulfsolter for the contribution.
0.2.24
  • Merged Protect cell fix #166. This does not mean full support for protected cells merely that the parser is not confused by the extra xml. Thanks to jayflo for the contribution.
0.2.25
  • Added functions to delete cells, rows and columns from a worksheet. Modelled after the Array splice method, the functions allow cells, rows and columns to be deleted (and optionally inserted). See Columns and Rows for details.
    Note: Not compatible with cell merges
0.2.26
0.2.27
0.2.28
0.2.29
0.2.30
  • Merged Fix issue #178 #201. Adds the following properties to workbook:
    • title
    • subject
    • keywords
    • category
    • description
    • company
    • manager
    Thanks to stavenko for the contribution.
0.2.31
0.2.32
0.2.33
0.2.34
0.2.35
0.2.36
0.2.37
0.2.38
0.2.39
0.2.42
  • Browser Compatible!
    • Well mostly. I have added a browser sub-folder that contains a browserified bundle and an index.js that can be used to generate another. See Browser section for details.
  • Fixed corrupted theme.xml. Apologies for letting that through.
  • Merged [BUGFIX] data validation formulae undefined #253. Thanks to jayflo for the contribution.
0.2.43
0.2.44
  • Reduced Dependencies.
    • Goodbye lodash, goodbye bluebird. Minified bundle is now just over half what it was in the first version.
0.2.45
0.2.46
0.3.0
0.3.1
0.4.0
0.4.1
0.4.2
  • Addressed the following issues:

    These issues are potentially caused by a bug that caused colours with zero themes, tints or indexes to be rendered and parsed incorrectly.

    Regarding themes: the theme files stored inside the xlsx container hold important information regarding colours, styles etc and if the theme information from a loaded xlsx file is lost, the results can be unpredictable and undesirable. To address this, when an ExcelJS Workbook parses an XLSX file, it will preserve any theme files it finds and include them when writing to a new XLSX. If this behaviour is not desired, the Workbook class exposes a clearThemes() function which will drop the theme content. Note that this behaviour is only implemented in the document based Workbook class, not the streamed Reader and Writer.

0.4.3
0.4.4
0.4.6
0.4.9
  • Switching to transpiled code for distribution. This will ensure compatability with 4.0.0 and above from here on. And it will also allow use of much more expressive JS code in the lib folder!
  • Basic Image Support!Images can now be added to worksheets either as a tiled background or stretched over a range. Note: other features like rotation, etc. are not supported yet and will reqeuire further work.
0.4.10
0.4.11
0.4.12
0.4.13
0.4.14
0.5.0
0.5.1
0.6.0
0.6.1
0.6.2
0.7.0
0.7.1
0.8.0
0.8.1
0.8.2
0.8.3
0.8.4
0.8.5
0.9.0
0.9.1
1.0.0
1.0.1
1.0.2
1.1.0
1.1.1
1.1.2
1.1.3
1.2.0
1.2.1
1.3.0
1.4.2
1.4.3
1.4.5
1.4.6
1.4.7
1.4.8
1.4.9
1.4.10
1.4.12
1.4.13
1.5.0
1.5.1
1.6.0
1.6.1
1.6.2
1.6.3
1.7.0
1.8.0
1.9.0
1.9.1
1.10.0
1.11.0
1.12.0
1.12.1
1.12.2
1.13.0
1.14.0
1.15.0
2.0.1

Major Version Change

Introducing async/await to ExcelJS!

The new async and await features of JavaScript can help a lot to make code more readable and maintainable. To avoid confusion, particularly with returned promises from async functions, we have had to remove the Promise class configuration option and from v2 onwards ExcelJS will use native Promises. Since this is potentially a breaking change we're bumping the major version for this release.

Changes

3.0.0

Another Major Version Change

Javascript has changed a lot over the years, and so have the modules and technologies surrounding it. To this end, this major version of ExcelJS changes the structure of the publish artefacts:

Main Export is now the Original Javascript Source

Prior to this release, the transpiled ES5 code was exported as the package main. From now on, the package main comes directly from the lib/ folder. This means a number of dependencies have been removed, including the polyfills.

ES5 and Browserify are Still Included

In order to support those that still require ES5 ready code (e.g. as dependencies in web apps) the source code will still be transpiled and available in dist/es5.

The ES5 code is also browserified and available as dist/exceljs.js or dist/exceljs.min.js

See the section Importing for details

3.1.0
3.2.0
3.3.0
3.3.1
3.4.0
3.5.0
  • Conditional Formatting A subset of Excel Conditional formatting has been implemented! Specifically the formatting rules that do not require XML to be rendered inside an <extLst> node, or in other words everything except databar and three icon sets (3Triangles, 3Stars, 5Boxes). These will be implemented in due course
  • Merged remove core-js/ import #1030. Many thanks to jeffrey n. carre for this contribution. This change is used to create a new browserified bundle artefact that does not include any polyfills. See Browserify for details.
3.6.0
3.6.1
3.7.0
3.8.0
3.8.1

Keywords

FAQs

Package last updated on 31 Mar 2020

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc