@corbe30/fortune-excel 1.0.3

package/dist/ToFortuneSheet/FortuneFile.d.ts

@@ -0,0 +1,50 @@
+import { IuploadfileList } from "../ICommon.js";
+import { FortuneFileBase } from "./FortuneBase.js";
+export declare class FortuneFile {
+    private files;
+    private sheetNameList;
+    private readXml;
+    private fileName;
+    private styles;
+    private sharedStrings;
+    private calcChain;
+    private imageList;
+    private sheets?;
+    private info?;
+    constructor(files: IuploadfileList, fileName: string);
+    /**
+     * @return All sheet name of workbook
+     */
+    private getSheetNameList;
+    /**
+     * @param sheetName WorkSheet'name
+     * @return sheet file name and path in zip
+     */
+    private getSheetFileBysheetId;
+    /**
+     * @return workBook information
+     */
+    getWorkBookInfo(): void;
+    /**
+     * @return All sheet , include whole information
+     */
+    getSheetsFull(isInitialCell?: boolean): void;
+    private columnWidthSet;
+    private rowHeightSet;
+    private extendArray;
+    private imagePositionCaculation;
+    /**
+     * @return drawing file string
+     */
+    private getDrawingFile;
+    private getDrawingRelsFile;
+    /**
+     * @return All sheet base information widthout cell and config
+     */
+    getSheetsWithoutCell(): void;
+    /**
+     * @return FortuneSheet file json
+     */
+    Parse(): void;
+    serialize(): FortuneFileBase;
+}

package/dist/ToFortuneSheet/FortuneFile.js

@@ -0,0 +1,432 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { FortuneSheet } from "./FortuneSheet.js";
+import { workBookFile, coreFile, appFile, stylesFile, sharedStringsFile, numFmtDefault, theme1File, calcChainFile, workbookRels, numFmtDefaultMap, } from "../common/constant.js";
+import { ReadXml } from "./ReadXml.js";
+import { getXmlAttibute } from "../common/method.js";
+import { FortuneFileBase, FortuneFileInfo, } from "./FortuneBase.js";
+import { ImageList } from "./FortuneImage.js";
+export class FortuneFile {
+    constructor(files, fileName) {
+        this.columnWidthSet = [];
+        this.rowHeightSet = [];
+        this.files = files;
+        this.fileName = fileName;
+        this.readXml = new ReadXml(files);
+        this.getSheetNameList();
+        this.sharedStrings = this.readXml.getElementsByTagName("sst/si", sharedStringsFile);
+        this.calcChain = this.readXml.getElementsByTagName("calcChain/c", calcChainFile);
+        this.styles = {};
+        this.styles["cellXfs"] = this.readXml.getElementsByTagName("cellXfs/xf", stylesFile);
+        this.styles["cellStyleXfs"] = this.readXml.getElementsByTagName("cellStyleXfs/xf", stylesFile);
+        this.styles["cellStyles"] = this.readXml.getElementsByTagName("cellStyles/cellStyle", stylesFile);
+        this.styles["fonts"] = this.readXml.getElementsByTagName("fonts/font", stylesFile);
+        this.styles["fills"] = this.readXml.getElementsByTagName("fills/fill", stylesFile);
+        this.styles["borders"] = this.readXml.getElementsByTagName("borders/border", stylesFile);
+        this.styles["clrScheme"] = this.readXml.getElementsByTagName("a:clrScheme/a:dk1|a:lt1|a:dk2|a:lt2|a:accent1|a:accent2|a:accent3|a:accent4|a:accent5|a:accent6|a:hlink|a:folHlink", theme1File);
+        this.styles["indexedColors"] = this.readXml.getElementsByTagName("colors/indexedColors/rgbColor", stylesFile);
+        this.styles["mruColors"] = this.readXml.getElementsByTagName("colors/mruColors/color", stylesFile);
+        this.imageList = new ImageList(files);
+        let numfmts = this.readXml.getElementsByTagName("numFmt/numFmt", stylesFile);
+        let numFmtDefaultC = JSON.parse(JSON.stringify(numFmtDefault));
+        for (let i = 0; i < numfmts.length; i++) {
+            let attrList = numfmts[i].attributeList;
+            let numfmtid = getXmlAttibute(attrList, "numFmtId", "49");
+            let formatcode = getXmlAttibute(attrList, "formatCode", "@");
+            // console.log(numfmtid, formatcode);
+            if (!(numfmtid in numFmtDefault)) {
+                numFmtDefaultC[numfmtid] = numFmtDefaultMap[formatcode] || formatcode;
+            }
+        }
+        // console.log(JSON.stringify(numFmtDefaultC), numfmts);
+        this.styles["numfmts"] = numFmtDefaultC;
+    }
+    /**
+     * @return All sheet name of workbook
+     */
+    getSheetNameList() {
+        let workbookRelList = this.readXml.getElementsByTagName("Relationships/Relationship", workbookRels);
+        if (workbookRelList == null) {
+            return;
+        }
+        let regex = new RegExp("worksheets/[^/]*?.xml");
+        let sheetNames = {};
+        for (let i = 0; i < workbookRelList.length; i++) {
+            let rel = workbookRelList[i], attrList = rel.attributeList;
+            let id = attrList["Id"], target = attrList["Target"];
+            if (regex.test(target)) {
+                if (target.indexOf("/xl") === 0) {
+                    sheetNames[id] = target.substr(1);
+                }
+                else {
+                    sheetNames[id] = "xl/" + target;
+                }
+            }
+        }
+        this.sheetNameList = sheetNames;
+    }
+    /**
+     * @param sheetName WorkSheet'name
+     * @return sheet file name and path in zip
+     */
+    getSheetFileBysheetId(sheetId) {
+        // for(let i=0;i<this.sheetNameList.length;i++){
+        //     let sheetFileName = this.sheetNameList[i];
+        //     if(sheetFileName.indexOf("sheet"+sheetId)>-1){
+        //         return sheetFileName;
+        //     }
+        // }
+        return this.sheetNameList[sheetId];
+    }
+    /**
+     * @return workBook information
+     */
+    getWorkBookInfo() {
+        let Company = this.readXml.getElementsByTagName("Company", appFile);
+        let AppVersion = this.readXml.getElementsByTagName("AppVersion", appFile);
+        let creator = this.readXml.getElementsByTagName("dc:creator", coreFile);
+        let lastModifiedBy = this.readXml.getElementsByTagName("cp:lastModifiedBy", coreFile);
+        let created = this.readXml.getElementsByTagName("dcterms:created", coreFile);
+        let modified = this.readXml.getElementsByTagName("dcterms:modified", coreFile);
+        this.info = new FortuneFileInfo();
+        this.info.name = this.fileName;
+        this.info.creator = creator.length > 0 ? creator[0].value : "";
+        this.info.lastmodifiedby =
+            lastModifiedBy.length > 0 ? lastModifiedBy[0].value : "";
+        this.info.createdTime = created.length > 0 ? created[0].value : "";
+        this.info.modifiedTime = modified.length > 0 ? modified[0].value : "";
+        this.info.company = Company.length > 0 ? Company[0].value : "";
+        this.info.appversion = AppVersion.length > 0 ? AppVersion[0].value : "";
+    }
+    /**
+     * @return All sheet , include whole information
+     */
+    getSheetsFull(isInitialCell = true) {
+        let sheets = this.readXml.getElementsByTagName("sheets/sheet", workBookFile);
+        let sheetList = {};
+        for (let key in sheets) {
+            let sheet = sheets[key];
+            sheetList[sheet.attributeList.name] = sheet.attributeList["sheetId"];
+        }
+        this.sheets = [];
+        let order = 0;
+        for (let key in sheets) {
+            let sheet = sheets[key];
+            let sheetName = sheet.attributeList.name;
+            let sheetId = sheet.attributeList["sheetId"];
+            let rid = sheet.attributeList["r:id"];
+            let sheetFile = this.getSheetFileBysheetId(rid);
+            let hide = sheet.attributeList.state === "hidden" ? 1 : 0;
+            let drawing = this.readXml.getElementsByTagName("worksheet/drawing", sheetFile), drawingFile, drawingRelsFile;
+            if (drawing != null && drawing.length > 0) {
+                let attrList = drawing[0].attributeList;
+                let rid = getXmlAttibute(attrList, "r:id", null);
+                if (rid != null) {
+                    drawingFile = this.getDrawingFile(rid, sheetFile);
+                    drawingRelsFile = this.getDrawingRelsFile(drawingFile);
+                }
+            }
+            if (sheetFile != null) {
+                let sheet = new FortuneSheet(sheetName, sheetId, order, isInitialCell, {
+                    sheetFile: sheetFile,
+                    readXml: this.readXml,
+                    sheetList: sheetList,
+                    styles: this.styles,
+                    sharedStrings: this.sharedStrings,
+                    calcChain: this.calcChain,
+                    imageList: this.imageList,
+                    drawingFile: drawingFile,
+                    drawingRelsFile: drawingRelsFile,
+                    hide: hide,
+                });
+                this.columnWidthSet = [];
+                this.rowHeightSet = [];
+                this.imagePositionCaculation(sheet);
+                this.sheets.push(sheet);
+                order++;
+            }
+        }
+    }
+    extendArray(index, sets, def, hidden, lens) {
+        if (index < sets.length) {
+            return;
+        }
+        let startIndex = sets.length, endIndex = index;
+        let allGap = 0;
+        if (startIndex > 0) {
+            allGap = sets[startIndex - 1];
+        }
+        // else{
+        //     sets.push(0);
+        // }
+        for (let i = startIndex; i <= endIndex; i++) {
+            let gap = def, istring = i.toString();
+            if (istring in hidden) {
+                gap = 0;
+            }
+            else if (istring in lens) {
+                gap = lens[istring];
+            }
+            allGap += Math.round(gap + 1);
+            sets.push(allGap);
+        }
+    }
+    imagePositionCaculation(sheet) {
+        let images = sheet.images, defaultColWidth = sheet.defaultColWidth, defaultRowHeight = sheet.defaultRowHeight;
+        let colhidden = {};
+        if (sheet.config.colhidden) {
+            colhidden = sheet.config.colhidden;
+        }
+        let columnlen = {};
+        if (sheet.config.columnlen) {
+            columnlen = sheet.config.columnlen;
+        }
+        let rowhidden = {};
+        if (sheet.config.rowhidden) {
+            rowhidden = sheet.config.rowhidden;
+        }
+        let rowlen = {};
+        if (sheet.config.rowlen) {
+            rowlen = sheet.config.rowlen;
+        }
+        for (let key in images) {
+            let imageObject = images[key]; //Image, fortuneImage
+            let fromCol = imageObject.fromCol;
+            let fromColOff = imageObject.fromColOff;
+            let fromRow = imageObject.fromRow;
+            let fromRowOff = imageObject.fromRowOff;
+            let toCol = imageObject.toCol;
+            let toColOff = imageObject.toColOff;
+            let toRow = imageObject.toRow;
+            let toRowOff = imageObject.toRowOff;
+            let x_n = 0, y_n = 0;
+            let cx_n = 0, cy_n = 0;
+            if (fromCol >= this.columnWidthSet.length) {
+                this.extendArray(fromCol, this.columnWidthSet, defaultColWidth, colhidden, columnlen);
+            }
+            if (fromCol == 0) {
+                x_n = 0;
+            }
+            else {
+                x_n = this.columnWidthSet[fromCol - 1];
+            }
+            x_n = x_n + fromColOff;
+            if (fromRow >= this.rowHeightSet.length) {
+                this.extendArray(fromRow, this.rowHeightSet, defaultRowHeight, rowhidden, rowlen);
+            }
+            if (fromRow == 0) {
+                y_n = 0;
+            }
+            else {
+                y_n = this.rowHeightSet[fromRow - 1];
+            }
+            y_n = y_n + fromRowOff;
+            if (toCol >= this.columnWidthSet.length) {
+                this.extendArray(toCol, this.columnWidthSet, defaultColWidth, colhidden, columnlen);
+            }
+            if (toCol == 0) {
+                cx_n = 0;
+            }
+            else {
+                cx_n = this.columnWidthSet[toCol - 1];
+            }
+            cx_n = cx_n + toColOff - x_n;
+            if (toRow >= this.rowHeightSet.length) {
+                this.extendArray(toRow, this.rowHeightSet, defaultRowHeight, rowhidden, rowlen);
+            }
+            if (toRow == 0) {
+                cy_n = 0;
+            }
+            else {
+                cy_n = this.rowHeightSet[toRow - 1];
+            }
+            cy_n = cy_n + toRowOff - y_n;
+            console.log(defaultColWidth, colhidden, columnlen);
+            console.log(fromCol, this.columnWidthSet[fromCol], fromColOff);
+            console.log(toCol, this.columnWidthSet[toCol], toColOff, JSON.stringify(this.columnWidthSet));
+            imageObject.originWidth = cx_n;
+            imageObject.originHeight = cy_n;
+            imageObject.crop.height = cy_n;
+            imageObject.crop.width = cx_n;
+            imageObject.default.height = cy_n;
+            imageObject.default.left = x_n;
+            imageObject.default.top = y_n;
+            imageObject.default.width = cx_n;
+        }
+        //console.log(this.columnWidthSet, this.rowHeightSet);
+    }
+    /**
+     * @return drawing file string
+     */
+    getDrawingFile(rid, sheetFile) {
+        let sheetRelsPath = "xl/worksheets/_rels/";
+        let sheetFileArr = sheetFile.split("/");
+        let sheetRelsName = sheetFileArr[sheetFileArr.length - 1];
+        let sheetRelsFile = sheetRelsPath + sheetRelsName + ".rels";
+        let drawing = this.readXml.getElementsByTagName("Relationships/Relationship", sheetRelsFile);
+        if (drawing.length > 0) {
+            for (let i = 0; i < drawing.length; i++) {
+                let relationship = drawing[i];
+                let attrList = relationship.attributeList;
+                let relationshipId = getXmlAttibute(attrList, "Id", null);
+                if (relationshipId == rid) {
+                    let target = getXmlAttibute(attrList, "Target", null);
+                    if (target != null) {
+                        return target.replace(/\.\.\//g, "");
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    getDrawingRelsFile(drawingFile) {
+        let drawingRelsPath = "xl/drawings/_rels/";
+        let drawingFileArr = drawingFile.split("/");
+        let drawingRelsName = drawingFileArr[drawingFileArr.length - 1];
+        let drawingRelsFile = drawingRelsPath + drawingRelsName + ".rels";
+        return drawingRelsFile;
+    }
+    /**
+     * @return All sheet base information widthout cell and config
+     */
+    getSheetsWithoutCell() {
+        this.getSheetsFull(false);
+    }
+    /**
+     * @return FortuneSheet file json
+     */
+    Parse() {
+        this.getWorkBookInfo();
+        this.getSheetsFull();
+    }
+    serialize() {
+        var _a;
+        const FortuneOutPutFile = new FortuneFileBase();
+        FortuneOutPutFile.info = this.info;
+        FortuneOutPutFile.sheets = [];
+        for (const sheet of this.sheets) {
+            const sheetout = {};
+            //let attrName = ["name","color","config","index","status","order","row","column","luckysheet_select_save","scrollLeft","scrollTop","zoomRatio","showGridLines","defaultColWidth","defaultRowHeight","celldata","chart","isPivotTable","pivotTable","luckysheet_conditionformat_save","freezen","calcChain"];
+            if (sheet.name != null) {
+                sheetout.name = sheet.name;
+            }
+            if (sheet.color != null) {
+                sheetout.color = sheet.color;
+            }
+            if (sheet.config != null) {
+                sheetout.config = sheet.config;
+                // if(sheetout.config._borderInfo!=null){
+                //     delete sheetout.config._borderInfo;
+                // }
+            }
+            if (sheet.id != null) {
+                sheetout.id = sheet.id;
+            }
+            if (sheet.status != null) {
+                sheetout.status = sheet.status;
+            }
+            if (sheet.order != null) {
+                sheetout.order = sheet.order;
+            }
+            if (sheet.row != null) {
+                sheetout.row = sheet.row;
+            }
+            if (sheet.column != null) {
+                sheetout.column = sheet.column;
+            }
+            if (sheet.luckysheet_select_save != null) {
+                sheetout.luckysheet_select_save = sheet.luckysheet_select_save;
+            }
+            if (sheet.scrollLeft != null) {
+                sheetout.scrollLeft = sheet.scrollLeft;
+            }
+            if (sheet.scrollTop != null) {
+                sheetout.scrollTop = sheet.scrollTop;
+            }
+            if (sheet.zoomRatio != null) {
+                sheetout.zoomRatio = sheet.zoomRatio;
+            }
+            if (sheet.showGridLines != null) {
+                sheetout.showGridLines = sheet.showGridLines;
+            }
+            if (sheet.defaultColWidth != null) {
+                sheetout.defaultColWidth = sheet.defaultColWidth;
+            }
+            if (sheet.defaultRowHeight != null) {
+                sheetout.defaultRowHeight = sheet.defaultRowHeight;
+            }
+            // https://github.com/ruilisi/fortune-sheet/issues/299
+            const merges = new Map();
+            if ((_a = sheet.config) === null || _a === void 0 ? void 0 : _a.merge) {
+                for (const { r, c, rs, cs } of Object.values(sheet.config.merge)) {
+                    merges.set(r + "_" + c, { r, c, rs, cs });
+                    for (let i = r + 1; i < r + rs; i++)
+                        for (let j = c + 1; j < c + cs; j++)
+                            merges.set(i + "_" + j, { r, c });
+                }
+            }
+            if (sheet.celldata != null) {
+                // Plain objects matter here
+                sheetout.celldata = [];
+                for (let { r, c, v } of sheet.celldata) {
+                    if (typeof v === "object") {
+                        const xv = __rest(v, []);
+                        v = xv;
+                        if (v.ct) {
+                            const ct = __rest(v.ct, []);
+                            v.ct = ct;
+                        }
+                        if (merges.has(r + "_" + c)) {
+                            v.mc = merges.get(r + "_" + c);
+                            if (v.mc.r !== r || v.mc.c !== c)
+                                v = { mc: v.mc };
+                        }
+                    }
+                    sheetout.celldata.push({ r, c, v });
+                }
+            }
+            if (sheet.chart != null) {
+                sheetout.chart = sheet.chart;
+            }
+            if (sheet.isPivotTable != null) {
+                sheetout.isPivotTable = sheet.isPivotTable;
+            }
+            if (sheet.pivotTable != null) {
+                sheetout.pivotTable = sheet.pivotTable;
+            }
+            if (sheet.luckysheet_conditionformat_save != null) {
+                sheetout.luckysheet_conditionformat_save =
+                    sheet.luckysheet_conditionformat_save;
+            }
+            if (sheet.freezen != null) {
+                sheetout.freezen = sheet.freezen;
+            }
+            if (sheet.calcChain != null) {
+                sheetout.calcChain = sheet.calcChain;
+            }
+            if (sheet.images != null) {
+                sheetout.images = sheet.images;
+            }
+            if (sheet.dataVerification != null) {
+                sheetout.dataVerification = sheet.dataVerification;
+            }
+            if (sheet.hyperlink != null) {
+                sheetout.hyperlink = sheet.hyperlink;
+            }
+            if (sheet.hide != null) {
+                sheetout.hide = sheet.hide;
+            }
+            FortuneOutPutFile.sheets.push(sheetout);
+        }
+        return FortuneOutPutFile;
+    }
+}

package/dist/ToFortuneSheet/FortuneImage.d.ts

@@ -0,0 +1,20 @@
+import { IuploadfileList } from "../ICommon.js";
+import { FortuneImageBase } from "./FortuneBase.js";
+export declare class ImageList {
+    private images;
+    constructor(files: IuploadfileList);
+    getImageByName(pathName: string): Image;
+}
+declare class Image extends FortuneImageBase {
+    fromCol: number;
+    fromColOff: number;
+    fromRow: number;
+    fromRowOff: number;
+    toCol: number;
+    toColOff: number;
+    toRow: number;
+    toRowOff: number;
+    constructor(pathName: string, base64: string);
+    setDefault(): void;
+}
+export {};

package/dist/ToFortuneSheet/FortuneImage.js

@@ -0,0 +1,51 @@
+import { FortuneImageBase } from "./FortuneBase.js";
+import { FromEMF, ToContext2D } from "../common/emf.js";
+export class ImageList {
+    constructor(files) {
+        if (files == null) {
+            return;
+        }
+        this.images = {};
+        for (let fileKey in files) {
+            // let reg = new RegExp("xl/media/image1.png", "g");
+            if (fileKey.indexOf("xl/media/") > -1) {
+                let fileNameArr = fileKey.split(".");
+                let suffix = fileNameArr[fileNameArr.length - 1].toLowerCase();
+                if (suffix in
+                    { png: 1, jpeg: 1, jpg: 1, gif: 1, bmp: 1, tif: 1, webp: 1, emf: 1 }) {
+                    if (suffix == "emf") {
+                        var pNum = 0; // number of the page, that you want to render
+                        var scale = 1; // the scale of the document
+                        var wrt = new ToContext2D(pNum, scale);
+                        var inp, out, stt;
+                        FromEMF.K = [];
+                        inp = FromEMF.C;
+                        out = FromEMF.K;
+                        stt = 4;
+                        for (var p in inp)
+                            out[inp[p]] = p.slice(stt);
+                        FromEMF.Parse(files[fileKey], wrt);
+                        this.images[fileKey] = wrt.canvas.toDataURL("image/png");
+                    }
+                    else {
+                        this.images[fileKey] = files[fileKey];
+                    }
+                }
+            }
+        }
+    }
+    getImageByName(pathName) {
+        if (pathName in this.images) {
+            let base64 = this.images[pathName];
+            return new Image(pathName, base64);
+        }
+        return null;
+    }
+}
+class Image extends FortuneImageBase {
+    constructor(pathName, base64) {
+        super();
+        this.src = base64;
+    }
+    setDefault() { }
+}

package/dist/ToFortuneSheet/FortuneSheet.d.ts

@@ -0,0 +1,36 @@
+import { FortuneSheetBase } from "./FortuneBase.js";
+export declare class FortuneSheet extends FortuneSheetBase {
+    private readXml;
+    private sheetFile;
+    private isInitialCell;
+    private styles;
+    private sharedStrings;
+    private mergeCells;
+    private calcChainEles;
+    private sheetList;
+    private imageList;
+    private formulaRefList;
+    constructor(sheetName: string, sheetId: string, sheetOrder: number, isInitialCell: boolean, allFileOption: any);
+    private getXdrValue;
+    private getBase64ByRid;
+    /**
+     * @desc This will convert cols/col to fortunesheet config of column'width
+     */
+    private generateConfigColumnLenAndHidden;
+    /**
+     * @desc This will convert cols/col to fortunesheet config of column'width
+     */
+    private generateConfigRowLenAndHiddenAddCell;
+    /**
+     * fortunesheet config of dataValidations
+     *
+     * @returns {IfortunesheetDataVerification} - dataValidations config
+     */
+    private generateConfigDataValidations;
+    /**
+     * fortunesheet config of hyperlink
+     *
+     * @returns {IfortunesheetHyperlink} - hyperlink config
+     */
+    private generateConfigHyperlinks;
+}