@microsoft/connected-workbooks 1.0.0 → 2.1.16-beta

package/dist/utils/documentUtils.d.ts

@@ -0,0 +1,15 @@
+import JSZip from "jszip";
+import { DataTypes } from "../types";
+declare const _default: {
+    createOrUpdateProperty: (doc: Document, parent: Element, property: string, value?: string | null | undefined) => void;
+    getDocPropsProperties: (zip: JSZip) => Promise<{
+        doc: Document;
+        properties: Element;
+    }>;
+    getCellReferenceRelative: (col: number, row: number) => string;
+    getCellReferenceAbsolute: (col: number, row: number) => string;
+    createCell: (doc: Document, colIndex: number, rowIndex: number, dataType: DataTypes, data: string) => Element;
+    getTableReference: (numberOfCols: number, numberOfRows: number) => string;
+    resolveType: (originalDataType: DataTypes, originalData: string | number | boolean) => DataTypes;
+};
+export default _default;

package/dist/utils/documentUtils.js

@@ -0,0 +1,101 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const types_1 = require("../types");
+const createOrUpdateProperty = (doc, parent, property, value) => {
+    if (value === undefined) {
+        return;
+    }
+    const elements = parent.getElementsByTagName(property);
+    if ((elements === null || elements === void 0 ? void 0 : elements.length) === 0) {
+        const newElement = doc.createElement(property);
+        newElement.textContent = value;
+        parent.appendChild(newElement);
+    }
+    else if (elements.length > 1) {
+        throw new Error(`Invalid DocProps core.xml, multiple ${property} elements`);
+    }
+    else if ((elements === null || elements === void 0 ? void 0 : elements.length) > 0) {
+        elements[0].textContent = value;
+    }
+};
+const getDocPropsProperties = (zip) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const docPropsCoreXmlString = yield ((_a = zip.file(constants_1.docPropsCoreXmlPath)) === null || _a === void 0 ? void 0 : _a.async(constants_1.textResultType));
+    if (docPropsCoreXmlString === undefined) {
+        throw new Error("DocProps core.xml was not found in template");
+    }
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(docPropsCoreXmlString, constants_1.xmlTextResultType);
+    const properties = doc.getElementsByTagName(constants_1.docPropsRootElement).item(0);
+    if (properties === null) {
+        throw new Error("Invalid DocProps core.xml");
+    }
+    return { doc, properties };
+});
+const getCellReferenceAbsolute = (col, row) => {
+    // 65 is the ascii value of first column 'A'
+    return "$" + String.fromCharCode(col + 65) + "$" + row.toString();
+};
+const getCellReferenceRelative = (col, row) => {
+    // 65 is the ascii value of first column 'A'
+    return String.fromCharCode(col + 65) + row.toString();
+};
+const getTableReference = (numberOfCols, numberOfRows) => {
+    return `A1:${getCellReferenceRelative(numberOfCols, numberOfRows)}`;
+};
+const createCellElement = (doc, colIndex, rowIndex, dataType, data) => {
+    const cell = doc.createElementNS(doc.documentElement.namespaceURI, constants_1.element.kindCell);
+    cell.setAttribute(constants_1.elementAttributes.row, getCellReferenceRelative(colIndex, rowIndex + 1));
+    const cellData = doc.createElementNS(doc.documentElement.namespaceURI, constants_1.element.cellValue);
+    updateCellData(dataType, data, cell, cellData);
+    cell.appendChild(cellData);
+    return cell;
+};
+const updateCellData = (dataType, data, cell, cellData) => {
+    switch (resolveType(dataType, data)) {
+        case types_1.DataTypes.string:
+            cell.setAttribute(constants_1.element.text, constants_1.dataTypeKind.string);
+            break;
+        case types_1.DataTypes.number:
+            cell.setAttribute(constants_1.element.text, constants_1.dataTypeKind.number);
+            break;
+        case types_1.DataTypes.boolean:
+            cell.setAttribute(constants_1.element.text, constants_1.dataTypeKind.boolean);
+            break;
+    }
+    cellData.textContent = data;
+};
+const resolveType = (originalDataType, originalData) => {
+    if (originalDataType !== types_1.DataTypes.autodetect) {
+        return originalDataType;
+    }
+    const data = originalData;
+    let dataType = isNaN(Number(data)) ? types_1.DataTypes.string : types_1.DataTypes.number;
+    if (dataType == types_1.DataTypes.string) {
+        if (data.toLowerCase().trim() == constants_1.trueStr || data.toLowerCase().trim() == constants_1.falseStr) {
+            dataType = types_1.DataTypes.boolean;
+        }
+    }
+    return dataType;
+};
+exports.default = {
+    createOrUpdateProperty,
+    getDocPropsProperties,
+    getCellReferenceRelative,
+    getCellReferenceAbsolute,
+    createCell: createCellElement,
+    getTableReference,
+    resolveType,
+};

package/dist/utils/htmlUtils.d.ts

@@ -0,0 +1 @@
+export declare const extractTableValues: (table: HTMLTableElement) => [string[], string[][]];

package/dist/utils/htmlUtils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTableValues = void 0;
+const extractTableValues = (table) => {
+    const headers = [];
+    const rows = [];
+    // Extract headers
+    const headerRow = table.rows[0];
+    for (let i = 0; i < headerRow.cells.length; i++) {
+        const cell = headerRow.cells[i];
+        headers.push(cell.textContent || "");
+    }
+    // Extract values from each row
+    for (let i = 1; i < table.rows.length; i++) {
+        const row = table.rows[i];
+        const rowData = [];
+        for (let j = 0; j < row.cells.length; j++) {
+            const cell = row.cells[j];
+            rowData.push(cell.textContent || "");
+        }
+        rows.push(rowData);
+    }
+    return [headers, rows];
+};
+exports.extractTableValues = extractTableValues;

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export { default as pqUtils } from "./pqUtils";
+export { default as arrayUtils } from "./arrayUtils";
+export { default as documentUtils } from "./documentUtils";
+export { default as xmlPartsUtils } from "./xmlPartsUtils";
+export { default as xmlInnerPartsUtils } from "./xmlInnerPartsUtils";
+export { default as tableUtils } from "./tableUtils";

package/dist/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableUtils = exports.xmlInnerPartsUtils = exports.xmlPartsUtils = exports.documentUtils = exports.arrayUtils = exports.pqUtils = void 0;
+var pqUtils_1 = require("./pqUtils");
+Object.defineProperty(exports, "pqUtils", { enumerable: true, get: function () { return __importDefault(pqUtils_1).default; } });
+var arrayUtils_1 = require("./arrayUtils");
+Object.defineProperty(exports, "arrayUtils", { enumerable: true, get: function () { return __importDefault(arrayUtils_1).default; } });
+var documentUtils_1 = require("./documentUtils");
+Object.defineProperty(exports, "documentUtils", { enumerable: true, get: function () { return __importDefault(documentUtils_1).default; } });
+var xmlPartsUtils_1 = require("./xmlPartsUtils");
+Object.defineProperty(exports, "xmlPartsUtils", { enumerable: true, get: function () { return __importDefault(xmlPartsUtils_1).default; } });
+var xmlInnerPartsUtils_1 = require("./xmlInnerPartsUtils");
+Object.defineProperty(exports, "xmlInnerPartsUtils", { enumerable: true, get: function () { return __importDefault(xmlInnerPartsUtils_1).default; } });
+var tableUtils_1 = require("./tableUtils");
+Object.defineProperty(exports, "tableUtils", { enumerable: true, get: function () { return __importDefault(tableUtils_1).default; } });

package/dist/utils/mashupDocumentParser.d.ts

@@ -0,0 +1,7 @@
+export default class MashupHandler {
+    ReplaceSingleQuery(base64Str: string, queryName: string, queryMashupDoc: string): Promise<string>;
+    private getPackageComponents;
+    private editSingleQueryPackage;
+    private setSection1m;
+    private editSingleQueryMetadata;
+}

package/dist/utils/mashupDocumentParser.js

@@ -0,0 +1,166 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base64 = __importStar(require("base64-js"));
+const jszip_1 = __importDefault(require("jszip"));
+const constants_1 = require("./constants");
+const _1 = require(".");
+class MashupHandler {
+    constructor() {
+        this.setSection1m = (queryMashupDoc, zip) => {
+            var _a;
+            if (!((_a = zip.file(constants_1.section1mPath)) === null || _a === void 0 ? void 0 : _a.async(constants_1.textResultType))) {
+                throw new Error(constants_1.formulaSectionNotFoundErr);
+            }
+            const newSection1m = queryMashupDoc;
+            zip.file(constants_1.section1mPath, newSection1m, {
+                compression: constants_1.emptyValue,
+            });
+        };
+        this.editSingleQueryMetadata = (metadataArray, metadata) => {
+            var _a;
+            //extract metadataXml
+            const mashupArray = new _1.arrayUtils.ArrayReader(metadataArray.buffer);
+            const metadataVersion = mashupArray.getBytes(4);
+            const metadataXmlSize = mashupArray.getInt32();
+            const metadataXml = mashupArray.getBytes(metadataXmlSize);
+            const endBuffer = mashupArray.getBytes();
+            //parse metdataXml
+            const textDecoder = new TextDecoder();
+            const metadataString = textDecoder.decode(metadataXml);
+            const parser = new DOMParser();
+            const serializer = new XMLSerializer();
+            const parsedMetadata = parser.parseFromString(metadataString, constants_1.xmlTextResultType);
+            // Update InfoPaths to new QueryName
+            const itemPaths = parsedMetadata.getElementsByTagName(constants_1.element.itemPath);
+            if (itemPaths && itemPaths.length) {
+                for (let i = 0; i < itemPaths.length; i++) {
+                    const itemPath = itemPaths[i];
+                    const content = itemPath.innerHTML;
+                    if (content.includes(constants_1.section1PathPrefix)) {
+                        const strArr = content.split(constants_1.divider);
+                        strArr[1] = metadata.queryName;
+                        const newContent = strArr.join(constants_1.divider);
+                        itemPath.textContent = newContent;
+                    }
+                }
+            }
+            const entries = parsedMetadata.getElementsByTagName(constants_1.element.entry);
+            if (entries && entries.length) {
+                for (let i = 0; i < entries.length; i++) {
+                    const entry = entries[i];
+                    const entryAttributes = entry.attributes;
+                    const entryAttributesArr = [...entryAttributes];
+                    const entryProp = entryAttributesArr.find((prop) => {
+                        return (prop === null || prop === void 0 ? void 0 : prop.name) === constants_1.elementAttributes.type;
+                    });
+                    if ((entryProp === null || entryProp === void 0 ? void 0 : entryProp.nodeValue) == constants_1.elementAttributes.relationshipInfo) {
+                        const newValue = (_a = entry
+                            .getAttribute(constants_1.elementAttributes.value)) === null || _a === void 0 ? void 0 : _a.replace(/Query1/g, metadata.queryName);
+                        if (newValue) {
+                            entry.setAttribute(constants_1.elementAttributes.value, newValue);
+                        }
+                    }
+                    if ((entryProp === null || entryProp === void 0 ? void 0 : entryProp.nodeValue) == constants_1.elementAttributes.resultType) {
+                        entry.setAttribute(constants_1.elementAttributes.value, constants_1.elementAttributesValues.tableResultType());
+                    }
+                    if ((entryProp === null || entryProp === void 0 ? void 0 : entryProp.nodeValue) == constants_1.elementAttributes.fillColumnNames) {
+                        const oldValue = entry.getAttribute(constants_1.elementAttributes.value);
+                        if (oldValue) {
+                            entry.setAttribute(constants_1.elementAttributes.value, oldValue.replace(constants_1.defaults.queryName, metadata.queryName));
+                        }
+                    }
+                    if ((entryProp === null || entryProp === void 0 ? void 0 : entryProp.nodeValue) == constants_1.elementAttributes.fillTarget) {
+                        const oldValue = entry.getAttribute(constants_1.elementAttributes.value);
+                        if (oldValue) {
+                            entry.setAttribute(constants_1.elementAttributes.value, oldValue.replace(constants_1.defaults.queryName, metadata.queryName));
+                        }
+                    }
+                    if ((entryProp === null || entryProp === void 0 ? void 0 : entryProp.nodeValue) == constants_1.elementAttributes.fillLastUpdated) {
+                        const nowTime = new Date().toISOString();
+                        entry.setAttribute(constants_1.elementAttributes.value, (constants_1.elementAttributes.day + nowTime).replace(/Z/, "0000Z"));
+                    }
+                }
+            }
+            // Convert new metadataXml to Uint8Array
+            const newMetadataString = serializer.serializeToString(parsedMetadata);
+            const encoder = new TextEncoder();
+            const newMetadataXml = encoder.encode(newMetadataString);
+            const newMetadataXmlSize = _1.arrayUtils.getInt32Buffer(newMetadataXml.byteLength);
+            const newMetadataArray = _1.arrayUtils.concatArrays(metadataVersion, newMetadataXmlSize, newMetadataXml, endBuffer);
+            return newMetadataArray;
+        };
+    }
+    ReplaceSingleQuery(base64Str, queryName, queryMashupDoc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { version, packageOPC, permissionsSize, permissions, metadata, endBuffer } = this.getPackageComponents(base64Str);
+            const newPackageBuffer = yield this.editSingleQueryPackage(packageOPC, queryMashupDoc);
+            const packageSizeBuffer = _1.arrayUtils.getInt32Buffer(newPackageBuffer.byteLength);
+            const permissionsSizeBuffer = _1.arrayUtils.getInt32Buffer(permissionsSize);
+            const newMetadataBuffer = this.editSingleQueryMetadata(metadata, { queryName });
+            const metadataSizeBuffer = _1.arrayUtils.getInt32Buffer(newMetadataBuffer.byteLength);
+            const newMashup = _1.arrayUtils.concatArrays(version, packageSizeBuffer, newPackageBuffer, permissionsSizeBuffer, permissions, metadataSizeBuffer, newMetadataBuffer, endBuffer);
+            return base64.fromByteArray(newMashup);
+        });
+    }
+    getPackageComponents(base64Str) {
+        const buffer = base64.toByteArray(base64Str).buffer;
+        const mashupArray = new _1.arrayUtils.ArrayReader(buffer);
+        const version = mashupArray.getBytes(4);
+        const packageSize = mashupArray.getInt32();
+        const packageOPC = mashupArray.getBytes(packageSize);
+        const permissionsSize = mashupArray.getInt32();
+        const permissions = mashupArray.getBytes(permissionsSize);
+        const metadataSize = mashupArray.getInt32();
+        const metadata = mashupArray.getBytes(metadataSize);
+        const endBuffer = mashupArray.getBytes();
+        return {
+            version,
+            packageOPC,
+            permissionsSize,
+            permissions,
+            metadata,
+            endBuffer,
+        };
+    }
+    editSingleQueryPackage(packageOPC, queryMashupDoc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packageZip = yield jszip_1.default.loadAsync(packageOPC);
+            this.setSection1m(queryMashupDoc, packageZip);
+            return yield packageZip.generateAsync({ type: constants_1.uint8ArrayType });
+        });
+    }
+}
+exports.default = MashupHandler;

package/dist/utils/pqUtils.d.ts

@@ -0,0 +1,15 @@
+import JSZip from "jszip";
+declare type CustomXmlFile = {
+    found: boolean;
+    path: string;
+    xmlString: string | undefined;
+    value: string | undefined;
+};
+declare const _default: {
+    getBase64: (zip: JSZip) => Promise<string | undefined>;
+    setBase64: (zip: JSZip, base64: string) => Promise<void>;
+    getCustomXmlFile: (zip: JSZip, url: string, encoding?: string) => Promise<CustomXmlFile>;
+    getDataMashupFile: (zip: JSZip) => Promise<CustomXmlFile>;
+    validateQueryName: (queryName: string) => void;
+};
+export default _default;

package/dist/utils/pqUtils.js

@@ -0,0 +1,101 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const constants_1 = require("./constants");
+const generators_1 = require("../generators");
+const getBase64 = (zip) => __awaiter(void 0, void 0, void 0, function* () {
+    const mashup = yield getDataMashupFile(zip);
+    return mashup.value;
+});
+const setBase64 = (zip, base64) => __awaiter(void 0, void 0, void 0, function* () {
+    const newXml = generators_1.generateMashupXMLTemplate(base64);
+    const encoded = iconv_lite_1.default.encode(newXml, "UCS2", { addBOM: true });
+    const mashup = yield getDataMashupFile(zip);
+    zip.file(mashup === null || mashup === void 0 ? void 0 : mashup.path, encoded);
+});
+const getDataMashupFile = (zip) => __awaiter(void 0, void 0, void 0, function* () {
+    let mashup;
+    for (const url of constants_1.URLS.PQ) {
+        const item = yield getCustomXmlFile(zip, url);
+        if (item.found) {
+            mashup = item;
+            break;
+        }
+    }
+    if (!mashup) {
+        throw new Error("DataMashup XML is not found");
+    }
+    return mashup;
+});
+const getCustomXmlFile = (zip, url, encoding = "UTF-16") => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const parser = new DOMParser();
+    const itemsArray = yield zip.file(/customXml\/item\d.xml/);
+    if (!itemsArray || itemsArray.length === 0) {
+        throw new Error("No customXml files were found!");
+    }
+    let found = false;
+    let path;
+    let xmlString;
+    let value;
+    for (let i = 1; i <= itemsArray.length; i++) {
+        path = generators_1.generateCustomXmlFilePath(i);
+        const xmlValue = yield ((_a = zip.file(path)) === null || _a === void 0 ? void 0 : _a.async("uint8array"));
+        if (xmlValue === undefined) {
+            break;
+        }
+        xmlString = iconv_lite_1.default.decode(xmlValue.buffer, encoding);
+        const doc = parser.parseFromString(xmlString, "text/xml");
+        found = ((_b = doc === null || doc === void 0 ? void 0 : doc.documentElement) === null || _b === void 0 ? void 0 : _b.namespaceURI) === url;
+        if (found) {
+            value = doc.documentElement.innerHTML;
+            break;
+        }
+    }
+    return { found, path: path, xmlString: xmlString, value };
+});
+const queryNameHasInvalidChars = (queryName) => {
+    const invalidQueryNameChars = ['"', "."];
+    // Control characters as defined in Unicode
+    for (let c = 0; c <= 0x001f; ++c) {
+        invalidQueryNameChars.push(String.fromCharCode(c));
+    }
+    for (let c = 0x007f; c <= 0x009f; ++c) {
+        invalidQueryNameChars.push(String.fromCharCode(c));
+    }
+    return queryName.split("").some((ch) => invalidQueryNameChars.indexOf(ch) !== -1);
+};
+const validateQueryName = (queryName) => {
+    if (queryName) {
+        if (queryName.length > constants_1.maxQueryLength) {
+            throw new Error(constants_1.QueryNameMaxLengthErr);
+        }
+        if (queryNameHasInvalidChars(queryName)) {
+            throw new Error(constants_1.QueryNameMaxLengthErr);
+        }
+    }
+    if (!queryName.trim()) {
+        throw new Error(constants_1.EmptyQueryNameErr);
+    }
+};
+exports.default = {
+    getBase64,
+    setBase64,
+    getCustomXmlFile,
+    getDataMashupFile,
+    validateQueryName,
+};

package/dist/utils/tableUtils.d.ts

@@ -0,0 +1,10 @@
+import JSZip from "jszip";
+import { TableData } from "../types";
+declare const _default: {
+    updateTableInitialDataIfNeeded: (zip: JSZip, tableData?: TableData | undefined, updateQueryTable?: boolean | undefined) => Promise<void>;
+    updateSheetsInitialData: (sheetsXmlString: string, tableData: TableData) => Promise<string>;
+    updateWorkbookInitialData: (workbookXmlString: string, tableData: TableData, queryName?: string | undefined) => Promise<string>;
+    updateTablesInitialData: (tableXmlString: string, tableData: TableData, updateQueryTable?: boolean) => Promise<string>;
+    updateQueryTablesInitialData: (queryTableXmlString: string, tableData: TableData) => Promise<string>;
+};
+export default _default;

package/dist/utils/tableUtils.js

@@ -0,0 +1,146 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const constants_1 = require("./constants");
+const documentUtils_1 = __importDefault(require("./documentUtils"));
+const uuid_1 = require("uuid");
+const updateTableInitialDataIfNeeded = (zip, tableData, updateQueryTable) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    if (!tableData) {
+        return;
+    }
+    const sheetsXmlString = yield ((_a = zip.file(constants_1.sheetsXmlPath)) === null || _a === void 0 ? void 0 : _a.async(constants_1.textResultType));
+    if (sheetsXmlString === undefined) {
+        throw new Error(constants_1.sheetsNotFoundErr);
+    }
+    const newSheet = yield updateSheetsInitialData(sheetsXmlString, tableData);
+    zip.file(constants_1.sheetsXmlPath, newSheet);
+    if (updateQueryTable) {
+        const queryTableXmlString = yield ((_b = zip.file(constants_1.queryTableXmlPath)) === null || _b === void 0 ? void 0 : _b.async(constants_1.textResultType));
+        if (queryTableXmlString === undefined) {
+            throw new Error(constants_1.queryTableNotFoundErr);
+        }
+        const newQueryTable = yield updateQueryTablesInitialData(queryTableXmlString, tableData);
+        zip.file(constants_1.queryTableXmlPath, newQueryTable);
+        // update defined name
+        const workbookXmlString = yield ((_c = zip.file(constants_1.workbookXmlPath)) === null || _c === void 0 ? void 0 : _c.async(constants_1.textResultType));
+        if (workbookXmlString === undefined) {
+            throw new Error(constants_1.sheetsNotFoundErr);
+        }
+        const newWorkbook = yield updateWorkbookInitialData(workbookXmlString, tableData);
+        zip.file(constants_1.workbookXmlPath, newWorkbook);
+    }
+    const tableXmlString = yield ((_d = zip.file(constants_1.tableXmlPath)) === null || _d === void 0 ? void 0 : _d.async(constants_1.textResultType));
+    if (tableXmlString === undefined) {
+        throw new Error(constants_1.tableNotFoundErr);
+    }
+    const newTable = yield updateTablesInitialData(tableXmlString, tableData, updateQueryTable);
+    zip.file(constants_1.tableXmlPath, newTable);
+});
+const updateTablesInitialData = (tableXmlString, tableData, updateQueryTable = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const tableDoc = parser.parseFromString(tableXmlString, constants_1.xmlTextResultType);
+    const tableColumns = tableDoc.getElementsByTagName(constants_1.element.tableColumns)[0];
+    tableColumns.textContent = "";
+    tableData.columnMetadata.forEach((col, columnIndex) => {
+        const tableColumn = tableDoc.createElementNS(tableDoc.documentElement.namespaceURI, constants_1.element.tableColumn);
+        tableColumn.setAttribute(constants_1.elementAttributes.id, (columnIndex + 1).toString());
+        tableColumn.setAttribute(constants_1.elementAttributes.name, col.name);
+        tableColumns.appendChild(tableColumn);
+        tableColumn.setAttribute(constants_1.elementAttributes.xr3uid, "{" + uuid_1.v4().toUpperCase() + "}");
+        if (updateQueryTable) {
+            tableColumn.setAttribute(constants_1.elementAttributes.uniqueName, (columnIndex + 1).toString());
+            tableColumn.setAttribute(constants_1.elementAttributes.queryTableFieldId, (columnIndex + 1).toString());
+        }
+    });
+    tableColumns.setAttribute(constants_1.elementAttributes.count, tableData.columnMetadata.length.toString());
+    tableDoc
+        .getElementsByTagName(constants_1.element.table)[0]
+        .setAttribute(constants_1.elementAttributes.reference, `A1:${documentUtils_1.default.getCellReferenceRelative(tableData.columnMetadata.length - 1, tableData.rows.length + 1)}`);
+    tableDoc
+        .getElementsByTagName(constants_1.element.autoFilter)[0]
+        .setAttribute(constants_1.elementAttributes.reference, `A1:${documentUtils_1.default.getCellReferenceRelative(tableData.columnMetadata.length - 1, tableData.rows.length + 1)}`);
+    return serializer.serializeToString(tableDoc);
+});
+const updateWorkbookInitialData = (workbookXmlString, tableData, queryName) => __awaiter(void 0, void 0, void 0, function* () {
+    const newParser = new DOMParser();
+    const newSerializer = new XMLSerializer();
+    const workbookDoc = newParser.parseFromString(workbookXmlString, constants_1.xmlTextResultType);
+    const definedName = workbookDoc.getElementsByTagName(constants_1.element.definedName)[0];
+    const prefix = queryName === undefined ? constants_1.defaults.queryName : queryName;
+    definedName.textContent =
+        prefix +
+            `!$A$1:${documentUtils_1.default.getCellReferenceAbsolute(tableData.columnMetadata.length - 1, tableData.rows.length + 1)}`;
+    return newSerializer.serializeToString(workbookDoc);
+});
+const updateQueryTablesInitialData = (queryTableXmlString, tableData) => __awaiter(void 0, void 0, void 0, function* () {
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const queryTableDoc = parser.parseFromString(queryTableXmlString, constants_1.xmlTextResultType);
+    const queryTableFields = queryTableDoc.getElementsByTagName(constants_1.element.queryTableFields)[0];
+    queryTableFields.textContent = "";
+    tableData.columnMetadata.forEach((col, columnIndex) => {
+        const queryTableField = queryTableDoc.createElementNS(queryTableDoc.documentElement.namespaceURI, constants_1.element.queryTableField);
+        queryTableField.setAttribute(constants_1.elementAttributes.id, (columnIndex + 1).toString());
+        queryTableField.setAttribute(constants_1.elementAttributes.name, col.name);
+        queryTableField.setAttribute(constants_1.elementAttributes.tableColumnId, (columnIndex + 1).toString());
+        queryTableFields.appendChild(queryTableField);
+    });
+    queryTableFields.setAttribute(constants_1.elementAttributes.count, tableData.columnMetadata.length.toString());
+    queryTableDoc
+        .getElementsByTagName(constants_1.element.queryTableRefresh)[0]
+        .setAttribute(constants_1.elementAttributes.nextId, (tableData.columnMetadata.length + 1).toString());
+    return serializer.serializeToString(queryTableDoc);
+});
+const updateSheetsInitialData = (sheetsXmlString, tableData) => __awaiter(void 0, void 0, void 0, function* () {
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const sheetsDoc = parser.parseFromString(sheetsXmlString, constants_1.xmlTextResultType);
+    const sheetData = sheetsDoc.getElementsByTagName(constants_1.element.sheetData)[0];
+    sheetData.textContent = "";
+    let rowIndex = 0;
+    const columnRow = sheetsDoc.createElementNS(sheetsDoc.documentElement.namespaceURI, constants_1.element.row);
+    columnRow.setAttribute(constants_1.elementAttributes.row, (rowIndex + 1).toString());
+    columnRow.setAttribute(constants_1.elementAttributes.spans, "1:" + tableData.columnMetadata.length);
+    columnRow.setAttribute(constants_1.elementAttributes.x14acDyDescent, "0.3");
+    tableData.columnMetadata.forEach((col, colIndex) => {
+        columnRow.appendChild(documentUtils_1.default.createCell(sheetsDoc, colIndex, rowIndex, types_1.DataTypes.string, col.name));
+    });
+    sheetData.appendChild(columnRow);
+    rowIndex++;
+    tableData.rows.forEach((row) => {
+        const newRow = sheetsDoc.createElementNS(sheetsDoc.documentElement.namespaceURI, constants_1.element.row);
+        newRow.setAttribute(constants_1.elementAttributes.row, (rowIndex + 1).toString());
+        newRow.setAttribute(constants_1.elementAttributes.spans, "1:" + row.length);
+        newRow.setAttribute(constants_1.elementAttributes.x14acDyDescent, "0.3");
+        row.forEach((cellContent, colIndex) => {
+            newRow.appendChild(documentUtils_1.default.createCell(sheetsDoc, colIndex, rowIndex, tableData.columnMetadata[colIndex].type, cellContent));
+        });
+        sheetData.appendChild(newRow);
+        rowIndex++;
+    });
+    sheetsDoc
+        .getElementsByTagName(constants_1.element.dimension)[0]
+        .setAttribute(constants_1.elementAttributes.reference, documentUtils_1.default.getTableReference(tableData.rows[0].length - 1, tableData.rows.length));
+    return serializer.serializeToString(sheetsDoc);
+});
+exports.default = {
+    updateTableInitialDataIfNeeded,
+    updateSheetsInitialData,
+    updateWorkbookInitialData,
+    updateTablesInitialData,
+    updateQueryTablesInitialData,
+};

package/dist/utils/xmlInnerPartsUtils.d.ts

@@ -0,0 +1,24 @@
+import JSZip from "jszip";
+import { DocProps } from "../types";
+declare const _default: {
+    updateDocProps: (zip: JSZip, docProps?: DocProps) => Promise<void>;
+    updateConnections: (connectionsXmlString: string, queryName: string, refreshOnOpen: boolean) => Promise<{
+        connectionId: string | undefined;
+        connectionXmlFileString: string;
+    }>;
+    updateSharedStrings: (sharedStringsXmlString: string, queryName: string) => Promise<{
+        sharedStringIndex: number;
+        newSharedStrings: string;
+    }>;
+    updateWorksheet: (sheetsXmlString: string, sharedStringIndex: string) => Promise<string>;
+    updatePivotTablesandQueryTables: (zip: JSZip, queryName: string, refreshOnOpen: boolean, connectionId: string) => Promise<void>;
+    updateQueryTable: (tableXmlString: string, connectionId: string, refreshOnOpen: boolean) => {
+        isQueryTableUpdated: boolean;
+        newQueryTable: string;
+    };
+    updatePivotTable: (tableXmlString: string, connectionId: string, refreshOnOpen: boolean) => {
+        isPivotTableUpdated: boolean;
+        newPivotTable: string;
+    };
+};
+export default _default;