@microsoft/connected-workbooks 1.0.0 → 2.1.16-beta

package/dist/utils/xmlInnerPartsUtils.js

@@ -0,0 +1,198 @@
+"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 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) => __awaiter(void 0, void 0, void 0, function* () {
+    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) => __awaiter(void 0, void 0, void 0, function* () {
+    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) => __awaiter(void 0, void 0, void 0, function* () {
+    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 _d, _e;
+    // Find Query Table
+    let found = false;
+    const queryTablePromises = [];
+    (_d = zip.folder(constants_1.queryTablesPath)) === null || _d === void 0 ? void 0 : _d.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 = [];
+    (_e = zip.folder(constants_1.pivotCachesPath)) === null || _e === void 0 ? void 0 : _e.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/utils/xmlPartsUtils.d.ts

@@ -0,0 +1,8 @@
+import JSZip from "jszip";
+import { DocProps, TableData } from "../types";
+declare const _default: {
+    updateWorkbookInitialDataIfNeeded: (zip: JSZip, docProps?: DocProps | undefined, tableData?: TableData | undefined, updateQueryTable?: boolean) => Promise<void>;
+    updateWorkbookPowerQueryDocument: (zip: JSZip, queryName: string, queryMashupDoc: string) => Promise<void>;
+    updateWorkbookSingleQueryAttributes: (zip: JSZip, queryName: string, refreshOnOpen: boolean) => Promise<void>;
+};
+export default _default;

package/dist/utils/xmlPartsUtils.js

@@ -0,0 +1,62 @@
+"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 constants_1 = require("./constants");
+const mashupDocumentParser_1 = __importDefault(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 new mashupDocumentParser_1.default().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 } = yield 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 } = yield 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 = yield 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,
+};

package/dist/workbookManager.d.ts

@@ -1,13 +1,8 @@
-export declare class QueryInfo {
-    queryMashup: string;
-    refreshOnOpen: boolean;
-    constructor(queryMashup: string, refreshOnOpen: boolean);
-}
-export declare class WorkbookManager {
-    private mashupHandler;
-    generateSingleQueryWorkbook(query: QueryInfo, templateFile?: File): Promise<Blob>;
-    private generateSingleQueryWorkbookFromZip;
-    private setSingleQueryRefreshOnOpen;
-    private setBase64;
-    private getBase64;
-}
+import { DocProps, QueryInfo, Grid } from "./types";
+declare const _default: {
+    generateSingleQueryWorkbook: (query: QueryInfo, initialDataGrid?: Grid | undefined, templateFile?: File | undefined, docProps?: DocProps | undefined) => Promise<Blob>;
+    generateTableWorkbookFromHtml: (htmlTable: HTMLTableElement, docProps?: DocProps | undefined) => Promise<Blob>;
+    generateTableWorkbookFromGrid: (initialDataGrid: Grid, docProps?: DocProps | undefined) => Promise<Blob>;
+    downloadWorkbook: (file: Blob, filename: string) => void;
+};
+export default _default;

package/dist/workbookManager.js

@@ -14,145 +14,90 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkbookManager = exports.QueryInfo = void 0;
 const jszip_1 = __importDefault(require("jszip"));
-const iconv_lite_1 = __importDefault(require("iconv-lite"));
-const mashupDocumentParser_1 = __importDefault(require("./mashupDocumentParser"));
+const utils_1 = require("./utils");
 const workbookTemplate_1 = __importDefault(require("./workbookTemplate"));
-const pqCustomXmlPath = "customXml/item1.xml";
-const connectionsXmlPath = "xl/connections.xml";
-const queryTablesPath = "xl/queryTables/";
-const pivotCachesPath = "xl/pivotCache/";
-class QueryInfo {
-    constructor(queryMashup, refreshOnOpen) {
-        this.queryMashup = queryMashup;
-        this.refreshOnOpen = refreshOnOpen;
+const constants_1 = require("./utils/constants");
+const types_1 = require("./types");
+const TableDataParserFactory_1 = __importDefault(require("./TableDataParserFactory"));
+const generators_1 = require("./generators");
+const htmlUtils_1 = require("./utils/htmlUtils");
+const generateSingleQueryWorkbook = (query, initialDataGrid, templateFile, docProps) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!query.queryMashup) {
+        throw new Error(constants_1.emptyQueryMashupErr);
     }
-}
-exports.QueryInfo = QueryInfo;
-class WorkbookManager {
-    constructor() {
-        this.mashupHandler = new mashupDocumentParser_1.default();
+    if (!query.queryName) {
+        query.queryName = constants_1.defaults.queryName;
     }
-    generateSingleQueryWorkbook(query, templateFile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let zip = templateFile === undefined
-                ? yield jszip_1.default.loadAsync(workbookTemplate_1.default.SIMPLE_QUERY_WORKBOOK_TEMPLATE, { base64: true })
-                : yield jszip_1.default.loadAsync(templateFile);
-            return yield this.generateSingleQueryWorkbookFromZip(zip, query);
-        });
+    if (templateFile !== undefined && initialDataGrid !== undefined) {
+        throw new Error(constants_1.templateWithInitialDataErr);
     }
-    generateSingleQueryWorkbookFromZip(zip, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let old_base64 = yield this.getBase64(zip);
-            let new_base64 = yield this.mashupHandler.ReplaceSingleQuery(old_base64, query.queryMashup);
-            yield this.setBase64(zip, new_base64);
-            if (query.refreshOnOpen) {
-                yield this.setSingleQueryRefreshOnOpen(zip);
-            }
-            return yield zip.generateAsync({
-                type: "blob",
-                mimeType: "application/xlsx",
-            });
-        });
+    utils_1.pqUtils.validateQueryName(query.queryName);
+    const zip = templateFile === undefined
+        ? yield jszip_1.default.loadAsync(workbookTemplate_1.default.SIMPLE_QUERY_WORKBOOK_TEMPLATE, { base64: true })
+        : yield jszip_1.default.loadAsync(templateFile);
+    const tableData = yield parseInitialDataGrid(initialDataGrid);
+    return yield generateSingleQueryWorkbookFromZip(zip, query, docProps, tableData);
+});
+const generateTableWorkbookFromHtml = (htmlTable, docProps) => __awaiter(void 0, void 0, void 0, function* () {
+    const [headers, gridData] = htmlUtils_1.extractTableValues(htmlTable);
+    const header = headers.map((column) => ({ name: column, type: types_1.DataTypes.autodetect }));
+    return yield generateTableWorkbookFromGrid({ gridData, header }, docProps);
+});
+const generateTableWorkbookFromGrid = (initialDataGrid, docProps) => __awaiter(void 0, void 0, void 0, function* () {
+    const zip = yield jszip_1.default.loadAsync(workbookTemplate_1.default.SIMPLE_BLANK_TABLE_TEMPLATE, { base64: true });
+    const tableData = yield parseInitialDataGrid(initialDataGrid);
+    if (tableData === undefined) {
+        throw new Error(constants_1.tableNotFoundErr);
     }
-    setSingleQueryRefreshOnOpen(zip) {
-        var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function* () {
-            let connectionsXmlString = yield ((_a = zip.file(connectionsXmlPath)) === null || _a === void 0 ? void 0 : _a.async("text"));
-            if (connectionsXmlString === undefined) {
-                throw new Error("Connections were not found in template");
-            }
-            let parser = new DOMParser();
-            let serializer = new XMLSerializer();
-            let connectionsDoc = parser.parseFromString(connectionsXmlString, "text/xml");
-            let connectionId = "-1";
-            let connectionsProperties = connectionsDoc.getElementsByTagName("dbPr");
-            for (let properties of connectionsProperties) {
-                if (properties.getAttribute("command") == "SELECT * FROM [Query1]") {
-                    (_b = properties.parentElement) === null || _b === void 0 ? void 0 : _b.setAttribute("refreshOnLoad", "1");
-                    connectionId = (_c = properties.parentElement) === null || _c === void 0 ? void 0 : _c.getAttribute("id");
-                    let newConn = serializer.serializeToString(connectionsDoc);
-                    zip.file(connectionsXmlPath, newConn);
-                    break;
-                }
-            }
-            if (connectionId == "-1") {
-                throw new Error("No connection found for Query1");
-            }
-            let found = false;
-            // Find Query Table
-            let queryTablePromises = [];
-            (_d = zip.folder(queryTablesPath)) === null || _d === void 0 ? void 0 : _d.forEach((relativePath, queryTableFile) => __awaiter(this, void 0, void 0, function* () {
-                queryTablePromises.push((() => {
-                    return queryTableFile.async("text").then(queryTableString => {
-                        return { path: relativePath, queryTableXmlString: queryTableString };
-                    });
-                })());
-            }));
-            (yield Promise.all(queryTablePromises)).forEach(({ path, queryTableXmlString }) => {
-                let queryTableDoc = parser.parseFromString(queryTableXmlString, "text/xml");
-                let element = queryTableDoc.getElementsByTagName("queryTable")[0];
-                if (element.getAttribute("connectionId") == connectionId) {
-                    element.setAttribute("refreshOnLoad", "1");
-                    let newQT = serializer.serializeToString(queryTableDoc);
-                    zip.file(queryTablesPath + path, newQT);
-                    found = true;
-                }
-            });
-            if (found) {
-                return;
-            }
-            // Find Query Table
-            let pivotCachePromises = [];
-            (_e = zip.folder(pivotCachesPath)) === null || _e === void 0 ? void 0 : _e.forEach((relativePath, pivotCacheFile) => __awaiter(this, void 0, void 0, function* () {
-                if (relativePath.startsWith("pivotCacheDefinition")) {
-                    pivotCachePromises.push((() => {
-                        return pivotCacheFile.async("text").then(pivotCacheString => {
-                            return { path: relativePath, pivotCacheXmlString: pivotCacheString };
-                        });
-                    })());
-                }
-            }));
-            (yield Promise.all(pivotCachePromises)).forEach(({ path, pivotCacheXmlString }) => {
-                let pivotCacheDoc = parser.parseFromString(pivotCacheXmlString, "text/xml");
-                let element = pivotCacheDoc.getElementsByTagName("cacheSource")[0];
-                if (element.getAttribute("connectionId") == connectionId) {
-                    element.parentElement.setAttribute("refreshOnLoad", "1");
-                    let newPC = serializer.serializeToString(pivotCacheDoc);
-                    zip.file(pivotCachesPath + path, newPC);
-                    found = true;
-                }
-            });
-            if (!found) {
-                throw new Error("No Query Table or Pivot Table found for Query1 in given template.");
-            }
-        });
+    yield utils_1.xmlPartsUtils.updateWorkbookInitialDataIfNeeded(zip, docProps, tableData);
+    return yield zip.generateAsync({
+        type: constants_1.blobFileType,
+        mimeType: constants_1.application,
+    });
+});
+const parseInitialDataGrid = (initialDataGrid) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!initialDataGrid) {
+        return undefined;
     }
-    setBase64(zip, base64) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let newXml = `<?xml version="1.0" encoding="utf-16"?><DataMashup xmlns="http://schemas.microsoft.com/DataMashup">${base64}</DataMashup>`;
-            let encoded = iconv_lite_1.default.encode(newXml, "UCS2", { addBOM: true });
-            zip.file(pqCustomXmlPath, encoded);
-        });
+    const parser = TableDataParserFactory_1.default.createParser(initialDataGrid);
+    const tableData = parser.parseToTableData(initialDataGrid);
+    return tableData;
+});
+const generateSingleQueryWorkbookFromZip = (zip, query, docProps, tableData) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!query.queryName) {
+        query.queryName = constants_1.defaults.queryName;
     }
-    getBase64(zip) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let xmlValue = yield ((_a = zip.file(pqCustomXmlPath)) === null || _a === void 0 ? void 0 : _a.async("uint8array"));
-            if (xmlValue === undefined) {
-                throw new Error("PQ document wasn't found in zip");
-            }
-            let xmlString = iconv_lite_1.default.decode(xmlValue.buffer, "UTF-16");
-            let parser = new DOMParser();
-            let doc = parser.parseFromString(xmlString, "text/xml");
-            let result = doc.childNodes[0].textContent;
-            if (result === null) {
-                throw Error("Base64 wasn't found in zip");
-            }
-            return result;
-        });
+    yield utils_1.xmlPartsUtils.updateWorkbookPowerQueryDocument(zip, query.queryName, generators_1.generateSingleQueryMashup(query.queryName, query.queryMashup));
+    yield utils_1.xmlPartsUtils.updateWorkbookSingleQueryAttributes(zip, query.queryName, query.refreshOnOpen);
+    yield utils_1.xmlPartsUtils.updateWorkbookInitialDataIfNeeded(zip, docProps, tableData, true /*updateQueryTable*/);
+    return yield zip.generateAsync({
+        type: constants_1.blobFileType,
+        mimeType: constants_1.application,
+    });
+});
+const downloadWorkbook = (file, filename) => {
+    const nav = window.navigator;
+    if (nav.msSaveOrOpenBlob)
+        // IE10+
+        nav.msSaveOrOpenBlob(file, filename);
+    else {
+        // Others
+        const a = document.createElement("a");
+        const url = URL.createObjectURL(file);
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        setTimeout(function () {
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+        }, 0);
     }
-}
-exports.WorkbookManager = WorkbookManager;
-//# sourceMappingURL=workbookManager.js.map
+};
+exports.default = {
+    generateSingleQueryWorkbook,
+    generateTableWorkbookFromHtml,
+    generateTableWorkbookFromGrid,
+    downloadWorkbook,
+};