SCCommon/report/dist/index.cjs.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var fs = require('fs');
var uuid = require('uuid');

const VAL_DEF = {
    NODE_CROSS_INFO: '交叉表_信息',
    NODE_CROSS_ROW: '交叉行',
    NODE_CROSS_COL: '交叉列',
    NODE_CROSS_CONTENT: '交叉数据',
    NODE_CROSS_ROW_SUM: '交叉行合计',
    NODE_CROSS_COL_SUM: '交叉列合计',
    NODE_CROSS_ROW_EXT: '交叉行拓展',
    NODE_CROSS_ROW_SUM_EXT: '交叉行拓展合计',
    NODE_CROSS_ROW_AD_HOC: '交叉行AD_HOC',
    NODE_FIELD_MAP: '指标_数据_映射',
    NODE_DISCRETE_FIELDS: '离散指标_集合',
    NODE_NO_MAPPING_FIELDS: '无映射离散指标_集合',
    NODE_DISCRETE_PARAMS: '离散参数_集合',
    NODE_MASTER_FIELDS: '主数据指标_集合',
    NODE_MASTER_FIELDS_EX: '主数据指标_拓展集合',
    NODE_DETAIL_FIELDS: '从数据指标_集合',
    NODE_DETAIL_FIELDS_EX: '从数据指标_拓展集合',
    NODE_BAND_COLLECTION: '布局框_集合',
    NODE_FORMULAS: '计算式_集合',
    NODE_EVENTS: '事件_集合',
    NODE_DISCRETE_INFO: '离散信息',
    NODE_BILL_INFO: '账单式表_信息',
    NODE_BILL_CONTENT: '账单式表_数据',
    NODE_FLOW_INFO: '流水式表_信息',
    NODE_FLOW_INFO_EX: '流水式表_拓展信息',
    NODE_FLOW_GROUP: '流水式表_分组信息',
    NODE_FLOW_SEG_SUM: '流水式表_段统计信息',
    NODE_FLOW_PAGE_SUM: '流水式表_页统计信息',
    NODE_FLOW_COLUMN: '流水式表_列',
    NODE_FLOW_CONTENT: '流水式表_数据',
    PROP_MULTI_COLUMN: '多列显示数量',
    PROP_FLOW_EX_DISPLAY_MODE: '流水拓展显示模式',
    DISPLAY_MODE_INDEPENDENT: '单独模式',
    DISPLAY_MODE_FOLLOW: '紧随模式',
    NODE_MAIN_INFO: '主信息',
    NODE_MAIN_INFO_RPT_NAME: '报表名称',
    NODE_PAGE_INFO: '打印页面_信息',
    NODE_PAGE_SIZE: '纸张宽高',
    NODE_MARGINS: '页边距',
    NODE_RPT_BIZ_TYPE: '报表业务类型',
    NODE_BIZ_TYPE_AUDI: '审核类型',
    NODE_BIZ_TYPE_SUM: '汇总类型',
    NODE_BIZ_TYPE_DETAIL: '明细类型',
    NODE_MAP_DATA_HANDLE_INFO: '映射数据预处理',
    PROP_DATA_KEY: '映射数据对象',
    PROP_PARENT_DATA_KEY: '父映射数据对象',
    PROP_PARENT_CHILD_SORT_KEY: '父子排序键',
    PROP_PARENT_SORT_KEYS: '父排序键值集',
    PROP_CHILD_SORT_KEYS: '子排序键值集',
    PROP_OTHER_SUB_SORT: '其他子排序',
    PROP_OTHER_SUB_FILTER: '其他子过滤',
    PROP_HANDLE_TYPE: '预处理类型',
    PROP_FILTER_KEYS: '过滤键值集',
    PROP_FILTER_TOP_BILLS_NODES: '清单顶节点集',
    PROP_FILTER_OTHER_BILLS_NODES: '其他清单节点集',
    PROP_FILTER_COMPARE_OBJ: 'compareObjKey',
    PROP_FILTER_COMPARE_OBJ_KEY: 'compareObjIdKey',
    PROP_FILTER_COMPARE_VAL: 'compareValue',
    PROP_FILTER_CONDITION: '判断条件',
    PROP_HANDLE_TYPE_FILTER: '过滤',
    PROP_HANDLE_TYPE_SUM: '合计',
    PROP_HANDLE_TYPE_SORT: '排序',
    PROP_HANDLE_TYPE_ADD_DUMMY: '增加Dummy数据',
    PROP_HANDLE_TYPE_ADJUST: '数据调整',
    PROP_HANDLE_TYPE_BILLS_DATA_MOVE: '量材数据转移',
    PROP_HANDLE_TYPE_COMPONENT_MOVE: '组成物数据转移',
    PROP_HANDLE_TYPE_COMPONENT_REPLACEMENT: '组成物替换',
    PROP_HANDLE_TYPE_PRECISION: '合计精度',
    PROP_ADJUST_COLLECTION: '数据调整集',
    PROP_ADJUST_ACTION: 'action',
    PROP_ADJUST_ACTION_VAL: 'actionValue',
    PROP_DUMMY_COLLECTION: 'Dummy数据集',
    PROP_DUMMY_VAL: 'Dummy数据对象值',
    PROP_FREQUENCY: '频率',
    PROP_GRP_KEYS: 'GrpKeyIds',
    PROP_SORT_TYPE: '排序方式',
    PROP_SORT_TYPE_SELF_DEFINE_LOGIC: '自定义逻辑',
    PROP_SORT_KEYS: '排序键值集',
    PROP_SUM_GROUP_KEYS: '分组键值集',
    PROP_SUM_SUM_KEYS: '统计键值集',
    PROP_SUM_CALC_AHEAD: '统计前计算',
    PROP_SUM_CACL_TYPE: '计算类型',
    PROP_FIELD_EXP_MAP: 'mapExpression',
    PROP_PRECISION: 'Precision',
    PROP_FIXED_PRECISION_AMT: 'fixedPrecisionNum',
    PROP_FIELD_EXP_FIXED_MAP: 'fixedMapExpression',
    PROP_FIELD_EXP_FLEXIBLE_MAP: 'flexibleMapExpression',
    PROP_FLEXIBLE_REF_FILED_ID: 'flexibleRefFieldID',
    NODE_FONT_COLLECTION: 'font_collection',
    NODE_STYLE_COLLECTION: 'style_collection',
    NODE_CONTROL_COLLECTION: 'control_collection',
    PROP_ID: 'ID',
    PROP_AD_HOC_DATA: 'data_field',
    PROP_CMN_HEIGHT: 'CommonHeight',
    PROP_CMN_WIDTH: 'CommonWidth',
    PROP_BAND_NAME: 'BandName',
    PROP_BAND_NORMAL_ONLY: 'normalOnly',
    PROP_BAND_EX_ONLY: 'exOnly',
    PROP_BAND_EX_JOIN_AFTER: 'isJoinAfter',
    PROP_UNITS: '单位',
    PROP_PAGE_SIZE: '页规格',
    PROP_ORIENTATION: '方向',
    PROP_LEFT: 'Left',
    PROP_RIGHT: 'Right',
    PROP_TOP: 'Top',
    PROP_BOTTOM: 'Bottom',
    PROP_DATA_TYPE: 'DataType',
    PROP_NAME: 'Name',
    PROP_DFT_VALUE: 'Default_Value',
    PROP_EXPRESSION: 'expression',
    PROP_RUN_TYPE: 'run_type',
    PROP_BORDER_STYLE: 'border_style',
    PROP_POSITION: 'Position',
    PROP_HIDDEN: 'Hidden',
    PROP_IS_SERIAL: 'isSerial',
    PROP_IS_MERGE: 'isMerge',
    PROP_COMBINE_TYPE: 'combineType',
    PROP_IS_AUTO_HEIGHT: 'isAutoHeight',
    PROP_FONT: 'font',
    PROP_CONTROL: 'control',
    PROP_STYLE: 'style',
    PROP_VALUE: 'Value',
    PROP_LABEL: 'Label',
    PROP_AREA: 'area',
    PROP_DISCRETE_FIELDS: 'discrete_field_s',
    PROP_FLOW_FIELDS: 'flow_field_s',
    PROP_BILL_FIELDS: 'bill_field_s',
    PROP_CROSS_FIELDS: 'cross_field_s',
    PROP_CROSS_DISPLAY_ORDER: 'cross_display_order',
    PROP_GROUP_FIELDS: 'group_field_s',
    PROP_GROUP_LINES: 'group_lines',
    PROP_GROUP_SUM_KEYS: 'SumKey_S',
    PROP_SUM_KEY: 'SumKey',
    PROP_SUM_FIELDS: 'sum_field_s',
    PROP_TEXTS: 'text_s',
    PROP_TEXT: 'text',
    PROP_PARAMS: 'param_s',
    PROP_FIELD_ID: 'FieldID',
    PROP_PARAM_ID: 'ParamID',
    PROP_PREFIX: 'Prefix',
    PROP_SUFFIX: 'Suffix',
    PROP_FORMAT: 'Format',
    PROP_SHOW_ZERO: 'ShowZero',
    PROP_EXTENSION_TYPE: 'ExtType',
    PROP_CALCULATION: 'CalculationType',
    PROP_H_CALCULATION: 'H_CalculationType',
    PROP_V_CALCULATION: 'V_CalculationType',
    PROP_FIT_AREA: 'isFitArea',
    IDX_LEFT: 0,
    IDX_TOP: 1,
    IDX_RIGHT: 2,
    IDX_BOTTOM: 3,
    BAND_PROP_NAME: 'Name',
    BAND_PROP_MERGE_BAND: 'MergeBand',
    BAND_PROP_STYLE: 'style',
    BAND_PROP_CONTROL: 'control',
    BAND_PROP_HEIGHT: 'Height',
    BAND_PROP_WIDTH: 'Width',
    BAND_PROP_DISPLAY_TYPE: 'DisplayType',
    BAND_PROP_ALIGNMENT: 'Alignment',
    BAND_PROP_MERGE_BORDER: 'MergeBorder',
    BAND_PROP_SUB_BANDS: 'band_s',
    MEASUREMENT: {
        PIXEL: ['像素点', '象素点', 'PIXEL'],
        CM: ['厘米', 'CM'],
        INCH: ['英寸', 'INCH'],
    },
    PROP_IS_ID: 'isID',
    PROP_ID_SEQ: 'IDSeq',
    TAB_FIELD_PROP_SORT: 'Sort',
    TAB_FIELD_PROP_SORT_VAL_NOSORT: 'no_sort',
    TAB_FIELD_PROP_SORT_VAL_ASC: 'ascend',
    TAB_FIELD_PROP_SORT_VAL_DESC: 'descend',
    DATA_DISCRETE_DATA: 'discrete_data',
    DATA_MASTER_DATA: 'master_data',
    DATA_DETAIL_DATA: 'detail_data',
    DATA_MASTER_DATA_EX: 'master_data_ex',
    DATA_DETAIL_DATA_EX: 'detail_data_ex',
    BLANK_FIELD_INDEX: -10,
    BLANK_VALUE_INDEX: -100,
    BLANK_PAGE_VALUE_INDEX: -200,
    PROP_SEG_GRP_IDX: 'segGrpRecStartIdx',
    PROP_PRE_ADD_GRP_REC_INFO: 'preAddPageGrpInfo',
    PROP_INSERTED_GRP_REC: 'insertedGrpRecAmt',
    PROP_GRP_LINES: 'group_lines_amt',
    RUN_TYPE_BEFORE_ANALYZING: 'before_analyzing',
    RUN_TYPE_BEFORE_PAGING: 'before_paging',
    RUN_TYPE_BEFORE_OUTPUT: 'before_output',
    RUN_TYPE_BEFORE_COMBINE: 'before_combine',
    RUN_TYPE_AFTER_COMBINE: 'after_combine',
    RUN_TYPE_BEFORE_GROUP_TEXT_OUT: 'before_group_text_output',
    PAGE_STATUS: [
        'EveryPage',
        'FirstPage',
        'LastPage',
        'SegmentStart',
        'SegmentEnd',
        'Group',
        'CrossRowEnd',
        'CrossColEnd',
    ],
    CONTROL_PROPS: [
        'Shrink',
        'ShowZero',
        'Horizon',
        'Vertical',
        'Wrap',
        'VerticalForExcel',
        'ShrinkFirst',
        'CloseOutput',
    ],
    CONTROL_PROP_IDX_SHRINK: 0,
    CONTROL_PROP_IDX_SHOW_ZERO: 1,
    CONTROL_PROP_IDX_HORIZON: 2,
    CONTROL_PROP_IDX_VERTICAL: 3,
    CONTROL_PROP_IDX_WRAP: 4,
    CONTROL_PROP_IDX_VERTICAL_EXCEL: 5,
    CONTROL_PROP_IDX_SHRINK_FIRST: 6,
    CONTROL_PROP_IDX_CLOSE_OUTPUT: 7,
    BORDER_STYLE_PROPS: ['LineWeight', 'DashStyle', 'Color'],
    PROP_LINE_WEIGHT: 'LineWeight',
    PROP_DASH_STYLE: 'DashStyle',
    PROP_COLOR: 'Color',
    FONT_PROPS: [
        'Name',
        'FontHeight',
        'FontColor',
        'FontBold',
        'FontItalic',
        'FontUnderline',
        'FontStrikeOut',
        'FontAngle',
    ],
    FONT_PROP_IDX_NAME: 0,
    FONT_PROP_IDX_HEIGHT: 1,
    FONT_PROP_IDX_COLOR: 2,
    FONT_PROP_IDX_BOLD: 3,
    FONT_PROP_IDX_ITALIC: 4,
    FONT_PROP_IDX_UNDERLINE: 5,
    FONT_PROP_IDX_STRIKEOUT: 6,
    FONT_PROP_IDX_ANGLE: 7,
    STATUS_NORMAL: 0,
    STATUS_REPORT_START: 1,
    STATUS_REPORT_END: 2,
    STATUS_SEGMENT_START: 3,
    STATUS_SEGMENT_END: 4,
    STATUS_GROUP: 5,
    STATUS_CROSS_ROW_END: 6,
    STATUS_CROSS_COL_END: 7,
    LAYOUT: ['Top', 'Bottom', 'Left', 'Right', 'Fulfill'],
    LAYOUT_TOP: 0,
    LAYOUT_BOTTOM: 1,
    LAYOUT_LEFT: 2,
    LAYOUT_RIGHT: 3,
    LAYOUT_FULFILL: 4,
    OUTPUT_ALIGN: {
        H: ['left', 'center', 'right'],
        V: ['top', 'center', 'bottom'],
    },
    H_ALIGN_IDX_LEFT: 0,
    H_ALIGN_IDX_CENTER: 1,
    H_ALIGN_IDX_RIGHT: 2,
    V_ALIGN_IDX_TOP: 0,
    V_ALIGN_IDX_CENTER: 1,
    V_ALIGN_IDX_BOTTOM: 2,
    CAL_TYPE: ['percentage', 'abstract'],
    CAL_TYPE_PERCENTAGE: 0,
    CAL_TYPE_ABSTRACT: 1,
    EVENT_TYPE: ['GRP_ON_CREATE', 'FLOW_CONTENT_ON_CREATE'],
    EVENT_IDX_GRP_ON_CREATE: 0,
    EVENT_IDX_FLOW_CONTENT_ON_CREATE: 1,
    PAGE_ORIENTATION_V_FIRST: 0,
    PAGE_ORIENTATION_H_FIRST: 1,
    ORIENTATION_PORTRAIT: 'PORTRAIT',
    ORIENTATION_LANDSCAPE: 'LANDSCAPE',
    ORIENTATION_PORTRAIT_CHN: '纵向',
    ORIENTATION_LANDSCAPE_CHN: '横向',
    SIZE_A3: [11.69, 16.54],
    SIZE_A4: [8.27, 11.69],
    SIZE_A5: [5.83, 8.27],
    SIZE_B5: [6.93, 9.84],
    SIZE_LETTER: [8.5, 11.0],
    SIZE_LEGAL: [8.5, 14.0],
    SIZE_16K: [7.75, 10.75],
    SIZE_EXECUTIVE: [7.25, 10.5],
    OUTPUT_OFFSET: [2, 2, 1, 3],
    OFFSET_IDX_LEFT: 0,
    OFFSET_IDX_RIGHT: 1,
    OFFSET_IDX_TOP: 2,
    OFFSET_IDX_BOTTOM: 3,
    PROP_PAGE_SEQ: 'page_seq',
    PROP_PAGE_MERGE_BORDER: 'page_merge_border',
    PROP_CELLS: 'cells',
    PAGING_OPTION_NORMAL: 'normal',
    PAGING_OPTION_INFINITY: 'infinity',
    OUTPUT_TYPE_NORMAL: 'normal',
    OUTPUT_TYPE_SVG: 'svg',
    OUTPUT_TYPE_PDF: 'pdf',
    OUTPUT_TYPE_EXCEL: 'excel',
    DISPLAY_VAL_TYPE_NORMAL: 0,
    DISPLAY_VAL_TYPE_GROUP: 1,
    DISPLAY_VAL_TYPE_AUTO_HEIGHT: 2,
    TYPE_FOLLOW_MODE: 1,
    PAGE_SELF_DEFINE: '自定义',
    PAGE_SPECIAL_MERGE_POS: 'page_merge_pos',
    PAGES_SIZE_STR: [
        'A3',
        'A4',
        'A5',
        'B5',
        'LETTER',
        'LEGAL',
        'EXECUTIVE',
        '16K',
    ],
    PAGES_SIZE_IDX: [8, 9, 11, 13, 1, 5, 7, 93],
    PAGES_SIZE: [
        [11.69, 16.54],
        [8.27, 11.69],
        [5.83, 8.27],
        [6.93, 9.84],
        [8.5, 11.0],
        [8.5, 14.0],
        [7.25, 10.5],
        [7.25, 10.5],
    ],
    HUNDRED_PERCENT: 100.0,
    VERTICAL_ANGLE: '90',
    ANTI_VERTICAL_ANGLE: '-90',
    VERTICAL_ANGLE_INT: 90,
    ANTI_VERTICAL_ANGLE_INT: -90,
    LAST_DEF: '',
};

const RESOLUTION = [96, 96];
const JpcCommonHelper = {
    getResultByID(KeyID, collectionList) {
        let rst = null;
        if (KeyID) {
            for (let i = 0; i < collectionList.length; i++) {
                let collection = collectionList[i];
                if (collection && collection instanceof Array) {
                    for (let j = 0; j < collection.length; j++) {
                        if (collection[j].ID === KeyID) {
                            rst = collection[j];
                            break;
                        }
                    }
                    if (rst)
                        break;
                }
            }
        }
        return rst;
    },
    //by lish ,多余参数，
    // getFont(fontName: string, dftFonts: any[], rptTpl: IRptTpl) {
    getFont(fontName, dftFonts) {
        let me = this, list = [];
        // if (rptTpl) list.push(rptTpl.control_collection); //by lish ,多余参数，
        list.push(dftFonts);
        return me.getResultByID(fontName, list);
    },
    //by lish ,多余参数，
    // getStyle(styleName: string, dftStyles: IStyles[], rptTpl?: IRptTpl) {
    getStyle(styleName, dftStyles) {
        let me = this, list = [];
        // if (rptTpl) list.push(rptTpl.control_collection);   //by lish ,多余参数，
        list.push(dftStyles);
        return me.getResultByID(styleName, list);
    },
    getControl(controlName, dftControls, rptTpl) {
        let me = this, list = [];
        if (rptTpl)
            list.push(rptTpl.control_collection);
        list.push(dftControls);
        return me.getResultByID(controlName, list);
    },
    getLayoutAlignment(alignStr) {
        let rst = VAL_DEF.LAYOUT.indexOf(alignStr);
        if (rst < 0)
            rst = VAL_DEF.LAYOUT_FULFILL;
        return rst;
    },
    getPosCalculationType(typeStr) {
        let rst = VAL_DEF.CAL_TYPE.indexOf(typeStr);
        if (rst < 0)
            rst = VAL_DEF.CAL_TYPE_ABSTRACT;
        return rst;
    },
    getBoolean(bStr) {
        let rst = false;
        if (bStr !== null && bStr !== undefined) {
            let valType = typeof (bStr);
            if (valType === 'boolean') {
                rst = bStr;
            }
            else if (valType === 'string') {
                let tS = bStr.toUpperCase();
                rst = (tS === 'T' || tS === 'TRUE' || tS === 'YES' || tS === 'Y');
            }
            else if (valType === 'number') {
                rst = (bStr === 1);
            }
        }
        return rst;
    },
    getScreenDPI() {
        return RESOLUTION.slice(0);
    },
    getUnitFactor(rptTpl) {
        let me = this;
        return me.translateUnit(rptTpl.主信息.单位);
    },
    translateUnit(unitStr) {
        let me = this, rst = 1.0;
        if (unitStr) {
            let sdpi = me.getScreenDPI();
            if (VAL_DEF.MEASUREMENT.PIXEL.indexOf(unitStr) >= 0) {
                rst = 1.0;
            }
            else if (VAL_DEF.MEASUREMENT.CM.indexOf(unitStr) >= 0) {
                rst = 1.0 * sdpi[0] / 2.54;
            }
            else if (VAL_DEF.MEASUREMENT.INCH.indexOf(unitStr) >= 0) {
                rst = 1.0 * sdpi[0];
            }
        }
        return rst;
    },
    getPageSize(rptTpl) {
        let size = VAL_DEF.SIZE_A4.slice(0);
        let sizeStr = rptTpl.主信息.打印页面_信息.页规格;
        let sizeIdx = VAL_DEF.PAGES_SIZE_STR.indexOf(sizeStr);
        if (sizeIdx >= 0) {
            size = VAL_DEF.PAGES_SIZE[sizeIdx].slice(0);
        }
        let page_orientation = rptTpl.主信息.打印页面_信息.方向;
        if (page_orientation === VAL_DEF.ORIENTATION_LANDSCAPE || page_orientation === VAL_DEF.ORIENTATION_LANDSCAPE_CHN) {
            //swap x,y
            let tmp = size[0];
            size[0] = size[1];
            size[1] = tmp;
        }
        return size;
    },
    getReportArea(rptTpl, unitFactor) {
        let me = this, sdpi = me.getScreenDPI(), rst = [], size = me.getPageSize(rptTpl);
        size[0] = sdpi[0] * size[0];
        size[1] = sdpi[0] * size[1];
        rst.push(unitFactor * rptTpl.主信息.页边距.Left);
        rst.push(unitFactor * rptTpl.主信息.页边距.Top);
        rst.push(size[0] - unitFactor * rptTpl.主信息.页边距.Right);
        rst.push(size[1] - unitFactor * rptTpl.主信息.页边距.Bottom);
        return rst;
    },
    getSegIdxByPageIdx(page, page_seg_map) {
        let rst = -1;
        for (let pIdx = 0; pIdx < page_seg_map.length; pIdx++) {
            if (page_seg_map[pIdx][0] === page) {
                rst = page_seg_map[pIdx][1];
                break;
            }
        }
        return rst;
    },
    getStringLinesInArea(area, strVal, chnW, otherW) {
        //备注： 因后台的pdf kit判断字符串长度与前端的不一样，需要做些调整，不一次性地判断字符串长度。
        //      分2种字符：中文与非中文，按照各种字符的数量分别乘以相关一个字符的宽度再累计。
        //      另判断行数还不能直接用总长度除以宽度来计算，因每一行都会有不同的余量，所以得一行行走过来判断。
        let rst = 0;
        if (strVal) {
            let areaWidth = area.Right - area.Left - VAL_DEF.OUTPUT_OFFSET[VAL_DEF.OFFSET_IDX_RIGHT] - VAL_DEF.OUTPUT_OFFSET[VAL_DEF.OFFSET_IDX_LEFT] - 1;
            let txtWidth = 0, currentW = 0;
            for (let sIdx = 0; sIdx < strVal.length; sIdx++) {
                currentW = (strVal.charCodeAt(sIdx) > 127) ? chnW : otherW;
                txtWidth += currentW;
                if (txtWidth > areaWidth) {
                    rst++;
                    txtWidth = currentW;
                }
                if (sIdx === strVal.length - 1) {
                    rst++;
                }
            }
        }
        if (rst === 0)
            rst = 1; //即使是空字符串，也得有一行啊
        return rst;
    },
    splitString(area, strVal, chnW, otherW) {
        let rst = [];
        if (strVal) {
            let areaWidth = area.Right - area.Left - VAL_DEF.OUTPUT_OFFSET[VAL_DEF.OFFSET_IDX_RIGHT] - VAL_DEF.OUTPUT_OFFSET[VAL_DEF.OFFSET_IDX_LEFT] - 1;
            let preSIdx = 0, txtWidth = 0;
            let currentW = 0;
            for (let sIdx = 0; sIdx < strVal.length; sIdx++) {
                currentW = (strVal.charCodeAt(sIdx) > 127) ? chnW : otherW;
                txtWidth += currentW;
                if (txtWidth > areaWidth) {
                    if (preSIdx < sIdx) {
                        rst.push(strVal.substr(preSIdx, sIdx - preSIdx));
                        preSIdx = sIdx;
                    }
                    else {
                        rst.push(strVal.substr(preSIdx, 1));
                        preSIdx = sIdx + 1;
                    }
                    txtWidth = currentW;
                }
                if (sIdx === strVal.length - 1) {
                    rst.push(strVal.substr(preSIdx, strVal.length - preSIdx));
                }
            }
        }
        if (rst.length === 0)
            rst.push(''); //什么都没有，也得整个空串
        return rst;
    }
};

let JpcBandHelper = {
    getBandTypeValByString: function (bandType) {
        let rst = VAL_DEF.PAGE_STATUS.indexOf(bandType);
        if (rst < 0)
            rst = VAL_DEF.STATUS_NORMAL;
        return rst;
    },
    setBandArea: function (bands, rptTpl, pageStatus, isOnlyNormalStatus, isOnlyExStatus) {
        let me = this;
        if (rptTpl.布局框_集合) {
            isOnlyNormalStatus = isOnlyNormalStatus || false;
            isOnlyExStatus = isOnlyExStatus || false;
            let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
            let orgArea = JpcCommonHelper.getReportArea(rptTpl, unitFactor);
            for (let i = 0; i < rptTpl.布局框_集合.length; i++) {
                me.setBandPos(bands, rptTpl.布局框_集合[i], orgArea, unitFactor, pageStatus, isOnlyNormalStatus, isOnlyExStatus);
            }
        }
    },
    setBandPos: function (bands, bandNode, orgArea, unitFactor, pageStatus, isOnlyNormalStatus, isOnlyExStatus) {
        let me = this, band = bands[bandNode.Name];
        //0. for multi flow purpose
        if (isOnlyNormalStatus) {
            if (bandNode.hasOwnProperty(VAL_DEF.PROP_BAND_EX_ONLY) && JpcCommonHelper.getBoolean(bandNode.exOnly)) {
                return;
            }
        }
        if (isOnlyExStatus) {
            if (bandNode.hasOwnProperty(VAL_DEF.PROP_BAND_NORMAL_ONLY) && !(JpcCommonHelper.getBoolean(bandNode.normalOnly))) {
                return;
            }
        }
        //1. initialize
        band.Left = orgArea[VAL_DEF.IDX_LEFT];
        band.Top = orgArea[VAL_DEF.IDX_TOP];
        band.Right = orgArea[VAL_DEF.IDX_RIGHT];
        band.Bottom = orgArea[VAL_DEF.IDX_BOTTOM];
        //2. set this band
        if (pageStatus[(band.BDisplayType)]) {
            switch (band.Alignment) {
                case VAL_DEF.LAYOUT_TOP:
                    if (band.CalculationType === VAL_DEF.CAL_TYPE_ABSTRACT) {
                        band.Bottom = band.Top + unitFactor * band.Height;
                    }
                    else {
                        band.Bottom = band.Top + (band.Bottom - band.Top) * band.Height / 100;
                    }
                    orgArea[VAL_DEF.IDX_TOP] = band.Bottom;
                    break;
                case VAL_DEF.LAYOUT_BOTTOM:
                    if (band.CalculationType === VAL_DEF.CAL_TYPE_ABSTRACT) {
                        band.Top = band.Bottom - unitFactor * band.Height;
                    }
                    else {
                        band.Top = band.Bottom - (band.Bottom - band.Top) * band.Height / 100;
                    }
                    orgArea[VAL_DEF.IDX_BOTTOM] = band.Top;
                    break;
                case VAL_DEF.LAYOUT_LEFT:
                    if (band.CalculationType === VAL_DEF.CAL_TYPE_ABSTRACT) {
                        band.Right = band.Left + unitFactor * band.Width;
                    }
                    else {
                        band.Right = band.Left + (band.Right - band.Left) * band.Width / 100;
                    }
                    orgArea[VAL_DEF.IDX_LEFT] = band.Right;
                    break;
                case VAL_DEF.LAYOUT_RIGHT:
                    if (band.CalculationType === VAL_DEF.CAL_TYPE_ABSTRACT) {
                        band.Left = band.Right - unitFactor * band.Width;
                    }
                    else {
                        band.Left = band.Right - (band.Right - band.Left) * band.Width / 100;
                    }
                    orgArea[VAL_DEF.IDX_RIGHT] = band.Left;
                    break;
            }
            //3. set sub-bands
            if (bandNode.band_s) {
                let bandArea = [band.Left, band.Top, band.Right, band.Bottom];
                for (let i = 0; i < bandNode.band_s.length; i++) {
                    me.setBandPos(bands, bandNode.band_s[i], bandArea, unitFactor, pageStatus, isOnlyNormalStatus, isOnlyExStatus);
                }
            }
        }
    },
    resetBandPos: function (bandCollection, bands, contentBand, offsetX, offsetY) {
        let orgX = contentBand.Right, orgY = contentBand.Bottom;
        function _chkAndResetPos(targetBand) {
            let band = bands[targetBand.Name];
            if (band) {
                if (band === contentBand) {
                    band.Bottom += offsetY;
                    band.Right += offsetX;
                }
                else {
                    if (band.Top >= orgY) {
                        band.Top += offsetY;
                        band.Bottom += offsetY;
                    }
                    else if (band.Bottom >= orgY && band.Top < orgY) {
                        band.Bottom += offsetY;
                    }
                    if (band.Left >= orgX) {
                        band.Left += offsetX;
                        band.Right += offsetX;
                    }
                    else if (band.Le && band.Right >= orgX && band.Le < orgX) {
                        band.Right += offsetX;
                    }
                }
                if (targetBand.band_s) {
                    for (let i = 0; i < targetBand.band_s.length; i++) {
                        _chkAndResetPos(targetBand.band_s[i]);
                    }
                }
            }
        }
        for (let i = 0; i < bandCollection.length; i++) {
            _chkAndResetPos(bandCollection[i]);
        }
    }
};

const JpcBand = {
    createNew(rptTpl, defProperties) {
        let me = this;
        let JpcBandResult = {};
        if (rptTpl.布局框_集合) {
            for (let i = 0; i < rptTpl.布局框_集合.length; i++) {
                me.createSingle(rptTpl.布局框_集合[i], JpcBandResult, rptTpl, defProperties);
            }
        }
        return JpcBandResult;
    },
    createSingle(bandNode, parentObj, rptTpl, defProperties) {
        let me = this;
        if (bandNode && bandNode.Name) {
            let item = {
                Left: 0,
                Right: 0,
                Top: 0,
                Bottom: 0,
                style: JpcCommonHelper.getStyle(bandNode.style, defProperties.styles),
                control: JpcCommonHelper.getControl(bandNode.control, defProperties.ctrls),
                Height: (bandNode.Height) ? (1.0 * bandNode.Height) : 0,
                Width: (bandNode.Width) ? 1.0 * bandNode.Width : 0,
                DisplayType: JpcBandHelper.getBandTypeValByString(bandNode.DisplayType),
                Alignment: JpcCommonHelper.getLayoutAlignment(bandNode.Alignment),
                CalculationType: JpcCommonHelper.getPosCalculationType(bandNode.CalculationType),
            };
            if (bandNode.hasOwnProperty(VAL_DEF.PROP_BAND_NORMAL_ONLY)) {
                item.normalOnly = JpcCommonHelper.getBoolean(bandNode.normalOnly);
            }
            if (bandNode.hasOwnProperty(VAL_DEF.PROP_BAND_EX_ONLY)) {
                item.exOnly = JpcCommonHelper.getBoolean(bandNode.exOnly);
            }
            if (bandNode.MergeBorder) {
                item.MergeBorder = bandNode.MergeBorder;
            }
            if (bandNode.band_s) {
                for (let i = 0; i < bandNode.band_s.length; i++) {
                    me.createSingle(bandNode.band_s[i], parentObj, rptTpl, defProperties);
                }
            }
            parentObj[bandNode.Name] = item;
            if (item.MergeBorder !== null && item.MergeBorder !== undefined && item.MergeBorder === 'T') {
                parentObj.MergeBand = item;
            }
        }
    }
};

var strUtil = {
    isEmptyString: function (str) {
        let rst = false;
        if (str === null || str === undefined) {
            rst = true;
        }
        else if (typeof str) {
            let reg = /^\s*$/;
            rst = reg.test(str);
        }
        return rst;
    },
    trim: function (str) {
        return str.replace(/(^\s*)|(\s*$)/g, "");
    },
    leftTrim: function (str) {
        return str.replace(/(^\s*)/g, "");
    },
    rightTrim: function (str) {
        return str.replace(/(\s*$)/g, "");
    },
    replaceAll: function (targetStr, FindText, RepText) {
        let regExp = new RegExp(FindText, "gm");
        return targetStr.replace(regExp, RepText);
    },
    comdify: function (numStr) {
        let re = /\d{1,3}(?=(\d{3})+$)/g;
        return numStr.replace(/^(\d+)((\.\d+)?)$/, function (s, s1, s2) { return s1.replace(re, "$&,") + s2; });
    },
    convertToCaptionNum: function (num, isCurrency, isTraditionalCap) {
        let me = this, rst = "";
        if (/^\d*(\.\d*)?$/.test(num)) {
            let capChars, unitChars;
            if (isTraditionalCap) {
                capChars = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
                unitChars = ["", "拾", "佰", "仟", "萬", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万"];
            }
            else {
                capChars = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
                unitChars = ["", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千", "万"];
            }
            let numSplitArr = ("" + num).replace(/(^0*)/g, "").split(".");
            if (numSplitArr[0] === "")
                numSplitArr[0] = "0";
            let len = numSplitArr[0].length;
            let intPartArr = [];
            if (len <= 13) {
                for (let idx = 0; idx < len; idx++) {
                    intPartArr.push(capChars[parseInt(numSplitArr[0].charAt(idx))] + unitChars[len - idx - 1]);
                }
                rst = intPartArr.join('');
                rst = me.replaceAll(rst, capChars[0] + unitChars[3], capChars[0]); //零千 -> 零
                rst = me.replaceAll(rst, capChars[0] + unitChars[2], capChars[0]); //零百 -> 零
                rst = me.replaceAll(rst, capChars[0] + unitChars[1], capChars[0]); //零十 -> 零
                //
                rst = me.replaceAll(me.replaceAll(rst, "零零", "零"), "零零", "零");
                rst = me.replaceAll(rst, capChars[0] + unitChars[8], unitChars[8]); //零亿 -> 亿
                rst = me.replaceAll(rst, capChars[0] + unitChars[4], unitChars[4]); //零万 -> 万
                //
                rst = me.replaceAll(rst, unitChars[8] + unitChars[4], unitChars[8] + capChars[0]); //亿万 -> 亿零
                if (num === 0) {
                    rst = "零";
                }
                else if (rst.length > 1 && rst.charAt(rst.length - 1) === '零') {
                    rst = rst.slice(0, rst.length - 1);
                }
                //小数部分处理
                if (numSplitArr.length > 1) {
                    len = numSplitArr[1].length;
                    if (parseInt(numSplitArr[1]) === 0) {
                        rst = rst + (isCurrency ? "元整" : "");
                    }
                    else {
                        if (isCurrency && len > 2)
                            len = 2;
                        let fractionStr = [];
                        for (let idx = 0; idx < len; idx++) {
                            fractionStr.push(capChars[parseInt(numSplitArr[1].charAt(idx))] + (isCurrency ? ((idx === 0) ? "角" : "分") : ""));
                        }
                        rst = rst + (isCurrency ? "元" : "点") + fractionStr.join("");
                    }
                }
                else {
                    rst = rst + (isCurrency ? "元整" : "");
                }
            }
            else {
                rst = "Number is too big!";
            }
        }
        else {
            rst = "Number is wrong!";
        }
        return rst;
    },
    convertStrToBoolean: function (str) {
        let rst = false, me = this;
        if (!me.isEmptyString(str)) {
            let upperStr = str.toUpperCase();
            if (upperStr === 'T' || upperStr === 'Y' || upperStr === 'YES' || upperStr === 'TRUE') {
                rst = true;
            }
        }
        return rst;
    },
    formatNumber: function (formatStr, val) {
        let rst = val;
        if (formatStr) {
            if (!(isNaN(parseFloat(val)))) {
                let dotIdx = formatStr.indexOf(".");
                if (dotIdx >= 0) {
                    let tmpStr = parseFloat(val).toFixed(formatStr.length - dotIdx - 1);
                    let digStr = formatStr.substr(dotIdx + 1, formatStr.length - dotIdx);
                    for (let sIdx = digStr.length - 1; sIdx >= 0; sIdx--) {
                        if (digStr[sIdx] === '#') {
                            if (tmpStr.length > 0 && tmpStr[tmpStr.length - 1] === '0') {
                                tmpStr = tmpStr.substr(0, tmpStr.length - 1);
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                    if (tmpStr[tmpStr.length - 1] === '.')
                        tmpStr = tmpStr.substr(0, tmpStr.length - 1);
                    rst = tmpStr;
                }
                else {
                    rst = parseFloat(val).toFixed(0);
                }
                let commaIdx = formatStr.indexOf(",");
                if (commaIdx >= 0) {
                    rst = comdify(val.toString());
                }
            }
        }
        return rst;
    },
};
function comdify(numStr) {
    let re = /\d{1,3}(?=(\d{3})+$)/g;
    return numStr.replace(/^(\d+)((\.\d+)?)$/, function (s, s1, s2) { return s1.replace(re, "$&,") + s2; });
}

/**
 * Created by Tony on 2017/4/14.
 */
var scMathUtil = {
    innerRoundTo: function (num, digit) {
        let lFactor = Math.pow(10, digit);
        let fOffSet = 0.5;
        let sign = '';
        // 处理符号
        if (num < 0) {
            sign = '-';
            num = Math.abs(num);
        }
        // 计算
        let result = Math.floor((num / lFactor) + fOffSet).toString();
        let iLength = result.length;
        // 因为数值被转为整数计算，当目标位数在小数点后，且数值小于0，需要补齐前面的位数
        if (iLength < -digit) {
            result = this.zeroString(-digit) + result;
        }
        // 当目标位数在小数点前，需要补齐后面的位数
        else if ((digit > 0) && (iLength < digit)) {
            result = result + this.zeroString(digit);
        }
        iLength = result.length;
        // 获得小数点前的数字
        let r1 = result.substring(0, iLength + digit);
        // 获得小数点后的数字
        let r2 = result.substring(iLength + digit, iLength);
        // 拼出完整结果
        return Number(sign + r1 + '.' + r2);
    },
    // 原来直接用num.toString(2)，如果小数段最后位数是0，会被舍掉，导致进位计算bug
    // 改为自己计算二进制，固定为53位。
    // 经验证速度没有差别
    // 另：经手工验证，用num.toString(2)将十进制浮点数转换为二进制浮点数时，最后一位有错误的情况出现，例子（10.0311）
    floatToBin: function (num) {
        let sign = '';
        let dNum = num;
        // 符号位
        if (num < 0) {
            sign = '-';
            dNum = -num;
        }
        // 解析整数段
        let iNum = Math.floor(dNum);
        let iFactor;
        let sResult1 = '';
        // 计算二进制整数段
        while (iNum > 0) {
            iFactor = iNum % 2;
            iNum = Math.floor(iNum / 2);
            sResult1 = iFactor + sResult1;
        }
        // 判断是否有整数段
        let bIntZero = sResult1 === '';
        if (bIntZero) {
            sResult1 = '0';
        }
        // 解析小数段
        let fNum = dNum - Math.floor(dNum);
        let sResult2 = '';
        if (fNum > 0) {
            // 双精度浮点数，尾数总长52位，因为第一位总是1，存储时已经被隐藏，所以有效位数为53位
            // 由于js未对浮点数做优化，所以在有运算的情况下，误差会被放大，因此放弃一位有效位数来消除误差，二进制有效位数50位，十进制有效位数15位
            const floatLength = 50;
            let iLength;
            // js的bug，浮点数直接取小数可能不能获得精确值，只有转成字符串，截取字符串中的小数段
            let sNum = dNum.toString(10);
            let iDot = sNum.indexOf('.');
            sNum = '0' + sNum.substring(iDot, sNum.length);
            fNum = Number(sNum);
            // 有整数段，则小数位数为全部位数-整数位数
            if (!bIntZero) {
                iLength = floatLength - sResult1.length;
            }
            else {
                iLength = floatLength;
            }
            // 计算二进制小数段
            while (iLength > 0) {
                fNum = fNum * 2;
                iFactor = Math.floor(fNum);
                fNum = fNum % 1;
                sResult2 = sResult2 + iFactor;
                if (iFactor > 0) {
                    bIntZero = false;
                }
                if (bIntZero && (iFactor === 0)) {
                    continue;
                }
                iLength--;
            }
        }
        return sign + sResult1 + '.' + sResult2;
    },
    binToFloat: function (bin) {
        let result = 0;
        let iLength = bin.length;
        let sign = '';
        if (iLength > 0 && bin[0] === '-') {
            sign = '-';
            bin = bin.substring(1, iLength);
        }
        iLength = bin.length;
        let iDot = bin.indexOf('.');
        if (iDot >= 0) {
            for (let i = 0; i < iLength; i++) {
                let num = Number(bin[i]);
                let idx = iDot - i;
                if (idx === 0) {
                    continue;
                }
                if (idx > 0) {
                    idx -= 1;
                }
                let r = Math.pow(2, idx);
                result += num * r;
            }
        }
        else {
            result = parseInt(bin, 2);
        }
        return sign + result;
    },
    zeroString: function (length) {
        let result = '';
        for (let i = 0; i < length; i++) {
            result = result + '0';
        }
        return result;
    },
    incMantissa: function (bin) {
        let result = bin;
        const me = this;
        let iDot = bin.indexOf('.');
        if (iDot < 0) {
            return result;
        }
        let iLength = bin.length;
        iLength = bin.length;
        for (let i = iLength - 1; i > iDot; i--) {
            let num = Number(bin[i]);
            if (num === 0) {
                num = 1;
                let bin1 = bin.substring(0, i);
                let bin2 = me.zeroString(iLength - (i + 1)); //bin.substring(i + 1, iLength);
                result = bin1 + num.toString() + bin2;
                break;
            }
        }
        return result;
    },
    roundTo: function (num, digit) {
        let me = this;
        // let str1 = me.floatToBin(num);
        // let str2 = me.incMantissa(str1);
        // return me.innerRoundTo( parseFloat(me.binToFloat(str2)), digit);
        return me.innerRoundTo(parseFloat(me.binToFloat(me.incMantissa(me.floatToBin(num)))), digit);
    },
    isNumber: function (obj) {
        return obj === +obj;
    },
    roundForObj: function (obj, decimal) {
        let me = this;
        let value;
        if (me.isNumber(obj)) {
            value = me.roundTo(obj, -decimal);
        }
        else {
            value = me.roundTo(Number(obj), -decimal);
        }
        return value;
    },
    roundToString: function (obj, decimal) {
        let me = this;
        let value;
        if (me.isNumber(obj)) {
            value = me.roundTo(obj, -decimal);
        }
        else {
            value = me.roundTo(Number(obj), -decimal);
        }
        return value.toFixed(decimal);
    },
    // isNumOrFormula:function (text: any) {
    //     let value = Number(text);
    //     if(value ==0 ) return value;
    //     if (!value) {
    //         try {
    //             let exp = new Expression('');
    //             exp.Expression(text);
    //             value = Number(exp.Evaluate());
    //         } catch (error) {
    //             value = 0;
    //         }
    //     }
    //     if(text == null || text == ''){
    //         value = 0;
    //     }
    //     return value;
    // },
    isDef: function (v) {
        return v !== undefined && v !== null;
    },
    //获取ID引用
    getFIDArr: function (exp) {
        let fidRex = /@[\d,a-z,A-Z,-]{36}/g;
        let fidArr = exp.match(fidRex);
        return this.isDef(fidArr) ? fidArr : [];
    }
};

var IDataObj_props;
(function (IDataObj_props) {
    IDataObj_props["detail_data"] = "detail_data";
    IDataObj_props["detail_data_ex"] = "detail_data_ex";
    IDataObj_props["discrete_data"] = "discrete_data";
    IDataObj_props["master_data"] = "master_data";
    IDataObj_props["master_data_ex"] = "master_data_ex";
})(IDataObj_props || (IDataObj_props = {}));
var IEvent_type;
(function (IEvent_type) {
    IEvent_type["GRP_ON_CREATE"] = "GRP_ON_CREATE";
    IEvent_type["FLOW_CONTENT_ON_CREATE"] = "FLOW_CONTENT_ON_CREATE";
})(IEvent_type || (IEvent_type = {}));

/**
 * Created by Tony on 2016/12/28.
 */
const JE = {
    $STR_UTIL: strUtil,
    $SC_MATH_UTIL: scMathUtil,
    F: function (fID, $CURRENT_RPT) {
        let rst = null;
        if ($CURRENT_RPT && ($CURRENT_RPT.fields.从数据指标_集合[VAL_DEF.PROP_ID + "_" + fID])) {
            rst = $CURRENT_RPT.fields.从数据指标_集合[VAL_DEF.PROP_ID + "_" + fID];
        }
        else if ($CURRENT_RPT && ($CURRENT_RPT.fields.主数据指标_集合[VAL_DEF.PROP_ID + "_" + fID])) {
            rst = $CURRENT_RPT.fields.主数据指标_集合[VAL_DEF.PROP_ID + "_" + fID];
        }
        else if ($CURRENT_RPT && ($CURRENT_RPT.fields.主数据指标_拓展集合[VAL_DEF.PROP_ID + "_" + fID])) {
            rst = $CURRENT_RPT.fields.主数据指标_拓展集合[VAL_DEF.PROP_ID + "_" + fID];
        }
        else if ($CURRENT_RPT && ($CURRENT_RPT.fields.从数据指标_拓展集合[VAL_DEF.PROP_ID + "_" + fID])) {
            rst = $CURRENT_RPT.fields.从数据指标_拓展集合[VAL_DEF.PROP_ID + "_" + fID];
        }
        else if ($CURRENT_RPT && ($CURRENT_RPT.fields.离散指标_集合[VAL_DEF.PROP_ID + "_" + fID])) {
            rst = $CURRENT_RPT.fields.离散指标_集合[VAL_DEF.PROP_ID + "_" + fID];
        }
        else if ($CURRENT_RPT && ($CURRENT_RPT.fields.无映射离散指标_集合[VAL_DEF.PROP_ID + "_" + fID])) {
            rst = $CURRENT_RPT.fields.无映射离散指标_集合[VAL_DEF.PROP_ID + "_" + fID];
        }
        else {
            //该方法返回对象可能会导致jpc_flow_tab.ts 的130行 报错, ,by lish
            rst = null;
            // rst = {msg: "the Field-ID is not valid, no result could be found!"};
        }
        return rst;
    },
    P: function (pID, $CURRENT_RPT) {
        let rst = null;
        if ($CURRENT_RPT && ($CURRENT_RPT.params[VAL_DEF.PROP_ID + "_" + pID])) {
            rst = $CURRENT_RPT.params[VAL_DEF.PROP_ID + "_" + pID];
        }
        return rst;
    },
    getCurrentPage: function ($CURRENT_RPT) {
        let rst = 0;
        if ($CURRENT_RPT && $CURRENT_RPT.runTimePageData.currentPage) {
            rst = $CURRENT_RPT.runTimePageData.currentPage;
        }
        return rst;
    },
    getTotalPage: function ($CURRENT_RPT) {
        let rst = 0;
        if ($CURRENT_RPT) {
            rst = $CURRENT_RPT.totalPages;
        }
        return rst;
    },
    getFieldDataLen: function (field, dataObj) {
        let rst = 0;
        if (field.DataNodeName === 'NA') {
            if (!field.data_field) {
                field.data_field = [];
            }
            rst = field.data_field.length;
        }
        else {
            if (!field.DataNodeName) {
                // that means this is a self-defined discrete field!
                field.DataNodeName = VAL_DEF.DATA_DISCRETE_DATA;
                field.DataSeq = dataObj[VAL_DEF.DATA_DISCRETE_DATA];
                dataObj[VAL_DEF.DATA_DISCRETE_DATA].push([]);
            }
            rst = dataObj[field.DataNodeName][field.DataSeq].length;
        }
        return rst;
    },
    setFieldValue: function (field, dataObj, valIdx, newValue) {
        if (field.DataNodeName === "NA") {
            if (!field.data_field) {
                field.data_field = [];
            }
            field.data_field[valIdx] = newValue;
        }
        else if (!field.DataNodeName) {
            //that means this is a self-defined discrete field!
            field.DataNodeName = IDataObj_props.discrete_data;
            field.DataSeq = dataObj[VAL_DEF.DATA_DISCRETE_DATA].length;
            dataObj[VAL_DEF.DATA_DISCRETE_DATA].push([]);
            dataObj[field.DataNodeName][field.DataSeq][valIdx] = newValue;
        }
        else {
            dataObj[field.DataNodeName][field.DataSeq][valIdx] = newValue;
        }
    },
    getFieldValue: function (field, dataObj, valIdx, newVal) {
        let rst = null;
        if (field.DataNodeName === "NA") {
            if (!field.data_field) {
                field.data_field = [];
            }
            if (field.data_field.length > valIdx) {
                rst = field.data_field[valIdx];
            }
            else {
                if (newVal === null && field.data_field.length > 0) {
                    rst = field.data_field[field.data_field.length - 1];
                }
            }
        }
        else {
            if (!field.DataNodeName) {
                //that means this is a self-defined discrete field!
                field.DataNodeName = VAL_DEF.DATA_DISCRETE_DATA;
                field.DataSeq = dataObj[VAL_DEF.DATA_DISCRETE_DATA];
                dataObj[VAL_DEF.DATA_DISCRETE_DATA].push([]);
            }
            if (dataObj[field.DataNodeName][field.DataSeq].length > valIdx) {
                rst = dataObj[field.DataNodeName][field.DataSeq][valIdx];
            }
            else {
                if (newVal === null && dataObj[field.DataNodeName][field.DataSeq].length > 0) {
                    rst = dataObj[field.DataNodeName][field.DataSeq][dataObj[field.DataNodeName][field.DataSeq].length - 1];
                }
            }
        }
        if (rst === null || rst === undefined)
            rst = newVal;
        return rst;
    },
    getFieldValueArray: function (field, dataObj) {
        let rst = null;
        if (field.DataNodeName === 'NA') {
            if (!field.data_field) {
                field.data_field = [];
            }
            rst = field.data_field;
        }
        else {
            if (!field.DataNodeName) {
                // that means this is a self-defined discrete field!
                field.DataNodeName = VAL_DEF.DATA_DISCRETE_DATA;
                field.DataSeq = dataObj[VAL_DEF.DATA_DISCRETE_DATA];
                dataObj[VAL_DEF.DATA_DISCRETE_DATA].push([]);
            }
            rst = dataObj[field.DataNodeName][field.DataSeq];
        }
        if (rst === null || rst === undefined)
            rst = [];
        return rst;
    },
    setFieldValueArray: function (field, dataObj, newArr) {
        if (newArr instanceof Array) {
            if (field.DataNodeName === 'NA') {
                field.data_field = newArr;
            }
            else {
                if (!field.DataNodeName) {
                    // that means this is a self-defined discrete field!
                    field.DataNodeName = VAL_DEF.DATA_DISCRETE_DATA;
                    field.DataSeq = dataObj[VAL_DEF.DATA_DISCRETE_DATA].length;
                    dataObj[VAL_DEF.DATA_DISCRETE_DATA].push([]);
                }
                dataObj[field.DataNodeName][field.DataSeq] = newArr;
            }
        }
    },
    removeFieldValue: function (field, dataObj, valIdx) {
        if (field.DataNodeName === "NA") {
            if (field.data_field.length > valIdx && valIdx >= 0) {
                field.data_field.splice(valIdx, 1);
            }
        }
        else {
            if (dataObj[field.DataNodeName][field.DataSeq].length > valIdx && valIdx >= 0) {
                dataObj[field.DataNodeName][field.DataSeq].splice(valIdx, 1);
            }
        }
    },
    insertFieldValue: function (field, dataObj, valIdx, newValue) {
        if (field.DataNodeName === "NA") {
            if (field.data_field.length > valIdx && valIdx >= 0) {
                field.data_field.splice(valIdx, 0, newValue);
            }
            else if (field.data_field.length <= valIdx) {
                field.data_field[field.data_field.length] = newValue;
            }
        }
        else {
            if (dataObj[field.DataNodeName][field.DataSeq].length > valIdx && valIdx >= 0) {
                dataObj[field.DataNodeName][field.DataSeq].splice(valIdx, 0, newValue);
            }
            else if (dataObj[field.DataNodeName][field.DataSeq].length <= valIdx) {
                dataObj[field.DataNodeName][field.DataSeq][dataObj[field.DataNodeName][field.DataSeq].length] = newValue;
            }
        }
    }
};

let JpcFieldHelper = {
    getValue: function (dataField, valueIdx) {
        let rst = '';
        if (dataField && (dataField.length > valueIdx) && (valueIdx >= 0)) {
            rst = dataField[valueIdx];
        }
        return rst;
    },
    setValue: function (dataField, valueIdx, newValue) {
        if (dataField && (dataField.length > valueIdx) && (valueIdx >= 0)) {
            dataField[valueIdx] = newValue;
        }
    },
    resetSumFormat: function (ref_tab_fields, sum_tab_field) {
        let rst = false;
        if (ref_tab_fields && ref_tab_fields.length > 0) {
            for (let tab_field of ref_tab_fields) {
                if (tab_field[VAL_DEF.PROP_FIELD_ID] === sum_tab_field[VAL_DEF.PROP_FIELD_ID]) {
                    rst = true;
                    if (tab_field.Format) {
                        sum_tab_field.Format = tab_field.Format;
                    }
                    break;
                }
            }
        }
        return rst;
    },
    resetFormat: function (tab_field, map_field, customizeCfg) {
        let rst = false;
        if (map_field && map_field.Precision && map_field.Precision.type === "fixed") {
            let formatStrs = ["#"], ffStr = (customizeCfg && customizeCfg.fillZero) ? "0" : "#";
            for (let idx = 0; idx < parseInt(map_field[VAL_DEF.PROP_FIXED_PRECISION_AMT]); idx++) {
                if (idx === 0) {
                    formatStrs.push(".");
                }
                formatStrs.push(ffStr);
            }
            if (tab_field.Format && tab_field.Format.indexOf(",") >= 0) {
                tab_field.Format = "," + formatStrs.join("");
            }
            else {
                tab_field.Format = formatStrs.join("");
            }
            map_field.Format = tab_field.Format; //这里顺手把format也赋给map_field,后期统计用得着
            rst = true;
        }
        else if (map_field && tab_field.Format && tab_field.Format.indexOf("#") >= 0 && (customizeCfg && customizeCfg.fillZero)) {
            tab_field.Format = strUtil.replaceAll(tab_field.Format, '#', '0');
            map_field.Format = tab_field.Format;
            rst = true;
        }
        return rst;
    },
    resetFlexibleFormat: function (tab_field, ref_field_data, flexiblePrecisionRefObj, valueIdx, customizeCfg) {
        let precisionAmt = 2;
        if (ref_field_data && flexiblePrecisionRefObj && valueIdx >= 0) {
            precisionAmt = flexiblePrecisionRefObj["refUnit_" + ref_field_data[valueIdx]];
            if (precisionAmt === null || precisionAmt === undefined)
                precisionAmt = flexiblePrecisionRefObj["refUnit_其他未列单位"];
        }
        let formatStrs = ["#."], ffStr = (customizeCfg && customizeCfg.fillZero) ? "0" : "#";
        for (let idx = 0; idx < precisionAmt; idx++) {
            formatStrs.push(ffStr);
        }
        if (tab_field.Format && tab_field.Format.indexOf(",") >= 0) {
            tab_field.Format = "," + formatStrs.join("");
        }
        else {
            tab_field.Format = formatStrs.join("");
        }
    },
    decorateValue: function (cell, controls) {
        if (controls) {
            const showZero = controls[cell.control].ShowZero;
            if (showZero && showZero === 'F') {
                const val = parseFloat(cell.Value);
                if (val === 0) {
                    cell.Value = '';
                }
            }
        }
    },
    findAndPutDataFieldIdx: function (rptTpl, tab_fields, rstFields, rstFieldsIdx, isEx) {
        //通过FieldID找到相关映射指标的位置IDX并记录下来，方便后续引用
        if (tab_fields) {
            let DTL_STR = isEx ? '从数据指标_拓展集合' : '从数据指标_集合';
            let detail_fields = rptTpl.指标_数据_映射[DTL_STR];
            for (let i = 0; i < tab_fields.length; i++) {
                let isFounded = false;
                for (let j = 0; j < detail_fields.length; j++) {
                    if (tab_fields[i]["FieldID"] === detail_fields[j]["ID"]) {
                        isFounded = true;
                        if (rstFields)
                            rstFields.push(tab_fields[i]);
                        if (rstFieldsIdx)
                            rstFieldsIdx.push(j);
                        break;
                    }
                }
                if (!isFounded) {
                    if (rstFields)
                        rstFields.push(tab_fields[i]);
                    if (rstFieldsIdx) {
                        if (rptTpl.无映射离散指标_集合 && rptTpl.无映射离散指标_集合.length > 0) {
                            for (let discretField of rptTpl.无映射离散指标_集合) {
                                if (discretField.ID === tab_fields[i]["FieldID"]) {
                                    rstFieldsIdx.push(discretField);
                                    isFounded = true;
                                    break;
                                }
                            }
                        }
                        else {
                            rstFieldsIdx.push(VAL_DEF.BLANK_FIELD_INDEX);
                        }
                    }
                }
            }
        }
    },
    findAutoHeightFieldIdx: function (rptTpl, tab_fields, rstFieldsIdx, isEx) {
        if (tab_fields) {
            let DTL_STR = isEx ? VAL_DEF.NODE_DETAIL_FIELDS_EX : VAL_DEF.NODE_DETAIL_FIELDS;
            let detail_fields = rptTpl.指标_数据_映射[DTL_STR];
            for (let i = 0; i < tab_fields.length; i++) {
                if (tab_fields[i].isAutoHeight) {
                    for (let j = 0; j < detail_fields.length; j++) {
                        if (tab_fields[i]["FieldID"] === detail_fields[j]["ID"]) {
                            let item = [];
                            item[0] = j;
                            item[1] = tab_fields[i];
                            rstFieldsIdx.push(item);
                            break;
                        }
                    }
                }
            }
            if (!isEx) {
                let dis_detail_fields = rptTpl.无映射离散指标_集合;
                for (let i = 0; i < tab_fields.length; i++) {
                    if (tab_fields[i].isAutoHeight) {
                        for (let j = 0; j < dis_detail_fields.length; j++) {
                            if (tab_fields[i]["FieldID"] === dis_detail_fields[j]["ID"]) {
                                let item = [];
                                item[0] = VAL_DEF.BLANK_FIELD_INDEX;
                                item[1] = tab_fields[i];
                                rstFieldsIdx.push(item);
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
};

let JpcFlowTabHelper = {
    getMaxRowsPerPage: function (bands, rptTpl, isEx) {
        let rst = 1;
        let tab;
        (!isEx) ? tab = rptTpl.流水式表_信息.流水式表_数据 : tab = rptTpl.流水式表_拓展信息.流水式表_数据;
        let band = bands[tab.BandName];
        if (band) {
            let maxFieldMeasure = 1.0;
            if (VAL_DEF.CAL_TYPE_ABSTRACT === JpcCommonHelper.getPosCalculationType(tab.CalculationType)) {
                let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
                maxFieldMeasure = 1.0 * tab.CommonHeight * unitFactor;
            }
            else {
                maxFieldMeasure = (band.Bottom - band.Top) * tab.CommonHeight / VAL_DEF.HUNDRED_PERCENT;
            }
            rst = Math.floor((band.Bottom - band.Top) / maxFieldMeasure);
        }
        return rst;
    },
    getActualContentAreaHeight: function (bands, rptTpl, segments, rowAmt, page, isEx) {
        let rst = 1;
        let tab;
        (!isEx) ? tab = rptTpl.流水式表_信息.流水式表_数据 : tab = rptTpl.流水式表_拓展信息.流水式表_数据;
        let band = bands[tab.BandName];
        if (band) {
            let maxFieldMeasure = 1.0;
            if (VAL_DEF.CAL_TYPE_ABSTRACT === JpcCommonHelper.getPosCalculationType(tab.CalculationType)) {
                let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
                maxFieldMeasure = 1.0 * tab.CommonHeight * unitFactor;
            }
            else {
                maxFieldMeasure = (band.Bottom - band.Top) * tab.CommonHeight / VAL_DEF.HUNDRED_PERCENT;
            }
            if (segments.length >= page) {
                rst = rowAmt * maxFieldMeasure;
            }
        }
        return rst;
    },
    chkSegEnd: function (bands, rptTpl, segmentLength, preRec, pageRecAmt, isEx) {
        let me = this, rst = false;
        let remainAmt = preRec + pageRecAmt - segmentLength;
        rst = me.hasEnoughSpace(rptTpl, bands, remainAmt, isEx);
        return rst;
    },
    hasEnoughSpace: function (rptTpl, bands, remainAmt, isEx) {
        if (remainAmt < 0)
            return false;
        let rst = true, measurement = 1.0, douDiffForCompare = 0.00001;
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        let tab;
        (!isEx) ? tab = rptTpl.流水式表_信息.流水式表_数据 : tab = rptTpl.流水式表_拓展信息.流水式表_数据;
        let band = bands[tab.BandName];
        if (band !== null && band !== undefined) {
            measurement = 1.0 * tab.CommonHeight * unitFactor;
            let spareHeight = measurement * remainAmt;
            let douH = band.Bottom - band.Top;
            rst = ((spareHeight >= douH) || ((spareHeight - douH) <= douDiffForCompare));
        }
        return rst;
    }
};

const OFFSET_FLOAT = 0.0000000001;
let JpcCommonOutputHelper = {
    createCommonOutputWithoutDecorate: function (node, value, forceCombine) {
        let me = this, 
        //1. font/style/control
        rst = {
            font: node.font,
            control: node.control,
            style: node.style,
            Value: value
        };
        //2. value
        me.formatCell(node.Format, rst);
        // innerFormat(node.Format, rst);
        if (node.Prefix && rst.Value !== null) {
            rst.Value = node.Prefix + rst.Value;
        }
        else if (node.Prefix && forceCombine) {
            rst.Value = node.Prefix;
        }
        if (node.Suffix && rst.Value !== null) {
            rst.Value = rst.Value + node.Suffix;
        }
        else if (node.Suffix && forceCombine) {
            rst.Value = node.Suffix;
        }
        return rst;
    },
    createCommonOutput: function (node, value, controls) {
        let me = this, 
        //1. font/style/control
        rst = {
            font: node.font,
            control: node.control,
            style: node.style,
            Value: value
        };
        //2. value
        JpcFieldHelper.decorateValue(rst, controls);
        me.formatCell(node.Format, rst);
        // innerFormat(node.Format, rst);
        if (node.Prefix && rst.Value !== null && rst.Value !== '') {
            rst.Value = node.Prefix + rst.Value;
        }
        if (node.Suffix && rst.Value !== null && rst.Value !== '') {
            rst.Value = rst.Value + node.Suffix;
        }
        return rst;
    },
    formatCell: function (formatStr, rstCell) {
        if (formatStr) {
            const rstCellFloatVal = parseFloat(rstCell.Value);
            if (!(isNaN(rstCellFloatVal))) {
                const dotIdx = formatStr.indexOf('.');
                if (dotIdx >= 0) {
                    let tmpStr = (rstCellFloatVal + OFFSET_FLOAT).toFixed(formatStr.length - dotIdx - 1);
                    const digStr = formatStr.substr(dotIdx + 1, formatStr.length - dotIdx);
                    for (let sIdx = digStr.length - 1; sIdx >= 0; sIdx--) {
                        if (digStr[sIdx] === '#') {
                            if (tmpStr.length > 0 && tmpStr[tmpStr.length - 1] === '0') {
                                tmpStr = tmpStr.substr(0, tmpStr.length - 1);
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                    if (tmpStr[tmpStr.length - 1] === '.')
                        tmpStr = tmpStr.substr(0, tmpStr.length - 1);
                    rstCell.Value = tmpStr;
                }
                else {
                    rstCell.Value = (rstCellFloatVal + OFFSET_FLOAT).toFixed(0);
                }
                const commaIdx = formatStr.indexOf(',');
                if (commaIdx >= 0) {
                    rstCell.Value = comdify$1(rstCell.Value.toString());
                }
            }
        }
    }
};
function comdify$1(numStr) {
    let re = /\d{1,3}(?=(\d{3})+$)/g;
    return numStr.replace(/^(\d+)((\.\d+)?)$/, function (s, s1, s2) { return s1.replace(re, '$&,') + s2; });
}

const JpcAreaHelper = {
    outputArea: function (areaNode, band, unitFactor, rowAmount, rowIdx, colAmount, colIdx, multipleDispCol, multipleColIdx, syncHeight, syncWidth) {
        let rst = {
            Left: 0,
            Right: 0,
            Top: 0,
            Bottom: 0
        }, maxMultiColumns = 3;
        if (multipleDispCol > 0 && multipleDispCol <= maxMultiColumns) {
            //1. calculate left/right
            let areaWidth = 1.0 * (band.Right - band.Left) / multipleDispCol;
            areaWidth = areaWidth / colAmount;
            let innerLeft = 0.0, innerRight = areaWidth;
            //
            if (typeof areaNode.H_CalculationType === "string") {
                switch (areaNode.H_CalculationType) {
                    case VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_PERCENTAGE]:
                        innerLeft = (1.0 * areaNode.Left * areaWidth / VAL_DEF.HUNDRED_PERCENT);
                        innerRight = (1.0 * areaNode.Right * areaWidth / VAL_DEF.HUNDRED_PERCENT);
                        break;
                    case VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_ABSTRACT]:
                        innerLeft = 1.0 * areaNode.Left * unitFactor;
                        innerRight = 1.0 * areaNode.Right * unitFactor;
                        break;
                }
            }
            else {
                //颗粒度更加细化的控制，可能左右两边的计算坐标方式都不同
                if (areaNode.H_CalculationType && areaNode.H_CalculationType.Left === VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_PERCENTAGE]) {
                    innerLeft = (1.0 * areaNode.Left * areaWidth / VAL_DEF.HUNDRED_PERCENT);
                }
                else {
                    innerLeft = 1.0 * areaNode.Left * unitFactor;
                }
                if (areaNode.H_CalculationType && areaNode.H_CalculationType.Right === VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_PERCENTAGE]) {
                    innerRight = (1.0 * areaNode.Right * areaWidth / VAL_DEF.HUNDRED_PERCENT);
                }
                else {
                    innerRight = 1.0 * areaNode.Right * unitFactor;
                }
            }
            //2. calculate top/bottom
            let areaHeight = 1.0 * (band.Bottom - band.Top);
            areaHeight = areaHeight / rowAmount;
            let innerTop = 0.0, innerBottom = areaHeight;
            if (typeof areaNode.V_CalculationType === "string") {
                switch (areaNode.V_CalculationType) {
                    case VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_PERCENTAGE]:
                        innerTop = (1.0 * areaNode.Top * areaHeight / VAL_DEF.HUNDRED_PERCENT);
                        innerBottom = (1.0 * areaNode.Bottom * areaHeight / VAL_DEF.HUNDRED_PERCENT);
                        break;
                    case VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_ABSTRACT]:
                        innerTop = 1.0 * areaNode.Top * unitFactor;
                        innerBottom = 1.0 * areaNode.Bottom * unitFactor;
                        break;
                }
            }
            else {
                //颗粒度更加细化的控制，可能上下两边的计算坐标方式都不同
                if (areaNode.V_CalculationType && areaNode.V_CalculationType.Top === VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_PERCENTAGE]) {
                    innerTop = (1.0 * areaNode.Top * areaHeight / VAL_DEF.HUNDRED_PERCENT);
                }
                else {
                    innerTop = 1.0 * areaNode.Top * unitFactor;
                }
                if (areaNode.V_CalculationType && areaNode.V_CalculationType.Bottom === VAL_DEF.CAL_TYPE[VAL_DEF.CAL_TYPE_PERCENTAGE]) {
                    innerBottom = (1.0 * areaNode.Bottom * areaHeight / VAL_DEF.HUNDRED_PERCENT);
                }
                else {
                    innerBottom = 1.0 * areaNode.Bottom * unitFactor;
                }
            }
            //
            let rstLeft = 0.0, rstRight = 0.0, rstTop = 0.0, rstBottom = 0.0;
            if (syncHeight) {
                rstBottom = Math.round(1.0 * band.Top + areaHeight * (rowIdx + 1) + innerTop);
            }
            else {
                rstBottom = Math.round(1.0 * band.Top + areaHeight * rowIdx + innerBottom);
            }
            if (syncWidth) {
                rstRight = Math.round(1.0 * band.Left + areaWidth * (colIdx + 1) + innerLeft + multipleColIdx * areaWidth);
            }
            else {
                rstRight = Math.round(1.0 * band.Left + areaWidth * colIdx + innerRight + multipleColIdx * areaWidth);
            }
            rstLeft = Math.round(1.0 * band.Left + areaWidth * colIdx + innerLeft + multipleColIdx * areaWidth);
            rstTop = Math.round(1.0 * band.Top + areaHeight * rowIdx + innerTop);
            rst.Left = rstLeft;
            rst.Right = rstRight;
            rst.Top = rstTop;
            rst.Bottom = rstBottom;
        }
        return rst;
    }
};

let JpcTextHelper = {
    //暂定
    outputText: function (textNode, band, unitFactor, rows, rowIdx, cols, colIdx, multiCols, multiColIdx) {
        let rst = JpcCommonOutputHelper.createCommonOutput(textNode, textNode.Label, null);
        //position
        rst.area = JpcAreaHelper.outputArea(textNode.area, band, unitFactor, rows, rowIdx, cols, colIdx, multiCols, multiColIdx, false, false);
        return rst;
    },
    outputDirectValue: function (textNode, value, band, unitFactor, rows, rowIdx, cols, colIdx, multiCols, multiColIdx) {
        let rst = JpcCommonOutputHelper.createCommonOutput(textNode, value, null);
        //position
        rst.area = JpcAreaHelper.outputArea(textNode.area, band, unitFactor, rows, rowIdx, cols, colIdx, multiCols, multiColIdx, false, false);
        return rst;
    }
};

const JpcDiscreteHelper = {
    outputDiscreteInfo: function (discreteArray, bands, dataObj, unitFactor, pageStatus, segIdx, multiCols, multiColIdx, $CURRENT_RPT, customizeCfg) {
        let rst = [];
        if (discreteArray && dataObj) {
            for (let i = 0; i < discreteArray.length; i++) {
                let band = bands[discreteArray[i].BandName];
                if (band && pageStatus[(band.DisplayType)] === true) {
                    if (discreteArray[i].text) {
                        rst.push(JpcTextHelper.outputText(discreteArray[i].text, band, unitFactor, 1, 0, 1, 0, multiCols, multiColIdx));
                    }
                    if (discreteArray[i].text_s) {
                        for (let j = 0; j < discreteArray[i].text_s.length; j++) {
                            rst.push(JpcTextHelper.outputText(discreteArray[i].text_s[j], band, unitFactor, 1, 0, 1, 0, multiCols, multiColIdx));
                        }
                    }
                    if (discreteArray[i].discrete_field_s) {
                        let flexiblePrecisionRefObj = null, flexibleRefField = null;
                        for (let j = 0; j < discreteArray[i].discrete_field_s.length; j++) {
                            let df = discreteArray[i].discrete_field_s[j];
                            let value = "";
                            if (df.FieldID) {
                                // let map_data_field = JE.F(df[JV.PROP_FIELD_ID], $CURRENT_RPT);
                                let map_data_field = JE.F(df.FieldID, $CURRENT_RPT);
                                if (map_data_field && map_data_field.DataSeq !== VAL_DEF.BLANK_FIELD_INDEX) {
                                    let data = dataObj[map_data_field.DataNodeName][map_data_field.DataSeq];
                                    if (data && data.length > 0) {
                                        if (data.length > segIdx) {
                                            value = data[segIdx];
                                        }
                                        else {
                                            value = data[0];
                                        }
                                    }
                                }
                                else {
                                    if (map_data_field && map_data_field[VAL_DEF.PROP_AD_HOC_DATA] && map_data_field[VAL_DEF.PROP_AD_HOC_DATA].length > 0) {
                                        value = map_data_field[VAL_DEF.PROP_AD_HOC_DATA][0];
                                    }
                                    else
                                        value = "";
                                }
                                if (map_data_field && map_data_field[VAL_DEF.PROP_PRECISION] && map_data_field.flexiblePrecisionRefObj) {
                                    let pre_ref_data = null;
                                    if (flexiblePrecisionRefObj === null) {
                                        flexiblePrecisionRefObj = {};
                                        flexibleRefField = JE.F(map_data_field[VAL_DEF.PROP_PRECISION][VAL_DEF.PROP_FLEXIBLE_REF_FILED_ID], $CURRENT_RPT);
                                        if (flexibleRefField)
                                            pre_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq]; //这里的引用指标必须得存在，哪怕不显示，也要存放在指标集合中！
                                        for (let decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                            flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                                        }
                                    }
                                    JpcFieldHelper.resetFlexibleFormat(df, pre_ref_data, flexiblePrecisionRefObj, segIdx, customizeCfg);
                                }
                                else {
                                    JpcFieldHelper.resetFormat(df, map_data_field, customizeCfg);
                                }
                            }
                            else if (df.ParamID) {
                                let param = JE.P(df.ParamID, $CURRENT_RPT);
                                if (param && param.Default_Value)
                                    value = param.Default_Value;
                            }
                            let item = JpcCommonOutputHelper.createCommonOutputWithoutDecorate(df, value, true);
                            //position
                            item.area = JpcAreaHelper.outputArea(df.area, band, unitFactor, 1, 0, 1, 0, multiCols, multiColIdx, false, false);
                            rst.push(item);
                        }
                    }
                }
            }
        }
        return rst;
    },
    outputPreviewDiscreteInfo: function (discreteArray, bands, unitFactor, pageStatus) {
        let rst = [];
        for (let i = 0; i < discreteArray.length; i++) {
            let band = bands[discreteArray[i].BandName];
            if (band && pageStatus[(band.DisplayType)]) {
                if (discreteArray[i].text) {
                    rst.push(JpcTextHelper.outputText(discreteArray[i].text, band, unitFactor, 1, 0, 1, 0, 1, 0));
                }
                if (discreteArray[i].text_s) {
                    for (let j = 0; j < discreteArray[i].text_s.length; j++) {
                        rst.push(JpcTextHelper.outputText(discreteArray[i].text_s[j], band, unitFactor, 1, 0, 1, 0, 1, 0));
                    }
                }
                if (discreteArray[i].discrete_field_s) {
                    for (let j = 0; j < discreteArray[i].discrete_field_s.length; j++) {
                        let df = discreteArray[i].discrete_field_s[j];
                        let value = "";
                        if (df.Default_Value) {
                            value = df.Default_Value;
                        }
                        let item = JpcCommonOutputHelper.createCommonOutputWithoutDecorate(df, value, false);
                        //position
                        item.area = JpcAreaHelper.outputArea(df.area, band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                        rst.push(item);
                    }
                }
            }
        }
        return rst;
    },
    outputPreviewSumInfoOutput: function (band, unitFactor, tab) {
        let rst = [];
        if (tab.text) {
            rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, 1, 0, 1, 0));
        }
        if (tab.text_s) {
            for (let j = 0; j < tab.text_s.length; j++) {
                rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, 1, 0, 1, 0));
            }
        }
        if (tab.sum_field_s) {
            for (let i = 0; i < tab.sum_field_s.length; i++) {
                let tab_field = tab.sum_field_s[i];
                if (!(tab_field.Hidden)) {
                    // rst.push(me.outputTabField(band, tab_field, null, -1, -1, 1, 0, 1, 0, unitFactor, true, controls, 0));
                    let value = "";
                    let item = JpcCommonOutputHelper.createCommonOutputWithoutDecorate(tab_field, value, false);
                    //position
                    item.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                    rst.push(item);
                }
            }
        }
        return rst;
    }
};

/**
 * Created by Tony on 2019/12/12.
 */
const fontWidthMap = {
    '宋体': {
        '宽': {
            '_6': 6,
            '_7': 7,
            '_8': 8,
            '_9': 9,
            '_10': 10,
            '_11': 11,
            '_12': 12,
            '_13': 13,
            '_14': 14,
            '_15': 15,
            '_16': 16,
            '_17': 17,
            '_18': 18,
            '_19': 19,
            '_20': 20,
            '_21': 21,
            '_22': 22,
            '_23': 23,
            '_24': 24,
            '_25': 25,
            '_26': 26,
            '_27': 27,
            '_28': 28,
            '_29': 29,
            '_30': 30,
            '_31': 31,
            '_32': 32,
            '_33': 33,
            '_34': 34,
            '_35': 35,
            '_36': 36,
            '_37': 37,
            '_38': 38,
            '_39': 39,
            '_40': 40,
            '_41': 41,
            '_42': 42,
            '_43': 43,
            '_44': 44,
            '_45': 45,
            '_46': 46,
            '_47': 47,
            '_48': 48,
            '_49': 49,
            '_50': 50,
            '_51': 51,
            '_52': 52,
            '_53': 53,
            '_54': 54,
            '_55': 55,
            '_56': 56,
            '_57': 57,
            '_58': 58,
            '_59': 59,
            '_60': 60,
            '_61': 61,
            '_62': 62,
            '_63': 63,
            '_64': 64
        },
        '窄': {
            '_6': 3,
            '_7': 3.5,
            '_8': 4,
            '_9': 4.5,
            '_10': 5,
            '_11': 5.5,
            '_12': 6,
            '_13': 6.5,
            '_14': 7,
            '_15': 7.5,
            '_16': 8,
            '_17': 8.5,
            '_18': 9,
            '_19': 9.5,
            '_20': 10,
            '_21': 10.5,
            '_22': 11,
            '_23': 11.5,
            '_24': 12,
            '_25': 12.5,
            '_26': 13,
            '_27': 13.5,
            '_28': 14,
            '_29': 14.5,
            '_30': 15,
            '_31': 15.5,
            '_32': 16,
            '_33': 16.5,
            '_34': 17,
            '_35': 17.5,
            '_36': 18,
            '_37': 18.5,
            '_38': 19,
            '_39': 19.5,
            '_40': 20,
            '_41': 20.5,
            '_42': 21,
            '_43': 21.5,
            '_44': 22,
            '_45': 22.5,
            '_46': 23,
            '_47': 23.5,
            '_48': 24,
            '_49': 24.5,
            '_50': 25,
            '_51': 25.5,
            '_52': 26,
            '_53': 26.5,
            '_54': 27,
            '_55': 27.5,
            '_56': 28,
            '_57': 28.5,
            '_58': 29,
            '_59': 29.5,
            '_60': 30,
            '_61': 30.5,
            '_62': 31,
            '_63': 31.5,
            '_64': 32
        }
    },
    '黑体': {
        '宽': {
            '_6': 6,
            '_7': 7,
            '_8': 8,
            '_9': 9,
            '_10': 10,
            '_11': 11,
            '_12': 12,
            '_13': 13,
            '_14': 14,
            '_15': 15,
            '_16': 16,
            '_17': 17,
            '_18': 18,
            '_19': 19,
            '_20': 20,
            '_21': 21,
            '_22': 22,
            '_23': 23,
            '_24': 24,
            '_25': 25,
            '_26': 26,
            '_27': 27,
            '_28': 28,
            '_29': 29,
            '_30': 30,
            '_31': 31,
            '_32': 32,
            '_33': 33,
            '_34': 34,
            '_35': 35,
            '_36': 36,
            '_37': 37,
            '_38': 38,
            '_39': 39,
            '_40': 40,
            '_41': 41,
            '_42': 42,
            '_43': 43,
            '_44': 44,
            '_45': 45,
            '_46': 46,
            '_47': 47,
            '_48': 48,
            '_49': 49,
            '_50': 50,
            '_51': 51,
            '_52': 52,
            '_53': 53,
            '_54': 54,
            '_55': 55,
            '_56': 56,
            '_57': 57,
            '_58': 58,
            '_59': 59,
            '_60': 60,
            '_61': 61,
            '_62': 62,
            '_63': 63,
            '_64': 64
        },
        '窄': {
            '_6': 3,
            '_7': 3.5,
            '_8': 4,
            '_9': 4.5,
            '_10': 5,
            '_11': 5.5,
            '_12': 6,
            '_13': 6.5,
            '_14': 7,
            '_15': 7.5,
            '_16': 8,
            '_17': 8.5,
            '_18': 9,
            '_19': 9.5,
            '_20': 10,
            '_21': 10.5,
            '_22': 11,
            '_23': 11.5,
            '_24': 12,
            '_25': 12.5,
            '_26': 13,
            '_27': 13.5,
            '_28': 14,
            '_29': 14.5,
            '_30': 15,
            '_31': 15.5,
            '_32': 16,
            '_33': 16.5,
            '_34': 17,
            '_35': 17.5,
            '_36': 18,
            '_37': 18.5,
            '_38': 19,
            '_39': 19.5,
            '_40': 20,
            '_41': 20.5,
            '_42': 21,
            '_43': 21.5,
            '_44': 22,
            '_45': 22.5,
            '_46': 23,
            '_47': 23.5,
            '_48': 24,
            '_49': 24.5,
            '_50': 25,
            '_51': 25.5,
            '_52': 26,
            '_53': 26.5,
            '_54': 27,
            '_55': 27.5,
            '_56': 28,
            '_57': 28.5,
            '_58': 29,
            '_59': 29.5,
            '_60': 30,
            '_61': 30.5,
            '_62': 31,
            '_63': 31.5,
            '_64': 32
        }
    },
    '楷体': {
        '宽': {
            '_6': 6,
            '_7': 7,
            '_8': 8,
            '_9': 9,
            '_10': 10,
            '_11': 11,
            '_12': 12,
            '_13': 13,
            '_14': 14,
            '_15': 15,
            '_16': 16,
            '_17': 17,
            '_18': 18,
            '_19': 19,
            '_20': 20,
            '_21': 21,
            '_22': 22,
            '_23': 23,
            '_24': 24,
            '_25': 25,
            '_26': 26,
            '_27': 27,
            '_28': 28,
            '_29': 29,
            '_30': 30,
            '_31': 31,
            '_32': 32,
            '_33': 33,
            '_34': 34,
            '_35': 35,
            '_36': 36,
            '_37': 37,
            '_38': 38,
            '_39': 39,
            '_40': 40,
            '_41': 41,
            '_42': 42,
            '_43': 43,
            '_44': 44,
            '_45': 45,
            '_46': 46,
            '_47': 47,
            '_48': 48,
            '_49': 49,
            '_50': 50,
            '_51': 51,
            '_52': 52,
            '_53': 53,
            '_54': 54,
            '_55': 55,
            '_56': 56,
            '_57': 57,
            '_58': 58,
            '_59': 59,
            '_60': 60,
            '_61': 61,
            '_62': 62,
            '_63': 63,
            '_64': 64
        },
        '窄': {
            '_6': 3,
            '_7': 3.5,
            '_8': 4,
            '_9': 4.5,
            '_10': 5,
            '_11': 5.5,
            '_12': 6,
            '_13': 6.5,
            '_14': 7,
            '_15': 7.5,
            '_16': 8,
            '_17': 8.5,
            '_18': 9,
            '_19': 9.5,
            '_20': 10,
            '_21': 10.5,
            '_22': 11,
            '_23': 11.5,
            '_24': 12,
            '_25': 12.5,
            '_26': 13,
            '_27': 13.5,
            '_28': 14,
            '_29': 14.5,
            '_30': 15,
            '_31': 15.5,
            '_32': 16,
            '_33': 16.5,
            '_34': 17,
            '_35': 17.5,
            '_36': 18,
            '_37': 18.5,
            '_38': 19,
            '_39': 19.5,
            '_40': 20,
            '_41': 20.5,
            '_42': 21,
            '_43': 21.5,
            '_44': 22,
            '_45': 22.5,
            '_46': 23,
            '_47': 23.5,
            '_48': 24,
            '_49': 24.5,
            '_50': 25,
            '_51': 25.5,
            '_52': 26,
            '_53': 26.5,
            '_54': 27,
            '_55': 27.5,
            '_56': 28,
            '_57': 28.5,
            '_58': 29,
            '_59': 29.5,
            '_60': 30,
            '_61': 30.5,
            '_62': 31,
            '_63': 31.5,
            '_64': 32
        }
    },
    'Arial': {
        '宽': {
            '_6': 6,
            '_7': 7,
            '_8': 8,
            '_9': 9,
            '_10': 10,
            '_11': 11,
            '_12': 12,
            '_13': 13,
            '_14': 14,
            '_15': 15,
            '_16': 16,
            '_17': 17,
            '_18': 18,
            '_19': 19,
            '_20': 20,
            '_21': 21,
            '_22': 22,
            '_23': 23,
            '_24': 24,
            '_25': 25,
            '_26': 26,
            '_27': 27,
            '_28': 28,
            '_29': 29,
            '_30': 30,
            '_31': 31,
            '_32': 32,
            '_33': 33,
            '_34': 34,
            '_35': 35,
            '_36': 36,
            '_37': 37,
            '_38': 38,
            '_39': 39,
            '_40': 40,
            '_41': 41,
            '_42': 42,
            '_43': 43,
            '_44': 44,
            '_45': 45,
            '_46': 46,
            '_47': 47,
            '_48': 48,
            '_49': 49,
            '_50': 50,
            '_51': 51,
            '_52': 52,
            '_53': 53,
            '_54': 54,
            '_55': 55,
            '_56': 56,
            '_57': 57,
            '_58': 58,
            '_59': 59,
            '_60': 60,
            '_61': 61,
            '_62': 62,
            '_63': 63,
            '_64': 64
        },
        '窄': {
            '_6': 3.3399999141693115,
            '_7': 3.8899998664855957,
            '_8': 4.449999809265137,
            '_9': 5.009999752044678,
            '_10': 5.559999942779541,
            '_11': 6.119999885559082,
            '_12': 6.670000076293945,
            '_13': 7.230000019073486,
            '_14': 7.789999961853027,
            '_15': 8.34000015258789,
            '_16': 8.899999618530273,
            '_17': 9.449999809265136,
            '_18': 10.010000228881836,
            '_19': 10.569999694824218,
            '_20': 11.119999885559082,
            '_21': 11.679999351501464,
            '_22': 12.239999771118164,
            '_23': 12.789999961853027,
            '_24': 13.34999942779541,
            '_25': 13.899999618530273,
            '_26': 14.460000038146972,
            '_27': 15.019999504089355,
            '_28': 15.569999694824218,
            '_29': 16.1299991607666,
            '_30': 16.68000030517578,
            '_31': 17.239999771118164,
            '_32': 17.799999237060547,
            '_33': 18.350000381469726,
            '_34': 18.90999984741211,
            '_35': 19.469999313354492,
            '_36': 20.020000457763672,
            '_37': 20.579999923706054,
            '_38': 21.1299991607666,
            '_39': 21.689998626708984,
            '_40': 22.25,
            '_41': 22.799999237060547,
            '_42': 23.35999870300293,
            '_43': 23.90999984741211,
            '_44': 24.469999313354492,
            '_45': 25.029998779296875,
            '_46': 25.579999923706054,
            '_47': 26.139999389648437,
            '_48': 26.69999885559082,
            '_49': 27.25,
            '_50': 27.809999465942383,
            '_51': 28.35999870300293,
            '_52': 28.920000076293945,
            '_53': 29.479999542236328,
            '_54': 30.029998779296875,
            '_55': 30.59000015258789,
            '_56': 31.139999389648437,
            '_57': 31.69999885559082,
            '_58': 32.2599983215332,
            '_59': 32.80999755859375,
            '_60': 33.369998931884766,
            '_61': 33.93000030517578,
            '_62': 34.47999954223633,
            '_63': 35.040000915527344,
            '_64': 35.59000015258789
        }
    },
    getFontWidth: function (fontName, fontHeight, typeStr) {
        let rst = 12;
        if (fontWidthMap[fontName]) {
            rst = fontWidthMap[fontName][typeStr]['_' + fontHeight];
        }
        else {
            rst = fontWidthMap['宋体'][typeStr]['_' + fontHeight];
        }
        return rst;
    }
};

class JpcFlowTabClass {
    constructor(isEx) {
        //初始化
        this.isEx = isEx;
        this.paging_option = VAL_DEF.PAGING_OPTION_NORMAL;
        this.segments = [];
        this.dispValueIdxLst = [];
        this.page_seg_map = [];
        this.disp_fields_idx = [];
        this.disp_fields_ex_idx = [];
        this.seg_sum_fields_idx = [];
        this.seg_sum_tab_fields = [];
        this.page_sum_fields_idx = [];
        this.page_sum_tab_fields = [];
        this.auto_height_fields_idx = []; //那些被标记为判断自动行高的指标集合
        this.auto_height_info = [];
        this.group_check_fields = [];
        this.group_sum_fields = [];
        this.group_sum_values = [];
        // this.group_sum_values = null; 因为在后面初始化时会先把该变量设置为[],所以这里直接修改为[] ,by lish
        this.group_node_info = []; //记录在哪个seg及到哪条记录后有group sum信息
        // this.group_node_info = null; 因为在后面初始化时会先把该变量设置为[],所以这里直接修改为[]  ,by lish
        this.group_lines_amt = 0; //每group一次占用多少行，计算page信息会用到
        this.pageStatusLst = [];
        this.groupSumValLst = [];
        this.segSumValLst = [];
        this.pageSumValLst = [];
        this.multiCols = 1;
        this.pagesAmt = 0;
    }
    ;
    sorting(rptTpl, dataObj, dataSeq, $CURRENT_RPT) {
        let me = this;
        // let FLOW_NODE_STR = me.isEx?'流水式表_拓展信息':'流水式表_信息';
        //因为rptTpl[FLOW_NODE_STR的写法不兼容ts，所以把变量改为flow_node_str代替
        let flow_node_str = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        if (flow_node_str.流水式表_段统计信息)
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, flow_node_str.流水式表_段统计信息.sum_field_s, me.seg_sum_tab_fields, me.seg_sum_fields_idx, me.isEx);
        if (flow_node_str.流水式表_页统计信息)
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, flow_node_str.流水式表_页统计信息.sum_field_s, me.page_sum_tab_fields, me.page_sum_fields_idx, me.isEx);
        if (flow_node_str.流水式表_分组信息) {
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, flow_node_str.流水式表_分组信息.group_field_s, me.group_check_fields, null, me.isEx);
            if (flow_node_str.流水式表_分组信息.group_lines) {
                for (let grpLine of flow_node_str.流水式表_分组信息.group_lines) {
                    if (grpLine.SumKey_S && grpLine.SumKey_S.length > 0) {
                        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, grpLine.SumKey_S, me.group_sum_fields, null, me.isEx);
                    }
                }
            }
            for (let grp_sum_f of me.group_sum_fields) {
                grp_sum_f.SumKey = `grp_sum_key_` + grp_sum_f.FieldID;
            }
        }
        JpcFieldHelper.findAutoHeightFieldIdx(rptTpl, flow_node_str.流水式表_数据.flow_field_s, me.auto_height_fields_idx, me.isEx);
        for (let si = 0; si < dataSeq.length; si++) {
            me.segments.push(dataSeq[si].slice(0));
        }
        //pre-sum the data(for seg sum display)
        //考虑到实际会有离散指标的汇总，这些离散指标数据是通过计算式后得来的，这种情况下，不适宜在sorting阶段进行汇总统计，现挪到preSetupPages阶段处理
    }
    ;
    sumSeg(dataObj, $CURRENT_RPT) {
        let me = this;
        let data_details = me.isEx ? dataObj.detail_data_ex : dataObj.detail_data, data_fields = [];
        for (let i = 0; i < me.seg_sum_fields_idx.length; i++) {
            if (typeof (me.seg_sum_fields_idx[i]) === "object") {
                let exField = JE.F(me.seg_sum_fields_idx[i][VAL_DEF.PROP_ID], $CURRENT_RPT);
                if (exField) {
                    data_fields.push(exField.data_field);
                }
                else {
                    data_fields.push(null);
                }
            }
            else {
                let data_field = data_details[me.seg_sum_fields_idx[i]];
                data_fields.push(data_field);
            }
        }
        for (let i = 0; i < me.segments.length; i++) { //seg level
            if (me.segments[i].length > 0) {
                let rowGrandTotal = [];
                for (let di = 0; di < data_fields.length; di++) {
                    rowGrandTotal.push(0.0);
                    let precisionAmt = 4;
                    let sum_field = JE.F(me.seg_sum_tab_fields[di][VAL_DEF.PROP_FIELD_ID], $CURRENT_RPT);
                    if (sum_field && sum_field.Precision && sum_field.Precision.type === `fixed`) {
                        precisionAmt = sum_field.fixedPrecisionNum;
                    }
                    else {
                        let flowF = me.seg_sum_tab_fields[di];
                        if (flowF && !strUtil.isEmptyString(flowF[VAL_DEF.PROP_FORMAT])) {
                            let idx = flowF[VAL_DEF.PROP_FORMAT].indexOf('.');
                            if (idx >= 0) {
                                precisionAmt = flowF[VAL_DEF.PROP_FORMAT].length - idx - 1;
                            }
                        }
                    }
                    for (let j = 0; j < me.segments[i].length; j++) {
                        //3. start to sum
                        // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(data_fields[di], me.segments[i][j]);
                        let sv = JpcFieldHelper.getValue(data_fields[di], me.segments[i][j]);
                        if (sv) {
                            rowGrandTotal[di] = rowGrandTotal[di] + parseFloat(parseFloat(sv).toFixed(precisionAmt));
                        }
                    }
                }
                me.segSumValLst.push(rowGrandTotal);
            }
        }
    }
    ;
    sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, nexGrpIdx) {
        let me = this, segDataIdx = me.segments[segIdx];
        for (let j = 0; j < me.group_sum_fields.length; j++) {
            let sum_field = JE.F(me.group_sum_fields[j].FieldID, $CURRENT_RPT);
            if (sum_field) {
                let data_field = null;
                if (sum_field.data_field) {
                    data_field = sum_field.data_field;
                }
                else {
                    data_field = dataObj[sum_field.DataNodeName][sum_field.DataSeq];
                }
                let sumV = 0, precisionAmt = 4;
                for (let si = preGrpIdx; si <= nexGrpIdx; si++) {
                    if (sum_field.Precision && sum_field.Precision.type === `fixed`) {
                        precisionAmt = sum_field.fixedPrecisionNum;
                    }
                    else {
                        let flowF = me.group_sum_fields[j]; //调整后，me.group_sum_fields[j]就是group lines下数组SumKey_S的元素值，无需再找
                        if (flowF && !strUtil.isEmptyString(flowF.Format)) {
                            let idx = flowF.Format.indexOf('.');
                            if (idx >= 0) {
                                precisionAmt = flowF.Format.length - idx - 1;
                            }
                        }
                    }
                    //sumV += parseFloat(JpcFieldHelper.getValue(data_field, segDataIdx[si]));
                    sumV += parseFloat(parseFloat(JpcFieldHelper.getValue(data_field, segDataIdx[si])).toFixed(precisionAmt));
                }
                // me.group_sum_values[segIdx][j].push(sumV);
                me.group_sum_values[segIdx][me.group_sum_fields[j].SumKey].push(sumV);
            }
        }
        me.group_node_info[segIdx].push(nexGrpIdx);
    }
    ;
    setupGroupingData(rptTpl, dataObj, $CURRENT_RPT) {
        let me = this;
        if (me.group_check_fields.length > 0 && me.group_sum_fields.length > 0) {
            me.group_sum_values = [];
            me.group_node_info = [];
            // let CURRENT_FLOW_INFO = (me.isEx)?'流水式表_拓展信息':'流水式表_信息';
            let current_flow_info = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
            me.group_lines_amt = current_flow_info.流水式表_分组信息.group_lines.length;
            //
            let preGrpIdx = 0, nexGrpIdx = 0;
            for (let segIdx = 0; segIdx < me.segments.length; segIdx++) {
                let segDataIdx = me.segments[segIdx];
                // me.group_sum_values.push([]);
                me.group_sum_values.push({});
                me.group_node_info.push([]);
                for (let j = 0; j < me.group_sum_fields.length; j++) {
                    // me.group_sum_values[segIdx].push([]);
                    me.group_sum_values[segIdx][me.group_sum_fields[j].SumKey] = [];
                    // me.group_node_info[segIdx].push([]);
                }
                for (let di = 0; di < segDataIdx.length; di++) {
                    let hasDiff = false;
                    if (di >= 1) {
                        for (let i = 0; i < me.group_check_fields.length; i++) {
                            let grp_field = JE.F(me.group_check_fields[i].FieldID, $CURRENT_RPT);
                            if (grp_field) {
                                let data_field = null;
                                if (grp_field.data_field) {
                                    data_field = grp_field.data_field;
                                }
                                else {
                                    data_field = dataObj[grp_field.DataNodeName][grp_field.DataSeq];
                                }
                                let v1 = JpcFieldHelper.getValue(data_field, segDataIdx[di]), v2 = JpcFieldHelper.getValue(data_field, segDataIdx[di - 1]);
                                if (v1 !== v2) {
                                    hasDiff = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (hasDiff) {
                        //then sum up the fields
                        me.sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, nexGrpIdx);
                        nexGrpIdx = di;
                        preGrpIdx = di;
                        if (di === segDataIdx.length - 1) {
                            me.sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, nexGrpIdx);
                        }
                    }
                    else if (di === segDataIdx.length - 1) {
                        me.sumUpGrp(rptTpl, $CURRENT_RPT, dataObj, segIdx, preGrpIdx, di);
                    }
                    else {
                        nexGrpIdx = di;
                    }
                }
            }
        }
    }
    ;
    setupAutoHeightData(bands, segIdx, rptTpl, dataObj, $CURRENT_RPT, defProperties) {
        let me = this;
        if (me.auto_height_fields_idx.length > 0) {
            // let CURRENT_FLOW_INFO = (me.isEx)?'流水式表_拓展信息':'流水式表_信息';
            let current_flow_info = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
            let band = bands[current_flow_info.流水式表_数据.BandName];
            let data_details = me.isEx ? dataObj.detail_data_ex : dataObj.detail_data;
            let tab_fields = current_flow_info.流水式表_数据.flow_field_s;
            let adHocAutoHeightStyleStr = [];
            let reg1 = new RegExp('\n\r', 'g'), reg2 = new RegExp('\r\n', 'g'), reg3 = new RegExp('\n', 'g'), reg4 = new RegExp('\r', 'g');
            // let doc = new PDFKit({autoFirstPage: false});
            let fonts = defProperties.fonts;
            let fontCache = {};
            let private_get_font = function (fontKey) {
                let rst = null;
                if (fontCache[fontKey]) {
                    rst = fontCache[fontKey];
                }
                else {
                    for (let i = 0; i < fonts.length; i++) {
                        if (fonts[i].ID === fontKey) {
                            fontCache[fontKey] = fonts[i];
                            rst = fonts[i];
                            break;
                        }
                    }
                }
                return rst;
            };
            let private_get_max_lines_of_the_record = function (theRecIdx) {
                let rst = 1;
                for (let loop = 0; loop < me.auto_height_fields_idx.length; loop++) {
                    let tab_field = me.auto_height_fields_idx[loop][1];
                    let data_field = null, map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                    if (me.auto_height_fields_idx[loop][0] !== VAL_DEF.BLANK_FIELD_INDEX && (typeof me.auto_height_fields_idx[loop][0] !== 'object')) {
                        data_field = data_details[me.auto_height_fields_idx[loop][0]];
                    }
                    else {
                        if (map_data_field) {
                            data_field = map_data_field.data_field;
                        }
                    }
                    if (data_field) {
                        let value = JpcFieldHelper.getValue(data_field, theRecIdx);
                        let area = JpcAreaHelper.outputArea(tab_field.area, band, 1, 1, 0, 1, 0, 1, 0, false, false);
                        if (value !== null && value !== undefined) {
                            value = value.replace('\t', '');
                            value = value.replace(reg1, '|').replace(reg2, '|').replace(reg3, '|').replace(reg4, '|');
                        }
                        else {
                            value = '';
                        }
                        JpcFieldHelper.setValue(data_field, theRecIdx, value);
                        let values = value.split('|');
                        if (values.length > rst)
                            rst = values.length;
                        let font = private_get_font(tab_field.font);
                        let chkFontName = '宋体';
                        let chkFontHeight = 12;
                        if (font) {
                            chkFontName = font[VAL_DEF.FONT_PROPS[0]];
                            chkFontHeight = font[VAL_DEF.FONT_PROPS[VAL_DEF.FONT_PROP_IDX_HEIGHT]];
                        }
                        let hasSplitStr = false, splitStrArr = [];
                        let accAmt = 0;
                        // let chnW = doc.widthOfString('一'), otherW = doc.widthOfString('_');
                        let chnW = fontWidthMap.getFontWidth(chkFontName, chkFontHeight, '宽'), otherW = fontWidthMap.getFontWidth(chkFontName, chkFontHeight, '窄');
                        for (let i = 0; i < values.length; i++) {
                            let amt = JpcCommonHelper.getStringLinesInArea(area, values[i], chnW, otherW);
                            accAmt += amt;
                            if (amt > 1) {
                                hasSplitStr = true;
                                splitStrArr.push(i);
                            }
                        }
                        if (accAmt > rst)
                            rst = accAmt;
                        if (hasSplitStr) {
                            let newValArr = [];
                            for (let i = 0; i < values.length; i++) {
                                if (splitStrArr.indexOf(i) < 0) {
                                    newValArr.push(values[i]);
                                }
                                else {
                                    newValArr = newValArr.concat(JpcCommonHelper.splitString(area, values[i], chnW, otherW));
                                }
                            }
                            JpcFieldHelper.setValue(data_field, theRecIdx, newValArr.join('|'));
                            splitStrArr = [];
                            newValArr = [];
                        }
                        //备注： 如果outputType是excel类型，那么就只保留原始的分行符，无需介入分行，由excel本身去处理分行，只需要保留足够的空间即可。
                        //      根据最新需求，暂时不考虑excel类型输出,换回原来逻辑
                    }
                }
                return rst;
            };
            for (let tabField of tab_fields) {
                if (adHocAutoHeightStyleStr.indexOf(tabField.style) < 0) {
                    adHocAutoHeightStyleStr.push(tabField.style);
                }
            }
            if (adHocAutoHeightStyleStr.length > 0) {
                if (!(rptTpl.style_collection)) {
                    rptTpl.style_collection = [];
                }
                for (let styleStr of adHocAutoHeightStyleStr) {
                    let adHocStyle1 = { "ID": styleStr + "_AutoHeightMerge_Top" };
                    let adHocStyle2 = { "ID": styleStr + "_AutoHeightMerge_Middle" };
                    let adHocStyle3 = { "ID": styleStr + "_AutoHeightMerge_Bottom" };
                    rptTpl.style_collection.push(adHocStyle1);
                    rptTpl.style_collection.push(adHocStyle2);
                    rptTpl.style_collection.push(adHocStyle3);
                }
            }
            //这里先记录下来每一Segment里的每一条record占用行的数量（普通是1行高度，超过1就表示需要调整行数了）
            let infoArr = [];
            me.auto_height_info.push(infoArr);
            let segArr = me.segments[segIdx];
            for (let i = 0; i < segArr.length; i++) {
                infoArr.push(private_get_max_lines_of_the_record(segArr[i]));
            }
        }
    }
    ;
    preSetupPages(rptTpl, dataObj, defProperties, option, $CURRENT_RPT, followTabEx) {
        //换一种思路来整理流水式数据
        let me = this, rst = 1, counterRowRec = 0, counterRowRecEx = 0, maxRowRec = 1, pageIdx = 0, currentRecAmt = 0;
        me.paging_option = option || VAL_DEF.PAGING_OPTION_NORMAL;
        let current_flow_info = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, current_flow_info.流水式表_数据.flow_field_s, null, me.disp_fields_idx, me.isEx);
        if (followTabEx) {
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl.流水式表_拓展信息.流水式表_数据.flow_field_s, null, me.disp_fields_ex_idx, true);
        }
        //根据实际情况，统计前要先根据format整理好小数位数，否则会出现显示的数据的累计与最后统计的结果不一致
        me.setupGroupingData(rptTpl, dataObj, $CURRENT_RPT);
        if (followTabEx) {
            followTabEx.setupGroupingData(rptTpl, dataObj, $CURRENT_RPT);
        }
        me.sumSeg(dataObj, $CURRENT_RPT); //考虑到实际会有离散指标的汇总，这些离散指标数据是通过计算式后得来的，这种情况下，不适宜在sorting阶段进行汇总统计，现统一挪到这里处理
        const bands = JpcBand.createNew(rptTpl, defProperties);
        if (me.paging_option === VAL_DEF.PAGING_OPTION_INFINITY) {
            rst = me.segments.length;
            const pageStatus = [true, true, false, true, true, true, true, true];
            const grpPageInfo = {};
            let pageIdx = 0;
            for (let segIdx = 0; segIdx < me.segments.length; segIdx++) {
                // 备注：有break flow的情况下 连续输出 要考虑段(seg)的多页输出问题
                if (segIdx === me.segments.length - 1) {
                    pageStatus[VAL_DEF.STATUS_REPORT_END] = true;
                }
                if (segIdx > 0) {
                    pageStatus[VAL_DEF.STATUS_REPORT_START] = false;
                }
                const grpSeqInfo = (me.group_node_info) ? me.group_node_info[segIdx] : null;
                const grpRecAmt = (grpSeqInfo) ? (grpSeqInfo.length * me.group_lines_amt) : 0;
                grpPageInfo.segGrpRecStartIdx = 0;
                grpPageInfo.insertedGrpRecAmt = 0;
                grpPageInfo.preAddPageGrpInfo = [];
                grpPageInfo.group_lines_amt = me.group_lines_amt;
                JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, !me.isEx, me.isEx);
                maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, me.isEx);
                me.setupAutoHeightData(bands, segIdx, rptTpl, dataObj, $CURRENT_RPT, defProperties);
                let adHocAutoHeightAmt = 0;
                if (me.auto_height_info.length > 0) {
                    for (let loop = 0; loop < me.auto_height_info[segIdx].length; loop++) {
                        adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                    }
                }
                me.pageStatusLst.push(pageStatus.slice(0));
                pageIdx++;
                const rowAmt = Math.max(maxRowRec, me.segments[segIdx].length + adHocAutoHeightAmt);
                _addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, 0, rowAmt, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, 0);
            }
            //目前不支持flowTabEx
        }
        else {
            let bands = JpcBand.createNew(rptTpl, defProperties);
            let pageStatus = [true, true, false, true, false, false, false, false];
            if (me.isEx) {
                pageStatus[VAL_DEF.STATUS_REPORT_START] = false;
            }
            if (current_flow_info.多列显示数量) {
                me.multiCols = 1 * current_flow_info.多列显示数量;
            }
            let grpPageInfo = {};
            let prePageLeftAutoHeightRecAmt = 0; //考虑自动行高的跨页情况
            function private_resetBandArea() {
                JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, !me.isEx, me.isEx);
                maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, me.isEx);
            }
            let handledRowAmt = 0; //handledRowAmt纪录的是真正处理过的显示行数，包含了空白行，主要是为分页用（自动行高）
            let segRestRecAmt = 0; //一般情况下为0，只有在特殊情况下才需要，如09-x表中，正常流水一页显示不了的时候，就有大问题了
            function private_addPage(segIdx, grpSeqInfo, isFollow, isMix, mixSplitPoint) {
                private_resetBandArea();
                me.pageStatusLst.push(pageStatus.slice(0));
                currentRecAmt += maxRowRec; //在自动行高的场景下，currentRecAmt在后面还需要调整
                handledRowAmt += maxRowRec;
                let redundantRecAmt = 0;
                pageIdx++;
                function private_chk_handle_rec_amt(dv, isEx) {
                    if ((dv[1] === VAL_DEF.DISPLAY_VAL_TYPE_NORMAL) || (dv[1] === VAL_DEF.DISPLAY_VAL_TYPE_AUTO_HEIGHT && dv[3] === dv[4] - 1)) {
                        if (isEx) {
                            counterRowRecEx++;
                        }
                        else
                            counterRowRec++;
                    }
                    else if (dv[1] === VAL_DEF.DISPLAY_VAL_TYPE_AUTO_HEIGHT) {
                        redundantRecAmt++;
                    }
                }
                let restRecAmt = 0;
                if (isMix) {
                    //先处理上半部分
                    prePageLeftAutoHeightRecAmt = _addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, counterRowRec, mixSplitPoint, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, prePageLeftAutoHeightRecAmt);
                    for (let dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, false);
                    }
                    //再处理下半部分
                    restRecAmt = maxRowRec - me.dispValueIdxLst[me.dispValueIdxLst.length - 1].length; //备注：在一些极端条件下，mixSplitPoint这个分割点不合适处理下半部分数据，以实际生成的value-index数量为准
                    _addPageValue(me.dispValueIdxLst, followTabEx.segments[segIdx], null, counterRowRecEx, restRecAmt, me.page_seg_map, segIdx, pageIdx, null, true, null, 0);
                    for (let dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, true);
                    }
                    //合并到一页中
                    me.page_seg_map.splice(me.page_seg_map.length - 1, 1);
                    let vl = me.dispValueIdxLst[me.dispValueIdxLst.length - 2];
                    for (let item of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        vl.push(item);
                    }
                    me.dispValueIdxLst.splice(me.dispValueIdxLst.length - 1, 1);
                }
                else if (isFollow) {
                    prePageLeftAutoHeightRecAmt = _addPageValue(me.dispValueIdxLst, followTabEx.segments[segIdx], null, counterRowRecEx, maxRowRec, me.page_seg_map, segIdx, pageIdx, null, true, null, 0);
                    for (let dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, true);
                    }
                }
                else {
                    prePageLeftAutoHeightRecAmt = _addPageValue(me.dispValueIdxLst, me.segments[segIdx], grpSeqInfo, counterRowRec, maxRowRec, me.page_seg_map, segIdx, pageIdx, grpPageInfo, false, me.auto_height_info, prePageLeftAutoHeightRecAmt);
                    for (let dv of me.dispValueIdxLst[me.dispValueIdxLst.length - 1]) {
                        private_chk_handle_rec_amt(dv, false);
                    }
                }
                currentRecAmt -= redundantRecAmt; //在自动行高调整场景下，需要减去冗余的数量
                if (restRecAmt < 0) {
                    currentRecAmt -= restRecAmt;
                    segRestRecAmt = restRecAmt;
                }
            }
            for (let segIdx = 0; segIdx < me.segments.length; segIdx++) {
                let grpSeqInfo = (me.group_node_info) ? me.group_node_info[segIdx] : null;
                let grpRecAmt = (grpSeqInfo) ? (grpSeqInfo.length * me.group_lines_amt) : 0;
                let grpRecAmtEx = 0;
                let accAutoHeightAmt = 0; //累计的自动行高数量
                handledRowAmt = 0; //初始化每一段的已处理纪录行数
                segRestRecAmt = 0;
                if (followTabEx && followTabEx.group_node_info) {
                    grpRecAmtEx = followTabEx.group_node_info.length * followTabEx.group_lines_amt;
                }
                grpPageInfo.segGrpRecStartIdx = 0;
                grpPageInfo.insertedGrpRecAmt = 0;
                grpPageInfo.preAddPageGrpInfo = [];
                grpPageInfo.group_lines_amt = me.group_lines_amt;
                pageStatus[VAL_DEF.STATUS_SEGMENT_START] = true;
                private_resetBandArea();
                me.setupAutoHeightData(bands, segIdx, rptTpl, dataObj, $CURRENT_RPT, defProperties);
                let threshold = 0;
                currentRecAmt = 0;
                counterRowRec = 0;
                counterRowRecEx = 0;
                let ttlSegRecAmtNormal = me.segments[segIdx].length + grpRecAmt; //正常的segment下的数据长度累计(含grouping data)
                let ttlSegRecAmt = (followTabEx) ? (me.segments[segIdx].length + grpRecAmt + followTabEx.segments[segIdx].length + grpRecAmtEx) : (me.segments[segIdx].length + grpRecAmt); //所有的segment下的数据长度累计(包括ex部分)
                let adHocAutoHeightAmt = 0;
                let exBuffer = 0;
                let adHocAutoHeightGrpStartIdx = 0;
                if (me.auto_height_fields_idx.length > 0) {
                    for (let loop = 0; loop < me.auto_height_info[segIdx].length; loop++) {
                        adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                        if (me.group_node_info && me.group_node_info[segIdx]) {
                            if (me.group_node_info[segIdx][adHocAutoHeightGrpStartIdx] === loop) {
                                adHocAutoHeightGrpStartIdx++;
                            }
                        }
                    }
                    ttlSegRecAmtNormal += adHocAutoHeightAmt;
                    ttlSegRecAmt += adHocAutoHeightAmt;
                    if (adHocAutoHeightAmt > 0)
                        exBuffer = grpRecAmt;
                }
                //自动行高调整在多流水合并方式时，只支持前部分(后期需要再加)
                while (true) {
                    if (currentRecAmt > 0)
                        pageStatus[VAL_DEF.STATUS_SEGMENT_START] = false;
                    if (pageIdx > 0)
                        pageStatus[VAL_DEF.STATUS_REPORT_START] = false;
                    private_resetBandArea(); // 这里得预先算maxRowRec（实际数据情况，会有章首页框，在章数据多的情况下，章第二页开始就得补上章首页框不显示遗留下来的row）
                    //开始判断各种scenarios
                    adHocAutoHeightAmt = 0;
                    if (me.auto_height_fields_idx.length > 0) {
                        adHocAutoHeightAmt -= prePageLeftAutoHeightRecAmt;
                        //for (let loop = currentRecAmt; loop < me.auto_height_info[segIdx].length; loop++) {
                        for (let loop = currentRecAmt; loop < currentRecAmt + maxRowRec; loop++) {
                            if (me.auto_height_info[segIdx].length > loop) {
                                adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                            }
                            else {
                                break;
                            }
                        }
                    }
                    if ((ttlSegRecAmtNormal < ttlSegRecAmt) || (followTabEx !== null)) {
                        //有流水拓展，并且是follow mode
                        if (currentRecAmt + accAutoHeightAmt + exBuffer + maxRowRec > ttlSegRecAmtNormal) {
                            // if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt + maxRowRec > ttlSegRecAmtNormal) {
                            // if (currentRecAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                            if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                                //纯 followTabEx 数据
                                // if (currentRecAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                    pageStatus[VAL_DEF.STATUS_SEGMENT_END] = true;
                                    private_resetBandArea();
                                    let hasAdHocRow = !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, currentRecAmt + adHocAutoHeightAmt, maxRowRec, me.isEx);
                                    if (hasAdHocRow) {
                                        //add page info(pre segment end)
                                        pageStatus[VAL_DEF.STATUS_SEGMENT_END] = false;
                                        private_addPage(segIdx, null, true, false, -1);
                                    }
                                    //add page info
                                    pageStatus[VAL_DEF.STATUS_SEGMENT_END] = true;
                                    private_addPage(segIdx, null, true, false, -1);
                                }
                                else {
                                    private_addPage(segIdx, null, true, false, -1);
                                }
                            }
                            else {
                                //混合数据
                                // if (currentRecAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt + maxRowRec >= ttlSegRecAmt) {
                                    pageStatus[VAL_DEF.STATUS_SEGMENT_END] = true;
                                    private_resetBandArea();
                                    let hasAdHocRow = !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, currentRecAmt + adHocAutoHeightAmt, maxRowRec, me.isEx);
                                    if (hasAdHocRow) {
                                        //add page info(pre segment end)
                                        pageStatus[VAL_DEF.STATUS_SEGMENT_END] = false;
                                        private_addPage(segIdx, grpSeqInfo, false, true, ttlSegRecAmtNormal);
                                    }
                                    //add page info
                                    pageStatus[VAL_DEF.STATUS_SEGMENT_END] = true;
                                    // if (currentRecAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                                    if (currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt >= ttlSegRecAmtNormal) {
                                        //纯 followTabEx 数据啦
                                        private_addPage(segIdx, null, true, false, -1);
                                    }
                                    else {
                                        private_addPage(segIdx, grpSeqInfo, false, true, ttlSegRecAmtNormal);
                                    }
                                }
                                else {
                                    //在这里要考虑如果有多页正常的流水数据情况，那么就得考虑这页有多少条普通流水记录，不应该一刀切地用ttlSegRecAmtNormal
                                    let splitPoint = ttlSegRecAmtNormal - handledRowAmt;
                                    // if (splitPoint > (exBuffer + maxRowRec)) {
                                    //     splitPoint = splitPoint % (exBuffer + maxRowRec);
                                    // }
                                    private_addPage(segIdx, grpSeqInfo, false, true, splitPoint);
                                }
                            }
                        }
                        else {
                            //纯followTab数据
                            private_addPage(segIdx, grpSeqInfo, false, false, -1);
                        }
                    }
                    else {
                        //普通流水数据情况
                        if (handledRowAmt + maxRowRec >= ttlSegRecAmt) {
                            //备注： 理论上自动行高是没有上限的，有可能正常一页的数据可以拓展到3页及以上，在此极端情况下，必须做一些限制判断，否则会出现缺页情况。
                            // 2018-08-04 其实之前的判断逻辑完全是自找麻烦，而且还不够正确。其实只需要判断已经处理了多少行纪录(所有的都算，包括空白行)，
                            // 与总的seg纪录数想比较，就很容易得到结果，而且能处理极端边界的情况。
                            pageStatus[VAL_DEF.STATUS_SEGMENT_END] = true;
                            // pageStatus[JV.STATUS_REPORT_END] = true;
                            pageStatus[VAL_DEF.STATUS_REPORT_END] = (segIdx === me.segments.length - 1);
                            private_resetBandArea();
                            let hasAdHocRow = ((adHocAutoHeightAmt > maxRowRec) || !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, handledRowAmt, maxRowRec, me.isEx));
                            // !JpcFlowTabHelper.chkSegEnd(bands, rptTpl, ttlSegRecAmt, currentRecAmt + adHocAutoHeightAmt, maxRowRec, me.isEx));
                            if (hasAdHocRow) {
                                //add page info(pre segment end)
                                pageStatus[VAL_DEF.STATUS_SEGMENT_END] = false;
                                pageStatus[VAL_DEF.STATUS_REPORT_END] = false;
                                private_addPage(segIdx, grpSeqInfo, false, false, -1);
                                pageStatus[VAL_DEF.STATUS_REPORT_START] = false;
                                pageStatus[VAL_DEF.STATUS_SEGMENT_START] = false;
                            }
                            //add page info
                            pageStatus[VAL_DEF.STATUS_SEGMENT_END] = true;
                            pageStatus[VAL_DEF.STATUS_REPORT_END] = (segIdx === me.segments.length - 1);
                            private_addPage(segIdx, grpSeqInfo, false, false, -1);
                            pageStatus[VAL_DEF.STATUS_SEGMENT_END] = false; // 加完章统计页后，记得把章尾页设置为false
                        }
                        else {
                            private_addPage(segIdx, grpSeqInfo, false, false, -1);
                        }
                    }
                    //检测是否可退出
                    // if ((currentRecAmt + accAutoHeightAmt + adHocAutoHeightAmt >= ttlSegRecAmt) && (pageIdx % me.multiCols === 0)) {
                    if (handledRowAmt >= (ttlSegRecAmt + segRestRecAmt) && (pageIdx % me.multiCols === 0)) {
                        //备注：这里必须得考虑多栏的情况，否则会造成pageStatus出界的问题
                        break;
                    }
                    accAutoHeightAmt += adHocAutoHeightAmt;
                    //控制阈值，超过阈值则强制退出，防止死循环
                    threshold++;
                    if (threshold > 1000) {
                        console.log("Hey! There may be a dead loop here!!!");
                        break;
                    }
                }
            }
            // console.log(me.auto_height_info);
            // console.log(me.dispValueIdxLst);
            rst = Math.ceil(pageIdx / me.multiCols);
        }
        me.pagesAmt = rst;
        return rst;
    }
    ;
    outputAsPreviewPage(rptTpl, bands, controls, $CURRENT_RPT) {
        let me = this, rst = [];
        //只预览第一页的数据
        let pageStatus = [true, true, true, true, true, true, true, true];
        me.pageStatusLst.push(pageStatus);
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl.流水式表_信息.流水式表_数据.flow_field_s, null, me.disp_fields_idx, false);
        JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, true, false);
        let maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, false);
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        // 2.2 Column tab
        rst = rst.concat(me.outputColumn(rptTpl, null, 1, 0, bands, unitFactor, 0, $CURRENT_RPT, null));
        // 2.1 Content-Tab
        rst = rst.concat(me.outputPreviewContent(rptTpl, bands, unitFactor, controls, pageStatus, maxRowRec));
        // 2.3 Sum Seg
        rst = rst.concat(me.outputPreviewSegSum(rptTpl, bands, unitFactor, controls, pageStatus));
        // 2.4 Sum Page
        rst = rst.concat(me.outputPreviewPageSum(rptTpl, bands, unitFactor, controls, pageStatus));
        // 2.5 Group
        // 2.6 Discrete
        rst = rst.concat(JpcDiscreteHelper.outputPreviewDiscreteInfo(rptTpl.流水式表_信息.离散信息, bands, unitFactor, pageStatus));
        return rst;
    }
    ;
    outputPreviewContent(rptTpl, bands, unitFactor, controls, pageStatus, maxRec) {
        let me = this, rst = [];
        let tab = rptTpl.流水式表_信息.流水式表_数据;
        let band = bands[tab.BandName];
        if (band) {
            if (pageStatus[(band.DisplayType)]) {
                let tab_fields = tab.flow_field_s;
                for (let rowIdx = 0; rowIdx < maxRec; rowIdx++) {
                    for (let i = 0; i < tab_fields.length; i++) {
                        let tab_field = tab_fields[i];
                        if (!(tab_field.Hidden)) {
                            rst.push(me.outputTabField(band, tab_field, null, -1, -1, maxRec, rowIdx, 1, 0, unitFactor, false, controls, 0));
                        }
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputPreviewSegSum(rptTpl, bands, unitFactor, controls, pageStatus) {
        let rst = [];
        let tab = rptTpl.流水式表_信息.流水式表_段统计信息;
        let band = bands[tab.BandName];
        if (band) {
            if (pageStatus[(band.DisplayType)]) {
                rst = rst.concat(JpcDiscreteHelper.outputPreviewSumInfoOutput(band, unitFactor, tab));
            }
        }
        return rst;
    }
    ;
    outputPreviewPageSum(rptTpl, bands, unitFactor, controls, pageStatus) {
        let rst = [];
        let tab = rptTpl.流水式表_信息.流水式表_页统计信息;
        let band = bands[tab.BandName];
        if (band) {
            if (pageStatus[(band.DisplayType)]) {
                rst = rst.concat(JpcDiscreteHelper.outputPreviewSumInfoOutput(band, unitFactor, tab));
            }
        }
        return rst;
    }
    ;
    outputAsSimpleJSONPage(rptTpl, dataObj, page, bands, controls, adHocMergePos, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], tabRstLst = [];
        // let FLOW_NODE_STR = me.isEx?'流水式表_拓展信息':'流水式表_信息';
        let flow_node_str = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        if (me.paging_option === "infinity") {
            const segIdx = page - 1;
            // 1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1], !me.isEx, me.isEx);
            const maxRowRec = JpcFlowTabHelper.getMaxRowsPerPage(bands, rptTpl, me.isEx);
            // 2. then reset the band height
            const tab = rptTpl.流水式表_信息.流水式表_数据;
            const flowContentBand = bands[tab.BandName];
            let adHocAutoHeightAmt = 0;
            if (me.auto_height_info.length > 0) {
                for (let loop = 0; loop < me.auto_height_info[segIdx].length; loop++) {
                    adHocAutoHeightAmt += (me.auto_height_info[segIdx][loop] - 1);
                }
            }
            const rowAmt = Math.max(maxRowRec, me.segments[segIdx].length + adHocAutoHeightAmt); // 如不满一页，则需要填充满一页
            const actH = JpcFlowTabHelper.getActualContentAreaHeight(bands, rptTpl, me.segments, rowAmt, page, me.isEx);
            const offsetY = actH - (flowContentBand.Bottom - flowContentBand.Top);
            JpcBandHelper.resetBandPos(rptTpl.布局框_集合, bands, flowContentBand, 0, offsetY);
            // 2.1 Content-Tab
            tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, 0, $CURRENT_RPT, customizeCfg));
            // 2.2 Column tab
            tabRstLst.push(me.outputColumn(rptTpl, dataObj, page, segIdx, bands, unitFactor, 0, $CURRENT_RPT, customizeCfg));
            // 2.3 Sum Seg
            tabRstLst.push(me.outputSegSum(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            // 2.4 Sum Page
            tabRstLst.push(me.outputPageSum(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            // 2.5 Group
            // 2.6 Discrete
            tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(flow_node_str.离散信息, bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 1, 0, $CURRENT_RPT, customizeCfg));
            // 3. reset merge band position
            if (bands.MergeBand && adHocMergePos) {
                const mergedBand = bands.MergeBand;
                let arr = [];
                arr.push(parseInt(mergedBand.Left.toFixed(0)));
                adHocMergePos.Left = arr;
                arr = [];
                arr.push(parseInt(mergedBand.Right.toFixed(0)));
                adHocMergePos.Right = arr;
                arr = [];
                arr.push(parseInt(mergedBand.Top.toFixed(0)));
                adHocMergePos.Top = arr;
                arr = [];
                arr.push(parseInt((mergedBand.Bottom).toFixed(0)));
                adHocMergePos.Bottom = arr;
            }
        }
        else {
            let segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            //1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1], !me.isEx, me.isEx);
            //2. start to output detail-part
            for (let pi = 0; pi < me.multiCols; pi++) {
                let actualPage = (page - 1) * me.multiCols + pi + 1;
                // 2.1 Content-Tab
                tabRstLst.push(me.outputContent(rptTpl, dataObj, actualPage, bands, unitFactor, controls, pi, $CURRENT_RPT, customizeCfg));
                // 2.2 Column tab
                tabRstLst.push(me.outputColumn(rptTpl, dataObj, actualPage, segIdx, bands, unitFactor, pi, $CURRENT_RPT, customizeCfg));
                // 2.3 Sum Seg
                tabRstLst.push(me.outputSegSum(rptTpl, dataObj, actualPage, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
                // 2.4 Sum Page
                tabRstLst.push(me.outputPageSum(rptTpl, dataObj, actualPage, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
                // 2.5 Group
                // 2.6 Discrete
                if (pi === 0) {
                    tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(flow_node_str.离散信息, bands, dataObj, unitFactor, me.pageStatusLst[actualPage - 1], segIdx, 1, pi, $CURRENT_RPT, customizeCfg));
                }
            }
        }
        for (let i = 0; i < tabRstLst.length; i++) {
            rst = rst.concat(tabRstLst[i]);
            tabRstLst[i] = null;
        }
        return rst;
    }
    ;
    outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, multiColIdx, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], prepareObj = {};
        // let FLOW_NODE_STR = me.isEx?'流水式表_拓展信息':'流水式表_信息';
        let flow_node_str = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        let tab = flow_node_str.流水式表_数据;
        let tabEx = (rptTpl.流水式表_拓展信息) ? rptTpl.流水式表_拓展信息.流水式表_数据 : null;
        let verticalCombinePos = [], horizonCombinePos = []; //合并特性用
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)]) {
                let tab_fields = tab.flow_field_s;
                let tab_fields_ex = tabEx ? tabEx.flow_field_s : null;
                let data_details = me.isEx ? dataObj.detail_data_ex : dataObj.detail_data;
                let data_details_ex = $CURRENT_RPT.isFollowMode ? dataObj.detail_data_ex : null;
                let contentValuesIdx = me.dispValueIdxLst[page - 1];
                let page_sum_data_fields = [];
                for (let i = 0; i < me.page_sum_fields_idx.length; i++) {
                    if (typeof (me.page_sum_fields_idx[i]) === "object") {
                        let exField = JE.F(me.page_sum_fields_idx[i][VAL_DEF.PROP_ID], $CURRENT_RPT);
                        if (exField) {
                            page_sum_data_fields.push(exField.data_field);
                        }
                        else {
                            page_sum_data_fields.push(null);
                        }
                    }
                    else {
                        let data_field = data_details[me.page_sum_fields_idx[i]];
                        page_sum_data_fields.push(data_field);
                    }
                }
                let rowGrandTotal = [];
                for (let di = 0; di < page_sum_data_fields.length; di++) {
                    rowGrandTotal.push(0.0);
                }
                //normal content
                let flexiblePrecisionRefObj = null, flexibleRefField = null, precision_ref_data = null;
                for (let rowIdx = 0; rowIdx < contentValuesIdx.length; rowIdx++) {
                    for (let fieldIdx = 0; fieldIdx < tab_fields.length; fieldIdx++) {
                        let tab_field = tab_fields[fieldIdx];
                        let data_field = null, map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                        if (me.disp_fields_idx[fieldIdx] !== VAL_DEF.BLANK_FIELD_INDEX && (typeof me.disp_fields_idx[fieldIdx] !== 'object')) {
                            data_field = data_details[me.disp_fields_idx[fieldIdx]];
                        }
                        else {
                            if (map_data_field) {
                                data_field = map_data_field.data_field;
                            }
                        }
                        if (map_data_field && map_data_field.Precision && map_data_field.flexiblePrecisionRefObj) {
                            if (flexiblePrecisionRefObj === null) {
                                flexiblePrecisionRefObj = {};
                                if (map_data_field.Precision.flexibleRefFieldID)
                                    flexibleRefField = JE.F(map_data_field.Precision.flexibleRefFieldID, $CURRENT_RPT);
                                if (flexibleRefField)
                                    precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                for (let decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                    flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                                }
                            }
                            JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, contentValuesIdx[rowIdx][2], customizeCfg);
                        }
                        else {
                            if (rowIdx === 0)
                                JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                        }
                        if (!(tab_field.Hidden)) {
                            if (contentValuesIdx[rowIdx][0] !== VAL_DEF.TYPE_FOLLOW_MODE && contentValuesIdx[rowIdx][1] === VAL_DEF.DISPLAY_VAL_TYPE_NORMAL) {
                                rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][2], -1, contentValuesIdx.length, rowIdx, 1, 0, unitFactor, false, controls, multiColIdx));
                            }
                            else if (contentValuesIdx[rowIdx][1] === VAL_DEF.DISPLAY_VAL_TYPE_AUTO_HEIGHT) {
                                if (contentValuesIdx[rowIdx][4] === 1) {
                                    //等效于普通输出
                                    rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][2], -1, contentValuesIdx.length, rowIdx, 1, 0, unitFactor, false, controls, multiColIdx));
                                }
                                else {
                                    //这里需要做些style调整(中间的那些横杠线去掉)
                                    let cellItem = me.outputAutoHeightTabField(band, tab_field, data_field, contentValuesIdx[rowIdx], contentValuesIdx.length, rowIdx, 1, 0, unitFactor, true, controls, multiColIdx);
                                    rst.push(cellItem);
                                    if (contentValuesIdx[rowIdx][3] === 0 || rowIdx === 0) {
                                        cellItem.style = cellItem.style + '_AutoHeightMerge_Top';
                                    }
                                    else if (contentValuesIdx[rowIdx][3] === contentValuesIdx[rowIdx][4] - 1) {
                                        cellItem.style = cellItem.style + '_AutoHeightMerge_Bottom';
                                    }
                                    else {
                                        cellItem.style = cellItem.style + '_AutoHeightMerge_Middle';
                                    }
                                    prepareAutoHeightCells(prepareObj, cellItem, rst.length - 1, rst);
                                }
                            }
                        }
                        if (rowIdx === 0 && tab_field.combineType !== undefined && tab_field.combineType !== null) {
                            let rstCellItem = rst[rst.length - 1];
                            let cbfPos = [];
                            cbfPos.push(rstCellItem.area.Left);
                            cbfPos.push(rstCellItem.area.Left);
                            if (tab_field.combineType === 'vertical') {
                                verticalCombinePos.push(cbfPos);
                            }
                            else if (tab_field.combineType === 'horizon') {
                                horizonCombinePos.push(cbfPos);
                            }
                        }
                    }
                    if (tab_fields_ex && contentValuesIdx[rowIdx][0] === 1) {
                        for (let idx_ex = 0; idx_ex < tab_fields_ex.length; idx_ex++) {
                            let tab_fieldex = tab_fields_ex[idx_ex];
                            let data_fieldex = null, map_data_fieldex = JE.F(tab_fieldex.FieldID, $CURRENT_RPT);
                            if (data_details_ex && me.disp_fields_ex_idx[idx_ex] !== VAL_DEF.BLANK_FIELD_INDEX && (typeof me.disp_fields_ex_idx[idx_ex] !== 'object')) {
                                data_fieldex = data_details_ex[me.disp_fields_ex_idx[idx_ex]];
                            }
                            else {
                                if (map_data_fieldex) {
                                    data_fieldex = map_data_fieldex.data_field;
                                }
                            }
                            if (map_data_fieldex && map_data_fieldex.Precision && map_data_fieldex.flexiblePrecisionRefObj) {
                                if (flexiblePrecisionRefObj === null) {
                                    flexiblePrecisionRefObj = {};
                                    if (map_data_fieldex.Precision.flexibleRefFieldID)
                                        flexibleRefField = JE.F(map_data_fieldex.Precision.flexibleRefFieldID, $CURRENT_RPT);
                                    for (let decimalObj of map_data_fieldex.flexiblePrecisionRefObj) {
                                        flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                                    }
                                }
                                JpcFieldHelper.resetFlexibleFormat(tab_fieldex, flexibleRefField, flexiblePrecisionRefObj, contentValuesIdx[rowIdx][2], customizeCfg);
                            }
                            else {
                                if (rowIdx === 0)
                                    JpcFieldHelper.resetFormat(tab_fieldex, map_data_fieldex, customizeCfg);
                            }
                            if (!(tab_fieldex.Hidden)) {
                                if (contentValuesIdx[rowIdx][0] === 1 && contentValuesIdx[rowIdx][1] === 0) {
                                    rst.push(me.outputTabField(band, tab_fieldex, data_fieldex, contentValuesIdx[rowIdx][2], -1, contentValuesIdx.length, rowIdx, 1, 0, unitFactor, false, controls, multiColIdx));
                                }
                            }
                        }
                    }
                    //page sum content
                    for (let di = 0; di < page_sum_data_fields.length; di++) {
                        if (contentValuesIdx[rowIdx][1] === 0 ||
                            contentValuesIdx[rowIdx][1] === 2 && contentValuesIdx[rowIdx][3] === 0) {
                            let precisionAmt = 4;
                            let sum_field = JE.F(me.page_sum_tab_fields[di].FieldID, $CURRENT_RPT);
                            if (sum_field && sum_field.Precision && sum_field.Precision.type === `fixed`) {
                                precisionAmt = sum_field.fixedPrecisionNum;
                            }
                            else {
                                let flowF = me.page_sum_tab_fields[di];
                                if (flowF && !strUtil.isEmptyString(flowF.Format)) {
                                    let idx = flowF.Format.indexOf('.');
                                    if (idx >= 0) {
                                        precisionAmt = flowF.Format.length - idx - 1;
                                    }
                                }
                            }
                            // rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(page_sum_data_fields[di], contentValuesIdx[rowIdx][2]);
                            if (contentValuesIdx[rowIdx][2] >= 0) {
                                let psv = JpcFieldHelper.getValue(page_sum_data_fields[di], contentValuesIdx[rowIdx][2]);
                                if (psv) {
                                    rowGrandTotal[di] = rowGrandTotal[di] + parseFloat(parseFloat(psv).toFixed(precisionAmt));
                                }
                            }
                        }
                    }
                }
                me.pageSumValLst.push(rowGrandTotal);
                //grouping content
                let grpCntIdx = 0;
                for (let rowIdx = 0; rowIdx < contentValuesIdx.length; rowIdx++) {
                    if (contentValuesIdx[rowIdx][1] === 1) {
                        for (let grpIdx = 0; grpIdx < flow_node_str.流水式表_分组信息.group_lines.length; grpIdx++) {
                            if (contentValuesIdx[rowIdx][3] === grpIdx) {
                                let grp_line = flow_node_str.流水式表_分组信息.group_lines[grpIdx];
                                if (page === 1) {
                                    if (grp_line.SumKey_S && grp_line.SumKey_S.length > 0) {
                                        for (let grp_sum_field of grp_line.SumKey_S) {
                                            if (grp_sum_field.FieldID) {
                                                let map_field = JE.F(grp_sum_field.FieldID, $CURRENT_RPT);
                                                JpcFieldHelper.resetFormat(grp_sum_field, map_field, customizeCfg);
                                            }
                                        }
                                    }
                                }
                                let lineRst = me.outputTabGrpLine(band, grp_line, page, contentValuesIdx[rowIdx], contentValuesIdx.length, rowIdx, 1, 0, unitFactor, true, controls, multiColIdx, grpCntIdx, $CURRENT_RPT);
                                rst = rst.concat(lineRst);
                            }
                        }
                        grpCntIdx++;
                    }
                }
            }
        }
        let eliminateCells = combineAutoHeightCells(prepareObj, page, controls);
        for (let idIdx = eliminateCells.length - 1; idIdx >= 0; idIdx--) {
            rst.splice(eliminateCells[idIdx], 1);
        }
        me.checkCombineEvent(VAL_DEF.RUN_TYPE_BEFORE_COMBINE, verticalCombinePos, horizonCombinePos, rst, $CURRENT_RPT);
        me.combinePageCells(rst, verticalCombinePos, horizonCombinePos);
        me.checkCombineEvent(VAL_DEF.RUN_TYPE_AFTER_COMBINE, verticalCombinePos, horizonCombinePos, rst, $CURRENT_RPT);
        return rst;
    }
    ;
    combinePageCells(rstPageCells, verticalCombinePos, horizonCombinePos) {
        // let me = this;
        //备注：纵向合并要考虑以下因素：
        //     如果有多个column纵向合并，需要总体考虑分割，
        //     假如：第一列的前3个数据(1、2、3)是相同的，第二列中第2、3、4行数据相同，那么第二列只能合并2、3行的数据，不能合并到第四行
        //     同理如此类推第三列...n列
        if (verticalCombinePos.length > 0 || horizonCombinePos.length > 1) {
            let cacheObj = { vCache: {}, hCache: {}, hCacheStr: [] };
            let removeCellIds = [];
            for (let vPosArr of verticalCombinePos) {
                let pStr = "_" + vPosArr[0] + "_" + vPosArr[1];
                cacheObj.vCache[pStr] = [];
            }
            //horizonCombinePos不需要预记
            for (let idx = 0; idx < rstPageCells.length; idx++) {
                let cell = rstPageCells[idx];
                for (let vPosArr of verticalCombinePos) {
                    if (cell.area.Left === vPosArr[0] && cell.area.Right === vPosArr[1]) {
                        cacheObj.vCache["_" + vPosArr[0] + "_" + vPosArr[1]].push(idx);
                    }
                }
                for (let hPosArr of horizonCombinePos) {
                    if (cell.area.Left === hPosArr[0] && cell.area.Right === hPosArr[1]) {
                        let hpStr = "_" + cell.area.Top + "_" + cell.area.Bottom;
                        if (cacheObj.hCacheStr.indexOf(hpStr) < 0) {
                            cacheObj.hCache[hpStr] = [];
                            cacheObj.hCacheStr.push(hpStr);
                        }
                        cacheObj.hCache[hpStr].push(idx);
                    }
                }
            }
            if (verticalCombinePos.length > 0) {
                let preColMergePosArr = []; //见上面备注描述，纪录当前列的分割坐标集合情况
                let private_chk_in_pre_merge = function (preIdx, newCell) {
                    let rst = true;
                    if (preIdx >= 0 && preIdx < preColMergePosArr.length) {
                        for (let mergeArea of preColMergePosArr[preIdx]) {
                            if (newCell.area[VAL_DEF.PROP_TOP] >= mergeArea[0] && newCell.area[VAL_DEF.PROP_TOP] < mergeArea[1]) {
                                rst = (newCell.area.Bottom <= mergeArea[1]);
                                break;
                            }
                        }
                    }
                    return rst;
                };
                for (let vidx = 0; vidx < verticalCombinePos.length; vidx++) {
                    let vPosArr = verticalCombinePos[vidx];
                    let pStr = "_" + vPosArr[0] + "_" + vPosArr[1];
                    //rstPageCells的结果已经是按顺序排列了，这里不用再排序
                    if (cacheObj.vCache[pStr] && cacheObj.vCache[pStr].length > 0) {
                        let preCell = rstPageCells[cacheObj.vCache[pStr][0]];
                        if (vidx === 0) {
                            //这里要处理下
                            let minY = 10000, maxY = 0;
                            for (let preCIdx = 0; preCIdx < cacheObj.vCache[pStr].length; preCIdx++) {
                                if (minY > rstPageCells[cacheObj.vCache[pStr][preCIdx]].area.Top)
                                    minY = rstPageCells[cacheObj.vCache[pStr][preCIdx]].area.Top;
                                if (maxY < rstPageCells[cacheObj.vCache[pStr][preCIdx]].area.Bottom)
                                    maxY = rstPageCells[cacheObj.vCache[pStr][preCIdx]].area.Bottom;
                            }
                            preColMergePosArr.push([[minY, maxY]]);
                        }
                        let dtlColMergePosArr = [];
                        preColMergePosArr.push(dtlColMergePosArr);
                        for (let cIdx = 1; cIdx < cacheObj.vCache[pStr].length; cIdx++) {
                            if (preCell.Value === "") {
                                dtlColMergePosArr.push([preCell.area.Top, preCell.area.Bottom]);
                                preCell = rstPageCells[cacheObj.vCache[pStr][cIdx]];
                            }
                            else {
                                if (preCell.Value === rstPageCells[cacheObj.vCache[pStr][cIdx]].Value) {
                                    let bkBottom = preCell.area.Bottom;
                                    preCell.area.Bottom = rstPageCells[cacheObj.vCache[pStr][cIdx]].area.Bottom;
                                    if (private_chk_in_pre_merge(vidx, preCell)) {
                                        removeCellIds.push(cacheObj.vCache[pStr][cIdx]);
                                        if (cIdx === cacheObj.vCache[pStr].length - 1) {
                                            dtlColMergePosArr.push([preCell.area.Top, preCell.area.Bottom]);
                                        }
                                    }
                                    else {
                                        preCell.area.Bottom = bkBottom;
                                        dtlColMergePosArr.push([preCell.area.Top, preCell.area.Bottom]);
                                        preCell = rstPageCells[cacheObj.vCache[pStr][cIdx]];
                                    }
                                }
                                else {
                                    dtlColMergePosArr.push([preCell.area.Top, preCell.area.Bottom]);
                                    preCell = rstPageCells[cacheObj.vCache[pStr][cIdx]];
                                }
                            }
                        }
                    }
                }
            }
            if (horizonCombinePos.length > 1) {
                if (cacheObj.hCacheStr.length > 0) {
                    for (let hStr of cacheObj.hCacheStr) {
                        let preCell = rstPageCells[cacheObj.hCache[hStr][0]];
                        for (let cIdx = 1; cIdx < cacheObj.hCache[hStr].length; cIdx++) {
                            if (preCell.Value === "") {
                                preCell = rstPageCells[cacheObj.hCache[hStr][cIdx]];
                            }
                            else {
                                if (preCell.Value === rstPageCells[cacheObj.hCache[hStr][cIdx]].Value) {
                                    if (preCell.area.Right < rstPageCells[cacheObj.hCache[hStr][cIdx]].area.Right) {
                                        preCell.area.Right = rstPageCells[cacheObj.hCache[hStr][cIdx]].area.Right;
                                    }
                                    else {
                                        preCell.area.Left = rstPageCells[cacheObj.hCache[hStr][cIdx]].area.Left;
                                    }
                                    removeCellIds.push(cacheObj.hCache[hStr][cIdx]);
                                }
                                else {
                                    preCell = rstPageCells[cacheObj.hCache[hStr][cIdx]];
                                }
                            }
                        }
                    }
                }
            }
            if (removeCellIds.length > 0) {
                //排序，保证一定的顺序，不能用默认的方式(默认方式是针对字符串的简单排序)
                removeCellIds.sort(function (idx1, idx2) {
                    return parseInt(idx1) - parseInt(idx2);
                });
                for (let idx = removeCellIds.length - 1; idx >= 0; idx--) {
                    rstPageCells.splice(removeCellIds[idx], 1);
                }
            }
        }
    }
    ;
    checkCombineEvent($RUN_TYPE, $VER_COMB_ARRAY, $HOR_COMB_ARRAY, $CURRENT_CELL_ITEMS, $CURRENT_RPT) {
        if ($CURRENT_RPT.formulas) {
            for (let execFmlIdx = 0; execFmlIdx < $CURRENT_RPT.formulas.length; execFmlIdx++) {
                if ($CURRENT_RPT.formulas[execFmlIdx].run_type === $RUN_TYPE) {
                    let expression = $CURRENT_RPT.formulas[execFmlIdx].expression;
                    if (expression) {
                        let $ME = $CURRENT_RPT.formulas[execFmlIdx];
                        try {
                            eval(expression);
                        }
                        catch (ex) {
                            console.log(ex);
                        }
                    }
                }
            }
        }
    }
    ;
    outputColumn(rptTpl, dataObj, page, segIdx, bands, unitFactor, multiColIdx, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        // let FLOW_NODE_STR = me.isEx?'流水式表_拓展信息':'流水式表_信息';
        let flow_node_str = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        let tab = flow_node_str.流水式表_列;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)]) {
                rst = rst.concat(me.commonTabRestOutput(dataObj, page, segIdx, bands, band, unitFactor, tab, multiColIdx, $CURRENT_RPT, customizeCfg));
            }
        }
        return rst;
    }
    ;
    outputSegSum(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        // let FLOW_NODE_STR = me.isEx?'流水式表_拓展信息':'流水式表_信息';
        let flow_node_str = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        let tab = flow_node_str.流水式表_段统计信息;
        let refTab = flow_node_str.流水式表_数据;
        let refTabEx = (rptTpl.流水式表_拓展信息) ? rptTpl.流水式表_拓展信息.流水式表_数据 : null;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)]) {
                let ref_tab_fields = refTab.flow_field_s;
                let ref_tab_fields_ex = refTabEx ? refTabEx.flow_field_s : null;
                let tab_fields = me.seg_sum_tab_fields;
                for (let i = 0; i < tab_fields.length; i++) {
                    if (ref_tab_fields_ex && !JpcFieldHelper.resetSumFormat(ref_tab_fields, tab_fields[i])) {
                        if (!JpcFieldHelper.resetSumFormat(ref_tab_fields_ex, tab_fields[i])) {
                            let map_data_field = JE.F(tab_fields[i][VAL_DEF.PROP_FIELD_ID], $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[i], map_data_field, customizeCfg);
                            //如果都找不到，就得靠自己的Format属性了
                        }
                    }
                    let sumVal = 0;
                    if (me.segSumValLst[segIdx] && me.segSumValLst[segIdx].length > i) {
                        sumVal = me.segSumValLst[segIdx][i];
                    }
                    //备注：考虑到有时候会出现没有数据可合计的scenario,得有容错处理
                    let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_fields[i], sumVal, controls);
                    cellItem.area = JpcAreaHelper.outputArea(tab_fields[i].area, band, unitFactor, 1, 0, 1, 0, me.multiCols, 0, false, false);
                    rst.push(cellItem);
                }
                rst = rst.concat(me.commonTabRestOutput(dataObj, page, segIdx, bands, band, unitFactor, tab, 0, $CURRENT_RPT, customizeCfg));
            }
        }
        return rst;
    }
    ;
    outputPageSum(rptTpl, dataObj, page, segIdx, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        // let FLOW_NODE_STR = me.isEx?'流水式表_拓展信息':'流水式表_信息';
        let flow_node_str = me.isEx ? rptTpl.流水式表_拓展信息 : rptTpl.流水式表_信息;
        let tab = flow_node_str.流水式表_页统计信息;
        let refTab = flow_node_str.流水式表_数据;
        let refTabEx = (rptTpl.流水式表_拓展信息) ? rptTpl.流水式表_拓展信息.流水式表_数据 : null;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)]) {
                let ref_tab_fields = refTab.flow_field_s;
                let ref_tab_fields_ex = refTabEx ? refTabEx.flow_field_s : null;
                let tab_fields = me.page_sum_tab_fields;
                for (let i = 0; i < tab_fields.length; i++) {
                    if (!JpcFieldHelper.resetSumFormat(ref_tab_fields, tab_fields[i])) {
                        if (ref_tab_fields_ex && !JpcFieldHelper.resetSumFormat(ref_tab_fields_ex, tab_fields[i])) {
                            let map_data_field = JE.F(tab_fields[i][VAL_DEF.PROP_FIELD_ID], $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[i], map_data_field, customizeCfg);
                            //如果都找不到，就得靠自己的Format属性了
                        }
                    }
                    let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_fields[i], me.pageSumValLst[page - 1][i], controls);
                    cellItem.area = JpcAreaHelper.outputArea(tab_fields[i].area, band, unitFactor, 1, 0, 1, 0, me.multiCols, 0, false, false);
                    rst.push(cellItem);
                }
                rst = rst.concat(me.commonTabRestOutput(dataObj, page, segIdx, bands, band, unitFactor, tab, 0, $CURRENT_RPT, customizeCfg));
            }
        }
        return rst;
    }
    ;
    outputTabField(band, tab_field, data_field, valueIdx, serialIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls, multiColIdx) {
        let me = this, rst = JpcCommonOutputHelper.createCommonOutput(tab_field, JpcFieldHelper.getValue(data_field, valueIdx), controls);
        rst.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx, isRow, false);
        return rst;
    }
    ;
    outputAutoHeightTabField(band, tab_field, data_field, contentValInfo, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls, multiColIdx) {
        let me = this;
        let showText = JpcFieldHelper.getValue(data_field, contentValInfo[2]);
        if (tab_field.isAutoHeight) {
            let textArr = [];
            if (showText) {
                textArr = textArr.concat(showText.split('|'));
            }
            if (contentValInfo[3] < textArr.length && contentValInfo[3] >= 0) {
                showText = textArr[contentValInfo[3]];
            }
            else {
                showText = '';
            }
            let rst = JpcCommonOutputHelper.createCommonOutput(tab_field, showText, controls);
            rst.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx, true, false);
            rst.isAutoHeight = true;
            return rst;
        }
        else {
            if (contentValInfo[3] > 0)
                showText = '';
            let rst = JpcCommonOutputHelper.createCommonOutput(tab_field, showText, controls);
            rst.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx, true, false);
            rst.isAutoHeight = false;
            return rst;
        }
    }
    ;
    outputTabGrpLine(band, grp_line, page, grpValueIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls, multiColIdx, grpCntIdx, $CURRENT_RPT) {
        let me = this, rst = [];
        if (grp_line.SumKey_S) {
            let segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            let curSegGrpSum = me.group_sum_values[segIdx];
            for (let sumFieldNode of grp_line.SumKey_S) {
                // let value = curSegGrpSum[sumFieldNode[JV.PROP_SUM_KEY]][grpValueIdx[2]];
                let value = curSegGrpSum[`grp_sum_key_` + sumFieldNode.FieldID][grpValueIdx[2]];
                let sumFldRst = JpcTextHelper.outputDirectValue(sumFieldNode, value, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx);
                rst.push(sumFldRst);
            }
        }
        if (grp_line.text_s) {
            for (let txt of grp_line.text_s) {
                me.checkGrpTxtOutEvent(VAL_DEF.RUN_TYPE_BEFORE_GROUP_TEXT_OUT, txt, grpCntIdx, $CURRENT_RPT);
                rst.push(JpcTextHelper.outputText(txt, band, unitFactor, rows, rowIdx, cols, colIdx, me.multiCols, multiColIdx));
                // me.combinePageCells(rst, verticalCombinePos, horizonCombinePos);
                // 可能会有一个After，但意义不大，用不着
            }
        }
        if (grp_line.discrete_field_s) ;
        if (grp_line.param_s) ;
        // console.log(rst);
        return rst;
    }
    ;
    //暂定
    checkGrpTxtOutEvent($RUN_TYPE, $TEXT, $TIMES, $CURRENT_RPT) {
        if ($CURRENT_RPT.formulas) {
            for (let execFmlIdx = 0; execFmlIdx < $CURRENT_RPT.formulas.length; execFmlIdx++) {
                if ($CURRENT_RPT.formulas[execFmlIdx].run_type === $RUN_TYPE) {
                    let expression = $CURRENT_RPT.formulas[execFmlIdx].expression;
                    if (expression) {
                        let $ME = $CURRENT_RPT.formulas[execFmlIdx];
                        try {
                            eval(expression);
                        }
                        catch (ex) {
                            console.log(ex);
                        }
                    }
                }
            }
        }
    }
    ;
    commonTabRestOutput(dataObj, page, segIdx, bands, band, unitFactor, tab, multiColIdx, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        if (tab.text) {
            rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, 1, 0, me.multiCols, multiColIdx));
        }
        if (tab.text_s) {
            for (let j = 0; j < tab.text_s.length; j++) {
                rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, 1, 0, me.multiCols, multiColIdx));
            }
        }
        if (tab.离散信息) {
            rst = rst.concat(JpcDiscreteHelper.outputDiscreteInfo(tab.离散信息, bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 1, 0, $CURRENT_RPT, customizeCfg));
        }
        return rst;
    }
    ;
}
function _addPageValue(ValuedIdxLst, sortedSequence, grpSequenceInfo, startRecIdx, maxRecPerPage, page_seg_map, segIdx, pageIdx, grpPageInfo, isFollow, segAutoHeightInfo, prePageLeftAutoHeightRecAmt) {
    let vIdx = [], vFirstIdx = [], preAmt = 0, insertedGrpAmt = 0, grp_lines = 0, followMode = (isFollow) ? VAL_DEF.TYPE_FOLLOW_MODE : -1, nextPageAutoHeightRecAmt = 0;
    if (grpSequenceInfo && grpPageInfo) {
        if (grpPageInfo.preAddPageGrpInfo.length > 0) {
            for (let grpLineIdx of grpPageInfo.preAddPageGrpInfo) {
                //vIdx.push([followMode, JV.DISPLAY_VAL_TYPE_GROUP, grpPageInfo.segGrpRecStartIdx, grpLineIdx]);
                vFirstIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_GROUP, grpPageInfo.segGrpRecStartIdx, grpLineIdx]);
            }
            grpPageInfo.segGrpRecStartIdx++;
        }
        preAmt = grpPageInfo.preAddPageGrpInfo.length;
        grpPageInfo.preAddPageGrpInfo = [];
        grp_lines = grpPageInfo.group_lines_amt;
    }
    let autoHeightAmt = 0;
    let private_addAutoHeightPageValue = function (vi) {
        let couldBreak = false, startIdx = 0;
        let ttlValAmt = 0;
        if (segAutoHeightInfo && [segIdx].length > startRecIdx + vi) {
            ttlValAmt = segAutoHeightInfo[segIdx][startRecIdx + vi];
        }
        if (prePageLeftAutoHeightRecAmt > 0 && vi === 0) {
            startIdx = prePageLeftAutoHeightRecAmt;
        }
        for (let subValIdx = startIdx; subValIdx < ttlValAmt; subValIdx++) {
            vIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_AUTO_HEIGHT, sortedSequence[startRecIdx + vi], subValIdx, ttlValAmt]);
            autoHeightAmt++;
            if (autoHeightAmt >= maxRecPerPage) {
                nextPageAutoHeightRecAmt = (subValIdx + 1) % ttlValAmt;
                couldBreak = true;
                break;
            }
        }
        return couldBreak;
    };
    let private_inner_add_grp_rec = function (vi) {
        let hasFullGrp = true, couldBreak = false;
        if (grpPageInfo) {
            for (let i = 0; i < grp_lines; i++) {
                if (vIdx.length >= maxRecPerPage) {
                    for (let j = i; j < grp_lines; j++) {
                        grpPageInfo.preAddPageGrpInfo.push(j);
                    }
                    //准备要跳出去了
                    hasFullGrp = false;
                    break;
                }
                else {
                    vIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_GROUP, grpPageInfo.segGrpRecStartIdx, i]);
                }
            }
            //3. 进位下一个group信息所在位置
            if (hasFullGrp) {
                grpPageInfo.insertedGrpRecAmt++;
                insertedGrpAmt++;
                grpPageInfo.segGrpRecStartIdx++;
            }
            else {
                couldBreak = true;
            }
        }
        return couldBreak;
    };
    let private_normal_add_rec = function (vi) {
        let couldBreak = false;
        if (segAutoHeightInfo && segAutoHeightInfo.length > 0) {
            if (segAutoHeightInfo[segIdx].length > startRecIdx + vi) {
                couldBreak = private_addAutoHeightPageValue(vi);
                // if (couldBreak) break;
            }
            else if (vIdx.length < maxRecPerPage) {
                vIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_NORMAL, VAL_DEF.BLANK_VALUE_INDEX]);
            }
        }
        else {
            if (sortedSequence.length > startRecIdx + vi) {
                vIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_NORMAL, sortedSequence[startRecIdx + vi]]);
            }
            else {
                vIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_NORMAL, VAL_DEF.BLANK_VALUE_INDEX]);
            }
        }
        return couldBreak;
    };
    for (let vi = 0; (vi + insertedGrpAmt * grp_lines) < maxRecPerPage - preAmt; vi++) {
        if (grpSequenceInfo && grpPageInfo) {
            if ((startRecIdx + vi) === grpSequenceInfo[grpPageInfo.segGrpRecStartIdx]) {
                //表示这里要插入grouping信息啦！
                let couldBreak = false;
                //1. 首先push正常的记录(要考虑自动行高调整的分支)
                if (segAutoHeightInfo && segAutoHeightInfo.length > 0) {
                    couldBreak = private_addAutoHeightPageValue(vi);
                }
                else {
                    vIdx.push([followMode, VAL_DEF.DISPLAY_VAL_TYPE_NORMAL, sortedSequence[startRecIdx + vi]]);
                }
                //2. 然后就要push grouping记录了
                if (private_inner_add_grp_rec())
                    break;
                if (couldBreak)
                    break;
            }
            else {
                //备注： 在有group的情况下，如果grpPageInfo[JV.PROP_SEG_GRP_IDX] 范围大于 grpSequenceInfo.length，则表示已经到最后了，不要再加空白数据了
                //      ！！！但这是在有ex数据的情况下！！！
                if (grpPageInfo.segGrpRecStartIdx < grpSequenceInfo.length) {
                    if (private_normal_add_rec(vi))
                        break;
                }
                else {
                    //还得判断是否是普通的流水数据情况，这里可以用isFollow来进行判断，暂时不需要特意加新参数(以后如isFollow的意义有变化则需要调整)
                    if (!isFollow) {
                        if (private_normal_add_rec(vi))
                            break;
                    }
                    else {
                        break;
                    }
                }
            }
        }
        else {
            if (private_normal_add_rec(vi))
                break;
        }
    }
    if (vFirstIdx.length > 0) {
        vIdx = vIdx.concat(vFirstIdx);
        //备注： 在一开始就加grp的情况下，这些数据应该放在后面才对
    }
    page_seg_map.push([pageIdx, segIdx]);
    ValuedIdxLst.push(vIdx);
    return nextPageAutoHeightRecAmt;
}
function push_cell(pageCellObj, cell, cellIdx) {
    let key = cell.area.Left + '_' + cell.area.Right;
    if (!pageCellObj[key]) {
        pageCellObj[key] = [];
    }
    let cellArr = pageCellObj[key];
    cellArr.push({ "cellIdx": cellIdx, "cell": cell });
}
function prepareAutoHeightCells(prepareObj, cellItem, cellIdx, cellsArr) {
    if (prepareObj) {
        if (prepareObj.cellsArr === undefined) {
            prepareObj.cellsArr = cellsArr;
            prepareObj.pageCellObj = {};
        }
        push_cell(prepareObj.pageCellObj, cellItem, cellIdx);
    }
}
function setupControl(mergeCell, controls) {
    let orgCtrl = null;
    if (typeof mergeCell.control === "string") {
        orgCtrl = controls[mergeCell.control];
        mergeCell.control = {
            "Shrink": "T",
            "ShrinkFirst": orgCtrl.ShrinkFirst,
            "CloseOutput": orgCtrl.CloseOutput,
            "ShowZero": orgCtrl.ShowZero,
            "Horizon": orgCtrl.Horizon,
            "Vertical": orgCtrl.Vertical,
            "Wrap": (mergeCell.isAutoHeight) ? 'T' : 'F',
            "VerticalForExcel": "center"
        };
    }
    else {
        mergeCell.control.Shrink = "T";
        mergeCell.control.Vertical = "top";
        mergeCell.control.Wrap = (mergeCell.isAutoHeight) ? 'T' : 'F',
            mergeCell.control.VerticalForExcel = "center";
        orgCtrl = mergeCell.control;
    }
    if (mergeCell.isAutoHeight) {
        mergeCell.control.VerticalForExcel = 'justify';
        // mergeCell.control["Vertical"] = 'center';
    }
    else {
        mergeCell.control.VerticalForExcel = 'center';
        // mergeCell.control["Vertical"] = 'top';
    }
    return orgCtrl;
}
function combineAutoHeightCells(prepareObj, page, controls) {
    let rst = [];
    if (prepareObj.cellsArr) {
        //merge cells' value and area
        //备注： 系统逻辑已经把Cell的顺序放好，无需再做排序。
        for (let mergeKey in prepareObj.pageCellObj) {
            let sameColCells = prepareObj.pageCellObj[mergeKey]; //左右位置相同的Cell先放在一起，统一处理
            if (sameColCells.length > 1) {
                //强转格式，此处是强制把本来是字符串的control属性转化为对象,by lish
                let firstMergeCell = { ...sameColCells[0].cell, control: {} };
                firstMergeCell.style = firstMergeCell.style.slice(0, firstMergeCell.style.indexOf("_AutoHeightMerge")); //首先还原original style
                //生成原始对象，并且把对象中的control属性转化为对象
                let orgCtrl = setupControl(firstMergeCell, controls);
                let validValueAmt = 0, fullValidValueAmt = 0;
                for (let i = 1; i < sameColCells.length; i++) {
                    let mergeCell = sameColCells[i].cell;
                    if (mergeCell.style.indexOf("_AutoHeightMerge_Top") < 0) {
                        fullValidValueAmt++;
                        //merge into the firstMergeCell! position & value
                        firstMergeCell.area.Bottom = mergeCell.area.Bottom;
                        if (mergeCell.Value) {
                            firstMergeCell.Value = firstMergeCell.Value + "|" + mergeCell.Value;
                            validValueAmt++;
                        }
                        rst.push(sameColCells[i].cellIdx); //记下Cell的位置，在函数外消除
                        //如果到了最后一条数据，得判断firstMergeCell是否满格（即数据是满的，有可能有些格数据也有折行但不是自动行高判断指标）
                        //不满格的cell的Vertical强制设置为 'center'
                        if (i === sameColCells.length - 1 && validValueAmt !== fullValidValueAmt && (fullValidValueAmt / validValueAmt > 2.5)) {
                            firstMergeCell.control.VerticalForExcel = 'center';
                        }
                    }
                    else {
                        //碰到新开始的自动行高行，判断原先的firstMergeCell是否满格（即数据是满的，有可能有些格数据也有折行但不是自动行高判断指标）
                        //不满格的cell的Vertical强制设置为 'center'
                        if (validValueAmt !== fullValidValueAmt && (fullValidValueAmt / validValueAmt > 2.5)) {
                            firstMergeCell.control.VerticalForExcel = 'center';
                        }
                        //强制把已为对象的control属性还原成为字符串,by lish
                        firstMergeCell = sameColCells[i].cell;
                        firstMergeCell.style = firstMergeCell.style.slice(0, firstMergeCell.style.indexOf("_AutoHeightMerge"));
                        orgCtrl = setupControl(firstMergeCell, controls);
                        validValueAmt = 0;
                        fullValidValueAmt = 0;
                    }
                }
            }
        }
        rst.sort(function (i1, i2) {
            return (i1 > i2) ? 1 : -1;
        });
    }
    return rst;
}

class JpcBillTabSrvClass {
    constructor() {
        this.disp_fields_idx = []; // typescript的class属性初始化都要放constructor里，不然总报错
    }
    ;
    sorting(rptTpl) {
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl.账单式表_信息.账单式表_数据.bill_field_s, [], this.disp_fields_idx, false);
    }
    ;
    paging(rptTpl, dataObj) {
        let rst = 0;
        function _getDataLength(fields_str) {
            let dataFields = dataObj[fields_str];
            if (dataFields && dataFields.length > 0) {
                rst = dataFields[0].length;
            }
        }
        if (rptTpl.指标_数据_映射) {
            if (rptTpl.指标_数据_映射.从数据指标_集合) {
                _getDataLength(IDataObj_props.detail_data);
            }
            else if (rptTpl.指标_数据_映射.主数据指标_集合) {
                _getDataLength(IDataObj_props.master_data);
            }
            else if (rptTpl.指标_数据_映射.离散指标_集合) {
                _getDataLength(IDataObj_props.discrete_data);
            }
            else if (rptTpl.指标_数据_映射.离散参数_集合) {
                rst = 1;
            }
        }
        return rst;
    }
    ;
    outputAsPreviewPage(rptTpl, bands, controls, $CURRENT_RPT) {
        let me = this, rst = [];
        //只预览第一页的数据
        let pageStatus = [true, true, false, true, false, false, false, false];
        JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, true, false);
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        rst = rst.concat(me.outputPreviewContent(rptTpl, bands, unitFactor, controls, pageStatus));
        rst = rst.concat(JpcDiscreteHelper.outputPreviewDiscreteInfo(rptTpl.账单式表_信息.离散信息, bands, unitFactor, pageStatus));
        return rst;
    }
    ;
    outputAsSimpleJSONPage(rptTpl, dataObj, page, bands, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], tabRstLst = [];
        //1 calculate the band position
        let pageStatus = [true, false, false, false, false, false, false, false];
        JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, false, false);
        //2. start to output detail-part
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        //2.1 output content
        tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, pageStatus, $CURRENT_RPT, customizeCfg));
        //2.2 output discrete
        tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl.账单式表_信息.离散信息, bands, dataObj, unitFactor, pageStatus, page - 1, 1, 0, $CURRENT_RPT, customizeCfg));
        for (let i = 0; i < tabRstLst.length; i++) {
            rst = rst.concat(tabRstLst[i]);
            tabRstLst[i] = null;
        }
        return rst;
    }
    ;
    outputPreviewContent(rptTpl, bands, unitFactor, controls, pageStatus) {
        let rst = [];
        let tab = rptTpl.账单式表_信息.账单式表_数据;
        let band = bands[tab.BandName];
        if (band) {
            if (pageStatus[(band.DisplayType)]) {
                let tab_fields = tab.bill_field_s;
                for (let i = 0; i < tab_fields.length; i++) {
                    let tab_field = tab_fields[i];
                    if (!(tab_field.Hidden)) {
                        let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, "", controls);
                        cellItem.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                        rst.push(cellItem);
                    }
                }
                if (tab.text) {
                    rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, 1, 0, 1, 0));
                }
                if (tab.text_s) {
                    for (let j = 0; j < tab.text_s.length; j++) {
                        rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, 1, 0, 1, 0));
                    }
                }
                if (tab.离散信息) {
                    rst = rst.concat(JpcDiscreteHelper.outputPreviewDiscreteInfo(tab.离散信息, bands, unitFactor, pageStatus));
                }
            }
        }
        return rst;
    }
    ;
    outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, pageStatus, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        let tab = rptTpl.账单式表_信息.账单式表_数据;
        let band = bands[tab.BandName];
        if (band) {
            if (pageStatus[(band.DisplayType)]) {
                let tab_fields = tab.bill_field_s;
                // let data_details = null;//bylish
                let data_details = [];
                if (rptTpl.指标_数据_映射.从数据指标_集合) {
                    data_details = dataObj[IDataObj_props.detail_data];
                }
                else if (rptTpl.指标_数据_映射.主数据指标_集合) {
                    data_details = dataObj[IDataObj_props.master_data];
                }
                let flexiblePrecisionRefObj = null, flexibleRefField = null, precision_ref_data = null;
                for (let i = 0; i < tab_fields.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = null, map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                    if (me.disp_fields_idx.length > i && me.disp_fields_idx[i] !== VAL_DEF.BLANK_FIELD_INDEX && (typeof me.disp_fields_idx[i] !== 'object')) {
                        data_field = data_details[me.disp_fields_idx[i]];
                    }
                    else {
                        if (map_data_field) {
                            data_field = map_data_field.data_field;
                        }
                    }
                    if (map_data_field && map_data_field.Precision && map_data_field.flexiblePrecisionRefObj && map_data_field.Precision.flexibleRefFieldID) { //加了最后一个判断  by lish
                        if (flexiblePrecisionRefObj === null) {
                            flexiblePrecisionRefObj = {};
                            flexibleRefField = JE.F(map_data_field.Precision.flexibleRefFieldID, $CURRENT_RPT);
                            if (flexibleRefField)
                                precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                            for (let decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                            }
                        }
                        JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, page - 1, customizeCfg);
                    }
                    else {
                        if (page === 1)
                            JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                    }
                    if (!(tab_field.Hidden)) {
                        let val = JpcFieldHelper.getValue(data_field, page - 1);
                        let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                        cellItem.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                        rst.push(cellItem);
                    }
                }
                if (tab.text) {
                    rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, 1, 0, 1, 0));
                }
                if (tab.text_s) {
                    for (let j = 0; j < tab.text_s.length; j++) {
                        rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, 1, 0, 1, 0));
                    }
                }
                if (tab.离散信息) {
                    rst = rst.concat(JpcDiscreteHelper.outputDiscreteInfo(tab.离散信息, bands, dataObj, unitFactor, pageStatus, page - 1, 1, 0, $CURRENT_RPT, customizeCfg));
                }
            }
        }
        return rst;
    }
}

let JpcCrossTabHelper = {
    getColIDX: function (cl, val) {
        let rst = -1;
        for (let i = 0; i < cl.length; i++) {
            let ca = cl[i];
            for (let j = 0; j < ca.length; j++) {
                if (ca[j] == val) {
                    rst = i;
                    break;
                }
            }
            if (rst != -1) {
                break;
            }
        }
        return rst;
    },
    pushToSeg: function (segArr, dataSeq, segIdx, sIdx, eIdx) {
        let arrIdx = [];
        for (let k = sIdx; k < eIdx; k++) {
            arrIdx.push(dataSeq[segIdx][k]);
        }
        segArr.push(arrIdx);
    },
    sortFieldValue: function (sIDX, eIDX, sortOrder, dataField, dataValSeq) {
        let tmpSeq = [];
        if ((sortOrder) && (sortOrder !== VAL_DEF.TAB_FIELD_PROP_SORT_VAL_NOSORT)) {
            if (sIDX >= 0 && eIDX >= sIDX && dataValSeq.length > eIDX) {
                let reversed = 1;
                if (sortOrder === VAL_DEF.TAB_FIELD_PROP_SORT_VAL_DESC) {
                    reversed = -1;
                }
                for (let i = sIDX; i <= eIDX; i++) {
                    tmpSeq.push(dataValSeq[i]);
                }
                tmpSeq.sort(function (idx1, idx2) {
                    let rst = 0;
                    // if (isNaN(parseFloat(dataField[idx1])) || isNaN(parseFloat(dataField[idx1]))) {
                    if (typeof (dataField[idx1]) === 'string' || typeof (dataField[idx1]) === 'string') {
                        if (dataField[idx1] > dataField[idx2]) {
                            rst = reversed;
                        }
                        else if (dataField[idx1] < dataField[idx2]) {
                            rst = -reversed;
                        }
                    }
                    else {
                        if ((1.0 * dataField[idx1]) > (1.0 * dataField[idx2])) {
                            rst = reversed;
                        }
                        else if ((1.0 * dataField[idx1]) < (1.0 * dataField[idx2])) {
                            rst = -reversed;
                        }
                    }
                    return rst;
                });
            }
        }
        if (tmpSeq.length > 0) {
            for (let i = sIDX; i <= eIDX; i++) {
                dataValSeq[i] = tmpSeq[i - sIDX];
            }
        }
        return tmpSeq;
    },
    checkIfEqual: function (dataFields, seq1, seq2) {
        let rst = true;
        for (let i = 0; i < dataFields.length; i++) {
            if ((dataFields[i][seq1] !== dataFields[i][seq2])) {
                rst = false;
                break;
            }
        }
        return rst;
    },
    //暂定
    sortTabFields: function (tabFields, fieldSeqs, data_details, dataSeq, $CURRENT_RPT) {
        let me = this;
        let sIDX = 0, eIDX = -1, isFirstSort = true;
        for (let i = 0; i < tabFields.length; i++) {
            let tabField = tabFields[i];
            if (tabField.Sort !== VAL_DEF.TAB_FIELD_PROP_SORT_VAL_NOSORT) {
                if (isFirstSort) {
                    isFirstSort = false;
                    //first field, should sort all data items
                    for (let j = 0; j < dataSeq.length; j++) {
                        sIDX = 0;
                        eIDX = dataSeq[j].length - 1;
                        //sort the field value here
                        if (typeof (fieldSeqs[i]) === "object") {
                            let exFirstField = JE.F(fieldSeqs[i].ID, $CURRENT_RPT);
                            if (exFirstField) {
                                me.sortFieldValue(sIDX, eIDX, tabField.Sort, exFirstField.data_field, dataSeq[j]);
                            }
                        }
                        else {
                            me.sortFieldValue(sIDX, eIDX, tabField.Sort, data_details[fieldSeqs[i]], dataSeq[j]);
                        }
                        // me.sortFieldValue(sIDX, eIDX, tabField.Sort,data_details[fieldSeqs[i]], dataSeq[j]);
                    }
                }
                else {
                    //then sort the rest fields one by one
                    for (let j = 0; j < dataSeq.length; j++) {
                        let chkFields = [];
                        for (let k = 0; k < i; k++) {
                            if (typeof (fieldSeqs[k]) === "object") {
                                let exField = JE.F(fieldSeqs[k].ID, $CURRENT_RPT);
                                if (exField) {
                                    chkFields.push(exField.data_field);
                                }
                                else {
                                    chkFields.push(null);
                                }
                            }
                            else {
                                chkFields.push(data_details[fieldSeqs[k]]);
                            }
                            // chkFields.push(data_details[fieldSeqs[k]]);
                        }
                        sIDX = 0, eIDX = -1;
                        for (let m = 1; m < dataSeq[j].length; m++) {
                            if (!(me.checkIfEqual(chkFields, dataSeq[j][m - 1], dataSeq[j][m]))) {
                                eIDX = m - 1;
                            }
                            else if (m == dataSeq[j].length - 1) {
                                eIDX = m;
                            }
                            if (eIDX >= sIDX) {
                                if (eIDX != sIDX) {
                                    if (typeof (fieldSeqs[i]) === "object") {
                                        let exOtherField = JE.F(fieldSeqs[i].ID, $CURRENT_RPT);
                                        if (exOtherField) {
                                            me.sortFieldValue(sIDX, eIDX, tabField.Sort, exOtherField.data_field, dataSeq[j]);
                                        }
                                    }
                                    else {
                                        me.sortFieldValue(sIDX, eIDX, tabField.Sort, data_details[fieldSeqs[i]], dataSeq[j]);
                                    }
                                    // me.sortFieldValue(sIDX, eIDX, tabField.Sort,data_details[fieldSeqs[i]], dataSeq[j]);
                                }
                                sIDX = m;
                                eIDX = m - 1; //for protection purpose
                            }
                        }
                    }
                }
            }
        }
    },
    getMaxRowsPerPage: function (bands, rptTpl) {
        let rst = 1;
        let band = bands[rptTpl.交叉表_信息.交叉行.BandName];
        if (band) {
            rst = getMaxTabCntPerPage(rptTpl, '交叉行', 'CommonHeight', band.Bottom - band.Top);
        }
        return rst;
    },
    getMaxColsPerPage: function (bands, rptTpl) {
        let rst = 1;
        let band = bands[rptTpl.交叉表_信息.交叉列.BandName];
        if (band) {
            rst = getMaxTabCntPerPage(rptTpl, '交叉列', 'CommonWidth', band.Right - band.Left);
        }
        return rst;
    },
    getActualRowsHeight: function (bands, rptTpl, segments, page) {
        let rst = 1;
        let band = bands[rptTpl.交叉表_信息.交叉行.BandName];
        if (band) {
            rst = getActualContentAreaMeasurement(rptTpl, '交叉行', 'CommonHeight', band.Bottom - band.Top, segments, page);
        }
        return rst;
    },
    getActualColsWidth: function (bands, rptTpl, segments, page) {
        let rst = 1;
        let band = bands[rptTpl.交叉表_信息.交叉列.BandName];
        if (band) {
            rst = getActualContentAreaMeasurement(rptTpl, VAL_DEF.NODE_CROSS_COL, VAL_DEF.PROP_CMN_WIDTH, band.Right - band.Left, segments, page);
        }
        return rst;
    },
    chkTabEnd: function (tabType, rptTpl, bands, sortedSequence, segIdx, preRec, nextRec) {
        let me = this, rst = true;
        let remainAmt = preRec + nextRec - sortedSequence[segIdx].length;
        rst = me.hasEnoughSpace(tabType, rptTpl, bands, remainAmt);
        return rst;
    },
    hasEnoughSpace: function (tabType, rptTpl, bands, remainAmt) {
        if (remainAmt < 0)
            return false;
        let rst = true, measurement = 1.0, douDiffForCompare = 0.00001;
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        let band = null;
        if (rptTpl.交叉表_信息[tabType]) {
            band = bands[rptTpl.交叉表_信息[tabType].BandName];
        }
        if (band != null && band != undefined) {
            if (tabType === VAL_DEF.NODE_CROSS_ROW_SUM || tabType === VAL_DEF.NODE_CROSS_ROW_EXT) {
                measurement = 1.0 * rptTpl.交叉表_信息.交叉行.CommonHeight * unitFactor;
                let spareHeight = measurement * remainAmt;
                let douH = 1.0 * (band.Bottom - band.Top);
                rst = (spareHeight >= douH) || (spareHeight - douH <= douDiffForCompare);
            }
            else if (tabType === VAL_DEF.NODE_CROSS_COL_SUM) {
                measurement = 1.0 * rptTpl.交叉表_信息.交叉列.CommonWidth * unitFactor;
                let spareWidth = measurement * remainAmt;
                let douW = 1.0 * (band.Right - band.Left);
                rst = (spareWidth >= douW) || (spareWidth - douW <= douDiffForCompare);
            }
        }
        return rst;
    },
    initialPageStatus: function (pageStatus) {
        pageStatus[VAL_DEF.STATUS_NORMAL] = true;
        pageStatus[VAL_DEF.STATUS_REPORT_START] = false;
        pageStatus[VAL_DEF.STATUS_REPORT_END] = false;
        pageStatus[VAL_DEF.STATUS_SEGMENT_START] = false;
        pageStatus[VAL_DEF.STATUS_SEGMENT_END] = false;
        pageStatus[VAL_DEF.STATUS_GROUP] = false;
        pageStatus[VAL_DEF.STATUS_CROSS_ROW_END] = false;
        pageStatus[VAL_DEF.STATUS_CROSS_COL_END] = false;
    }
};
function getMaxTabCntPerPage(rptTpl, tabNodeName, tabMeasurePropName, measureForCal) {
    let rst = 1;
    if (rptTpl.交叉表_信息[tabNodeName]) {
        let tab = rptTpl.交叉表_信息[tabNodeName];
        let maxFieldMeasure = 1.0;
        if (VAL_DEF.CAL_TYPE_ABSTRACT === JpcCommonHelper.getPosCalculationType(tab[VAL_DEF.PROP_CALCULATION])) {
            let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
            maxFieldMeasure = 1.0 * rptTpl.交叉表_信息[tabNodeName][tabMeasurePropName] * unitFactor;
        }
        else {
            maxFieldMeasure = measureForCal * rptTpl.交叉表_信息[tabNodeName][tabMeasurePropName] / VAL_DEF.HUNDRED_PERCENT;
        }
        rst = Math.floor(measureForCal / maxFieldMeasure);
    }
    if (rst <= 0)
        rst = 1;
    return rst;
}
function getActualContentAreaMeasurement(rptTpl, tabNodeName, tabMeasurePropName, measureForCal, segments, page) {
    let rst = 1;
    if (rptTpl.交叉表_信息[tabNodeName]) {
        let tab = rptTpl.交叉表_信息[tabNodeName];
        let maxFieldMeasure = 1.0;
        if (VAL_DEF.CAL_TYPE_ABSTRACT === JpcCommonHelper.getPosCalculationType(tab[VAL_DEF.PROP_CALCULATION])) {
            let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
            maxFieldMeasure = 1.0 * rptTpl.交叉表_信息[tabNodeName][tabMeasurePropName] * unitFactor;
        }
        else {
            maxFieldMeasure = measureForCal * rptTpl.交叉表_信息[tabNodeName][tabMeasurePropName] / VAL_DEF.HUNDRED_PERCENT;
        }
        if (segments.length >= page) {
            rst = segments[page - 1].length * maxFieldMeasure;
        }
    }
    return rst;
}

class JpcCrossTabClass {
    constructor() {
        this.dispValueIdxLst_Row = [];
        this.dispValueIdxLst_Col = [];
        this.dispValueIdxLst_Content = [];
        this.dispSerialIdxLst_Row = [];
        this.col_sum_fields_idx = [];
        this.col_sum_fields_value_total = [];
        this.dispSumValueLst_Col = [];
        this.page_seg_map = [];
        this.row_fields_idx = [];
        this.row_fields_adhoc_idx = [];
        this.col_fields_idx = [];
        this.content_fields_idx = [];
        this.row_extension_fields_idx = [];
        this.row_sum_extension_fields_idx = [];
        this.sortedRowSequence = [];
        this.sortedColSequence = [];
        this.sortedContentSequence = [];
        this.crsOrient = VAL_DEF.PAGE_ORIENTATION_V_FIRST;
        this.pageStatusLst = [];
        this.paging_option = VAL_DEF.PAGING_OPTION_NORMAL;
    }
    ;
    sorting(rptTpl, dataObj, dataSeq, $CURRENT_RPT) {
        let me = this;
        //IMPORTANT: the data should be sorted in SQL/NoSQL level!
        me.sortedRowSequence = _SortAndOptimize(rptTpl, dataObj, dataSeq, VAL_DEF.NODE_CROSS_ROW, me.row_fields_idx, $CURRENT_RPT);
        _SortAndOptimize(rptTpl, dataObj, dataSeq, VAL_DEF.NODE_CROSS_ROW_AD_HOC, me.row_fields_adhoc_idx, $CURRENT_RPT);
        me.sortedColSequence = _SortAndOptimize(rptTpl, dataObj, dataSeq, VAL_DEF.NODE_CROSS_COL, me.col_fields_idx, $CURRENT_RPT);
        me.sortedContentSequence = _SortForDisplayContent(rptTpl, me.sortedRowSequence, me.sortedColSequence, me.content_fields_idx);
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl.交叉表_信息.交叉列合计.cross_field_s, null, me.col_sum_fields_idx, false);
        //pre-sum the data(for col sum display)
        let data_details = dataObj.detail_data, data_fields = [];
        for (let i = 0; i < me.col_sum_fields_idx.length; i++) {
            let data_field = null;
            if (typeof me.col_sum_fields_idx[i] === 'object') {
                let exField = JE.F(me.col_sum_fields_idx[i].ID, $CURRENT_RPT);
                if (exField) {
                    data_field = exField.data_field;
                }
            }
            else {
                data_field = data_details[me.col_sum_fields_idx[i]];
            }
            data_fields.push(data_field);
        }
        for (let i = 0; i < me.sortedRowSequence.length; i++) { //seg level
            if (me.sortedRowSequence[i].length > 0) {
                me.col_sum_fields_value_total.push([]);
                for (let j = 0; j < me.sortedRowSequence[i].length; j++) {
                    let rowGrandTotal = [];
                    for (let di = 0; di < data_fields.length; di++) {
                        rowGrandTotal.push(0.0);
                        for (let k = 0; k < me.sortedRowSequence[i][j].length; k++) {
                            // 3. start to sum
                            let vTtl = parseFloat(JpcFieldHelper.getValue(data_fields[di], me.sortedRowSequence[i][j][k]));
                            if (isNaN(vTtl)) {
                                vTtl = 0;
                            }
                            rowGrandTotal[di] = rowGrandTotal[di] + vTtl;
                        }
                    }
                    me.col_sum_fields_value_total[i].push(rowGrandTotal);
                }
            }
        }
    }
    ;
    preSetupPages(rptTpl, defProperties, option) {
        let me = this, rst = 0;
        me.paging_option = option || VAL_DEF.PAGING_OPTION_NORMAL;
        //1. original initialize
        let maxRowRec = 1, maxColRec = 1, counterRowRec = 0, counterColRec = 0, pageIdx = 0, segCnt = me.sortedContentSequence.length;
        let pageStatus = [true, true, false, true, false, false, false, false];
        //2. calculate the page info one by one
        let bands = JpcBand.createNew(rptTpl, defProperties);
        function private_resetBandArea() {
            JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, false, false);
            maxRowRec = JpcCrossTabHelper.getMaxRowsPerPage(bands, rptTpl);
            maxColRec = JpcCrossTabHelper.getMaxColsPerPage(bands, rptTpl);
        }
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl.交叉表_信息.交叉行拓展.cross_field_s, null, me.row_extension_fields_idx, false);
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl.交叉表_信息.交叉行拓展合计.cross_field_s, null, me.row_sum_extension_fields_idx, false);
        if (me.paging_option === VAL_DEF.PAGING_OPTION_INFINITY) ;
        else {
            for (let segIdx = 0; segIdx < segCnt; segIdx++) {
                //2.1. seg level initialize
                private_resetBandArea();
                let orgMaxRowRec = maxRowRec, orgMaxColRec = maxColRec;
                let rowSplitCnt = Math.ceil(1.0 * me.sortedRowSequence[segIdx].length / maxRowRec);
                let colSplitCnt = Math.ceil(1.0 * me.sortedColSequence[segIdx].length / maxColRec);
                pageStatus[VAL_DEF.STATUS_CROSS_ROW_END] = true;
                private_resetBandArea();
                let hasAdHocRow = !JpcCrossTabHelper.chkTabEnd(VAL_DEF.NODE_CROSS_ROW_SUM, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                if (hasAdHocRow) {
                    hasAdHocRow = !JpcCrossTabHelper.chkTabEnd(VAL_DEF.NODE_CROSS_ROW_EXT, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                }
                pageStatus[VAL_DEF.STATUS_CROSS_ROW_END] = false;
                pageStatus[VAL_DEF.STATUS_CROSS_COL_END] = true;
                private_resetBandArea();
                let hasAdHocCol = !JpcCrossTabHelper.chkTabEnd(VAL_DEF.NODE_CROSS_COL_SUM, rptTpl, bands, me.sortedColSequence, segIdx, (colSplitCnt - 1) * orgMaxColRec, maxColRec);
                pageStatus[VAL_DEF.STATUS_CROSS_COL_END] = false;
                private_resetBandArea();
                if (hasAdHocRow)
                    rowSplitCnt++;
                if (hasAdHocCol)
                    colSplitCnt++;
                //2.2
                if (rptTpl.主信息.打印页面_信息.cross_display_order === VAL_DEF.PAGE_ORIENTATION_H_FIRST) {
                    for (let rowIdx = 0; rowIdx < rowSplitCnt; rowIdx++) {
                        pageStatus[VAL_DEF.STATUS_CROSS_ROW_END] = (rowIdx === (rowSplitCnt - 1));
                        private_resetBandArea();
                        counterRowRec = orgMaxRowRec * rowIdx;
                        let currentSortedRowSequence = me.sortedRowSequence;
                        let currentSortedContentSequence = me.sortedContentSequence;
                        if (hasAdHocRow && rowIdx === (rowSplitCnt - 1)) {
                            currentSortedRowSequence = null;
                            currentSortedContentSequence = null;
                            counterRowRec = 0;
                        }
                        for (let colIdx = 0; colIdx < colSplitCnt; colIdx++) {
                            pageStatus[VAL_DEF.STATUS_CROSS_COL_END] = (colIdx === (colSplitCnt - 1));
                            private_resetBandArea();
                            counterColRec = orgMaxColRec * colIdx;
                            let currentSortedColSequence = me.sortedColSequence;
                            if (hasAdHocCol && colIdx === (colSplitCnt - 1)) {
                                currentSortedColSequence = null;
                                currentSortedContentSequence = null;
                                counterColRec = 0;
                            }
                            me.pageStatusLst.push(pageStatus.slice(0));
                            pageIdx++;
                            _addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                            _addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, null, null);
                            _addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                        }
                    }
                }
                else {
                    for (let colIdx = 0; colIdx < colSplitCnt; colIdx++) {
                        pageStatus[VAL_DEF.STATUS_CROSS_COL_END] = (colIdx === (colSplitCnt - 1));
                        private_resetBandArea();
                        counterColRec = orgMaxColRec * colIdx;
                        let currentSortedContentSequence = me.sortedContentSequence;
                        let currentSortedColSequence = me.sortedColSequence;
                        if (hasAdHocCol && colIdx === (colSplitCnt - 1)) {
                            currentSortedColSequence = null;
                            currentSortedContentSequence = null;
                            counterColRec = 0;
                        }
                        for (let rowIdx = 0; rowIdx < rowSplitCnt; rowIdx++) {
                            pageStatus[VAL_DEF.STATUS_CROSS_ROW_END] = (rowIdx === (rowSplitCnt - 1));
                            private_resetBandArea();
                            me.pageStatusLst.push(pageStatus.slice(0));
                            pageIdx++;
                            counterRowRec = orgMaxRowRec * rowIdx;
                            let currentSortedRowSequence = me.sortedRowSequence;
                            if (hasAdHocRow && rowIdx === (rowSplitCnt - 1)) {
                                currentSortedRowSequence = null;
                                currentSortedContentSequence = null;
                                counterRowRec = 0;
                            }
                            _addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                            _addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, null, null);
                            _addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                        }
                    }
                }
                JpcCrossTabHelper.initialPageStatus(pageStatus);
            }
            //3. set pageSeq and return the result
            rst = pageIdx;
        }
        // bands = null;
        return rst;
    }
    ;
    outputAsPreviewPage(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        let pageStatus = [true, true, true, true, true, true, true, true];
        me.pageStatusLst.push(pageStatus);
        // JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_FLOW_INFO][JV.NODE_FLOW_CONTENT][JV.PROP_FLOW_FIELDS], null, me.disp_fields_idx, false);
        JpcBandHelper.setBandArea(bands, rptTpl, pageStatus, true, false);
        let maxRowRec = JpcCrossTabHelper.getMaxRowsPerPage(bands, rptTpl);
        let maxColRec = JpcCrossTabHelper.getMaxColsPerPage(bands, rptTpl);
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        //1. 交叉行
        rst = rst.concat(me.outputPreviewRowTab(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, unitFactor));
        //2. 交叉列
        rst = rst.concat(me.outputPreviewColTab(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor));
        //3. 交叉数据
        rst = rst.concat(me.outputPreviewContent(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, unitFactor));
        //4. 交叉行拓展
        rst = rst.concat(me.outputPreviewTabExt(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor));
        //5. 交叉行拓展合计
        rst = rst.concat(me.outputPreviewSumTabExt(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, unitFactor));
        //6. 交叉列合计
        rst = rst.concat(me.outputPreviewTabSum(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, '交叉列合计', unitFactor));
        //7. 离散
        rst = rst.concat(JpcDiscreteHelper.outputPreviewDiscreteInfo(rptTpl.交叉表_信息.离散信息, bands, unitFactor, pageStatus));
        return rst;
    }
    ;
    outputPreviewContent(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, rptTpl.交叉表_信息.交叉数据, unitFactor);
    }
    ;
    outputPreviewRowTab(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, unitFactor) {
        let rst = this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, 1, rptTpl.交叉表_信息.交叉行, unitFactor);
        rst = rst.concat(this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, 1, rptTpl.交叉表_信息.交叉行AD_HOC, unitFactor));
        return rst;
    }
    ;
    outputPreviewColTab(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, maxColRec, rptTpl.交叉表_信息.交叉列, unitFactor);
    }
    ;
    outputPreviewTabExt(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxColRec, unitFactor) {
        //交叉行拓展
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, maxColRec, rptTpl.交叉表_信息.交叉行拓展, unitFactor);
    }
    ;
    outputPreviewSumTabExt(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, unitFactor) {
        //交叉行拓展合计
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, 1, 1, rptTpl.交叉表_信息.交叉行拓展合计, unitFactor);
    }
    ;
    outputPreviewTabSum(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, tabNodeName, unitFactor) {
        return this.private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, 1, rptTpl.交叉表_信息[tabNodeName], unitFactor);
    }
    ;
    private_OutputPreviewCommon(rptTpl, bands, controls, $CURRENT_RPT, customizeCfg, maxRowRec, maxColRec, tab, unitFactor) {
        let me = this, rst = [];
        let band = (tab) ? bands[tab.BandName] : null;
        if (band) {
            let tab_fields = tab.cross_field_s;
            for (let rowIdx = 0; rowIdx < maxRowRec; rowIdx++) {
                for (let i = 0; i < tab_fields.length; i++) {
                    let tab_field = tab_fields[i];
                    if (!(tab_field.Hidden)) {
                        for (let colIdx = 0; colIdx < maxColRec; colIdx++) {
                            if (tab_field.isSerial) {
                                rst.push(me.outputTabField(band, tab_field, [rowIdx + 1], 0, -1, maxRowRec, rowIdx, maxColRec, colIdx, unitFactor, false, controls));
                            }
                            else {
                                rst.push(me.outputTabField(band, tab_field, null, -1, -1, maxRowRec, rowIdx, maxColRec, colIdx, unitFactor, false, controls));
                            }
                        }
                    }
                }
                if (tab.text_s) {
                    for (let j = 0; j < tab.text_s.length; j++) {
                        for (let colIdx = 0; colIdx < maxColRec; colIdx++) {
                            rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, maxRowRec, rowIdx, maxColRec, colIdx, 1, 0));
                        }
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputAsSimpleJSONPage(rptTpl, dataObj, page, bands, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], tabRstLst = [];
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        if (me.paging_option === VAL_DEF.PAGING_OPTION_INFINITY) ;
        else {
            let segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            //1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1], false, false);
            //2. start to output detail-part
            //2.1 Row-Tab
            //tabRstLst.push(me.outputRowTab(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            tabRstLst.push(me.outputRowTabCommon(rptTpl, dataObj, page, bands, VAL_DEF.NODE_CROSS_ROW, me.row_fields_idx, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            tabRstLst.push(me.outputRowTabCommon(rptTpl, dataObj, page, bands, VAL_DEF.NODE_CROSS_ROW_AD_HOC, me.row_fields_adhoc_idx, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            //2.2 Col-Tab
            tabRstLst.push(me.outputColTab(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            //2.3 Content-Tab
            tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            //2.4 Sum-Tab Row
            //2.4 Sum-tab Col
            tabRstLst.push(me.outputTabSum(rptTpl, dataObj, page, bands, unitFactor, VAL_DEF.NODE_CROSS_COL_SUM, controls, $CURRENT_RPT, customizeCfg));
            //2.x row tab ext
            tabRstLst.push(me.outputTabExt(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg));
            tabRstLst.push(me.outputSumTabExt(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls, $CURRENT_RPT, customizeCfg));
            //2.5 Discrete
            tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl.交叉表_信息.离散信息, bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 1, 0, $CURRENT_RPT, customizeCfg));
        }
        for (let i = 0; i < tabRstLst.length; i++) {
            rst = rst.concat(tabRstLst[i]);
            tabRstLst[i] = null;
        }
        return rst;
    }
    ;
    outputTabSum(rptTpl, dataObj, page, bands, unitFactor, tabNodeName, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], tab = rptTpl.交叉表_信息[tabNodeName], band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)] === true) {
                let tab_fields = tab.cross_field_s;
                for (let i = 0; i < me.dispSumValueLst_Col[page - 1].length; i++) {
                    if (i === 0) {
                        for (let tfIdx = 0; tfIdx < tab_fields.length; tfIdx++) {
                            let map_data_field = JE.F(tab_fields[tfIdx].FieldID, $CURRENT_RPT);
                            JpcFieldHelper.resetFormat(tab_fields[tfIdx], map_data_field, customizeCfg);
                        }
                    }
                    if (me.dispSumValueLst_Col[page - 1][i] !== null) {
                        for (let j = 0; j < me.dispSumValueLst_Col[page - 1][i].length; j++) {
                            let tab_field = tab_fields[j];
                            let val = me.dispSumValueLst_Col[page - 1][i][j];
                            let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem.area = JpcAreaHelper.outputArea(tab_field[VAL_DEF.PROP_AREA], band, unitFactor, me.dispSumValueLst_Col[page - 1].length, i, 1, 0, 1, 0, true, false);
                            rst.push(cellItem);
                        }
                    }
                    else {
                        let sumL = 1;
                        for (let si = 0; si < me.dispSumValueLst_Col.length; si++) {
                            if (me.dispSumValueLst_Col[si][0] !== null) {
                                sumL = me.dispSumValueLst_Col[si][0].length;
                                break;
                            }
                        }
                        for (let j = 0; j < sumL; j++) {
                            let tab_field = tab_fields[j];
                            let val = null;
                            let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem.area = JpcAreaHelper.outputArea(tab_field[VAL_DEF.PROP_AREA], band, unitFactor, me.dispSumValueLst_Col[page - 1].length, i, 1, 0, 1, 0, true, false);
                            rst.push(cellItem);
                        }
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputTabExt(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], firstTextOutput = true, tab = rptTpl.交叉表_信息.交叉行拓展;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)] === true) {
                let tab_fields = tab.cross_field_s, data_details = dataObj[IDataObj_props.detail_data], valuesIdx = me.dispValueIdxLst_Col[page - 1];
                for (let i = 0; i < me.row_extension_fields_idx.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = null;
                    let map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                    if (typeof me.row_extension_fields_idx[i] !== 'object') {
                        data_field = data_details[me.row_extension_fields_idx[i]];
                    }
                    else {
                        if (map_data_field) {
                            data_field = map_data_field.data_field;
                        }
                    }
                    if (!(tab_field.Hidden)) {
                        let cols = valuesIdx.length;
                        for (let colIdx = 0; colIdx < cols; colIdx++) {
                            if (colIdx === 0)
                                JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            //2. output texts if has
                            if (firstTextOutput) {
                                if (tab.text) {
                                    rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                }
                                if (tab.text_s) {
                                    for (let j = 0; j < tab.text_s.length; j++) {
                                        rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    }
                                }
                            }
                        }
                        firstTextOutput = false;
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputSumTabExt(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], tab = rptTpl.交叉表_信息.交叉行拓展合计;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)] === true && pageStatus[6] === true) {
                let tab_fields = tab.cross_field_s, data_details = dataObj[IDataObj_props.detail_data], data_fields = [];
                for (let i = 0; i < me.row_sum_extension_fields_idx.length; i++) {
                    // let data_field = data_details[me.row_sum_extension_fields_idx[i]];
                    let tab_field = tab_fields[i];
                    let data_field = null;
                    let map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                    if (typeof me.row_sum_extension_fields_idx[i] !== 'object') {
                        data_field = data_details[me.row_sum_extension_fields_idx[i]];
                    }
                    else {
                        if (map_data_field) {
                            data_field = map_data_field.data_field;
                        }
                    }
                    JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                    data_fields.push(data_field);
                }
                //2. initialize grand total value
                let rowGrandTotal = [];
                for (let di = 0; di < data_fields.length; di++) {
                    rowGrandTotal[di] = 0.0;
                    //3. start to sum
                    for (let i = 0; i < me.sortedColSequence[segIdx].length; i++) {
                        //me.sortedColSequence[segIdx][i][0] //this is the data field value index!
                        rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * parseFloat(JpcFieldHelper.getValue(data_fields[di], me.sortedColSequence[segIdx][i][0]));
                    }
                }
                //4. output
                for (let di = 0; di < tab_fields.length; di++) {
                    let tab_field = tab_fields[di];
                    if (!tab_field.Hidden) {
                        let val = rowGrandTotal[di];
                        let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                        cellItem.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                        rst.push(cellItem);
                    }
                }
                //output texts if has
                if (tab.text) {
                    rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, 1, 0, 1, 0));
                }
                if (tab.text_s) {
                    for (let j = 0; j < tab.text_s.length; j++) {
                        rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, 1, 0, 1, 0));
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputContent(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        let tab = rptTpl.交叉表_信息.交叉数据;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)] === true) {
                let tab_fields = tab.cross_field_s;
                let data_details = dataObj[IDataObj_props.detail_data];
                let contentValuesIdx = me.dispValueIdxLst_Content[page - 1];
                let flexiblePrecisionRefObj = null, flexibleRefField = null, precision_ref_data = null;
                for (let i = 0; i < tab_fields.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = null;
                    let map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                    if (typeof me.content_fields_idx[i] !== 'object') {
                        data_field = data_details[me.content_fields_idx[i]];
                    }
                    else {
                        if (map_data_field) {
                            data_field = map_data_field.data_field;
                        }
                    }
                    if (!(tab_field.Hidden)) {
                        let rows = contentValuesIdx.length;
                        for (let rowIdx = 0; rowIdx < rows; rowIdx++) {
                            let cols = contentValuesIdx[rowIdx].length;
                            for (let colIdx = 0; colIdx < cols; colIdx++) {
                                if (map_data_field && map_data_field.Precision && map_data_field.flexiblePrecisionRefObj && map_data_field.Precision.flexibleRefFieldID) {
                                    if (flexiblePrecisionRefObj === null) {
                                        flexiblePrecisionRefObj = {};
                                        flexibleRefField = JE.F(map_data_field.Precision.flexibleRefFieldID, $CURRENT_RPT);
                                        if (flexibleRefField && flexibleRefField.DataSeq)
                                            precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                        for (let decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                            flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                                        }
                                    }
                                    JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, contentValuesIdx[rowIdx][colIdx], customizeCfg);
                                }
                                else {
                                    if (colIdx === 0)
                                        JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                                }
                                rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][colIdx], -1, rows, rowIdx, cols, colIdx, unitFactor, true, controls));
                            }
                        }
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputColTab(rptTpl, dataObj, page, bands, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [], firstTextOutput = true;
        let tab = rptTpl.交叉表_信息.交叉列;
        let band = bands[tab.BandName];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)] === true) {
                let tab_fields = tab.cross_field_s;
                let data_details = dataObj[IDataObj_props.detail_data];
                let valuesIdx = me.dispValueIdxLst_Col[page - 1];
                let flexiblePrecisionRefObj = null, flexibleRefField = null, precision_ref_data = null;
                for (let i = 0; i < me.col_fields_idx.length; i++) {
                    let tab_field = tab_fields[i];
                    if (!(tab_field.Hidden)) {
                        let mergedRst = [];
                        let data_field = null;
                        let map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                        if (typeof me.col_fields_idx[i] !== 'object') {
                            data_field = data_details[me.col_fields_idx[i]];
                        }
                        else {
                            if (map_data_field) {
                                data_field = map_data_field.data_field;
                            }
                        }
                        let cols = valuesIdx.length;
                        for (let colIdx = 0; colIdx < cols; colIdx++) {
                            if (map_data_field && map_data_field.Precision && map_data_field.flexiblePrecisionRefObj && map_data_field.Precision.flexibleRefFieldID) {
                                if (flexiblePrecisionRefObj === null) {
                                    flexiblePrecisionRefObj = {};
                                    flexibleRefField = JE.F(map_data_field.Precision.flexibleRefFieldID, $CURRENT_RPT);
                                    if (flexibleRefField && flexibleRefField.DataSeq)
                                        precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                    for (let decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                        flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                                    }
                                }
                                JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, valuesIdx[colIdx], customizeCfg);
                            }
                            else {
                                if (colIdx === 0)
                                    JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                            }
                            mergedRst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            //rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            //2. output texts
                            if (firstTextOutput) {
                                if (tab.text) {
                                    // mergedRst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    rst.push(JpcTextHelper.outputText(tab.text, band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                }
                                if (tab.text_s) {
                                    for (let j = 0; j < tab.text_s.length; j++) {
                                        // mergedRst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                        rst.push(JpcTextHelper.outputText(tab.text_s[j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    }
                                }
                            }
                        }
                        firstTextOutput = false;
                        //判断是否需要合并
                        if (tab_field.isMerge && mergedRst.length > 1) {
                            let lastCell = mergedRst[mergedRst.length - 1];
                            for (let mergeIdx = mergedRst.length - 2; mergeIdx >= 0; mergeIdx--) {
                                if (lastCell.Value === mergedRst[mergeIdx].Value) {
                                    mergedRst[mergeIdx].area.Right = lastCell.area.Right;
                                    mergedRst.splice(mergeIdx + 1, 1);
                                }
                                lastCell = mergedRst[mergeIdx];
                            }
                        }
                        rst = rst.concat(mergedRst);
                    }
                }
            }
        }
        return rst;
    }
    ;
    outputRowTabCommon(rptTpl, dataObj, page, bands, tabStr, rowFieldsIdxArr, unitFactor, controls, $CURRENT_RPT, customizeCfg) {
        let me = this, rst = [];
        let tab = rptTpl.交叉表_信息[tabStr];
        let band = (tab) ? bands[tab.BandName] : null;
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[(band.DisplayType)] === true) {
                let tab_fields = tab.cross_field_s;
                let data_details = dataObj[IDataObj_props.detail_data];
                let valuesIdx = me.dispValueIdxLst_Row[page - 1];
                let serialsIdx = me.dispSerialIdxLst_Row[page - 1];
                let flexiblePrecisionRefObj = null, flexibleRefField = null, precision_ref_data = null;
                for (let i = 0; i < rowFieldsIdxArr.length; i++) {
                    let tab_field = tab_fields[i];
                    if (!(tab_field.Hidden)) {
                        let data_field = null;
                        let map_data_field = JE.F(tab_field.FieldID, $CURRENT_RPT);
                        if (typeof rowFieldsIdxArr[i] !== 'object') {
                            data_field = data_details[rowFieldsIdxArr[i]];
                        }
                        else {
                            if (map_data_field) {
                                data_field = map_data_field.data_field;
                            }
                        }
                        let rows = valuesIdx.length;
                        for (let rowIdx = 0; rowIdx < rows; rowIdx++) {
                            if (map_data_field && map_data_field.Precision && map_data_field.flexiblePrecisionRefObj && map_data_field.Precision.flexibleRefFieldID) {
                                if (flexiblePrecisionRefObj === null) {
                                    flexiblePrecisionRefObj = {};
                                    flexibleRefField = JE.F(map_data_field.Precision.flexibleRefFieldID, $CURRENT_RPT);
                                    if (flexibleRefField && flexibleRefField.DataSeq)
                                        precision_ref_data = dataObj[map_data_field.DataNodeName][flexibleRefField.DataSeq];
                                    for (let decimalObj of map_data_field.flexiblePrecisionRefObj) {
                                        flexiblePrecisionRefObj["refUnit_" + decimalObj.unit] = decimalObj.decimal;
                                    }
                                }
                                JpcFieldHelper.resetFlexibleFormat(tab_field, precision_ref_data, flexiblePrecisionRefObj, valuesIdx[rowIdx], customizeCfg);
                            }
                            else {
                                if (rowIdx === 0)
                                    JpcFieldHelper.resetFormat(tab_field, map_data_field, customizeCfg);
                            }
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[rowIdx], serialsIdx[rowIdx], rows, rowIdx, 1, 0, unitFactor, true, controls));
                        }
                    }
                }
            }
        }
        return rst;
    }
    ;
    //暂定
    outputTabField(band, tab_field, data_field, valueIdx, serialIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls) {
        let rst = null;
        if (isRow === true && tab_field.isSerial && tab_field.isSerial === true) {
            if (serialIdx >= 0) {
                rst = JpcCommonOutputHelper.createCommonOutput(tab_field, serialIdx + 1, null);
            }
            else
                rst = JpcCommonOutputHelper.createCommonOutput(tab_field, "", controls);
        }
        else {
            rst = JpcCommonOutputHelper.createCommonOutput(tab_field, JpcFieldHelper.getValue(data_field, valueIdx), controls);
        }
        //position
        if (isRow === true) {
            rst.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, rows, rowIdx, cols, colIdx, 1, 0, true, false);
        }
        else {
            rst.area = JpcAreaHelper.outputArea(tab_field.area, band, unitFactor, rows, rowIdx, cols, colIdx, 1, 0, false, false);
        }
        return rst;
    }
    ;
}
function _addTabValue(tabValuedIdxLst, sortedSequence, segIdx, preRec, nextRec, dispSerialIdxLst, sorted_sum_value_Lst, rst_sum_value_Lst) {
    if (tabValuedIdxLst) {
        let serial1stTier = null;
        if (dispSerialIdxLst)
            serial1stTier = [];
        let pgseg1stTier = [];
        let sumVal = [];
        let sumValL = 1;
        if (sortedSequence) {
            let arrDupVals = sortedSequence[segIdx];
            let arrDupSumVals = null;
            if (sorted_sum_value_Lst !== null) {
                arrDupSumVals = sorted_sum_value_Lst[segIdx];
                sumValL = arrDupSumVals[0].length;
            }
            for (let i = 0; i < nextRec; i++) {
                if (arrDupVals.length <= preRec + i) {
                    pgseg1stTier[i] = VAL_DEF.BLANK_VALUE_INDEX;
                    sumVal[i] = [];
                    for (let ei = 0; ei < sumValL; ei++) {
                        sumVal[i][ei] = null;
                    }
                    if (serial1stTier !== null) {
                        serial1stTier[i] = VAL_DEF.BLANK_VALUE_INDEX;
                    }
                    continue;
                }
                let duplicateValueArr = arrDupVals[preRec + i];
                pgseg1stTier[i] = duplicateValueArr[0];
                if (arrDupSumVals !== null)
                    sumVal[i] = arrDupSumVals[preRec + i];
                if (serial1stTier !== null) {
                    serial1stTier[i] = preRec + i;
                }
            }
            tabValuedIdxLst.push(pgseg1stTier);
            if (dispSerialIdxLst !== null) {
                dispSerialIdxLst.push(serial1stTier);
            }
            if (sorted_sum_value_Lst !== null && rst_sum_value_Lst !== null) {
                rst_sum_value_Lst.push(sumVal);
            }
        }
        else {
            //should push blank value index rather than null
            for (let i = 0; i < nextRec; i++) {
                pgseg1stTier[i] = VAL_DEF.BLANK_VALUE_INDEX;
                sumVal[i] = null;
                if (serial1stTier !== null) {
                    serial1stTier[i] = VAL_DEF.BLANK_VALUE_INDEX;
                }
            }
            tabValuedIdxLst.push(pgseg1stTier);
            if (dispSerialIdxLst !== null) {
                dispSerialIdxLst.push(serial1stTier);
            }
            if (sorted_sum_value_Lst !== null && rst_sum_value_Lst !== null) {
                rst_sum_value_Lst.push(sumVal);
            }
        }
    }
}
function _addContentValue(dispValueIdxLst_Content, sortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, page_seg_map, pageIdx) {
    if (dispValueIdxLst_Content !== null) {
        page_seg_map.push([pageIdx, segIdx]);
        let arrContents = [];
        if (sortedContentSequence !== null) {
            let arrAllContent = sortedContentSequence[segIdx];
            for (let i = 0; i < maxRowRec; i++) {
                arrContents.push([]);
                for (let j = 0; j < maxColRec; j++) {
                    if (arrAllContent.length <= counterRowRec + i || arrAllContent[counterRowRec + i].length <= counterColRec + j) {
                        arrContents[i][j] = VAL_DEF.BLANK_VALUE_INDEX;
                    }
                    else {
                        arrContents[i][j] = arrAllContent[counterRowRec + i][counterColRec + j];
                    }
                }
            }
            dispValueIdxLst_Content.push(arrContents);
        }
        else {
            //should push blank value index rather than null
            for (let i = 0; i < maxRowRec; i++) {
                arrContents.push([]);
                for (let j = 0; j < maxColRec; j++) {
                    arrContents[i][j] = VAL_DEF.BLANK_VALUE_INDEX;
                }
            }
            dispValueIdxLst_Content.push(arrContents);
        }
    }
}
function _SortAndOptimize(rptTpl, dataObj, dataSeq, sortTab, rstFieldsIdx, $CURRENT_RPT) {
    let result = [];
    let tab = rptTpl.交叉表_信息[sortTab];
    if (tab) {
        let sIDX = 0;
        //1. prepare and sort by tab-field
        let fields = [];
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, tab.cross_field_s, fields, rstFieldsIdx, false);
        let data_details = dataObj[IDataObj_props.detail_data];
        JpcCrossTabHelper.sortTabFields(fields, rstFieldsIdx, data_details, dataSeq, $CURRENT_RPT);
        //2. distinguish sort tab fields value
        let b1 = false;
        for (let i = 0; i < dataSeq.length; i++) {
            sIDX = 0;
            let segArr = [];
            if (dataSeq[i].length === 1) {
                JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, 0, 1);
            }
            else {
                for (let j = 1; j < dataSeq[i].length; j++) {
                    b1 = false;
                    for (let k = 0; k < rstFieldsIdx.length; k++) {
                        if (fields[k].hasOwnProperty(VAL_DEF.TAB_FIELD_PROP_SORT)) {
                            //只有被选择了作为排序字段的才进入排序及优化
                            if (typeof (rstFieldsIdx[k]) === 'object') {
                                let map_data_field = JE.F(rstFieldsIdx[k].ID, $CURRENT_RPT);
                                if (map_data_field && map_data_field.data_field[dataSeq[i][j - 1]] !== map_data_field.data_field[dataSeq[i][j]]) {
                                    b1 = true;
                                    break;
                                }
                            }
                            else {
                                if (data_details[rstFieldsIdx[k]][dataSeq[i][j - 1]] !== data_details[rstFieldsIdx[k]][dataSeq[i][j]]) {
                                    b1 = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (b1) {
                        JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, sIDX, j);
                        sIDX = j;
                        if (j === dataSeq[i].length - 1) {
                            JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, j, dataSeq[i].length);
                        }
                    }
                    else if (j === dataSeq[i].length - 1) {
                        JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, sIDX, dataSeq[i].length);
                    }
                }
            }
            if (segArr.length > 0)
                result.push(segArr);
        }
    }
    return result;
}
function _SortForDisplayContent(rptTpl, rowSeq, colSeq, rstFieldsIdx) {
    let result = [];
    let tab = rptTpl.交叉表_信息.交叉数据;
    if (tab) {
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, tab.cross_field_s, [], rstFieldsIdx, false);
    }
    for (let i = 0; i < rowSeq.length; i++) {
        let rl = rowSeq[i], cl = colSeq[i];
        let ds = [];
        //1. initialize to blank value index
        for (let j = 0; j < rl.length; j++) {
            ds.push([]);
            for (let k = 0; k < cl.length; k++) {
                ds[j].push(VAL_DEF.BLANK_VALUE_INDEX);
            }
        }
        //2. then fill up the right index
        for (let j = 0; j < rl.length; j++) {
            let ra = rl[j];
            for (let k = 0; k < ra.length; k++) {
                let colIdx = JpcCrossTabHelper.getColIDX(cl, ra[k]);
                if (colIdx >= 0) {
                    ds[j][colIdx] = ra[k];
                }
            }
        }
        result.push(ds);
    }
    return result;
}

const JpcField = {
    createNew(rptTpl) {
        let me = this;
        let JpcFieldResult = {
            离散指标_集合: {},
            主数据指标_集合: {},
            从数据指标_集合: {},
            无映射离散指标_集合: {},
            主数据指标_拓展集合: {},
            从数据指标_拓展集合: {}
        };
        if (rptTpl.指标_数据_映射 && rptTpl.指标_数据_映射.离散指标_集合) {
            for (let i = 0; i < rptTpl.指标_数据_映射.离散指标_集合.length; i++) {
                me.createSingle(rptTpl.指标_数据_映射.离散指标_集合[i], JpcFieldResult.离散指标_集合, IDataObj_props.discrete_data, i);
            }
        }
        if (rptTpl.指标_数据_映射 && rptTpl.指标_数据_映射.主数据指标_集合) {
            for (let i = 0; i < rptTpl.指标_数据_映射.主数据指标_集合.length; i++) {
                me.createSingle(rptTpl.指标_数据_映射.主数据指标_集合[i], JpcFieldResult.主数据指标_集合, IDataObj_props.master_data, i);
            }
        }
        if (rptTpl.指标_数据_映射 && rptTpl.指标_数据_映射.从数据指标_集合) {
            for (let i = 0; i < rptTpl.指标_数据_映射.从数据指标_集合.length; i++) {
                me.createSingle(rptTpl.指标_数据_映射.从数据指标_集合[i], JpcFieldResult.从数据指标_集合, IDataObj_props.detail_data, i);
            }
        }
        if (rptTpl.无映射离散指标_集合) {
            for (let i = 0; i < rptTpl.无映射离散指标_集合.length; i++) {
                me.createSingle(rptTpl.无映射离散指标_集合[i], JpcFieldResult.无映射离散指标_集合, "NA", -10);
            }
        }
        if (rptTpl.指标_数据_映射 && rptTpl.指标_数据_映射.主数据指标_拓展集合) {
            for (let i = 0; i < rptTpl.指标_数据_映射.主数据指标_拓展集合.length; i++) {
                me.createSingle(rptTpl.指标_数据_映射.主数据指标_拓展集合[i], JpcFieldResult.主数据指标_拓展集合, IDataObj_props.master_data_ex, i);
            }
        }
        if (rptTpl.指标_数据_映射 && rptTpl.指标_数据_映射.从数据指标_拓展集合) {
            for (let i = 0; i < rptTpl.指标_数据_映射.从数据指标_拓展集合.length; i++) {
                me.createSingle(rptTpl.指标_数据_映射.从数据指标_拓展集合[i], JpcFieldResult.从数据指标_拓展集合, IDataObj_props.detail_data_ex, i);
            }
        }
        //NODE_MASTER_FIELDS_EX
        return JpcFieldResult;
    },
    createSingle(fieldNode, parentObj, dataNodeName, sequence) {
        if (fieldNode && fieldNode.ID) {
            let item = {
                ID: fieldNode.ID,
                Name: fieldNode.Name,
                DataType: fieldNode.DataType,
                // Precision : null//  edit by lish
                Precision: {}
            };
            if (fieldNode.Precision) {
                item.Precision = {};
                item.Precision.type = fieldNode.Precision.type;
                if (fieldNode.Precision.type === 'fixed') {
                    item.fixedPrecisionNum = fieldNode.fixedPrecisionNum;
                }
                else {
                    item.Precision.flexibleRefFieldID = fieldNode.Precision.flexibleRefFieldID;
                    item.flexiblePrecisionRefObj = fieldNode.flexiblePrecisionRefObj;
                }
            }
            item.DataNodeName = dataNodeName;
            item.DataSeq = sequence;
            parentObj["ID_" + fieldNode.ID] = item;
        }
    }
};

const JpcParam = {
    createNew(rptTpl) {
        let JpcParamResult = {};
        let me = this;
        if (rptTpl.离散参数_集合) {
            for (let i = 0; i < rptTpl.离散参数_集合.length; i++) {
                me.createSingle(rptTpl.离散参数_集合[i], JpcParamResult, i);
            }
        }
        return JpcParamResult;
    },
    createSingle(paramNode, parentObj, sequence) {
        if (paramNode && paramNode.ID) {
            const item = {
                ID: paramNode.ID,
                Name: paramNode.Name,
                DataType: paramNode.DataType,
                Default_Value: (paramNode.Default_Value) ? paramNode.Default_Value : null,
                DataSeq: sequence
            };
            parentObj[VAL_DEF.PROP_ID + '_' + paramNode.ID] = item;
        }
    }
};

const JpcFunc = {
    createNew(rptTpl) {
        let rst = [];
        if (rptTpl.计算式_集合) {
            for (let i = 0; i < rptTpl.计算式_集合.length; i++) {
                let item = { ...rptTpl.计算式_集合[i] }; // 新的copy规范
                // let propArr = Object.getOwnPropertyNames(rptTpl[JV.NODE_FORMULAS][i]);
                // for (let key of propArr) {
                //     item[key] = rptTpl[JV.NODE_FORMULAS][i][key];
                // }
                rst.push(item);
            }
        }
        return rst;
    }
};

/**
 * Created by Tony on 2019/5/17.
 */
const JpcEvent = {
    createNew(rptTpl) {
        let rst = {
            GRP_ON_CREATE: {},
            FLOW_CONTENT_ON_CREATE: {} //bylish
        };
        if (rptTpl.事件_集合) {
            for (let i = 0; i < rptTpl.事件_集合.length; i++) {
                let item = { ...rptTpl.事件_集合[i] };
                // let propArr = Object.getOwnPropertyNames(rptTpl[JV.NODE_EVENTS][i]);
                // for (let key of propArr) {
                //     item[key] = rptTpl[JV.NODE_EVENTS][i][key];
                // }
                const event_type = [IEvent_type.GRP_ON_CREATE, IEvent_type.FLOW_CONTENT_ON_CREATE];
                switch (event_type.indexOf(item.type)) {
                    case VAL_DEF.EVENT_IDX_GRP_ON_CREATE:
                        rst.FLOW_CONTENT_ON_CREATE = item;
                        break;
                    case VAL_DEF.EVENT_IDX_FLOW_CONTENT_ON_CREATE:
                        rst.FLOW_CONTENT_ON_CREATE = item;
                        break;
                }
                //rst.push(item);
            }
        }
        return rst;
    }
};

const JpcData = {
    createNew() {
        let JpcDataRst = {
            dataSeq: [],
            exDataSeq: [],
            analyzeData(rptTpl, dataObj) {
                let me = this;
                let _analyse = function (MASTER_FIELD_STR, DETAIL_FIELD_STR, MASTER_DATA_STR, DETAIL_DATA_STR, dataSeqArr) {
                    //1. get ID fields
                    let masterIDs = [];
                    if (rptTpl.指标_数据_映射[MASTER_FIELD_STR]) {
                        for (let i = 0; i < rptTpl.指标_数据_映射[MASTER_FIELD_STR].length; i++) {
                            let mstFieldObj = rptTpl.指标_数据_映射[MASTER_FIELD_STR][i];
                            if (JpcCommonHelper.getBoolean(mstFieldObj.isID)) {
                                masterIDs.push({ "idx": i, "seq": mstFieldObj.IDSeq });
                            }
                        }
                    }
                    let detailIDs = [];
                    if (rptTpl.指标_数据_映射[DETAIL_FIELD_STR]) {
                        for (let i = 0; i < rptTpl.指标_数据_映射[DETAIL_FIELD_STR].length; i++) {
                            let dtlFieldObj = rptTpl.指标_数据_映射[DETAIL_FIELD_STR][i];
                            if (JpcCommonHelper.getBoolean(dtlFieldObj.isID)) {
                                detailIDs.push({ "idx": i, "seq": dtlFieldObj.IDSeq });
                            }
                        }
                    }
                    //2. sort the ID fields
                    if (masterIDs.length > 1) {
                        masterIDs.sort(function (a, b) {
                            return 1 * a["seq"] - 1 * b["seq"];
                        });
                    }
                    if (detailIDs.length > 1) {
                        detailIDs.sort(function (a, b) {
                            return 1 * a["seq"] - 1 * b["seq"];
                        });
                    }
                    //3. prepare data sequence
                    if (masterIDs.length > 0) {
                        let mst_dt_len = 0, dtl_dt_len = 0, mst_fields = [];
                        for (let i = 0; i < masterIDs.length; i++) {
                            mst_fields.push(dataObj[MASTER_DATA_STR][masterIDs[i]["idx"]]);
                            mst_dt_len = dataObj[MASTER_DATA_STR][masterIDs[i]["idx"]].length;
                        }
                        let dtl_fields = [];
                        for (let i = 0; i < detailIDs.length; i++) {
                            dtl_fields.push(dataObj[DETAIL_DATA_STR][detailIDs[i]["idx"]]);
                            dtl_dt_len = dataObj[DETAIL_DATA_STR][detailIDs[i]["idx"]].length;
                        }
                        let sIdx = 0;
                        let isEqual = true;
                        for (let i = 0; i < mst_dt_len; i++) {
                            dataSeqArr.push([]);
                            //then compare the master/detail ID-field value
                            for (let j = sIdx; j < dtl_dt_len; j++) {
                                isEqual = true;
                                for (let k = 0; k < mst_fields.length; k++) {
                                    if (!(mst_fields[k][i] === dtl_fields[k][j])) {
                                        isEqual = false;
                                        break;
                                    }
                                }
                                if (isEqual) {
                                    dataSeqArr[i].push(j);
                                }
                                else {
                                    sIdx = j;
                                    //below logic is for the data robustness purpose, to avoid those strange record(detail level) which could not match even one of the master record!
                                    if (i < mst_dt_len - 1 && j < dtl_dt_len - 1) {
                                        for (let j1 = j; j1 < dtl_dt_len; j1++) {
                                            isEqual = true;
                                            for (let k = 0; k < mst_fields.length; k++) {
                                                if (!(mst_fields[k][i + 1] === dtl_fields[k][j1])) {
                                                    isEqual = false;
                                                    break;
                                                }
                                            }
                                            if (isEqual) {
                                                sIdx = j1;
                                                break;
                                            }
                                        }
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    else { //if no master data
                        if (dataObj && dataObj[DETAIL_DATA_STR] && dataObj[DETAIL_DATA_STR].length > 0) {
                            //may be bill type report which may only have discrete fields!
                            let field = dataObj[DETAIL_DATA_STR][0];
                            dataSeqArr.push([]);
                            for (let i = 0; i < field.length; i++) {
                                dataSeqArr[0].push(i);
                            }
                        }
                    }
                };
                if ((rptTpl) && (dataObj)) {
                    _analyse('主数据指标_集合', '从数据指标_集合', IDataObj_props.master_data, IDataObj_props.detail_data, me.dataSeq);
                    if (rptTpl.流水式表_拓展信息) {
                        _analyse('主数据指标_拓展集合', '从数据指标_拓展集合', IDataObj_props.master_data_ex, IDataObj_props.detail_data_ex, me.exDataSeq);
                    }
                }
            }
        };
        return JpcDataRst;
    }
};

class JpcExClass {
    constructor(rptTpl) {
        this.isFollowMode = false;
        this.totalPages = 0;
        this.exTotalPages = 0;
        if (rptTpl.流水式表_信息) {
            this.flowTab = new JpcFlowTabClass(false);
            this.isFollowMode = false;
        }
        if (rptTpl.流水式表_拓展信息) {
            this.flowTabEx = new JpcFlowTabClass(true);
            if (rptTpl.流水式表_拓展信息.流水拓展显示模式 === '紧随模式') {
                this.isFollowMode = true;
            }
        }
        if (rptTpl.账单式表_信息) {
            this.billTab = new JpcBillTabSrvClass();
        }
        //let dt1 = new Date();
        if (rptTpl.交叉表_信息) {
            this.crossTab = new JpcCrossTabClass();
        }
        this.runTimePageData = {};
        this.fields = JpcField.createNew(rptTpl);
        this.params = JpcParam.createNew(rptTpl);
        this.formulas = JpcFunc.createNew(rptTpl);
        this.events = JpcEvent.createNew(rptTpl);
    }
    ;
    analyzeData(rptTpl, dataObj, defProperties, option, outputType) {
        let me = this, dftPagingOption = option || VAL_DEF.PAGING_OPTION_NORMAL;
        //1. data object
        let dataHelper = JpcData.createNew();
        me.executeFormulas(VAL_DEF.RUN_TYPE_BEFORE_ANALYZING, rptTpl, dataObj, me); //在分析前运行，主要是增加灵活性，比如：重新编排数据的主从关系
        if (me.crossTab) {
            me.executeFormulas(VAL_DEF.RUN_TYPE_BEFORE_PAGING, rptTpl, dataObj, me);
            dataHelper.analyzeData(rptTpl, dataObj);
            me.crossTab.sorting(rptTpl, dataObj, dataHelper.dataSeq.slice(0), me);
        }
        else {
            dataHelper.analyzeData(rptTpl, dataObj);
            //2. tab object
            //pre-condition: the data should be sorted in SQL/NoSQL level!
            //let dt1 = new Date();
            if (me.flowTab) {
                me.flowTab.sorting(rptTpl, dataObj, dataHelper.dataSeq.slice(0), me);
                if (me.flowTabEx) {
                    me.flowTabEx.sorting(rptTpl, dataObj, dataHelper.exDataSeq.slice(0), me);
                }
            }
            if (me.billTab) {
                // me.billTab.sorting(rptTpl, dataObj, dataHelper.dataSeq.slice(0), me);
                me.billTab.sorting(rptTpl); //edit by lish,方法中需要的参数只有一个，但是这里存入了4个
            }
            //let dt2 = new Date();
            //alert(dt2 - dt1);
            //3. formulas
            me.executeFormulas(VAL_DEF.RUN_TYPE_BEFORE_PAGING, rptTpl, dataObj, me);
        }
        //4. paging
        me.paging(rptTpl, dataObj, defProperties, dftPagingOption);
        //alert('analyzeData was completed!');
        //for garbage collection:
        // dataHelper = null;
    }
    ;
    paging(rptTpl, dataObj, defProperties, option) {
        let me = this, dftPagingOption = option || VAL_DEF.PAGING_OPTION_NORMAL;
        if (me.flowTab) {
            if (me.isFollowMode) {
                me.totalPages = me.flowTab.preSetupPages(rptTpl, dataObj, defProperties, dftPagingOption, me, me.flowTabEx);
            }
            else {
                me.totalPages = me.flowTab.preSetupPages(rptTpl, dataObj, defProperties, dftPagingOption, me, null);
                if (me.flowTabEx) {
                    me.exTotalPages = me.flowTabEx.preSetupPages(rptTpl, dataObj, defProperties, dftPagingOption, me, null);
                    //console.log('ad-hoc flow pages: ' + me.exTotalPages);
                }
                me.totalPages += me.exTotalPages;
            }
        }
        else if (me.crossTab) {
            //me.totalPages = me.crossTab.preSetupPages(rptTpl, defProperties, dftPagingOption);
            me.totalPages = me.crossTab.preSetupPages(rptTpl, defProperties, VAL_DEF.PAGING_OPTION_NORMAL); //infinity对交叉表来说无意义
        }
        else if (me.billTab) {
            me.totalPages = me.billTab.paging(rptTpl, dataObj);
        }
    }
    ;
    executeFormulas(runType, $CURRENT_TEMPLATE, $CURRENT_DATA, $CURRENT_RPT) {
        let execFmlMe = this;
        for (let execFmlIdx = 0; execFmlIdx < execFmlMe.formulas.length; execFmlIdx++) {
            //remark: 搞这么复杂的变量名是为了防止与表达式起冲突(如循环变量i,j,k，容易造成变量冲突且不容易看出问题)
            if (execFmlMe.formulas[execFmlIdx].run_type === runType) {
                let expression = execFmlMe.formulas[execFmlIdx].expression;
                if (expression) {
                    let $ME = execFmlMe.formulas[execFmlIdx];
                    // console.log("current expression idx: " + execFmlIdx);
                    // console.log(expression);
                    try {
                        eval(expression);
                    }
                    catch (ex) {
                        console.log(ex);
                    }
                }
            }
        }
    }
    ;
    outputAsPreviewPage(rptTpl, defProperties) {
        let me = this, rst = {};
        rst.control_collection = private_buildDftControls(rptTpl, (defProperties === null) ? null : defProperties.ctrls);
        rst.style_collection = private_buildDftStyles(rptTpl, (defProperties === null) ? null : defProperties.styles);
        rst.font_collection = private_buildDftFonts(rptTpl, (defProperties === null) ? null : defProperties.fonts);
        rst.打印页面_信息 = {};
        rst.打印页面_信息.报表名称 = rptTpl.主信息.报表名称;
        rst.打印页面_信息.纸张宽高 = JpcCommonHelper.getPageSize(rptTpl);
        rst.打印页面_信息.页边距 = rptTpl.主信息.页边距;
        rst.items = [];
        let bands = JpcBand.createNew(rptTpl, defProperties);
        try {
            function getPageMergeBorder() {
                let mergeRst = {};
                if (bands.MergeBand) {
                    let mergedBand = bands.MergeBand;
                    mergeRst.Left = parseInt(mergedBand.Left.toFixed(0));
                    mergeRst.Right = parseInt(mergedBand.Right.toFixed(0));
                    mergeRst.Top = parseInt(mergedBand.Top.toFixed(0));
                    mergeRst.Bottom = parseInt(mergedBand.Bottom.toFixed(0));
                }
                return null;
            }
            //1.
            let rstPage = {};
            rstPage.page_seq = 1;
            if (me.flowTab) {
                rstPage.cells = me.flowTab.outputAsPreviewPage(rptTpl, bands, rst.control_collection, me);
            }
            else if (me.crossTab) {
                rstPage.cells = me.crossTab.outputAsPreviewPage(rptTpl, bands, rst.control_collection, me, null); //方法中定义了5个参数，这里只传进去了4个参数，故加一个参数，by lish
            }
            else if (me.billTab) {
                rstPage.cells = me.billTab.outputAsPreviewPage(rptTpl, bands, rst.control_collection, me);
            }
            let pageMergeBorder = getPageMergeBorder();
            if (pageMergeBorder) ;
            rst.items.push(rstPage);
            //2.
            if (bands.MergeBand) {
                let mergedBand = {}, band = bands.MergeBand;
                mergedBand.Left = parseInt(band.Left.toFixed(0));
                mergedBand.Right = parseInt(band.Right.toFixed(0));
                mergedBand.Top = parseInt(band.Top.toFixed(0));
                mergedBand.Bottom = parseInt(band.Bottom.toFixed(0));
                mergedBand.style = band.style;
                rst.MergeBand = mergedBand;
            }
        }
        catch (exception) {
            console.log(exception);
        }
        finally {
            bands = null;
        }
        return rst;
    }
    ;
    outputAsSimpleJSONPageArray(rptTpl, dataObj, startPage, endPage, defProperties, customizeCfg) {
        let me = this, rst = {};
        if ((startPage > 0) && (startPage <= endPage) && (endPage <= me.totalPages)) {
            rst.control_collection = private_buildDftControls(rptTpl, (defProperties === null) ? null : defProperties.ctrls);
            rst.style_collection = private_buildDftStyles(rptTpl, (defProperties === null) ? null : defProperties.styles);
            rst[VAL_DEF.NODE_FONT_COLLECTION] = private_buildDftFonts(rptTpl, (defProperties === null) ? null : defProperties.fonts);
            rst.打印页面_信息 = {};
            rst.打印页面_信息.报表名称 = rptTpl.主信息.报表名称;
            rst.打印页面_信息.纸张宽高 = JpcCommonHelper.getPageSize(rptTpl);
            rst.打印页面_信息.页边距 = rptTpl.主信息.页边距;
            rst.items = [];
            let bands = JpcBand.createNew(rptTpl, defProperties);
            try {
                for (let page = startPage; page <= endPage; page++) {
                    me.runTimePageData.currentPage = page;
                    me.executeFormulas(VAL_DEF.RUN_TYPE_BEFORE_OUTPUT, rptTpl, dataObj, me);
                    rst.items.push(me.outputAsSimpleJSONPage(rptTpl, dataObj, bands, page, rst.control_collection, customizeCfg));
                }
                if (bands.MergeBand) {
                    let mergedBand = {}, band = bands.MergeBand;
                    mergedBand.Left = parseInt(band.Left.toFixed(0));
                    mergedBand.Right = parseInt(band.Right.toFixed(0));
                    mergedBand.Top = parseInt(band.Top.toFixed(0));
                    mergedBand.Bottom = parseInt(band.Bottom.toFixed(0));
                    mergedBand.style = band.style;
                    rst.MergeBand = mergedBand;
                }
            }
            catch (exception) {
                console.log(exception);
            }
            finally {
                bands = null;
            }
        }
        return rst;
    }
    ;
    outputAsSimpleJSONPage(rptTpl, dataObj, bands, page, controls, customizeCfg) {
        let me = this, rst = null;
        function getPageMergeBorder() {
            // let mergeRst = null;
            let mergeRst = {};
            if (bands.MergeBand) {
                let mergedBand = bands.MergeBand;
                mergeRst = {};
                mergeRst.Left = parseInt(mergedBand.Left.toFixed(0));
                mergeRst.Right = parseInt(mergedBand.Right.toFixed(0));
                mergeRst.Top = parseInt(mergedBand.Top.toFixed(0));
                mergeRst.Bottom = parseInt(mergedBand.Bottom.toFixed(0));
            }
            // return mergeRst;
            return false;
        }
        if (me.totalPages >= page) {
            rst = {};
            rst.page_seq = page;
            //rst.cells = [];
            let adHocMergePos = null;
            if (me.flowTab) {
                if (me.totalPages - me.exTotalPages >= page) {
                    if (me.flowTab.paging_option === VAL_DEF.PAGING_OPTION_INFINITY) {
                        adHocMergePos = {};
                    }
                    rst.cells = me.flowTab.outputAsSimpleJSONPage(rptTpl, dataObj, page, bands, controls, adHocMergePos, me, customizeCfg);
                    if (adHocMergePos) {
                        adHocMergePos.纸张宽高 = JpcCommonHelper.getPageSize(rptTpl);
                        rst[VAL_DEF.PAGE_SPECIAL_MERGE_POS] = adHocMergePos;
                    }
                }
                else {
                    if (!me.isFollowMode) {
                        rst.cells = me.flowTabEx.outputAsSimpleJSONPage(rptTpl, dataObj, page - (me.totalPages - me.exTotalPages), bands, controls, adHocMergePos, me, customizeCfg);
                    }
                }
            }
            else if (me.crossTab) {
                rst.cells = me.crossTab.outputAsSimpleJSONPage(rptTpl, dataObj, page, bands, controls, me, customizeCfg);
            }
            else if (me.billTab) {
                rst.cells = me.billTab.outputAsSimpleJSONPage(rptTpl, dataObj, page, bands, controls, me, customizeCfg);
            }
            if (!(me.flowTab && me.flowTab.paging_option === VAL_DEF.PAGING_OPTION_INFINITY)) {
                let pageMergeBorder = getPageMergeBorder();
            }
        }
        return rst;
    }
    ;
}
//暂定
function private_buildDftItems(rptTpl, dftCollection, propArray, nodeName) {
    const rst = {};
    if (dftCollection) {
        for (let i = 0; i < dftCollection.length; i++) {
            const item = {};
            for (let j = 0; j < propArray.length; j++) {
                item[propArray[j]] = dftCollection[i][propArray[j]];
            }
            rst[dftCollection[i].ID] = item;
        }
        if (rptTpl && rptTpl[nodeName] && rptTpl[nodeName].length > 0) {
            for (let i = 0; i < rptTpl[nodeName].length; i++) {
                const rptDftItem = rptTpl[nodeName][i];
                if (rst[rptDftItem.ID] === undefined) {
                    const item = {};
                    for (let j = 0; j < propArray.length; j++) {
                        item[propArray[j]] = rptDftItem[propArray[j]];
                    }
                    rst[rptDftItem.ID] = item;
                }
            }
        }
    }
    return rst;
}
function private_buildDftControls(rptTpl, dftControlCollection) {
    return private_buildDftItems(rptTpl, dftControlCollection, VAL_DEF.CONTROL_PROPS, VAL_DEF.NODE_CONTROL_COLLECTION);
}
function private_buildDftFonts(rptTpl, dftFontCollection) {
    return private_buildDftItems(rptTpl, dftFontCollection, VAL_DEF.FONT_PROPS, VAL_DEF.NODE_FONT_COLLECTION);
}
function private_buildDftStyles(rptTpl, dftStyleCollection) {
    const rst = {};
    function private_CopyBorder(destItem, srcItem) {
        destItem.LineWeight = srcItem.LineWeight;
        destItem.DashStyle = srcItem.DashStyle;
        destItem.Color = srcItem.Color;
    }
    if (dftStyleCollection) {
        for (let i = 0; i < dftStyleCollection.length; i++) {
            const item = {};
            if (dftStyleCollection[i].border_style && dftStyleCollection[i].border_style.length > 0) {
                for (let j = 0; j < dftStyleCollection[i].border_style.length; j++) {
                    const borderItem = {};
                    private_CopyBorder(borderItem, dftStyleCollection[i].border_style[j]);
                    item[dftStyleCollection[i].border_style[j].Position] = borderItem;
                }
            }
            rst[dftStyleCollection[i].ID] = item;
        }
        if (rptTpl && rptTpl.style_collection && rptTpl.style_collection.length > 0) {
            for (let i = 0; i < rptTpl.style_collection.length; i++) {
                const rptDftItem = rptTpl.style_collection[i];
                if (rst[rptDftItem.ID] === undefined) {
                    if (rptDftItem.ID.indexOf('_AutoHeightMerge_Top') > 0) {
                        const key = rptDftItem.ID.substr(0, rptDftItem.ID.indexOf('_AutoHeightMerge_Top'));
                        if (rst[key]) {
                            const item = {};
                            if (rst[key].Left) {
                                item.Left = {};
                                private_CopyBorder(item.Left, rst[key].Left);
                            }
                            if (rst[key].Right) {
                                item.Right = {};
                                private_CopyBorder(item.Right, rst[key].Right);
                            }
                            if (rst[key].Top) {
                                item.Top = {};
                                private_CopyBorder(item.Top, rst[key].Top);
                            }
                            rst[rptDftItem.ID] = item;
                        }
                    }
                    else if (rptDftItem.ID.indexOf('_AutoHeightMerge_Middle') > 0) {
                        const key = rptDftItem.ID.substr(0, rptDftItem.ID.indexOf('_AutoHeightMerge_Middle'));
                        if (rst[key]) {
                            const item = {};
                            if (rst[key].Left) {
                                item.Left = {};
                                private_CopyBorder(item.Left, rst[key].Left);
                            }
                            if (rst[key].Right) {
                                item.Right = {};
                                private_CopyBorder(item.Right, rst[key].Right);
                            }
                            rst[rptDftItem.ID] = item;
                        }
                    }
                    else if (rptDftItem.ID.indexOf('_AutoHeightMerge_Bottom') > 0) {
                        const key = rptDftItem.ID.substr(0, rptDftItem.ID.indexOf('_AutoHeightMerge_Bottom'));
                        if (rst[key]) {
                            const item = {};
                            if (rst[key].Left) {
                                item.Left = {};
                                private_CopyBorder(item.Left, rst[key].Left);
                            }
                            if (rst[key].Right) {
                                item.Right = {};
                                private_CopyBorder(item.Right, rst[key].Right);
                            }
                            if (rst[key].Bottom) {
                                item.Bottom = {};
                                private_CopyBorder(item.Bottom, rst[key].Bottom);
                            }
                            rst[rptDftItem.ID] = item;
                        }
                    }
                    else {
                        const item = {};
                        for (let j = 0; j < rptDftItem.border_style.length; j++) {
                            const borderItem = {};
                            private_CopyBorder(borderItem, rptDftItem.border_style[j]);
                            item[rptDftItem.border_style[j].Position] = borderItem;
                        }
                        rst[rptDftItem.ID] = item;
                    }
                }
            }
        }
    }
    return rst;
}

let JSZip = require("jszip");
const DPI = JpcCommonHelper.getScreenDPI()[0];
const dftHeadXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
const uuidV1 = uuid.v1;
function writeContentTypes(sheets, isSinglePage) {
    const rst = [];
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">');
    // ...
    rst.push('<Override PartName="/xl/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>');
    rst.push('<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>');
    rst.push('<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>');
    rst.push('<Default Extension="xml" ContentType="application/xml"/>');
    rst.push('<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>');
    rst.push('<Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>');
    rst.push('<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>');
    if (isSinglePage) {
        rst.push('<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>');
    }
    else {
        for (let i = 0; i < sheets.length; i++) {
            rst.push(`<Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`);
        }
    }
    rst.push('<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>');
    rst.push('</Types>');
    return rst;
}
function writeRootRels() {
    const rst = [];
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">');
    rst.push('<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>');
    rst.push('<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>');
    rst.push('<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>');
    rst.push('</Relationships>');
    return rst;
}
function writeApp(sheets, isSinglePage) {
    const rst = [];
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">');
    rst.push('<Application>Microsoft Excel</Application>');
    rst.push('<DocSecurity>0</DocSecurity>');
    rst.push('<ScaleCrop>false</ScaleCrop>');
    rst.push('<HeadingPairs>');
    rst.push('<vt:vector size="2" baseType="variant">');
    rst.push('<vt:variant><vt:lpstr>工作表</vt:lpstr></vt:variant>');
    if (isSinglePage)
        rst.push('<vt:variant><vt:i4>1</vt:i4></vt:variant>');
    else
        rst.push(`<vt:variant><vt:i4>${sheets.length}</vt:i4></vt:variant>`);
    rst.push('</vt:vector>');
    rst.push('</HeadingPairs>');
    rst.push('<TitlesOfParts>');
    if (isSinglePage) {
        rst.push('<vt:vector size="1" baseType="lpstr">');
        rst.push(`<vt:lpstr>${sheets[0].sheetName}</vt:lpstr>`);
    }
    else {
        rst.push(`<vt:vector size="${sheets.length}" baseType="lpstr">`);
        for (let i = 0; i < sheets.length; i++) {
            rst.push(`<vt:lpstr>${sheets[i].sheetName}</vt:lpstr>`);
        }
    }
    rst.push('</vt:vector>');
    rst.push('</TitlesOfParts>');
    rst.push('<Company>SmartCost</Company>');
    rst.push('<LinksUpToDate>false</LinksUpToDate>');
    rst.push('<SharedDoc>false</SharedDoc>');
    rst.push('<HyperlinksChanged>false</HyperlinksChanged>');
    rst.push('<AppVersion>12.0000</AppVersion>');
    rst.push('</Properties>');
    return rst;
}
function writeCore() {
    const rst = [];
    const p_fillZero = function (val) {
        let _rst = val;
        if (val < 10) {
            _rst = `0${val}`;
        }
        return _rst;
    };
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">');
    rst.push('<dc:creator>SmartCost</dc:creator>');
    rst.push('<cp:lastModifiedBy>SmartCost</cp:lastModifiedBy>');
    const dt = new Date();
    dt.setDate(dt.getDate() - 8 / 24); // it's GMT time, so please add the server offset time ( -8 hours )
    const dtStr = `${dt.getFullYear()}-${p_fillZero(dt.getMonth() + 1)}-${p_fillZero(dt.getDate())}T${p_fillZero(dt.getHours())}:${p_fillZero(dt.getMinutes())}:${p_fillZero(dt.getSeconds())}Z`;
    rst.push(`<dcterms:created xsi:type="dcterms:W3CDTF">${dtStr}</dcterms:created>`);
    rst.push(`<dcterms:modified xsi:type="dcterms:W3CDTF">${dtStr}</dcterms:modified>`);
    // rst.push('');
    rst.push('</cp:coreProperties>');
    return rst;
}
function writeXlWorkBook(sheets, isSinglePage) {
    const rst = [];
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">');
    rst.push('<fileVersion appName="xl" lastEdited="4" lowestEdited="4" rupBuild="4505"/>');
    rst.push('<workbookPr defaultThemeVersion="124226"/>');
    rst.push('<bookViews><workbookView xWindow="360" yWindow="345" windowWidth="14655" windowHeight="4305"/></bookViews>');
    rst.push('<sheets>');
    if (isSinglePage) {
        rst.push(`<sheet name="${sheets[0].sheetName}" sheetId="1" r:id="rId1"/>`);
    }
    else {
        for (let i = 0; i < sheets.length; i++) {
            rst.push(`<sheet name="${sheets[i].sheetName}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`);
        }
    }
    rst.push('</sheets>');
    rst.push('<calcPr calcId="124519"/>');
    rst.push('</workbook>');
    return rst;
}
function writeXlRels(sheets, isSinglePage) {
    const rst = [];
    let idx = 1;
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">');
    if (isSinglePage) {
        rst.push(`<Relationship Id="rId${idx}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>`);
        idx++;
    }
    else {
        for (let i = 0; i < sheets.length; i++) {
            rst.push(`<Relationship Id="rId${idx}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`);
            idx++;
        }
    }
    rst.push(`<Relationship Id="rId${idx}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="theme/theme1.xml"/>`);
    idx++;
    rst.push(`<Relationship Id="rId${idx}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`);
    idx++;
    rst.push(`<Relationship Id="rId${idx}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`);
    rst.push('</Relationships>');
    return rst;
}
function writeTheme() {
    const rst = fs.readFileSync(`${__dirname}/excel_base_files/theme1.xml`, 'utf8');
    return rst;
}
function writeStyles(stylesObj) {
    const rst = [];
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">');
    // 1. push fonts
    rst.push(`<fonts count="${stylesObj.fonts.length}">`);
    for (let i = 0; i < stylesObj.fonts.length; i++) {
        const font = stylesObj.fonts[i];
        rst.push('<font>');
        if (strUtil.convertStrToBoolean(font[VAL_DEF.FONT_PROPS[3]])) {
            rst.push('<b/>');
        }
        if (strUtil.convertStrToBoolean(font[VAL_DEF.FONT_PROPS[4]])) {
            rst.push('<i/>');
        }
        if (strUtil.convertStrToBoolean(font[VAL_DEF.FONT_PROPS[5]])) {
            rst.push('<u/>');
        }
        rst.push(`<sz val="${font.size}"/>`);
        rst.push(`<color indexed="${font.colorIdx}"/>`);
        rst.push(`<name val="${font[VAL_DEF.FONT_PROPS[0]]}"/>`);
        rst.push(`<charset val="${font.charset}"/>`);
        rst.push('</font>');
    }
    rst.push('</fonts>');
    // 2. push default fills
    rst.push('<fills count="2"><fill><patternFill patternType="none" /></fill><fill><patternFill patternType="gray125" /></fill></fills>');
    // 3. push borders
    rst.push(`<borders count="${stylesObj.borders.length}">`);
    const private_setBorder = function (border, borderDirection) {
        if (parseInt(border[borderDirection][VAL_DEF.PROP_LINE_WEIGHT]) === 0) {
            rst.push(`<${borderDirection.toLowerCase()}/>`);
        }
        else {
            let bW = 'thin';
            if (parseInt(border[borderDirection][VAL_DEF.PROP_LINE_WEIGHT]) === 2)
                bW = 'medium';
            if (parseInt(border[borderDirection][VAL_DEF.PROP_LINE_WEIGHT]) > 2)
                bW = 'thick';
            rst.push(`<${borderDirection.toLowerCase()} style="${bW}">` +
                `<color indexed="64"/>` +
                `</${borderDirection.toLowerCase()}>`);
        }
    };
    for (let i = 0; i < stylesObj.borders.length; i++) {
        const border = stylesObj.borders[i];
        rst.push('<border>');
        private_setBorder(border, VAL_DEF.PROP_LEFT);
        private_setBorder(border, VAL_DEF.PROP_RIGHT);
        private_setBorder(border, VAL_DEF.PROP_TOP);
        private_setBorder(border, VAL_DEF.PROP_BOTTOM);
        rst.push('<diagonal />');
        rst.push('</border>');
    }
    rst.push('</borders>');
    // 4. push cellStyleXfs
    rst.push('<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"><alignment vertical="center"/></xf></cellStyleXfs>');
    // 5. push cellXfs
    rst.push(`<cellXfs count="${stylesObj.cellXfs.length}">`);
    for (let i = 0; i < stylesObj.cellXfs.length; i++) {
        const excelStyle = stylesObj.cellXfs[i];
        rst.push(`<xf numFmtId="0" fontId="${excelStyle.fontId}" fillId="0" borderId="${excelStyle.borderId}" xfId="0">`);
        // pageData[JV.NODE_FONT_COLLECTION] excelStyle.fontId
        let alignStr = '<alignment';
        let textRotation = 0;
        let newHorizontal = excelStyle[VAL_DEF.CONTROL_PROPS[2]];
        let newVertical = excelStyle[VAL_DEF.CONTROL_PROPS[3]];
        if (excelStyle[VAL_DEF.CONTROL_PROPS[5]] &&
            !strUtil.convertStrToBoolean(excelStyle[VAL_DEF.CONTROL_PROPS[VAL_DEF.CONTROL_PROP_IDX_CLOSE_OUTPUT]])) {
            newVertical = excelStyle[VAL_DEF.CONTROL_PROPS[5]];
        }
        if (parseInt(excelStyle.fontAngle) !== 0) {
            let tmpH = newHorizontal;
            let tmpV = newVertical;
            if (excelStyle.fontAngle > 0) {
                textRotation = 180;
                if (newHorizontal === 'left') {
                    tmpV = 'top';
                }
                else if (newHorizontal === 'right') {
                    tmpV = 'bottom';
                }
                else {
                    tmpV = 'center';
                }
                if (newVertical === 'top') {
                    tmpH = 'right';
                }
                else if (newVertical === 'bottom') {
                    tmpH = 'left';
                }
                else if (newVertical === 'justify') {
                    tmpH = 'justify';
                }
                else {
                    tmpH = 'center';
                }
            }
            else {
                textRotation = 90;
                if (newHorizontal === 'left') {
                    tmpV = 'bottom';
                }
                else if (newHorizontal === 'right') {
                    tmpV = 'top';
                }
                else {
                    tmpV = 'center';
                }
                if (newVertical === 'top') {
                    tmpH = 'left';
                }
                else if (newVertical === 'bottom') {
                    tmpH = 'right';
                }
                else {
                    tmpH = 'center';
                }
            }
            newHorizontal = tmpH;
            newVertical = tmpV;
        }
        alignStr += ` horizontal="${newHorizontal}" vertical="${newVertical}"`;
        if (strUtil.convertStrToBoolean(excelStyle[VAL_DEF.CONTROL_PROPS[0]])) {
            alignStr += ' shrinkToFit="1"';
        }
        if (strUtil.convertStrToBoolean(excelStyle[VAL_DEF.CONTROL_PROPS[4]]) &&
            !strUtil.convertStrToBoolean(excelStyle[VAL_DEF.CONTROL_PROPS[6]])) {
            alignStr += ' wrapText="1"';
        }
        if (textRotation !== 0) {
            alignStr += ` textRotation="${textRotation}"`;
        }
        alignStr += '/>';
        rst.push(alignStr);
        rst.push('</xf>');
    }
    rst.push('</cellXfs>');
    // 6. others (xfl style / dxfs / tableStyles)
    rst.push('<cellStyles count="1"><cellStyle name="常规" xfId="0" builtinId="0"/></cellStyles>');
    rst.push('<dxfs count="0"/>');
    rst.push('<tableStyles count="0" defaultTableStyle="TableStyleMedium9" defaultPivotStyle="PivotStyleLight16"/>');
    rst.push('</styleSheet>');
    return rst;
}
function writeSharedString(sharedStrList) {
    const rst = [];
    const pri_func_write = function (cellVal) {
        if (cellVal !== null) {
            if (typeof cellVal === 'string' && cellVal.indexOf(' ') === 0) {
                rst.push(`<si><t xml:space="preserve">${cellVal}</t></si>`);
            }
            else {
                rst.push(`<si><t>${cellVal}</t></si>`);
            }
        }
    };
    if (sharedStrList && sharedStrList.length > 0) {
        rst.push(`${dftHeadXml}\r\n`);
        rst.push(`<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${sharedStrList.length}" uniqueCount="${sharedStrList.length}">`);
        const regExp = new RegExp('<', 'gm');
        for (let i = 0; i < sharedStrList.length; i++) {
            if (typeof sharedStrList[i] === 'string') {
                // 转换特殊字符，如 < , 则需要转义一下
                sharedStrList[i] = sharedStrList[i].replace(regExp, '&lt;');
                if (sharedStrList[i].indexOf('|') >= 0) {
                    // rst.push('<si><t>' + sharedStrList[i].split('|').join('\r\n') + '</t></si>');
                    // rst.push('<si><t>' + sharedStrList[i].split('|').join('\n') + '</t></si>');
                    pri_func_write(sharedStrList[i].split('|').join('\n'));
                }
                else {
                    // rst.push('<si><t>' + sharedStrList[i] + '</t></si>');
                    pri_func_write(sharedStrList[i]);
                }
                // rst.push('<si><t>' + sharedStrList[i].replace('|','\r\n') + '</t></si>');
            }
            else {
                // rst.push('<si><t>' + sharedStrList[i] + '</t></si>');
                pri_func_write(sharedStrList[i]);
            }
        }
        rst.push('</sst>');
    }
    return rst;
}
function _setupPgBrks(pageData) {
    pageData.pageBreaks = [];
    let pgBrkIdx = 0;
    const pgBrk = [];
    for (const page of pageData.items) {
        const maxBottomArr = [];
        for (const cell of page.cells) {
            if (maxBottomArr.indexOf(cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM]) < 0) {
                maxBottomArr.push(cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM]);
            }
        }
        pgBrkIdx += maxBottomArr.length;
        pgBrk.push(pgBrkIdx);
    }
    pageData.pageBreaks.push(pgBrk);
}
function writeSheets(pageData, paperSize, sharedStrList, stylesObj, isSinglePage, custSheetMergeBands) {
    const rst = [];
    const private_pushDftFont = function () {
        const font = {};
        if (!stylesObj.fonts) {
            stylesObj.fonts = [];
        }
        font[VAL_DEF.FONT_PROPS[0]] = '宋体'; // font name
        font.size = 12;
        font.charset = 134;
        font.colorIdx = '8';
        stylesObj.fonts.push(font);
    };
    const private_buildFirstDftStyle = function () {
        stylesObj.cellXfs = [];
        stylesObj.borders = [];
        const fontId = 0;
        const borderId = 0;
        const border = {};
        border[VAL_DEF.PROP_LEFT] = {};
        border[VAL_DEF.PROP_LEFT][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        border[VAL_DEF.PROP_RIGHT] = {};
        border[VAL_DEF.PROP_RIGHT][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        border[VAL_DEF.PROP_TOP] = {};
        border[VAL_DEF.PROP_TOP][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        border[VAL_DEF.PROP_BOTTOM] = {};
        border[VAL_DEF.PROP_BOTTOM][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        stylesObj.borders.push(border);
        const cellControl = pageData[VAL_DEF.NODE_CONTROL_COLLECTION].Default;
        const sheetControl = {};
        sheetControl.fontId = fontId;
        sheetControl.borderId = borderId;
        sheetControl.fontAngle = 0;
        for (let i = 0; i < VAL_DEF.CONTROL_PROPS.length; i++) {
            sheetControl[VAL_DEF.CONTROL_PROPS[i]] = cellControl[VAL_DEF.CONTROL_PROPS[i]];
        }
        stylesObj.cellXfs.push(sheetControl);
    };
    private_pushDftFont();
    private_buildFirstDftStyle();
    if (isSinglePage) {
        rst.push(writeSheet(pageData, null, paperSize, sharedStrList, stylesObj, null, true, -1));
    }
    else {
        for (let i = 0; i < pageData.items.length; i++) {
            let appointedMergeBand = null;
            if (custSheetMergeBands && custSheetMergeBands.length > i) {
                appointedMergeBand = custSheetMergeBands[i];
            }
            rst.push(writeSheet(pageData, pageData.items[i], paperSize, sharedStrList, stylesObj, appointedMergeBand, i === 0, i));
        }
    }
    return rst;
}
function writeSheet(pageData, sheetData, paperSize, sharedStrList, stylesObj, appointedMergeBand, isFirstSheet, pgBrkIdx) {
    const rst = [];
    const xPos = [];
    let yPos = [];
    const yMultiPos = [];
    let currentMergeBorder = null;
    const headerStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    let currentPageMergePos = null; // 在 JV.PAGING_OPTION_INFINITY 场合应用
    const private_pre_analyze_pos = function () {
        let cell;
        let pos;
        const self_analyze_sheet_pos = function (theShtData, theXPos, theYPos) {
            // theShtData.cells.sort(function(cell1, cell2) {
            //     let rst = 0;
            //     if (cell1[JV.PROP_AREA][JV.PROP_TOP] > cell2[JV.PROP_AREA][JV.PROP_TOP]) {
            //         rst = 1;
            //     } else if (cell1[JV.PROP_AREA][JV.PROP_TOP] < cell2[JV.PROP_AREA][JV.PROP_TOP]) {
            //         rst = -1;
            //     } else {
            //         if (cell1[JV.PROP_AREA][JV.PROP_LEFT] > cell2[JV.PROP_AREA][JV.PROP_LEFT]) {
            //             rst = 1;
            //         } else if (cell1[JV.PROP_AREA][JV.PROP_LEFT] < cell2[JV.PROP_AREA][JV.PROP_LEFT]) {
            //             rst = -1;
            //         }
            //     }
            //     return rst;
            // });
            for (let i = 0; i < theShtData.cells.length; i++) {
                cell = theShtData.cells[i];
                pos = cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_LEFT];
                if (theXPos.indexOf(pos) < 0)
                    theXPos.push(pos);
                pos = cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_RIGHT];
                if (theXPos.indexOf(pos) < 0)
                    theXPos.push(pos);
                pos = cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP];
                if (theYPos.indexOf(pos) < 0)
                    theYPos.push(pos);
                pos = cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM];
                if (theYPos.indexOf(pos) < 0)
                    theYPos.push(pos);
            }
        };
        xPos.push(0);
        if (sheetData) {
            // current sheet data
            yPos.push(0);
            self_analyze_sheet_pos(sheetData, xPos, yPos);
            xPos.sort(private_array_sort);
            yPos.sort(private_array_sort);
        }
        else {
            // total data in one sheet
            const marginBottomPos = Math.round((pageData[VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_PAGE_SIZE][1] -
                parseFloat(pageData[VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_MARGINS][VAL_DEF.PROP_BOTTOM]) /
                    2.54) *
                DPI);
            for (const shtItemData of pageData.items) {
                const tmpPos = [];
                tmpPos.push(0);
                self_analyze_sheet_pos(shtItemData, xPos, tmpPos);
                tmpPos.sort(private_array_sort);
                if (marginBottomPos - tmpPos[tmpPos.length - 1] > 10) {
                    // 此逻辑是为了防止打印跨页(假设有些报表模板高度设置离底部margin还好远，导出excel后预览时会发现跨页现象(即下一页的某几行数据会挪到前一页来预览))
                    tmpPos.push(marginBottomPos - 10);
                }
                yMultiPos.push(tmpPos);
            }
            xPos.sort(private_array_sort);
            yPos = yMultiPos[0];
        }
    };
    let private_array_sort = function (i1, i2) {
        let rst = 0;
        if (i1 > i2) {
            rst = 1;
        }
        else if (i1 < i2)
            rst = -1;
        return rst;
    };
    const private_getCellIdxStr = function (idx) {
        let rst = 'A';
        if (idx < 26) {
            rst = headerStr[idx];
        }
        else if (idx < 26 * 26 + 26) {
            const ti = Math.floor(idx / 26);
            const tj = idx % 26;
            rst = headerStr[ti - 1] + headerStr[tj];
        }
        else if (idx < 26 * 26 * 26 + 26) {
            const ti = Math.floor(idx / (26 * 26));
            const tj = Math.floor((idx - ti * 26 * 26) / 26);
            const tk = idx % 26;
            rst = headerStr[ti - 1] + headerStr[tj - 1] + headerStr[tk];
        }
        return rst;
    };
    const private_getSharedStrIdx = function (val) {
        let strVal = val;
        if (val === null ||
            val === undefined ||
            (typeof val === 'number' && isNaN(val))) {
            strVal = '';
        }
        let rst = sharedStrList.indexOf(strVal);
        if (rst < 0) {
            sharedStrList.push(strVal);
            rst = sharedStrList.length - 1;
        }
        return rst;
    };
    const private_getFontId = function (cell) {
        let rst = 0;
        let hasFont = false;
        if (!stylesObj.fonts) {
            stylesObj.fonts = [];
            // for (let i = 0; i < sheetData.font_collection)
        }
        let sheetFont = null;
        if (typeof cell[VAL_DEF.PROP_FONT] === 'string') {
            sheetFont = pageData[VAL_DEF.NODE_FONT_COLLECTION][cell[VAL_DEF.PROP_FONT]];
        }
        else {
            sheetFont = cell[VAL_DEF.PROP_FONT];
        }
        for (let i = 0; i < stylesObj.fonts.length; i++) {
            const font = stylesObj.fonts[i];
            if (sheetFont) {
                // if (font[JV.FONT_PROPS[0]] === sheetFont[JV.FONT_PROPS[0]] && font.size === Math.round(sheetFont[JV.FONT_PROPS[1]] * 3 / 4)
                if (font[VAL_DEF.FONT_PROPS[0]] === sheetFont[VAL_DEF.FONT_PROPS[0]] &&
                    font.size === Math.floor((sheetFont[VAL_DEF.FONT_PROPS[1]] * 3) / 4) &&
                    font[VAL_DEF.FONT_PROPS[3]] === sheetFont[VAL_DEF.FONT_PROPS[3]] &&
                    font[VAL_DEF.FONT_PROPS[4]] === sheetFont[VAL_DEF.FONT_PROPS[4]] &&
                    font[VAL_DEF.FONT_PROPS[5]] === sheetFont[VAL_DEF.FONT_PROPS[5]]) {
                    hasFont = true;
                    rst = i;
                    break;
                }
            }
            else {
                break;
            }
        }
        if (!hasFont) {
            const font = {};
            font[VAL_DEF.FONT_PROPS[0]] = sheetFont[VAL_DEF.FONT_PROPS[0]]; // font name
            // font.size = Math.round(sheetFont[JV.FONT_PROPS[1]] * 3 / 4);
            font.size = Math.floor((sheetFont[VAL_DEF.FONT_PROPS[1]] * 3) / 4);
            font.charset = 134;
            font.colorIdx = '8';
            font[VAL_DEF.FONT_PROPS[3]] = sheetFont[VAL_DEF.FONT_PROPS[3]]; // font bold
            font[VAL_DEF.FONT_PROPS[4]] = sheetFont[VAL_DEF.FONT_PROPS[4]]; // font italic
            font[VAL_DEF.FONT_PROPS[5]] = sheetFont[VAL_DEF.FONT_PROPS[5]]; // font underline
            stylesObj.fonts.push(font);
            rst = stylesObj.fonts.length - 1;
        }
        return rst;
    };
    const private_checkBorder = function (cell, border, sheetBorder) {
        let rst = true;
        const borderLineWidths = [];
        const sheetBorderLineWidths = [];
        borderLineWidths.push(border[VAL_DEF.PROP_LEFT][VAL_DEF.PROP_LINE_WEIGHT]);
        borderLineWidths.push(border[VAL_DEF.PROP_RIGHT][VAL_DEF.PROP_LINE_WEIGHT]);
        borderLineWidths.push(border[VAL_DEF.PROP_TOP][VAL_DEF.PROP_LINE_WEIGHT]);
        borderLineWidths.push(border[VAL_DEF.PROP_BOTTOM][VAL_DEF.PROP_LINE_WEIGHT]);
        if (sheetBorder[VAL_DEF.PROP_LEFT] &&
            sheetBorder[VAL_DEF.PROP_LEFT][VAL_DEF.PROP_LINE_WEIGHT]) {
            sheetBorderLineWidths.push(private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_LEFT, true));
        }
        else {
            sheetBorderLineWidths.push(0);
        }
        if (sheetBorder[VAL_DEF.PROP_RIGHT] &&
            sheetBorder[VAL_DEF.PROP_RIGHT][VAL_DEF.PROP_LINE_WEIGHT]) {
            sheetBorderLineWidths.push(private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_RIGHT, true));
        }
        else {
            sheetBorderLineWidths.push(0);
        }
        if (sheetBorder[VAL_DEF.PROP_TOP] &&
            sheetBorder[VAL_DEF.PROP_TOP][VAL_DEF.PROP_LINE_WEIGHT]) {
            sheetBorderLineWidths.push(private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_TOP, false));
        }
        else {
            sheetBorderLineWidths.push(0);
        }
        if (sheetBorder[VAL_DEF.PROP_BOTTOM] &&
            sheetBorder[VAL_DEF.PROP_BOTTOM][VAL_DEF.PROP_LINE_WEIGHT]) {
            sheetBorderLineWidths.push(private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_BOTTOM, false));
        }
        else {
            sheetBorderLineWidths.push(0);
        }
        for (let i = 0; i < 4; i++) {
            if (borderLineWidths[i] != sheetBorderLineWidths[i]) {
                rst = false;
                break;
            }
        }
        return rst;
    };
    let private_chkAndGetMergeLine = function (cell, sheetBorder, borderStr, needFurtherChk) {
        let rst = 0;
        // mergeBorder = (sheetData)?sheetData[JV.PROP_PAGE_MERGE_BORDER]:pageData[JV.BAND_PROP_MERGE_BAND],
        const mergeBorder = currentMergeBorder;
        let mergeBand = pageData[VAL_DEF.BAND_PROP_MERGE_BAND];
        if (appointedMergeBand !== null) {
            mergeBand = appointedMergeBand;
        }
        if (sheetBorder[borderStr] &&
            sheetBorder[borderStr][VAL_DEF.PROP_LINE_WEIGHT] !== undefined) {
            rst = sheetBorder[borderStr][VAL_DEF.PROP_LINE_WEIGHT];
        }
        if (currentPageMergePos) {
            const side = currentPageMergePos[borderStr];
            if (side.indexOf(cell[VAL_DEF.PROP_AREA][borderStr]) >= 0) {
                if (needFurtherChk) {
                    const topSide = currentPageMergePos[VAL_DEF.PROP_TOP];
                    const bottomSide = currentPageMergePos[VAL_DEF.PROP_BOTTOM];
                    for (let i = 0; i < topSide.length; i++) {
                        if (cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP] >= topSide[i]) {
                            if (cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM] <= bottomSide[i]) {
                                const destStyle = pageData[VAL_DEF.NODE_STYLE_COLLECTION][mergeBand[VAL_DEF.PROP_STYLE][VAL_DEF.PROP_ID]];
                                rst = destStyle[borderStr][VAL_DEF.PROP_LINE_WEIGHT];
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
                else {
                    const destStyle = pageData[VAL_DEF.NODE_STYLE_COLLECTION][mergeBand[VAL_DEF.PROP_STYLE][VAL_DEF.PROP_ID]];
                    rst = destStyle[borderStr][VAL_DEF.PROP_LINE_WEIGHT];
                }
            }
        }
        else if (cell[VAL_DEF.PROP_AREA][borderStr] === mergeBorder[borderStr]) {
            const destStyle = pageData[VAL_DEF.NODE_STYLE_COLLECTION][mergeBand[VAL_DEF.PROP_STYLE][VAL_DEF.PROP_ID]];
            if (needFurtherChk) {
                if (cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP] >= mergeBorder[VAL_DEF.PROP_TOP] &&
                    cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM] <= mergeBorder[VAL_DEF.PROP_BOTTOM]) {
                    rst = destStyle[borderStr][VAL_DEF.PROP_LINE_WEIGHT];
                }
            }
            else {
                rst = destStyle[borderStr][VAL_DEF.PROP_LINE_WEIGHT];
            }
        }
        return parseInt(rst);
    };
    const private_getIniBorder = function () {
        const rst = {};
        rst[VAL_DEF.PROP_LEFT] = {};
        rst[VAL_DEF.PROP_LEFT][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        rst[VAL_DEF.PROP_RIGHT] = {};
        rst[VAL_DEF.PROP_RIGHT][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        rst[VAL_DEF.PROP_TOP] = {};
        rst[VAL_DEF.PROP_TOP][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        rst[VAL_DEF.PROP_BOTTOM] = {};
        rst[VAL_DEF.PROP_BOTTOM][VAL_DEF.PROP_LINE_WEIGHT] = 0;
        return rst;
    };
    const private_getBorderId = function (cell) {
        let rst = 0;
        let hasBorder = false;
        if (!stylesObj.borders) {
            stylesObj.borders = [];
        }
        const sheetBorder = pageData[VAL_DEF.NODE_STYLE_COLLECTION][cell.style];
        const mergedBorder = private_getIniBorder();
        mergedBorder[VAL_DEF.PROP_LEFT][VAL_DEF.PROP_LINE_WEIGHT] = private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_LEFT, true);
        mergedBorder[VAL_DEF.PROP_RIGHT][VAL_DEF.PROP_LINE_WEIGHT] = private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_RIGHT, true);
        mergedBorder[VAL_DEF.PROP_TOP][VAL_DEF.PROP_LINE_WEIGHT] = private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_TOP, false);
        mergedBorder[VAL_DEF.PROP_BOTTOM][VAL_DEF.PROP_LINE_WEIGHT] = private_chkAndGetMergeLine(cell, sheetBorder, VAL_DEF.PROP_BOTTOM, false);
        for (let i = 0; i < stylesObj.borders.length; i++) {
            const border = stylesObj.borders[i];
            if (private_checkBorder(cell, border, mergedBorder)) {
                hasBorder = true;
                rst = i;
                break;
            }
        }
        if (!hasBorder) {
            stylesObj.borders.push(mergedBorder);
            rst = stylesObj.borders.length - 1;
        }
        return rst;
    };
    const private_checkControl = function (cellControl, sheetControl) {
        let rst = true;
        for (let i = 0; i < VAL_DEF.CONTROL_PROPS.length; i++) {
            if (cellControl[VAL_DEF.CONTROL_PROPS[i]] != sheetControl[VAL_DEF.CONTROL_PROPS[i]]) {
                rst = false;
                break;
            }
        }
        return rst;
    };
    const private_getStyleId = function (cell) {
        let rst = 1;
        let hasStyle = false;
        if (!stylesObj.cellXfs)
            stylesObj.cellXfs = [];
        const fontId = private_getFontId(cell);
        let fontAngle = 0;
        if (typeof cell[VAL_DEF.PROP_FONT] === 'string') {
            fontAngle = parseInt(pageData[VAL_DEF.NODE_FONT_COLLECTION][cell[VAL_DEF.PROP_FONT]].FontAngle);
        }
        else {
            fontAngle = parseInt(cell[VAL_DEF.PROP_FONT].FontAngle);
        }
        const borderId = private_getBorderId(cell);
        let cellControl = null;
        if (typeof cell[VAL_DEF.PROP_CONTROL] === 'string') {
            cellControl = pageData[VAL_DEF.NODE_CONTROL_COLLECTION][cell[VAL_DEF.PROP_CONTROL]];
        }
        else {
            cellControl = cell[VAL_DEF.PROP_CONTROL];
        }
        for (let i = 0; i < stylesObj.cellXfs.length; i++) {
            const sheetControl = stylesObj.cellXfs[i];
            if (sheetControl.fontId === fontId &&
                sheetControl.borderId === borderId) {
                if (private_checkControl(cellControl, sheetControl)) {
                    rst = i;
                    hasStyle = true;
                    break;
                }
            }
        }
        if (!hasStyle) {
            const sheetControl = {};
            sheetControl.fontId = fontId;
            sheetControl.borderId = borderId;
            sheetControl.fontAngle = fontAngle;
            for (let i = 0; i < VAL_DEF.CONTROL_PROPS.length; i++) {
                sheetControl[VAL_DEF.CONTROL_PROPS[i]] = cellControl[VAL_DEF.CONTROL_PROPS[i]];
            }
            stylesObj.cellXfs.push(sheetControl);
            rst = stylesObj.cellXfs.length - 1;
        }
        return rst;
    };
    const private_setCols = function () {
        // remark: 1 excel unit width = 2.117 mm
        rst.push('<cols>');
        let w = 0;
        for (let i = 1; i < xPos.length - 1; i++) {
            w = (((1.0 * (xPos[i + 1] - xPos[i])) / DPI) * 25.4) / 2.117;
            w = Math.round(w * 1000) / 1000;
            rst.push(`<col min="${i}" max="${i}" width="${w}" customWidth="1"/>`);
        }
        rst.push(`<col min="${xPos.length - 1}" max="${xPos.length - 1}" width="${10}" customWidth="1"/>`);
        rst.push('</cols>');
    };
    const private_setMergedCells = function () {
        let cell;
        let idxR;
        let idxL;
        let idxT;
        let idxB;
        let cnt = 0;
        rst.push('<mergeCells count="?">');
        const startIdx = rst.length - 1;
        const self_setMergedCells = function (theData, theYPos, offsetY) {
            for (let i = 0; i < theData.cells.length; i++) {
                cell = theData.cells[i];
                idxR = xPos.indexOf(cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_RIGHT]);
                idxL = xPos.indexOf(cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_LEFT]);
                idxB = theYPos.indexOf(cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM]);
                idxT = theYPos.indexOf(cell[VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP]);
                if (idxR - idxL > 1 || idxB - idxT > 1) {
                    rst.push(`<mergeCell ref="${private_getCellIdxStr(idxL - 1)}${idxT + offsetY}:${private_getCellIdxStr(idxR - 2)}${idxB - 1 + offsetY}"/>`);
                    cnt++;
                }
            }
        };
        if (sheetData) {
            self_setMergedCells(sheetData, yPos, 0);
        }
        else {
            let osY = 0;
            for (let i = 0; i < pageData.items.length; i++) {
                const shtItemData = pageData.items[i];
                const tmpPos = yMultiPos[i];
                self_setMergedCells(shtItemData, tmpPos, osY);
                osY += tmpPos.length - 2;
            }
        }
        rst[startIdx] = `<mergeCells count="${cnt}">`;
        rst.push('</mergeCells>');
    };
    const private_setSheetData = function () {
        // remark: 1 excel unit height = 0.3612 mm
        rst.push('<sheetData>');
        const spanX = xPos.length - 2;
        let h = 0;
        const self_setDataEx = function (theShtData, theYPos, offsetY) {
            const rows = [];
            // 1. build full set of blank rows/cells
            for (let i = 1; i < theYPos.length - 1; i++) {
                const rowObj = {};
                h = (((theYPos[i + 1] - theYPos[i]) / DPI) * 25.4) / 0.3612;
                h = Math.round(h * 1000) / 1000;
                rowObj.height = h;
                rowObj.r = i + offsetY;
                rowObj.items = [];
                rows.push(rowObj);
                for (let j = 1; j < xPos.length - 1; j++) {
                    const colIdxStr = private_getCellIdxStr(j - 1);
                    const cellObj = {};
                    cellObj.r = colIdxStr + (i + offsetY);
                    cellObj.s = 0;
                    cellObj.isBlank = true;
                    rows[i - 1].items.push(cellObj);
                }
            }
            // 2. then fill up the cell style-ids and values
            let rowIdx1 = 0;
            let colIdx1 = 0;
            let rowIdx2 = 0;
            let colIdx2 = 0;
            for (let cIdx = 0; cIdx < theShtData.cells.length; cIdx++) {
                const styleIdx = private_getStyleId(theShtData.cells[cIdx]);
                // colIdxStr = private_getCellIdxStr(j - 1);
                rowIdx1 = theYPos.indexOf(theShtData.cells[cIdx][VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP]);
                colIdx1 = xPos.indexOf(theShtData.cells[cIdx][VAL_DEF.PROP_AREA][VAL_DEF.PROP_LEFT]);
                let cellObj = rows[rowIdx1 - 1].items[colIdx1 - 1];
                cellObj.s = styleIdx;
                cellObj.isBlank = false;
                if (!strUtil.isEmptyString(theShtData.cells[cIdx][VAL_DEF.PROP_VALUE])) {
                    const valIdx = private_getSharedStrIdx(theShtData.cells[cIdx][VAL_DEF.PROP_VALUE]);
                    cellObj.v = valIdx;
                }
                rowIdx2 = theYPos.indexOf(theShtData.cells[cIdx][VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM]);
                colIdx2 = xPos.indexOf(theShtData.cells[cIdx][VAL_DEF.PROP_AREA][VAL_DEF.PROP_RIGHT]);
                if (rowIdx2 - rowIdx1 > 1 || colIdx2 - colIdx1 > 1) {
                    for (let i = 0; i < rowIdx2 - rowIdx1; i++) {
                        for (let j = 0; j < colIdx2 - colIdx1; j++) {
                            if (i === 0 && j === 0)
                                continue;
                            cellObj = rows[rowIdx1 - 1 + i].items[colIdx1 - 1 + j];
                            cellObj.s = styleIdx;
                            cellObj.isBlank = true;
                        }
                    }
                }
            }
            // 3. then fill up rst
            for (let i = 0; i < rows.length; i++) {
                rst.push(`<row r="${i + 1 + offsetY}" spans="1:${spanX}" ht="${rows[i].height}" customHeight="1">`);
                for (let j = 0; j < rows[i].items.length; j++) {
                    const cellObj = rows[i].items[j];
                    if (cellObj.v === undefined) {
                        rst.push(`<c r="${cellObj.r}" s="${cellObj.s}"/>`);
                    }
                    else {
                        rst.push(`<c r="${cellObj.r}" s="${cellObj.s}" t="s">`);
                        rst.push(`<v>${cellObj.v}</v>`);
                        rst.push('</c>');
                    }
                }
                rst.push('</row>');
            }
            // 4. maybe need to dispose the memory
            // ...
        };
        if (sheetData) {
            // current sheet data
            currentPageMergePos = sheetData[VAL_DEF.PAGE_SPECIAL_MERGE_POS];
            currentMergeBorder = sheetData[VAL_DEF.PROP_PAGE_MERGE_BORDER];
            self_setDataEx(sheetData, yPos, 0);
        }
        else {
            // total data in one sheet
            let cnt = 0;
            for (let i = 0; i < pageData.items.length; i++) {
                const shtItemData = pageData.items[i];
                currentPageMergePos = shtItemData[VAL_DEF.PAGE_SPECIAL_MERGE_POS];
                currentMergeBorder = shtItemData[VAL_DEF.PROP_PAGE_MERGE_BORDER];
                const tmpPos = yMultiPos[i];
                self_setDataEx(shtItemData, tmpPos, cnt);
                cnt += tmpPos.length - 2;
            }
        }
        rst.push('</sheetData>');
    };
    private_pre_analyze_pos();
    rst.push(`${dftHeadXml}\r\n`);
    rst.push('<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">');
    const colStr = private_getCellIdxStr(xPos.length - 3);
    rst.push(`<dimension ref="A1:${colStr}${yPos.length}"/>`);
    if (isFirstSheet) {
        rst.push('<sheetViews><sheetView showGridLines="1" tabSelected="1" workbookViewId="0">');
    }
    else {
        rst.push('<sheetViews><sheetView showGridLines="1" workbookViewId="0">');
    }
    // rst.push('<selection sqref="A1:' + colStr + '1"/>');
    rst.push('<selection sqref="A1:A1"/>');
    rst.push('</sheetView></sheetViews>');
    rst.push('<sheetFormatPr defaultRowHeight="13.5"/>');
    private_setCols();
    private_setSheetData();
    private_setMergedCells();
    rst.push('<phoneticPr fontId="1" type="noConversion"/>');
    // rst.push('<pageMargins left="0.315" right="0.215" top="0.315" bottom="0.315" header="0" footer="0"/>');
    rst.push(`<pageMargins left="${parseFloat(pageData[VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_MARGINS][VAL_DEF.PROP_LEFT]) *
        0.39375}" right="0.215" top="0.315" bottom="0.315" header="0" footer="0"/>`);
    const paperSizeIdx = VAL_DEF.PAGES_SIZE_STR.indexOf(paperSize);
    let pStr = '';
    if (paperSizeIdx >= 0) {
        pStr = `paperSize="${VAL_DEF.PAGES_SIZE_IDX[paperSizeIdx]}"`;
    }
    let orientationStr = pageData[VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_PAGE_SIZE][0] >
        pageData[VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_PAGE_SIZE][1]
        ? 'landscape'
        : 'portrait';
    if (currentPageMergePos) {
        orientationStr =
            currentPageMergePos[VAL_DEF.NODE_PAGE_SIZE][0] >
                currentPageMergePos[VAL_DEF.NODE_PAGE_SIZE][1]
                ? 'landscape'
                : 'portrait';
    }
    rst.push(`<pageSetup ${pStr} fitToWidth="0" fitToHeight="0" orientation="${orientationStr}" />`);
    rst.push('<headerFooter alignWithMargins="0"/>');
    // 插入分页符---------------------------
    if (pageData.pageBreaks) {
        let pgBrks = [];
        if (sheetData !== null) {
            pgBrks = pageData.pageBreaks[pgBrkIdx];
        }
        else {
            pgBrks = pageData.pageBreaks[0];
        }
        if (pgBrks.length > 1) {
            rst.push(`<rowBreaks count="${pgBrks.length}" manualBreakCount="${pgBrks.length}" >`);
            for (let pbi = 0; pbi < pgBrks.length; pbi++) {
                rst.push(`<brk id="${pgBrks[pbi]}" max="16383" man="1" />`);
            }
            rst.push('</rowBreaks>');
        }
    }
    // 插入分页符结束---------------------------
    rst.push('</worksheet>');
    return rst;
}
function mergeProperties(orgObj, newObj) {
    const orgPropArr = [];
    const newPropArr = [];
    for (const p in orgObj) {
        orgPropArr.push(p);
    }
    for (const p in newObj) {
        newPropArr.push(p);
    }
    for (let i = 0; i < newPropArr.length; i++) {
        if (orgPropArr.indexOf(newPropArr[i]) < 0) {
            orgObj[newPropArr[i]] = newObj[newPropArr[i]];
        }
    }
}
var rpt_excel_util = {
    exportExcel(pageData, paperSize, outputPath, options, custSheetNames, custSheetMergeBands, callback) {
        const rptOptions = { singlePage: false, fileName: 'report' };
        if (options === 'true' || options === true) {
            rptOptions.singlePage = true;
        }
        const isSinglePage = rptOptions.singlePage;
        const sheets = [];
        if (isSinglePage) {
            // 加分页符(分页符要在外部处理好)-------------------
            _setupPgBrks(pageData);
            // 加分页符结束-------------------
            sheets.push({ sheetName: '全部页' });
        }
        else if (custSheetNames &&
            custSheetNames.length === pageData.items.length) {
            for (let i = 0; i < pageData.items.length; i++) {
                sheets.push({ sheetName: custSheetNames[i] });
            }
        }
        else {
            for (let i = 0; i < pageData.items.length; i++) {
                sheets.push({ sheetName: `第${i + 1}页` });
            }
        }
        // 1.
        let file = '[Content_Types].xml';
        let data = writeContentTypes(sheets, isSinglePage);
        const zip = new JSZip();
        zip.file(file, data.join(''), { compression: 'DEFLATE' });
        // 2.
        const zip_rels = zip.folder('_rels');
        file = '.rels';
        data = writeRootRels();
        zip_rels.file(file, data.join(''), { compression: 'DEFLATE' });
        // 3.
        const zip_docProps = zip.folder('docProps');
        file = 'app.xml';
        data = writeApp(sheets, isSinglePage);
        zip_docProps.file(file, data.join(''), { compression: 'DEFLATE' });
        file = 'core.xml';
        data = writeCore();
        zip_docProps.file(file, data.join(''), { compression: 'DEFLATE' });
        // 4.
        const zip_xl = zip.folder('xl');
        file = 'workbook.xml';
        data = writeXlWorkBook(sheets, isSinglePage);
        zip_xl.file(file, data.join(''), { compression: 'DEFLATE' });
        const zip_rels2 = zip_xl.folder('_rels');
        file = 'workbook.xml.rels';
        data = writeXlRels(sheets, isSinglePage);
        zip_rels2.file(file, data.join(''), { compression: 'DEFLATE' });
        // 5.
        const zip_theme = zip_xl.folder('theme');
        file = 'theme1.xml';
        data = writeTheme();
        zip_theme.file(file, data, { compression: 'DEFLATE' });
        // 6.
        const zip_worksheets = zip_xl.folder('worksheets');
        const sharedStrList = [];
        const stylesObj = {};
        data = writeSheets(pageData, paperSize, sharedStrList, stylesObj, isSinglePage, custSheetMergeBands);
        if (isSinglePage) {
            for (let i = 0; i < 1; i++) {
                file = `sheet${i + 1}.xml`;
                zip_worksheets.file(file, data[i].join(''), { compression: 'DEFLATE' });
            }
        }
        else {
            for (let i = 0; i < data.length; i++) {
                file = `sheet${i + 1}.xml`;
                zip_worksheets.file(file, data[i].join(''), { compression: 'DEFLATE' });
            }
        }
        file = 'sharedStrings.xml';
        data = writeSharedString(sharedStrList);
        zip_xl.file(file, data.join(''), { compression: 'DEFLATE' });
        file = 'styles.xml';
        data = writeStyles(stylesObj);
        zip_xl.file(file, data.join(''), { compression: 'DEFLATE' });
        if (outputPath) {
            // let newName = '' + (new Date()).valueOf();
            const newName = uuidV1();
            zip
                .generateNodeStream({ type: 'nodebuffer', streamFiles: true })
                .pipe(fs.createWriteStream(`${outputPath}/tmp/${newName}.xlsx`))
                .on('finish', function () {
                // JSZip generates a readable stream with a "end" event,
                // but is piped here in a writable stream which emits a "finish" event.
                console.log(`${newName}.xlsx was written.`);
                if (callback)
                    callback(newName);
            });
        }
        else {
            // return zip.generateNodeStream({type:'nodebuffer',streamFiles:true});
            return zip;
        }
    },
    exportExcelInOneBook(pageDataArray, paperSize, outputPath, callback) {
        const me = this;
        const newPageData = {};
        // 1. 重新编排一下数据，把一份报表的pageData合并到一起作为一个Sheet输出（需要重新调整数据纵向坐标），多份报表数据就形成多个Sheet
        //   -- 简单来说，就是重新包装数据
        try {
            // 1.1 newPageData外围属性
            const newContrl = {};
            const newFont = {};
            const newStyle = {};
            const custMergeBands = [];
            for (let i = 0; i < pageDataArray.length; i++) {
                mergeProperties(newContrl, pageDataArray[i][VAL_DEF.NODE_CONTROL_COLLECTION]);
                mergeProperties(newFont, pageDataArray[i][VAL_DEF.NODE_FONT_COLLECTION]);
                mergeProperties(newStyle, pageDataArray[i][VAL_DEF.NODE_STYLE_COLLECTION]);
            }
            newPageData[VAL_DEF.NODE_CONTROL_COLLECTION] = newContrl;
            newPageData[VAL_DEF.NODE_FONT_COLLECTION] = newFont;
            newPageData[VAL_DEF.NODE_STYLE_COLLECTION] = newStyle;
            newPageData[VAL_DEF.NODE_PAGE_INFO] = pageDataArray[0][VAL_DEF.NODE_PAGE_INFO];
            newPageData[VAL_DEF.BAND_PROP_MERGE_BAND] =
                pageDataArray[0][VAL_DEF.BAND_PROP_MERGE_BAND];
            // 1.2 重新设置pageDataArray的各个cell的Top/Bottom坐标
            const sheetNames = [];
            const newPagePos = [];
            for (let i = 0; i < pageDataArray.length; i++) {
                let offsetY = 0;
                const mergeBand = {};
                custMergeBands.push(pageDataArray[i][VAL_DEF.BAND_PROP_MERGE_BAND]);
                // 备注：不同的报表有可能有不同的边框，如封面表就是无边框的
                mergeBand[VAL_DEF.PROP_LEFT] = [];
                mergeBand[VAL_DEF.PROP_RIGHT] = [];
                mergeBand[VAL_DEF.PROP_TOP] = [];
                mergeBand[VAL_DEF.PROP_BOTTOM] = [];
                newPagePos.push(mergeBand);
                mergeBand[VAL_DEF.PROP_LEFT].push(pageDataArray[i][VAL_DEF.BAND_PROP_MERGE_BAND][VAL_DEF.PROP_LEFT]);
                mergeBand[VAL_DEF.PROP_RIGHT].push(pageDataArray[i][VAL_DEF.BAND_PROP_MERGE_BAND][VAL_DEF.PROP_RIGHT]);
                sheetNames.push(pageDataArray[i][VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_MAIN_INFO_RPT_NAME]);
                // 加分页符(分页符要在外部处理好)-------------------
                _setupPgBrks(pageDataArray[i]);
                // 加分页符结束-------------------
                for (let j = 0; j < pageDataArray[i].items.length; j++) {
                    let maxY = 0;
                    let minY = 100000;
                    if (pageDataArray[i].items[j][VAL_DEF.PAGE_SPECIAL_MERGE_POS]) {
                        let pos = pageDataArray[i].items[j][VAL_DEF.PAGE_SPECIAL_MERGE_POS][VAL_DEF.PROP_TOP][0] + offsetY;
                        mergeBand[VAL_DEF.PROP_TOP].push(pos);
                        pos =
                            pageDataArray[i].items[j][VAL_DEF.PAGE_SPECIAL_MERGE_POS][VAL_DEF.PROP_BOTTOM][0] + offsetY;
                        mergeBand[VAL_DEF.PROP_BOTTOM].push(pos);
                    }
                    else if (pageDataArray[i].items[j][VAL_DEF.PROP_PAGE_MERGE_BORDER]) {
                        let pos = pageDataArray[i].items[j][VAL_DEF.PROP_PAGE_MERGE_BORDER][VAL_DEF.PROP_TOP] + offsetY;
                        mergeBand[VAL_DEF.PROP_TOP].push(pos);
                        pos =
                            pageDataArray[i].items[j][VAL_DEF.PROP_PAGE_MERGE_BORDER][VAL_DEF.PROP_BOTTOM] + offsetY;
                        mergeBand[VAL_DEF.PROP_BOTTOM].push(pos);
                    }
                    else {
                        mergeBand[VAL_DEF.PROP_TOP].push(pageDataArray[i][VAL_DEF.BAND_PROP_MERGE_BAND][VAL_DEF.PROP_TOP] + offsetY);
                        mergeBand[VAL_DEF.PROP_BOTTOM].push(pageDataArray[i][VAL_DEF.BAND_PROP_MERGE_BAND][VAL_DEF.PROP_BOTTOM] +
                            offsetY);
                    }
                    for (let k = 0; k < pageDataArray[i].items[j].cells.length; k++) {
                        if (maxY <
                            pageDataArray[i].items[j].cells[k][VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM]) {
                            maxY =
                                pageDataArray[i].items[j].cells[k][VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM];
                        }
                        if (minY >
                            pageDataArray[i].items[j].cells[k][VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP]) {
                            minY =
                                pageDataArray[i].items[j].cells[k][VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP];
                        }
                        pageDataArray[i].items[j].cells[k][VAL_DEF.PROP_AREA][VAL_DEF.PROP_BOTTOM] += offsetY;
                        pageDataArray[i].items[j].cells[k][VAL_DEF.PROP_AREA][VAL_DEF.PROP_TOP] += offsetY;
                    }
                    const bottomGap = Math.round((pageDataArray[i][VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_PAGE_SIZE][1] -
                        parseFloat(pageDataArray[i][VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_MARGINS][VAL_DEF.PROP_BOTTOM]) /
                            2.54) *
                        DPI) - maxY;
                    offsetY += maxY - minY;
                    if (bottomGap > 10) {
                        offsetY += bottomGap - 10;
                    }
                }
            }
            // 2. newPageData的items属性及相关分页符
            newPageData.items = [];
            newPageData.pageBreaks = [];
            for (let i = 0; i < pageDataArray.length; i++) {
                const pageItem = {};
                pageItem[VAL_DEF.PROP_PAGE_SEQ] = i + 1;
                pageItem[VAL_DEF.PROP_CELLS] = [];
                for (let j = 0; j < pageDataArray[i].items.length; j++) {
                    for (let k = 0; k < pageDataArray[i].items[j].cells.length; k++) {
                        pageItem[VAL_DEF.PROP_CELLS].push(pageDataArray[i].items[j].cells[k]);
                    }
                }
                newPagePos[i][VAL_DEF.NODE_PAGE_SIZE] =
                    pageDataArray[i][VAL_DEF.NODE_PAGE_INFO][VAL_DEF.NODE_PAGE_SIZE];
                pageItem[VAL_DEF.PAGE_SPECIAL_MERGE_POS] = newPagePos[i];
                newPageData.items.push(pageItem);
                // 重新分配分页符()------------------
                if (pageDataArray[i].pageBreaks.length === 1) {
                    newPageData.pageBreaks.push(pageDataArray[i].pageBreaks[0]);
                }
                else {
                    newPageData.pageBreaks.push([]);
                }
                // 重新分配分页符结束------------------
            }
            // 3. everything is ok, then call me
            me.exportExcel(newPageData, paperSize, outputPath, 'false', sheetNames, custMergeBands, callback);
            // fsUtil.writeObjToFile(newPageData, 'D:/GitHome/ConstructionOperation/tmp/combinedHeader.js');
        }
        catch (e) {
            console.log(e);
        }
    },
};

exports.core = JpcExClass;
exports.excel_util = rpt_excel_util;