@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/workbook.js

@@ -0,0 +1,317 @@
+import { __asyncGenerator, __asyncValues, __await, __awaiter, __generator, __read } from "tslib";
+import { CFBDecryptor, detectCfbContainerKind, LEGACY_XLS_UNSUPPORTED_MESSAGE, } from "./cfb-decryptor";
+import { getChartReferenceFromAnchor as _getChartReferenceFromAnchor, WorkbookStyles, } from "./plugins/xlsx/index";
+import { getPluginForFile } from "./registry";
+var CFB_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+var isCFBFile = function (source) { return __awaiter(void 0, void 0, void 0, function () {
+    var header, headerBuffer;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(source instanceof File)) return [3 /*break*/, 2];
+                return [4 /*yield*/, source
+                        .slice(0, CFB_SIGNATURE.length)
+                        .arrayBuffer()];
+            case 1:
+                headerBuffer = _a.sent();
+                header = new Uint8Array(headerBuffer);
+                return [3 /*break*/, 3];
+            case 2:
+                header = new Uint8Array(source, 0, CFB_SIGNATURE.length);
+                _a.label = 3;
+            case 3:
+                if (header.length < CFB_SIGNATURE.length) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/, CFB_SIGNATURE.every(function (value, index) { return header[index] === value; })];
+        }
+    });
+}); };
+var WorkBook = /** @class */ (function () {
+    function WorkBook() {
+    }
+    WorkBook.prototype.load = function (buffer, fileName, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var decryptedBuffer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, isCFBFile(buffer)];
+                    case 1:
+                        if (!_a.sent()) return [3 /*break*/, 4];
+                        return [4 /*yield*/, detectCfbContainerKind(buffer)];
+                    case 2:
+                        if ((_a.sent()) === "legacy-xls") {
+                            throw new Error(LEGACY_XLS_UNSUPPORTED_MESSAGE);
+                        }
+                        if (!password) {
+                            throw new Error("PASSWORD_REQUIRED");
+                        }
+                        return [4 /*yield*/, CFBDecryptor.decrypt(buffer, password)];
+                    case 3:
+                        decryptedBuffer = _a.sent();
+                        buffer = decryptedBuffer;
+                        _a.label = 4;
+                    case 4:
+                        this.plugin = getPluginForFile(fileName || "unknown.xlsx");
+                        return [4 /*yield*/, this.plugin.load(buffer, password)];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WorkBook.prototype.dispose = function () {
+        var _a;
+        (_a = this.plugin) === null || _a === void 0 ? void 0 : _a.dispose();
+    };
+    WorkBook.prototype.getSheetCount = function () {
+        return this.plugin.getSheetCount();
+    };
+    WorkBook.prototype.getSheets = function (minRowCount, minColumnCount) {
+        return this.plugin.getSheets(minRowCount, minColumnCount);
+    };
+    /**
+     * Lightweight sheet catalog. Plugins with sheet-scoped support resolve it
+     * from workbook-level data only; others fall back to the eager
+     * `getSheets()` scan.
+     */
+    WorkBook.prototype.getSheetCatalog = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, sheets;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.plugin.getSheetCatalog) {
+                            return [2 /*return*/, this.plugin.getSheetCatalog()];
+                        }
+                        return [4 /*yield*/, this.plugin.getSheets()];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 1]), sheets = _a[0];
+                        return [2 /*return*/, sheets.map(function (sheet, index) {
+                                var _a;
+                                return ({
+                                    sheetId: sheet.sheetId,
+                                    title: sheet.title,
+                                    visibility: (_a = sheet.visibility) !== null && _a !== void 0 ? _a : "visible",
+                                    hidden: !!sheet.hidden,
+                                    index: index,
+                                });
+                            })];
+                }
+            });
+        });
+    };
+    WorkBook.prototype.getSheet = function (sheetId, minRowCount, minColumnCount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, sheets, tables, sheet;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.plugin.getSheet) {
+                            return [2 /*return*/, this.plugin.getSheet(sheetId, minRowCount, minColumnCount)];
+                        }
+                        return [4 /*yield*/, this.plugin.getSheets(minRowCount, minColumnCount)];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 2]), sheets = _a[0], tables = _a[1];
+                        sheet = sheets.find(function (entry) { return entry.sheetId === sheetId; });
+                        if (!sheet) {
+                            throw new Error("Unknown sheetId: ".concat(sheetId));
+                        }
+                        return [2 /*return*/, [sheet, tables.filter(function (table) { return table.sheetId === sheetId; })]];
+                }
+            });
+        });
+    };
+    WorkBook.prototype.getTheme = function () {
+        return this.plugin.getTheme();
+    };
+    /** Workbook default font (styles.xml fonts[0]); null when unavailable. */
+    WorkBook.prototype.getDefaultFont = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.plugin).getDefaultFont) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null;
+    };
+    WorkBook.prototype.getFonts = function () {
+        return this.plugin.getFonts();
+    };
+    WorkBook.prototype.getCellXfs = function () {
+        return this.plugin.getCellXfs();
+    };
+    WorkBook.prototype.getStyles = function () {
+        return this.plugin.getStyles();
+    };
+    Object.defineProperty(WorkBook.prototype, "workbookStyles", {
+        get: function () {
+            return this.plugin.workbookStyles;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WorkBook.prototype, "sharedStrings", {
+        get: function () {
+            return this.plugin.sharedStrings;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WorkBook.prototype, "richSharedStringRuns", {
+        get: function () {
+            return this.plugin.richSharedStringRuns;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WorkBook.prototype, "sharedFormulaMap", {
+        get: function () {
+            return this.plugin.sharedFormulaMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WorkBook.prototype.requiresRecalc = function () {
+        return this.plugin.requiresRecalc();
+    };
+    WorkBook.prototype.getIterativeCalculationOptions = function () {
+        return this.plugin.getIterativeCalculationOptions();
+    };
+    WorkBook.prototype.getUse1904Epoch = function () {
+        return this.plugin.getUse1904Epoch();
+    };
+    WorkBook.prototype.getSharedStrings = function () {
+        return this.plugin.getSharedStrings();
+    };
+    WorkBook.prototype.processSheetData = function (chunkSize, enableCellXfsRegistry, enableSharedStrings, onPhase) {
+        return this.plugin.processSheetData(chunkSize, enableCellXfsRegistry, enableSharedStrings, onPhase);
+    };
+    WorkBook.prototype.processSheetDataForSheet = function (options) {
+        if (this.plugin.processSheetDataForSheet) {
+            return this.plugin.processSheetDataForSheet(options);
+        }
+        var plugin = this.plugin;
+        return (function () {
+            return __asyncGenerator(this, arguments, function () {
+                var _a, _b, _c, result, e_1_1;
+                var _d, e_1, _e, _f;
+                return __generator(this, function (_g) {
+                    switch (_g.label) {
+                        case 0:
+                            _g.trys.push([0, 7, 8, 13]);
+                            _a = true, _b = __asyncValues(plugin.processSheetData(options.chunkSize, options.enableCellXfsRegistry, options.enableSharedStrings, options.onPhase));
+                            _g.label = 1;
+                        case 1: return [4 /*yield*/, __await(_b.next())];
+                        case 2:
+                            if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 6];
+                            _f = _c.value;
+                            _a = false;
+                            result = _f;
+                            if (!(result.sheetId === options.sheetId)) return [3 /*break*/, 5];
+                            return [4 /*yield*/, __await(result)];
+                        case 3: return [4 /*yield*/, _g.sent()];
+                        case 4:
+                            _g.sent();
+                            _g.label = 5;
+                        case 5:
+                            _a = true;
+                            return [3 /*break*/, 1];
+                        case 6: return [3 /*break*/, 13];
+                        case 7:
+                            e_1_1 = _g.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 13];
+                        case 8:
+                            _g.trys.push([8, , 11, 12]);
+                            if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 10];
+                            return [4 /*yield*/, __await(_e.call(_b))];
+                        case 9:
+                            _g.sent();
+                            _g.label = 10;
+                        case 10: return [3 /*break*/, 12];
+                        case 11:
+                            if (e_1) throw e_1.error;
+                            return [7 /*endfinally*/];
+                        case 12: return [7 /*endfinally*/];
+                        case 13: return [2 /*return*/];
+                    }
+                });
+            });
+        })();
+    };
+    WorkBook.prototype.releaseSheetCaches = function (sheetId) {
+        var _a, _b;
+        (_b = (_a = this.plugin).releaseSheetCaches) === null || _b === void 0 ? void 0 : _b.call(_a, sheetId);
+    };
+    WorkBook.prototype.getDrawings = function () {
+        return this.plugin.getDrawings();
+    };
+    WorkBook.prototype.getCharts = function () {
+        return this.plugin.getCharts();
+    };
+    WorkBook.prototype.getConditionalFormatting = function (sheetId) {
+        if (sheetId === undefined) {
+            return this.plugin.getConditionalFormatting();
+        }
+        if (this.plugin.getConditionalFormattingForSheet) {
+            return this.plugin.getConditionalFormattingForSheet(sheetId);
+        }
+        return this.plugin
+            .getConditionalFormatting()
+            .then(function (rules) {
+            return rules.filter(function (rule) { var _a; return (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.some(function (range) { return range.sheetId === sheetId; }); });
+        });
+    };
+    WorkBook.prototype.getDataValidations = function (sheetId) {
+        if (sheetId === undefined) {
+            return this.plugin.getDataValidations();
+        }
+        if (this.plugin.getDataValidationsForSheet) {
+            return this.plugin.getDataValidationsForSheet(sheetId);
+        }
+        return this.plugin
+            .getDataValidations()
+            .then(function (rules) {
+            return rules.filter(function (rule) { var _a; return (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.some(function (range) { return range.sheetId === sheetId; }); });
+        });
+    };
+    WorkBook.prototype.getNamedRanges = function () {
+        return this.plugin.getNamedRanges();
+    };
+    WorkBook.prototype.getCommentThreads = function (sheetId) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.plugin).getCommentThreads) === null || _b === void 0 ? void 0 : _b.call(_a, sheetId)) !== null && _c !== void 0 ? _c : Promise.resolve([]);
+    };
+    WorkBook.prototype.getSlicers = function () {
+        return this.plugin.getSlicers();
+    };
+    WorkBook.prototype.getPivotTables = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.plugin).getPivotTables) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : Promise.resolve([]);
+    };
+    WorkBook.prototype.getPowerQuery = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.plugin).getPowerQuery) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : Promise.resolve(undefined);
+    };
+    WorkBook.prototype.getExternalLinks = function () {
+        return this.plugin.getExternalLinks();
+    };
+    WorkBook.prototype.getProperties = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, ((_b = (_a = this.plugin).getProperties) === null || _b === void 0 ? void 0 : _b.call(_a))];
+                    case 1: return [2 /*return*/, (_c = (_d.sent())) !== null && _c !== void 0 ? _c : undefined];
+                }
+            });
+        });
+    };
+    WorkBook.prototype.registerFormat = function (format) {
+        if (this.plugin.registerFormat) {
+            return this.plugin.registerFormat(format);
+        }
+        return "";
+    };
+    return WorkBook;
+}());
+export { WorkBook };
+export var getChartReferenceFromAnchor = _getChartReferenceFromAnchor;
+export { WorkbookStyles };

package/dist/cjs/excel-parser/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/cjs/excel-parser/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../excel-parser/worker.ts"],"names":[],"mappings":""}