office-viewer 0.2.1 → 0.3.0

package/esm/excel/sheet/cfRule/notContainsText.d.ts

@@ -0,0 +1,7 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { Sheet } from '../Sheet';
+/**
+ * 不包含文本
+ */
+export declare function notContainsText(sheet: Sheet, cellInfo: CellInfo, cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/notContainsText.js

@@ -0,0 +1,17 @@
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+/**
+ * 不包含文本
+ */
+function notContainsText(sheet, cellInfo, cfRule) {
+    if (!cfRule.text) {
+        return false;
+    }
+    if (!cellInfo.value.includes(cfRule.text)) {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { notContainsText };

package/esm/excel/sheet/cfRule/timePeriod.d.ts

@@ -0,0 +1,9 @@
+import { CT_CfRule, ST_TimePeriod } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+export declare function checkDate(date: Date, timePeriod: ST_TimePeriod): boolean;
+/**
+ * 时间相关的判断，这里不依赖公式
+ */
+export declare function timePeriod(sheet: Sheet, cellInfo: CellInfo, ranges: RangeRef[], cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/timePeriod.js

@@ -0,0 +1,129 @@
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+import { fromExcelDate } from '../../io/excel/util/fromExcelDate.js';
+
+function isToday(date) {
+    var now = new Date();
+    return (date.getFullYear() === now.getFullYear() &&
+        date.getMonth() === now.getMonth() &&
+        date.getDate() === now.getDate());
+}
+function isYesterday(date) {
+    var now = new Date();
+    var yesterday = new Date(now);
+    yesterday.setDate(now.getDate() - 1);
+    return (date.getFullYear() === yesterday.getFullYear() &&
+        date.getMonth() === yesterday.getMonth() &&
+        date.getDate() === yesterday.getDate());
+}
+function isTomorrow(date) {
+    var now = new Date();
+    var tomorrow = new Date(now);
+    tomorrow.setDate(now.getDate() + 1);
+    return (date.getFullYear() === tomorrow.getFullYear() &&
+        date.getMonth() === tomorrow.getMonth() &&
+        date.getDate() === tomorrow.getDate());
+}
+function isThisMonth(date) {
+    var now = new Date();
+    return (date.getFullYear() === now.getFullYear() &&
+        date.getMonth() === now.getMonth());
+}
+function isLastMonth(date) {
+    var now = new Date();
+    var lastMonth = new Date(now);
+    lastMonth.setMonth(now.getMonth() - 1);
+    return (date.getFullYear() === lastMonth.getFullYear() &&
+        date.getMonth() === lastMonth.getMonth());
+}
+function isNextMonth(date) {
+    var now = new Date();
+    var nextMonth = new Date(now);
+    nextMonth.setMonth(now.getMonth() + 1);
+    return (date.getFullYear() === nextMonth.getFullYear() &&
+        date.getMonth() === nextMonth.getMonth());
+}
+function isThisWeek(date) {
+    var now = new Date();
+    var day = now.getDay();
+    var start = new Date(now);
+    start.setDate(now.getDate() - day);
+    start.setHours(0, 0, 0, 0);
+    var end = new Date(start);
+    end.setDate(start.getDate() + 7);
+    return date >= start && date < end;
+}
+function isLastWeek(date) {
+    var now = new Date();
+    var day = now.getDay();
+    var start = new Date(now);
+    start.setDate(now.getDate() - day - 7);
+    start.setHours(0, 0, 0, 0);
+    var end = new Date(start);
+    end.setDate(start.getDate() + 7);
+    return date >= start && date < end;
+}
+function isNextWeek(date) {
+    var now = new Date();
+    var day = now.getDay();
+    var start = new Date(now);
+    start.setDate(now.getDate() - day + 7);
+    start.setHours(0, 0, 0, 0);
+    var end = new Date(start);
+    end.setDate(start.getDate() + 7);
+    return date >= start && date < end;
+}
+function isLast7Days(date) {
+    var now = new Date();
+    var start = new Date(now);
+    start.setDate(now.getDate() - 7);
+    start.setHours(0, 0, 0, 0);
+    return date >= start && date < now;
+}
+function checkDate(date, timePeriod) {
+    switch (timePeriod) {
+        case 'today':
+            return isToday(date);
+        case 'yesterday':
+            return isYesterday(date);
+        case 'tomorrow':
+            return isTomorrow(date);
+        case 'last7Days':
+            return isLast7Days(date);
+        case 'thisMonth':
+            return isThisMonth(date);
+        case 'lastMonth':
+            return isLastMonth(date);
+        case 'nextMonth':
+            return isNextMonth(date);
+        case 'thisWeek':
+            return isThisWeek(date);
+        case 'lastWeek':
+            return isLastWeek(date);
+        case 'nextWeek':
+            return isNextWeek(date);
+        default:
+            return false;
+    }
+}
+/**
+ * 时间相关的判断，这里不依赖公式
+ */
+function timePeriod(sheet, cellInfo, ranges, cfRule) {
+    var timePeriod = cfRule.timePeriod;
+    if (!timePeriod) {
+        return false;
+    }
+    var dateValue = cellInfo.value;
+    if (dateValue === undefined) {
+        return false;
+    }
+    // 这是天，要先转成秒
+    var date = fromExcelDate(dateValue, sheet.workbook.is1904());
+    if (checkDate(date, timePeriod)) {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { checkDate, timePeriod };

package/esm/excel/sheet/cfRule/top10.d.ts

@@ -0,0 +1,9 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+export declare function getRankValue(values: number[], cfRule: CT_CfRule): number | null;
+/**
+ * 处理 top 值的规则
+ */
+export declare function top10(sheet: Sheet, cellInfo: CellInfo, ranges: RangeRef[], cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/top10.js

@@ -0,0 +1,72 @@
+import { lte, gte, lt, gt } from '../../../util/number.js';
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+function getRankValue(values, cfRule) {
+    if (values.length === 0) {
+        return null;
+    }
+    // 用大小堆会更快但预计数据量不大就直接排序了
+    values.sort(function (a, b) {
+        if (lt(a, b)) {
+            return -1;
+        }
+        if (gt(a, b)) {
+            return 1;
+        }
+        return 0;
+    });
+    var top10Number = cfRule.rank || 10;
+    if (cfRule.percent) {
+        top10Number = Math.ceil(values.length * (top10Number / 100));
+    }
+    top10Number = Math.max(Math.min(top10Number, values.length), 1);
+    // 默认是从小到大排序的
+    if (cfRule.bottom) {
+        return values[top10Number - 1];
+    }
+    else {
+        return values[values.length - top10Number];
+    }
+}
+/**
+ * 处理 top 值的规则
+ */
+function top10(sheet, cellInfo, ranges, cfRule) {
+    var rangeCache = sheet.getRangeCache();
+    var ruleKey = JSON.stringify(cfRule);
+    var rankValue = rangeCache.get(ranges, ruleKey);
+    if (!rankValue) {
+        var rangeValues = sheet.getCellValueByRanges(ranges);
+        if (rangeValues.length === 0) {
+            return false;
+        }
+        var values_1 = [];
+        rangeValues.map(function (value) {
+            if (value.text === '') {
+                return;
+            }
+            values_1.push(parseFloat(value.value));
+        });
+        rankValue = getRankValue(values_1, cfRule);
+        if (rankValue === null) {
+            return false;
+        }
+        rangeCache.set(ranges, ruleKey, rankValue);
+    }
+    var value = parseFloat(cellInfo.value);
+    if (cfRule.bottom) {
+        if (lte(value, rankValue)) {
+            applyCfRuleDxf(cfRule, sheet, cellInfo);
+            return true;
+        }
+    }
+    else {
+        if (gte(value, rankValue)) {
+            applyCfRuleDxf(cfRule, sheet, cellInfo);
+            return true;
+        }
+    }
+    return false;
+}
+
+export { getRankValue, top10 };

package/esm/excel/sheet/cfRule/uniqueValues.d.ts

@@ -0,0 +1,8 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+/**
+ * 对不重复值应用样式
+ */
+export declare function uniqueValues(sheet: Sheet, cellInfo: CellInfo, ranges: RangeRef[], cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/uniqueValues.js

@@ -0,0 +1,46 @@
+import { __values } from 'tslib';
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+/**
+ * 对不重复值应用样式
+ */
+function uniqueValues(sheet, cellInfo, ranges, cfRule) {
+    var e_1, _a;
+    var rangeCache = sheet.getRangeCache();
+    var rangeUniqueValues = rangeCache.get(ranges, 'uniqueValues');
+    if (!rangeUniqueValues) {
+        rangeUniqueValues = new Set();
+        var allValues = new Set();
+        var rangeValues = sheet.getCellValueByRanges(ranges);
+        try {
+            for (var rangeValues_1 = __values(rangeValues), rangeValues_1_1 = rangeValues_1.next(); !rangeValues_1_1.done; rangeValues_1_1 = rangeValues_1.next()) {
+                var value = rangeValues_1_1.value;
+                if (value.text === '') {
+                    continue;
+                }
+                if (allValues.has(value.text)) {
+                    rangeUniqueValues.delete(value.text);
+                }
+                else {
+                    allValues.add(value.text);
+                    rangeUniqueValues.add(value.text);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (rangeValues_1_1 && !rangeValues_1_1.done && (_a = rangeValues_1.return)) _a.call(rangeValues_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        rangeCache.set(ranges, 'uniqueValues', rangeUniqueValues);
+    }
+    if (rangeUniqueValues.has(cellInfo.value)) {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { uniqueValues };

package/esm/excel/sheet/getCellAbsolutePosition.d.ts

@@ -0,0 +1,10 @@
+import { IndexInfo } from './getViewRange';
+/**
+ *  获取单元格的绝对位置
+ */
+export declare function getCellAbsolutePosition(row: number, col: number, getRowHeight: (index: number) => number, rowPositionCache: IndexInfo[] | undefined, getColWidth: (index: number) => number, colPositionCache?: IndexInfo[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/esm/excel/sheet/getCellAbsolutePosition.js

@@ -0,0 +1,41 @@
+function findSizeInCache(index, positionCache, getSize) {
+    if (positionCache[index] !== undefined) {
+        return positionCache[index];
+    }
+    else {
+        var lastIndex = Math.max(0, positionCache.length - 1);
+        for (var i = lastIndex; i <= index; i++) {
+            var size = getSize(i);
+            if (i !== 0) {
+                positionCache[i] = {
+                    offset: positionCache[i - 1].offset + positionCache[i - 1].size,
+                    size: size
+                };
+            }
+            else {
+                positionCache[i] = {
+                    offset: 0,
+                    size: size
+                };
+            }
+        }
+        return positionCache[index];
+    }
+}
+/**
+ *  获取单元格的绝对位置
+ */
+function getCellAbsolutePosition(row, col, getRowHeight, rowPositionCache, getColWidth, colPositionCache) {
+    if (rowPositionCache === void 0) { rowPositionCache = []; }
+    if (colPositionCache === void 0) { colPositionCache = []; }
+    var rowPosition = findSizeInCache(row, rowPositionCache, getRowHeight);
+    var colPosition = findSizeInCache(col, colPositionCache, getColWidth);
+    return {
+        x: colPosition.offset,
+        y: rowPosition.offset,
+        width: colPosition.size,
+        height: rowPosition.size
+    };
+}
+
+export { getCellAbsolutePosition };

package/esm/excel/sheet/getViewPointData.d.ts

@@ -0,0 +1,24 @@
+import { RangeRef } from '../types/RangeRef';
+import { CellData } from '../types/worksheet/CellData';
+import { DisplayData } from './Sheet';
+import { ViewRange } from './ViewRange';
+/**
+ * 计算单元格的高宽，主要是得考虑合并单元格的情况
+ * @param row
+ * @param col
+ * @param rowHeight
+ * @param colWidth
+ * @param mergeCells
+ * @returns
+ */
+export declare function calcCellDisplaySize(row: number, col: number, rowHeight: number, colWidth: number, getRowHeight: (row: number) => number, getColWidth: (row: number) => number, mergeCells: RangeRef[]): {
+    isMergeCell: boolean;
+    mergeCell: RangeRef | undefined;
+    mergeCellId: string;
+    displayHeight: number;
+    displayWidth: number;
+};
+/**
+ * 返回可视区域的数据及位置信息，拆分函数方便但要测试
+ */
+export declare function getViewPointData(getSheetRowData: (row: number) => CellData[], getMergeCells: () => RangeRef[], getRowHeight: (index: number) => number, getColWidth: (index: number) => number, viewRange: ViewRange): DisplayData[];

package/esm/excel/sheet/getViewPointData.js

@@ -0,0 +1,171 @@
+import { __values } from 'tslib';
+import { hasValue } from '../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 = __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 = __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, __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 (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;
+}
+
+export { calcCellDisplaySize, getViewPointData };

package/esm/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;