office-viewer 0.2.1 → 0.3.0

package/esm/excel/io/excel/stylesheet/parseColor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 这个比较常用就封装了一下
+ */
+import { XMLNode } from '../../../../util/xml';
+export declare function parseColor(node: XMLNode): any;

package/esm/excel/io/excel/stylesheet/parseColor.js

@@ -0,0 +1,11 @@
+import { autoParse } from '../../../../common/autoParse.js';
+import { CT_Color_Attributes } from '../../../../openxml/ExcelTypes.js';
+
+/**
+ * 这个比较常用就封装了一下
+ */
+function parseColor(node) {
+    return autoParse(node, CT_Color_Attributes);
+}
+
+export { parseColor };

package/esm/excel/io/excel/util/Range.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 处理选区相关的工具函数
+ */
+import { ViewRange } from 'src/excel/sheet/ViewRange';
+import { RangeRef } from '../../../types/RangeRef';
+/**
+ * 解析选区字符串，比如 A1:B2
+ */
+export declare function parseRange(range: string): RangeRef;
+/**
+ * 将 RangeRef 转换为字符串
+ */
+export declare function rangeRefToString(rangeRef: RangeRef): string;
+/**
+ * 扩展选区，取这两个选区合并后最大值
+ * @param range1
+ * @param range2
+ * @returns
+ */
+export declare function mergeRange(range1: RangeRef, range2: RangeRef): {
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+};
+/**
+ * 判断一个选区是否在另一个选区内
+ * @param 主选区
+ * @param 被包含的选区
+ */
+export declare function inRange(range: RangeRef, otherRange: RangeRef): boolean;
+/**
+ * 判断两个选区是否相等
+ * @param range1
+ * @param range2
+ */
+export declare function rangeEqual(range1: RangeRef, range2: RangeRef): boolean;
+/**
+ * 判断两个选区是否相交
+ */
+export declare function rangeIntersect(range1: RangeRef, range2: RangeRef): boolean;
+/**
+ * 这个单元格是否是个合并单元格
+ * @param range
+ * @param mergeCells
+ * @returns
+ */
+export declare function isMergeCell(range: RangeRef, mergeCells: RangeRef[]): boolean;
+/**
+ * 是否是单个单元格
+ * @param range
+ */
+export declare function isSingleCell(range: RangeRef): boolean;
+/**
+ * 判断单元格是否在选区内
+ */
+export declare function isCellInRange(range: RangeRef, row: number, col: number): boolean;
+/**
+ * 基于 viewRange 构建出 RangeRef
+ */
+export declare function viewRangeToRangeRef(viewRange: ViewRange): {
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+};

package/esm/excel/io/excel/util/Range.js

@@ -0,0 +1,120 @@
+import { __read } from 'tslib';
+import { decodeAddress } from './decodeAddress.js';
+import { numberToLetters } from './numberToLetters.js';
+
+/**
+ * 处理选区相关的工具函数
+ */
+/**
+ * 解析选区字符串，比如 A1:B2
+ */
+function parseRange(range) {
+    if (range.indexOf(':') !== -1) {
+        var parts = range.split(':');
+        if (parts.length !== 2) {
+            throw new Error('range 格式错误');
+        }
+        var _a = __read(parts, 2), start = _a[0], end = _a[1];
+        var startRange = decodeAddress(start);
+        var endRange = decodeAddress(end);
+        return {
+            startRow: startRange.row,
+            startCol: startRange.col,
+            endRow: endRange.row,
+            endCol: endRange.col
+        };
+    }
+    else {
+        var startRange = decodeAddress(range);
+        return {
+            startRow: startRange.row,
+            startCol: startRange.col,
+            endRow: startRange.row,
+            endCol: startRange.col
+        };
+    }
+}
+/**
+ * 将 RangeRef 转换为字符串
+ */
+function rangeRefToString(rangeRef) {
+    return (numberToLetters(rangeRef.startCol) +
+        (rangeRef.startRow + 1) +
+        ':' +
+        numberToLetters(rangeRef.endCol) +
+        (rangeRef.endRow + 1));
+}
+/**
+ * 扩展选区，取这两个选区合并后最大值
+ * @param range1
+ * @param range2
+ * @returns
+ */
+function mergeRange(range1, range2) {
+    return {
+        startRow: Math.min(range1.startRow, range2.startRow),
+        startCol: Math.min(range1.startCol, range2.startCol),
+        endRow: Math.max(range1.endRow, range2.endRow),
+        endCol: Math.max(range1.endCol, range2.endCol)
+    };
+}
+/**
+ * 判断两个选区是否相等
+ * @param range1
+ * @param range2
+ */
+function rangeEqual(range1, range2) {
+    return (range1.startRow === range2.startRow &&
+        range1.startCol === range2.startCol &&
+        range1.endRow === range2.endRow &&
+        range1.endCol === range2.endCol);
+}
+/**
+ * 判断两个选区是否相交
+ */
+function rangeIntersect(range1, range2) {
+    return (range1.startRow <= range2.endRow &&
+        range1.endRow >= range2.startRow &&
+        range1.startCol <= range2.endCol &&
+        range1.endCol >= range2.startCol);
+}
+/**
+ * 这个单元格是否是个合并单元格
+ * @param range
+ * @param mergeCells
+ * @returns
+ */
+function isMergeCell(range, mergeCells) {
+    return mergeCells.some(function (mergeCell) { return rangeEqual(mergeCell, range); });
+}
+/**
+ * 是否是单个单元格
+ * @param range
+ */
+function isSingleCell(range) {
+    return range.startRow === range.endRow && range.startCol === range.endCol;
+}
+/**
+ * 判断单元格是否在选区内
+ */
+function isCellInRange(range, row, col) {
+    return (range.startRow <= row &&
+        range.startCol <= col &&
+        range.endRow >= row &&
+        range.endCol >= col);
+}
+/**
+ * 基于 viewRange 构建出 RangeRef
+ */
+function viewRangeToRangeRef(viewRange) {
+    var rows = viewRange.rows;
+    var cols = viewRange.cols;
+    return {
+        startRow: rows[0],
+        startCol: cols[0],
+        endRow: rows[rows.length - 1],
+        endCol: cols[cols.length - 1]
+    };
+}
+
+export { isCellInRange, isMergeCell, isSingleCell, mergeRange, parseRange, rangeEqual, rangeIntersect, rangeRefToString, viewRangeToRangeRef };

package/esm/excel/io/excel/util/__tests__/makeBlankValue.test.d.ts

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

package/esm/excel/io/excel/util/decodeAddress.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 将 A1 转成 {col: 0, row: 0}
+ * 从 exceljs 中拷贝过来的方法
+ * 简单进行了修改，必须同时有行和列，如果只有一个就用 lettersToNumber
+ * 返回结果是从 0 开始的
+ * @param value
+ */
+export declare function decodeAddress(value: string): {
+    col: number;
+    row: number;
+};

package/esm/excel/io/excel/util/decodeAddress.js

@@ -0,0 +1,63 @@
+/**
+ * 缓存解析结果
+ */
+var addressCache = {};
+/**
+ * 将 A1 转成 {col: 0, row: 0}
+ * 从 exceljs 中拷贝过来的方法
+ * 简单进行了修改，必须同时有行和列，如果只有一个就用 lettersToNumber
+ * 返回结果是从 0 开始的
+ * @param value
+ */
+function decodeAddress(value) {
+    var addr = value.length < 5 && addressCache[value];
+    if (addr) {
+        return addr;
+    }
+    var hasCol = false;
+    var col = '';
+    var colNumber = 0;
+    var hasRow = false;
+    var row = '';
+    var rowNumber = 0;
+    for (var i = 0, char = void 0; i < value.length; i++) {
+        char = value.charCodeAt(i);
+        // col should before row
+        if (!hasRow && char >= 65 && char <= 90) {
+            // 65 = 'A'.charCodeAt(0)
+            // 90 = 'Z'.charCodeAt(0)
+            hasCol = true;
+            col += value[i];
+            // colNumber starts from 1
+            colNumber = colNumber * 26 + char - 64;
+        }
+        else if (char >= 48 && char <= 57) {
+            // 48 = '0'.charCodeAt(0)
+            // 57 = '9'.charCodeAt(0)
+            hasRow = true;
+            row += value[i];
+            // rowNumber starts from 0
+            rowNumber = rowNumber * 10 + char - 48;
+        }
+        else if (hasRow && hasCol && char !== 36) {
+            // 36 = '$'.charCodeAt(0)
+            break;
+        }
+    }
+    if (colNumber > 16384) {
+        throw new Error("Out of bounds. Invalid column letter: ".concat(col));
+    }
+    // in case $row$col
+    value = col + row;
+    var address = {
+        col: colNumber - 1,
+        row: rowNumber - 1
+    };
+    // mem fix - cache only the tl 100x100 square
+    if (colNumber && colNumber <= 100 && rowNumber && rowNumber <= 100) {
+        addressCache[value] = address;
+    }
+    return address;
+}
+
+export { decodeAddress };

package/esm/excel/io/excel/util/fromExcelDate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 将 Excel 日期转换为 Date 对象
+ * 来自 https://github.com/RaschidJFR/js-excel-date-convert
+ * @param excelDate Excel 日期
+ * @param date1904 是否使用 1904 年作为基准
+ */
+export declare function fromExcelDate(excelDate: number | string, date1904: boolean): Date;
+/**
+ * Encode date to excel
+ * @param {Date} date
+ * @param {boolean} [date1904] Whether to use the 1904 Date System. See https://bettersolutions.com/excel/dates-times/1904-date-system.htm
+ * @author Raschid JF Rafaelly <hello&commat;raschidjdr.dev>
+ */
+export declare function toExcelDate(date: Date, date1904?: boolean): number;

package/esm/excel/io/excel/util/fromExcelDate.js

@@ -0,0 +1,26 @@
+var pasteCache = {};
+/**
+ * 将 Excel 日期转换为 Date 对象
+ * 来自 https://github.com/RaschidJFR/js-excel-date-convert
+ * @param excelDate Excel 日期
+ * @param date1904 是否使用 1904 年作为基准
+ */
+function fromExcelDate(excelDate, date1904) {
+    var cacheKey = "".concat(excelDate, "-").concat(date1904);
+    if (pasteCache[cacheKey]) {
+        return new Date(pasteCache[cacheKey]);
+    }
+    if (typeof excelDate === 'string') {
+        excelDate = parseInt(excelDate, 10);
+    }
+    var daysIn4Years = 1461;
+    var daysIn70years = Math.round(25567.5 + 1); // +1 because of the leap-year bug
+    var daysFrom1900 = excelDate + (date1904 ? daysIn4Years + 1 : 0);
+    var daysFrom1970 = daysFrom1900 - daysIn70years;
+    var secondsFrom1970 = daysFrom1970 * (3600 * 24);
+    var utc = new Date(secondsFrom1970 * 1000);
+    pasteCache[cacheKey] = utc.getTime();
+    return utc;
+}
+
+export { fromExcelDate };

package/esm/excel/io/excel/util/lettersToNumber.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 将字母转成数字
+ */
+export declare function lettersToNumber(letters: string): number;

package/esm/excel/io/excel/util/makeBlankValue.d.ts

@@ -0,0 +1,6 @@
+import { CellData } from '../../../types/worksheet/CellData';
+import { RangeRef } from '../../../types/RangeRef';
+/**
+ * 制造空值，这个主要是给 containsBlanks 条件格式用，目前的实现下如果没有值就没法渲染
+ */
+export declare function makeBlankValue(cellData: CellData[][], range: RangeRef): void;

package/esm/excel/io/excel/util/makeBlankValue.js

@@ -0,0 +1,21 @@
+/**
+ * 制造空值，这个主要是给 containsBlanks 条件格式用，目前的实现下如果没有值就没法渲染
+ */
+function makeBlankValue(cellData, range) {
+    for (var i = range.startRow; i <= range.endRow; i++) {
+        var rowData = cellData[i];
+        if (!rowData) {
+            rowData = [];
+            cellData[i] = rowData;
+        }
+        for (var j = range.startCol; j <= range.endCol; j++) {
+            if (rowData[j] === undefined) {
+                rowData[j] = {
+                    type: 'blank'
+                };
+            }
+        }
+    }
+}
+
+export { makeBlankValue };

package/esm/excel/io/excel/util/numberToLetters.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 数字转成字母名，这个输入是从 0 开始，所以不需要加 1
+ */
+export declare function numberToLetters(num: number): string;

package/esm/excel/io/excel/util/numberToLetters.js

@@ -0,0 +1,13 @@
+/**
+ * 数字转成字母名，这个输入是从 0 开始，所以不需要加 1
+ */
+function numberToLetters(num) {
+    var letters = '';
+    while (num >= 0) {
+        letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[num % 26] + letters;
+        num = Math.floor(num / 26) - 1;
+    }
+    return letters;
+}
+
+export { numberToLetters };

package/esm/excel/io/excel/worksheet/parseSheetData.d.ts

@@ -0,0 +1,11 @@
+import { CT_Row } from '../../../../openxml/ExcelTypes';
+import { XMLNode } from '../../../../util/xml';
+import { StringItem } from '../../../types/StringItem';
+import { CellData } from '../../../types/worksheet/CellData';
+/**
+ * 解析 sheetData
+ */
+export declare function parseSheetData(sheetDataNode: XMLNode, sharedStrings: StringItem[]): {
+    rows: CT_Row[];
+    cellData: CellData[][];
+};

package/esm/excel/io/excel/worksheet/parseSheetData.js

@@ -0,0 +1,154 @@
+import { __values } from 'tslib';
+import { CT_Row_Attributes } from '../../../../openxml/ExcelTypes.js';
+import { CT_Cell_Attributes } from '../../../types/worksheet/ICell.js';
+import { decodeAddress } from '../util/decodeAddress.js';
+import { autoParse } from '../../../../common/autoParse.js';
+
+/**
+ * 解析 sheetData
+ */
+function parseSheetData(sheetDataNode, sharedStrings) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    var rows = [];
+    var cellData = [];
+    try {
+        for (var _e = __values(sheetDataNode.children || []), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var rowNode = _f.value;
+            // 这里不自动填充默认值，因为数据量可能很大，后面代码里判断
+            var row = autoParse(rowNode, CT_Row_Attributes);
+            // 行号，改成从 0 开始
+            var r = (row.r || 1) - 1;
+            rows[r] = row;
+            try {
+                for (var _g = (e_2 = void 0, __values(rowNode.children || [])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var cellNode = _h.value;
+                    var cell = autoParse(cellNode, CT_Cell_Attributes);
+                    var cellType = cell.t;
+                    var styleIndex = cell.s;
+                    /**
+                     * 列号，改成从 0 开始
+                     */
+                    var colNumber = decodeAddress(cell.r).col;
+                    // 开始解析 cell 里的数据
+                    var value = '';
+                    var formula = '';
+                    try {
+                        for (var _j = (e_3 = void 0, __values(cellNode.children || [])), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var cellNodeChild = _k.value;
+                            var tag = cellNodeChild.tag;
+                            switch (tag) {
+                                case 'v':
+                                    // shared string
+                                    if (cellType === 's') {
+                                        var index = parseInt(cellNodeChild.text || '');
+                                        value = sharedStrings[index];
+                                    }
+                                    else if (cellType == 'd') {
+                                        value = {
+                                            type: 'date',
+                                            value: cellNodeChild.text || ''
+                                        };
+                                    }
+                                    else {
+                                        value = cellNodeChild.text || '';
+                                    }
+                                    break;
+                                case 'f':
+                                    formula = cellNodeChild.text || '';
+                                    break;
+                                case 'is':
+                                    try {
+                                        // 这种基本上是 inlineStr
+                                        for (var _l = (e_4 = void 0, __values(cellNodeChild.children || [])), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                            var isNode = _m.value;
+                                            var tag_1 = isNode.tag;
+                                            if (tag_1 === 't' && cellType === 'inlineStr') {
+                                                value = isNode.text || '';
+                                            }
+                                        }
+                                    }
+                                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                    finally {
+                                        try {
+                                            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                                        }
+                                        finally { if (e_4) throw e_4.error; }
+                                    }
+                                    break;
+                                default:
+                                    break;
+                            }
+                            if (formula && typeof value === 'string') {
+                                value = {
+                                    type: 'formula',
+                                    formula: formula,
+                                    value: value
+                                };
+                            }
+                            if (styleIndex) {
+                                if (typeof value === 'string') {
+                                    value = {
+                                        type: 'style',
+                                        s: styleIndex,
+                                        value: value
+                                    };
+                                }
+                                else if (typeof value === 'object') {
+                                    value.s = styleIndex;
+                                }
+                            }
+                            if (cellData[r]) {
+                                cellData[r][colNumber] = value;
+                            }
+                            else {
+                                cellData[r] = [];
+                                cellData[r][colNumber] = value;
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    // 有些节点没数据，就只有边框样式或合并单元格
+                    if (!cellNode.children || cellNode.children.length === 0) {
+                        var emptyValue = {
+                            type: 'blank',
+                            s: styleIndex
+                        };
+                        if (cellData[r]) {
+                            cellData[r][colNumber] = emptyValue;
+                        }
+                        else {
+                            cellData[r] = [];
+                            cellData[r][colNumber] = emptyValue;
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    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 {
+        rows: rows,
+        cellData: cellData
+    };
+}
+
+export { parseSheetData };

package/esm/excel/io/parseExcel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 解析 Excel 格式，转成内部数据结构
+ */
+import { PackageParser } from '../../package/PackageParser';
+import { ExcelFile } from '../types/ExcelFile';
+/**
+ * 解析 Excel
+ * @param parser
+ */
+export declare function parseExcel(parser: PackageParser): Promise<ExcelFile>;

package/esm/excel/io/parseExcel.js

@@ -0,0 +1,39 @@
+import { __awaiter, __generator } from 'tslib';
+import { parseWorkbook } from './excel/parseWorkbook.js';
+import { parseContentType } from '../../common/parseContentType.js';
+import { xml2json } from '../../util/xml.js';
+import { CT_Stylesheet_Attributes } from '../../openxml/ExcelTypes.js';
+import { autoParse } from '../../common/autoParse.js';
+
+/**
+ * 解析 Excel 格式，转成内部数据结构
+ */
+/**
+ * 解析 Excel
+ * @param parser
+ */
+function parseExcel(parser) {
+    return __awaiter(this, void 0, void 0, function () {
+        var contentTypes, styleSheetNode, styleSheet, workbook;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, parseContentType(parser)];
+                case 1:
+                    contentTypes = _a.sent();
+                    return [4 /*yield*/, xml2json(parser.getString('xl/styles.xml'))];
+                case 2:
+                    styleSheetNode = _a.sent();
+                    styleSheet = autoParse(styleSheetNode, CT_Stylesheet_Attributes);
+                    return [4 /*yield*/, parseWorkbook(parser, styleSheet)];
+                case 3:
+                    workbook = _a.sent();
+                    return [2 /*return*/, {
+                            contentTypes: contentTypes,
+                            workbook: workbook
+                        }];
+            }
+        });
+    });
+}
+
+export { parseExcel };

package/esm/excel/lang/en_US.d.ts

@@ -0,0 +1,24 @@
+export declare const en_US: {
+    'autoFilter.sortAscending': string;
+    'autoFilter.sortDescending': string;
+    'checkBox.selectAll': string;
+    'checkBox.search': string;
+    'customFilter.equal': string;
+    'customFilter.notEqual': string;
+    'customFilter.greaterThan': string;
+    'customFilter.greaterThanOrEqual': string;
+    'customFilter.lessThan': string;
+    'customFilter.lessThanOrEqual': string;
+    'customFilter.beginsWith': string;
+    'customFilter.notBeginsWith': string;
+    'customFilter.endsWith': string;
+    'customFilter.notEndsWith': string;
+    'customFilter.contains': string;
+    'customFilter.notContains': string;
+    'customFilter.and': string;
+    'customFilter.or': string;
+    average: string;
+    count: string;
+    sum: string;
+};
+export type EnKeys = keyof typeof en_US;

package/esm/excel/lang/en_US.js

@@ -0,0 +1,25 @@
+var en_US = {
+    'autoFilter.sortAscending': 'Ascending',
+    'autoFilter.sortDescending': 'Descending',
+    'checkBox.selectAll': '(Select All)',
+    'checkBox.search': 'Search',
+    'customFilter.equal': 'Equals',
+    'customFilter.notEqual': 'Does not equal',
+    'customFilter.greaterThan': 'Greater than',
+    'customFilter.greaterThanOrEqual': 'Greater than or equal to',
+    'customFilter.lessThan': 'Less than',
+    'customFilter.lessThanOrEqual': 'Less than or equal to',
+    'customFilter.beginsWith': 'Begins with',
+    'customFilter.notBeginsWith': 'Does not begin with',
+    'customFilter.endsWith': 'Ends with',
+    'customFilter.notEndsWith': 'Does not end with',
+    'customFilter.contains': 'Contains',
+    'customFilter.notContains': 'Does not contain',
+    'customFilter.and': 'And',
+    'customFilter.or': 'Or',
+    'average': 'Average',
+    'count': 'Count',
+    'sum': 'SUM'
+};
+
+export { en_US };