@cj-tech-master/excelts 1.6.3 → 2.0.0-canary.20251228013952.4f2c3c6

package/dist/esm/xlsx/xlsx.base.js

@@ -0,0 +1,739 @@
+/**
+ * XLSXBase - Abstract base class for XLSX operations
+ *
+ * Contains all platform-agnostic logic shared between Node.js and Browser versions:
+ * - reconcile: Reconcile model after parsing
+ * - _process*Entry: Process individual ZIP entries
+ * - add*: Add content to ZIP during writing
+ * - prepareModel: Prepare model for writing
+ * - loadFromFiles: Load from pre-extracted ZIP data
+ */
+import { XmlStream } from "../utils/xml-stream.js";
+import { StylesXform } from "./xform/style/styles-xform.js";
+import { CoreXform } from "./xform/core/core-xform.js";
+import { SharedStringsXform } from "./xform/strings/shared-strings-xform.js";
+import { RelationshipsXform } from "./xform/core/relationships-xform.js";
+import { ContentTypesXform } from "./xform/core/content-types-xform.js";
+import { AppXform } from "./xform/core/app-xform.js";
+import { WorkbookXform } from "./xform/book/workbook-xform.js";
+import { WorkSheetXform } from "./xform/sheet/worksheet-xform.js";
+import { DrawingXform } from "./xform/drawing/drawing-xform.js";
+import { TableXform } from "./xform/table/table-xform.js";
+import { PivotCacheRecordsXform } from "./xform/pivot-table/pivot-cache-records-xform.js";
+import { PivotCacheDefinitionXform } from "./xform/pivot-table/pivot-cache-definition-xform.js";
+import { PivotTableXform } from "./xform/pivot-table/pivot-table-xform.js";
+import { CommentsXform } from "./xform/comment/comments-xform.js";
+import { VmlNotesXform } from "./xform/comment/vml-notes-xform.js";
+import { theme1Xml } from "./xml/theme1.js";
+import { RelType } from "./rel-type.js";
+/**
+ * Abstract base class for XLSX operations
+ */
+class XLSXBase {
+    constructor(workbook) {
+        this.workbook = workbook;
+    }
+    // ===========================================================================
+    // Parse helpers - shared by all platforms
+    // ===========================================================================
+    parseRels(stream) {
+        const xform = new RelationshipsXform();
+        return xform.parseStream(stream);
+    }
+    parseWorkbook(stream) {
+        const xform = new WorkbookXform();
+        return xform.parseStream(stream);
+    }
+    parseSharedStrings(stream) {
+        const xform = new SharedStringsXform();
+        return xform.parseStream(stream);
+    }
+    // ===========================================================================
+    // Reconcile - shared by all platforms
+    // ===========================================================================
+    reconcile(model, options) {
+        const workbookXform = new WorkbookXform();
+        const worksheetXform = new WorkSheetXform(options);
+        const drawingXform = new DrawingXform();
+        const tableXform = new TableXform();
+        workbookXform.reconcile(model);
+        // reconcile drawings with their rels
+        const drawingOptions = {
+            media: model.media,
+            mediaIndex: model.mediaIndex
+        };
+        Object.keys(model.drawings).forEach(name => {
+            const drawing = model.drawings[name];
+            const drawingRel = model.drawingRels[name];
+            if (drawingRel) {
+                drawingOptions.rels = drawingRel.reduce((o, rel) => {
+                    o[rel.Id] = rel;
+                    return o;
+                }, {});
+                (drawing.anchors || []).forEach((anchor) => {
+                    const hyperlinks = anchor.picture && anchor.picture.hyperlinks;
+                    if (hyperlinks && drawingOptions.rels[hyperlinks.rId]) {
+                        hyperlinks.hyperlink = drawingOptions.rels[hyperlinks.rId].Target;
+                        delete hyperlinks.rId;
+                    }
+                });
+                drawingXform.reconcile(drawing, drawingOptions);
+            }
+        });
+        // reconcile tables with the default styles
+        const tableOptions = {
+            styles: model.styles
+        };
+        Object.values(model.tables).forEach((table) => {
+            tableXform.reconcile(table, tableOptions);
+        });
+        // Reconcile pivot tables
+        this._reconcilePivotTables(model);
+        const sheetOptions = {
+            styles: model.styles,
+            sharedStrings: model.sharedStrings,
+            media: model.media,
+            mediaIndex: model.mediaIndex,
+            date1904: model.properties && model.properties.date1904,
+            drawings: model.drawings,
+            comments: model.comments,
+            tables: model.tables,
+            vmlDrawings: model.vmlDrawings,
+            pivotTables: model.pivotTablesIndexed
+        };
+        model.worksheets.forEach((worksheet) => {
+            worksheet.relationships = model.worksheetRels[worksheet.sheetNo];
+            worksheetXform.reconcile(worksheet, sheetOptions);
+        });
+        // delete unnecessary parts
+        delete model.worksheetHash;
+        delete model.worksheetRels;
+        delete model.globalRels;
+        delete model.sharedStrings;
+        delete model.workbookRels;
+        delete model.sheetDefs;
+        delete model.styles;
+        delete model.mediaIndex;
+        delete model.drawings;
+        delete model.drawingRels;
+        delete model.vmlDrawings;
+        delete model.pivotTableRels;
+        delete model.pivotCacheDefinitionRels;
+    }
+    /**
+     * Reconcile pivot tables by linking them to worksheets and their cache data.
+     */
+    _reconcilePivotTables(model) {
+        const rawPivotTables = model.pivotTables || {};
+        if (typeof rawPivotTables !== "object" || Object.keys(rawPivotTables).length === 0) {
+            model.pivotTables = [];
+            model.pivotTablesIndexed = {};
+            return;
+        }
+        const definitionToCacheId = this._buildDefinitionToCacheIdMap(model);
+        const cacheMap = new Map();
+        Object.entries(model.pivotCacheDefinitions || {}).forEach(([name, definition]) => {
+            const cacheId = definitionToCacheId.get(name);
+            if (cacheId !== undefined) {
+                const recordsName = name.replace("Definition", "Records");
+                cacheMap.set(cacheId, {
+                    definition,
+                    records: model.pivotCacheRecords?.[recordsName],
+                    definitionName: name
+                });
+            }
+        });
+        const loadedPivotTables = [];
+        const pivotTablesIndexed = {};
+        Object.entries(rawPivotTables).forEach(([pivotName, pivotTable]) => {
+            const pt = pivotTable;
+            const tableNumber = this._extractTableNumber(pivotName);
+            const cacheData = cacheMap.get(pt.cacheId);
+            const completePivotTable = {
+                ...pt,
+                tableNumber,
+                cacheDefinition: cacheData?.definition,
+                cacheRecords: cacheData?.records,
+                cacheFields: cacheData?.definition?.cacheFields || [],
+                rows: pt.rowFields.filter(f => f >= 0),
+                columns: pt.colFields.filter(f => f >= 0 && f !== -2),
+                values: pt.dataFields.map(df => df.fld),
+                metric: this._determineMetric(pt.dataFields),
+                applyWidthHeightFormats: pt.applyWidthHeightFormats || "0"
+            };
+            loadedPivotTables.push(completePivotTable);
+            pivotTablesIndexed[`../pivotTables/${pivotName}.xml`] = completePivotTable;
+        });
+        loadedPivotTables.sort((a, b) => a.tableNumber - b.tableNumber);
+        model.pivotTables = loadedPivotTables;
+        model.pivotTablesIndexed = pivotTablesIndexed;
+        model.loadedPivotTables = loadedPivotTables;
+    }
+    _extractTableNumber(name) {
+        const match = name.match(/pivotTable(\d+)/);
+        return match ? parseInt(match[1], 10) : 1;
+    }
+    _buildCacheIdMap(model) {
+        const rIdToCacheId = new Map();
+        const pivotCaches = model.pivotCaches || [];
+        for (const cache of pivotCaches) {
+            if (cache.cacheId && cache.rId) {
+                rIdToCacheId.set(cache.rId, parseInt(cache.cacheId, 10));
+            }
+        }
+        return rIdToCacheId;
+    }
+    _buildDefinitionToCacheIdMap(model) {
+        const definitionToCacheId = new Map();
+        const rIdToCacheId = this._buildCacheIdMap(model);
+        const workbookRels = model.workbookRels || [];
+        for (const rel of workbookRels) {
+            if (rel.Type === XLSXBase.RelType.PivotCacheDefinition && rel.Target) {
+                const match = rel.Target.match(/pivotCacheDefinition(\d+)\.xml/);
+                if (match) {
+                    const defName = `pivotCacheDefinition${match[1]}`;
+                    const cacheId = rIdToCacheId.get(rel.Id);
+                    if (cacheId !== undefined) {
+                        definitionToCacheId.set(defName, cacheId);
+                    }
+                }
+            }
+        }
+        return definitionToCacheId;
+    }
+    _determineMetric(dataFields) {
+        if (dataFields.length > 0 && dataFields[0].subtotal === "count") {
+            return "count";
+        }
+        return "sum";
+    }
+    // ===========================================================================
+    // Process Entry methods - shared by all platforms
+    // ===========================================================================
+    async _processWorksheetEntry(stream, model, sheetNo, options, path) {
+        const xform = new WorkSheetXform(options);
+        const worksheet = await xform.parseStream(stream);
+        if (!worksheet) {
+            throw new Error(`Failed to parse worksheet ${path}`);
+        }
+        worksheet.sheetNo = sheetNo;
+        model.worksheetHash[path] = worksheet;
+        model.worksheets.push(worksheet);
+    }
+    async _processCommentEntry(stream, model, name) {
+        const xform = new CommentsXform();
+        const comments = await xform.parseStream(stream);
+        model.comments[`../${name}.xml`] = comments;
+    }
+    async _processTableEntry(stream, model, name) {
+        const xform = new TableXform();
+        const table = await xform.parseStream(stream);
+        model.tables[`../tables/${name}.xml`] = table;
+    }
+    async _processWorksheetRelsEntry(stream, model, sheetNo) {
+        const xform = new RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.worksheetRels[sheetNo] = relationships;
+    }
+    async _processMediaEntry(stream, model, filename) {
+        const lastDot = filename.lastIndexOf(".");
+        if (lastDot >= 1) {
+            const extension = filename.substr(lastDot + 1);
+            const name = filename.substr(0, lastDot);
+            await new Promise((resolve, reject) => {
+                const streamBuf = this.createStreamBuf();
+                const cleanup = () => {
+                    stream.removeListener("error", onError);
+                    streamBuf.removeListener("error", onError);
+                    streamBuf.removeListener("finish", onFinish);
+                };
+                const onFinish = () => {
+                    cleanup();
+                    model.mediaIndex[filename] = model.media.length;
+                    model.mediaIndex[name] = model.media.length;
+                    const medium = {
+                        type: "image",
+                        name,
+                        extension,
+                        buffer: streamBuf.toBuffer ? streamBuf.toBuffer() : streamBuf.read()
+                    };
+                    model.media.push(medium);
+                    resolve();
+                };
+                const onError = (error) => {
+                    cleanup();
+                    reject(error);
+                };
+                streamBuf.once("finish", onFinish);
+                stream.on("error", onError);
+                streamBuf.on("error", onError);
+                stream.pipe(streamBuf);
+            });
+        }
+    }
+    async _processDrawingEntry(entry, model, name) {
+        const xform = new DrawingXform();
+        const drawing = await xform.parseStream(entry);
+        model.drawings[name] = drawing;
+    }
+    async _processDrawingRelsEntry(entry, model, name) {
+        const xform = new RelationshipsXform();
+        const relationships = await xform.parseStream(entry);
+        model.drawingRels[name] = relationships;
+    }
+    async _processVmlDrawingEntry(entry, model, name) {
+        const xform = new VmlNotesXform();
+        const vmlDrawing = await xform.parseStream(entry);
+        model.vmlDrawings[`../drawings/${name}.vml`] = vmlDrawing;
+    }
+    async _processThemeEntry(stream, model, name) {
+        await new Promise((resolve, reject) => {
+            const streamBuf = this.createStreamBuf();
+            const cleanup = () => {
+                stream.removeListener("error", onError);
+                streamBuf.removeListener("error", onError);
+                streamBuf.removeListener("finish", onFinish);
+            };
+            const onFinish = () => {
+                cleanup();
+                const data = streamBuf.read();
+                model.themes[name] = data
+                    ? typeof data === "string"
+                        ? data
+                        : this.bufferToString(data)
+                    : "";
+                resolve();
+            };
+            const onError = (err) => {
+                cleanup();
+                reject(err);
+            };
+            streamBuf.once("finish", onFinish);
+            stream.on("error", onError);
+            streamBuf.on("error", onError);
+            stream.pipe(streamBuf);
+        });
+    }
+    async _processPivotTableEntry(stream, model, name) {
+        const xform = new PivotTableXform();
+        const pivotTable = await xform.parseStream(stream);
+        if (pivotTable) {
+            model.pivotTables[name] = pivotTable;
+        }
+    }
+    async _processPivotTableRelsEntry(stream, model, name) {
+        const xform = new RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.pivotTableRels[name] = relationships;
+    }
+    async _processPivotCacheDefinitionEntry(stream, model, name) {
+        const xform = new PivotCacheDefinitionXform();
+        const cacheDefinition = await xform.parseStream(stream);
+        if (cacheDefinition) {
+            model.pivotCacheDefinitions[name] = cacheDefinition;
+        }
+    }
+    async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
+        const xform = new RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.pivotCacheDefinitionRels[name] = relationships;
+    }
+    async _processPivotCacheRecordsEntry(stream, model, name) {
+        const xform = new PivotCacheRecordsXform();
+        const cacheRecords = await xform.parseStream(stream);
+        if (cacheRecords) {
+            model.pivotCacheRecords[name] = cacheRecords;
+        }
+    }
+    // ===========================================================================
+    // loadFromFiles - shared logic for loading from pre-extracted ZIP data
+    // ===========================================================================
+    async loadFromFiles(zipData, options) {
+        const model = {
+            worksheets: [],
+            worksheetHash: {},
+            worksheetRels: [],
+            themes: {},
+            media: [],
+            mediaIndex: {},
+            drawings: {},
+            drawingRels: {},
+            comments: {},
+            tables: {},
+            vmlDrawings: {},
+            pivotTables: {},
+            pivotTableRels: {},
+            pivotCacheDefinitions: {},
+            pivotCacheDefinitionRels: {},
+            pivotCacheRecords: {}
+        };
+        const entries = Object.keys(zipData).map(name => ({
+            name,
+            dir: name.endsWith("/"),
+            data: zipData[name]
+        }));
+        for (const entry of entries) {
+            if (!entry.dir) {
+                let entryName = entry.name;
+                if (entryName[0] === "/") {
+                    entryName = entryName.substr(1);
+                }
+                // Create appropriate stream based on entry type
+                const isBinaryEntry = entryName.match(/xl\/media\//) || entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/);
+                const stream = isBinaryEntry
+                    ? this.createBinaryStream(entry.data)
+                    : this.createTextStream(this.bufferToString(entry.data));
+                const match = entryName.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
+                if (match) {
+                    const sheetNo = parseInt(match[1], 10);
+                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+                }
+                else {
+                    switch (entryName) {
+                        case "_rels/.rels":
+                            model.globalRels = await this.parseRels(stream);
+                            break;
+                        case "xl/workbook.xml": {
+                            const workbook = await this.parseWorkbook(stream);
+                            model.sheets = workbook.sheets;
+                            model.definedNames = workbook.definedNames;
+                            model.views = workbook.views;
+                            model.properties = workbook.properties;
+                            model.calcProperties = workbook.calcProperties;
+                            model.pivotCaches = workbook.pivotCaches;
+                            break;
+                        }
+                        case "xl/sharedStrings.xml":
+                            model.sharedStrings = new SharedStringsXform();
+                            await model.sharedStrings.parseStream(stream);
+                            break;
+                        case "xl/_rels/workbook.xml.rels":
+                            model.workbookRels = await this.parseRels(stream);
+                            break;
+                        case "docProps/app.xml": {
+                            const appXform = new AppXform();
+                            const appProperties = await appXform.parseStream(stream);
+                            model.company = appProperties.company;
+                            model.manager = appProperties.manager;
+                            break;
+                        }
+                        case "docProps/core.xml": {
+                            const coreXform = new CoreXform();
+                            const coreProperties = await coreXform.parseStream(stream);
+                            Object.assign(model, coreProperties);
+                            break;
+                        }
+                        case "xl/styles.xml":
+                            model.styles = new StylesXform();
+                            await model.styles.parseStream(stream);
+                            break;
+                        default:
+                            await this._processDefaultEntry(stream, model, entryName);
+                    }
+                }
+            }
+        }
+        this.reconcile(model, options);
+        this.workbook.model = model;
+        return this.workbook;
+    }
+    /**
+     * Process default entries (drawings, comments, tables, etc.)
+     */
+    async _processDefaultEntry(stream, model, entryName) {
+        let match;
+        match = entryName.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml[.]rels/);
+        if (match) {
+            const sheetNo = parseInt(match[1], 10);
+            await this._processWorksheetRelsEntry(stream, model, sheetNo);
+            return;
+        }
+        match = entryName.match(/xl\/media\/([a-zA-Z0-9]+[.][a-zA-Z0-9]{3,4})$/);
+        if (match) {
+            await this._processMediaEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/drawings\/(drawing\d+)[.]xml/);
+        if (match) {
+            await this._processDrawingEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/drawings\/_rels\/(drawing\d+)[.]xml[.]rels/);
+        if (match) {
+            await this._processDrawingRelsEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/drawings\/(vmlDrawing\d+)[.]vml/);
+        if (match) {
+            await this._processVmlDrawingEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/comments(\d+)[.]xml/);
+        if (match) {
+            await this._processCommentEntry(stream, model, `comments${match[1]}`);
+            return;
+        }
+        match = entryName.match(/xl\/tables\/(table\d+)[.]xml/);
+        if (match) {
+            await this._processTableEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/);
+        if (match) {
+            await this._processThemeEntry(stream, model, match[1]);
+            return;
+        }
+        // Pivot table files
+        match = entryName.match(/xl\/pivotTables\/(pivotTable\d+)[.]xml/);
+        if (match) {
+            await this._processPivotTableEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels/);
+        if (match) {
+            await this._processPivotTableRelsEntry(stream, model, match[1]);
+            return;
+        }
+        // Pivot cache files
+        match = entryName.match(/xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml/);
+        if (match) {
+            await this._processPivotCacheDefinitionEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels/);
+        if (match) {
+            await this._processPivotCacheDefinitionRelsEntry(stream, model, match[1]);
+            return;
+        }
+        match = entryName.match(/xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml/);
+        if (match) {
+            await this._processPivotCacheRecordsEntry(stream, model, match[1]);
+            return;
+        }
+    }
+    // ===========================================================================
+    // Write methods - shared by all platforms
+    // ===========================================================================
+    async addContentTypes(zip, model) {
+        const xform = new ContentTypesXform();
+        const xml = xform.toXml(model);
+        zip.append(xml, { name: "[Content_Types].xml" });
+    }
+    async addApp(zip, model) {
+        const xform = new AppXform();
+        const xml = xform.toXml(model);
+        zip.append(xml, { name: "docProps/app.xml" });
+    }
+    async addCore(zip, model) {
+        const xform = new CoreXform();
+        zip.append(xform.toXml(model), { name: "docProps/core.xml" });
+    }
+    async addThemes(zip, model) {
+        const themes = model.themes || { theme1: theme1Xml };
+        Object.keys(themes).forEach(name => {
+            const xml = themes[name];
+            const path = `xl/theme/${name}.xml`;
+            zip.append(xml, { name: path });
+        });
+    }
+    async addOfficeRels(zip, _model) {
+        const xform = new RelationshipsXform();
+        const xml = xform.toXml([
+            { Id: "rId1", Type: XLSXBase.RelType.OfficeDocument, Target: "xl/workbook.xml" },
+            { Id: "rId2", Type: XLSXBase.RelType.CoreProperties, Target: "docProps/core.xml" },
+            { Id: "rId3", Type: XLSXBase.RelType.ExtenderProperties, Target: "docProps/app.xml" }
+        ]);
+        zip.append(xml, { name: "_rels/.rels" });
+    }
+    async addWorkbookRels(zip, model) {
+        let count = 1;
+        const relationships = [
+            { Id: `rId${count++}`, Type: XLSXBase.RelType.Styles, Target: "styles.xml" },
+            { Id: `rId${count++}`, Type: XLSXBase.RelType.Theme, Target: "theme/theme1.xml" }
+        ];
+        if (model.sharedStrings.count) {
+            relationships.push({
+                Id: `rId${count++}`,
+                Type: XLSXBase.RelType.SharedStrings,
+                Target: "sharedStrings.xml"
+            });
+        }
+        (model.pivotTables || []).forEach((pivotTable) => {
+            pivotTable.rId = `rId${count++}`;
+            relationships.push({
+                Id: pivotTable.rId,
+                Type: XLSXBase.RelType.PivotCacheDefinition,
+                Target: `pivotCache/pivotCacheDefinition${pivotTable.tableNumber}.xml`
+            });
+        });
+        model.worksheets.forEach((worksheet, index) => {
+            worksheet.rId = `rId${count++}`;
+            worksheet.fileIndex = index + 1;
+            relationships.push({
+                Id: worksheet.rId,
+                Type: XLSXBase.RelType.Worksheet,
+                Target: `worksheets/sheet${worksheet.fileIndex}.xml`
+            });
+        });
+        const xform = new RelationshipsXform();
+        const xml = xform.toXml(relationships);
+        zip.append(xml, { name: "xl/_rels/workbook.xml.rels" });
+    }
+    async addSharedStrings(zip, model) {
+        if (model.sharedStrings && model.sharedStrings.count) {
+            zip.append(model.sharedStrings.xml, { name: "xl/sharedStrings.xml" });
+        }
+    }
+    async addStyles(zip, model) {
+        const { xml } = model.styles;
+        if (xml) {
+            zip.append(xml, { name: "xl/styles.xml" });
+        }
+    }
+    async addWorkbook(zip, model) {
+        const xform = new WorkbookXform();
+        zip.append(xform.toXml(model), { name: "xl/workbook.xml" });
+    }
+    async addWorksheets(zip, model) {
+        const worksheetXform = new WorkSheetXform();
+        const relationshipsXform = new RelationshipsXform();
+        const commentsXform = new CommentsXform();
+        const vmlNotesXform = new VmlNotesXform();
+        model.worksheets.forEach((worksheet, index) => {
+            const fileIndex = worksheet.fileIndex || index + 1;
+            let xmlStream = new XmlStream();
+            worksheetXform.render(xmlStream, worksheet);
+            zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${fileIndex}.xml` });
+            if (worksheet.rels && worksheet.rels.length) {
+                xmlStream = new XmlStream();
+                relationshipsXform.render(xmlStream, worksheet.rels);
+                zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${fileIndex}.xml.rels` });
+            }
+            if (worksheet.comments.length > 0) {
+                xmlStream = new XmlStream();
+                commentsXform.render(xmlStream, worksheet);
+                zip.append(xmlStream.xml, { name: `xl/comments${fileIndex}.xml` });
+                xmlStream = new XmlStream();
+                vmlNotesXform.render(xmlStream, worksheet);
+                zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${fileIndex}.vml` });
+            }
+        });
+    }
+    addDrawings(zip, model) {
+        const drawingXform = new DrawingXform();
+        const relsXform = new RelationshipsXform();
+        model.worksheets.forEach((worksheet) => {
+            const { drawing } = worksheet;
+            if (drawing) {
+                drawingXform.prepare(drawing);
+                let xml = drawingXform.toXml(drawing);
+                zip.append(xml, { name: `xl/drawings/${drawing.name}.xml` });
+                xml = relsXform.toXml(drawing.rels);
+                zip.append(xml, { name: `xl/drawings/_rels/${drawing.name}.xml.rels` });
+            }
+        });
+    }
+    addTables(zip, model) {
+        const tableXform = new TableXform();
+        model.worksheets.forEach((worksheet) => {
+            const { tables } = worksheet;
+            tables.forEach((table) => {
+                tableXform.prepare(table, {});
+                const tableXml = tableXform.toXml(table);
+                zip.append(tableXml, { name: `xl/tables/${table.target}` });
+            });
+        });
+    }
+    addPivotTables(zip, model) {
+        if (!model.pivotTables.length) {
+            return;
+        }
+        const pivotCacheRecordsXform = new PivotCacheRecordsXform();
+        const pivotCacheDefinitionXform = new PivotCacheDefinitionXform();
+        const pivotTableXform = new PivotTableXform();
+        const relsXform = new RelationshipsXform();
+        model.pivotTables.forEach((pivotTable) => {
+            const n = pivotTable.tableNumber;
+            const isLoaded = pivotTable.isLoaded;
+            if (isLoaded) {
+                if (pivotTable.cacheDefinition) {
+                    const xml = pivotCacheDefinitionXform.toXml(pivotTable.cacheDefinition);
+                    zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
+                }
+                if (pivotTable.cacheRecords) {
+                    const xml = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
+                    zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+                }
+            }
+            else {
+                let xml = pivotCacheRecordsXform.toXml(pivotTable);
+                zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+                xml = pivotCacheDefinitionXform.toXml(pivotTable);
+                zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
+            }
+            let xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSXBase.RelType.PivotCacheRecords,
+                    Target: `pivotCacheRecords${n}.xml`
+                }
+            ]);
+            zip.append(xml, { name: `xl/pivotCache/_rels/pivotCacheDefinition${n}.xml.rels` });
+            xml = pivotTableXform.toXml(pivotTable);
+            zip.append(xml, { name: `xl/pivotTables/pivotTable${n}.xml` });
+            xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSXBase.RelType.PivotCacheDefinition,
+                    Target: `../pivotCache/pivotCacheDefinition${n}.xml`
+                }
+            ]);
+            zip.append(xml, { name: `xl/pivotTables/_rels/pivotTable${n}.xml.rels` });
+        });
+    }
+    _finalize(zip) {
+        return new Promise((resolve, reject) => {
+            zip.on("finish", () => {
+                resolve(this);
+            });
+            zip.on("error", reject);
+            zip.finalize();
+        });
+    }
+    prepareModel(model, options) {
+        model.creator = model.creator || "ExcelTS";
+        model.lastModifiedBy = model.lastModifiedBy || "ExcelTS";
+        model.created = model.created || new Date();
+        model.modified = model.modified || new Date();
+        model.useSharedStrings =
+            options.useSharedStrings !== undefined ? options.useSharedStrings : true;
+        model.useStyles = options.useStyles !== undefined ? options.useStyles : true;
+        model.sharedStrings = new SharedStringsXform();
+        model.styles = model.useStyles ? new StylesXform(true) : new StylesXform.Mock();
+        const workbookXform = new WorkbookXform();
+        const worksheetXform = new WorkSheetXform();
+        workbookXform.prepare(model);
+        const worksheetOptions = {
+            sharedStrings: model.sharedStrings,
+            styles: model.styles,
+            date1904: model.properties.date1904,
+            drawingsCount: 0,
+            media: model.media
+        };
+        worksheetOptions.drawings = model.drawings = [];
+        worksheetOptions.commentRefs = model.commentRefs = [];
+        let tableCount = 0;
+        model.tables = [];
+        model.worksheets.forEach((worksheet) => {
+            worksheet.tables.forEach((table) => {
+                tableCount++;
+                table.target = `table${tableCount}.xml`;
+                table.id = tableCount;
+                model.tables.push(table);
+            });
+            worksheetXform.prepare(worksheet, worksheetOptions);
+        });
+    }
+}
+XLSXBase.RelType = RelType;
+export { XLSXBase };