@microsoft/connected-workbooks 2.1.16-beta → 2.1.25

package/dist/src/utils/mashupDocumentParser.js

@@ -0,0 +1,145 @@
+"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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+exports.editSingleQueryMetadata = exports.getPackageComponents = exports.replaceSingleQuery = void 0;
+const base64 = __importStar(require("base64-js"));
+const jszip_1 = __importDefault(require("jszip"));
+const constants_1 = require("./constants");
+const _1 = require(".");
+const replaceSingleQuery = (base64Str, queryName, queryMashupDoc) => __awaiter(void 0, void 0, void 0, function* () {
+    const { version, packageOPC, permissionsSize, permissions, metadata, endBuffer } = (0, exports.getPackageComponents)(base64Str);
+    const newPackageBuffer = yield editSingleQueryPackage(packageOPC, queryMashupDoc);
+    const packageSizeBuffer = _1.arrayUtils.getInt32Buffer(newPackageBuffer.byteLength);
+    const permissionsSizeBuffer = _1.arrayUtils.getInt32Buffer(permissionsSize);
+    const newMetadataBuffer = (0, exports.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);
+});
+exports.replaceSingleQuery = replaceSingleQuery;
+const 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,
+    };
+};
+exports.getPackageComponents = getPackageComponents;
+const editSingleQueryPackage = (packageOPC, queryMashupDoc) => __awaiter(void 0, void 0, void 0, function* () {
+    const packageZip = yield jszip_1.default.loadAsync(packageOPC);
+    setSection1m(queryMashupDoc, packageZip);
+    return yield packageZip.generateAsync({ type: constants_1.uint8ArrayType });
+});
+const 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,
+    });
+};
+const editSingleQueryMetadata = (metadataArray, metadata) => {
+    //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] = encodeURIComponent(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.resultType) {
+                entry.setAttribute(constants_1.elementAttributes.value, constants_1.elementAttributesValues.tableResultType());
+            }
+            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;
+};
+exports.editSingleQueryMetadata = editSingleQueryMetadata;

package/dist/src/utils/pqUtils.js

@@ -0,0 +1,100 @@
+"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 generators_1 = require("../generators");
+const buffer_1 = require("buffer");
+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 = (0, generators_1.generateMashupXMLTemplate)(base64);
+    const encoded = buffer_1.Buffer.from(constants_1.BOM + newXml, "ucs2");
+    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 = "utf16le") => __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 = (0, 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 = buffer_1.Buffer.from(xmlValue)
+            .toString(encoding)
+            .replace(/^\ufeff/, "");
+        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.QueryNameInvalidCharsErr);
+        }
+    }
+    if (!queryName.trim()) {
+        throw new Error(constants_1.EmptyQueryNameErr);
+    }
+};
+exports.default = {
+    getBase64,
+    setBase64,
+    getCustomXmlFile,
+    getDataMashupFile,
+    validateQueryName,
+};

package/dist/src/utils/tableUtils.js

@@ -0,0 +1,143 @@
+"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 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 = 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 = 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 = updateTablesInitialData(tableXmlString, tableData, updateQueryTable);
+    zip.file(constants_1.tableXmlPath, newTable);
+});
+const updateTablesInitialData = (tableXmlString, tableData, updateQueryTable = false) => {
+    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.columnNames.forEach((column, 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, column);
+        tableColumns.appendChild(tableColumn);
+        tableColumn.setAttribute(constants_1.elementAttributes.xr3uid, "{" + (0, 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.columnNames.length.toString());
+    tableDoc
+        .getElementsByTagName(constants_1.element.table)[0]
+        .setAttribute(constants_1.elementAttributes.reference, `A1:${documentUtils_1.default.getCellReferenceRelative(tableData.columnNames.length - 1, tableData.rows.length + 1)}`);
+    tableDoc
+        .getElementsByTagName(constants_1.element.autoFilter)[0]
+        .setAttribute(constants_1.elementAttributes.reference, `A1:${documentUtils_1.default.getCellReferenceRelative(tableData.columnNames.length - 1, tableData.rows.length + 1)}`);
+    return serializer.serializeToString(tableDoc);
+};
+const updateWorkbookInitialData = (workbookXmlString, tableData) => {
+    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];
+    definedName.textContent =
+        constants_1.defaults.sheetName + `!$A$1:${documentUtils_1.default.getCellReferenceAbsolute(tableData.columnNames.length - 1, tableData.rows.length + 1)}`;
+    return newSerializer.serializeToString(workbookDoc);
+};
+const updateQueryTablesInitialData = (queryTableXmlString, tableData) => {
+    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.columnNames.forEach((column, 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, column);
+        queryTableField.setAttribute(constants_1.elementAttributes.tableColumnId, (columnIndex + 1).toString());
+        queryTableFields.appendChild(queryTableField);
+    });
+    queryTableFields.setAttribute(constants_1.elementAttributes.count, tableData.columnNames.length.toString());
+    queryTableDoc.getElementsByTagName(constants_1.element.queryTableRefresh)[0].setAttribute(constants_1.elementAttributes.nextId, (tableData.columnNames.length + 1).toString());
+    return serializer.serializeToString(queryTableDoc);
+};
+const updateSheetsInitialData = (sheetsXmlString, tableData) => {
+    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.columnNames.length);
+    columnRow.setAttribute(constants_1.elementAttributes.x14acDyDescent, "0.3");
+    tableData.columnNames.forEach((col, colIndex) => {
+        columnRow.appendChild(documentUtils_1.default.createCell(sheetsDoc, colIndex, rowIndex, col));
+    });
+    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, 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/src/utils/xmlInnerPartsUtils.js

@@ -0,0 +1,200 @@
+"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 types_1 = require("../types");
+const constants_1 = require("./constants");
+const documentUtils_1 = __importDefault(require("./documentUtils"));
+const updateDocProps = (zip, docProps = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const { doc, properties } = yield documentUtils_1.default.getDocPropsProperties(zip);
+    //set auto updated elements
+    const docPropsAutoUpdatedElementsArr = Object.keys(types_1.DocPropsAutoUpdatedElements);
+    const nowTime = new Date().toISOString();
+    docPropsAutoUpdatedElementsArr.forEach((tag) => {
+        documentUtils_1.default.createOrUpdateProperty(doc, properties, types_1.DocPropsAutoUpdatedElements[tag], nowTime);
+    });
+    //set modifiable elements
+    const docPropsModifiableElementsArr = Object.keys(types_1.DocPropsModifiableElements);
+    docPropsModifiableElementsArr
+        .map((key) => ({
+        name: types_1.DocPropsModifiableElements[key],
+        value: docProps[key],
+    }))
+        .forEach((kvp) => {
+        documentUtils_1.default.createOrUpdateProperty(doc, properties, kvp.name, kvp.value);
+    });
+    const serializer = new XMLSerializer();
+    const newDoc = serializer.serializeToString(doc);
+    zip.file(constants_1.docPropsCoreXmlPath, newDoc);
+});
+const updateConnections = (connectionsXmlString, queryName, refreshOnOpen) => {
+    var _a, _b, _c;
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const refreshOnLoadValue = refreshOnOpen ? constants_1.trueValue : constants_1.falseValue;
+    const connectionsDoc = parser.parseFromString(connectionsXmlString, constants_1.xmlTextResultType);
+    const connectionsProperties = connectionsDoc.getElementsByTagName(constants_1.element.databaseProperties);
+    const dbPr = connectionsProperties[0];
+    dbPr.setAttribute(constants_1.elementAttributes.refreshOnLoad, refreshOnLoadValue);
+    // Update query details to match queryName
+    (_a = dbPr.parentElement) === null || _a === void 0 ? void 0 : _a.setAttribute(constants_1.elementAttributes.name, constants_1.elementAttributesValues.connectionName(queryName));
+    (_b = dbPr.parentElement) === null || _b === void 0 ? void 0 : _b.setAttribute(constants_1.elementAttributes.description, constants_1.elementAttributesValues.connectionDescription(queryName));
+    dbPr.setAttribute(constants_1.elementAttributes.connection, constants_1.elementAttributesValues.connection(queryName));
+    dbPr.setAttribute(constants_1.elementAttributes.command, constants_1.elementAttributesValues.connectionCommand(queryName));
+    const connectionId = (_c = dbPr.parentElement) === null || _c === void 0 ? void 0 : _c.getAttribute(constants_1.elementAttributes.id);
+    const connectionXmlFileString = serializer.serializeToString(connectionsDoc);
+    if (connectionId === null) {
+        throw new Error(constants_1.connectionsNotFoundErr);
+    }
+    return { connectionId, connectionXmlFileString };
+};
+const updateSharedStrings = (sharedStringsXmlString, queryName) => {
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const sharedStringsDoc = parser.parseFromString(sharedStringsXmlString, constants_1.xmlTextResultType);
+    const sharedStringsTable = sharedStringsDoc.getElementsByTagName(constants_1.element.sharedStringTable)[0];
+    if (!sharedStringsTable) {
+        throw new Error(constants_1.sharedStringsNotFoundErr);
+    }
+    const textElementCollection = sharedStringsDoc.getElementsByTagName(constants_1.element.text);
+    let textElement = null;
+    let sharedStringIndex = textElementCollection.length;
+    if (textElementCollection && textElementCollection.length) {
+        for (let i = 0; i < textElementCollection.length; i++) {
+            if (textElementCollection[i].innerHTML === queryName) {
+                textElement = textElementCollection[i];
+                sharedStringIndex = i + 1;
+                break;
+            }
+        }
+    }
+    if (textElement === null) {
+        if (sharedStringsDoc.documentElement.namespaceURI) {
+            textElement = sharedStringsDoc.createElementNS(sharedStringsDoc.documentElement.namespaceURI, constants_1.element.text);
+            textElement.textContent = queryName;
+            const siElement = sharedStringsDoc.createElementNS(sharedStringsDoc.documentElement.namespaceURI, constants_1.element.sharedStringItem);
+            siElement.appendChild(textElement);
+            sharedStringsDoc.getElementsByTagName(constants_1.element.sharedStringTable)[0].appendChild(siElement);
+        }
+        const value = sharedStringsTable.getAttribute(constants_1.elementAttributes.count);
+        if (value) {
+            sharedStringsTable.setAttribute(constants_1.elementAttributes.count, (parseInt(value) + 1).toString());
+        }
+        const uniqueValue = sharedStringsTable.getAttribute(constants_1.elementAttributes.uniqueCount);
+        if (uniqueValue) {
+            sharedStringsTable.setAttribute(constants_1.elementAttributes.uniqueCount, (parseInt(uniqueValue) + 1).toString());
+        }
+    }
+    const newSharedStrings = serializer.serializeToString(sharedStringsDoc);
+    return { sharedStringIndex, newSharedStrings };
+};
+const updateWorksheet = (sheetsXmlString, sharedStringIndex) => {
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const sheetsDoc = parser.parseFromString(sheetsXmlString, constants_1.xmlTextResultType);
+    sheetsDoc.getElementsByTagName(constants_1.element.cellValue)[0].innerHTML = sharedStringIndex.toString();
+    const newSheet = serializer.serializeToString(sheetsDoc);
+    return newSheet;
+};
+const updatePivotTablesandQueryTables = (zip, queryName, refreshOnOpen, connectionId) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    // Find Query Table
+    let found = false;
+    const queryTablePromises = [];
+    (_a = zip.folder(constants_1.queryTablesPath)) === null || _a === void 0 ? void 0 : _a.forEach((relativePath, queryTableFile) => __awaiter(void 0, void 0, void 0, function* () {
+        queryTablePromises.push((() => {
+            return queryTableFile.async(constants_1.textResultType).then((queryTableString) => {
+                return {
+                    path: relativePath,
+                    queryTableXmlString: queryTableString,
+                };
+            });
+        })());
+    }));
+    (yield Promise.all(queryTablePromises)).forEach(({ path, queryTableXmlString }) => {
+        const { isQueryTableUpdated, newQueryTable } = updateQueryTable(queryTableXmlString, connectionId, refreshOnOpen);
+        zip.file(constants_1.queryTablesPath + path, newQueryTable);
+        if (isQueryTableUpdated) {
+            found = true;
+        }
+    });
+    if (found) {
+        return;
+    }
+    // Find Pivot Table
+    const pivotCachePromises = [];
+    (_b = zip.folder(constants_1.pivotCachesPath)) === null || _b === void 0 ? void 0 : _b.forEach((relativePath, pivotCacheFile) => __awaiter(void 0, void 0, void 0, function* () {
+        if (relativePath.startsWith(constants_1.pivotCachesPathPrefix)) {
+            pivotCachePromises.push((() => {
+                return pivotCacheFile.async(constants_1.textResultType).then((pivotCacheString) => {
+                    return {
+                        path: relativePath,
+                        pivotCacheXmlString: pivotCacheString,
+                    };
+                });
+            })());
+        }
+    }));
+    (yield Promise.all(pivotCachePromises)).forEach(({ path, pivotCacheXmlString }) => {
+        const { isPivotTableUpdated, newPivotTable } = updatePivotTable(pivotCacheXmlString, connectionId, refreshOnOpen);
+        zip.file(constants_1.pivotCachesPath + path, newPivotTable);
+        if (isPivotTableUpdated) {
+            found = true;
+        }
+    });
+    if (!found) {
+        throw new Error(constants_1.queryAndPivotTableNotFoundErr);
+    }
+});
+const updateQueryTable = (tableXmlString, connectionId, refreshOnOpen) => {
+    const refreshOnLoadValue = refreshOnOpen ? constants_1.trueValue : constants_1.falseValue;
+    let isQueryTableUpdated = false;
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const queryTableDoc = parser.parseFromString(tableXmlString, constants_1.xmlTextResultType);
+    const queryTable = queryTableDoc.getElementsByTagName(constants_1.element.queryTable)[0];
+    let newQueryTable = constants_1.emptyValue;
+    if (queryTable.getAttribute(constants_1.elementAttributes.connectionId) == connectionId) {
+        queryTable.setAttribute(constants_1.elementAttributes.refreshOnLoad, refreshOnLoadValue);
+        newQueryTable = serializer.serializeToString(queryTableDoc);
+        isQueryTableUpdated = true;
+    }
+    return { isQueryTableUpdated, newQueryTable };
+};
+const updatePivotTable = (tableXmlString, connectionId, refreshOnOpen) => {
+    const refreshOnLoadValue = refreshOnOpen ? constants_1.trueValue : constants_1.falseValue;
+    let isPivotTableUpdated = false;
+    const parser = new DOMParser();
+    const serializer = new XMLSerializer();
+    const pivotCacheDoc = parser.parseFromString(tableXmlString, constants_1.xmlTextResultType);
+    let cacheSource = pivotCacheDoc.getElementsByTagName(constants_1.element.cacheSource)[0];
+    let newPivotTable = constants_1.emptyValue;
+    if (cacheSource.getAttribute(constants_1.elementAttributes.connectionId) == connectionId) {
+        cacheSource = cacheSource.parentElement;
+        cacheSource.setAttribute(constants_1.elementAttributes.refreshOnLoad, refreshOnLoadValue);
+        newPivotTable = serializer.serializeToString(pivotCacheDoc);
+        isPivotTableUpdated = true;
+    }
+    return { isPivotTableUpdated, newPivotTable };
+};
+exports.default = {
+    updateDocProps,
+    updateConnections,
+    updateSharedStrings,
+    updateWorksheet,
+    updatePivotTablesandQueryTables,
+    updateQueryTable,
+    updatePivotTable,
+};

package/dist/src/utils/xmlPartsUtils.js

@@ -0,0 +1,64 @@
+"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 constants_1 = require("./constants");
+const mashupDocumentParser_1 = require("./mashupDocumentParser");
+const pqUtils_1 = __importDefault(require("./pqUtils"));
+const xmlInnerPartsUtils_1 = __importDefault(require("./xmlInnerPartsUtils"));
+const tableUtils_1 = __importDefault(require("./tableUtils"));
+const updateWorkbookInitialDataIfNeeded = (zip, docProps, tableData, updateQueryTable = false) => __awaiter(void 0, void 0, void 0, function* () {
+    yield xmlInnerPartsUtils_1.default.updateDocProps(zip, docProps);
+    yield tableUtils_1.default.updateTableInitialDataIfNeeded(zip, tableData, updateQueryTable);
+});
+const updateWorkbookPowerQueryDocument = (zip, queryName, queryMashupDoc) => __awaiter(void 0, void 0, void 0, function* () {
+    const old_base64 = yield pqUtils_1.default.getBase64(zip);
+    if (!old_base64) {
+        throw new Error(constants_1.base64NotFoundErr);
+    }
+    const new_base64 = yield (0, mashupDocumentParser_1.replaceSingleQuery)(old_base64, queryName, queryMashupDoc);
+    yield pqUtils_1.default.setBase64(zip, new_base64);
+});
+const updateWorkbookSingleQueryAttributes = (zip, queryName, refreshOnOpen) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    // Update connections
+    const connectionsXmlString = yield ((_a = zip.file(constants_1.connectionsXmlPath)) === null || _a === void 0 ? void 0 : _a.async(constants_1.textResultType));
+    if (connectionsXmlString === undefined) {
+        throw new Error(constants_1.connectionsNotFoundErr);
+    }
+    const { connectionId, connectionXmlFileString } = xmlInnerPartsUtils_1.default.updateConnections(connectionsXmlString, queryName, refreshOnOpen);
+    zip.file(constants_1.connectionsXmlPath, connectionXmlFileString);
+    // Update sharedStrings
+    const sharedStringsXmlString = yield ((_b = zip.file(constants_1.sharedStringsXmlPath)) === null || _b === void 0 ? void 0 : _b.async(constants_1.textResultType));
+    if (sharedStringsXmlString === undefined) {
+        throw new Error(constants_1.sharedStringsNotFoundErr);
+    }
+    const { sharedStringIndex, newSharedStrings } = xmlInnerPartsUtils_1.default.updateSharedStrings(sharedStringsXmlString, queryName);
+    zip.file(constants_1.sharedStringsXmlPath, newSharedStrings);
+    // Update sheet
+    const sheetsXmlString = yield ((_c = zip.file(constants_1.sheetsXmlPath)) === null || _c === void 0 ? void 0 : _c.async(constants_1.textResultType));
+    if (sheetsXmlString === undefined) {
+        throw new Error(constants_1.sheetsNotFoundErr);
+    }
+    const worksheetString = xmlInnerPartsUtils_1.default.updateWorksheet(sheetsXmlString, sharedStringIndex.toString());
+    zip.file(constants_1.sheetsXmlPath, worksheetString);
+    // Update tables
+    yield xmlInnerPartsUtils_1.default.updatePivotTablesandQueryTables(zip, queryName, refreshOnOpen, connectionId);
+});
+exports.default = {
+    updateWorkbookInitialDataIfNeeded,
+    updateWorkbookPowerQueryDocument,
+    updateWorkbookSingleQueryAttributes,
+};