@microsoft/connected-workbooks 1.0.0 → 2.1.24-beta

package/dist/utils/documentUtils.js

@@ -0,0 +1,98 @@
+"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, 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(data, cell, cellData);
+    cell.appendChild(cellData);
+    return cell;
+};
+const updateCellData = (data, cell, cellData) => {
+    switch (resolveType(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 = (originalData) => {
+    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.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTableValues = void 0;
+const extractTableValues = (table) => {
+    const headers = [];
+    const rows = [];
+    // Extract values from each row
+    for (let i = 0; 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 rows;
+};
+exports.extractTableValues = extractTableValues;

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.js

@@ -0,0 +1,163 @@
+"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.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 } = getPackageComponents(base64Str);
+    const newPackageBuffer = yield editSingleQueryPackage(packageOPC, queryMashupDoc);
+    const packageSizeBuffer = _1.arrayUtils.getInt32Buffer(newPackageBuffer.byteLength);
+    const permissionsSizeBuffer = _1.arrayUtils.getInt32Buffer(permissionsSize);
+    const newMetadataBuffer = 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,
+    };
+};
+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) => {
+    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;
+};

package/dist/utils/pqUtils.js

@@ -0,0 +1,97 @@
+"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 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.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.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.QueryNameMaxLengthErr);
+        }
+    }
+    if (!queryName.trim()) {
+        throw new Error(constants_1.EmptyQueryNameErr);
+    }
+};
+exports.default = {
+    getBase64,
+    setBase64,
+    getCustomXmlFile,
+    getDataMashupFile,
+    validateQueryName,
+};

package/dist/utils/tableUtils.js

@@ -0,0 +1,144 @@
+"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 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.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) => __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];
+    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) => __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.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) => __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.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,
+};