office-viewer 0.2.1 → 0.3.0

package/lib/excel/sheet/getViewPointData.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var CellData = require('../types/worksheet/CellData.js');
+
+/**
+ * 计算单元格的高宽，主要是得考虑合并单元格的情况
+ * @param row
+ * @param col
+ * @param rowHeight
+ * @param colWidth
+ * @param mergeCells
+ * @returns
+ */
+function calcCellDisplaySize(row, col, rowHeight, colWidth, getRowHeight, getColWidth, mergeCells) {
+    var e_1, _a;
+    var displayWidth = colWidth;
+    var displayHeight = rowHeight;
+    var isMergeCell = false;
+    var matchMergeCell = undefined;
+    // 用于标识是哪个合并单元格
+    var mergeCellId = '';
+    try {
+        for (var mergeCells_1 = tslib.__values(mergeCells), mergeCells_1_1 = mergeCells_1.next(); !mergeCells_1_1.done; mergeCells_1_1 = mergeCells_1.next()) {
+            var mergeCell = mergeCells_1_1.value;
+            var startRow = mergeCell.startRow, endRow = mergeCell.endRow, startCol = mergeCell.startCol, endCol = mergeCell.endCol;
+            mergeCellId = "".concat(startRow, "-").concat(endRow, "-").concat(startCol, "-").concat(endCol);
+            if (row >= startRow && row <= endRow && col >= startCol && col <= endCol) {
+                isMergeCell = true;
+                matchMergeCell = mergeCell;
+                // 补上合并单元格的高宽
+                if (startRow !== endRow) {
+                    for (var i = row + 1; i <= endRow; i++) {
+                        displayHeight += getRowHeight(i);
+                    }
+                }
+                if (startCol !== endCol) {
+                    for (var i = col + 1; i <= endCol; i++) {
+                        displayWidth += getColWidth(i);
+                    }
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (mergeCells_1_1 && !mergeCells_1_1.done && (_a = mergeCells_1.return)) _a.call(mergeCells_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        isMergeCell: isMergeCell,
+        mergeCell: matchMergeCell,
+        mergeCellId: mergeCellId,
+        displayHeight: displayHeight,
+        displayWidth: displayWidth
+    };
+}
+/**
+ * 返回可视区域的数据及位置信息，拆分函数方便但要测试
+ */
+function getViewPointData(getSheetRowData, getMergeCells, getRowHeight, getColWidth, viewRange) {
+    var e_2, _a, e_3, _b;
+    var rows = viewRange.rows, rowSizes = viewRange.rowSizes, cols = viewRange.cols, colSizes = viewRange.colSizes;
+    var displayData = [];
+    var mergeCells = getMergeCells();
+    // 已经渲染的合并单元格
+    var renderedMergeCell = new Set();
+    var rIndex = 0;
+    try {
+        for (var rows_1 = tslib.__values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+            var rowIndex = rows_1_1.value;
+            var rowHeight = rowSizes[rIndex].size;
+            var rowData = getSheetRowData(rowIndex);
+            var cIndex = 0;
+            try {
+                for (var cols_1 = (e_3 = void 0, tslib.__values(cols)), cols_1_1 = cols_1.next(); !cols_1_1.done; cols_1_1 = cols_1.next()) {
+                    var colIndex = cols_1_1.value;
+                    var colWidth = colSizes[cIndex].size;
+                    if (rowData[colIndex] !== undefined) {
+                        var value = rowData[colIndex];
+                        var displayWidth = colWidth;
+                        var displayHeight = rowHeight;
+                        var needClear = false;
+                        // 是否忽略渲染，这种情况主要是发生在合并单元格的时候
+                        var ignore = false;
+                        if (mergeCells.length) {
+                            var displaySize = calcCellDisplaySize(rowIndex, colIndex, rowHeight, colWidth, getRowHeight, getColWidth, mergeCells);
+                            if (displaySize.isMergeCell) {
+                                displayWidth = displaySize.displayWidth;
+                                displayHeight = displaySize.displayHeight;
+                                if (CellData.hasValue(value)) {
+                                    needClear = true;
+                                    renderedMergeCell.add(displaySize.mergeCellId);
+                                }
+                                else {
+                                    // 没有值的情况下，不需要渲染
+                                    ignore = true;
+                                    // 还有另一个情况是在合并单元格下，第一个单元格不再显示，这时需要手动将第一个单元格信息补上
+                                    // 目前这个逻辑是比较复杂，但目前这样做性能最好
+                                    if (!renderedMergeCell.has(displaySize.mergeCellId) &&
+                                        displaySize.mergeCell) {
+                                        // 反算第一个单元格的位置
+                                        var x = colSizes[cIndex].offset;
+                                        var y = rowSizes[rIndex].offset;
+                                        var _c = displaySize.mergeCell, startCol = _c.startCol, startRow = _c.startRow;
+                                        // 当前单元格相对于第一个单元格在 x 方向的偏移
+                                        var xOffset = 0;
+                                        for (var i = startCol; i < colIndex; i++) {
+                                            xOffset += getColWidth(i);
+                                        }
+                                        x -= xOffset;
+                                        // 当前单元格相对于第一个单元格在 y 方向的偏移
+                                        var yOffset = 0;
+                                        for (var i = startRow; i < rowIndex; i++) {
+                                            yOffset += getRowHeight(i);
+                                        }
+                                        y == yOffset;
+                                        var value_1 = getSheetRowData(startRow)[startCol];
+                                        displayData.push({
+                                            x: x,
+                                            y: y,
+                                            width: displayWidth + xOffset,
+                                            height: displayHeight + yOffset,
+                                            row: startRow,
+                                            col: startCol,
+                                            value: value_1,
+                                            needClear: true
+                                        });
+                                        // 避免再次添加
+                                        renderedMergeCell.add(displaySize.mergeCellId);
+                                    }
+                                }
+                            }
+                        }
+                        if (!ignore) {
+                            displayData.push({
+                                x: colSizes[cIndex].offset,
+                                y: rowSizes[rIndex].offset,
+                                width: displayWidth,
+                                height: displayHeight,
+                                row: rowIndex,
+                                col: colIndex,
+                                value: value,
+                                needClear: needClear
+                            });
+                        }
+                    }
+                    cIndex++;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (cols_1_1 && !cols_1_1.done && (_b = cols_1.return)) _b.call(cols_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            rIndex++;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return displayData;
+}
+
+exports.calcCellDisplaySize = calcCellDisplaySize;
+exports.getViewPointData = getViewPointData;

package/lib/excel/sheet/getViewRange.d.ts

@@ -0,0 +1,68 @@
+import { Size, ViewRange } from './ViewRange';
+export interface RangeInfo {
+    /**
+     * 索引列表
+     */
+    indexes: number[];
+    /**
+     * 起始偏移量
+     */
+    startOffset: number;
+    /**
+     * 每个索引的尺寸信息
+     */
+    sizes: Size[];
+    /**
+     * 最大长度
+     */
+    length: number;
+}
+/**
+ * 索引位置缓存信息
+ */
+export interface IndexInfo {
+    offset: number;
+    size: number;
+}
+/**
+ * 影藏列范围
+ */
+export interface HiddenRange {
+    min: number;
+    max: number;
+}
+/**
+ * 使用二分查找第一个大于等于目标值的索引，也就是在某个偏移量下能看到的第一个单元格
+ * @param rangeCache
+ * @param target
+ * @returns
+ */
+export declare function findStartInCache(rangeCache: IndexInfo[], target: number): number;
+/**
+ * 获取范围内的索引列表
+ * @param offset 滚动条偏移
+ * @param shift 表头导致的偏移
+ * @param totalLength 总长度
+ * @param getHeight 获取长度的方法
+ * @param hiddenRange 隐藏的范围
+ * @param rangeCache 位置信息缓存
+ * @returns
+ */
+export declare function getRange(offset: number, shift: number, totalLength: number, getHeight: (index: number) => number, hiddenRange?: HiddenRange[], rangeCache?: IndexInfo[]): RangeInfo;
+/**
+ * 获取视口范围的单元格区域，拆分单独函数是为了方便单元测试，这部分逻辑不需要依赖 UI 展现
+ *
+ * @param scrollLeft 水平滚动条
+ * @param scrollTop 垂直滚动条
+ * @param leftShift 左偏移量，主要是表头导致的偏移量
+ * @param topShift 上偏移量，主要是表头导致的偏移量
+ * @param height 窗口高度
+ * @param width 窗口宽度
+ * @param defaultRowHeight 行默认高度
+ * @param defaultColWidth 列默认宽度
+ * @param customRowHeight 自定义行高
+ * @param customColWidth 自定义列宽
+ *
+ * @returns 从 0 开始的行和列，以及初始的坐标
+ */
+export declare function getViewRange(scrollLeft: number, scrollTop: number, leftShift: number, topShift: number, height: number, width: number, getRowHeight: (index: number) => number, rowPositionCache: IndexInfo[] | undefined, getColWidth: (index: number) => number, colPositionCache?: IndexInfo[], colHiddenRange?: HiddenRange[]): ViewRange;

package/lib/excel/sheet/getViewRange.js

@@ -0,0 +1,199 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+
+/**
+ * 使用二分查找第一个大于等于目标值的索引，也就是在某个偏移量下能看到的第一个单元格
+ * @param rangeCache
+ * @param target
+ * @returns
+ */
+function findStartInCache(rangeCache, target) {
+    var start = 0, end = rangeCache.length - 1;
+    var found = -1;
+    while (start < end) {
+        var mid = Math.floor((start + end) / 2);
+        var indexInfo = rangeCache[mid];
+        // 找不到说明 bug 了
+        if (!indexInfo) {
+            console.error('findStartInCache indexInfo is undefined');
+            break;
+        }
+        var indexRange = indexInfo.offset + indexInfo.size;
+        if (indexRange === target) {
+            found = mid;
+            break;
+        }
+        else if (indexRange < target) {
+            start = mid + 1;
+        }
+        else {
+            end = mid;
+        }
+    }
+    if (found !== -1) {
+        return found;
+    }
+    else {
+        return start;
+    }
+}
+/**
+ * 获取范围内的索引列表
+ * @param offset 滚动条偏移
+ * @param shift 表头导致的偏移
+ * @param totalLength 总长度
+ * @param getHeight 获取长度的方法
+ * @param hiddenRange 隐藏的范围
+ * @param rangeCache 位置信息缓存
+ * @returns
+ */
+function getRange(offset, shift, totalLength, getHeight, hiddenRange, rangeCache) {
+    var e_1, _a;
+    if (hiddenRange === void 0) { hiddenRange = []; }
+    if (rangeCache === void 0) { rangeCache = []; }
+    // 从零开始遍历直到找到
+    var foundStart = false;
+    var foundEnd = false;
+    var index = 0;
+    var startOffset = 0;
+    var currentOffset = 0;
+    // 这些都不能为 undefined，避免后面计算死循环
+    offset = offset || 0;
+    totalLength = totalLength || 0;
+    var indexes = [];
+    var sizes = [];
+    var MAX_LOOP = 10000;
+    var loop = 0;
+    if (rangeCache.length) {
+        var lastRangeCache = rangeCache[rangeCache.length - 1];
+        if (lastRangeCache.offset < offset) {
+            index = rangeCache.length;
+            currentOffset = lastRangeCache.offset;
+        }
+        else {
+            var foundIndex = findStartInCache(rangeCache, offset);
+            // 这时肯定有找到，为 -1 基本上是 bug
+            if (foundIndex !== -1) {
+                index = foundIndex;
+                currentOffset = rangeCache[index].offset;
+            }
+        }
+    }
+    while (!(foundStart && foundEnd)) {
+        try {
+            // 如果有隐藏列就直接跳到下一个不隐藏的列，避免很大隐藏列导致性能卡顿
+            for (var hiddenRange_1 = (e_1 = void 0, tslib.__values(hiddenRange)), hiddenRange_1_1 = hiddenRange_1.next(); !hiddenRange_1_1.done; hiddenRange_1_1 = hiddenRange_1.next()) {
+                var range = hiddenRange_1_1.value;
+                if (index >= range.min && index <= range.max) {
+                    index = range.max + 1;
+                    // 将索引信息加入到缓存中，只处理一次
+                    if (range.max > rangeCache.length - 1) {
+                        for (var i = range.min; i <= range.max; i++) {
+                            rangeCache[i] = {
+                                offset: currentOffset,
+                                size: 0
+                            };
+                        }
+                    }
+                    continue;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (hiddenRange_1_1 && !hiddenRange_1_1.done && (_a = hiddenRange_1.return)) _a.call(hiddenRange_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var cellLength = getHeight(index) || 0;
+        rangeCache[index] = {
+            offset: currentOffset,
+            size: cellLength
+        };
+        // 第一次大于 offset 就找到了开始位置
+        if (currentOffset + cellLength >= offset && !foundStart) {
+            startOffset = currentOffset - offset;
+            foundStart = true;
+            indexes.push(index);
+            sizes.push({
+                size: cellLength,
+                offset: currentOffset - offset + shift
+            });
+            currentOffset += cellLength;
+            index = index + 1;
+            continue;
+        }
+        // 第一次大于结束位置就找到了结束位置
+        if (currentOffset + cellLength >= offset + totalLength && !foundEnd) {
+            foundEnd = true;
+            indexes.push(index);
+            sizes.push({
+                size: cellLength,
+                offset: currentOffset - offset + shift
+            });
+        }
+        // 中间节点
+        if (foundStart && !foundEnd) {
+            indexes.push(index);
+            sizes.push({
+                size: cellLength,
+                offset: currentOffset - offset + shift
+            });
+        }
+        currentOffset += cellLength;
+        // 避免是死循环
+        if (loop++ > MAX_LOOP) {
+            console.error('getRange loop too many times');
+            break;
+        }
+        index = index + 1;
+    }
+    return {
+        indexes: indexes,
+        sizes: sizes,
+        startOffset: startOffset,
+        length: totalLength + shift
+    };
+}
+/**
+ * 获取视口范围的单元格区域，拆分单独函数是为了方便单元测试，这部分逻辑不需要依赖 UI 展现
+ *
+ * @param scrollLeft 水平滚动条
+ * @param scrollTop 垂直滚动条
+ * @param leftShift 左偏移量，主要是表头导致的偏移量
+ * @param topShift 上偏移量，主要是表头导致的偏移量
+ * @param height 窗口高度
+ * @param width 窗口宽度
+ * @param defaultRowHeight 行默认高度
+ * @param defaultColWidth 列默认宽度
+ * @param customRowHeight 自定义行高
+ * @param customColWidth 自定义列宽
+ *
+ * @returns 从 0 开始的行和列，以及初始的坐标
+ */
+function getViewRange(scrollLeft, scrollTop, leftShift, topShift, height, width, getRowHeight, rowPositionCache, getColWidth, colPositionCache, colHiddenRange) {
+    if (rowPositionCache === void 0) { rowPositionCache = []; }
+    if (colPositionCache === void 0) { colPositionCache = []; }
+    if (colHiddenRange === void 0) { colHiddenRange = []; }
+    var _a = getRange(scrollTop, topShift, height, getRowHeight, [], rowPositionCache), rows = _a.indexes, startRowOffset = _a.startOffset, rowSizes = _a.sizes;
+    var _b = getRange(scrollLeft, leftShift, width, getColWidth, colHiddenRange, colPositionCache), cols = _b.indexes, startColOffset = _b.startOffset, colSizes = _b.sizes;
+    return {
+        region: 'normal',
+        rows: rows,
+        rowSizes: rowSizes,
+        height: height,
+        startRowOffset: startRowOffset,
+        cols: cols,
+        colSizes: colSizes,
+        width: width,
+        startColOffset: startColOffset
+    };
+}
+
+exports.findStartInCache = findStartInCache;
+exports.getRange = getRange;
+exports.getViewRange = getViewRange;

package/lib/excel/sheet/table/__test__/calcTableRelativePosition.test.d.ts

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

package/lib/excel/sheet/table/applyTableStyle.d.ts

@@ -0,0 +1,5 @@
+import { CT_Table } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+export declare function applyTableStyle(cellInfo: CellInfo, tablePart: CT_Table, ref: RangeRef, sheet: Sheet, row: number, col: number): void;

package/lib/excel/sheet/table/applyTableStyle.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var presetTableStyles = require('../../io/excel/preset/presetTableStyles.js');
+var applyDxf = require('../applyDxf.js');
+var buildTableStyle = require('./buildTableStyle.js');
+var calcTableRelativePosition = require('./calcTableRelativePosition.js');
+
+function applyTableStyle(cellInfo, tablePart, ref, sheet, row, col) {
+    var _a;
+    var headerRowCount = (_a = tablePart.headerRowCount) !== null && _a !== void 0 ? _a : 1;
+    var totalsRowShown = tablePart.totalsRowShown || true;
+    var totalsRowCount = tablePart.totalsRowCount || 0;
+    // 这是来自 MS-OI29500 P291 的说明，如果 totalsRowCount 为 0，那么 totalsRowShown 必须为 true
+    if (totalsRowCount > 0) {
+        totalsRowShown = true;
+    }
+    var tableStyleInfo = tablePart.tableStyleInfo;
+    if (!tableStyleInfo) {
+        console.warn('表格缺少 tableStyleInfo 字段', tablePart);
+        return;
+    }
+    var name = tableStyleInfo.name;
+    // 表格名称
+    if (!name) {
+        console.warn('表格缺少 name 字段', tablePart);
+        return;
+    }
+    var tableStyle = presetTableStyles.presetTableStyles[name];
+    if (!tableStyle) {
+        console.warn('未知的表格样式', name);
+        return;
+    }
+    var tablePosition = calcTableRelativePosition.calcTableRelativePosition(ref, function (r) { return sheet.isRowHidden(r); }, function (c) { return sheet.isColHidden(c); }, row, col, headerRowCount, totalsRowCount, totalsRowShown);
+    var showFirstColumn = tableStyleInfo.showFirstColumn || false;
+    var showLastColumn = tableStyleInfo.showLastColumn || false;
+    var showRowStripes = tableStyleInfo.showRowStripes || false;
+    var showColumnStripes = tableStyleInfo.showColumnStripes || false;
+    var dxfs = tableStyle.dxfs.dxf || [];
+    var tableStyles = buildTableStyle.buildTableStyle(tableStyle);
+    if (tableStyles.wholeTable !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.wholeTable]);
+    }
+    if (showRowStripes &&
+        tablePosition.rowType === 'odd' &&
+        tableStyles.firstRowStripe !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.firstRowStripe]);
+    }
+    if (showColumnStripes &&
+        tablePosition.colType === 'odd' &&
+        tableStyles.firstColumnStripe !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.firstColumnStripe]);
+    }
+    if (tablePosition.rowType === 'header' &&
+        tableStyles.headerRow !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.headerRow]);
+    }
+    if (tablePosition.rowType === 'total' && tableStyles.totalRow !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.totalRow]);
+    }
+    if (showFirstColumn &&
+        tablePosition.colPosition === 'first' &&
+        tableStyles.firstColumn !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.firstColumn]);
+    }
+    if (showLastColumn &&
+        tablePosition.colPosition === 'last' &&
+        tableStyles.lastColumn !== undefined) {
+        applyDxf.applyDxf(cellInfo, dxfs[tableStyles.lastColumn]);
+    }
+    // 表格内部添加默认白色分隔线，目前不知道这样做是否正确
+    if (!cellInfo.border) {
+        cellInfo.border = {
+            bottom: {
+                color: {
+                    rgb: 'FFFFFFFF'
+                },
+                style: 'thin'
+            },
+            right: {
+                color: {
+                    rgb: 'FFFFFFFF'
+                },
+                style: 'thin'
+            }
+        };
+    }
+}
+
+exports.applyTableStyle = applyTableStyle;

package/lib/excel/sheet/table/buildTableStyle.d.ts

@@ -0,0 +1,13 @@
+import { TableStyleDef } from '../../types/TableStyleDef';
+/**
+ * 构建演示表，这个主要原因是样式应用有顺序要求，所以先构建为对象格式
+ */
+export declare function buildTableStyle(tableStyle: TableStyleDef): {
+    wholeTable: number | undefined;
+    headerRow: number | undefined;
+    firstRowStripe: number | undefined;
+    firstColumnStripe: number | undefined;
+    totalRow: number | undefined;
+    firstColumn: number | undefined;
+    lastColumn: number | undefined;
+};

package/lib/excel/sheet/table/buildTableStyle.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+
+/**
+ * 构建演示表，这个主要原因是样式应用有顺序要求，所以先构建为对象格式
+ */
+function buildTableStyle(tableStyle) {
+    var e_1, _a;
+    var _b, _c, _d;
+    var wholeTable;
+    var headerRow;
+    var firstRowStripe;
+    var firstColumnStripe;
+    var totalRow;
+    var firstColumn;
+    var lastColumn;
+    try {
+        for (var _e = tslib.__values(((_c = (_b = tableStyle.tableStyles.tableStyle) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.tableStyleElement) || []), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var tableStyleElement = _f.value;
+            var type = tableStyleElement.type;
+            var dxfId = (_d = tableStyleElement.dxfId) !== null && _d !== void 0 ? _d : 1;
+            // 文档里说是从 0 开始，但其实是从 1 开始
+            dxfId = dxfId - 1;
+            switch (type) {
+                case 'wholeTable':
+                    wholeTable = dxfId;
+                    break;
+                case 'headerRow':
+                    headerRow = dxfId;
+                    break;
+                case 'firstRowStripe':
+                    firstRowStripe = dxfId;
+                    break;
+                case 'firstColumnStripe':
+                    firstColumnStripe = dxfId;
+                    break;
+                case 'totalRow':
+                    totalRow = dxfId;
+                    break;
+                case 'firstColumn':
+                    firstColumn = dxfId;
+                    break;
+                case 'lastColumn':
+                    lastColumn = dxfId;
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        wholeTable: wholeTable,
+        headerRow: headerRow,
+        firstRowStripe: firstRowStripe,
+        firstColumnStripe: firstColumnStripe,
+        totalRow: totalRow,
+        firstColumn: firstColumn,
+        lastColumn: lastColumn
+    };
+}
+
+exports.buildTableStyle = buildTableStyle;

package/lib/excel/sheet/table/calcTableRelativePosition.d.ts

@@ -0,0 +1,11 @@
+import { RangeRef } from '../../types/RangeRef';
+export type RelationPosition = {
+    rowType: 'header' | 'odd' | 'even' | 'total';
+    colType: 'odd' | 'even';
+    rowPosition: 'header' | 'first' | 'last' | 'middle' | 'total';
+    colPosition: 'first' | 'last' | 'middle';
+};
+/**
+ * 计算出这个位置相对于表格区域的位置，这个可以缓存的，但先不优化
+ */
+export declare function calcTableRelativePosition(tableRange: RangeRef, isRowHidden: (rowIndex: number) => boolean, isColHidden: (colIndex: number) => boolean, row: number, col: number, headerRowCount: number, totalsRowCount: number, totalsRowShown: boolean): RelationPosition;