2017-09-30 06:18:11 +00:00
/* xlsx.js (C) 2013-present SheetJS -- http://sheetjs.com */
2013-10-30 19:26:07 +00:00
/* vim: set ts=2: */
2017-10-17 00:14:32 +00:00
/*jshint mocha:true */
/*global process, document, require */
/ * : :
declare type EmptyFunc = ( ( ) => void ) | null ;
declare type DescribeIt = { ( desc : string , test : EmptyFunc ) : void ; skip ( desc : string , test : EmptyFunc ) : void ; } ;
declare var describe : DescribeIt ;
declare var it : DescribeIt ;
declare var before : ( test : EmptyFunc ) => void ;
declare var cptable : any ;
* /
2014-03-29 22:53:15 +00:00
var X ;
2014-06-29 18:29:45 +00:00
var modp = './' ;
2013-10-30 19:26:07 +00:00
var fs = require ( 'fs' ) , assert = require ( 'assert' ) ;
2014-06-29 18:29:45 +00:00
describe ( 'source' , function ( ) { it ( 'should load' , function ( ) { X = require ( modp ) ; } ) ; } ) ;
2017-04-30 16:27:03 +00:00
var DIF _XL = true ;
2014-02-15 05:08:18 +00:00
2017-09-30 06:18:11 +00:00
var browser = typeof document !== 'undefined' ;
2017-08-05 06:32:57 +00:00
2017-10-17 00:14:32 +00:00
var opts = ( { cellNF : true } /*:any*/ ) ;
2017-08-05 06:32:57 +00:00
var TYPE = browser ? "binary" : "buffer" ;
opts . type = TYPE ;
2017-10-17 00:14:32 +00:00
var fullex = [ ".xlsb" , /*".xlsm",*/ ".xlsx" /*, ".xlml", ".xls"*/ ] ;
2017-12-04 04:41:41 +00:00
var ofmt = [ "xlsb" , "xlsm" , "xlsx" , "ods" , "biff2" , "biff5" , "biff8" , "xlml" , "sylk" , "dif" , "dbf" , "eth" ] ;
2017-03-10 08:39:51 +00:00
var ex = fullex . slice ( ) ; ex = ex . concat ( [ ".ods" , ".xls" , ".xml" , ".fods" ] ) ;
2017-08-05 06:32:57 +00:00
if ( typeof process != 'undefined' && ( ( process || { } ) . env ) ) {
opts . WTF = true ;
opts . cellStyles = true ;
if ( process . env . FMTS === "full" ) process . env . FMTS = ex . join ( ":" ) ;
if ( process . env . FMTS ) ex = process . env . FMTS . split ( ":" ) . map ( function ( x ) { return x [ 0 ] === "." ? x : "." + x ; } ) ;
}
2014-02-12 06:09:42 +00:00
var exp = ex . map ( function ( x ) { return x + ".pending" ; } ) ;
2017-12-09 07:17:25 +00:00
function test _file ( x ) { 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 ; }
2014-01-28 16:38:02 +00:00
2017-08-05 06:32:57 +00:00
var files = browser ? [ ] : ( fs . existsSync ( 'tests.lst' ) ? fs . readFileSync ( 'tests.lst' , 'utf-8' ) . split ( "\n" ) . map ( function ( x ) { return x . trim ( ) ; } ) : fs . readdirSync ( 'test_files' ) ) . filter ( test _file ) ;
var fileA = browser ? [ ] : ( fs . existsSync ( 'tests/testA.lst' ) ? fs . readFileSync ( 'tests/testA.lst' , 'utf-8' ) . split ( "\n" ) . map ( function ( x ) { return x . trim ( ) ; } ) : [ ] ) . filter ( test _file ) ;
2013-10-30 19:26:07 +00:00
2014-01-23 06:20:19 +00:00
/* Excel enforces 31 character sheet limit, although technical file limit is 255 */
2017-10-17 00:14:32 +00:00
function fixsheetname ( x /*:string*/ ) /*:string*/ { return x . substr ( 0 , 31 ) ; }
2014-01-23 06:20:19 +00:00
2017-10-17 00:14:32 +00:00
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]+$/ , "" ) ; }
2013-12-27 03:15:16 +00:00
2014-02-15 05:08:18 +00:00
var dir = "./test_files/" ;
2017-09-30 06:18:11 +00:00
var dirwp = dir + "artifacts/wps/" , dirqp = dir + "artifacts/quattro/" ;
2014-03-29 22:53:15 +00:00
var paths = {
2017-09-30 06:18:11 +00:00
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' ,
2017-04-10 05:10:54 +00:00
afxlsx : dir + 'AutoFilter.xlsx' ,
afxlsb : dir + 'AutoFilter.xlsb' ,
2017-04-13 01:29:38 +00:00
2017-09-30 06:18:11 +00:00
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' ,
2015-04-02 20:32:22 +00:00
cpxlsx : dir + 'custom_properties.xlsx' ,
cpxlsb : dir + 'custom_properties.xlsb' ,
2017-04-13 01:29:38 +00:00
2015-04-02 20:32:22 +00:00
cssxls : dir + 'cell_style_simple.xls' ,
cssxml : dir + 'cell_style_simple.xml' ,
cssxlsx : dir + 'cell_style_simple.xlsx' ,
cssxlsb : dir + 'cell_style_simple.xlsb' ,
2017-04-13 01:29:38 +00:00
2015-04-02 20:32:22 +00:00
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' ,
2017-04-02 06:47:25 +00:00
cstods : dir + 'comments_stress_test.ods' ,
2017-04-13 01:29:38 +00:00
2017-04-28 07:28:03 +00:00
cwxls : dir + 'column_width.xls' ,
2017-04-13 01:29:38 +00:00
cwxls5 : dir + 'column_width.biff5' ,
cwxml : dir + 'column_width.xml' ,
cwxlsx : dir + 'column_width.xlsx' ,
2017-04-28 07:28:03 +00:00
cwxlsb : dir + 'column_width.xlsb' ,
cwslk : dir + 'column_width.slk' ,
2017-04-13 01:29:38 +00:00
2017-04-11 22:15:36 +00:00
dnsxls : dir + 'defined_names_simple.xls' ,
dnsxml : dir + 'defined_names_simple.xml' ,
dnsxlsx : dir + 'defined_names_simple.xlsx' ,
dnsxlsb : dir + 'defined_names_simple.xlsb' ,
2017-04-13 01:29:38 +00:00
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' ,
2015-04-02 20:32:22 +00:00
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' ,
2017-04-13 01:29:38 +00:00
2015-04-02 20:32:22 +00:00
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' ,
2017-04-13 01:29:38 +00:00
2017-12-15 01:18:40 +00:00
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' ,
2015-04-02 20:32:22 +00:00
lonxls : dir + 'LONumbers.xls' ,
lonxlsx : dir + 'LONumbers.xlsx' ,
2017-04-13 01:29:38 +00:00
2015-04-02 20:32:22 +00:00
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' ,
2017-04-13 01:29:38 +00:00
2015-04-02 20:32:22 +00:00
nfxls : dir + 'number_format.xls' ,
nfxml : dir + 'number_format.xls.xml' ,
nfxlsx : dir + 'number_format.xlsm' ,
nfxlsb : dir + 'number_format.xlsb' ,
2017-04-13 01:29:38 +00:00
2017-07-09 17:37:45 +00:00
olxls : dir + 'outline.xls' ,
olxls5 : dir + 'outline.biff5' ,
olxlsx : dir + 'outline.xlsx' ,
olxlsb : dir + 'outline.xlsb' ,
olods : dir + 'outline.ods' ,
2017-04-13 01:29:38 +00:00
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' ,
2017-04-28 07:28:03 +00:00
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' ,
2017-03-31 18:46:42 +00:00
svxls : dir + 'sheet_visibility.xls' ,
svxls5 : dir + 'sheet_visibility.xls' ,
svxml : dir + 'sheet_visibility.xml' ,
svxlsx : dir + 'sheet_visibility.xlsx' ,
svxlsb : dir + 'sheet_visibility.xlsb' ,
2017-04-13 01:29:38 +00:00
2015-04-02 20:32:22 +00:00
swcxls : dir + 'apachepoi_SimpleWithComments.xls' ,
swcxml : dir + '2011/apachepoi_SimpleWithComments.xls.xml' ,
swcxlsx : dir + 'apachepoi_SimpleWithComments.xlsx' ,
swcxlsb : dir + '2013/apachepoi_SimpleWithComments.xlsx.xlsb'
2014-03-29 22:53:15 +00:00
} ;
2017-10-17 00:14:32 +00:00
function pathit ( p , ext ) { 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 NFPaths = pathit ( "nf" , [ "xlsx" , "xlsb" , "xls" , "xml" ] ) ;
var HLPaths = pathit ( "hl" , [ "xlsx" , "xlsb" , "xls" , "xml" ] ) ;
2017-12-15 01:18:40 +00:00
var ILPaths = pathit ( "il" , [ "xlsx" , "xlsb" , "xls" , "xml" , "ods" , "xls5" ] ) ;
2017-10-17 00:14:32 +00:00
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 ] ; } ) ;
function parsetest ( x /*:string*/ , wb /*:Workbook*/ , full /*:boolean*/ , ext /*:?string*/ ) {
2014-05-16 00:33:34 +00:00
ext = ( ext ? " [" + ext + "]" : "" ) ;
2014-05-29 22:30:03 +00:00
if ( ! full && ext ) return ;
2014-05-16 00:33:34 +00:00
describe ( x + ext + ' should have all bits' , function ( ) {
2017-03-27 21:35:15 +00:00
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' ;
2013-10-30 19:26:07 +00:00
it ( 'should have all sheets' , function ( ) {
wb . SheetNames . forEach ( function ( y ) { assert ( wb . Sheets [ y ] , 'bad sheet ' + y ) ; } ) ;
} ) ;
2017-03-27 21:35:15 +00:00
if ( fs . existsSync ( sname ) ) it ( 'should have the right sheet names' , function ( ) {
2014-05-30 01:09:20 +00:00
var file = fs . readFileSync ( sname , 'utf-8' ) . replace ( /\r/g , "" ) ;
2014-01-23 06:20:19 +00:00
var names = wb . SheetNames . map ( fixsheetname ) . join ( "\n" ) + "\n" ;
2017-05-13 18:21:22 +00:00
if ( file . length && ! x . match ( /artifacts/ ) ) assert . equal ( names , file ) ;
2017-03-27 21:35:15 +00:00
} ) ;
2013-10-30 19:26:07 +00:00
} ) ;
2014-05-16 00:33:34 +00:00
describe ( x + ext + ' should generate CSV' , function ( ) {
2014-01-23 06:20:19 +00:00
wb . SheetNames . forEach ( function ( ws , i ) {
it ( '#' + i + ' (' + ws + ')' , function ( ) {
2014-05-03 18:51:10 +00:00
X . utils . make _csv ( wb . Sheets [ ws ] ) ;
2014-01-23 06:20:19 +00:00
} ) ;
} ) ;
} ) ;
2014-05-16 00:33:34 +00:00
describe ( x + ext + ' should generate JSON' , function ( ) {
2014-01-23 15:55:07 +00:00
wb . SheetNames . forEach ( function ( ws , i ) {
it ( '#' + i + ' (' + ws + ')' , function ( ) {
2017-04-28 07:28:03 +00:00
X . utils . sheet _to _json ( wb . Sheets [ ws ] ) ;
2014-01-23 15:55:07 +00:00
} ) ;
} ) ;
} ) ;
2014-05-16 00:33:34 +00:00
describe ( x + ext + ' should generate formulae' , function ( ) {
2014-01-23 15:55:07 +00:00
wb . SheetNames . forEach ( function ( ws , i ) {
it ( '#' + i + ' (' + ws + ')' , function ( ) {
2014-05-03 18:51:10 +00:00
X . utils . get _formulae ( wb . Sheets [ ws ] ) ;
2014-01-23 15:55:07 +00:00
} ) ;
} ) ;
} ) ;
2014-04-15 09:04:03 +00:00
if ( ! full ) return ;
2014-05-03 18:51:10 +00:00
var getfile = function ( dir , x , i , type ) {
var name = ( dir + x + '.' + i + type ) ;
2017-02-03 20:50:45 +00:00
var root = "" ;
2014-10-10 02:22:38 +00:00
if ( x . substr ( - 5 ) === ".xlsb" ) {
root = x . slice ( 0 , - 5 ) ;
2014-05-03 18:51:10 +00:00
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 ) ;
}
2015-04-02 20:32:22 +00:00
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 ) ;
}
2014-05-03 18:51:10 +00:00
return name ;
} ;
2014-05-16 00:33:34 +00:00
describe ( x + ext + ' should generate correct CSV output' , function ( ) {
2013-10-30 19:26:07 +00:00
wb . SheetNames . forEach ( function ( ws , i ) {
2014-05-03 18:51:10 +00:00
var name = getfile ( dir , x , i , ".csv" ) ;
2017-03-27 21:35:15 +00:00
if ( fs . existsSync ( name ) ) it ( '#' + i + ' (' + ws + ')' , function ( ) {
2013-10-30 19:26:07 +00:00
var file = fs . readFileSync ( name , 'utf-8' ) ;
2014-03-29 22:53:15 +00:00
var csv = X . utils . make _csv ( wb . Sheets [ ws ] ) ;
2014-05-03 18:51:10 +00:00
assert . equal ( fixcsv ( csv ) , fixcsv ( file ) , "CSV badness" ) ;
2017-03-27 21:35:15 +00:00
} ) ;
2013-10-30 19:26:07 +00:00
} ) ;
} ) ;
2014-05-16 00:33:34 +00:00
describe ( x + ext + ' should generate correct JSON output' , function ( ) {
2014-05-03 18:51:10 +00:00
wb . SheetNames . forEach ( function ( ws , 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 = X . utils . make _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 = X . utils . make _json ( wb . Sheets [ ws ] ) ;
assert . equal ( JSON . stringify ( json ) , fixjson ( file ) , "JSON badness" ) ;
} ) ;
} ) ;
} ) ;
2015-04-02 20:32:22 +00:00
if ( fs . existsSync ( dir + '2011/' + x + '.xml' ) )
describe ( x + ext + '.xml from 2011' , function ( ) {
it ( 'should parse' , function ( ) {
2017-09-30 06:18:11 +00:00
/*var wb = */ X . readFile ( dir + '2011/' + x + '.xml' , opts ) ;
2015-04-02 20:32:22 +00:00
} ) ;
} ) ;
2014-05-22 20:15:47 +00:00
if ( fs . existsSync ( dir + '2013/' + x + '.xlsb' ) )
2014-05-16 00:33:34 +00:00
describe ( x + ext + '.xlsb from 2013' , function ( ) {
2014-02-17 08:44:22 +00:00
it ( 'should parse' , function ( ) {
2017-09-30 06:18:11 +00:00
/*var wb = */ X . readFile ( dir + '2013/' + x + '.xlsb' , opts ) ;
2014-02-17 08:44:22 +00:00
} ) ;
} ) ;
2015-04-02 20:32:22 +00:00
if ( fs . existsSync ( dir + x + '.xml' + ext ) )
describe ( x + '.xml' , function ( ) {
it ( 'should parse' , function ( ) {
2017-09-30 06:18:11 +00:00
/*var wb = */ X . readFile ( dir + x + '.xml' , opts ) ;
2015-04-02 20:32:22 +00:00
} ) ;
} ) ;
2013-10-30 19:26:07 +00:00
}
2014-05-29 22:30:03 +00:00
var wbtable = { } ;
2017-08-05 06:32:57 +00:00
( browser ? describe . skip : describe ) ( 'should parse test files' , function ( ) {
2013-10-30 19:26:07 +00:00
files . forEach ( function ( x ) {
2017-03-27 21:35:15 +00:00
if ( x . slice ( - 8 ) == ".pending" || ! fs . existsSync ( dir + x ) ) return ;
it ( x , function ( ) {
2014-03-29 22:53:15 +00:00
var wb = X . readFile ( dir + x , opts ) ;
2014-05-29 22:30:03 +00:00
wbtable [ dir + x ] = wb ;
2014-04-03 22:51:54 +00:00
parsetest ( x , wb , true ) ;
2014-05-29 22:30:03 +00:00
} ) ;
fullex . forEach ( function ( ext , idx ) {
it ( x + ' [' + ext + ']' , function ( ) {
var wb = wbtable [ dir + x ] ;
if ( ! wb ) wb = X . readFile ( dir + x , opts ) ;
2017-03-19 06:50:30 +00:00
wb = X . read ( X . write ( wb , { type : "buffer" , bookType : ext . replace ( /\./ , "" ) } ) , { WTF : opts . WTF , cellNF : true } ) ;
parsetest ( x , wb , ext . replace ( /\./ , "" ) !== "xlsb" , ext ) ;
2014-05-16 00:33:34 +00:00
} ) ;
2014-04-03 22:51:54 +00:00
} ) ;
} ) ;
2014-04-15 09:04:03 +00:00
fileA . forEach ( function ( x ) {
2017-03-27 21:35:15 +00:00
if ( x . slice ( - 8 ) == ".pending" || ! fs . existsSync ( dir + x ) ) return ;
it ( x , function ( ) {
2017-12-04 04:41:41 +00:00
var wb = X . readFile ( dir + x , { WTF : opts . WTF , sheetRows : 10 } ) ;
2014-04-03 22:51:54 +00:00
parsetest ( x , wb , false ) ;
2013-10-30 19:26:07 +00:00
} ) ;
} ) ;
} ) ;
2014-01-15 07:26:00 +00:00
2017-04-08 06:55:35 +00:00
function get _cell ( ws /*:Worksheet*/ , addr /*:string*/ ) {
if ( ! Array . isArray ( ws ) ) return ws [ addr ] ;
var a = X . utils . decode _cell ( addr ) ;
return ( ws [ a . r ] || [ ] ) [ a . c ] ;
}
function each _cell ( ws , f ) {
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 ] ) ; } ) ;
}
2017-10-17 00:14:32 +00:00
function each _sheet ( wb , f ) { wb . SheetNames . forEach ( function ( n , i ) { f ( wb . Sheets [ n ] , i ) ; } ) ; }
2017-04-02 06:47:25 +00:00
/* comments_stress_test family */
function check _comments ( wb ) {
var ws0 = wb . Sheets . Sheet2 ;
2017-04-08 06:55:35 +00:00
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' ) ;
2017-04-02 06:47:25 +00:00
var ws3 = wb . Sheets . Sheet4 ;
2017-04-08 06:55:35 +00:00
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 , '' ) ;
2017-04-02 06:47:25 +00:00
}
2014-05-16 00:33:34 +00:00
describe ( 'parse options' , function ( ) {
2014-02-12 06:09:42 +00:00
var html _cell _types = [ 's' ] ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2014-06-29 18:29:45 +00:00
X = require ( modp ) ;
2014-02-12 06:09:42 +00:00
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-02-15 05:08:18 +00:00
describe ( 'cell' , function ( ) {
2015-04-02 20:32:22 +00:00
it ( 'XLSX should generate HTML by default' , function ( ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( paths . cstxlsx ) , { type : TYPE } ) ;
2014-02-15 05:08:18 +00:00
var ws = wb . Sheets . Sheet1 ;
2017-04-08 06:55:35 +00:00
each _cell ( ws , function ( cell ) {
assert ( html _cell _types . indexOf ( cell . t ) === - 1 || cell . h ) ;
2014-02-13 06:22:42 +00:00
} ) ;
} ) ;
2015-04-02 20:32:22 +00:00
it ( 'XLSX should not generate HTML when requested' , function ( ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( paths . cstxlsx ) , { type : TYPE , cellHTML : false } ) ;
2014-02-15 05:08:18 +00:00
var ws = wb . Sheets . Sheet1 ;
2017-04-08 06:55:35 +00:00
each _cell ( ws , function ( cell ) {
assert ( typeof cell . h === 'undefined' ) ;
2014-02-13 06:22:42 +00:00
} ) ;
} ) ;
2014-02-15 05:08:18 +00:00
it ( 'should generate formulae by default' , function ( ) {
2017-04-26 02:27:12 +00:00
FSTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ;
2015-04-02 20:32:22 +00:00
var found = false ;
wb . SheetNames . forEach ( function ( s ) {
2017-10-17 00:14:32 +00:00
each _cell ( wb . Sheets [ s ] , function ( cell ) {
2017-04-08 06:55:35 +00:00
if ( typeof cell . f !== 'undefined' ) return ( found = true ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
2015-04-02 20:32:22 +00:00
assert ( found ) ;
2014-02-13 08:48:41 +00:00
} ) ;
} ) ;
2014-02-15 05:08:18 +00:00
it ( 'should not generate formulae when requested' , function ( ) {
2017-04-26 02:27:12 +00:00
FSTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , cellFormula : false } ) ;
2015-04-02 20:32:22 +00:00
wb . SheetNames . forEach ( function ( s ) {
2017-10-17 00:14:32 +00:00
each _cell ( wb . Sheets [ s ] , function ( cell ) {
2017-04-08 06:55:35 +00:00
assert ( typeof cell . f === 'undefined' ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
} ) ;
} ) ;
2017-04-26 02:27:12 +00:00
it ( 'should generate formatted text by default' , function ( ) {
FSTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ;
2017-04-26 02:27:12 +00:00
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 ( found ) ;
} ) ;
} ) ;
it ( 'should not generate formatted text when requested' , function ( ) {
FSTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , cellText : false } ) ;
2017-04-26 02:27:12 +00:00
wb . SheetNames . forEach ( function ( s ) {
var ws = wb . Sheets [ s ] ;
each _cell ( ws , function ( cell ) {
assert ( typeof cell . w === 'undefined' ) ;
} ) ;
} ) ;
} ) ;
} ) ;
2014-02-15 05:08:18 +00:00
it ( 'should not generate number formats by default' , function ( ) {
2017-04-28 07:28:03 +00:00
NFPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ;
2015-04-02 20:32:22 +00:00
wb . SheetNames . forEach ( function ( s ) {
var ws = wb . Sheets [ s ] ;
2017-04-08 06:55:35 +00:00
each _cell ( ws , function ( cell ) {
assert ( typeof cell . z === 'undefined' ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
2014-02-13 08:48:41 +00:00
} ) ;
} ) ;
2014-02-15 05:08:18 +00:00
it ( 'should generate number formats when requested' , function ( ) {
2017-04-28 07:28:03 +00:00
NFPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , cellNF : true } ) ;
2015-04-02 20:32:22 +00:00
wb . SheetNames . forEach ( function ( s ) {
var ws = wb . Sheets [ s ] ;
2017-04-08 06:55:35 +00:00
each _cell ( ws , function ( cell ) {
assert ( cell . t !== 'n' || typeof cell . z !== 'undefined' ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
} ) ;
} ) ;
2014-05-29 22:30:03 +00:00
it ( 'should not generate cell styles by default' , function ( ) {
2017-10-17 00:14:32 +00:00
CSSPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , WTF : 1 } ) ;
2017-04-08 06:55:35 +00:00
wb . SheetNames . forEach ( function ( s ) {
var ws = wb . Sheets [ s ] ;
each _cell ( ws , function ( cell ) {
assert ( typeof cell . s === 'undefined' ) ;
} ) ;
2014-05-29 22:30:03 +00:00
} ) ;
} ) ;
} ) ;
2015-04-02 20:32:22 +00:00
it ( 'should generate cell styles when requested' , function ( ) {
/* TODO: XLS / XLML */
2017-04-08 06:55:35 +00:00
[ paths . cssxlsx /*, paths.cssxlsb, paths.cssxls, paths.cssxml*/ ] . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , cellStyles : true } ) ;
2017-04-08 06:55:35 +00:00
var found = false ;
2017-10-17 00:14:32 +00:00
each _sheet ( wb , function ( ws , i ) { each _cell ( ws , function ( cell ) {
if ( typeof cell . s !== 'undefined' ) return ( found = true ) ;
} ) ; } ) ;
2017-04-08 06:55:35 +00:00
assert ( found ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-05-29 22:30:03 +00:00
} ) ;
2014-10-26 05:26:18 +00:00
it ( 'should not generate cell dates by default' , function ( ) {
2017-04-28 07:28:03 +00:00
DTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ;
2017-10-17 00:14:32 +00:00
each _sheet ( wb , function ( ws , i ) { each _cell ( ws , function ( cell ) {
assert ( cell . t !== 'd' ) ;
} ) ; } ) ;
2014-10-26 05:26:18 +00:00
} ) ;
} ) ;
2017-04-28 07:28:03 +00:00
it ( 'should generate cell dates when requested' , function ( ) {
DTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , cellDates : true , WTF : 1 } ) ;
2017-04-08 06:55:35 +00:00
var found = false ;
2017-10-17 00:14:32 +00:00
each _sheet ( wb , function ( ws , i ) { each _cell ( ws , function ( cell ) {
if ( cell . t === 'd' ) return ( found = true ) ;
} ) ; } ) ;
2017-04-08 06:55:35 +00:00
assert ( found ) ;
2014-10-26 05:26:18 +00:00
} ) ;
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
describe ( 'sheet' , function ( ) {
it ( 'should not generate sheet stubs by default' , function ( ) {
2017-10-17 00:14:32 +00:00
MCPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ;
2017-04-08 06:55:35 +00:00
assert . throws ( function ( ) { return get _cell ( wb . Sheets . Merge , "A2" ) . v ; } ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
it ( 'should generate sheet stubs when requested' , function ( ) {
2017-10-17 00:14:32 +00:00
MCPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , sheetStubs : true } ) ;
2017-04-08 06:55:35 +00:00
assert ( get _cell ( wb . Sheets . Merge , "A2" ) . t == 'z' ) ;
2017-03-15 08:19:02 +00:00
} ) ;
} ) ;
it ( 'should handle stub cells' , function ( ) {
2017-10-17 00:14:32 +00:00
MCPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , sheetStubs : true } ) ;
2017-03-15 08:19:02 +00:00
X . utils . sheet _to _csv ( wb . Sheets . Merge ) ;
X . utils . sheet _to _json ( wb . Sheets . Merge ) ;
X . utils . sheet _to _formulae ( wb . Sheets . Merge ) ;
2017-10-27 16:25:54 +00:00
ofmt . forEach ( function ( f ) { if ( f != "dbf" ) X . write ( wb , { type : TYPE , bookType : f } ) ; } ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
2014-03-29 02:05:50 +00:00
function checkcells ( wb , A46 , B26 , C16 , D2 ) {
2017-10-17 00:14:32 +00:00
[ [ "A46" , A46 ] , [ "B26" , B26 ] , [ "C16" , C16 ] , [ "D2" , D2 ] ] . forEach ( function ( r ) {
assert ( ( typeof get _cell ( wb . Sheets . Text , r [ 0 ] ) !== 'undefined' ) == r [ 1 ] ) ;
2015-04-02 20:32:22 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
}
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 ) ;
} ) ; } ) ;
2014-02-13 08:48:41 +00:00
} ) ;
2014-02-14 06:25:46 +00:00
describe ( 'book' , function ( ) {
it ( 'bookSheets should not generate sheets' , function ( ) {
2017-10-17 00:14:32 +00:00
MCPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , bookSheets : true } ) ;
2015-04-02 20:32:22 +00:00
assert ( typeof wb . Sheets === 'undefined' ) ;
} ) ;
2014-02-14 06:25:46 +00:00
} ) ;
it ( 'bookProps should not generate sheets' , function ( ) {
2017-10-17 00:14:32 +00:00
NFPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , bookProps : true } ) ;
2015-04-02 20:32:22 +00:00
assert ( typeof wb . Sheets === 'undefined' ) ;
} ) ;
2014-02-14 06:25:46 +00:00
} ) ;
it ( 'bookProps && bookSheets should not generate sheets' , function ( ) {
2017-10-17 00:14:32 +00:00
PMPaths . forEach ( function ( p ) {
2017-10-18 03:05:05 +00:00
if ( ! fs . existsSync ( p ) ) return ;
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE , bookProps : true , bookSheets : true } ) ;
2015-04-02 20:32:22 +00:00
assert ( typeof wb . Sheets === 'undefined' ) ;
} ) ;
2014-02-14 06:25:46 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
var FSTXL = [
[ paths . fstxlsx , true ] ,
[ paths . fstxlsb , true ] ,
[ paths . fstxls , false ]
] ;
2014-02-15 05:08:18 +00:00
it ( 'should not generate deps by default' , function ( ) {
2017-10-17 00:14:32 +00:00
FSTPaths . forEach ( function ( p ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ;
2015-04-02 20:32:22 +00:00
assert ( typeof wb . Deps === 'undefined' || ! ( wb . Deps && wb . Deps . length > 0 ) ) ;
} ) ;
2014-02-17 08:44:22 +00:00
} ) ;
2015-04-02 20:32:22 +00:00
it ( 'bookDeps should generate deps (XLSX/XLSB)' , function ( ) {
2017-10-17 00:14:32 +00:00
FSTXL . forEach ( function ( p ) {
if ( ! p [ 1 ] ) return ;
var wb = X . read ( fs . readFileSync ( p [ 0 ] ) , { type : TYPE , bookDeps : true } ) ;
2015-04-02 20:32:22 +00:00
assert ( typeof wb . Deps !== 'undefined' && wb . Deps . length > 0 ) ;
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
var ckf = function ( wb , fields , exists ) { fields . forEach ( function ( f ) { assert ( ( typeof wb [ 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 ( 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 ( wb . vbaraw ) ;
} ) ; } ) ;
2014-02-14 06:25:46 +00:00
} ) ;
} ) ;
describe ( 'input formats' , function ( ) {
2017-10-17 00:14:32 +00:00
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' } ) ;
} ) ; } ) ;
2017-08-05 06:32:57 +00:00
var k = browser ? 'array' : 'buffer' ;
2017-10-17 00:14:32 +00:00
( typeof Uint8Array !== 'undefined' ? it : it . skip ) ( 'should read ' + k + 's' , function ( ) { artifax . forEach ( function ( p ) {
X . read ( fs . readFileSync ( p , browser ? 'buffer' : null ) , { type : k } ) ;
} ) ; } ) ;
( typeof Uint8Array !== 'undefined' ? it : it . skip ) ( '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 throw if format is unknown' , function ( ) { artifax . forEach ( function ( p ) {
assert . throws ( function ( ) { X . read ( fs . readFileSync ( p ) , { type : 'dafuq' } ) ; } ) ;
} ) ; } ) ;
2017-08-05 06:32:57 +00:00
2017-10-17 00:14:32 +00:00
var T = browser ? 'base64' : 'buffer' ;
it ( 'should default to "' + T + '" type' , function ( ) { artifax . forEach ( function ( p ) {
X . read ( fs . readFileSync . apply ( fs , browser ? [ p , 'base64' ] : [ p ] ) ) ;
} ) ; } ) ;
if ( ! browser ) it ( 'should read files' , function ( ) { artifax . forEach ( function ( p ) { X . readFile ( p ) ; } ) ; } ) ;
2014-05-16 00:33:34 +00:00
} ) ;
describe ( 'output formats' , function ( ) {
2017-09-30 06:18:11 +00:00
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 ] ,
[ "sylk" , false , true ] ,
2017-12-04 04:41:41 +00:00
[ "eth" , false , true ] ,
2017-09-30 06:18:11 +00:00
[ "html" , true , true ] ,
[ "dif" , false , true ] ,
2017-10-27 16:25:54 +00:00
[ "dbf" , false , false ] ,
2017-09-30 06:18:11 +00:00
[ "prn" , false , true ]
] ;
function RT ( T ) {
if ( ! X ) X = require ( modp ) ;
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 ] , WTF : 1 } ) ; } ) ;
var out = X . write ( wb , { type : T , bookType : fmt [ 0 ] , WTF : 1 } ) ;
var nwb = X . read ( out , { type : T , WTF : 1 } ) ;
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' ) ; } ) ;
2017-12-30 05:40:35 +00:00
if ( typeof ArrayBuffer !== 'undefined' && ( typeof process == 'undefined' || ! process . version . match ( /v0.12/ ) ) ) it ( 'should write array buffers' , function ( ) { RT ( 'array' ) ; } ) ;
2017-09-30 06:18:11 +00:00
if ( ! browser ) it ( 'should write buffers' , function ( ) { RT ( 'buffer' ) ; } ) ;
it ( 'should throw if format is unknown' , function ( ) { assert . throws ( function ( ) { RT ( 'dafuq' ) ; } ) ; } ) ;
2014-02-12 06:09:42 +00:00
} ) ;
2014-02-14 03:39:03 +00:00
2017-05-13 18:21:22 +00:00
function eqarr ( a , b ) {
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" ] ) ;
} ) ;
} ) ;
2017-10-17 00:14:32 +00:00
function coreprop ( props ) {
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' ) ;
2014-05-16 00:33:34 +00:00
}
2017-10-17 00:14:32 +00:00
function custprop ( props ) {
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 ) ;
2014-05-16 00:33:34 +00:00
}
2017-07-26 08:35:28 +00:00
function cmparr ( x ) { for ( var i = 1 ; i < x . length ; ++ i ) assert . deepEqual ( x [ 0 ] , x [ i ] ) ; }
2014-05-29 22:30:03 +00:00
function deepcmp ( x , y , k , m , c ) {
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 ) ;
2015-04-02 20:32:22 +00:00
return deepcmp ( x [ k . substr ( 0 , s ) ] , y [ k . substr ( 0 , s ) ] , k . substr ( s + 1 ) , m , c ) ;
2014-05-29 22:30:03 +00:00
}
var styexc = [
'A2|H10|bgColor.rgb' ,
'F6|H1|patternType'
2015-04-02 20:32:22 +00:00
] ;
2014-05-29 22:30:03 +00:00
var stykeys = [
"patternType" ,
"fgColor.rgb" ,
"bgColor.rgb"
] ;
function diffsty ( ws , r1 , r2 ) {
2017-04-08 06:55:35 +00:00
var c1 = get _cell ( ws , r1 ) . s , c2 = get _cell ( ws , r2 ) . s ;
2014-05-29 22:30:03 +00:00
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 ) ;
} ) ;
}
2017-12-15 01:18:40 +00:00
function hlink1 ( ws ) { [
[ "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 ) { [
[ "A1" , "#Sheet2!A1" ] ,
[ "A2" , "#WBScope" ] ,
[ "A3" , "#Sheet1!WSScope1" , "#Sheet1!C7:E8" ] ,
[ "A5" , "#Sheet1!A5" ]
] . forEach ( function ( r ) {
if ( r [ 2 ] && get _cell ( ws , r [ 0 ] ) . l . Target == r [ 2 ] ) return ;
assert . equal ( get _cell ( ws , r [ 0 ] ) . l . Target , r [ 1 ] ) ;
} ) ; }
2017-03-28 22:03:03 +00:00
2017-04-17 02:28:38 +00:00
function check _margin ( margins , exp ) {
2017-10-17 00:14:32 +00:00
[ "left" , "right" , "top" , "bottom" , "header" , "footer" ] . forEach ( function ( m , i ) {
assert . equal ( margins [ m ] , exp [ i ] ) ;
} ) ;
2017-04-17 02:28:38 +00:00
}
2017-03-28 22:03:03 +00:00
2014-05-16 00:33:34 +00:00
describe ( 'parse features' , function ( ) {
2017-03-31 18:46:42 +00:00
describe ( 'sheet visibility' , function ( ) {
2017-09-30 06:18:11 +00:00
var wbs = [ ] ;
2017-03-31 18:46:42 +00:00
var bef = ( function ( ) {
2017-10-17 00:14:32 +00:00
wbs = SVPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ; } ) ;
2017-03-31 18:46:42 +00:00
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-03-29 02:05:50 +00:00
2017-03-31 18:46:42 +00:00
it ( 'should detect visible sheets' , function ( ) {
2017-10-17 00:14:32 +00:00
if ( ! wbs . length ) bef ( ) ;
2017-09-30 06:18:11 +00:00
wbs . forEach ( function ( wb ) {
2017-03-31 18:46:42 +00:00
assert ( ! wb . Workbook . Sheets [ 0 ] . Hidden ) ;
} ) ;
} ) ;
it ( 'should detect all hidden sheets' , function ( ) {
2017-09-30 06:18:11 +00:00
wbs . forEach ( function ( wb ) {
2017-03-31 18:46:42 +00:00
assert ( wb . Workbook . Sheets [ 1 ] . Hidden ) ;
assert ( wb . Workbook . Sheets [ 2 ] . Hidden ) ;
} ) ;
} ) ;
it ( 'should distinguish very hidden sheets' , function ( ) {
2017-09-30 06:18:11 +00:00
wbs . forEach ( function ( wb ) {
2017-03-31 18:46:42 +00:00
assert . equal ( wb . Workbook . Sheets [ 1 ] . Hidden , 1 ) ;
assert . equal ( wb . Workbook . Sheets [ 2 ] . Hidden , 2 ) ;
} ) ;
} ) ;
} ) ;
describe ( 'comments' , function ( ) {
if ( fs . existsSync ( paths . swcxlsx ) ) it ( 'should have comment as part of cell properties' , function ( ) {
2017-10-27 16:25:54 +00:00
X = require ( modp ) ;
2017-03-31 18:46:42 +00:00
var sheet = 'Sheet1' ;
2017-08-05 06:32:57 +00:00
var wb1 = X . read ( fs . readFileSync ( paths . swcxlsx ) , { type : TYPE } ) ;
var wb2 = X . read ( fs . readFileSync ( paths . swcxlsb ) , { type : TYPE } ) ;
var wb3 = X . read ( fs . readFileSync ( paths . swcxls ) , { type : TYPE } ) ;
var wb4 = X . read ( fs . readFileSync ( paths . swcxml ) , { type : TYPE } ) ;
2017-03-31 18:46:42 +00:00
[ wb1 , wb2 , wb3 , wb4 ] . map ( function ( wb ) { return wb . Sheets [ sheet ] ; } ) . forEach ( function ( ws , i ) {
2017-04-08 06:55:35 +00:00
assert . equal ( get _cell ( ws , "B1" ) . c . length , 1 , "must have 1 comment" ) ;
assert . equal ( get _cell ( ws , "B1" ) . c [ 0 ] . a , "Yegor Kozlov" , "must have the same author" ) ;
assert . equal ( get _cell ( ws , "B1" ) . c [ 0 ] . t , "Yegor Kozlov:\nfirst cell" , "must have the concatenated texts" ) ;
2017-03-31 18:46:42 +00:00
if ( i > 0 ) return ;
2017-04-08 06:55:35 +00:00
assert . equal ( get _cell ( ws , "B1" ) . c [ 0 ] . r , '<r><rPr><b/><sz val="8"/><color indexed="81"/><rFont val="Tahoma"/></rPr><t>Yegor Kozlov:</t></r><r><rPr><sz val="8"/><color indexed="81"/><rFont val="Tahoma"/></rPr><t xml:space="preserve">\r\nfirst cell</t></r>' , "must have the rich text representation" ) ;
2017-04-20 03:24:48 +00:00
assert . equal ( get _cell ( ws , "B1" ) . c [ 0 ] . h , '<span style="font-size:8;"><b>Yegor Kozlov:</b></span><span style="font-size:8;"><br/>first cell</span>' , "must have the html representation" ) ;
2017-03-31 18:46:42 +00:00
} ) ;
2014-02-15 05:08:18 +00:00
} ) ;
2017-04-02 06:47:25 +00:00
[
[ 'xlsx' , paths . cstxlsx ] ,
[ 'xlsb' , paths . cstxlsb ] ,
[ 'xls' , paths . cstxls ] ,
[ 'xlml' , paths . cstxml ] ,
[ 'ods' , paths . cstods ]
] . forEach ( function ( m ) { it ( m [ 0 ] + ' stress test' , function ( ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( m [ 1 ] ) , { type : TYPE } ) ;
2017-04-02 06:47:25 +00:00
check _comments ( wb ) ;
var ws0 = wb . Sheets . Sheet2 ;
2017-04-08 06:55:35 +00:00
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' ) ;
2017-04-02 06:47:25 +00:00
} ) ; } ) ;
2014-02-14 03:39:03 +00:00
} ) ;
2014-02-15 03:15:10 +00:00
2014-02-19 03:03:28 +00:00
describe ( 'should parse core properties and custom properties' , function ( ) {
2017-09-30 06:18:11 +00:00
var wbs = [ ] ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2017-09-30 06:18:11 +00:00
wbs = [
2017-12-30 05:40:35 +00:00
X . read ( fs . readFileSync ( paths . cpxlsx ) , { type : TYPE , WTF : 1 } ) ,
X . read ( fs . readFileSync ( paths . cpxlsb ) , { type : TYPE , WTF : 1 } ) ,
X . read ( fs . readFileSync ( paths . cpxls ) , { type : TYPE , WTF : 1 } ) ,
X . read ( fs . readFileSync ( paths . cpxml ) , { type : TYPE , WTF : 1 } )
2017-09-30 06:18:11 +00:00
] ;
2014-02-15 05:08:18 +00:00
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-03-29 02:05:50 +00:00
2017-10-17 00:14:32 +00:00
[ 'XLSX' , 'XLSB' , 'XLS' , 'XML' ] . forEach ( function ( x , i ) {
it ( x + ' should parse core properties' , function ( ) { coreprop ( wbs [ i ] . Props ) ; } ) ;
it ( x + ' should parse custom properties' , function ( ) { custprop ( wbs [ i ] . Custprops ) ; } ) ;
2017-09-30 06:18:11 +00:00
} ) ;
[
[ "asxls" , "BIFF8" , "\u2603" ] ,
[ "asxls5" , "BIFF5" , "_" ] ,
[ "asxml" , "XLML" , "\u2603" ] ,
[ "asods" , "ODS" , "God" ] ,
[ "asxlsx" , "XLSX" , "\u2603" ] ,
[ "asxlsb" , "XLSB" , "\u2603" ]
] . forEach ( function ( x ) {
2017-10-17 00:14:32 +00:00
( fs . existsSync ( paths [ x [ 0 ] ] ) ? it : it . skip ) ( x [ 1 ] + ' should read ' + ( x [ 2 ] == "\u2603" ? 'unicode ' : "" ) + 'author' , function ( ) {
2017-09-30 06:18:11 +00:00
var wb = X . read ( fs . readFileSync ( paths [ x [ 0 ] ] ) , { type : TYPE } ) ;
assert . equal ( wb . Props . Author , x [ 2 ] ) ;
} ) ; } ) ;
var BASE = "இராமா" ;
2017-10-17 00:14:32 +00:00
/* TODO: ODS, XLS */
2017-09-30 06:18:11 +00:00
[ "xlsx" , "xlsb" , "xlml" /*, "ods", "xls" */ ] . forEach ( function ( n ) {
it ( n + ' should round-trip unicode category' , function ( ) {
var wb = X . utils . book _new ( ) ;
X . utils . book _append _sheet ( wb , X . utils . aoa _to _sheet ( [ [ "a" ] ] ) , "Sheet1" ) ;
if ( ! wb . Props ) wb . Props = { } ;
wb . Props . Category = BASE ;
var wb2 = X . read ( X . write ( wb , { bookType : n , type : TYPE } ) , { type : TYPE } ) ;
assert . equal ( wb2 . Props . Category , BASE ) ;
} ) ; } ) ;
2014-02-15 03:15:10 +00:00
} ) ;
2014-02-19 03:03:28 +00:00
describe ( 'sheetRows' , function ( ) {
it ( 'should use original range if not set' , function ( ) {
2017-08-05 06:32:57 +00:00
var opts = { type : TYPE } ;
2017-10-17 00:14:32 +00:00
FSTPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , opts ) ; } ) . forEach ( function ( wb ) {
2014-03-29 02:05:50 +00:00
assert . equal ( wb . Sheets . Text [ "!ref" ] , "A1:F49" ) ;
} ) ;
2014-02-19 03:03:28 +00:00
} ) ;
it ( 'should adjust range if set' , function ( ) {
2017-08-05 06:32:57 +00:00
var opts = { type : TYPE , sheetRows : 10 } ;
2017-10-17 00:14:32 +00:00
var wbs = FSTPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , opts ) ; } ) ;
/* TODO: XLS, XML, ODS */
wbs . slice ( 0 , 2 ) . forEach ( function ( wb ) {
2014-03-29 02:05:50 +00:00
assert . equal ( wb . Sheets . Text [ "!fullref" ] , "A1:F49" ) ;
assert . equal ( wb . Sheets . Text [ "!ref" ] , "A1:F10" ) ;
} ) ;
2014-02-19 03:03:28 +00:00
} ) ;
it ( 'should not generate comment cells' , function ( ) {
2017-08-05 06:32:57 +00:00
var opts = { type : TYPE , sheetRows : 10 } ;
2017-10-17 00:14:32 +00:00
var wbs = CSTPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , opts ) ; } ) ;
/* TODO: XLS, XML, ODS */
wbs . slice ( 0 , 2 ) . forEach ( function ( wb ) {
2014-03-29 02:05:50 +00:00
assert . equal ( wb . Sheets . Sheet7 [ "!fullref" ] , "A1:N34" ) ;
2014-05-03 18:51:10 +00:00
assert . equal ( wb . Sheets . Sheet7 [ "!ref" ] , "A1" ) ;
2014-03-29 02:05:50 +00:00
} ) ;
2014-02-19 03:03:28 +00:00
} ) ;
} ) ;
2014-03-23 21:30:00 +00:00
2017-03-20 09:02:25 +00:00
describe ( 'column properties' , function ( ) {
2017-10-17 00:14:32 +00:00
var wbs = [ ] , wbs _no _slk = [ ] ;
2017-03-20 09:02:25 +00:00
var bef = ( function ( ) {
X = require ( modp ) ;
2017-10-17 00:14:32 +00:00
wbs = CWPaths . map ( function ( n ) { return X . read ( fs . readFileSync ( CWPaths [ 0 ] ) , { type : TYPE , cellStyles : true } ) ; } ) ;
wbs _no _slk = wbs . slice ( 0 , 5 ) ;
2017-03-20 09:02:25 +00:00
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
it ( 'should have "!cols"' , function ( ) {
2017-10-17 00:14:32 +00:00
wbs . forEach ( function ( wb ) { assert ( wb . Sheets . Sheet1 [ '!cols' ] ) ; } ) ;
2017-03-20 09:02:25 +00:00
} ) ;
it ( 'should have correct widths' , function ( ) {
2017-04-28 07:28:03 +00:00
/* SYLK rounds wch so skip non-integral */
2017-10-17 00:14:32 +00:00
wbs _no _slk . map ( function ( x ) { return x . Sheets . Sheet1 [ '!cols' ] ; } ) . forEach ( function ( x ) {
2017-03-20 09:02:25 +00:00
assert . equal ( x [ 1 ] . width , 0.1640625 ) ;
assert . equal ( x [ 2 ] . width , 16.6640625 ) ;
assert . equal ( x [ 3 ] . width , 1.6640625 ) ;
2017-04-28 07:28:03 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
wbs . map ( function ( x ) { return x . Sheets . Sheet1 [ '!cols' ] ; } ) . forEach ( function ( x ) {
2017-03-20 09:02:25 +00:00
assert . equal ( x [ 4 ] . width , 4.83203125 ) ;
assert . equal ( x [ 5 ] . width , 8.83203125 ) ;
assert . equal ( x [ 6 ] . width , 12.83203125 ) ;
assert . equal ( x [ 7 ] . width , 16.83203125 ) ;
} ) ;
} ) ;
it ( 'should have correct pixels' , function ( ) {
2017-04-28 07:28:03 +00:00
/* SYLK rounds wch so skip non-integral */
2017-10-17 00:14:32 +00:00
wbs _no _slk . map ( function ( x ) { return x . Sheets . Sheet1 [ '!cols' ] ; } ) . forEach ( function ( x ) {
2017-03-20 09:02:25 +00:00
assert . equal ( x [ 1 ] . wpx , 1 ) ;
assert . equal ( x [ 2 ] . wpx , 100 ) ;
assert . equal ( x [ 3 ] . wpx , 10 ) ;
2017-04-28 07:28:03 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
wbs . map ( function ( x ) { return x . Sheets . Sheet1 [ '!cols' ] ; } ) . forEach ( function ( x ) {
2017-03-20 09:02:25 +00:00
assert . equal ( x [ 4 ] . wpx , 29 ) ;
assert . equal ( x [ 5 ] . wpx , 53 ) ;
assert . equal ( x [ 6 ] . wpx , 77 ) ;
assert . equal ( x [ 7 ] . wpx , 101 ) ;
} ) ;
} ) ;
} ) ;
2017-04-28 07:28:03 +00:00
describe ( 'row properties' , function ( ) {
2017-10-17 00:14:32 +00:00
var wbs = [ ] , ols = [ ] ;
2017-09-30 06:18:11 +00:00
var ol = fs . existsSync ( paths . olxls ) ;
2017-04-28 07:28:03 +00:00
var bef = ( function ( ) {
X = require ( modp ) ;
2017-10-17 00:14:32 +00:00
wbs = RHPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE , cellStyles : true } ) ; } ) ;
2017-09-30 06:18:11 +00:00
/* */
if ( ! ol ) return ;
2017-10-17 00:14:32 +00:00
ols = OLPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE , cellStyles : true } ) ; } ) ;
2017-04-28 07:28:03 +00:00
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
it ( 'should have "!rows"' , function ( ) {
2017-10-17 00:14:32 +00:00
wbs . forEach ( function ( wb ) { assert ( wb . Sheets . Sheet1 [ '!rows' ] ) ; } ) ;
2017-04-28 07:28:03 +00:00
} ) ;
it ( 'should have correct points' , function ( ) {
2017-10-17 00:14:32 +00:00
wbs . map ( function ( x ) { return x . Sheets . Sheet1 [ '!rows' ] ; } ) . forEach ( function ( x ) {
2017-04-28 07:28:03 +00:00
assert . equal ( x [ 1 ] . hpt , 1 ) ;
assert . equal ( x [ 2 ] . hpt , 10 ) ;
assert . equal ( x [ 3 ] . hpt , 100 ) ;
} ) ;
} ) ;
it ( 'should have correct pixels' , function ( ) {
2017-10-17 00:14:32 +00:00
wbs . map ( function ( x ) { return x . Sheets . Sheet1 [ '!rows' ] ; } ) . forEach ( function ( x ) {
2017-04-28 07:28:03 +00:00
/* note: at 96 PPI hpt == hpx */
assert . equal ( x [ 1 ] . hpx , 1 ) ;
assert . equal ( x [ 2 ] . hpx , 10 ) ;
assert . equal ( x [ 3 ] . hpx , 100 ) ;
} ) ;
} ) ;
2017-09-30 06:18:11 +00:00
( ol ? it : it . skip ) ( 'should have correct outline levels' , function ( ) {
2017-10-17 00:14:32 +00:00
ols . map ( function ( x ) { return x . Sheets . Sheet1 ; } ) . forEach ( function ( ws ) {
2017-07-09 17:37:45 +00:00
var rows = ws [ '!rows' ] ;
for ( var i = 0 ; i < 29 ; ++ i ) {
var cell = get _cell ( ws , "A" + X . utils . encode _row ( i ) ) ;
var lvl = ( rows [ i ] || { } ) . level || 0 ;
if ( ! cell || cell . t == 's' ) assert . equal ( lvl , 0 ) ;
else if ( cell . t == 'n' ) {
2017-09-30 06:18:11 +00:00
if ( cell . v === 0 ) assert . equal ( lvl , 0 ) ;
2017-07-09 17:37:45 +00:00
else assert . equal ( lvl , cell . v ) ;
}
}
assert . equal ( rows [ 29 ] . level , 7 ) ;
} ) ;
} ) ;
2017-04-28 07:28:03 +00:00
} ) ;
2014-03-23 21:30:00 +00:00
describe ( 'merge cells' , function ( ) {
2017-09-30 06:18:11 +00:00
var wbs = [ ] ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2014-06-29 18:29:45 +00:00
X = require ( modp ) ;
2017-10-17 00:14:32 +00:00
wbs = MCPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ; } ) ;
2014-03-23 21:30:00 +00:00
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-03-23 21:30:00 +00:00
it ( 'should have !merges' , function ( ) {
2017-09-30 06:18:11 +00:00
wbs . forEach ( function ( wb ) {
assert ( wb . Sheets . Merge [ '!merges' ] ) ;
} ) ;
var m = wbs . map ( function ( x ) { return x . Sheets . Merge [ '!merges' ] . map ( function ( y ) { return X . utils . encode _range ( y ) ; } ) ; } ) ;
m . slice ( 1 ) . forEach ( function ( x ) {
assert . deepEqual ( m [ 0 ] . sort ( ) , x . sort ( ) ) ;
} ) ;
2014-03-23 21:30:00 +00:00
} ) ;
} ) ;
2014-03-29 22:53:15 +00:00
2014-04-15 09:04:03 +00:00
describe ( 'should find hyperlinks' , function ( ) {
2017-12-15 01:18:40 +00:00
var wb1 , wb2 ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2014-06-29 18:29:45 +00:00
X = require ( modp ) ;
2017-12-15 01:18:40 +00:00
wb1 = HLPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ; } ) ;
wb2 = ILPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ; } ) ;
2014-04-15 09:04:03 +00:00
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-04-15 09:04:03 +00:00
2017-12-15 01:18:40 +00:00
[ 'xlsx' , 'xlsb' , 'xls' , 'xml' ] . forEach ( function ( x , i ) {
it ( x + " external" , function ( ) { hlink1 ( wb1 [ i ] . Sheets . Sheet1 ) ; } ) ;
} ) ;
[ 'xlsx' , 'xlsb' , 'xls' , 'xml' , 'ods' ] . forEach ( function ( x , i ) {
it ( x + " internal" , function ( ) { hlink2 ( wb2 [ i ] . Sheets . Sheet1 ) ; } ) ;
2017-09-30 06:18:11 +00:00
} ) ;
2014-04-15 09:04:03 +00:00
} ) ;
2014-03-29 22:53:15 +00:00
describe ( 'should parse cells with date type (XLSX/XLSM)' , function ( ) {
2014-10-26 05:26:18 +00:00
it ( 'Must have read the date' , function ( ) {
var wb , ws ;
2014-03-29 22:53:15 +00:00
var sheetName = 'Sheet1' ;
2017-08-05 06:32:57 +00:00
wb = X . read ( fs . readFileSync ( paths . dtxlsx ) , { type : TYPE } ) ;
2014-03-29 22:53:15 +00:00
ws = wb . Sheets [ sheetName ] ;
2017-04-28 07:28:03 +00:00
var sheet = X . utils . sheet _to _json ( ws ) ;
2014-03-29 22:53:15 +00:00
assert . equal ( sheet [ 3 ] [ 'てすと' ] , '2/14/14' ) ;
} ) ;
2014-10-26 05:26:18 +00:00
it ( 'cellDates should not affect formatted text' , function ( ) {
var sheetName = 'Sheet1' ;
2017-10-02 08:15:36 +00:00
var ws1 = X . read ( fs . readFileSync ( paths . dtxlsx ) , { type : TYPE } ) . Sheets [ sheetName ] ;
var ws2 = X . read ( fs . readFileSync ( paths . dtxlsb ) , { type : TYPE } ) . Sheets [ sheetName ] ;
2014-10-26 05:26:18 +00:00
assert . equal ( X . utils . sheet _to _csv ( ws1 ) , X . utils . sheet _to _csv ( ws2 ) ) ;
} ) ;
2014-03-29 22:53:15 +00:00
} ) ;
2014-05-29 22:30:03 +00:00
2017-03-21 20:44:35 +00:00
describe ( 'cellDates' , function ( ) {
var fmts = [
/* desc path sheet cell formatted */
[ 'XLSX' , paths . dtxlsx , 'Sheet1' , 'B5' , '2/14/14' ] ,
[ 'XLSB' , paths . dtxlsb , 'Sheet1' , 'B5' , '2/14/14' ] ,
[ 'XLS' , paths . dtxls , 'Sheet1' , 'B5' , '2/14/14' ] ,
[ 'XLML' , paths . dtxml , 'Sheet1' , 'B5' , '2/14/14' ] ,
[ 'XLSM' , paths . nfxlsx , 'Implied' , 'B13' , '18-Oct-33' ]
] ;
it ( 'should not generate date cells by default' , function ( ) { fmts . forEach ( function ( f ) {
var wb , ws ;
2017-08-05 06:32:57 +00:00
wb = X . read ( fs . readFileSync ( f [ 1 ] ) , { type : TYPE } ) ;
2017-03-21 20:44:35 +00:00
ws = wb . Sheets [ f [ 2 ] ] ;
2017-04-08 06:55:35 +00:00
assert . equal ( get _cell ( ws , f [ 3 ] ) . w , f [ 4 ] ) ;
assert . equal ( get _cell ( ws , f [ 3 ] ) . t , 'n' ) ;
2017-03-21 20:44:35 +00:00
} ) ; } ) ;
it ( 'should generate date cells if cellDates is true' , function ( ) { fmts . forEach ( function ( f ) {
var wb , ws ;
2017-08-05 06:32:57 +00:00
wb = X . read ( fs . readFileSync ( f [ 1 ] ) , { type : TYPE , cellDates : true } ) ;
2017-03-21 20:44:35 +00:00
ws = wb . Sheets [ f [ 2 ] ] ;
2017-04-08 06:55:35 +00:00
assert . equal ( get _cell ( ws , f [ 3 ] ) . w , f [ 4 ] ) ;
assert . equal ( get _cell ( ws , f [ 3 ] ) . t , 'd' ) ;
2017-03-21 20:44:35 +00:00
} ) ; } ) ;
} ) ;
2017-10-17 00:14:32 +00:00
describe ( 'defined names' , function ( ) { [
/* desc path cmnt */
[ 'xlsx' , paths . dnsxlsx , true ] ,
[ 'xlsb' , paths . dnsxlsb , true ] ,
[ 'xls' , paths . dnsxls , true ] ,
[ 'xlml' , paths . dnsxml , false ]
] . forEach ( function ( m ) { it ( m [ 0 ] , function ( ) {
var wb = X . read ( fs . readFileSync ( m [ 1 ] ) , { type : TYPE } ) ;
var names = wb . Workbook . Names ;
for ( var i = 0 ; i < names . length ; ++ i ) if ( names [ i ] . Name == "SheetJS" ) break ;
assert ( i < names . length , "Missing name" ) ;
assert . equal ( names [ i ] . Sheet , null ) ;
assert . equal ( names [ i ] . Ref , "Sheet1!$A$1" ) ;
if ( m [ 2 ] ) assert . equal ( names [ i ] . Comment , "defined names just suck excel formulae are bad MS should feel bad" ) ;
for ( i = 0 ; i < names . length ; ++ i ) if ( names [ i ] . Name == "SHEETjs" ) break ;
assert ( i < names . length , "Missing name" ) ;
assert . equal ( names [ i ] . Sheet , 0 ) ;
assert . equal ( names [ i ] . Ref , "Sheet1!$A$2" ) ;
} ) ; } ) ; } ) ;
2017-04-11 22:15:36 +00:00
2017-10-17 00:14:32 +00:00
describe ( 'auto filter' , function ( ) { [
[ 'xlsx' , paths . afxlsx ] ,
[ 'xlsb' , paths . afxlsb ] ,
[ 'xls' , paths . afxls ] ,
[ 'xlml' , paths . afxml ] ,
[ 'ods' , paths . afods ]
] . forEach ( function ( m ) { it ( m [ 0 ] , function ( ) {
var wb = X . read ( fs . readFileSync ( m [ 1 ] ) , { type : TYPE } ) ;
assert ( ! wb . Sheets [ wb . SheetNames [ 0 ] ] [ '!autofilter' ] ) ;
for ( var i = 1 ; i < wb . SheetNames . length ; ++ i ) {
assert ( wb . Sheets [ wb . SheetNames [ i ] ] [ '!autofilter' ] ) ;
assert . equal ( wb . Sheets [ wb . SheetNames [ i ] ] [ '!autofilter' ] . ref , "A1:E22" ) ;
}
} ) ; } ) ; } ) ;
2017-04-10 05:10:54 +00:00
2017-04-13 18:28:16 +00:00
describe ( 'HTML' , function ( ) {
var ws , wb ;
var bef = ( function ( ) {
ws = X . utils . aoa _to _sheet ( [
[ "a" , "b" , "c" ] ,
2017-04-16 04:32:13 +00:00
[ "&" , "<" , ">" , "\n" ]
2017-04-13 18:28:16 +00:00
] ) ;
wb = { SheetNames : [ "Sheet1" ] , Sheets : { Sheet1 : ws } } ;
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
[ 'xlsx' ] . forEach ( function ( m ) { it ( m , function ( ) {
2017-08-05 06:32:57 +00:00
var wb2 = X . read ( X . write ( wb , { bookType : m , type : TYPE } ) , { type : TYPE , cellHTML : true } ) ;
2017-04-13 18:28:16 +00:00
assert . equal ( get _cell ( wb2 . Sheets . Sheet1 , "A2" ) . h , "&" ) ;
assert . equal ( get _cell ( wb2 . Sheets . Sheet1 , "B2" ) . h , "<" ) ;
assert . equal ( get _cell ( wb2 . Sheets . Sheet1 , "C2" ) . h , ">" ) ;
2017-04-16 04:32:13 +00:00
assert . equal ( get _cell ( wb2 . Sheets . Sheet1 , "D2" ) . h , "
" ) ;
2017-04-13 18:28:16 +00:00
} ) ; } ) ;
} ) ;
2017-04-13 01:29:38 +00:00
describe ( 'page margins' , function ( ) {
2017-09-30 06:18:11 +00:00
var wbs = [ ] ;
2017-04-13 01:29:38 +00:00
var bef = ( function ( ) {
2017-09-30 06:18:11 +00:00
if ( ! fs . existsSync ( paths . pmxls ) ) return ;
2017-10-17 00:14:32 +00:00
wbs = PMPaths . map ( function ( p ) { return X . read ( fs . readFileSync ( p ) , { type : TYPE } ) ; } ) ;
2017-04-13 01:29:38 +00:00
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2017-10-17 00:14:32 +00:00
[
/* Sheet Name Margins: left right top bottom head foot */
[ "Normal" , [ 0.70 , 0.70 , 0.75 , 0.75 , 0.30 , 0.30 ] ] ,
[ "Wide" , [ 1.00 , 1.00 , 1.00 , 1.00 , 0.50 , 0.50 ] ] ,
[ "Narrow" , [ 0.25 , 0.25 , 0.75 , 0.75 , 0.30 , 0.30 ] ] ,
[ "Custom 1 Inch Centered" , [ 1.00 , 1.00 , 1.00 , 1.00 , 0.30 , 0.30 ] ] ,
[ "1 Inch HF" , [ 0.70 , 0.70 , 0.75 , 0.75 , 1.00 , 1.00 ] ]
] . forEach ( function ( t ) { it ( 'should parse ' + t [ 0 ] + ' margin' , function ( ) { wbs . forEach ( function ( wb ) {
check _margin ( wb . Sheets [ t [ 0 ] ] [ "!margins" ] , t [ 1 ] ) ;
} ) ; } ) ; } ) ;
2017-04-13 01:29:38 +00:00
} ) ;
2014-05-29 22:30:03 +00:00
describe ( 'should correctly handle styles' , function ( ) {
2015-04-02 20:32:22 +00:00
var wsxls , wsxlsx , rn , rn2 ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2017-08-05 06:32:57 +00:00
wsxls = X . read ( fs . readFileSync ( paths . cssxls ) , { type : TYPE , cellStyles : true , WTF : 1 } ) . Sheets . Sheet1 ;
wsxlsx = X . read ( fs . readFileSync ( paths . cssxlsx ) , { type : TYPE , cellStyles : true , WTF : 1 } ) . Sheets . Sheet1 ;
2014-05-29 22:30:03 +00:00
rn = function ( range ) {
var r = X . utils . decode _range ( range ) ;
var out = [ ] ;
for ( var R = r . s . r ; R <= r . e . r ; ++ R ) for ( var C = r . s . c ; C <= r . e . c ; ++ C )
out . push ( X . utils . encode _cell ( { c : C , r : R } ) ) ;
return out ;
} ;
rn2 = function ( r ) { return [ ] . concat . apply ( [ ] , r . split ( "," ) . map ( rn ) ) ; } ;
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-05-29 22:30:03 +00:00
var ranges = [
'A1:D1,F1:G1' , 'A2:D2,F2:G2' , /* rows */
'A3:A10' , 'B3:B10' , 'E1:E10' , 'F6:F8' , /* cols */
'H1:J4' , 'H10' /* blocks */
2014-06-02 05:19:07 +00:00
] ;
2017-10-17 00:14:32 +00:00
var exp /*:Array<any>*/ = [
2017-03-19 06:50:30 +00:00
{ patternType : 'darkHorizontal' ,
fgColor : { theme : 9 , raw _rgb : 'F79646' } ,
bgColor : { theme : 5 , raw _rgb : 'C0504D' } } ,
{ patternType : 'darkUp' ,
fgColor : { theme : 3 , raw _rgb : 'EEECE1' } ,
bgColor : { theme : 7 , raw _rgb : '8064A2' } } ,
{ patternType : 'darkGray' ,
fgColor : { theme : 3 , raw _rgb : 'EEECE1' } ,
bgColor : { theme : 1 , raw _rgb : 'FFFFFF' } } ,
{ patternType : 'lightGray' ,
fgColor : { theme : 6 , raw _rgb : '9BBB59' } ,
bgColor : { theme : 2 , raw _rgb : '1F497D' } } ,
{ patternType : 'lightDown' ,
fgColor : { theme : 4 , raw _rgb : '4F81BD' } ,
bgColor : { theme : 7 , raw _rgb : '8064A2' } } ,
{ patternType : 'lightGrid' ,
fgColor : { theme : 6 , raw _rgb : '9BBB59' } ,
bgColor : { theme : 9 , raw _rgb : 'F79646' } } ,
{ patternType : 'lightGrid' ,
fgColor : { theme : 4 , raw _rgb : '4F81BD' } ,
bgColor : { theme : 2 , raw _rgb : '1F497D' } } ,
{ patternType : 'lightVertical' ,
fgColor : { theme : 3 , raw _rgb : 'EEECE1' } ,
bgColor : { theme : 7 , raw _rgb : '8064A2' } }
] ;
2014-05-29 22:30:03 +00:00
ranges . forEach ( function ( rng ) {
2017-04-08 06:55:35 +00:00
it ( 'XLS | ' + rng , function ( ) { cmparr ( rn2 ( rng ) . map ( function ( x ) { return get _cell ( wsxls , x ) . s ; } ) ) ; } ) ;
it ( 'XLSX | ' + rng , function ( ) { cmparr ( rn2 ( rng ) . map ( function ( x ) { return get _cell ( wsxlsx , x ) . s ; } ) ) ; } ) ;
2014-05-29 22:30:03 +00:00
} ) ;
it ( 'different styles' , function ( ) {
for ( var i = 0 ; i != ranges . length - 1 ; ++ i ) {
for ( var j = i + 1 ; j != ranges . length ; ++ j ) {
2015-04-02 20:32:22 +00:00
diffsty ( wsxlsx , rn2 ( ranges [ i ] ) [ 0 ] , rn2 ( ranges [ j ] ) [ 0 ] ) ;
2017-10-17 00:14:32 +00:00
/* TODO: XLS */
2015-04-02 20:32:22 +00:00
//diffsty(wsxls, rn2(ranges[i])[0], rn2(ranges[j])[0]);
2014-05-29 22:30:03 +00:00
}
}
} ) ;
2014-06-02 05:19:07 +00:00
it ( 'correct styles' , function ( ) {
2017-10-17 00:14:32 +00:00
//var stylesxls = ranges.map(function(r) { return rn2(r)[0]; }).map(function(r) { return get_cell(wsxls,r).s; });
2017-04-08 06:55:35 +00:00
var stylesxlsx = ranges . map ( function ( r ) { return rn2 ( r ) [ 0 ] ; } ) . map ( function ( r ) { return get _cell ( wsxlsx , r ) . s ; } ) ;
2017-10-17 00:14:32 +00:00
exp . forEach ( function ( e , i ) {
2014-06-02 05:19:07 +00:00
[
"fgColor.theme" , "fgColor.raw_rgb" ,
"bgColor.theme" , "bgColor.raw_rgb" ,
"patternType"
2015-04-02 20:32:22 +00:00
] . forEach ( function ( k ) {
2017-10-17 00:14:32 +00:00
deepcmp ( e , stylesxlsx [ i ] , k , i + ":" + k , 0 ) ;
/* TODO: XLS */
//deepcmp(e, stylesxls[i], k, i + ":" + k, 0);
2015-04-02 20:32:22 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
} ) ;
2014-06-02 05:19:07 +00:00
} ) ;
2014-05-29 22:30:03 +00:00
} ) ;
2014-02-15 03:15:10 +00:00
} ) ;
2014-03-29 02:05:50 +00:00
2017-04-10 05:10:54 +00:00
describe ( 'write features' , function ( ) {
describe ( 'props' , function ( ) {
describe ( 'core' , function ( ) {
2017-10-17 00:14:32 +00:00
var ws ;
var baseprops = {
Category : "Newspaper" ,
ContentStatus : "Published" ,
Keywords : "☃" ,
LastAuthor : "Perry White" ,
LastPrinted : "1978-12-15" ,
RevNumber : 6969 ,
AppVersion : 69 ,
Author : "Lois Lane" ,
Comments : "Needs work" ,
Identifier : "1d" ,
Language : "English" ,
Subject : "Superman" ,
Title : "Man of Steel"
} ;
2017-04-10 05:10:54 +00:00
var bef = ( function ( ) {
X = require ( modp ) ;
ws = X . utils . aoa _to _sheet ( [ [ "a" , "b" , "c" ] , [ 1 , 2 , 3 ] ] ) ;
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
[ 'xlml' , 'xlsx' , 'xlsb' ] . forEach ( function ( w ) { it ( w , function ( ) {
2017-09-30 06:18:11 +00:00
var wb = {
2017-04-10 05:10:54 +00:00
Props : { } ,
SheetNames : [ "Sheet1" ] ,
Sheets : { Sheet1 : ws }
} ;
Object . keys ( baseprops ) . forEach ( function ( k ) { wb . Props [ k ] = baseprops [ k ] ; } ) ;
2017-08-05 06:32:57 +00:00
var wb2 = X . read ( X . write ( wb , { bookType : w , type : TYPE } ) , { type : TYPE } ) ;
2017-04-10 05:10:54 +00:00
Object . keys ( baseprops ) . forEach ( function ( k ) { assert . equal ( baseprops [ k ] , wb2 . Props [ k ] ) ; } ) ;
2017-08-05 06:32:57 +00:00
var wb3 = X . read ( X . write ( wb2 , { bookType : w , type : TYPE , Props : { Author : "SheetJS" } } ) , { type : TYPE } ) ;
2017-04-10 05:10:54 +00:00
assert . equal ( "SheetJS" , wb3 . Props . Author ) ;
} ) ; } ) ;
} ) ;
} ) ;
2017-04-16 04:32:13 +00:00
describe ( 'HTML' , function ( ) {
it ( 'should use `h` value when present' , function ( ) {
var sheet = X . utils . aoa _to _sheet ( [ [ "abc" ] ] ) ;
get _cell ( sheet , "A1" ) . h = "<b>abc</b>" ;
var wb = { SheetNames : [ "Sheet1" ] , Sheets : { Sheet1 : sheet } } ;
var str = X . write ( wb , { bookType : "html" , type : "binary" } ) ;
assert ( str . indexOf ( "<b>abc</b>" ) > 0 ) ;
} ) ;
} ) ;
2017-04-10 05:10:54 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
function seq ( end /*:number*/ , start /*:?number*/ ) /*:Array<number>*/ {
2014-10-26 05:26:18 +00:00
var s = start || 0 ;
var o = new Array ( end - s ) ;
for ( var i = 0 ; i != o . length ; ++ i ) o [ i ] = s + i ;
return o ;
}
2017-08-05 06:32:57 +00:00
var basedate = new Date ( 1899 , 11 , 30 , 0 , 0 , 0 ) ; // 2209161600000
var dnthresh = basedate . getTime ( ) + ( new Date ( ) . getTimezoneOffset ( ) - basedate . getTimezoneOffset ( ) ) * 60000 ;
function datenum ( v /*:Date*/ , date1904 /*:?boolean*/ ) /*:number*/ {
var epoch = v . getTime ( ) ;
if ( date1904 ) epoch += 1462 * 24 * 60 * 60 * 1000 ;
return ( epoch - dnthresh ) / ( 24 * 60 * 60 * 1000 ) ;
}
var good _pd _date = new Date ( '2017-02-19T19:06:09.000Z' ) ;
if ( isNaN ( good _pd _date . getFullYear ( ) ) ) good _pd _date = new Date ( '2/19/17' ) ;
var good _pd = good _pd _date . getFullYear ( ) == 2017 ;
function parseDate ( str /*:string|Date*/ ) /*:Date*/ {
var d = new Date ( str ) ;
if ( good _pd ) return d ;
if ( str instanceof Date ) return str ;
if ( good _pd _date . getFullYear ( ) == 1917 && ! isNaN ( d . getFullYear ( ) ) ) {
var s = d . getFullYear ( ) ;
if ( str . indexOf ( "" + s ) > - 1 ) return d ;
d . setFullYear ( d . getFullYear ( ) + 100 ) ; return d ;
}
var n = str . match ( /\d+/g ) || [ "2017" , "2" , "19" , "0" , "0" , "0" ] ;
return new Date ( Date . UTC ( + n [ 0 ] , + n [ 1 ] - 1 , + n [ 2 ] , + n [ 3 ] , + n [ 4 ] , + n [ 5 ] ) ) ;
}
var fixdate = browser ? parseDate ( "2014-02-19T14:30:00.000Z" ) : new Date ( "2014-02-19T14:30Z" ) ;
2014-05-16 00:33:34 +00:00
describe ( 'roundtrip features' , function ( ) {
2017-03-18 00:45:06 +00:00
var bef = ( function ( ) { X = require ( modp ) ; } ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2017-04-01 07:32:12 +00:00
describe ( 'should preserve core properties' , function ( ) { [
[ 'xlml' , paths . cpxml ] ,
[ 'xlsx' , paths . cpxlsx ] ,
[ 'xlsb' , paths . cpxlsb ]
] . forEach ( function ( w ) {
it ( w [ 0 ] , function ( ) {
2017-10-17 00:14:32 +00:00
var wb1 = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE } ) ;
coreprop ( wb1 . Props ) ;
var wb2 = X . read ( X . write ( wb1 , { bookType : w [ 0 ] , type : TYPE } ) , { type : TYPE } ) ;
coreprop ( wb2 . Props ) ;
2017-04-01 07:32:12 +00:00
} ) ;
} ) ; } ) ;
describe ( 'should preserve custom properties' , function ( ) { [
[ 'xlml' , paths . cpxml ] ,
[ 'xlsx' , paths . cpxlsx ] ,
[ 'xlsb' , paths . cpxlsb ]
] . forEach ( function ( w ) {
it ( w [ 0 ] , function ( ) {
2017-10-17 00:14:32 +00:00
var wb1 = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE } ) ;
custprop ( wb1 . Custprops ) ;
var wb2 = X . read ( X . write ( wb1 , { bookType : w [ 0 ] , type : TYPE } ) , { type : TYPE } ) ;
custprop ( wb2 . Custprops ) ;
2017-04-01 07:32:12 +00:00
} ) ;
} ) ; } ) ;
2014-08-26 17:40:04 +00:00
2017-04-28 07:28:03 +00:00
describe ( 'should preserve merge cells' , function ( ) {
2017-12-30 05:40:35 +00:00
[ "xlsx" , "xlsb" , "xlml" , "ods" , "biff8" ] . forEach ( function ( f ) { it ( f , function ( ) {
2017-08-05 06:32:57 +00:00
var wb1 = X . read ( fs . readFileSync ( paths . mcxlsx ) , { type : TYPE } ) ;
2017-03-16 01:17:24 +00:00
var wb2 = X . read ( X . write ( wb1 , { bookType : f , type : 'binary' } ) , { type : 'binary' } ) ;
2014-08-26 17:40:04 +00:00
var m1 = wb1 . Sheets . Merge [ '!merges' ] . map ( X . utils . encode _range ) ;
var m2 = wb2 . Sheets . Merge [ '!merges' ] . map ( X . utils . encode _range ) ;
assert . equal ( m1 . length , m2 . length ) ;
2017-03-16 01:17:24 +00:00
for ( var i = 0 ; i < m1 . length ; ++ i ) assert ( m1 . indexOf ( m2 [ i ] ) > - 1 ) ;
} ) ; } ) ;
2014-08-26 17:40:04 +00:00
} ) ;
2014-10-26 05:26:18 +00:00
describe ( 'should preserve dates' , function ( ) {
seq ( 16 ) . forEach ( function ( n ) {
var d = ( n & 1 ) ? 'd' : 'n' , dk = d === 'd' ;
var c = ( n & 2 ) ? 'd' : 'n' , dj = c === 'd' ;
var b = ( n & 4 ) ? 'd' : 'n' , di = b === 'd' ;
var a = ( n & 8 ) ? 'd' : 'n' , dh = a === 'd' ;
var f , sheet , addr ;
2015-04-02 20:32:22 +00:00
if ( dh ) { f = paths . dtxlsx ; sheet = 'Sheet1' ; addr = 'B5' ; }
else { f = paths . nfxlsx ; sheet = '2011' ; addr = 'J36' ; }
2014-10-26 05:26:18 +00:00
it ( '[' + a + '] -> (' + b + ') -> [' + c + '] -> (' + d + ')' , function ( ) {
2017-08-05 06:32:57 +00:00
var wb1 = X . read ( fs . readFileSync ( f ) , { type : TYPE , cellNF : true , cellDates : di , WTF : opts . WTF } ) ;
2017-03-21 20:44:35 +00:00
var _f = X . write ( wb1 , { type : 'binary' , cellDates : dj , WTF : opts . WTF } ) ;
var wb2 = X . read ( _f , { type : 'binary' , cellDates : dk , WTF : opts . WTF } ) ;
2017-04-08 06:55:35 +00:00
var m = [ wb1 , wb2 ] . map ( function ( x ) { return get _cell ( x . Sheets [ sheet ] , addr ) ; } ) ;
2014-10-26 05:26:18 +00:00
assert . equal ( m [ 0 ] . w , m [ 1 ] . w ) ;
2017-03-21 20:44:35 +00:00
assert . equal ( m [ 0 ] . t , b ) ;
assert . equal ( m [ 1 ] . t , d ) ;
2014-10-26 05:26:18 +00:00
2017-03-09 05:24:32 +00:00
if ( m [ 0 ] . t === 'n' && m [ 1 ] . t === 'n' ) assert . equal ( m [ 0 ] . v , m [ 1 ] . v ) ;
else if ( m [ 0 ] . t === 'd' && m [ 1 ] . t === 'd' ) assert . equal ( m [ 0 ] . v . toString ( ) , m [ 1 ] . v . toString ( ) ) ;
2017-09-30 06:18:11 +00:00
else if ( m [ 1 ] . t === 'n' ) assert ( Math . abs ( datenum ( browser ? parseDate ( m [ 0 ] . v ) : new Date ( m [ 0 ] . v ) ) - m [ 1 ] . v ) < 0.01 ) ;
2014-10-26 05:26:18 +00:00
} ) ;
} ) ;
} ) ;
2017-03-18 00:45:06 +00:00
describe ( 'should preserve formulae' , function ( ) { [
2017-10-17 00:14:32 +00:00
[ 'xlml' , paths . fstxml ] ,
[ 'xlsx' , paths . fstxlsx ] ,
[ 'ods' , paths . fstods ]
] . forEach ( function ( w ) { it ( w [ 0 ] , function ( ) {
var wb1 = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE , cellFormula : true } ) ;
var wb2 = X . read ( X . write ( wb1 , { bookType : w [ 0 ] , type : TYPE } ) , { cellFormula : true , type : TYPE } ) ;
wb1 . SheetNames . forEach ( function ( n ) {
assert . equal (
X . utils . sheet _to _formulae ( wb1 . Sheets [ n ] ) . sort ( ) . join ( "\n" ) ,
X . utils . sheet _to _formulae ( wb2 . Sheets [ n ] ) . sort ( ) . join ( "\n" )
) ;
2014-05-16 00:33:34 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
} ) ; } ) ; } ) ;
2017-03-28 22:03:03 +00:00
describe ( 'should preserve hyperlink' , function ( ) { [
2017-12-15 01:18:40 +00:00
[ 'xlml' , paths . hlxml , true ] ,
[ 'xls' , paths . hlxls , true ] ,
[ 'xlsx' , paths . hlxlsx , true ] ,
[ 'xlsb' , paths . hlxlsb , true ] ,
[ 'xlml' , paths . ilxml , false ] ,
[ 'xls' , paths . ilxls , false ] ,
[ 'xlsx' , paths . ilxlsx , false ] ,
[ 'xlsb' , paths . ilxlsb , false ] ,
[ 'ods' , paths . ilods , false ]
] . forEach ( function ( w ) { it ( w [ 0 ] + " " + ( w [ 2 ] ? "ex" : "in" ) + "ternal" , function ( ) {
var wb = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE , WTF : opts . WTF } ) ;
var hlink = ( w [ 2 ] ? hlink1 : hlink2 ) ; hlink ( wb . Sheets . Sheet1 ) ;
wb = X . read ( X . write ( wb , { bookType : w [ 0 ] , type : TYPE , WTF : opts . WTF } ) , { type : TYPE , WTF : opts . WTF } ) ;
2017-10-17 00:14:32 +00:00
hlink ( wb . Sheets . Sheet1 ) ;
} ) ; } ) ; } ) ;
2017-04-02 06:47:25 +00:00
2017-04-24 10:39:00 +00:00
( fs . existsSync ( paths . pmxlsx ) ? describe : describe . skip ) ( 'should preserve page margins' , function ( ) { [
2017-04-26 02:27:12 +00:00
[ 'xlml' , paths . pmxml ] ,
2017-04-17 02:28:38 +00:00
[ 'xlsx' , paths . pmxlsx ] ,
[ 'xlsb' , paths . pmxlsb ]
] . forEach ( function ( w ) { it ( w [ 0 ] , function ( ) {
2017-08-05 06:32:57 +00:00
var wb1 = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE } ) ;
2017-04-17 02:28:38 +00:00
var wb2 = X . read ( X . write ( wb1 , { bookType : w [ 0 ] , type : "binary" } ) , { type : "binary" } ) ;
2017-10-17 00:14:32 +00:00
[
/* Sheet Name Margins: left right top bottom head foot */
[ "Normal" , [ 0.70 , 0.70 , 0.75 , 0.75 , 0.30 , 0.30 ] ] ,
[ "Wide" , [ 1.00 , 1.00 , 1.00 , 1.00 , 0.50 , 0.50 ] ] ,
[ "Narrow" , [ 0.25 , 0.25 , 0.75 , 0.75 , 0.30 , 0.30 ] ] ,
[ "Custom 1 Inch Centered" , [ 1.00 , 1.00 , 1.00 , 1.00 , 0.30 , 0.30 ] ] ,
[ "1 Inch HF" , [ 0.70 , 0.70 , 0.75 , 0.75 , 1.00 , 1.00 ] ]
] . forEach ( function ( t ) {
check _margin ( wb2 . Sheets [ t [ 0 ] ] [ "!margins" ] , t [ 1 ] ) ;
} ) ;
2017-04-17 02:28:38 +00:00
} ) ; } ) ; } ) ;
2017-03-31 18:46:42 +00:00
describe ( 'should preserve sheet visibility' , function ( ) { [
[ 'xlml' , paths . svxml ] ,
[ 'xlsx' , paths . svxlsx ] ,
[ 'xlsb' , paths . svxlsb ]
] . forEach ( function ( w ) {
it ( w [ 0 ] , function ( ) {
2017-08-05 06:32:57 +00:00
var wb1 = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE } ) ;
var wb2 = X . read ( X . write ( wb1 , { bookType : w [ 0 ] , type : TYPE } ) , { type : TYPE } ) ;
2017-03-31 18:46:42 +00:00
var wbs1 = wb1 . Workbook . Sheets ;
var wbs2 = wb2 . Workbook . Sheets ;
assert . equal ( wbs1 . length , wbs2 . length ) ;
for ( var i = 0 ; i < wbs1 . length ; ++ i ) {
assert . equal ( wbs1 [ i ] . name , wbs2 [ i ] . name ) ;
assert . equal ( wbs1 [ i ] . Hidden , wbs2 [ i ] . Hidden ) ;
}
} ) ;
} ) ;
} ) ;
2017-04-02 06:47:25 +00:00
2017-04-28 07:28:03 +00:00
describe ( 'should preserve column properties' , function ( ) { [
2017-09-22 22:18:51 +00:00
'xlml' , /*'biff2', 'biff8', */ 'xlsx' , 'xlsb' , 'slk'
2017-04-28 07:28:03 +00:00
] . forEach ( function ( w ) { it ( w , function ( ) {
var ws1 = X . utils . aoa _to _sheet ( [ [ "hpx12" , "hpt24" , "hpx48" , "hidden" ] ] ) ;
ws1 [ '!cols' ] = [ { wch : 9 } , { wpx : 100 } , { width : 80 } , { hidden : true } ] ;
var wb1 = { SheetNames : [ "Sheet1" ] , Sheets : { Sheet1 : ws1 } } ;
2017-08-05 06:32:57 +00:00
var wb2 = X . read ( X . write ( wb1 , { bookType : w , type : TYPE } ) , { type : TYPE , cellStyles : true } ) ;
2017-04-28 07:28:03 +00:00
var ws2 = wb2 . Sheets . Sheet1 ;
assert . equal ( ws2 [ '!cols' ] [ 3 ] . hidden , true ) ;
assert . equal ( ws2 [ '!cols' ] [ 0 ] . wch , 9 ) ;
if ( w == 'slk' ) return ;
assert . equal ( ws2 [ '!cols' ] [ 1 ] . wpx , 100 ) ;
/* xlml stores integral pixels -> approximate width */
if ( w == 'xlml' ) assert . equal ( Math . round ( ws2 [ '!cols' ] [ 2 ] . width ) , 80 ) ;
else assert . equal ( ws2 [ '!cols' ] [ 2 ] . width , 80 ) ;
} ) ; } ) ;
} ) ;
2017-07-09 17:37:45 +00:00
/* TODO: ODS and BIFF5/8 */
2017-04-28 07:28:03 +00:00
describe ( 'should preserve row properties' , function ( ) { [
2017-09-22 22:18:51 +00:00
'xlml' , /*'biff2', 'biff8', */ 'xlsx' , 'xlsb' , 'slk'
2017-04-28 07:28:03 +00:00
] . forEach ( function ( w ) { it ( w , function ( ) {
var ws1 = X . utils . aoa _to _sheet ( [ [ "hpx12" ] , [ "hpt24" ] , [ "hpx48" ] , [ "hidden" ] ] ) ;
ws1 [ '!rows' ] = [ { hpx : 12 } , { hpt : 24 } , { hpx : 48 } , { hidden : true } ] ;
2017-07-09 17:37:45 +00:00
for ( var i = 0 ; i <= 7 ; ++ i ) ws1 [ '!rows' ] . push ( { level : i } ) ;
2017-04-28 07:28:03 +00:00
var wb1 = { SheetNames : [ "Sheet1" ] , Sheets : { Sheet1 : ws1 } } ;
2017-08-05 06:32:57 +00:00
var wb2 = X . read ( X . write ( wb1 , { bookType : w , type : TYPE , cellStyles : true } ) , { type : TYPE , cellStyles : true } ) ;
2017-04-28 07:28:03 +00:00
var ws2 = wb2 . Sheets . Sheet1 ;
assert . equal ( ws2 [ '!rows' ] [ 0 ] . hpx , 12 ) ;
assert . equal ( ws2 [ '!rows' ] [ 1 ] . hpt , 24 ) ;
assert . equal ( ws2 [ '!rows' ] [ 2 ] . hpx , 48 ) ;
assert . equal ( ws2 [ '!rows' ] [ 3 ] . hidden , true ) ;
2017-07-09 17:37:45 +00:00
if ( w == 'xlsb' || w == 'xlsx' ) for ( i = 0 ; i <= 7 ; ++ i ) assert . equal ( ( ws2 [ '!rows' ] [ 4 + i ] || { } ) . level || 0 , i ) ;
2017-04-28 07:28:03 +00:00
} ) ; } ) ;
} ) ;
2017-10-17 00:14:32 +00:00
/* TODO: ODS and XLS */
2017-04-02 06:47:25 +00:00
describe ( 'should preserve cell comments' , function ( ) { [
[ 'xlsx' , paths . cstxlsx ] ,
[ 'xlsb' , paths . cstxlsb ] ,
//['xls', paths.cstxlsx],
[ 'xlml' , paths . cstxml ]
//['ods', paths.cstods]
] . forEach ( function ( w ) {
it ( w [ 0 ] , function ( ) {
2017-08-05 06:32:57 +00:00
var wb1 = X . read ( fs . readFileSync ( w [ 1 ] ) , { type : TYPE } ) ;
var wb2 = X . read ( X . write ( wb1 , { bookType : w [ 0 ] , type : TYPE } ) , { type : TYPE } ) ;
2017-04-02 06:47:25 +00:00
check _comments ( wb1 ) ;
check _comments ( wb2 ) ;
} ) ;
} ) ;
} ) ;
2017-05-11 18:23:21 +00:00
2017-05-17 04:23:36 +00:00
it ( 'should preserve JS objects' , function ( ) {
2017-10-17 00:14:32 +00:00
var data /*:Array<any>*/ = [
2017-05-11 18:23:21 +00:00
{ a : 1 } ,
{ b : 2 , c : 3 } ,
{ b : "a" , d : "b" } ,
{ a : true , c : false } ,
2017-08-05 06:32:57 +00:00
{ c : fixdate }
2017-05-11 18:23:21 +00:00
] ;
2017-10-17 00:14:32 +00:00
var o = X . utils . sheet _to _json ( X . utils . json _to _sheet ( data , { cellDates : true } ) , { raw : true } ) ;
2017-05-11 18:23:21 +00:00
data . forEach ( function ( row , i ) {
2017-10-17 00:14:32 +00:00
Object . keys ( row ) . forEach ( function ( k ) { assert . equal ( row [ k ] , o [ i ] [ k ] ) ; } ) ;
2017-05-11 18:23:21 +00:00
} ) ;
} ) ;
2014-05-16 00:33:34 +00:00
} ) ;
2017-05-11 07:29:59 +00:00
//function password_file(x){return x.match(/^password.*\.xls$/); }
//var password_files = fs.readdirSync('test_files').filter(password_file);
var password _files = [
//"password_2002_40_972000.xls",
"password_2002_40_xor.xls"
] ;
2014-05-16 00:33:34 +00:00
describe ( 'invalid files' , function ( ) {
describe ( 'parse' , function ( ) { [
2017-10-17 00:14:32 +00:00
[ 'password' , 'apachepoi_password.xls' ] ,
[ 'passwords' , 'apachepoi_xor-encryption-abc.xls' ] ,
[ 'DOC files' , 'word_doc.doc' ]
] . forEach ( function ( w ) { it ( 'should fail on ' + w [ 0 ] , function ( ) {
assert . throws ( function ( ) { X . read ( fs . readFileSync ( dir + w [ 1 ] , 'binary' ) , { type : 'binary' } ) ; } ) ;
assert . throws ( function ( ) { X . read ( fs . readFileSync ( dir + w [ 1 ] , 'base64' ) , { type : 'base64' } ) ; } ) ;
} ) ; } ) ; } ) ;
2014-05-16 00:33:34 +00:00
describe ( 'write' , function ( ) {
2017-10-17 00:14:32 +00:00
it ( 'should pass -> XLSX' , function ( ) { FSTPaths . forEach ( function ( p ) {
X . write ( X . read ( fs . readFileSync ( p ) , { type : TYPE } ) , { type : TYPE } ) ;
} ) ; } ) ;
2014-05-16 00:33:34 +00:00
it ( 'should pass if a sheet is missing' , function ( ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( paths . fstxlsx ) , { type : TYPE } ) ; delete wb . Sheets [ wb . SheetNames [ 0 ] ] ;
2014-05-16 00:33:34 +00:00
X . read ( X . write ( wb , { type : 'binary' } ) , { type : 'binary' } ) ;
} ) ;
2017-10-17 00:14:32 +00:00
[ 'Props' , 'Custprops' , 'SSF' ] . forEach ( function ( t ) { it ( 'should pass if ' + t + ' is missing' , function ( ) {
var wb = X . read ( fs . readFileSync ( paths . fstxlsx ) , { type : TYPE } ) ;
assert . doesNotThrow ( function ( ) { delete wb [ t ] ; X . write ( wb , { type : 'binary' } ) ; } ) ;
} ) ; } ) ;
[ 'SheetNames' , 'Sheets' ] . forEach ( function ( t ) { it ( 'should fail if ' + t + ' is missing' , function ( ) {
var wb = X . read ( fs . readFileSync ( paths . fstxlsx ) , { type : TYPE } ) ;
assert . throws ( function ( ) { delete wb [ t ] ; X . write ( wb , { type : 'binary' } ) ; } ) ;
} ) ; } ) ;
2017-03-10 08:39:51 +00:00
it ( 'should fail if SheetNames has duplicate entries' , function ( ) {
2017-08-05 06:32:57 +00:00
var wb = X . read ( fs . readFileSync ( paths . fstxlsx ) , { type : TYPE } ) ;
2017-03-10 08:39:51 +00:00
wb . SheetNames . push ( wb . SheetNames [ 0 ] ) ;
2017-10-17 00:14:32 +00:00
assert . throws ( function ( ) { X . write ( wb , { type : 'binary' } ) ; } ) ;
2017-03-10 08:39:51 +00:00
} ) ;
2014-03-29 02:05:50 +00:00
} ) ;
} ) ;
2014-05-29 22:30:03 +00:00
describe ( 'json output' , function ( ) {
function seeker ( json , keys , val ) {
for ( var i = 0 ; i != json . length ; ++ i ) {
for ( var j = 0 ; j != keys . length ; ++ j ) {
if ( json [ i ] [ keys [ j ] ] === val ) throw new Error ( "found " + val + " in row " + i + " key " + keys [ j ] ) ;
}
}
}
var data , ws ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2014-05-29 22:30:03 +00:00
data = [
[ 1 , 2 , 3 ] ,
[ true , false , null , "sheetjs" ] ,
2017-08-05 06:32:57 +00:00
[ "foo" , "bar" , fixdate , "0.3" ] ,
2017-03-23 05:54:27 +00:00
[ "baz" , undefined , "qux" ]
2014-05-29 22:30:03 +00:00
] ;
2017-03-25 01:36:40 +00:00
ws = X . utils . aoa _to _sheet ( data ) ;
2014-05-29 22:30:03 +00:00
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2014-05-29 22:30:03 +00:00
it ( 'should use first-row headers and full sheet by default' , function ( ) {
var json = X . utils . sheet _to _json ( ws ) ;
assert . equal ( json . length , data . length - 1 ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 0 ] [ 1 ] , "TRUE" ) ;
2014-05-29 22:30:03 +00:00
assert . equal ( json [ 1 ] [ 2 ] , "bar" ) ;
assert . equal ( json [ 2 ] [ 3 ] , "qux" ) ;
assert . doesNotThrow ( function ( ) { seeker ( json , [ 1 , 2 , 3 ] , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , [ 1 , 2 , 3 ] , "baz" ) ; } ) ;
} ) ;
it ( 'should create array of arrays if header == 1' , function ( ) {
var json = X . utils . sheet _to _json ( ws , { header : 1 } ) ;
assert . equal ( json . length , data . length ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 1 ] [ 0 ] , "TRUE" ) ;
2014-05-29 22:30:03 +00:00
assert . equal ( json [ 2 ] [ 1 ] , "bar" ) ;
assert . equal ( json [ 3 ] [ 2 ] , "qux" ) ;
assert . doesNotThrow ( function ( ) { seeker ( json , [ 0 , 1 , 2 ] , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , [ 0 , 1 , 2 , 3 ] , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , [ 0 , 1 , 2 ] , "baz" ) ; } ) ;
} ) ;
it ( 'should use column names if header == "A"' , function ( ) {
var json = X . utils . sheet _to _json ( ws , { header : 'A' } ) ;
assert . equal ( json . length , data . length ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 1 ] . A , "TRUE" ) ;
2015-04-02 20:32:22 +00:00
assert . equal ( json [ 2 ] . B , "bar" ) ;
assert . equal ( json [ 3 ] . C , "qux" ) ;
2014-05-29 22:30:03 +00:00
assert . doesNotThrow ( function ( ) { seeker ( json , "ABC" , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , "ABCD" , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , "ABC" , "baz" ) ; } ) ;
} ) ;
it ( 'should use column labels if specified' , function ( ) {
var json = X . utils . sheet _to _json ( ws , { header : [ "O" , "D" , "I" , "N" ] } ) ;
assert . equal ( json . length , data . length ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 1 ] . O , "TRUE" ) ;
2015-04-02 20:32:22 +00:00
assert . equal ( json [ 2 ] . D , "bar" ) ;
assert . equal ( json [ 3 ] . I , "qux" ) ;
2014-05-29 22:30:03 +00:00
assert . doesNotThrow ( function ( ) { seeker ( json , "ODI" , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , "ODIN" , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , "ODIN" , "baz" ) ; } ) ;
} ) ;
[ [ "string" , "A2:D4" ] , [ "numeric" , 1 ] , [ "object" , { s : { r : 1 , c : 0 } , e : { r : 3 , c : 3 } } ] ] . forEach ( function ( w ) {
it ( 'should accept custom ' + w [ 0 ] + ' range' , function ( ) {
var json = X . utils . sheet _to _json ( ws , { header : 1 , range : w [ 1 ] } ) ;
assert . equal ( json . length , 3 ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 0 ] [ 0 ] , "TRUE" ) ;
2014-05-29 22:30:03 +00:00
assert . equal ( json [ 1 ] [ 1 ] , "bar" ) ;
assert . equal ( json [ 2 ] [ 2 ] , "qux" ) ;
assert . doesNotThrow ( function ( ) { seeker ( json , [ 0 , 1 , 2 ] , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , [ 0 , 1 , 2 , 3 ] , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , [ 0 , 1 , 2 ] , "baz" ) ; } ) ;
} ) ;
} ) ;
2017-03-23 05:54:27 +00:00
it ( 'should use defval if requested' , function ( ) {
var json = X . utils . sheet _to _json ( ws , { defval : 'jimjin' } ) ;
assert . equal ( json . length , data . length - 1 ) ;
assert . equal ( json [ 0 ] [ 1 ] , "TRUE" ) ;
assert . equal ( json [ 1 ] [ 2 ] , "bar" ) ;
assert . equal ( json [ 2 ] [ 3 ] , "qux" ) ;
assert . equal ( json [ 2 ] [ 2 ] , "jimjin" ) ;
assert . equal ( json [ 0 ] [ 3 ] , "jimjin" ) ;
assert . doesNotThrow ( function ( ) { seeker ( json , [ 1 , 2 , 3 ] , "sheetjs" ) ; } ) ;
assert . throws ( function ( ) { seeker ( json , [ 1 , 2 , 3 ] , "baz" ) ; } ) ;
2017-04-13 07:08:46 +00:00
X . utils . sheet _to _json ( ws , { raw : true } ) ;
X . utils . sheet _to _json ( ws , { raw : true , defval : 'jimjin' } ) ;
2017-03-23 05:54:27 +00:00
} ) ;
2017-03-10 23:39:17 +00:00
it ( 'should disambiguate headers' , function ( ) {
var _data = [ [ "S" , "h" , "e" , "e" , "t" , "J" , "S" ] , [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ] , [ 2 , 3 , 4 , 5 , 6 , 7 , 8 ] ] ;
2017-03-25 01:36:40 +00:00
var _ws = X . utils . aoa _to _sheet ( _data ) ;
2017-03-10 23:39:17 +00:00
var json = X . utils . sheet _to _json ( _ws ) ;
for ( var i = 0 ; i < json . length ; ++ i ) {
assert . equal ( json [ i ] . S , 1 + i ) ;
assert . equal ( json [ i ] . h , 2 + i ) ;
assert . equal ( json [ i ] . e , 3 + i ) ;
assert . equal ( json [ i ] . e _1 , 4 + i ) ;
assert . equal ( json [ i ] . t , 5 + i ) ;
assert . equal ( json [ i ] . J , 6 + i ) ;
assert . equal ( json [ i ] . S _1 , 7 + i ) ;
}
} ) ;
2017-03-22 07:50:11 +00:00
it ( 'should handle raw data if requested' , function ( ) {
2017-03-25 01:36:40 +00:00
var _ws = X . utils . aoa _to _sheet ( data , { cellDates : true } ) ;
2017-03-22 07:50:11 +00:00
var json = X . utils . sheet _to _json ( _ws , { header : 1 , raw : true } ) ;
assert . equal ( json . length , data . length ) ;
assert . equal ( json [ 1 ] [ 0 ] , true ) ;
2017-03-23 05:54:27 +00:00
assert . equal ( json [ 1 ] [ 2 ] , null ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 2 ] [ 1 ] , "bar" ) ;
2017-08-05 06:32:57 +00:00
assert . equal ( json [ 2 ] [ 2 ] . getTime ( ) , fixdate . getTime ( ) ) ;
2017-03-22 07:50:11 +00:00
assert . equal ( json [ 3 ] [ 2 ] , "qux" ) ;
} ) ;
2017-03-25 01:36:40 +00:00
it ( 'should include __rowNum__' , function ( ) {
var _data = [ [ "S" , "h" , "e" , "e" , "t" , "J" , "S" ] , [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ] , [ ] , [ 2 , 3 , 4 , 5 , 6 , 7 , 8 ] ] ;
var _ws = X . utils . aoa _to _sheet ( _data ) ;
var json = X . utils . sheet _to _json ( _ws ) ;
assert . equal ( json [ 0 ] . _ _rowNum _ _ , 1 ) ;
assert . equal ( json [ 1 ] . _ _rowNum _ _ , 3 ) ;
} ) ;
it ( 'should handle blankrows' , function ( ) {
var _data = [ [ "S" , "h" , "e" , "e" , "t" , "J" , "S" ] , [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ] , [ ] , [ 2 , 3 , 4 , 5 , 6 , 7 , 8 ] ] ;
var _ws = X . utils . aoa _to _sheet ( _data ) ;
var json1 = X . utils . sheet _to _json ( _ws ) ;
assert . equal ( json1 . length , 2 ) ; // = 2 non-empty records
2017-09-30 06:18:11 +00:00
var json2 = X . utils . sheet _to _json ( _ws , { header : 1 } ) ;
2017-03-25 01:36:40 +00:00
assert . equal ( json2 . length , 4 ) ; // = 4 sheet rows
2017-09-30 06:18:11 +00:00
var json3 = X . utils . sheet _to _json ( _ws , { blankrows : true } ) ;
2017-03-25 01:36:40 +00:00
assert . equal ( json3 . length , 3 ) ; // = 2 records + 1 blank row
2017-09-30 06:18:11 +00:00
var json4 = X . utils . sheet _to _json ( _ws , { blankrows : true , header : 1 } ) ;
2017-03-25 01:36:40 +00:00
assert . equal ( json4 . length , 4 ) ; // = 4 sheet rows
2017-09-30 06:18:11 +00:00
var json5 = X . utils . sheet _to _json ( _ws , { blankrows : false } ) ;
2017-03-25 01:36:40 +00:00
assert . equal ( json5 . length , 2 ) ; // = 2 records
2017-09-30 06:18:11 +00:00
var json6 = X . utils . sheet _to _json ( _ws , { blankrows : false , header : 1 } ) ;
2017-03-25 01:36:40 +00:00
assert . equal ( json6 . length , 3 ) ; // = 4 sheet rows - 1 blank row
} ) ;
2017-04-26 15:32:42 +00:00
it ( 'should have an index that starts with zero when selecting range' , function ( ) {
var _data = [ [ "S" , "h" , "e" , "e" , "t" , "J" , "S" ] , [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ] , [ 7 , 6 , 5 , 4 , 3 , 2 , 1 ] , [ 2 , 3 , 4 , 5 , 6 , 7 , 8 ] ] ;
var _ws = X . utils . aoa _to _sheet ( _data ) ;
var json1 = X . utils . sheet _to _json ( _ws , { header : 1 , raw : true , range : "B1:F3" } ) ;
assert . equal ( json1 [ 0 ] [ 3 ] , "t" ) ;
assert . equal ( json1 [ 1 ] [ 0 ] , 2 ) ;
assert . equal ( json1 [ 2 ] [ 1 ] , 5 ) ;
assert . equal ( json1 [ 2 ] [ 3 ] , 3 ) ;
} ) ;
2017-12-14 11:11:57 +00:00
it ( 'should preserve values when column header is missing' , function ( ) {
/*jshint elision:true */
var _data = [ [ , "a" , "b" , , "c" ] , [ 1 , 2 , 3 , , 5 ] , [ , 3 , 4 , 5 , 6 ] ] ;
/*jshint elision:false */
var _ws = X . utils . aoa _to _sheet ( _data ) ;
var json1 = X . utils . sheet _to _json ( _ws , { raw : true } ) ;
assert . equal ( json1 [ 0 ] . _ _EMPTY , 1 ) ;
assert . equal ( json1 [ 1 ] . _ _EMPTY _1 , 5 ) ;
} ) ;
2017-03-25 01:36:40 +00:00
} ) ;
2017-08-18 18:10:18 +00:00
2017-09-30 06:18:11 +00:00
var codes = [ [ "あ 1" , "\u00E3\u0081\u0082 1" ] ] ;
2017-08-18 18:10:18 +00:00
var plaintext _val = [
[ "A1" , 'n' , - 0.08 , "-0.08" ] ,
[ "B1" , 'n' , 4001 , "4,001" ] ,
[ "C1" , 's' , "あ 1" , "あ 1" ] ,
[ "A2" , 'n' , 41.08 , "$41.08" ] ,
[ "B2" , 'n' , 0.11 , "11%" ] ,
2017-09-30 06:18:11 +00:00
[ "C3" , 'b' , true , "TRUE" ] ,
[ "D3" , 'b' , false , "FALSE" ] ,
[ "B3" , 's' , " " , " " ] ,
[ "A3" ]
] ;
function plaintext _test ( wb , raw , t ) {
var sheet = wb . Sheets [ wb . SheetNames [ 0 ] ] ;
2017-08-18 18:10:18 +00:00
plaintext _val . forEach ( function ( x ) {
var cell = get _cell ( sheet , x [ 0 ] ) ;
2017-09-30 06:18:11 +00:00
var tcval = x [ 2 + ! ! raw ] ;
2017-10-17 00:14:32 +00:00
var type = raw ? 's' : x [ 1 ] ;
2017-08-18 18:10:18 +00:00
if ( x . length == 1 ) { if ( cell ) { assert . equal ( cell . t , 'z' ) ; assert ( ! cell . v ) ; } return ; }
2017-09-30 06:18:11 +00:00
assert . equal ( cell . v , tcval ) ; assert . equal ( cell . t , type ) ;
2017-08-18 18:10:18 +00:00
} ) ;
}
function make _html _str ( idx ) { return [ "<table>" ,
"<tr><td>-0.08</td><td>4,001</td><td>" , codes [ 0 ] [ idx ] , "</td></tr>" ,
"<tr><td>$41.08</td><td>11%</td></tr>" ,
2017-09-30 06:18:11 +00:00
"<tr><td></td><td> \n </td><td>TRUE</td><td>FALSE</td></tr>" ,
2017-08-18 18:10:18 +00:00
"</table>" ] . join ( "" ) ; }
2017-09-30 06:18:11 +00:00
function make _csv _str ( idx ) { return [ ( idx == 1 ? '\u00EF\u00BB\u00BF' : "" ) +
2017-08-18 18:10:18 +00:00
'-0.08,"4,001",' + codes [ 0 ] [ idx ] + '' ,
'$41.08,11%' ,
2017-09-30 06:18:11 +00:00
', ,TRUE,FALSE'
2017-08-18 18:10:18 +00:00
] . join ( "\n" ) ; }
var html _bstr = make _html _str ( 1 ) , html _str = make _html _str ( 0 ) ;
2017-09-30 06:18:11 +00:00
var csv _bstr = make _csv _str ( 1 ) , csv _str = make _csv _str ( 0 ) ;
2017-08-18 18:10:18 +00:00
2017-12-09 07:17:25 +00:00
describe ( 'CSV' , function ( ) {
2017-05-13 18:21:22 +00:00
describe ( 'input' , function ( ) {
var b = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,2/19/14,0.3\n,,,\nbaz,,qux,\n" ;
it ( 'should generate date numbers by default' , function ( ) {
var opts = { type : "binary" } ;
var cell = get _cell ( X . read ( b , opts ) . Sheets . Sheet1 , "C3" ) ;
assert . equal ( cell . w , '2/19/14' ) ;
assert . equal ( cell . t , 'n' ) ;
assert ( typeof cell . v == "number" ) ;
} ) ;
it ( 'should generate dates when requested' , function ( ) {
var opts = { type : "binary" , cellDates : true } ;
var cell = get _cell ( X . read ( b , opts ) . Sheets . Sheet1 , "C3" ) ;
assert . equal ( cell . w , '2/19/14' ) ;
assert . equal ( cell . t , 'd' ) ;
assert ( cell . v instanceof Date || typeof cell . v == "string" ) ;
} ) ;
it ( 'should use US date code 14 by default' , function ( ) {
2017-10-17 00:14:32 +00:00
var opts = ( { type : "binary" } /*:any*/ ) ;
2017-05-13 18:21:22 +00:00
var cell = get _cell ( X . read ( b , opts ) . Sheets . Sheet1 , "C3" ) ;
assert . equal ( cell . w , '2/19/14' ) ;
opts . cellDates = true ;
2017-09-30 06:18:11 +00:00
cell = get _cell ( X . read ( b , opts ) . Sheets . Sheet1 , "C3" ) ;
2017-05-13 18:21:22 +00:00
assert . equal ( cell . w , '2/19/14' ) ;
} ) ;
it ( 'should honor dateNF override' , function ( ) {
2017-10-17 00:14:32 +00:00
var opts = ( { type : "binary" , dateNF : "YYYY-MM-DD" } /*:any*/ ) ;
2017-05-13 18:21:22 +00:00
var cell = get _cell ( X . read ( b , opts ) . Sheets . Sheet1 , "C3" ) ;
2017-05-17 04:23:36 +00:00
/* NOTE: IE interprets 2-digit years as 19xx */
assert ( cell . w == '2014-02-19' || cell . w == '1914-02-19' ) ;
2017-05-13 18:21:22 +00:00
opts . cellDates = true ; opts . dateNF = "YY-MM-DD" ;
2017-09-30 06:18:11 +00:00
cell = get _cell ( X . read ( b , opts ) . Sheets . Sheet1 , "C3" ) ;
2017-05-13 18:21:22 +00:00
assert . equal ( cell . w , '14-02-19' ) ;
} ) ;
2017-06-01 21:22:11 +00:00
it ( 'should interpret dateNF' , function ( ) {
var bb = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,2/3/14,0.3\n,,,\nbaz,,qux,\n" ;
var opts = { type : "binary" , cellDates : true , dateNF : 'm/d/yy' } ;
var cell = get _cell ( X . read ( bb , opts ) . Sheets . Sheet1 , "C3" ) ;
assert . equal ( cell . v . getMonth ( ) , 1 ) ;
assert . equal ( cell . w , "2/3/14" ) ;
opts = { type : "binary" , cellDates : true , dateNF : 'd/m/yy' } ;
cell = get _cell ( X . read ( bb , opts ) . Sheets . Sheet1 , "C3" ) ;
assert . equal ( cell . v . getMonth ( ) , 2 ) ;
assert . equal ( cell . w , "2/3/14" ) ;
} ) ;
2017-09-30 06:18:11 +00:00
it ( 'should interpret values by default' , function ( ) { plaintext _test ( X . read ( csv _bstr , { type : "binary" } ) , false , false ) ; } ) ;
2017-10-17 00:14:32 +00:00
it ( 'should generate strings if raw option is passed' , function ( ) { plaintext _test ( X . read ( csv _str , { type : "string" , raw : true } ) , true , false ) ; } ) ;
2017-08-18 18:10:18 +00:00
it ( 'should handle formulae' , function ( ) {
var bb = '=,=1+1,="100"' ;
var sheet = X . read ( bb , { type : "binary" } ) . Sheets . Sheet1 ;
assert . equal ( get _cell ( sheet , "A1" ) . t , 's' ) ;
assert . equal ( get _cell ( sheet , "A1" ) . v , '=' ) ;
assert . equal ( get _cell ( sheet , "B1" ) . f , '1+1' ) ;
assert . equal ( get _cell ( sheet , "C1" ) . t , 's' ) ;
assert . equal ( get _cell ( sheet , "C1" ) . v , '100' ) ;
} ) ;
2017-12-09 07:17:25 +00:00
if ( ! browser || typeof cptable !== 'undefined' ) it ( 'should honor codepage for binary strings' , function ( ) {
var data = "abc,def\nghi,j\xD3l" ;
[ [ 1251 , 'У ' ] , [ 1252 , 'Ó' ] , [ 1253 , 'Σ' ] , [ 1254 , 'Ó' ] , [ 1255 , '׃ ' ] , [ 1256 , 'س' ] , [ 10000 , '”' ] ] . forEach ( function ( m ) {
var ws = X . read ( data , { type : "binary" , codepage : m [ 0 ] } ) . Sheets . Sheet1 ;
assert . equal ( get _cell ( ws , "B2" ) . v , "j" + m [ 1 ] + "l" ) ;
} ) ;
} ) ;
2017-05-13 18:21:22 +00:00
} ) ;
describe ( 'output' , function ( ) {
var data , ws ;
var bef = ( function ( ) {
data = [
[ 1 , 2 , 3 , null ] ,
[ true , false , null , "sheetjs" ] ,
2017-08-05 06:32:57 +00:00
[ "foo" , "bar" , fixdate , "0.3" ] ,
2017-05-13 18:21:22 +00:00
[ null , null , null ] ,
[ "baz" , undefined , "qux" ]
] ;
ws = X . utils . aoa _to _sheet ( data ) ;
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
it ( 'should generate csv' , function ( ) {
var baseline = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,2/19/14,0.3\n,,,\nbaz,,qux,\n" ;
assert . equal ( baseline , X . utils . sheet _to _csv ( ws ) ) ;
} ) ;
it ( 'should handle FS' , function ( ) {
assert . equal ( X . utils . sheet _to _csv ( ws , { FS : "|" } ) . replace ( /[|]/g , "," ) , X . utils . sheet _to _csv ( ws ) ) ;
assert . equal ( X . utils . sheet _to _csv ( ws , { FS : ";" } ) . replace ( /[;]/g , "," ) , X . utils . sheet _to _csv ( ws ) ) ;
} ) ;
it ( 'should handle RS' , function ( ) {
assert . equal ( X . utils . sheet _to _csv ( ws , { RS : "|" } ) . replace ( /[|]/g , "\n" ) , X . utils . sheet _to _csv ( ws ) ) ;
assert . equal ( X . utils . sheet _to _csv ( ws , { RS : ";" } ) . replace ( /[;]/g , "\n" ) , X . utils . sheet _to _csv ( ws ) ) ;
} ) ;
it ( 'should handle dateNF' , function ( ) {
var baseline = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,20140219,0.3\n,,,\nbaz,,qux,\n" ;
var _ws = X . utils . aoa _to _sheet ( data , { cellDates : true } ) ;
delete get _cell ( _ws , "C3" ) . w ;
delete get _cell ( _ws , "C3" ) . z ;
assert . equal ( baseline , X . utils . sheet _to _csv ( _ws , { dateNF : "YYYYMMDD" } ) ) ;
} ) ;
it ( 'should handle strip' , function ( ) {
var baseline = "1,2,3\nTRUE,FALSE,,sheetjs\nfoo,bar,2/19/14,0.3\n\nbaz,,qux\n" ;
assert . equal ( baseline , X . utils . sheet _to _csv ( ws , { strip : true } ) ) ;
} ) ;
it ( 'should handle blankrows' , function ( ) {
var baseline = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,2/19/14,0.3\nbaz,,qux,\n" ;
assert . equal ( baseline , X . utils . sheet _to _csv ( ws , { blankrows : false } ) ) ;
} ) ;
it ( 'should handle various line endings' , function ( ) {
var data = [ "1,a" , "2,b" , "3,c" ] ;
[ "\r" , "\n" , "\r\n" ] . forEach ( function ( RS ) {
var wb = X . read ( data . join ( RS ) , { type : 'binary' } ) ;
assert . equal ( get _cell ( wb . Sheets . Sheet1 , "A1" ) . v , 1 ) ;
assert . equal ( get _cell ( wb . Sheets . Sheet1 , "B3" ) . v , "c" ) ;
assert . equal ( wb . Sheets . Sheet1 [ '!ref' ] , "A1:B3" ) ;
} ) ;
2017-05-09 18:07:57 +00:00
} ) ;
2017-08-02 16:41:44 +00:00
it ( 'should handle skipHidden for rows if requested' , function ( ) {
var baseline = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,2/19/14,0.3\n,,,\nbaz,,qux,\n" ;
2017-08-05 06:32:57 +00:00
delete ws [ "!rows" ] ;
2017-08-02 16:41:44 +00:00
assert . equal ( X . utils . sheet _to _csv ( ws ) , baseline ) ;
2017-08-05 06:32:57 +00:00
assert . equal ( X . utils . sheet _to _csv ( ws , { skipHidden : true } ) , baseline ) ;
2017-08-02 16:41:44 +00:00
ws [ "!rows" ] = [ null , { hidden : true } , null , null ] ;
assert . equal ( X . utils . sheet _to _csv ( ws ) , baseline ) ;
assert . equal ( X . utils . sheet _to _csv ( ws , { skipHidden : true } ) , "1,2,3,\nfoo,bar,2/19/14,0.3\n,,,\nbaz,,qux,\n" ) ;
delete ws [ "!rows" ] ;
} ) ;
it ( 'should handle skipHidden for columns if requested' , function ( ) {
var baseline = "1,2,3,\nTRUE,FALSE,,sheetjs\nfoo,bar,2/19/14,0.3\n,,,\nbaz,,qux,\n" ;
2017-08-05 06:32:57 +00:00
delete ws [ "!cols" ] ;
2017-08-02 16:41:44 +00:00
assert . equal ( X . utils . sheet _to _csv ( ws ) , baseline ) ;
2017-08-05 06:32:57 +00:00
assert . equal ( X . utils . sheet _to _csv ( ws , { skipHidden : true } ) , baseline ) ;
2017-08-02 16:41:44 +00:00
ws [ "!cols" ] = [ null , { hidden : true } , null , null ] ;
assert . equal ( X . utils . sheet _to _csv ( ws ) , baseline ) ;
assert . equal ( X . utils . sheet _to _csv ( ws , { skipHidden : true } ) , "1,3,\nTRUE,,sheetjs\nfoo,2/19/14,0.3\n,,\nbaz,qux,\n" ) ;
ws [ "!cols" ] = [ { hidden : true } , null , null , null ] ;
assert . equal ( X . utils . sheet _to _csv ( ws , { skipHidden : true } ) , "2,3,\nFALSE,,sheetjs\nbar,2/19/14,0.3\n,,\n,qux,\n" ) ;
delete ws [ "!cols" ] ;
} ) ;
2017-05-09 18:07:57 +00:00
} ) ;
2014-05-29 22:30:03 +00:00
} ) ;
2017-10-17 00:14:32 +00:00
if ( fs . existsSync ( './test_files/dbf/d11.dbf' ) ) describe ( 'dbf' , function ( ) {
var wbs /*:Array<any>*/ = ( [
[ 'd11' , './test_files/dbf/d11.dbf' ] ,
[ 'vfp3' , './test_files/dbf/vfp3.dbf' ]
] /*:any*/ ) ;
var bef = ( function ( ) {
wbs = wbs . map ( function ( x ) { return [ x [ 0 ] , X . read ( fs . readFileSync ( x [ 1 ] ) , { type : TYPE } ) ] ; } ) ;
} ) ;
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
it ( wbs [ 1 ] [ 0 ] , function ( ) {
var ws = wbs [ 1 ] [ 1 ] . Sheets . Sheet1 ;
[
[ "A1" , "v" , "CHAR10" ] , [ "A2" , "v" , "test1" ] , [ "B2" , "v" , 123.45 ] ,
[ "C2" , "v" , 12.345 ] , [ "D2" , "v" , 1234.1 ] , [ "E2" , "w" , "19170219" ] ,
/* [F2", "w", "19170219"], */ [ "G2" , "v" , 1231.4 ] , [ "H2" , "v" , 123234 ] ,
[ "I2" , "v" , true ] , [ "L2" , "v" , "SheetJS" ]
] . forEach ( function ( r ) { assert . equal ( get _cell ( ws , r [ 0 ] ) [ r [ 1 ] ] , r [ 2 ] ) ; } ) ;
} ) ;
} ) ;
2017-08-18 18:10:18 +00:00
var JSDOM = null ;
2017-10-17 00:14:32 +00:00
// $FlowIgnore
2017-08-18 18:10:18 +00:00
var domtest = browser || ( function ( ) { try { return ! ! ( JSDOM = require ( 'jsdom' ) . JSDOM ) ; } catch ( e ) { return 0 ; } } ) ( ) ;
function get _dom _element ( html ) {
if ( browser ) {
var domelt = document . createElement ( 'div' ) ;
domelt . innerHTML = html ;
return domelt ;
}
2017-10-17 00:14:32 +00:00
if ( ! JSDOM ) throw new Error ( "Browser test fail" ) ;
2017-08-18 18:10:18 +00:00
return new JSDOM ( html ) . window . document . body . children [ 0 ] ;
}
2017-08-09 22:38:23 +00:00
describe ( 'HTML' , function ( ) {
2017-08-18 18:10:18 +00:00
describe ( 'input string' , function ( ) {
2017-09-30 06:18:11 +00:00
it ( 'should interpret values by default' , function ( ) { plaintext _test ( X . read ( html _bstr , { type : "binary" } ) , false , false ) ; } ) ;
it ( 'should generate strings if raw option is passed' , function ( ) { plaintext _test ( X . read ( html _bstr , { type : "binary" , raw : true } ) , true , false ) ; } ) ;
it ( 'should handle "string" type' , function ( ) { plaintext _test ( X . read ( html _str , { type : "string" } ) , false , false ) ; } ) ;
2017-12-25 02:25:03 +00:00
it ( 'should handle newlines correctly' , function ( ) {
var table = "<table><tr><td>foo<br/>bar</td><td>baz</td></tr></table>" ;
var wb = X . read ( table , { type : "string" } ) ;
assert . equal ( get _cell ( wb . Sheets . Sheet1 , "A1" ) . v , "foo\nbar" ) ;
} ) ;
2017-08-18 18:10:18 +00:00
} ) ;
( domtest ? describe : describe . skip ) ( 'input DOM' , function ( ) {
2017-09-30 06:18:11 +00:00
it ( 'should interpret values by default' , function ( ) { plaintext _test ( X . utils . table _to _book ( get _dom _element ( html _str ) ) , false , true ) ; } ) ;
it ( 'should generate strings if raw option is passed' , function ( ) { plaintext _test ( X . utils . table _to _book ( get _dom _element ( html _str ) , { raw : true } ) , true , true ) ; } ) ;
2017-10-31 18:31:04 +00:00
it ( 'should handle newlines correctly' , function ( ) {
var table = get _dom _element ( "<table><tr><td>foo<br/>bar</td><td>baz</td></tr></table>" ) ;
2017-12-30 05:40:35 +00:00
var ws = X . utils . table _to _sheet ( table ) ;
assert . equal ( get _cell ( ws , "A1" ) . v , "foo\nbar" ) ;
} ) ;
it ( 'should trim whitespace' , function ( ) {
if ( get _dom _element ( "foo <br> bar" ) . innerHTML != "foo <br> bar" ) return ;
var table = get _dom _element ( "<table><tr><td> foo <br/> bar </td><td> baz qux </td></tr></table>" ) ;
var ws = X . utils . table _to _sheet ( table ) ;
assert . equal ( get _cell ( ws , "A1" ) . v . replace ( /\n/g , "|" ) , "foo | bar" ) ;
assert . equal ( get _cell ( ws , "B1" ) . v , "baz qux" ) ;
2017-10-31 18:31:04 +00:00
} ) ;
2017-08-09 22:38:23 +00:00
} ) ;
2017-12-09 07:17:25 +00:00
if ( domtest ) it ( 'should handle entities' , function ( ) {
var html = "<table><tr><td>A&B</td><td>A·B</td></tr></table>" ;
var ws = X . utils . table _to _sheet ( get _dom _element ( html ) ) ;
assert . equal ( get _cell ( ws , "A1" ) . v , "A&B" ) ;
assert . equal ( get _cell ( ws , "B1" ) . v , "A·B" ) ;
} ) ;
2017-12-12 06:21:28 +00:00
describe ( 'type override' , function ( ) {
function chk ( ws ) {
assert . equal ( get _cell ( ws , "A1" ) . t , "s" ) ;
assert . equal ( get _cell ( ws , "A1" ) . v , "1234567890" ) ;
assert . equal ( get _cell ( ws , "B1" ) . t , "n" ) ;
assert . equal ( get _cell ( ws , "B1" ) . v , 1234567890 ) ;
}
var html = "<table><tr><td t=\"s\">1234567890</td><td>1234567890</td></tr></table>" ;
it ( 'HTML string' , function ( ) {
var ws = X . read ( html , { type : 'string' } ) . Sheets . Sheet1 ; chk ( ws ) ;
chk ( X . read ( X . utils . sheet _to _html ( ws ) , { type : 'string' } ) . Sheets . Sheet1 ) ;
} ) ;
if ( domtest ) it ( 'DOM' , function ( ) { chk ( X . utils . table _to _sheet ( get _dom _element ( html ) ) ) ; } ) ;
} ) ;
2017-08-09 22:38:23 +00:00
} ) ;
2017-02-10 19:23:01 +00:00
describe ( 'js -> file -> js' , function ( ) {
2017-10-17 00:14:32 +00:00
var wb , BIN = "binary" ;
2017-03-10 01:09:18 +00:00
var bef = ( function ( ) {
2017-10-17 00:14:32 +00:00
var ws = X . utils . aoa _to _sheet ( [
2017-10-27 16:25:54 +00:00
[ "number" , "bool" , "string" , "date" ] ,
[ 1 , true , "sheet" ] ,
[ 2 , false , "dot" ] ,
[ 6.9 , false , "JS" , fixdate ] ,
[ 72.62 , true , "0.3" ]
2017-10-17 00:14:32 +00:00
] ) ;
2017-02-10 19:23:01 +00:00
wb = { SheetNames : [ 'Sheet1' ] , Sheets : { Sheet1 : ws } } ;
} ) ;
2017-03-10 01:09:18 +00:00
if ( typeof before != 'undefined' ) before ( bef ) ;
else it ( 'before' , bef ) ;
2017-02-10 19:23:01 +00:00
function eqcell ( wb1 , wb2 , s , a ) {
2017-04-08 06:55:35 +00:00
assert . equal ( get _cell ( wb1 . Sheets [ s ] , a ) . v , get _cell ( wb2 . Sheets [ s ] , a ) . v ) ;
assert . equal ( get _cell ( wb1 . Sheets [ s ] , a ) . t , get _cell ( wb2 . Sheets [ s ] , a ) . t ) ;
2017-02-10 19:23:01 +00:00
}
ofmt . forEach ( function ( f ) {
it ( f , function ( ) {
var newwb = X . read ( X . write ( wb , { type : BIN , bookType : f } ) , { type : BIN } ) ;
2017-09-30 06:18:11 +00:00
var cb = function ( cell ) { eqcell ( wb , newwb , 'Sheet1' , cell ) ; } ;
2017-10-27 16:25:54 +00:00
[ 'A2' , 'A3' ] . forEach ( cb ) ; /* int */
[ 'A4' , 'A5' ] . forEach ( cb ) ; /* double */
[ 'B2' , 'B3' ] . forEach ( cb ) ; /* bool */
[ 'C2' , 'C3' ] . forEach ( cb ) ; /* string */
if ( ! DIF _XL ) cb ( 'D4' ) ; /* date */
if ( DIF _XL && f == "dif" ) assert . equal ( get _cell ( newwb . Sheets . Sheet1 , 'C5' ) . v , '=""0.3""' ) ; // dif forces string formula
else eqcell ( wb , newwb , 'Sheet1' , 'C5' ) ;
2017-02-10 19:23:01 +00:00
} ) ;
} ) ;
} ) ;
2014-05-29 22:30:03 +00:00
describe ( 'corner cases' , function ( ) {
it ( 'output functions' , function ( ) {
2017-10-17 00:14:32 +00:00
var ws = X . utils . aoa _to _sheet ( [
2014-05-29 22:30:03 +00:00
[ 1 , 2 , 3 ] ,
[ true , false , null , "sheetjs" ] ,
2017-08-05 06:32:57 +00:00
[ "foo" , "bar" , fixdate , "0.3" ] ,
2014-05-29 22:30:03 +00:00
[ "baz" , null , "q\"ux" ]
2017-10-17 00:14:32 +00:00
] ) ;
2017-04-08 06:55:35 +00:00
get _cell ( ws , "A1" ) . f = "" ; get _cell ( ws , "A1" ) . w = "" ;
delete get _cell ( ws , "C3" ) . w ; delete get _cell ( ws , "C3" ) . z ; get _cell ( ws , "C3" ) . XF = { ifmt : 14 } ;
get _cell ( ws , "A4" ) . t = "e" ;
2014-05-29 22:30:03 +00:00
X . utils . get _formulae ( ws ) ;
X . utils . make _csv ( ws ) ;
X . utils . make _json ( ws ) ;
2014-06-05 07:06:20 +00:00
ws [ '!cols' ] = [ { wch : 6 } , { wch : 7 } , { wch : 10 } , { wch : 20 } ] ;
var wb = { SheetNames : [ 'sheetjs' ] , Sheets : { sheetjs : ws } } ;
X . write ( wb , { type : "binary" , bookType : 'xlsx' } ) ;
2017-08-05 06:32:57 +00:00
X . write ( wb , { type : TYPE , bookType : 'xlsm' } ) ;
2014-06-05 07:06:20 +00:00
X . write ( wb , { type : "base64" , bookType : 'xlsb' } ) ;
2017-02-10 19:23:01 +00:00
X . write ( wb , { type : "binary" , bookType : 'ods' } ) ;
X . write ( wb , { type : "binary" , bookType : 'biff2' } ) ;
2017-10-17 00:14:32 +00:00
X . write ( wb , { type : "binary" , bookType : 'biff5' } ) ;
2017-09-22 22:18:51 +00:00
X . write ( wb , { type : "binary" , bookType : 'biff8' } ) ;
2017-04-08 06:55:35 +00:00
get _cell ( ws , "A2" ) . t = "f" ;
2014-05-29 22:30:03 +00:00
assert . throws ( function ( ) { X . utils . make _json ( ws ) ; } ) ;
} ) ;
it ( 'SSF' , function ( ) {
X . SSF . format ( "General" , "dafuq" ) ;
assert . throws ( function ( x ) { return X . SSF . format ( "General" , { sheet : "js" } ) ; } ) ;
X . SSF . format ( "b e ddd hh AM/PM" , 41722.4097222222 ) ;
X . SSF . format ( "b ddd hh m" , 41722.4097222222 ) ;
[ "hhh" , "hhh A/P" , "hhmmm" , "sss" , "[hhh]" , "G eneral" ] . forEach ( function ( f ) {
assert . throws ( function ( x ) { return X . SSF . format ( f , 12345.6789 ) ; } ) ;
} ) ;
[ "[m]" , "[s]" ] . forEach ( function ( f ) {
assert . doesNotThrow ( function ( x ) { return X . SSF . format ( f , 12345.6789 ) ; } ) ;
} ) ;
} ) ;
2017-03-19 06:50:30 +00:00
it ( 'SSF oddities' , function ( ) {
2017-10-17 00:14:32 +00:00
// $FlowIgnore
2017-03-19 06:50:30 +00:00
var ssfdata = require ( './misc/ssf.json' ) ;
2017-09-30 06:18:11 +00:00
var cb = function ( d , j ) { return function ( ) { return X . SSF . format ( d [ 0 ] , d [ j ] [ 0 ] ) ; } ; } ;
2017-03-19 06:50:30 +00:00
ssfdata . forEach ( function ( d ) {
for ( var j = 1 ; j < d . length ; ++ j ) {
if ( d [ j ] . length == 2 ) {
var expected = d [ j ] [ 1 ] , actual = X . SSF . format ( d [ 0 ] , d [ j ] [ 0 ] , { } ) ;
assert . equal ( actual , expected ) ;
2017-09-30 06:18:11 +00:00
} else if ( d [ j ] [ 2 ] !== "#" ) assert . throws ( cb ( d , j ) ) ;
2017-03-19 06:50:30 +00:00
}
} ) ;
} ) ;
2015-04-02 20:32:22 +00:00
it ( 'codepage' , function ( ) {
2017-08-05 06:32:57 +00:00
X . read ( fs . readFileSync ( dir + "biff5/number_format_greek.xls" ) , { type : TYPE } ) ;
2015-04-02 20:32:22 +00:00
} ) ;
} ) ;
describe ( 'encryption' , function ( ) {
password _files . forEach ( function ( x ) {
describe ( x , function ( ) {
2017-08-05 06:32:57 +00:00
it ( 'should throw with no password' , function ( ) { assert . throws ( function ( ) { X . read ( fs . readFileSync ( dir + x ) , { type : TYPE } ) ; } ) ; } ) ;
2017-05-11 07:29:59 +00:00
it ( 'should throw with wrong password' , function ( ) {
try {
2017-09-04 03:55:10 +00:00
X . read ( fs . readFileSync ( dir + x ) , { type : TYPE , password : 'Password' , WTF : opts . WTF } ) ;
2017-05-11 07:29:59 +00:00
throw new Error ( "incorrect password was accepted" ) ;
} catch ( e ) {
if ( e . message != "Password is incorrect" ) throw e ;
}
} ) ;
it ( 'should recognize correct password' , function ( ) {
try {
2017-08-05 06:32:57 +00:00
X . read ( fs . readFileSync ( dir + x ) , { type : TYPE , password : 'password' , WTF : opts . WTF } ) ;
2017-05-11 07:29:59 +00:00
} catch ( e ) {
if ( e . message == "Password is incorrect" ) throw e ;
}
2015-04-02 20:32:22 +00:00
} ) ;
it . skip ( 'should decrypt file' , function ( ) {
2017-09-30 06:18:11 +00:00
/*var wb = */ X . read ( fs . readFileSync ( dir + x ) , { type : TYPE , password : 'password' , WTF : opts . WTF } ) ;
2015-04-02 20:32:22 +00:00
} ) ;
} ) ;
} ) ;
2014-05-29 22:30:03 +00:00
} ) ;
2017-03-16 01:17:24 +00:00
2017-08-05 06:32:57 +00:00
if ( ! browser || typeof cptable !== 'undefined' )
2017-03-16 01:17:24 +00:00
describe ( 'multiformat tests' , function ( ) {
var mfopts = opts ;
2017-04-24 10:39:00 +00:00
var mft = fs . readFileSync ( 'multiformat.lst' , 'utf-8' ) . split ( "\n" ) . map ( function ( x ) { return x . trim ( ) ; } ) ;
2017-03-18 00:45:06 +00:00
var csv = true , formulae = false ;
2017-03-16 01:17:24 +00:00
mft . forEach ( function ( x ) {
2017-05-17 04:23:36 +00:00
if ( x . charAt ( 0 ) != "#" ) describe ( 'MFT ' + x , function ( ) {
2017-10-17 00:14:32 +00:00
var f = [ ] , r = x . split ( /\s+/ ) ;
2017-03-16 01:17:24 +00:00
if ( r . length < 3 ) return ;
2017-08-05 06:32:57 +00:00
if ( ! fs . existsSync ( dir + r [ 0 ] + r [ 1 ] ) ) return ;
2017-03-16 01:17:24 +00:00
it ( 'should parse all' , function ( ) {
2017-08-05 06:32:57 +00:00
for ( var j = 1 ; j < r . length ; ++ j ) f [ j - 1 ] = X . read ( fs . readFileSync ( dir + r [ 0 ] + r [ j ] ) , mfopts ) ;
2017-03-16 01:17:24 +00:00
} ) ;
it ( 'should have the same sheetnames' , function ( ) {
cmparr ( f . map ( function ( x ) { return x . SheetNames ; } ) ) ;
} ) ;
it ( 'should have the same ranges' , function ( ) {
f [ 0 ] . SheetNames . forEach ( function ( s ) {
var ss = f . map ( function ( x ) { return x . Sheets [ s ] ; } ) ;
cmparr ( ss . map ( function ( s ) { return s [ '!ref' ] ; } ) ) ;
} ) ;
} ) ;
it ( 'should have the same merges' , function ( ) {
f [ 0 ] . SheetNames . forEach ( function ( s ) {
var ss = f . map ( function ( x ) { return x . Sheets [ s ] ; } ) ;
cmparr ( ss . map ( function ( s ) { return ( s [ '!merges' ] || [ ] ) . map ( function ( y ) { return X . utils . encode _range ( y ) ; } ) . sort ( ) ; } ) ) ;
} ) ;
} ) ;
it ( 'should have the same CSV' , csv ? function ( ) {
cmparr ( f . map ( function ( x ) { return x . SheetNames ; } ) ) ;
2017-10-17 00:14:32 +00:00
f [ 0 ] . SheetNames . forEach ( function ( name ) {
2017-03-16 01:17:24 +00:00
cmparr ( f . map ( function ( x ) { return X . utils . sheet _to _csv ( x . Sheets [ name ] ) ; } ) ) ;
} ) ;
} : null ) ;
2017-03-18 00:45:06 +00:00
it ( 'should have the same formulae' , formulae ? function ( ) {
cmparr ( f . map ( function ( x ) { return x . SheetNames ; } ) ) ;
2017-10-17 00:14:32 +00:00
f [ 0 ] . SheetNames . forEach ( function ( name ) {
2017-03-18 00:45:06 +00:00
cmparr ( f . map ( function ( x ) { return X . utils . sheet _to _formulae ( x . Sheets [ name ] ) . sort ( ) ; } ) ) ;
} ) ;
} : null ) ;
2017-03-16 01:17:24 +00:00
} ) ;
else x . split ( /\s+/ ) . forEach ( function ( w ) { switch ( w ) {
case "no-csv" : csv = false ; break ;
case "yes-csv" : csv = true ; break ;
2017-03-18 00:45:06 +00:00
case "no-formula" : formulae = false ; break ;
case "yes-formula" : formulae = true ; break ;
2017-03-16 01:17:24 +00:00
} } ) ;
2017-10-17 00:14:32 +00:00
} ) ; } ) ;
2017-03-16 01:17:24 +00:00