React Excel Utility

    This topic provides utility function for loading and saving Microsoft Excel files using Excel Library

    import { saveAs } from "file-saver"; // npm package: "file-saver": "^1.3.8"
    import { Workbook } from 'igniteui-react-excel';
    import { WorkbookFormat } from 'igniteui-react-excel';
    import { WorkbookSaveOptions } from 'igniteui-react-excel';
    import { WorkbookLoadOptions } from 'igniteui-react-excel';
    import { IgrExcelXlsxModule } from 'igniteui-react-excel';
    import { IgrExcelCoreModule } from 'igniteui-react-excel';
    import { IgrExcelModule } from 'igniteui-react-excel';
    
    IgrExcelCoreModule.register();
    IgrExcelModule.register();
    IgrExcelXlsxModule.register();
    
    export class ExcelUtility {
        public static getExtension(format: WorkbookFormat) {
            switch (format) {
                case WorkbookFormat.StrictOpenXml:
                case WorkbookFormat.Excel2007:
                    return ".xlsx";
                case WorkbookFormat.Excel2007MacroEnabled:
                    return ".xlsm";
                case WorkbookFormat.Excel2007MacroEnabledTemplate:
                    return ".xltm";
                case WorkbookFormat.Excel2007Template:
                    return ".xltx";
                case WorkbookFormat.Excel97To2003:
                    return ".xls";
                case WorkbookFormat.Excel97To2003Template:
                    return ".xlt";
            }
        }
    
        public static load(file: File): Promise<Workbook> {
            return new Promise<Workbook>((resolve, reject) => {
                ExcelUtility.readFileAsUint8Array(file).then((a) => {
                    Workbook.load(a, new WorkbookLoadOptions(), (w) => {
                        resolve(w);
                    }, (e) => {
                        reject(e);
                    });
                }, (e) => {
                    reject(e);
                });
            });
        }
    
        public static loadFromUrl(url: string): Promise<Workbook> {
            return new Promise<Workbook>((resolve, reject) => {
                const req = new XMLHttpRequest();
                req.open("GET", url, true);
                req.responseType = "arraybuffer";
                req.onload = (d) => {
                    const data = new Uint8Array(req.response);
                    Workbook.load(data, new WorkbookLoadOptions(), (w) => {
                        resolve(w);
                    }, (e) => {
                        reject(e);
                    });
                };
                req.send();
            });
        }
    
        public static save(workbook: Workbook, fileNameWithoutExtension: string): Promise<string> {
            return new Promise<string>((resolve, reject) => {
                const opt = new WorkbookSaveOptions();
                opt.type = "blob";
    
                workbook.save(opt, (d) => {
                    const fileExt = ExcelUtility.getExtension(workbook.currentFormat);
                    const fileName = fileNameWithoutExtension + fileExt;
                    saveAs(d as Blob, fileName);
                    resolve(fileName);
                }, (e) => {
                    reject(e);
                });
            });
        }
    
        private static readFileAsUint8Array(file: File): Promise<Uint8Array> {
            return new Promise<Uint8Array>((resolve, reject) => {
                const fr = new FileReader();
                fr.onerror = (e) => {
                    reject(fr.error);
                };
    
                if (fr.readAsBinaryString) {
                    fr.onload = (e) => {
                        const rs = (fr as any).resultString;
                        const str: string = rs != null ? rs : fr.result;
                        const result = new Uint8Array(str.length);
                        for (let i = 0; i < str.length; i++) {
                            result[i] = str.charCodeAt(i);
                        }
                        resolve(result);
                    };
                    fr.readAsBinaryString(file);
                } else {
                    fr.onload = (e) => {
                        resolve(new Uint8Array(fr.result as ArrayBuffer));
                    };
                    fr.readAsArrayBuffer(file);
                }
            });
        }
    }
    

    API Members