@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,192 @@
+import { CFBDecryptor, detectCfbContainerKind, LEGACY_XLS_UNSUPPORTED_MESSAGE, } from "./cfb-decryptor";
+import { getChartReferenceFromAnchor as _getChartReferenceFromAnchor, WorkbookStyles, } from "./plugins/xlsx/index";
+import { getPluginForFile } from "./registry";
+const CFB_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+const isCFBFile = async (source) => {
+    let header;
+    if (source instanceof File) {
+        const headerBuffer = await source
+            .slice(0, CFB_SIGNATURE.length)
+            .arrayBuffer();
+        header = new Uint8Array(headerBuffer);
+    }
+    else {
+        header = new Uint8Array(source, 0, CFB_SIGNATURE.length);
+    }
+    if (header.length < CFB_SIGNATURE.length) {
+        return false;
+    }
+    return CFB_SIGNATURE.every((value, index) => header[index] === value);
+};
+export class WorkBook {
+    plugin;
+    constructor() { }
+    async load(buffer, fileName, password) {
+        if (await isCFBFile(buffer)) {
+            if ((await detectCfbContainerKind(buffer)) === "legacy-xls") {
+                throw new Error(LEGACY_XLS_UNSUPPORTED_MESSAGE);
+            }
+            if (!password) {
+                throw new Error("PASSWORD_REQUIRED");
+            }
+            const decryptedBuffer = await CFBDecryptor.decrypt(buffer, password);
+            buffer = decryptedBuffer;
+        }
+        this.plugin = getPluginForFile(fileName || "unknown.xlsx");
+        await this.plugin.load(buffer, password);
+    }
+    dispose() {
+        this.plugin?.dispose();
+    }
+    getSheetCount() {
+        return this.plugin.getSheetCount();
+    }
+    getSheets(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.
+     */
+    async getSheetCatalog() {
+        if (this.plugin.getSheetCatalog) {
+            return this.plugin.getSheetCatalog();
+        }
+        const [sheets] = await this.plugin.getSheets();
+        return sheets.map((sheet, index) => ({
+            sheetId: sheet.sheetId,
+            title: sheet.title,
+            visibility: sheet.visibility ?? "visible",
+            hidden: !!sheet.hidden,
+            index,
+        }));
+    }
+    async getSheet(sheetId, minRowCount, minColumnCount) {
+        if (this.plugin.getSheet) {
+            return this.plugin.getSheet(sheetId, minRowCount, minColumnCount);
+        }
+        const [sheets, tables] = await this.plugin.getSheets(minRowCount, minColumnCount);
+        const sheet = sheets.find((entry) => entry.sheetId === sheetId);
+        if (!sheet) {
+            throw new Error(`Unknown sheetId: ${sheetId}`);
+        }
+        return [sheet, tables.filter((table) => table.sheetId === sheetId)];
+    }
+    getTheme() {
+        return this.plugin.getTheme();
+    }
+    /** Workbook default font (styles.xml fonts[0]); null when unavailable. */
+    getDefaultFont() {
+        return this.plugin.getDefaultFont?.() ?? null;
+    }
+    getFonts() {
+        return this.plugin.getFonts();
+    }
+    getCellXfs() {
+        return this.plugin.getCellXfs();
+    }
+    getStyles() {
+        return this.plugin.getStyles();
+    }
+    get workbookStyles() {
+        return this.plugin.workbookStyles;
+    }
+    get sharedStrings() {
+        return this.plugin.sharedStrings;
+    }
+    get richSharedStringRuns() {
+        return this.plugin.richSharedStringRuns;
+    }
+    get sharedFormulaMap() {
+        return this.plugin.sharedFormulaMap;
+    }
+    requiresRecalc() {
+        return this.plugin.requiresRecalc();
+    }
+    getIterativeCalculationOptions() {
+        return this.plugin.getIterativeCalculationOptions();
+    }
+    getUse1904Epoch() {
+        return this.plugin.getUse1904Epoch();
+    }
+    getSharedStrings() {
+        return this.plugin.getSharedStrings();
+    }
+    processSheetData(chunkSize, enableCellXfsRegistry, enableSharedStrings, onPhase) {
+        return this.plugin.processSheetData(chunkSize, enableCellXfsRegistry, enableSharedStrings, onPhase);
+    }
+    processSheetDataForSheet(options) {
+        if (this.plugin.processSheetDataForSheet) {
+            return this.plugin.processSheetDataForSheet(options);
+        }
+        const plugin = this.plugin;
+        return (async function* () {
+            for await (const result of plugin.processSheetData(options.chunkSize, options.enableCellXfsRegistry, options.enableSharedStrings, options.onPhase)) {
+                if (result.sheetId === options.sheetId) {
+                    yield result;
+                }
+            }
+        })();
+    }
+    releaseSheetCaches(sheetId) {
+        this.plugin.releaseSheetCaches?.(sheetId);
+    }
+    getDrawings() {
+        return this.plugin.getDrawings();
+    }
+    getCharts() {
+        return this.plugin.getCharts();
+    }
+    getConditionalFormatting(sheetId) {
+        if (sheetId === undefined) {
+            return this.plugin.getConditionalFormatting();
+        }
+        if (this.plugin.getConditionalFormattingForSheet) {
+            return this.plugin.getConditionalFormattingForSheet(sheetId);
+        }
+        return this.plugin
+            .getConditionalFormatting()
+            .then((rules) => rules.filter((rule) => rule.ranges?.some((range) => range.sheetId === sheetId)));
+    }
+    getDataValidations(sheetId) {
+        if (sheetId === undefined) {
+            return this.plugin.getDataValidations();
+        }
+        if (this.plugin.getDataValidationsForSheet) {
+            return this.plugin.getDataValidationsForSheet(sheetId);
+        }
+        return this.plugin
+            .getDataValidations()
+            .then((rules) => rules.filter((rule) => rule.ranges?.some((range) => range.sheetId === sheetId)));
+    }
+    getNamedRanges() {
+        return this.plugin.getNamedRanges();
+    }
+    getCommentThreads(sheetId) {
+        return this.plugin.getCommentThreads?.(sheetId) ?? Promise.resolve([]);
+    }
+    getSlicers() {
+        return this.plugin.getSlicers();
+    }
+    getPivotTables() {
+        return this.plugin.getPivotTables?.() ?? Promise.resolve([]);
+    }
+    getPowerQuery() {
+        return this.plugin.getPowerQuery?.() ?? Promise.resolve(undefined);
+    }
+    getExternalLinks() {
+        return this.plugin.getExternalLinks();
+    }
+    async getProperties() {
+        return (await this.plugin.getProperties?.()) ?? undefined;
+    }
+    registerFormat(format) {
+        if (this.plugin.registerFormat) {
+            return this.plugin.registerFormat(format);
+        }
+        return "";
+    }
+}
+export const getChartReferenceFromAnchor = _getChartReferenceFromAnchor;
+export { WorkbookStyles };

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

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

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

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