@microsoft/connected-workbooks 2.1.24-beta → 3.0.0

package/dist/src/utils/gridUtils.js

@@ -0,0 +1,103 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../utils/constants");
+const parseToTableData = (grid) => {
+    var _a, _b, _c, _d;
+    if (grid === null || grid === undefined) {
+        grid = { data: [] };
+    }
+    if (grid.data === null || grid.data === undefined) {
+        grid.data = [];
+    }
+    const mergedGrid = {
+        config: {
+            promoteHeaders: (_b = (_a = grid.config) === null || _a === void 0 ? void 0 : _a.promoteHeaders) !== null && _b !== void 0 ? _b : false,
+            adjustColumnNames: (_d = (_c = grid.config) === null || _c === void 0 ? void 0 : _c.adjustColumnNames) !== null && _d !== void 0 ? _d : true,
+        },
+        data: grid.data.map((row) => row.map((value) => { var _a; return (_a = value === null || value === void 0 ? void 0 : value.toString()) !== null && _a !== void 0 ? _a : ""; })),
+    };
+    correctGrid(mergedGrid);
+    validateGrid(mergedGrid);
+    let columnNames = [];
+    if (mergedGrid.config.promoteHeaders && mergedGrid.config.adjustColumnNames) {
+        columnNames = getAdjustedColumnNames(mergedGrid.data.shift());
+    }
+    else if (mergedGrid.config.promoteHeaders && !mergedGrid.config.adjustColumnNames) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        columnNames = mergedGrid.data.shift();
+    }
+    else {
+        columnNames = Array.from({ length: mergedGrid.data[0].length }, (_, index) => `${constants_1.defaults.columnName} ${index + 1}`);
+    }
+    return { columnNames: columnNames, rows: mergedGrid.data };
+};
+const correctGrid = (grid) => {
+    if (grid.data.length === 0) {
+        // empty grid fix
+        grid.config.promoteHeaders = false;
+        grid.data.push([""]);
+        return;
+    }
+    const getEmptyArray = (n) => Array.from({ length: n }, () => "");
+    if (grid.data[0].length === 0) {
+        grid.data[0] = [""];
+    }
+    // replace empty rows
+    grid.data.forEach((row, index) => {
+        if (row.length === 0) {
+            grid.data[index] = getEmptyArray(grid.data[0].length);
+        }
+    });
+    if (grid.config.promoteHeaders && grid.data.length === 1) {
+        // table in Excel should have at least 2 rows
+        grid.data.push(getEmptyArray(grid.data[0].length));
+    }
+};
+/*
+ * Validates the grid, throws an error if the grid is invalid.
+ * A valid grid has:
+ * - MxN structure.
+ * - If promoteHeaders is true - has at least 1 row, and in case adjustColumnNames is false, first row is unique and non empty.
+ */
+const validateGrid = (grid) => {
+    validateDataArrayDimensions(grid.data);
+    if (grid.config.promoteHeaders && grid.config.adjustColumnNames === false && !validateUniqueAndValidDataArray(grid.data[0])) {
+        throw new Error(constants_1.promotedHeadersCannotBeUsedWithoutAdjustingColumnNamesErr);
+    }
+};
+const validateDataArrayDimensions = (arr) => {
+    if (arr.length === 0 || arr[0].length === 0) {
+        throw new Error(constants_1.unexpectedErr);
+    }
+    if (!arr.every((innerArr) => innerArr.length === arr[0].length)) {
+        throw new Error(constants_1.arrayIsntMxNErr);
+    }
+};
+const validateUniqueAndValidDataArray = (arr) => {
+    if (arr.some((element) => element === "")) {
+        return false; // Array contains empty elements
+    }
+    const uniqueSet = new Set(arr);
+    return uniqueSet.size === arr.length;
+};
+const getAdjustedColumnNames = (columnNames) => {
+    if (columnNames === undefined) {
+        throw new Error(constants_1.unexpectedErr);
+    }
+    let i = 1;
+    // replace empty column names with default names, can still conflict if columns exist, but we handle that later
+    columnNames = columnNames.map((columnName) => columnName || `${constants_1.defaults.columnName} ${i++}`);
+    const uniqueNames = new Set();
+    return columnNames.map((name) => {
+        let uniqueName = name;
+        i = 1;
+        while (uniqueNames.has(uniqueName)) {
+            uniqueName = `${name} (${i++})`;
+        }
+        uniqueNames.add(uniqueName);
+        return uniqueName;
+    });
+};
+exports.default = { parseToTableData };

package/dist/src/utils/htmlUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+const extractTableValues = (table) => {
+    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.default = { extractTableValues };

package/dist/src/utils/index.js

@@ -0,0 +1,24 @@
+"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.gridUtils = exports.htmlUtils = 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; } });
+var htmlUtils_1 = require("./htmlUtils");
+Object.defineProperty(exports, "htmlUtils", { enumerable: true, get: function () { return __importDefault(htmlUtils_1).default; } });
+var gridUtils_1 = require("./gridUtils");
+Object.defineProperty(exports, "gridUtils", { enumerable: true, get: function () { return __importDefault(gridUtils_1).default; } });

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++;
+    });
+    const reference = documentUtils_1.default.getTableReference(tableData.rows[0].length - 1, tableData.rows.length + 1);
+    sheetsDoc.getElementsByTagName(constants_1.element.dimension)[0].setAttribute(constants_1.elementAttributes.reference, reference);
+    sheetsDoc.getElementsByTagName(constants_1.element.selection)[0].setAttribute(constants_1.elementAttributes.sqref, reference);
+    return serializer.serializeToString(sheetsDoc);
+};
+exports.default = {
+    updateTableInitialDataIfNeeded,
+    updateSheetsInitialData,
+    updateWorkbookInitialData,
+    updateTablesInitialData,
+    updateQueryTablesInitialData,
+};