@corbe30/fortune-excel 1.0.3

package/dist/ToFortuneSheet/IFortune.d.ts

@@ -0,0 +1,301 @@
+export interface IFortuneFile {
+    info: IFortuneFileInfo;
+    sheets: IfortuneSheet[];
+}
+export interface IFortuneFileInfo {
+    name: string;
+    creator: string;
+    lastmodifiedby: string;
+    createdTime: string;
+    modifiedTime: string;
+    company: string;
+    appversion: string;
+}
+export interface IfortuneSheet {
+    name: string;
+    color: string;
+    config?: IfortuneSheetConfig;
+    id: string;
+    status: string;
+    order: string;
+    row: number;
+    column: number;
+    luckysheet_select_save?: IfortuneSheetSelection[];
+    scrollLeft: number;
+    scrollTop: number;
+    celldata?: IfortuneSheetCelldata[];
+    chart?: IfortuneSheetChart[];
+    isPivotTable: boolean;
+    pivotTable?: IfortuneSheetPivotTable;
+    luckysheet_conditionformat_save?: IfortunesheetConditionFormat[];
+    freezen?: IfortunesheetFrozen;
+    calcChain?: IfortunesheetCalcChain[];
+    zoomRatio: number;
+    showGridLines: string;
+    defaultColWidth: number;
+    defaultRowHeight: number;
+    images: IfortuneImages;
+    dataVerification: IfortunesheetDataVerification;
+    hyperlink: IfortunesheetHyperlink;
+    hide: number;
+}
+export interface IfortuneSheetSelection {
+    row: number[];
+    column: number[];
+    sheetIndex: number;
+}
+export interface IfortuneSheetChart {
+}
+export interface IfortuneSheetPivotTable {
+    pivot_select_save: IfortuneSheetSelection;
+    pivotDataSheetIndex: string | undefined;
+    column: IfortuneSheetPivotTableField[];
+    row: IfortuneSheetPivotTableField[];
+    filter: IfortuneSheetPivotTableField[];
+    filterparm: IfortuneSheetPivotTablefilterParam;
+    values: IfortuneSheetPivotTableField[];
+    showType: string;
+    pivotDatas: any[][];
+    drawPivotTable: boolean;
+    pivotTableBoundary: number[];
+}
+export interface IfortuneSheetPivotTableField {
+    index: number;
+    name: string;
+    fullname: string;
+    sumtype: string;
+    nameindex: number;
+}
+export interface IfortuneSheetPivotTablefilterParam {
+    [index: string]: IfortuneSheetPivotTablefilterParamItem;
+}
+export interface IfortuneSheetPivotTablefilterParamItem {
+    caljs: IfortuneSheetPivotTablefilterParamItemCaljs;
+    rowhidden: IfortuneSheetPivotTablefilterParamItemRowhidden;
+    selected: IfortuneSheetPivotTablefilterParamItemSelected;
+}
+export interface IfortuneSheetPivotTablefilterParamItemCaljs {
+    text: string;
+    type: string;
+    value: string;
+    value1: string;
+}
+export interface IfortuneSheetPivotTablefilterParamItemRowhidden {
+    [index: number]: number;
+}
+export interface IfortuneSheetPivotTablefilterParamItemSelected {
+    [index: number]: number;
+}
+export interface IfortunesheetFrozen {
+    horizen: number | undefined;
+    vertical: number | undefined;
+}
+export interface IfortunesheetConditionFormat {
+    type: string;
+    cellrange: IfortuneSheetSelection[];
+    format: string[] | IfortunesheetCFDefaultFormat | IfortunesheetCFIconsFormat;
+    conditionName: string | undefined;
+    conditionRange: IfortuneSheetSelection[];
+    conditionValue: any[];
+}
+export interface IfortunesheetCFDefaultFormat {
+    textColor: string | undefined | null;
+    cellColor: string | undefined | null;
+}
+export interface IfortunesheetCFIconsFormat {
+    len: string | number;
+    leftMin: string | number;
+    top: string | number;
+}
+export interface IfortunesheetCalcChain {
+    r: number;
+    c: number;
+    id: string | undefined;
+}
+export interface IfortuneSheetCelldata {
+    r: number;
+    c: number;
+    v: IfortuneSheetCelldataValue | {
+        mc: IfortuneSheetCelldataValueMerge;
+        ct?: IFortuneSheetCellFormat;
+    } | string | null;
+}
+export interface IfortuneSheetCelldataValue {
+    ct: IFortuneSheetCellFormat | undefined;
+    bg: string | undefined;
+    ff: string | undefined;
+    fc: string | undefined;
+    bl: number | undefined;
+    it: number | undefined;
+    fs: number | undefined;
+    cl: number | undefined;
+    un: number | undefined;
+    vt: number | undefined;
+    ht: number | undefined;
+    mc: IfortuneSheetCelldataValueMerge | undefined;
+    tr: number | undefined;
+    tb: number | undefined;
+    v: string | undefined;
+    m: string | undefined;
+    rt: number | undefined;
+    f: string | undefined;
+    qp: number | undefined;
+}
+export interface IFortuneSheetCellFormat {
+    fa: string;
+    t: string;
+}
+export interface IfortuneSheetCelldataValueMerge {
+    rs?: number;
+    cs?: number;
+    r: number;
+    c: number;
+}
+export interface IfortuneSheetConfig {
+    merge?: IfortuneSheetConfigMerges;
+    borderInfo: IfortuneSheetborderInfoCellForImp[];
+    rowlen?: IfortuneSheetRowAndColumnLen;
+    columnlen?: IfortuneSheetRowAndColumnLen;
+    rowhidden?: IfortuneSheetRowAndColumnHidden;
+    colhidden?: IfortuneSheetRowAndColumnHidden;
+    customHeight: IfortuneSheetRowAndColumnHidden;
+    customWidth: IfortuneSheetRowAndColumnHidden;
+}
+export interface IfortuneSheetConfigMerges {
+    [firstRange: string]: IfortuneSheetConfigMerge;
+}
+export interface IfortuneSheetConfigMerge {
+    r: number;
+    c: number;
+    rs: number;
+    cs: number;
+}
+export interface IfortuneSheetborderInfoCell {
+    rangeType: string;
+    value: IfortuneSheetborderInfoCellValue;
+}
+export interface IfortuneSheetborderInfoCellValue {
+    row_index: number;
+    col_index: number;
+    l: IfortuneSheetborderInfoCellValueStyle;
+    r: IfortuneSheetborderInfoCellValueStyle;
+    t: IfortuneSheetborderInfoCellValueStyle;
+    b: IfortuneSheetborderInfoCellValueStyle;
+}
+export interface IfortuneSheetborderInfoCellValueStyle {
+    style: number;
+    color: string;
+}
+export interface IfortuneSheetborderInfoRange {
+    rangeType: string;
+    borderType: string;
+    style: string;
+    color: string;
+    range: IfortuneSheetSelection[];
+}
+export interface IfortuneSheetborderInfoCellForImp {
+    rangeType: string;
+    cells?: string[];
+    value: IfortuneSheetborderInfoCellValue;
+}
+export interface IMapfortuneSheetborderInfoCellForImp {
+    [index: number]: IfortuneSheetborderInfoCellForImp;
+}
+export interface IfortuneSheetRowAndColumnLen {
+    [index: string]: number;
+}
+export interface IfortuneSheetRowAndColumnHidden {
+    [index: string]: number;
+}
+export interface IFormulaSI {
+    [index: string]: IFormulaCell;
+}
+export interface IFormulaCell {
+    [index: string]: IFormulaCellValue;
+}
+export interface IFormulaCellValue {
+    t: string;
+    ref: string;
+    si: string;
+    fv: string;
+    cellValue: IfortuneSheetCelldata;
+}
+export interface IFortuneInlineString {
+    ff: string | undefined;
+    fc: string | undefined;
+    fs: number | undefined;
+    cl: number | undefined;
+    un: number | undefined;
+    bl: number | undefined;
+    it: number | undefined;
+    va: number | undefined;
+    v: string | undefined;
+}
+export interface IfortuneImage {
+    border: IfortuneImageBorder;
+    crop: IfortuneImageCrop;
+    default: IfortuneImageDefault;
+    fixedLeft: number;
+    fixedTop: number;
+    isFixedPos: Boolean;
+    originHeight: number;
+    originWidth: number;
+    src: string;
+    type: string;
+}
+export interface IfortuneImageBorder {
+    color: string;
+    radius: number;
+    style: string;
+    width: number;
+}
+export interface IfortuneImageCrop {
+    height: number;
+    offsetLeft: number;
+    offsetTop: number;
+    width: number;
+}
+export interface IfortuneImageDefault {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export interface IfortuneImages {
+    [index: string]: IfortuneImage;
+}
+export interface IcellOtherInfo {
+    [index: string]: IformulaList;
+}
+export interface IformulaList {
+    [index: string]: IformulaListItem;
+}
+export interface IformulaListItem {
+    r: number;
+    c: number;
+}
+export interface IfortunesheetDataVerification {
+    [key: string]: IfortunesheetDataVerificationValue;
+}
+export interface IfortunesheetDataVerificationValue {
+    type: IfortunesheetDataVerificationType;
+    type2: string | null;
+    value1: string | number | null;
+    value2: string | number | null;
+    checked: boolean;
+    remote: boolean;
+    prohibitInput: boolean;
+    hintShow: boolean;
+    hintText: string;
+}
+export type IfortunesheetDataVerificationType = "dropdown" | "checkbox" | "number" | "number_integer" | "number_decimal" | "text_content" | "text_length" | "date" | "validity";
+export interface IfortunesheetHyperlink {
+    [key: string]: IfortunesheetHyperlinkValue;
+}
+export interface IfortunesheetHyperlinkValue {
+    linkAddress: string;
+    linkTooltip: string;
+    linkType: IfortunesheetHyperlinkType;
+    display: string;
+}
+export type IfortunesheetHyperlinkType = "internal" | "external";

package/dist/ToFortuneSheet/IFortune.js

@@ -0,0 +1 @@
+export {};

package/dist/ToFortuneSheet/ReadXml.d.ts

@@ -0,0 +1,61 @@
+import { IuploadfileList, IattributeList } from "../ICommon.js";
+declare class xmloperation {
+    /**
+     * @param tag Search xml tag name , div,title etc.
+     * @param file Xml string
+     * @return Xml element string
+     */
+    protected getElementsByOneTag(tag: string, file: string): string[];
+}
+export declare class ReadXml extends xmloperation {
+    originFile: IuploadfileList;
+    constructor(files: IuploadfileList);
+    /**
+     * @param path Search xml tag group , div,title etc.
+     * @param fileName One of uploadfileList, uploadfileList is file group, {key:value}
+     * @return Xml element calss
+     */
+    getElementsByTagName(path: string, fileName: string): Element[];
+    /**
+     * @param name One of uploadfileList's name, search for file by this parameter
+     * @retrun Select a file from uploadfileList
+     */
+    private getFileByName;
+}
+export declare class Element extends xmloperation {
+    elementString: string;
+    attributeList: IattributeList;
+    value: string;
+    container: string;
+    constructor(str: string);
+    /**
+     * @param name Get attribute by key in element
+     * @return Single attribute
+     */
+    get(name: string): string | number | boolean;
+    /**
+     * @param tag Get elements by tag in elementString
+     * @return Element group
+     */
+    getInnerElements(tag: string): Element[];
+    /**
+     * @desc get xml dom value and container, <container>value</container>
+     */
+    private setValue;
+    /**
+     * @desc get xml dom first tag, <a><b></b></a>, get a
+     */
+    private getFirstTag;
+}
+export interface IStyleCollections {
+    [index: string]: Element[] | IattributeList;
+}
+export declare function getColor(color: Element, styles: IStyleCollections, type?: string): string;
+/**
+ * @dom xml attribute object
+ * @attr attribute name
+ * @d if attribute is null, return default value
+ * @return attribute value
+ */
+export declare function getlineStringAttr(frpr: Element, attr: string): string;
+export {};

package/dist/ToFortuneSheet/ReadXml.js

@@ -0,0 +1,337 @@
+import { indexedColors } from "../common/constant.js";
+import { LightenDarkenColor } from "../common/method.js";
+class xmloperation {
+    /**
+     * @param tag Search xml tag name , div,title etc.
+     * @param file Xml string
+     * @return Xml element string
+     */
+    getElementsByOneTag(tag, file) {
+        //<a:[^/>: ]+?>.*?</a:[^/>: ]+?>
+        let readTagReg;
+        if (tag.indexOf("|") > -1) {
+            let tags = tag.split("|"), tagsRegTxt = "";
+            for (let i = 0; i < tags.length; i++) {
+                let t = tags[i];
+                tagsRegTxt +=
+                    "|<" +
+                        t +
+                        " [^>]+?[^/]>[\\s\\S]*?</" +
+                        t +
+                        ">|<" +
+                        t +
+                        " [^>]+?/>|<" +
+                        t +
+                        ">[\\s\\S]*?</" +
+                        t +
+                        ">|<" +
+                        t +
+                        "/>";
+            }
+            tagsRegTxt = tagsRegTxt.substr(1, tagsRegTxt.length);
+            readTagReg = new RegExp(tagsRegTxt, "g");
+        }
+        else {
+            readTagReg = new RegExp("<" +
+                tag +
+                " [^>]+?[^/]>[\\s\\S]*?</" +
+                tag +
+                ">|<" +
+                tag +
+                " [^>]+?/>|<" +
+                tag +
+                ">[\\s\\S]*?</" +
+                tag +
+                ">|<" +
+                tag +
+                "/>", "g");
+        }
+        let ret = file.match(readTagReg);
+        if (ret == null) {
+            return [];
+        }
+        else {
+            return ret;
+        }
+    }
+}
+export class ReadXml extends xmloperation {
+    constructor(files) {
+        super();
+        this.originFile = files;
+    }
+    /**
+     * @param path Search xml tag group , div,title etc.
+     * @param fileName One of uploadfileList, uploadfileList is file group, {key:value}
+     * @return Xml element calss
+     */
+    getElementsByTagName(path, fileName) {
+        let file = this.getFileByName(fileName);
+        let pathArr = path.split("/"), ret;
+        for (let key in pathArr) {
+            let path = pathArr[key];
+            if (ret == undefined) {
+                ret = this.getElementsByOneTag(path, file);
+            }
+            else {
+                if (ret instanceof Array) {
+                    let items = [];
+                    for (let key in ret) {
+                        let item = ret[key];
+                        items = items.concat(this.getElementsByOneTag(path, item));
+                    }
+                    ret = items;
+                }
+                else {
+                    ret = this.getElementsByOneTag(path, ret);
+                }
+            }
+        }
+        let elements = [];
+        for (let i = 0; i < ret.length; i++) {
+            let ele = new Element(ret[i]);
+            elements.push(ele);
+        }
+        return elements;
+    }
+    /**
+     * @param name One of uploadfileList's name, search for file by this parameter
+     * @retrun Select a file from uploadfileList
+     */
+    getFileByName(name) {
+        for (let fileKey in this.originFile) {
+            if (fileKey.indexOf(name) > -1) {
+                return this.originFile[fileKey];
+            }
+        }
+        return "";
+    }
+}
+export class Element extends xmloperation {
+    constructor(str) {
+        super();
+        this.elementString = str;
+        this.setValue();
+        const readAttrReg = new RegExp('[a-zA-Z0-9_:]*?=".*?"', "g");
+        let attrList = this.container.match(readAttrReg);
+        this.attributeList = {};
+        if (attrList != null) {
+            for (let key in attrList) {
+                let attrFull = attrList[key];
+                // let al= attrFull.split("=");
+                if (attrFull.length == 0) {
+                    continue;
+                }
+                let attrKey = attrFull.substr(0, attrFull.indexOf("="));
+                let attrValue = attrFull.substr(attrFull.indexOf("=") + 1);
+                if (attrKey == null ||
+                    attrValue == null ||
+                    attrKey.length == 0 ||
+                    attrValue.length == 0) {
+                    continue;
+                }
+                this.attributeList[attrKey] = attrValue.substr(1, attrValue.length - 2);
+            }
+        }
+    }
+    /**
+     * @param name Get attribute by key in element
+     * @return Single attribute
+     */
+    get(name) {
+        return this.attributeList[name];
+    }
+    /**
+     * @param tag Get elements by tag in elementString
+     * @return Element group
+     */
+    getInnerElements(tag) {
+        let ret = this.getElementsByOneTag(tag, this.elementString);
+        let elements = [];
+        for (let i = 0; i < ret.length; i++) {
+            let ele = new Element(ret[i]);
+            elements.push(ele);
+        }
+        if (elements.length == 0) {
+            return null;
+        }
+        return elements;
+    }
+    /**
+     * @desc get xml dom value and container, <container>value</container>
+     */
+    setValue() {
+        let str = this.elementString;
+        if (str.substr(str.length - 2, 2) == "/>") {
+            this.value = "";
+            this.container = str;
+        }
+        else {
+            let firstTag = this.getFirstTag();
+            const firstTagReg = new RegExp("(<" +
+                firstTag +
+                " [^>]+?[^/]>)([\\s\\S]*?)</" +
+                firstTag +
+                ">|(<" +
+                firstTag +
+                ">)([\\s\\S]*?)</" +
+                firstTag +
+                ">", "g");
+            let result = firstTagReg.exec(str);
+            if (result != null) {
+                if (result[1] != null) {
+                    this.container = result[1];
+                    this.value = result[2];
+                }
+                else {
+                    this.container = result[3];
+                    this.value = result[4];
+                }
+            }
+        }
+    }
+    /**
+     * @desc get xml dom first tag, <a><b></b></a>, get a
+     */
+    getFirstTag() {
+        let str = this.elementString;
+        let firstTag = str.substr(0, str.indexOf(" "));
+        if (firstTag == "" || firstTag.indexOf(">") > -1) {
+            firstTag = str.substr(0, str.indexOf(">"));
+        }
+        firstTag = firstTag.substr(1, firstTag.length);
+        return firstTag;
+    }
+}
+function combineIndexedColor(indexedColorsInner, indexedColors) {
+    let ret = {};
+    if (indexedColorsInner == null || indexedColorsInner.length == 0) {
+        return indexedColors;
+    }
+    for (let key in indexedColors) {
+        let value = indexedColors[key], kn = parseInt(key);
+        let inner = indexedColorsInner[kn];
+        if (inner == null) {
+            ret[key] = value;
+        }
+        else {
+            let rgb = inner.attributeList.rgb;
+            ret[key] = rgb;
+        }
+    }
+    return ret;
+}
+//clrScheme:Element[]
+export function getColor(color, styles, type = "g") {
+    let attrList = color.attributeList;
+    let clrScheme = styles["clrScheme"];
+    let indexedColorsInner = styles["indexedColors"];
+    let mruColorsInner = styles["mruColors"];
+    let indexedColorsList = combineIndexedColor(indexedColorsInner, indexedColors);
+    let indexed = attrList.indexed, rgb = attrList.rgb, theme = attrList.theme, tint = attrList.tint;
+    let bg;
+    if (indexed != null) {
+        let indexedNum = parseInt(indexed);
+        bg = indexedColorsList[indexedNum];
+        if (bg != null) {
+            bg = bg.substring(bg.length - 6, bg.length);
+            bg = "#" + bg;
+        }
+    }
+    else if (rgb != null) {
+        rgb = rgb.substring(rgb.length - 6, rgb.length);
+        bg = "#" + rgb;
+    }
+    else if (theme != null) {
+        let themeNum = parseInt(theme);
+        if (themeNum == 0) {
+            themeNum = 1;
+        }
+        else if (themeNum == 1) {
+            themeNum = 0;
+        }
+        else if (themeNum == 2) {
+            themeNum = 3;
+        }
+        else if (themeNum == 3) {
+            themeNum = 2;
+        }
+        let clrSchemeElement = clrScheme[themeNum];
+        if (clrSchemeElement != null) {
+            let clrs = clrSchemeElement.getInnerElements("a:sysClr|a:srgbClr");
+            if (clrs != null) {
+                let clr = clrs[0];
+                let clrAttrList = clr.attributeList;
+                // console.log(clr.container, );
+                if (clr.container.indexOf("sysClr") > -1) {
+                    // if(type=="g" && clrAttrList.val=="windowText"){
+                    //     bg = null;
+                    // }
+                    // else if((type=="t" || type=="b") && clrAttrList.val=="window"){
+                    //     bg = null;
+                    // }
+                    // else
+                    if (clrAttrList.lastClr != null) {
+                        bg = "#" + clrAttrList.lastClr;
+                    }
+                    else if (clrAttrList.val != null) {
+                        bg = "#" + clrAttrList.val;
+                    }
+                }
+                else if (clr.container.indexOf("srgbClr") > -1) {
+                    // console.log(clrAttrList.val);
+                    bg = "#" + clrAttrList.val;
+                }
+            }
+        }
+    }
+    if (tint != null) {
+        let tintNum = parseFloat(tint);
+        if (bg != null) {
+            bg = LightenDarkenColor(bg, tintNum);
+        }
+    }
+    return bg;
+}
+/**
+ * @dom xml attribute object
+ * @attr attribute name
+ * @d if attribute is null, return default value
+ * @return attribute value
+ */
+export function getlineStringAttr(frpr, attr) {
+    let attrEle = frpr.getInnerElements(attr), value;
+    if (attrEle != null && attrEle.length > 0) {
+        if (attr == "b" || attr == "i" || attr == "strike") {
+            value = "1";
+        }
+        else if (attr == "u") {
+            let v = attrEle[0].attributeList.val;
+            if (v == "double") {
+                value = "2";
+            }
+            else if (v == "singleAccounting") {
+                value = "3";
+            }
+            else if (v == "doubleAccounting") {
+                value = "4";
+            }
+            else {
+                value = "1";
+            }
+        }
+        else if (attr == "vertAlign") {
+            let v = attrEle[0].attributeList.val;
+            if (v == "subscript") {
+                value = "1";
+            }
+            else if (v == "superscript") {
+                value = "2";
+            }
+        }
+        else {
+            value = attrEle[0].attributeList.val;
+        }
+    }
+    return value;
+}