2022-06-06 23:05:27 +00:00
|
|
|
|
/* xlsx.js (C) 2013-present SheetJS -- http://sheetjs.com */
|
|
|
|
|
/* vim: set ts=2: */
|
|
|
|
|
/*jshint mocha:true */
|
|
|
|
|
/* eslint-env mocha */
|
|
|
|
|
/*global process, document, require */
|
|
|
|
|
/*global ArrayBuffer, Uint8Array */
|
|
|
|
|
/*::
|
|
|
|
|
declare type EmptyFunc = (() => void) | null;
|
|
|
|
|
declare var afterEach:(test:EmptyFunc)=>void;
|
|
|
|
|
declare var cptable: any;
|
|
|
|
|
*/
|
|
|
|
|
import * as assert_ from 'https://deno.land/std/testing/asserts.ts';
|
|
|
|
|
import * as base64_ from 'https://deno.land/std/encoding/base64.ts';
|
|
|
|
|
const assert: any = {...assert_};
|
|
|
|
|
assert.throws = function(f: () => void) { assert.assertThrows(function() { try { f(); } catch(e) { throw e instanceof Error ? e : new Error(e); }})};
|
|
|
|
|
assert.doesNotThrow = function(f: ()=>void) { f(); };
|
|
|
|
|
assert.equal = assert.assertEquals;
|
|
|
|
|
assert.notEqual = assert.assertNotEquals;
|
|
|
|
|
assert.deepEqual = (x: any,y: any, z?: string) => assert.equal(JSON.stringify(x), JSON.stringify(y), z);
|
|
|
|
|
|
|
|
|
|
// @deno-types="./types/index.d.ts"
|
|
|
|
|
import * as X from './xlsx.mjs';
|
|
|
|
|
import * as cptable from './dist/cpexcel.full.mjs';
|
|
|
|
|
X.set_cptable(cptable);
|
|
|
|
|
import XLSX_ZAHL from './dist/xlsx.zahl.mjs';
|
|
|
|
|
var DIF_XL = true;
|
|
|
|
|
|
|
|
|
|
type BSEncoding = 'utf-8' | 'binary' | 'base64';
|
|
|
|
|
type BFEncoding = 'buffer';
|
|
|
|
|
type ShEncoding = BSEncoding | BFEncoding;
|
|
|
|
|
function readFileSync2(x: string): Uint8Array;
|
|
|
|
|
function readFileSync2(x: string, e: BSEncoding): string;
|
|
|
|
|
function readFileSync2(x: string, e: BFEncoding): Uint8Array;
|
|
|
|
|
function readFileSync2(x: string, e?: ShEncoding): Uint8Array | string {
|
|
|
|
|
const u8 = Deno.readFileSync(x);
|
|
|
|
|
if(!e) return u8;
|
|
|
|
|
switch(e) {
|
|
|
|
|
case 'utf-8': return new TextDecoder().decode(u8);
|
|
|
|
|
case 'base64': return base64_.encode(u8);
|
|
|
|
|
case 'buffer': return u8;
|
|
|
|
|
case 'binary': return Array.from({length: u8.length}, (_,i) => String.fromCharCode(u8[i])).join("");
|
|
|
|
|
}
|
|
|
|
|
throw new Error(`unsupported encoding ${e}`)
|
|
|
|
|
}
|
|
|
|
|
var fs = {
|
|
|
|
|
readFileSync: readFileSync2,
|
|
|
|
|
existsSync: (x: string): boolean => { try { Deno.readFileSync(x); } catch(e) { return false; } return true; },
|
|
|
|
|
readdirSync: (x: string) => ([...Deno.readDirSync(x)].filter(x => x.isFile).map(x => x.name))
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var browser = false;
|
|
|
|
|
|
|
|
|
|
var Buffer_from = function(data: any, enc?: string): Uint8Array {
|
|
|
|
|
if(data instanceof Uint8Array) return data;
|
|
|
|
|
if((!enc || enc == "utf8") && typeof data == "string") return new TextEncoder().encode(data);
|
|
|
|
|
if(enc == "binary" && typeof data == "string") return Uint8Array.from({length: data.length}, (_,i) => data[i].charCodeAt(0))
|
|
|
|
|
throw `unsupported encoding ${enc}`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var opts: any = {cellNF: true};
|
|
|
|
|
var TYPE: 'buffer' = "buffer";
|
|
|
|
|
opts.type = TYPE;
|
|
|
|
|
var fullex = [".xlsb", /*".xlsm",*/ ".xlsx"/*, ".xlml", ".xls"*/];
|
|
|
|
|
var ofmt: X.BookType[] = ["xlsb", "xlsm", "xlsx", "ods", "biff2", "biff5", "biff8", "xlml", "sylk", "dif", "dbf", "eth", "fods", "csv", "txt", "html"];
|
|
|
|
|
var ex = fullex.slice(); ex = ex.concat([".ods", ".xls", ".xml", ".fods"]);
|
|
|
|
|
opts.WTF = true;
|
|
|
|
|
opts.cellStyles = true;
|
|
|
|
|
if(Deno.env.get("FMTS") === "full") Deno.env.set("FMTS", ex.join(":"));
|
|
|
|
|
if(Deno.env.get("FMTS")) ex=(Deno.env.get("FMTS")||"").split(":").map(function(x){return x[0]==="."?x:"."+x;});
|
|
|
|
|
var exp = ex.map(function(x: string){ return x + ".pending"; });
|
|
|
|
|
function test_file(x: string){ return ex.indexOf(x.slice(-5))>=0||exp.indexOf(x.slice(-13))>=0 || ex.indexOf(x.slice(-4))>=0||exp.indexOf(x.slice(-12))>=0; }
|
|
|
|
|
|
|
|
|
|
var files: string[] = [], fileA: string[] = [];
|
|
|
|
|
if(!browser) {
|
|
|
|
|
var _files = fs.existsSync('tests.lst') ? fs.readFileSync('tests.lst', 'utf-8').split("\n").map(function(x) { return x.trim(); }) : fs.readdirSync('test_files');
|
|
|
|
|
for(var _filesi = 0; _filesi < _files.length; ++_filesi) if(test_file(_files[_filesi])) files.push(_files[_filesi]);
|
|
|
|
|
var _fileA = fs.existsSync('tests/testA.lst') ? fs.readFileSync('tests/testA.lst', 'utf-8').split("\n").map(function(x) { return x.trim(); }) : [];
|
|
|
|
|
for(var _fileAi = 0; _fileAi < _fileA.length; ++_fileAi) if(test_file(_fileA[_fileAi])) fileA.push(_fileA[_fileAi]);
|
|
|
|
|
}
|
|
|
|
|
|
2022-09-22 09:05:24 +00:00
|
|
|
|
var can_write_numbers = typeof Set !== "undefined" && typeof Array.prototype.findIndex == "function" && typeof Uint8Array !== "undefined" && typeof Uint8Array.prototype.indexOf == "function";
|
|
|
|
|
|
2022-06-06 23:05:27 +00:00
|
|
|
|
/* Excel enforces 31 character sheet limit, although technical file limit is 255 */
|
|
|
|
|
function fixsheetname(x: string): string { return x.substr(0,31); }
|
|
|
|
|
|
|
|
|
|
function stripbom(x: string): string { return x.replace(/^\ufeff/,""); }
|
|
|
|
|
function fixcsv(x: string): string { return stripbom(x).replace(/\t/g,",").replace(/#{255}/g,"").replace(/"/g,"").replace(/[\n\r]+/g,"\n").replace(/\n*$/,""); }
|
|
|
|
|
function fixjson(x: string): string { return x.replace(/[\r\n]+$/,""); }
|
|
|
|
|
|
|
|
|
|
var dir = "./test_files/";
|
|
|
|
|
|
|
|
|
|
var dirwp = dir + "artifacts/wps/", dirqp = dir + "artifacts/quattro/";
|
|
|
|
|
var paths: any = {
|
|
|
|
|
aadbf: dirwp + 'write.dbf',
|
|
|
|
|
aadif: dirwp + 'write.dif',
|
|
|
|
|
aaxls: dirwp + 'write.xls',
|
|
|
|
|
aaxlsx: dirwp + 'write.xlsx',
|
|
|
|
|
aaxml: dirwp + 'write.xml',
|
|
|
|
|
|
|
|
|
|
abcsv: dirqp + 'write_.csv',
|
|
|
|
|
abdif: dirqp + 'write_.dif',
|
|
|
|
|
abslk: dirqp + 'write_.slk',
|
|
|
|
|
abx57: dirqp + 'write_57.xls',
|
|
|
|
|
abwb2: dirqp + 'write_6.wb2',
|
|
|
|
|
abwb2b: dirqp + 'write_6b.wb2',
|
|
|
|
|
abwb3: dirqp + 'write_8.wb3',
|
|
|
|
|
abqpw: dirqp + 'write_9.qpw',
|
|
|
|
|
abx97: dirqp + 'write_97.xls',
|
|
|
|
|
abwks: dirqp + 'write_L1.wks',
|
|
|
|
|
abwk1: dirqp + 'write_L2.wk1',
|
|
|
|
|
abwk3: dirqp + 'write_L3.wk3',
|
|
|
|
|
abwk4: dirqp + 'write_L45.wk4',
|
|
|
|
|
ab123: dirqp + 'write_L9.123',
|
|
|
|
|
ab124: dirqp + 'write_L97.123',
|
|
|
|
|
abwke2: dirqp + 'write_Led.wke',
|
|
|
|
|
abwq1: dirqp + 'write_qpdos.wq1',
|
|
|
|
|
abwb1: dirqp + 'write_qpw.wb1',
|
|
|
|
|
|
|
|
|
|
afxls: dir + 'AutoFilter.xls',
|
|
|
|
|
afxml: dir + 'AutoFilter.xml',
|
|
|
|
|
afods: dir + 'AutoFilter.ods',
|
|
|
|
|
afxlsx: dir + 'AutoFilter.xlsx',
|
|
|
|
|
afxlsb: dir + 'AutoFilter.xlsb',
|
|
|
|
|
|
|
|
|
|
asxls: dir + 'author_snowman.xls',
|
|
|
|
|
asxls5: dir + 'author_snowman.xls5',
|
|
|
|
|
asxml: dir + 'author_snowman.xml',
|
|
|
|
|
asods: dir + 'author_snowman.ods',
|
|
|
|
|
asxlsx: dir + 'author_snowman.xlsx',
|
|
|
|
|
asxlsb: dir + 'author_snowman.xlsb',
|
|
|
|
|
|
|
|
|
|
cpxls: dir + 'custom_properties.xls',
|
|
|
|
|
cpxml: dir + 'custom_properties.xls.xml',
|
|
|
|
|
cpxlsx: dir + 'custom_properties.xlsx',
|
|
|
|
|
cpxlsb: dir + 'custom_properties.xlsb',
|
|
|
|
|
|
|
|
|
|
cssxls: dir + 'cell_style_simple.xls',
|
|
|
|
|
cssxml: dir + 'cell_style_simple.xml',
|
|
|
|
|
cssxlsx: dir + 'cell_style_simple.xlsx',
|
|
|
|
|
cssxlsb: dir + 'cell_style_simple.xlsb',
|
|
|
|
|
|
|
|
|
|
cstxls: dir + 'comments_stress_test.xls',
|
|
|
|
|
cstxml: dir + 'comments_stress_test.xls.xml',
|
|
|
|
|
cstxlsx: dir + 'comments_stress_test.xlsx',
|
|
|
|
|
cstxlsb: dir + 'comments_stress_test.xlsb',
|
|
|
|
|
cstods: dir + 'comments_stress_test.ods',
|
|
|
|
|
|
|
|
|
|
cwxls: dir + 'column_width.xls',
|
|
|
|
|
cwxls5: dir + 'column_width.biff5',
|
|
|
|
|
cwxml: dir + 'column_width.xml',
|
|
|
|
|
cwxlsx: dir + 'column_width.xlsx',
|
|
|
|
|
cwxlsb: dir + 'column_width.xlsb',
|
|
|
|
|
cwslk: dir + 'column_width.slk',
|
|
|
|
|
|
|
|
|
|
dnsxls: dir + 'defined_names_simple.xls',
|
|
|
|
|
dnsxml: dir + 'defined_names_simple.xml',
|
|
|
|
|
dnsxlsx: dir + 'defined_names_simple.xlsx',
|
|
|
|
|
dnsxlsb: dir + 'defined_names_simple.xlsb',
|
|
|
|
|
dnsslk: dir + 'defined_names_simple.slk',
|
|
|
|
|
|
|
|
|
|
dnuxls: dir + 'defined_names_unicode.xls',
|
|
|
|
|
dnuxml: dir + 'defined_names_unicode.xml',
|
|
|
|
|
dnuods: dir + 'defined_names_unicode.ods',
|
|
|
|
|
dnuxlsx: dir + 'defined_names_unicode.xlsx',
|
|
|
|
|
dnuxlsb: dir + 'defined_names_unicode.xlsb',
|
|
|
|
|
|
|
|
|
|
dtxls: dir + 'xlsx-stream-d-date-cell.xls',
|
|
|
|
|
dtxml: dir + 'xlsx-stream-d-date-cell.xls.xml',
|
|
|
|
|
dtxlsx: dir + 'xlsx-stream-d-date-cell.xlsx',
|
|
|
|
|
dtxlsb: dir + 'xlsx-stream-d-date-cell.xlsb',
|
|
|
|
|
|
|
|
|
|
dtfxlsx: dir + 'DataTypesFormats.xlsx',
|
|
|
|
|
|
|
|
|
|
fstxls: dir + 'formula_stress_test.xls',
|
|
|
|
|
fstxml: dir + 'formula_stress_test.xls.xml',
|
|
|
|
|
fstxlsx: dir + 'formula_stress_test.xlsx',
|
|
|
|
|
fstxlsb: dir + 'formula_stress_test.xlsb',
|
|
|
|
|
fstods: dir + 'formula_stress_test.ods',
|
|
|
|
|
|
|
|
|
|
hlxls: dir + 'hyperlink_stress_test_2011.xls',
|
|
|
|
|
hlxml: dir + 'hyperlink_stress_test_2011.xml',
|
|
|
|
|
hlxlsx: dir + 'hyperlink_stress_test_2011.xlsx',
|
|
|
|
|
hlxlsb: dir + 'hyperlink_stress_test_2011.xlsb',
|
|
|
|
|
|
|
|
|
|
ilxls: dir + 'internal_link.xls',
|
|
|
|
|
ilxls5: dir + 'internal_link.biff5',
|
|
|
|
|
ilxml: dir + 'internal_link.xml',
|
|
|
|
|
ilxlsx: dir + 'internal_link.xlsx',
|
|
|
|
|
ilxlsb: dir + 'internal_link.xlsb',
|
|
|
|
|
ilods: dir + 'internal_link.ods',
|
|
|
|
|
|
|
|
|
|
lonxls: dir + 'LONumbers.xls',
|
|
|
|
|
lonxlsx: dir + 'LONumbers.xlsx',
|
|
|
|
|
|
|
|
|
|
m19xlsx: dir + 'metadata_2019.xlsx',
|
|
|
|
|
m19xlsb: dir + 'metadata_2019.xlsb',
|
|
|
|
|
|
|
|
|
|
mcxls: dir + 'merge_cells.xls',
|
|
|
|
|
mcxml: dir + 'merge_cells.xls.xml',
|
|
|
|
|
mcxlsx: dir + 'merge_cells.xlsx',
|
|
|
|
|
mcxlsb: dir + 'merge_cells.xlsb',
|
|
|
|
|
mcods: dir + 'merge_cells.ods',
|
|
|
|
|
|
|
|
|
|
nfxls: dir + 'number_format.xls',
|
|
|
|
|
nfxml: dir + 'number_format.xls.xml',
|
|
|
|
|
nfxlsx: dir + 'number_format.xlsm',
|
|
|
|
|
nfxlsb: dir + 'number_format.xlsb',
|
|
|
|
|
|
|
|
|
|
olxls: dir + 'outline.xls',
|
|
|
|
|
olxls5: dir + 'outline.biff5',
|
|
|
|
|
olxlsx: dir + 'outline.xlsx',
|
|
|
|
|
olxlsb: dir + 'outline.xlsb',
|
|
|
|
|
olods: dir + 'outline.ods',
|
|
|
|
|
|
|
|
|
|
pmxls: dir + 'page_margins_2016.xls',
|
|
|
|
|
pmxls5: dir + 'page_margins_2016_5.xls',
|
|
|
|
|
pmxml: dir + 'page_margins_2016.xml',
|
|
|
|
|
pmxlsx: dir + 'page_margins_2016.xlsx',
|
|
|
|
|
pmxlsb: dir + 'page_margins_2016.xlsb',
|
|
|
|
|
|
|
|
|
|
rhxls: dir + 'row_height.xls',
|
|
|
|
|
rhxls5: dir + 'row_height.biff5',
|
|
|
|
|
rhxml: dir + 'row_height.xml',
|
|
|
|
|
rhxlsx: dir + 'row_height.xlsx',
|
|
|
|
|
rhxlsb: dir + 'row_height.xlsb',
|
|
|
|
|
rhslk: dir + 'row_height.slk',
|
|
|
|
|
|
|
|
|
|
svxls: dir + 'sheet_visibility.xls',
|
|
|
|
|
svxls5: dir + 'sheet_visibility5.xls',
|
|
|
|
|
svxml: dir + 'sheet_visibility.xml',
|
|
|
|
|
svxlsx: dir + 'sheet_visibility.xlsx',
|
|
|
|
|
svxlsb: dir + 'sheet_visibility.xlsb',
|
|
|
|
|
svods: dir + 'sheet_visibility.ods',
|
|
|
|
|
|
|
|
|
|
swcxls: dir + 'apachepoi_SimpleWithComments.xls',
|
|
|
|
|
swcxml: dir + '2011/apachepoi_SimpleWithComments.xls.xml',
|
|
|
|
|
swcxlsx: dir + 'apachepoi_SimpleWithComments.xlsx',
|
|
|
|
|
swcxlsb: dir + '2013/apachepoi_SimpleWithComments.xlsx.xlsb'
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
function pathit(p: string, ext: string[]) { return ext.map(function(n) { return paths[p + n]; }); }
|
|
|
|
|
var FSTPaths = pathit("fst", ["xlsx", "xlsb", "xls", "xml", "ods"]);
|
|
|
|
|
var CSTPaths = pathit("cst", ["xlsx", "xlsb", "xls", "xml", "ods"]);
|
|
|
|
|
var MCPaths = pathit("mc", ["xlsx", "xlsb", "xls", "xml", "ods"]);
|
|
|
|
|
var CSSPaths = pathit("css", ["xlsx", "xlsb", "xls", "xml"]);
|
|
|
|
|
var NFPaths = pathit("nf", ["xlsx", "xlsb", "xls", "xml"]);
|
|
|
|
|
var DTPaths = pathit("dt", ["xlsx", "xlsb", "xls", "xml"]);
|
|
|
|
|
var HLPaths = pathit("hl", ["xlsx", "xlsb", "xls", "xml"]);
|
|
|
|
|
var ILPaths = pathit("il", ["xlsx", "xlsb", "xls", "xml", "ods", "xls5"]);
|
|
|
|
|
var OLPaths = pathit("ol", ["xlsx", "xlsb", "xls", "ods", "xls5"]);
|
|
|
|
|
var PMPaths = pathit("pm", ["xlsx", "xlsb", "xls", "xml", "xls5"]);
|
|
|
|
|
var SVPaths = pathit("sv", ["xlsx", "xlsb", "xls", "xml", "xls5"]);
|
|
|
|
|
var CWPaths = pathit("cw", ["xlsx", "xlsb", "xls", "xml", "xls5", "slk"]);
|
|
|
|
|
var RHPaths = pathit("rh", ["xlsx", "xlsb", "xls", "xml", "xls5", "slk"]);
|
|
|
|
|
|
|
|
|
|
var artifax = [
|
|
|
|
|
"cstods", "cstxls", "cstxlsb", "cstxlsb", "cstxml", "aadbf", "aadif",
|
|
|
|
|
"aaxls", "aaxml", "aaxlsx", "ab123", "ab124", "abcsv", "abdif", "abqpw",
|
|
|
|
|
"abslk", "abwb1", "abwb2", "abwb3", "abwk1", "abwk3", "abwk4", "abwks",
|
|
|
|
|
"abwq1", "abx57", "abx97", "abwke2", "abwb2b"
|
|
|
|
|
].map(function(x) { return paths[x]; });
|
|
|
|
|
|
|
|
|
|
async function parsetest(x: string, wb: X.WorkBook, full: boolean, ext: string, t: Deno.TestContext) {
|
|
|
|
|
ext = (ext ? " [" + ext + "]": "");
|
|
|
|
|
if(!full && ext) return;
|
|
|
|
|
describe(x + ext + ' should have all bits', function() {
|
|
|
|
|
var sname = dir + '2016/' + x.substr(x.lastIndexOf('/')+1) + '.sheetnames';
|
|
|
|
|
if(!fs.existsSync(sname)) sname = dir + '2011/' + x.substr(x.lastIndexOf('/')+1) + '.sheetnames';
|
|
|
|
|
if(!fs.existsSync(sname)) sname = dir + '2013/' + x.substr(x.lastIndexOf('/')+1) + '.sheetnames';
|
|
|
|
|
it('should have all sheets', function() {
|
|
|
|
|
wb.SheetNames.forEach(function(y) { assert.ok(wb.Sheets[y], 'bad sheet ' + y); });
|
|
|
|
|
});
|
|
|
|
|
if(fs.existsSync(sname)) it('should have the right sheet names', function() {
|
|
|
|
|
var file = fs.readFileSync(sname, 'utf-8').replace(/\r/g,"");
|
|
|
|
|
var names = wb.SheetNames.map(fixsheetname).join("\n") + "\n";
|
|
|
|
|
if(file.length && !x.match(/artifacts/)) assert.equal(names, file);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
describe(x + ext + ' should generate CSV', function() {
|
|
|
|
|
for(var i = 0; i < wb.SheetNames.length; ++i) { var ws = wb.SheetNames[i];
|
|
|
|
|
it('#' + i + ' (' + ws + ')', function() {
|
|
|
|
|
X.utils.sheet_to_csv(wb.Sheets[ws]);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
describe(x + ext + ' should generate JSON', function() {
|
|
|
|
|
for(var i = 0; i < wb.SheetNames.length; ++i) { var ws = wb.SheetNames[i];
|
|
|
|
|
it('#' + i + ' (' + ws + ')', function() {
|
|
|
|
|
X.utils.sheet_to_json(wb.Sheets[ws]);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
describe(x + ext + ' should generate formulae', function() {
|
|
|
|
|
for(var i = 0; i < wb.SheetNames.length; ++i) { var ws = wb.SheetNames[i];
|
|
|
|
|
it('#' + i + ' (' + ws + ')', function() {
|
|
|
|
|
X.utils.sheet_to_formulae(wb.Sheets[ws]);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
if(!full) return;
|
|
|
|
|
var getfile = function(dir: string, x: string, i: number, type: string) {
|
|
|
|
|
var name = (dir + x + '.' + i + type);
|
|
|
|
|
var root = "";
|
|
|
|
|
if(x.substr(-5) === ".xlsb") {
|
|
|
|
|
root = x.slice(0,-5);
|
|
|
|
|
if(!fs.existsSync(name)) name=(dir + root + '.xlsx.' + i + type);
|
|
|
|
|
if(!fs.existsSync(name)) name=(dir + root + '.xlsm.' + i + type);
|
|
|
|
|
if(!fs.existsSync(name)) name=(dir + root + '.xls.' + i + type);
|
|
|
|
|
}
|
|
|
|
|
if(x.substr(-4) === ".xls") {
|
|
|
|
|
root = x.slice(0,-4);
|
|
|
|
|
if(!fs.existsSync(name)) name=(dir + root + '.xlsx.' + i + type);
|
|
|
|
|
if(!fs.existsSync(name)) name=(dir + root + '.xlsm.' + i + type);
|
|
|
|
|
if(!fs.existsSync(name)) name=(dir + root + '.xlsb.' + i + type);
|
|
|
|
|
}
|
|
|
|
|
return name;
|
|
|
|
|
};
|
|
|
|
|
describe(x + ext + ' should generate correct CSV output', function() {
|
|
|
|
|
for(var i = 0; i < wb.SheetNames.length; ++i) { var ws = wb.SheetNames[i];
|
|
|
|
|
var name = getfile(dir, x, i, ".csv");
|
|
|
|
|
if(fs.existsSync(name)) it('#' + i + ' (' + ws + ')', function() {
|
|
|
|
|
var file = fs.readFileSync(name, 'utf-8');
|
|
|
|
|
var csv = X.utils.sheet_to_csv(wb.Sheets[ws]);
|
|
|
|
|
assert.equal(fixcsv(csv), fixcsv(file), "CSV badness");
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
if(typeof JSON !== 'undefined') describe(x + ext + ' should generate correct JSON output', function() {
|
|
|
|
|
for(var i = 0; i < wb.SheetNames.length; ++i) { var ws = wb.SheetNames[i];
|
|
|
|
|
var rawjson = getfile(dir, x, i, ".rawjson");
|
|
|
|
|
if(fs.existsSync(rawjson)) it('#' + i + ' (' + ws + ')', function() {
|
|
|
|
|
var file = fs.readFileSync(rawjson, 'utf-8');
|
|
|
|
|
var json: Array<any> = X.utils.sheet_to_json(wb.Sheets[ws],{raw:true});
|
|
|
|
|
assert.equal(JSON.stringify(json), fixjson(file), "JSON badness");
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
var jsonf = getfile(dir, x, i, ".json");
|
|
|
|
|
if(fs.existsSync(jsonf)) it('#' + i + ' (' + ws + ')', function() {
|
|
|
|
|
var file = fs.readFileSync(jsonf, 'utf-8');
|
|
|
|
|
var json: Array<any> = X.utils.sheet_to_json(wb.Sheets[ws], {raw:false});
|
|
|
|
|
assert.equal(JSON.stringify(json), fixjson(file), "JSON badness");
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
if(fs.existsSync(dir + '2011/' + x + '.xml'))
|
|
|
|
|
describe(x + ext + '.xml from 2011', function() {
|
|
|
|
|
it('should parse', function() {
|
|
|
|
|
/*var wb = */X.readFile(dir + '2011/' + x + '.xml', opts);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
if(fs.existsSync(dir + '2013/' + x + '.xlsb'))
|
|
|
|
|
describe(x + ext + '.xlsb from 2013', function() {
|
|
|
|
|
it('should parse', function() {
|
|
|
|
|
/*var wb = */X.readFile(dir + '2013/' + x + '.xlsb', opts);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
if(fs.existsSync(dir + x + '.xml' + ext))
|
|
|
|
|
describe(x + '.xml', function() {
|
|
|
|
|
it('should parse', function() {
|
|
|
|
|
/*var wb = */X.readFile(dir + x + '.xml', opts);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
describe('should parse test files', function() {
|
|
|
|
|
var idx = 0, x = "";
|
|
|
|
|
for(idx = 0; idx < files.length; ++idx) { var x = files[idx];
|
|
|
|
|
if(x.slice(-8) == ".pending" || !fs.existsSync(dir + x)) continue;
|
|
|
|
|
it(x, function() {
|
|
|
|
|
var _wb = X.readFile(dir + x, opts);
|
|
|
|
|
await parsetest(x, _wb, true, "", t);
|
|
|
|
|
for(var fidx = 0; fidx < fullex.length; ++fidx) { var ext = fullex[fidx];
|
|
|
|
|
it(x + ' [' + ext + ']', function(){
|
|
|
|
|
var wb = _wb;
|
|
|
|
|
wb = X.read(X.write(wb, {type:"buffer", bookType:(ext.replace(/\./,"") as X.BookType)}), {WTF:opts.WTF, cellNF: true});
|
|
|
|
|
await parsetest(x, wb, ext.replace(/\./,"") !== "xlsb", ext, t);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
for(idx = 0; idx < fileA.length; ++idx) { var x = fileA[idx];
|
|
|
|
|
if(x.slice(-8) == ".pending" || !fs.existsSync(dir + x)) continue;
|
|
|
|
|
it(x, function() {
|
|
|
|
|
var wb = X.readFile(dir + x, {WTF:opts.WTF, sheetRows:10});
|
|
|
|
|
await parsetest(x, wb, false, "", t);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
function get_cell(ws: X.WorkSheet, addr: string) {
|
2024-07-04 19:54:34 +00:00
|
|
|
|
if(!Array.isArray(ws["!data"])) return ws[addr];
|
2022-06-06 23:05:27 +00:00
|
|
|
|
var a = X.utils.decode_cell(addr);
|
2024-07-04 19:54:34 +00:00
|
|
|
|
return (ws["!data"][a.r]||[])[a.c];
|
2022-06-06 23:05:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function each_cell(ws: X.WorkSheet, f: (c: X.CellObject) => any) {
|
|
|
|
|
if(Array.isArray(ws)) ws.forEach(function(row) { if(row) row.forEach(f); });
|
|
|
|
|
else Object.keys(ws).forEach(function(addr) { if(addr[0] === "!" || !ws.hasOwnProperty(addr)) return; f(ws[addr]); });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function each_sheet(wb: X.WorkBook, f: (ws: X.WorkSheet, i: number)=>any) { wb.SheetNames.forEach(function(n, i) { f(wb.Sheets[n], i); }); }
|
|
|
|
|
|
|
|
|
|
/* comments_stress_test family */
|
|
|
|
|
function check_comments(wb: X.WorkBook) {
|
|
|
|
|
var ws0 = wb.Sheets["Sheet2"];
|
|
|
|
|
assert.equal(get_cell(ws0,"A1").c[0].a, 'Author');
|
|
|
|
|
assert.equal(get_cell(ws0,"A1").c[0].t, 'Author:\nGod thinks this is good');
|
|
|
|
|
assert.equal(get_cell(ws0,"C1").c[0].a, 'Author');
|
|
|
|
|
assert.equal(get_cell(ws0,"C1").c[0].t, 'I really hope that xlsx decides not to use magic like rPr');
|
|
|
|
|
|
|
|
|
|
var ws3 = wb.Sheets["Sheet4"];
|
|
|
|
|
assert.equal(get_cell(ws3,"B1").c[0].a, 'Author');
|
|
|
|
|
assert.equal(get_cell(ws3,"B1").c[0].t, 'The next comment is empty');
|
|
|
|
|
assert.equal(get_cell(ws3,"B2").c[0].a, 'Author');
|
|
|
|
|
assert.equal(get_cell(ws3,"B2").c[0].t, '');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
describe('parse options', function() {
|
|
|
|
|
var html_cell_types = ['s'];
|
|
|
|
|
describe('cell', function() {
|
|
|
|
|
it('XLSX should generate HTML by default', function() {
|
|
|
|
|
var wb = X.read(fs.readFileSync(paths.cstxlsx), {type:TYPE});
|
|
|
|
|
var ws = wb.Sheets["Sheet1"];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(html_cell_types.indexOf(cell.t) === -1 || cell.h);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('XLSX should not generate HTML when requested', function() {
|
|
|
|
|
var wb = X.read(fs.readFileSync(paths.cstxlsx), {type:TYPE, cellHTML:false});
|
|
|
|
|
var ws = wb.Sheets["Sheet1"];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(typeof cell.h === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should generate formulae by default', function() {
|
|
|
|
|
FSTPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE});
|
|
|
|
|
var found = false;
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
each_cell(wb.Sheets[s], function(cell) {
|
|
|
|
|
if(typeof cell.f !== 'undefined') return (found = true);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
assert.ok(found);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should not generate formulae when requested', function() {
|
|
|
|
|
FSTPaths.forEach(function(p) {
|
|
|
|
|
var wb =X.read(fs.readFileSync(p),{type:TYPE,cellFormula:false});
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
each_cell(wb.Sheets[s], function(cell) {
|
|
|
|
|
assert.ok(typeof cell.f === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should generate formatted text by default', function() {
|
|
|
|
|
FSTPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p),{type:TYPE});
|
|
|
|
|
var found = false;
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
var ws = wb.Sheets[s];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
if(typeof cell.w !== 'undefined') return (found = true);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
assert.ok(found);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should not generate formatted text when requested', function() {
|
|
|
|
|
FSTPaths.forEach(function(p) {
|
|
|
|
|
var wb =X.read(fs.readFileSync(p),{type:TYPE, cellText:false});
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
var ws = wb.Sheets[s];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(typeof cell.w === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should not generate number formats by default', function() {
|
|
|
|
|
NFPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE});
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
var ws = wb.Sheets[s];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(typeof cell.z === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should generate number formats when requested', function() {
|
|
|
|
|
NFPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, cellNF: true});
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
var ws = wb.Sheets[s];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(cell.t!== 'n' || typeof cell.z !== 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should not generate cell styles by default', function() {
|
|
|
|
|
CSSPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, WTF:true});
|
|
|
|
|
wb.SheetNames.forEach(function(s) {
|
|
|
|
|
var ws = wb.Sheets[s];
|
|
|
|
|
each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(typeof cell.s === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should generate cell styles when requested', function() {
|
|
|
|
|
/* TODO: XLS / XLML */
|
|
|
|
|
[paths.cssxlsx /*, paths.cssxlsb, paths.cssxls, paths.cssxml*/].forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, cellStyles:true});
|
|
|
|
|
var found = false;
|
|
|
|
|
each_sheet(wb, function(ws/*::, i*/) { /*:: void i; */each_cell(ws, function(cell) {
|
|
|
|
|
if(typeof cell.s !== 'undefined') return (found = true);
|
|
|
|
|
}); });
|
|
|
|
|
assert.ok(found);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should not generate cell dates by default', function() {
|
|
|
|
|
DTPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE});
|
|
|
|
|
each_sheet(wb, function(ws/*::, i*/) { /*:: void i; */each_cell(ws, function(cell) {
|
|
|
|
|
assert.ok(cell.t !== 'd');
|
|
|
|
|
}); });
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should generate cell dates when requested', function() {
|
|
|
|
|
DTPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, cellDates: true, WTF:true});
|
|
|
|
|
var found = false;
|
|
|
|
|
each_sheet(wb, function(ws/*::, i*/) { /*:: void i; */each_cell(ws, function(cell) {
|
|
|
|
|
if(cell.t === 'd') return (found = true);
|
|
|
|
|
}); });
|
|
|
|
|
assert.ok(found);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should preserve `_xlfn.` only when requested', function() {
|
|
|
|
|
var wb = { SheetNames: ["Sheet1"], Sheets: { Sheet1: {
|
|
|
|
|
"!ref": "A1:A1",
|
|
|
|
|
"A1": { t:"n", v:2, f:"_xlfn.IFS(2>3,1,3>2,2)"}
|
|
|
|
|
} } };
|
|
|
|
|
var str = X.write(wb, {bookType: "xlsx", type: "binary"});
|
|
|
|
|
var wb2 = X.read(str, {type: "binary"});
|
|
|
|
|
/*jshint -W069 */
|
|
|
|
|
assert.equal(wb2.Sheets["Sheet1"]["A1"].f, "IFS(2>3,1,3>2,2)");
|
|
|
|
|
var wb3 = X.read(str, {type: "binary", xlfn: true});
|
|
|
|
|
assert.equal(wb3.Sheets["Sheet1"]["A1"].f, "_xlfn.IFS(2>3,1,3>2,2)");
|
|
|
|
|
/*jshint +W069 */
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
describe('sheet', function() {
|
|
|
|
|
it('should not generate sheet stubs by default', function() {
|
|
|
|
|
MCPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE});
|
|
|
|
|
assert.throws(function() { return get_cell(wb.Sheets["Merge"], "A2").v; });
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should generate sheet stubs when requested', function() {
|
|
|
|
|
MCPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, sheetStubs:true});
|
|
|
|
|
assert.ok(get_cell(wb.Sheets["Merge"], "A2").t == 'z');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('should handle stub cells', function() {
|
|
|
|
|
MCPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, sheetStubs:true});
|
|
|
|
|
X.utils.sheet_to_csv(wb.Sheets["Merge"]);
|
|
|
|
|
X.utils.sheet_to_json(wb.Sheets["Merge"]);
|
|
|
|
|
X.utils.sheet_to_formulae(wb.Sheets["Merge"]);
|
|
|
|
|
ofmt.forEach(function(f) { if(f != "dbf") X.write(wb, {type:TYPE, bookType:f}); });
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
function checkcells(wb: X.WorkBook, A46: boolean, B26: boolean, C16: boolean, D2: boolean) {
|
|
|
|
|
([ ["A46", A46], ["B26", B26], ["C16", C16], ["D2", D2] ] as Array<[string, boolean]>).forEach(function(r: [string, boolean]) {
|
|
|
|
|
assert.ok((typeof get_cell(wb.Sheets["Text"], r[0]) !== 'undefined') == r[1]);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
it('should read all cells by default', function() { FSTPaths.forEach(function(p) {
|
|
|
|
|
checkcells(X.read(fs.readFileSync(p), {type:TYPE}), true, true, true, true);
|
|
|
|
|
}); });
|
|
|
|
|
it('sheetRows n=30', function() { FSTPaths.forEach(function(p) {
|
|
|
|
|
checkcells(X.read(fs.readFileSync(p), {type:TYPE, sheetRows:30}), false, true, true, true);
|
|
|
|
|
}); });
|
|
|
|
|
it('sheetRows n=20', function() { FSTPaths.forEach(function(p) {
|
|
|
|
|
checkcells(X.read(fs.readFileSync(p), {type:TYPE, sheetRows:20}), false, false, true, true);
|
|
|
|
|
}); });
|
|
|
|
|
it('sheetRows n=10', function() { FSTPaths.forEach(function(p) {
|
|
|
|
|
checkcells(X.read(fs.readFileSync(p), {type:TYPE, sheetRows:10}), false, false, false, true);
|
|
|
|
|
}); });
|
|
|
|
|
it('sheetRows n=1', function() { ofmt.forEach(function(fmt) {
|
|
|
|
|
([TYPE, "base64", "binary", "array"] as Array<'binary' | 'base64' | 'binary' | 'array'>).forEach(function(ot) {
|
|
|
|
|
var data = [[1,2],[3,4],[5,6]];
|
|
|
|
|
var ws = X.utils.aoa_to_sheet(data);
|
|
|
|
|
assert.ok(ws['!ref'] === "A1:B3");
|
|
|
|
|
var wb = X.utils.book_new();
|
|
|
|
|
X.utils.book_append_sheet(wb, ws, "Sheet1");
|
|
|
|
|
var bs = X.write(wb, { bookType: fmt, type: ot, WTF:true });
|
|
|
|
|
|
|
|
|
|
var wb0 = X.read(bs, { type: ot, WTF:true });
|
|
|
|
|
var ws0 = wb0.Sheets["Sheet1"];
|
|
|
|
|
assert.equal(ws0['!ref'], "A1:B3");
|
|
|
|
|
assert.equal(get_cell(ws0, "A1").v, fmt == "dbf" ? "1" : 1);
|
|
|
|
|
assert.equal(get_cell(ws0, "B2").v, 4);
|
|
|
|
|
assert.equal(get_cell(ws0, "A3").v, 5);
|
|
|
|
|
|
|
|
|
|
var wb1 = X.read(bs, { type: ot, sheetRows: 1 });
|
|
|
|
|
var ws1 = wb1.Sheets["Sheet1"];
|
|
|
|
|
assert.equal(ws1['!ref'], "A1:B1");
|
|
|
|
|
assert.equal(get_cell(ws1, "A1").v, fmt == "dbf" ? "1" : 1);
|
|
|
|
|
assert.ok(!get_cell(ws1, "B2"));
|
|
|
|
|
assert.ok(!get_cell(ws1, "A3"));
|
|
|
|
|
if(ws1['!fullref']) assert.equal(ws1['!fullref'], "A1:B3");
|
|
|
|
|
|
|
|
|
|
var wb2 = X.read(bs, { type: ot, sheetRows: 2 });
|
|
|
|
|
var ws2 = wb2.Sheets["Sheet1"];
|
|
|
|
|
assert.equal(ws2['!ref'], "A1:B2");
|
|
|
|
|
assert.equal(get_cell(ws2, "A1").v, fmt == "dbf" ? "1" : 1);
|
|
|
|
|
assert.equal(get_cell(ws2, "B2").v, 4);
|
|
|
|
|
assert.ok(!get_cell(ws2, "A3"));
|
|
|
|
|
if(ws2['!fullref']) assert.equal(ws2['!fullref'], "A1:B3");
|
|
|
|
|
|
|
|
|
|
var wb3 = X.read(bs, { type: ot, sheetRows: 3 });
|
|
|
|
|
var ws3 = wb3.Sheets["Sheet1"];
|
|
|
|
|
assert.equal(ws3['!ref'], "A1:B3");
|
|
|
|
|
assert.equal(get_cell(ws3, "A1").v, fmt == "dbf" ? "1" : 1);
|
|
|
|
|
assert.equal(get_cell(ws3, "B2").v, 4);
|
|
|
|
|
assert.equal(get_cell(ws3, "A3").v, 5);
|
|
|
|
|
if(ws3['!fullref']) assert.equal(ws3['!fullref'], "A1:B3");
|
|
|
|
|
}); }); });
|
|
|
|
|
});
|
|
|
|
|
describe('book', function() {
|
|
|
|
|
it('bookSheets should not generate sheets', function() {
|
|
|
|
|
MCPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, bookSheets:true});
|
|
|
|
|
assert.ok(typeof wb.Sheets === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('bookProps should not generate sheets', function() {
|
|
|
|
|
NFPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, bookProps:true});
|
|
|
|
|
assert.ok(typeof wb.Sheets === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('bookProps && bookSheets should not generate sheets', function() {
|
|
|
|
|
PMPaths.forEach(function(p) {
|
|
|
|
|
if(!fs.existsSync(p)) return;
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE, bookProps:true, bookSheets:true});
|
|
|
|
|
assert.ok(typeof wb.Sheets === 'undefined');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
var FSTXL = [
|
|
|
|
|
[paths.fstxlsx, true],
|
|
|
|
|
[paths.fstxlsb, true],
|
|
|
|
|
[paths.fstxls, false]
|
|
|
|
|
];
|
|
|
|
|
it('should not generate deps by default', function() {
|
|
|
|
|
FSTPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE});
|
|
|
|
|
//assert.ok(typeof wb.Deps === 'undefined' || !(wb.Deps && wb.Deps.length>0));
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
it('bookDeps should generate deps (XLSX/XLSB)', function() {
|
|
|
|
|
FSTXL.forEach(function(p) {
|
|
|
|
|
if(!p[1]) return;
|
|
|
|
|
var wb = X.read(fs.readFileSync(p[0]), {type:TYPE, bookDeps:true});
|
|
|
|
|
//assert.ok(typeof wb.Deps !== 'undefined' && wb.Deps.length > 0);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
var ckf = function(wb: X.WorkBook, fields: string[], exists: boolean) { fields.forEach(function(f) { assert.ok((typeof (wb as any)[f] !== 'undefined') == exists); }); };
|
|
|
|
|
it('should not generate book files by default', function() {FSTXL.forEach(function(r) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(r[0]), {type:TYPE});
|
|
|
|
|
ckf(wb, r[1] ? ['files', 'keys'] : ['cfb'], false);
|
|
|
|
|
}); });
|
|
|
|
|
it('bookFiles should generate book files', function() {FSTXL.forEach(function(r) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(r[0]), {type:TYPE, bookFiles:true});
|
|
|
|
|
ckf(wb, r[1] ? ['files', 'keys'] : ['cfb'], true);
|
|
|
|
|
}); });
|
|
|
|
|
|
|
|
|
|
var NFVBA = ["nfxlsx", "nfxlsb", "nfxls"].map(function(n) { return paths[n]; });
|
|
|
|
|
it('should not generate VBA by default', function() { NFPaths.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p), {type:TYPE}); assert.ok(typeof wb.vbaraw === 'undefined');
|
|
|
|
|
}); });
|
|
|
|
|
it('bookVBA should generate vbaraw', function() { NFVBA.forEach(function(p) {
|
|
|
|
|
var wb = X.read(fs.readFileSync(p),{type: TYPE, bookVBA: true});
|
|
|
|
|
assert.ok(wb.vbaraw);
|
|
|
|
|
var cfb = X.CFB.read(wb.vbaraw, {type: 'array'});
|
|
|
|
|
assert.ok(X.CFB.find(cfb, '/VBA/ThisWorkbook'));
|
|
|
|
|
}); });
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
describe('input formats', function() {
|
|
|
|
|
it('should read binary strings', function() { artifax.forEach(function(p) {
|
|
|
|
|
X.read(fs.readFileSync(p, 'binary'), {type: 'binary'});
|
|
|
|
|
}); });
|
|
|
|
|
it('should read base64 strings', function() { artifax.forEach(function(p) {
|
|
|
|
|
X.read(fs.readFileSync(p, 'base64'), {type: 'base64'});
|
|
|
|
|
}); });
|
2022-08-08 23:21:46 +00:00
|
|
|
|
it('handles base64 within data URI scheme (gh-2762)', function() {
|
|
|
|
|
var data = 'TmFtZXMNCkhhZmV6DQpTYW0NCg==';
|
|
|
|
|
|
|
|
|
|
var wb0 = X.read(data, { type: 'base64' }); // raw base64 string
|
|
|
|
|
var wb1 = X.read('data:;base64,' + data, { type: 'base64' }); // data URI, no media type
|
|
|
|
|
var wb2 = X.read('data:text/csv;base64,' + data, { type: 'base64' }); // data URI, CSV type
|
|
|
|
|
var wb3 = X.read('data:application/vnd.ms-excel;base64,' + data, { type: 'base64' }); // data URI, Excel
|
|
|
|
|
|
|
|
|
|
[wb0, wb1, wb2, wb3].forEach(function(wb) {
|
|
|
|
|
var ws = wb.Sheets.Sheet1;
|
|
|
|
|
assert.equal(ws["!ref"], "A1:A3");
|
|
|
|
|
assert.equal(get_cell(ws, "A1").v, "Names");
|
|
|
|
|
assert.equal(get_cell(ws, "A2").v, "Hafez");
|
|
|
|
|
assert.equal(get_cell(ws, "A3").v, "Sam");
|
|
|
|
|
});
|
|
|
|
|
});
|
2022-06-06 23:05:27 +00:00
|
|
|
|
if(typeof Uint8Array !== 'undefined') it('should read array', function() { artifax.forEach(function(p) {
|
|
|
|
|
X.read(fs.readFileSync(p, 'binary').split("").map(function(x) { return x.charCodeAt(0); }), {type:'array'});
|
|
|
|
|
}); });
|
|
|
|
|
it('should read Buffers', function() { artifax.forEach(function(p) {
|
|
|
|
|
X.read(fs.readFileSync(p), {type: 'buffer'});
|
|
|
|
|
}); });
|
|
|
|
|
if(typeof Uint8Array !== 'undefined') it('should read ArrayBuffer / Uint8Array', function() { artifax.forEach(function(p) {
|
|
|
|
|
var payload: any = fs.readFileSync(p, "buffer");
|
|
|
|
|
var ab = new ArrayBuffer(payload.length), vu = new Uint8Array(ab);
|
|
|
|
|
for(var i = 0; i < payload.length; ++i) vu[i] = payload[i];
|
|
|
|
|
X.read(ab, {type: 'array'});
|
|
|
|
|
X.read(vu, {type: 'array'});
|
|
|
|
|
}); });
|
|
|
|
|
it('should throw if format is unknown', function() { artifax.forEach(function(p) {
|
|
|
|
|
assert.throws(function() { X.read(fs.readFileSync(p), ({type: 'dafuq'} as any)); });
|
|
|
|
|
}); });
|
|
|
|
|
|
|
|
|
|
var T = browser ? 'base64' : 'buffer';
|
|
|
|
|
it('should default to "' + T + '" type', function() { artifax.forEach(function(p) {
|
|
|
|
|
X.read(fs.readFileSync(p));
|
|
|
|
|
}); });
|
|
|
|
|
if(!browser) it('should read files', function() { artifax.forEach(function(p) { X.readFile(p); }); });
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
describe('output formats', function() {
|
|
|
|
|
var fmts = [
|
|
|
|
|
/* fmt unicode str */
|
|
|
|
|
["xlsx", true, false],
|
|
|
|
|
["xlsb", true, false],
|
|
|
|
|
["xls", true, false],
|
|
|
|
|
["xlml", true, true],
|
|
|
|
|
["ods", true, false],
|
|
|
|
|
["fods", true, true],
|
|
|
|
|
["csv", true, true],
|
|
|
|
|
["txt", true, true],
|
2022-07-07 06:30:44 +00:00
|
|
|
|
["rtf", false, true],
|
2022-06-06 23:05:27 +00:00
|
|
|
|
["sylk", false, true],
|
|
|
|
|
["eth", false, true],
|
|
|
|
|
["html", true, true],
|
|
|
|
|
["dif", false, true],
|
|
|
|
|
["dbf", false, false],
|
|
|
|
|
["prn", false, true]
|
|
|
|
|
];
|
|
|
|
|
function RT(T: 'string' | 'binary' | 'base64' | 'array' | 'buffer') {
|
|
|
|
|
fmts.forEach(function(fmt) {
|
|
|
|
|
var wb = X.utils.book_new();
|
|
|
|
|
X.utils.book_append_sheet(wb, X.utils.aoa_to_sheet([['R',"\u2603"],["\u0BEE",2]]), "Sheet1");
|
|
|
|
|
if(T == 'string' && !fmt[2]) return assert.throws(function() {X.write(wb, {type: T, bookType:(fmt[0] as X.BookType), WTF:true});});
|
|
|
|
|
var out = X.write(wb, {type: T, bookType:(fmt[0] as X.BookType), WTF:true});
|
|
|
|
|
var nwb = X.read(out, {type: T, PRN: fmt[0] == 'prn', WTF:true});
|
|
|
|
|
var nws = nwb.Sheets[nwb.SheetNames[0]];
|
|
|
|
|
assert.equal(get_cell(nws, "B2").v, 2);
|
|
|
|
|
assert.equal(get_cell(nws, "A1").v, "R");
|
|
|
|
|
if(fmt[1]) assert.equal(get_cell(nws, "A2").v, "\u0BEE");
|
|
|
|
|
if(fmt[1]) assert.equal(get_cell(nws, "B1").v, "\u2603");
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
it('should write binary strings', function() { RT('binary'); });
|
|
|
|
|
it('should write base64 strings', function() { RT('base64'); });
|
|
|
|
|
it('should write JS strings', function() { RT('string'); });
|
|
|
|
|
if(typeof ArrayBuffer !== 'undefined') it('should write array buffers', function() { RT('array'); });
|
|
|
|
|
if(!browser) it('should write buffers', function() { RT('buffer'); });
|
|
|
|
|
it('should throw if format is unknown', function() { assert.throws(function() { RT('dafuq' as any); }); });
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
function eqarr(a: any[],b: any[]) {
|
|
|
|
|
assert.equal(a.length, b.length);
|
|
|
|
|
a.forEach(function(x, i) { assert.equal(x, b[i]); });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
describe('API', function() {
|
|
|
|
|
it('book_append_sheet', function() {
|
|
|
|
|
var wb = X.utils.book_new();
|
|
|
|
|
X.utils.book_append_sheet(wb, X.utils.aoa_to_sheet([[1,2,3],[4],[5]]), "A");
|
|
|
|
|
X.utils.book_append_sheet(wb, X.utils.aoa_to_sheet([[1,2,3],[4],[5]]));
|
|
|
|
|
X.utils.book_append_sheet(wb, X.utils.aoa_to_sheet([[1,2,3],[4],[5]]));
|
|
|
|
|
X.utils.book_append_sheet(wb, X.utils.aoa_to_sheet([[1,2,3],[4],[5]]), "B");
|
|
|
|
|
X.utils.book_append_sheet(wb, X.utils.aoa_to_sheet([[1,2,3],[4],[5]]));
|
|
|
|
|
eqarr(wb.SheetNames, ["A","Sheet1","Sheet2","B","Sheet3"]);
|
|
|
|
|
});
|
|
|
|
|
it('sheet_add_json', function() {
|
|
|
|
|
var ws = X.utils.json_to_sheet([{A:"S", B:"h", C:"e", D:"e", E:"t", F:"J", G:"S"}], {header:["A","B","C","D","E","F","G"], skipHeader:true});
|
|
|
|
|
X.utils.sheet_add_json(ws, [{A:1, B:2}, {A:2, B:3}, {A:3, B:4}], {skipHeader:true, origin:"A2"});
|
|
|
|
|
X.utils.sheet_add_json(ws, [{A:5, B:6, C:7}, {A:6, B:7, C:8}, {A:7, B:8, C:9}], {skipHeader:true, origin:{r:1, c:4}, header:["A","B","C"]});
|
|
|
|
|
X.utils.sheet_add_json(ws, [{A:4, B:5, C:6, D:7, E:8, F:9, G:0}], {header:["A","B","C","D","E","F","G"], skipHeader:true, origin:-1});
|
|
|
|
|
assert.equal(X.utils.sheet_to_csv(ws).trim(), "S,h,e,e,t,J,S\n1,2,,,5,6,7\n2,3,,,6,7,8\n3,4,,,7,8,9\n4,5,6,7,8,9,0");
|
|
|
|
|
});
|
|
|
|
|
it('sheet_add_aoa', function() {
|
|
|
|
|
var ws = X.utils.aoa_to_sheet([ "SheetJS".split("") ]);
|
|
|
|
|
X.utils.sheet_add_aoa(ws, [[1,2], [2,3], [3,4]], {origin: "A2"});
|
|
|
|
|
X.utils.sheet_add_aoa(ws, [[5,6,7], [6,7,8], [7,8,9]], {origin:{r:1, c:4}});
|
|
|
|
|
X.utils.sheet_add_aoa(ws, [[4,5,6,7,8,9,0]], {origin: -1});
|
|
|
|
|
assert.equal(X.utils.sheet_to_csv(ws).trim(), "S,h,e,e,t,J,S\n1,2,,,5,6,7\n2,3,,,6,7,8\n3,4,,,7,8,9\n4,5,6,7,8,9,0");
|
|
|
|
|
});
|
|
|
|
|
it('sheet_add_aoa support object cell', function() {
|
|
|
|
|
var data = X.utils.aoa_to_sheet([
|
|
|
|
|
['url', 'name', 'id'],
|
|
|
|
|
[ { l: { Target: 'https://123.com' }, v: 'url', t: 's' }, 'tom', 'xxx' ]
|
|
|
|
|
]);
|
|
|
|
|
if(assert.deepEqual) assert.deepEqual(data.A2, { l: { Target: 'https://123.com' }, v: 'url', t: 's' });
|
|
|
|
|
});
|
|
|
|
|
it('decode_range', function() {
|
|
|
|
|
var _c = "ABC", _r = "123", _C = "DEF", _R = "456";
|
|
|
|
|
|
|
|
|
|
var r = X.utils.decode_range(_c + _r + ":" + _C + _R);
|
|
|
|
|
assert.ok(r.s != r.e);
|
|
|
|
|
assert.equal(r.s.c, X.utils.decode_col(_c)); assert.equal(r.s.r, X.utils.decode_row(_r));
|
|
|
|
|
assert.equal(r.e.c, X.utils.decode_col(_C)); assert.equal(r.e.r, X.utils.decode_row(_R));
|
|
|
|
|
|
|
|
|
|
r = X.utils.decode_range(_c + _r);
|
|
|
|
|
assert.ok(r.s != r.e);
|
|
|
|
|
assert.equal(r.s.c, X.utils.decode_col(_c)); assert.equal(r.s.r, X.utils.decode_row(_r));
|
|
|
|
|
assert.equal(r.e.c, X.utils.decode_col(_c)); assert.equal(r.e.r, X.utils.decode_row(_r));
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
function coreprop(props: X.Properties) {
|
|
|
|
|
assert.equal(props.Title, 'Example with properties');
|
|
|
|
|
assert.equal(props.Subject, 'Test it before you code it');
|
|
|
|
|
assert.equal(props.Author, 'Pony Foo');
|
|
|
|
|
assert.equal(props.Manager, 'Despicable Drew');
|
|
|
|
|
assert.equal(props.Company, 'Vector Inc');
|
|
|
|
|
assert.equal(props.Category, 'Quirky');
|
|
|
|
|
assert.equal(props.Keywords, 'example humor');
|
|
|
|
|
assert.equal(props.Comments, 'some comments');
|
|
|
|
|
assert.equal(props.LastAuthor, 'Hugues');
|
|
|
|
|
}
|
|
|
|
|
function custprop(props: any) {
|
|
|
|
|
assert.equal(props['I am a boolean'], true);
|
|
|
|
|
assert.equal(props['Date completed'].toISOString(), '1967-03-09T16:30:00.000Z');
|
|
|
|
|
assert.equal(props.Status, 2);
|
|
|
|
|
assert.equal(props.Counter, -3.14);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmparr(x: any[]){ for(var i=1;i<x.length;++i) assert.deepEqual(x[0], x[i]); }
|
|
|
|
|
|
|
|
|
|
function deepcmp(x: any, y: any, k: string, m?: string, c: number = 0): void {
|
|
|
|
|
var s = k.indexOf(".");
|
|
|
|
|
m = (m||"") + "|" + (s > -1 ? k.substr(0,s) : k);
|
|
|
|
|
if(s < 0) return assert[c<0?'notEqual':'equal'](x[k], y[k], m);
|
|
|
|
|
return deepcmp(x[k.substr(0,s)],y[k.substr(0,s)],k.substr(s+1),m,c);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var styexc = [
|
|
|
|
|
'A2|H10|bgColor.rgb',
|
|
|
|
|
'F6|H1|patternType'
|
|
|
|
|
];
|
|
|
|
|
var stykeys = [
|
|
|
|
|
"patternType",
|
|
|
|
|
"fgColor.rgb",
|
|
|
|
|
"bgColor.rgb"
|
|
|
|
|
];
|
|
|
|
|
function diffsty(ws: X.WorkSheet, r1: string,r2: string) {
|
|
|
|
|
var c1 = get_cell(ws,r1).s, c2 = get_cell(ws,r2).s;
|
|
|
|
|
stykeys.forEach(function(m) {
|
|
|
|
|
var c = -1;
|
|
|
|
|
if(styexc.indexOf(r1+"|"+r2+"|"+m) > -1) c = 1;
|
|
|
|
|
else if(styexc.indexOf(r2+"|"+r1+"|"+m) > -1) c = 1;
|
|
|
|
|
deepcmp(c1,c2,m,r1+","+r2,c);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function hlink1(ws: X.WorkSheet) {[
|
|
|
|
|
["A1", "http://www.sheetjs.com"],
|
|
|
|
|
["A2", "http://oss.sheetjs.com"],
|
|
|
|
|
["A3", "http://oss.sheetjs.com#foo"],
|
|
|
|
|
["A4", "mailto:dev@sheetjs.com"],
|
|
|
|
|
["A5", "mailto:dev@sheetjs.com?subject=hyperlink"],
|
|
|
|
|
["A6", "../../sheetjs/Documents/Test.xlsx"],
|
|
|
|
|
["A7", "http://sheetjs.com", "foo bar baz"]
|
|
|
|
|
].forEach(function(r) {
|
|
|
|
|
assert.equal(get_cell(ws, r[0]).l.Target, r[1]);
|
|
|
|
|
if(r[2]) assert.equal(get_cell(ws, r[0]).l.Tooltip, r[2]);
|
|
|
|
|
}); }
|
|
|
|
|
|
|
|
|
|
function hlink2(ws: X.WorkSheet) { [
|
|