vita-playwright 1.0.0

package/src/utils/azure_storage_methods.ts

@@ -0,0 +1,91 @@
+var DOMParser = require('xmldom').DOMParser;
+import { XmlToJson } from './xmlToJson';
+var CryptoJS = require('crypto-js');
+import { TokenGenerators } from './api_axios'
+
+export class AzureStorageMethods {
+
+    static async getblobs(storageAccount: any, containerName: any, storageAccountKey: any, apiMethodName: string, blobFilterName = "") {
+        var header_date = new Date().toUTCString();
+        var apiMethod = apiMethodName.toUpperCase();
+
+        var url = new URL(`https://${storageAccount}.blob.core.windows.net/${containerName}?restype=container&comp=list&prefix=${blobFilterName}`);
+        const signatureParts = [apiMethod, "", "", "", "", "", "", "", "", "", "", ""]
+
+
+        const canonicalHeaderParts = [];
+        canonicalHeaderParts.push(`x-ms-date:${header_date}`);
+        canonicalHeaderParts.push(`x-ms-version:2018-03-28`);
+
+
+        // Add headers to signature
+        signatureParts.push.apply(signatureParts, canonicalHeaderParts);
+
+        // Construct CanonicalizedResource
+        const canonicalResourceParts = [`/${storageAccount}${url.pathname}`];
+        const canonicalQueryNames: string[] = [];
+        url.searchParams.forEach(function (value, key) {
+            canonicalQueryNames.push(key.toLowerCase());
+        });
+        canonicalQueryNames.sort();
+        canonicalQueryNames.forEach(queryName => {
+            const value = url.searchParams.get(queryName);
+
+            canonicalResourceParts.push(`${queryName}:${value}`);
+        });
+        // Add resource to signature
+        signatureParts.push.apply(signatureParts, canonicalResourceParts);
+
+        // Now, construct signature raw string
+        const signatureRaw = signatureParts.join("\n");
+
+        // Hash it using HMAC-SHA256 and then encode using base64
+
+        const signatureBytes = CryptoJS.HmacSHA256(signatureRaw, CryptoJS.enc.Base64.parse(storageAccountKey));
+        const signatureEncoded = signatureBytes.toString(CryptoJS.enc.Base64);
+
+        var config = {
+            method: apiMethod,
+            url: `https://${storageAccount}.blob.core.windows.net/${containerName}?restype=container&comp=list&prefix=${blobFilterName}`,
+            headers: {
+                "Authorization": `SharedKey ${storageAccount}:${signatureEncoded}`,
+                "x-ms-date": header_date,
+                "x-ms-version": "2018-03-28"
+            },
+        };
+
+        var response = await TokenGenerators.request(config);
+        var apiData = response.data
+        var XmlNode = new DOMParser().parseFromString(apiData, 'text/xml');
+        var jsonObj = await XmlToJson.xmlToJson(XmlNode);
+        var blobs = jsonObj.EnumerationResults.Blobs.Blob;
+        var newBlobs = [];
+        if (blobs.length) {
+            for (var i = 0; i < blobs.length; i++) {
+                var blob = {
+                    "fileName": (blobs[i].Name['#text']).replace(blobFilterName, ""),
+                    "modifiedTime": (Date.parse(blobs[i].Properties['Last-Modified']['#text'])),
+                    "status": Math.floor(Date.now() - (Date.parse(blobs[i].Properties['Last-Modified']['#text'])) / 1000) > 30 ? 1 : 0,
+                }
+                newBlobs.push(blob)
+            }
+        } else if (blobs.fileName) {
+            var blob = {
+                "fileName": (blobs.Name['#text']).replace(blobFilterName, ""),
+                "modifiedTime": (Date.parse(blobs.Properties['Last-Modified']['#text'])),
+                "status": Math.floor(Date.now() - (Date.parse(blobs.Properties['Last-Modified']['#text'])) / 1000) > 30 ? 1 : 0,
+            }
+            newBlobs.push(blob)
+        }
+
+        newBlobs.sort((a, b) => a.fileName > b.fileName ? 1 : ((b.fileName > a.fileName) ? -1 : 0))
+        newBlobs.sort((a, b) => a.modifiedTime < b.modifiedTime ? 1 : ((b.modifiedTime < a.modifiedTime) ? -1 : 0))
+
+        return newBlobs;
+    }
+
+
+
+
+
+}

package/src/utils/comparisions.ts

@@ -0,0 +1,72 @@
+import { expect } from "@playwright/test";
+import { isDeepStrictEqual } from "util";
+import _ from 'lodash';
+
+export class Comparisions {
+
+  static async compareObjects(actualObj: string, expectedObj: string) {
+    var same;
+    console.log("Actual Obj: " + actualObj + " and Expected Obj: " + expectedObj)
+    same = _.isEqual(actualObj, expectedObj);
+    console.log(same);
+    return same;
+  };
+
+  static async compareUnorderedJSONObjects(actualObj: { [x: string]: any; }, expectedObj: { [x: string]: any; }) {
+    var Keydata = Object.keys(expectedObj)
+    var result = new Array();
+    var boolean;
+    for (var i = 0; i < Keydata.length; i++) {
+      if (actualObj[Keydata[i]] == expectedObj[Keydata[i]]) {
+        result.push(true)
+      } else {
+        result.push(false)
+      }
+    }
+    boolean = result.includes(false) ? false : true;
+    return boolean;
+  }
+
+  static compareJSONObjects(receivedJson, expectedJson): Boolean {
+    let isJsonEqual = true;
+    let receivedKeys: string[] = this.getJsonKeys(receivedJson);
+    let expectedKeys = this.getJsonKeys(expectedJson);
+    let receivedValues = this.getJsonValues(receivedJson);
+    let expectedValues = this.getJsonValues(expectedJson);
+    let count: number = this.getJsonCount(receivedJson);
+
+    for (let i: number = 0; i < count; i++) {
+      let receivedKey = receivedKeys[i];
+      let expectedKey = expectedKeys[i];
+      let receivedValue = receivedValues[i];
+      let expectedValue = expectedValues[i];
+
+      let isKeyEmpty: Boolean = receivedKey == (null || "");
+      let isKeyEqual: Boolean = receivedKey == expectedKey;
+      let isValueEqual: Boolean = isDeepStrictEqual(receivedValue, expectedValue);
+      expect.soft(!isKeyEmpty, "Actual Key received is not null.");
+      expect.soft(isKeyEqual, "Actual key received is: '" + receivedKey + "' and expected key is: '" + expectedKey + "'.").toBeTruthy();
+      expect.soft(isValueEqual, "Actual value received for '" + expectedKey + "' is " + JSON.stringify(receivedValue) + " and \nExpected value is: " + JSON.stringify(expectedValue) + ".").toBeTruthy();
+
+      if (isKeyEmpty || !isKeyEqual || !isValueEqual) {
+        isJsonEqual = false;
+      }
+    }
+    return isJsonEqual;
+  }
+
+  //Get Keys from Json Files
+  static getJsonKeys(jsonFile) {
+    return Object.keys(jsonFile);
+  }
+
+  //Get Values From Json Files
+  static getJsonValues(jsonFile) {
+    return Object.values(jsonFile);
+  }
+
+  //Get Count of Json items
+  static getJsonCount(jsonFile) {
+    return Object.keys(jsonFile).length;
+  }
+}

package/src/utils/document_utility.ts

@@ -0,0 +1,49 @@
+import XLSX from 'xlsx';
+import _ from 'lodash';
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export class DocumentUtility {
+
+    static async readData(filePath: string) {
+        return XLSX.readFile(filePath, { cellDates: true, bookVBA: true, sheetStubs: true, cellNF: true });
+    }
+
+    static async readDataFromExcelorCSV(filePath: string, sheetname?: string) {
+        const workbook = await DocumentUtility.readData(filePath);
+        const sheet_name_list = workbook.SheetNames;
+        sheetname = (sheetname === undefined ? sheet_name_list[0] : sheetname);
+        return XLSX.utils.sheet_to_json(workbook.Sheets[sheet_name_list[0]]);
+
+        // const tempTwoDimentionalArr = new Array(_.keys(excelData[0]).length);
+        // for (var i = 0; i < tempTwoDimentionalArr.length; i++) {
+        //     tempTwoDimentionalArr[i] = new Array();
+        // }
+        // return _.map(excelData, function (obj) {
+        //     return _.reduce(_.keys(excelData[0]), function (result, columnName, index) {
+        //         tempTwoDimentionalArr[index].push(obj[columnName])
+        //         result[columnName] = tempTwoDimentionalArr[index];
+        //         return result;
+        //     }, {})
+        // })[0];
+    }
+
+    static async filterData(filePath: string, sheetName: string, filterObject: object) {
+        let fileData = await DocumentUtility.readData(filePath);
+        return _.filter(XLSX.utils.sheet_to_json(fileData.Sheets[sheetName]), filterObject)
+    }
+
+    static async updateExcelData(filePath: string, sheetName: string, exportData: Array<object>) {
+        const workbook = await DocumentUtility.readData(filePath);
+        workbook.Sheets[sheetName] = XLSX.utils.json_to_sheet(exportData);
+        XLSX.writeFile(workbook, filePath);
+    }
+
+    static async deleteAllFilesUnderDIr(dirPath: string) {
+        for (const file of await fs.readdir(dirPath)) {
+            await fs.unlink(path.join(dirPath, file));
+        }
+    }
+
+
+}

package/src/utils/keyvault_methods.ts

@@ -0,0 +1,17 @@
+import { TokenGenerators } from './api_axios'
+
+export class KeyVaultMethods {
+
+    static async getSecrets(secretName: any) {
+        var keyvault = `${process.env.subscription}conm${process.env.env}${process.env.locationshortcut}securekv`
+        var token = await TokenGenerators.generateKeyVaultAccessToken();
+        var config = {
+            method: 'get',
+            url: `https://${keyvault}.vault.azure.net/secrets/${secretName}?api-version=2016-10-01`,
+            headers: { "Authorization": `Bearer ${token}` }
+        };
+        var response = await TokenGenerators.request(config);
+        return response.data;
+
+    }
+}

package/src/utils/test_data.ts

@@ -0,0 +1,263 @@
+//const cosmosClient = require("@azure/cosmos").CosmosClient;
+const sql = require('mssql');
+import { AnyNaptrRecord } from "dns";
+import fsr from "fs";
+import path from "node:path";
+import XLSX from "xlsx";
+
+export class TestData {
+
+    static async sqlDBConnection() {
+        var server = process.env.subscription + "-conm-" + process.env.env + "-" + process.env.locationshortcut + "-sqlserver-dbs.database.windows.net"
+        var database = "ConnectivityModuleDb"
+        var config = {
+            server: server,
+            // user: 'mssqladministrator',
+            // password: process.env.sqldbpassword,
+            database: database,
+            requestTimeout: 600000,
+            options: {
+                encrypt: true // Use this if you're on Windows Azure
+            },
+            authentication: {
+                type: "azure-active-directory-service-principal-secret",
+                options: {
+                    clientId: process.env.servicePrincipalClientId,
+                    clientSecret: process.env.servicePrincipalClientSecret,
+                    tenantId: process.env.tenantId
+                }
+            }
+        };
+        var conn = new sql.ConnectionPool(config);
+        return conn;
+
+    }
+    static async executeSqlQuery(pool1: { connect: () => any; on: (arg0: string, arg1: (err: any) => void) => void; request: () => any; close: () => void; }, queryString: any) {
+        var pool1Connect = await pool1.connect();
+        pool1.on('error', err => {
+            console.log(err);
+            return;
+        })
+        await pool1Connect;
+        try {
+            const request = pool1.request(); // or: new sql.Request(pool1)
+            const result = await request.query(queryString)
+            return result;
+        } catch (err) {
+            console.error('SQL error', err);
+            return null;
+        }
+        pool1.close();
+
+    }
+
+
+
+    static async generateRandomUniqeIDNumber() {
+        const d = new Date();
+        let minutes = d.getMinutes();
+        let seconds = d.getSeconds();
+        let hour = d.getHours();
+        const result = Math.random().toString(36).substring(2, 5).toUpperCase();
+        let localUid = "SNO" + result + hour + minutes.toString() + seconds;
+        return localUid;
+
+    }
+
+    static async getUTCTimeCustom24hrs(localTime: string) {
+
+        console.log(localTime);
+        var localDate = new Date();
+
+        localDate.setHours(parseInt(localTime.split(":")[0].trim()));
+
+        localDate.setMinutes(parseInt(localTime.split(":")[1].substring(0, 2).trim()))
+        localDate.setSeconds(0, 0)
+        console.log("**** Returning time " + localDate.toISOString());
+        return localDate.toISOString()
+
+    }
+
+    static async waitFortimeOut(waitTime: any) {
+        const sleep = (waitTimeInMs: any) => new Promise(resolve => setTimeout(resolve, waitTimeInMs));
+        await sleep(waitTime);
+    }
+    static async executeCosmosQuery(queryString: any) {
+        /*var endpoint = process.env.cosmosConfig.endpoint;
+        var key = process.env.cosmosConfig.key;
+        var databaseId = process.env.cosmosConfig.databaseId;
+        var containerId = process.env.cosmosConfig.containerId;
+        const client = new cosmosClient({ endpoint, key });
+
+        const database = client.database(databaseId);
+        const container = database.container(containerId);
+        console.log(`Querying container: Items`);
+
+        // query to return all items
+        const querySpec = {
+            query: queryString
+        };
+
+        // read all items in the Items container
+        var {resources: items}  = await container.items.query(querySpec).fetchAll();
+        return items;*/
+    }
+
+    static async getUTCTimeCustom(localTime: any) {
+
+        console.log(localTime);
+        var localDate = new Date();
+        var hours = parseInt(localTime.split(":")[0].trim());
+        if (localTime.includes('PM')) {
+            if (hours == 12) {
+                localDate.setHours(parseInt(localTime.split(":")[0].trim()));
+            } else {
+                localDate.setHours(parseInt(localTime.split(":")[0].trim()) + 12);
+            }
+        } else {
+            if (hours == 12) {
+                localDate.setHours(0);
+            } else {
+                localDate.setHours(parseInt(localTime.split(":")[0].trim()));
+            }
+        }
+        localDate.setMinutes(parseInt(localTime.split(":")[1].substring(0, 2).trim()))
+        localDate.setSeconds(0, 0)
+        console.log("**** Returning time " + localDate.toISOString());
+        return localDate.toISOString()
+
+    }
+    static async ConvertCSVDataToJSONObject(csvfilePath: any, jsonfilePath: any) {
+        try {
+            const pathtoCSV = path.resolve(__dirname, csvfilePath);
+            const pathtoJson = path.resolve(__dirname, jsonfilePath);
+            const csvfile = fsr.readFileSync(pathtoCSV);
+            const arr = csvfile.toString().split(/[\r\n]+/);
+            var jsonObject = [];
+            var headers = arr[0].split(',')
+
+            for (var i = 1; i < arr.length; i++) {
+                var data = arr[i].split(',');
+                var object = {};
+                for (var j = 0; j < data.length; j++) {
+                    object[headers[j].trim()] = data[j].trim();
+                }
+                jsonObject.push(object)
+            }
+            const result = jsonObject;
+            fsr.writeFileSync(pathtoJson, JSON.stringify(jsonObject));
+
+            return result;
+
+        } catch (exception) {
+            console.log(exception.message);
+
+        }
+
+    }
+    static async ConvertCSVDataToJSONFile(csvfilePath: any, jsonfilePath: any) {
+        try {
+            const pathtoCSV = path.resolve(__dirname, csvfilePath);
+            const pathtoJson = path.resolve(__dirname, jsonfilePath);
+            const csvfile = fsr.readFileSync(pathtoCSV);
+            const arr = csvfile.toString().split(/[\r\n]+/);
+            var jsonObject = [];
+            var headers = arr[0].split('|')
+            for (var i = 1; i < arr.length; i++) {
+                var data = arr[i].split('|');
+                var object = {};
+                for (var j = 0; j < data.length; j++) {
+                    object[headers[j].trim()] = data[j].trim();
+                }
+                jsonObject.push(object)
+            }
+            const result = jsonObject;
+            fsr.writeFileSync(pathtoJson, JSON.stringify(jsonObject));
+            return result;
+
+        } catch (exception) {
+            console.log(exception.message);
+
+        }
+
+    }
+    static async ConvertCSVDataToKeyValue(csvfilePath: any, jsonfilePath: any) {
+        try {
+            const pathtoCSV = path.resolve(__dirname, csvfilePath);
+            const pathtoJson = path.resolve(__dirname, jsonfilePath);
+            const csvfile = fsr.readFileSync(pathtoCSV);
+            const arr = csvfile.toString().split(/[\r\n]+/);
+            var jsonObject = [];
+
+            for (var i = 0; i < arr.length; i++) {
+                var data = arr[i].split(',');
+                var object = {};
+                for (var j = 1; j < data.length; j++) {
+                    object[data[0].trim()] = data[j].trim();
+                }
+                jsonObject.push(object)
+            }
+            const result = jsonObject;
+            fsr.writeFileSync(pathtoJson, JSON.stringify(jsonObject));
+            return result;
+
+        } catch (exception) {
+            console.log(exception.message);
+
+        }
+
+    }
+    static async GenerateTripLinksFile(tripdetails: any, triplinks_path: any, triplinks_folder: any) {
+        try {
+            var pathtoTripLinks = path.resolve(__dirname, triplinks_path);
+            var dir = path.resolve(__dirname, triplinks_folder);
+            if (!fsr.existsSync(dir)) {
+                fsr.mkdirSync(dir);
+                if (!fsr.existsSync(pathtoTripLinks)) {
+                    fsr.open(pathtoTripLinks, 'w', function (err, file) {
+                        if (err) throw err;
+                        console.log('File is opened in write mode.');
+                    });
+                }
+            }
+            else {
+                if (!fsr.existsSync(pathtoTripLinks)) {
+                    fsr.open(pathtoTripLinks, 'w', function (err, file) {
+                        if (err) throw err;
+                        console.log('File is opened in write mode.');
+                    });
+                }
+            }
+            let existingTrips = fsr.readFileSync(pathtoTripLinks, "utf-8");
+            if (existingTrips.length != 0) {
+                var jsonObject = [];
+                jsonObject = JSON.parse(existingTrips);
+            }
+            else var jsonObject = [];
+            var headers = tripdetails[0].split(',')
+            for (var i = 1; i < tripdetails.length; i++) {
+                var data = tripdetails[i].split(',');
+                var object = {};
+                for (var j = 0; j < data.length; j++) {
+                    object[headers[j].trim()] = data[j].trim();
+                }
+                jsonObject.push(object)
+            }
+            const result = jsonObject;
+            fsr.writeFileSync(pathtoTripLinks, JSON.stringify(jsonObject));
+            return result;
+        } catch (exception) {
+            console.log(exception.message);
+
+        }
+    }
+
+    static async readExcel(path: string) {
+        const workbook = XLSX.readFile(path);
+        const sheet = workbook.Sheets[workbook.SheetNames[0]];
+        const jsonSheet = XLSX.utils.sheet_to_json(sheet);
+        console.log(jsonSheet);
+        return jsonSheet;
+    }
+
+}

package/src/utils/xmlToJson.ts

@@ -0,0 +1,40 @@
+export class XmlToJson {
+
+	static async xmlToJson(xml: any) {
+
+		// Create the return object
+		var obj: any = {};
+
+		if (xml.nodeType == 1) { // element
+			// do attributes
+			if (xml.attributes.length > 0) {
+				obj["@attributes"] = {};
+				for (var j = 0; j < xml.attributes.length; j++) {
+					var attribute = xml.attributes.item(j);
+					obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
+				}
+			}
+		} else if (xml.nodeType == 3) { // text
+			obj = xml.nodeValue;
+		}
+
+		// do children
+		if (xml.hasChildNodes()) {
+			for (var i = 0; i < xml.childNodes.length; i++) {
+				var item = xml.childNodes.item(i);
+				var nodeName = item.nodeName;
+				if (typeof (obj[nodeName]) == "undefined") {
+					obj[nodeName] = this.xmlToJson(item);
+				} else {
+					if (typeof (obj[nodeName].push) == "undefined") {
+						var old = obj[nodeName];
+						obj[nodeName] = [];
+						obj[nodeName].push(old);
+					}
+					obj[nodeName].push(this.xmlToJson(item));
+				}
+			}
+		}
+		return obj;
+	};
+}

package/tsconfig.json

@@ -0,0 +1,106 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": false,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    "useUnknownInCatchVariables": false,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}