ics-builder 4.4.10 → 4.4.11

package/src/builder/api/net5Builder.ts

@@ -1,181 +0,0 @@
-import * as path from "path";
-import * as shell from "shelljs";
-
-import { Module, Package } from "src/services/configManager";
-import { BaseBuilder, BuilderConfig } from "../baseBuilder";
-import { Logger, Utils } from "../../utils";
-import { DotnetUtils } from "../../dotnetUtils";
-import { packageStructureManager } from "../../services/packageStructure/packageStructureManager";
-import { CsprojFile } from "./csprojFile";
-import { WebConfigFile } from "./webConfigFile";
-
-export class Net5ApiBuilder extends BaseBuilder {
-	private buildApiFolder: string;
-	private modules = new Array<ApiModuleInfo>();
-	private allProjects: string[] = [];
-	private emptyModulesWithConfig: Map<string, string> = new Map<string, string>();
-
-	private configFile = "appsettings.json";
-
-	constructor(config: BuilderConfig) {
-		super(config);
-		this.buildApiFolder = path.join(this.config.paths.build, "api");
-
-		shell.config.silent = true;
-	}
-
-	run(): void | Promise<void> {
-		this.config.packages.forEach(pkg => {
-			this.collectModuleInfo(pkg);
-		});
-
-		// cleanup
-		this.allProjects.forEach(p => {
-			this.clearCache(path.dirname(p));
-		})
-
-		this._build()
-	}
-
-	private _build() {
-		if (this.modules.length == 0)
-		{
-			Logger.warn("Api layer not found, skipping.");
-			return;
-		}
-
-		let configuration = this.config.api?.configuration || "Debug";
-		this._buildProjects(configuration);
-		this._buildSolutions(configuration);
-	}
-
-	private _buildProjects(configuration: string)
-	{
-		let coreModule = this.modules.find(m => m.isCoreModule) ?? this.modules[0];
-		let slnName = "Mdt";
-		let slnDir = path.dirname(coreModule.buildFile.path);
-		let tempSlnPath = path.join(slnDir, slnName + ".sln");
-		let projects = this.modules.map(m => m.buildFile).filter(f => f.type == ApiModuleBuildFileType.Project);
-
-		try {
-			DotnetUtils.createTempSln(slnDir, slnName);
-			for(let p of projects)
-			{
-				let csproj = new CsprojFile(p.path);
-				csproj.setPublishPath(p.outputPath);
-				csproj.save(p.path);
-			}
-			DotnetUtils.addProjectsToSln(tempSlnPath, projects.map(p => p.path));
-			DotnetUtils.restoreNugetPackages(tempSlnPath);
-			DotnetUtils.publish(tempSlnPath, configuration);
-			let webConfigFilePath = path.join(coreModule.buildFile.outputPath, "web.config");
-			let webConfigFile = new WebConfigFile(webConfigFilePath);
-			webConfigFile.addDotnetProcessPath();
-			webConfigFile.save();
-
-			projects.filter(p => p.path != coreModule.buildFile.path).forEach(p => {
-				let projectDir = path.dirname(p.path);
-				this.copyModuleConfig(projectDir, p.outputPath, this.configFile);
-			});
-			this.emptyModulesWithConfig.forEach((val, key) => {
-				this.copyModuleConfig(val, path.join(this.buildApiFolder, "modules", key), this.configFile);
-			});
-		} finally {
-			Utils.deleteFile(tempSlnPath);
-		}
-	}
-
-	private _buildSolutions(configuration: string)
-	{
-		let solutions = this.modules.map(m => m.buildFile).filter(f => f.type == ApiModuleBuildFileType.Solution);
-		if (solutions.length == 0) return;
-		Logger.info(`building additional solutions`);
-		solutions.forEach(solution => {
-			DotnetUtils.restoreNugetPackages(solution.path);
-			DotnetUtils.publish(solution.path, configuration, solution.outputPath);
-		})
-	}
-
-	private collectModuleInfo(pkg: Package): void {
-		packageStructureManager.getModuleSourcePaths(pkg, "api", this.config).forEach(({ moduleName, sourcePath }) => {
-			this.writeModulesProjects(pkg.name, pkg.modules.find(m => m.name == moduleName), sourcePath);
-		});
-	}
-
-	private writeModulesProjects(packageName: string, module: Module, modulePath: string): void {
-		let moduleConfig = this.parsePackageInfoLegacy(path.join(modulePath, "module.yml"));
-
-		if (moduleConfig?.api?.project) {
-			let csprojPath = path.join(modulePath, moduleConfig.api.project);
-			if (!Utils.ensurePath(csprojPath)) {
-				Logger.error(`${csprojPath} does not exist`);
-				return;
-			}
-			this.modules.push(new ApiModuleInfo(packageName, module, csprojPath, this.buildApiFolder))
-		} else {
-			let files = shell.ls(path.join(modulePath, "*.sln"));
-			if (files.length) {
-				this.modules.push(new ApiModuleInfo(packageName, module, files[0], this.buildApiFolder));
-			} else {
-				files = shell.ls(path.join(modulePath, "*.csproj"));
-				if (files.length) {
-					this.modules.push(new ApiModuleInfo(packageName, module, files[0], this.buildApiFolder))
-				} else {
-					Logger.warn(`Module ${module.name} does not have .csproj file and will be skipped`);
-					let configFile = path.join(modulePath, this.configFile);
-					if (Utils.ensurePath(configFile))
-						this.emptyModulesWithConfig.set(packageName + "." + module.name, modulePath);
-					return;
-				}
-			}
-		}
-
-		this.addProjectFiles(modulePath);
-	}
-
-	private addProjectFiles(modulePath: string): void {
-		let files = shell.ls(path.join(modulePath, "*.csproj"), path.join(modulePath, "*", "*.csproj"));
-		files.forEach(f => {
-			this.allProjects.push(f);
-		})
-	}
-
-	private clearCache(folderPath: string): void {
-		Utils.deleteAllFoldersRecursively(folderPath, "bin");
-		Utils.deleteAllFoldersRecursively(folderPath, "obj");
-	}
-}
-
-class ApiModuleInfo {
-	package: string;
-	module: Module;
-	buildFile: ApiModuleBuildFile;
-	isCoreModule: boolean;
-
-	constructor(pkg: string, module: Module, buildFilePath: string, buildApiFolder: string) {
-		this.package = pkg;
-		this.module = module;
-		this.isCoreModule = module.name == "_core" && pkg == "mdt";
-		let outputPath = this.isCoreModule 
-			? buildApiFolder 
-			: path.join(buildApiFolder, "modules", Utils.getFileName(buildFilePath));
-		this.buildFile = new ApiModuleBuildFile(buildFilePath, outputPath);
-	}
-}
-
-class ApiModuleBuildFile {
-	path: string;
-	type: ApiModuleBuildFileType;
-	outputPath: string;
-
-	constructor(path: string, outputPath: string) {
-		this.path = path;
-		this.outputPath = outputPath;
-		this.type = path.endsWith(".csproj") ? ApiModuleBuildFileType.Project : ApiModuleBuildFileType.Solution;
-	}
-}
-
-enum ApiModuleBuildFileType {
-	Project,
-	Solution
-}

package/src/builder/api/webConfigFile.ts

@@ -1,11 +0,0 @@
-import { XmlFile } from "./xmlFile";
-
-export class WebConfigFile extends XmlFile {
-    addDotnetProcessPath() {
-        if (!this._xmlObj) this._readFile();
-        let aspNetCoreSectionOptions = this._xmlObj.configuration.location["system.webServer"].aspNetCore.$;
-        aspNetCoreSectionOptions.processPath = "dotnet";
-        aspNetCoreSectionOptions.arguments = ".\\Mdt.WebApi.dll";
-        aspNetCoreSectionOptions.stdoutLogEnabled = "false";
-    }
-}

package/src/builder/api/xmlFile.ts

@@ -1,24 +0,0 @@
-import * as xml2js from "xml2js";
-import * as fs from "fs";
-
-export class XmlFile {
-	protected _xmlObj;
-
-	constructor(private _path: string) {
-
-	}
-
-	protected _readFile(): void {
-		let file = fs.readFileSync(this._path);
-		xml2js.parseString(file, { explicitArray: false }, (err, result) => {
-			if (err) throw new Error(`Error while parsing xml file ${this._path}:\n${err.message}`);
-			this._xmlObj = result
-		});
-	}
-
-	save(path: string = null): void {
-		let builder = new xml2js.Builder();
-		let xml = builder.buildObject(this._xmlObj);
-		fs.writeFileSync(path ?? this._path, xml);
-	}
-}

package/src/builder/baseBuilder.ts

@@ -1,71 +0,0 @@
-import * as yaml from "yamljs";
-import * as fs from "fs";
-import * as path from "path";
-
-import { Config, Package, PackageInfoLegacy } from "../services/configManager";
-import { Utils, Logger } from "../utils";
-import { Run } from "../services/commandManager";
-import { PackageManager } from "../services/packageManager";
-
-export interface BuildOptions {
-	ui?: { mode: string };
-	multiple?: boolean;
-}
-
-type PartialConfig = Pick<Config, "version" | "paths" | "api" | "ui">;
-
-export interface BuilderConfig extends PartialConfig {
-	packages: Array<Package>;
-	options: BuildOptions;
-}
-
-export abstract class BaseBuilder implements Run {
-	protected config: BuilderConfig;
-	protected packageManager: PackageManager;
-
-	constructor(config: BuilderConfig) {
-		this.config = config;
-		this.packageManager = PackageManager.getInstance();
-		Logger.info(`using ${this.constructor.name}`);
-	}
-
-	abstract run(): void | Promise<void>;
-
-	protected parsePackageInfoLegacy(path: string): PackageInfoLegacy {
-		return Utils.ensurePath(path) ? <PackageInfoLegacy>yaml.load(path) : {};
-	}
-
-	protected writeBuildInfo(targetPath: string, object: any, mode: "yml" | "json"): void {
-		fs.writeFileSync(
-			targetPath.replace(new RegExp(`.${mode.replace("yml", "ya?ml")}$`), "").concat(`.${mode}`),
-			mode === "json" ? JSON.stringify(object, null, "\t") : yaml.stringify(object)
-		);
-	}
-
-	protected runTests(configPath: string) {
-		if (Utils.ensurePath(configPath)) {
-			Logger.info(`Found test config at path ${configPath}, start running tests.`);
-			const { stdout, stderr, code } = Utils.exec("npx --no-install jest --collectCoverage", {
-				cwd: path.dirname(configPath),
-				silent: true
-			});
-			if (code) {
-				let message = `Tests failed\n${stderr}`;
-				if (this.config.options.ui.mode === "prod") Logger.error(message);
-				Logger.warn(message);
-			} else Logger.info(`Tests successfully passed. Coverage report: \n${stdout}`);
-		}
-	}
-
-	protected copyModuleConfig(
-		sourceDir: string,
-		targetDir: string,
-		configFileName: string,
-		newConfigFileName?: string
-	): void {
-		let moduleConfigFile = path.join(sourceDir, configFileName);
-		if (Utils.ensurePath(moduleConfigFile)) {
-			Utils.copyFile(moduleConfigFile, path.join(targetDir, newConfigFileName ?? configFileName));
-		}
-	}
-}

package/src/builder/data/dataBuilder.ts

@@ -1,28 +0,0 @@
-import * as path from "path";
-
-import { BaseBuilder, BuilderConfig } from "../baseBuilder";
-import { Utils } from "../../utils";
-import { packageStructureManager } from "../../services/packageStructure/packageStructureManager";
-
-export class DataBuilder extends BaseBuilder {
-	constructor(config: BuilderConfig) {
-		super(config);
-	}
-
-	run(): void | Promise<void> {
-		const dataName = "data";
-		let targetDir = path.join(this.config.paths.build, dataName);
-		Utils.prepareDir(targetDir);
-
-		this.config.packages.forEach(pkg => {
-			packageStructureManager.getModuleSourcePaths(pkg, dataName, this.config).forEach(({moduleName, sourcePath}) => {
-				let moduleDestinationDir = path.join(targetDir, pkg.name.concat(".", moduleName));
-
-				Utils.copyAllFilesByPattern(sourcePath, moduleDestinationDir, "*.{yaml,yml}");
-				Utils.copyAllFolders(sourcePath, moduleDestinationDir);
-			});
-		});
-
-		Utils.removeEmptyFolders(targetDir);
-	}
-}

package/src/builder/db/dbBuilder.ts

@@ -1,167 +0,0 @@
-import * as path from "path";
-import * as glob from "glob";
-import * as xml2js from "xml2js";
-import * as yaml from "yamljs";
-import * as fs from "fs";
-
-import { BaseBuilder, BuilderConfig } from "../baseBuilder";
-import { Utils, Logger } from "../../utils";
-import { packageStructureManager } from "../../services/packageStructure/packageStructureManager";
-
-export class DbBuilder extends BaseBuilder {
-	constructor(config: BuilderConfig) {
-		super(config);
-	}
-
-	run(): void {
-		let targetDir = path.join(this.config.paths.build, "db");
-		Utils.prepareDir(targetDir);
-
-		this.config.packages.forEach(pkg => {
-			packageStructureManager.getModuleSourcePaths(pkg, "db", this.config).forEach(({moduleName, sourcePath}) => {
-				let moduleDestinationDir = path.join(targetDir, pkg.name.concat(".", moduleName));
-
-				let filesToConvert = glob.sync(path.join(sourcePath, "data", "**/*.{yml,json}"));
-				this.convertToXml(filesToConvert, moduleName, path.join(moduleDestinationDir, "data"));
-
-				Utils.copyAllFilesByPattern(
-					path.join(sourcePath, "data"),
-					path.join(moduleDestinationDir, "data"),
-					"**/*.xml"
-				);
-				Utils.copyAllFilesByPattern(
-					path.join(sourcePath, "scripts"),
-					path.join(moduleDestinationDir, "scripts"),
-					"**/*.sql"
-				);
-				Utils.copyAllFilesByPattern(
-					path.join(sourcePath, "updates"),
-					path.join(moduleDestinationDir, "updates"),
-					"**/*.sql"
-				);
-
-				let otherUpdatesDirs = fs.readdirSync(sourcePath, { withFileTypes: true })
-					.filter(d => d.isDirectory())
-					.map(d => d.name)
-					.filter(d => d.startsWith("updates."));
-
-				for (let updateDir of otherUpdatesDirs) {
-					Utils.copyAllFilesByPattern(
-						path.join(sourcePath, updateDir),
-						path.join(moduleDestinationDir, updateDir),
-						"**/*.sql"
-					);
-				}
-
-				let otherScriptsDirs = fs.readdirSync(sourcePath, { withFileTypes: true })
-					.filter(d => d.isDirectory())
-					.map(d => d.name)
-					.filter(d => d.startsWith("scripts."));
-
-				for (let scriptDir of otherScriptsDirs) {
-					Utils.copyAllFilesByPattern(
-						path.join(sourcePath, scriptDir),
-						path.join(moduleDestinationDir, scriptDir),
-						"**/*.sql"
-					);
-				}
-
-				if (Utils.ensurePath(moduleDestinationDir)) {
-					let scriptsPath = path.join(sourcePath, "scripts");
-					this.GenerateOrderFile(scriptsPath, moduleDestinationDir + "/scripts");
-
-					for (let scriptDir of otherScriptsDirs) {
-						let otherScriptPath = path.join(sourcePath, scriptDir);
-						this.GenerateOrderFile(otherScriptPath, moduleDestinationDir + "/" + scriptDir);
-					}
-				}
-			});
-		});
-	}
-
-	private GenerateOrderFile(scriptsPath: string, destinationScriptsPath: string)
-	{
-		let order = new Array<string>();
-		let files = new Array<string>();
-		let dependencies = {};
-		let dirs = ["view*", "function*", "procedure*", "trigger*", "index*"];
-
-		dirs.forEach(dir => {
-			files = files.concat(glob.sync(path.join(scriptsPath, dir, "**/*.sql")));
-		});
-
-		for (var i = 0; i < files.length; i++) files[i] = files[i].replace(/\//g, path.sep);
-
-		let reorder = function (file: string, parent?: string) {
-			if (file == parent) throw "Circular dependencies! " + parent;
-
-			let deps = dependencies[file];
-
-			deps &&
-				deps.forEach(dep => {
-					dep = path.resolve(scriptsPath, dep);
-					if (files.indexOf(dep) != -1) reorder(dep, parent || file);
-				});
-
-			if (!parent || order.indexOf(parent) > order.indexOf(file)) return;
-
-			order.splice(order.indexOf(file), 1);
-			order.splice(order.indexOf(parent), 0, file);
-		};
-
-		files.forEach(file => {
-			let deps = (dependencies[file] = []);
-			let data = fs.readFileSync(file).toString();
-			data.split("\n").forEach(line => {
-				var m = line.replace(/^\uFEFF/, "").match(/^--\s*\$dep\s+(.+?)\s*$/);
-				if (m) {
-					deps.push(m[1]);
-				}
-			});
-			order.push(file);
-		});
-		// reorder
-		files.forEach(file => {
-			reorder(file);
-		});
-
-		if (order.length)
-			fs.writeFileSync(
-				destinationScriptsPath + "/order.txt",
-				order
-					.map(function (f) {
-						return path.relative(scriptsPath, f);
-					})
-					.join("\n")
-			);
-	}
-
-	private convertToXml(paths: Array<string>, module: string, destinationDir: string): void {
-		paths.forEach(p => {
-			let obj = null;
-			let content = fs.readFileSync(p, "utf8").replace(/^\uFEFF/, "");
-
-			try {
-				switch (path.extname(p)) {
-					case ".yml":
-						obj = yaml.parse(content);
-						break;
-					case ".json":
-						obj = JSON.parse(content);
-						break;
-				}
-			} catch (ex) {
-				Logger.error(`Error parsing file ${p}\n`, ex);
-			}
-
-			if (obj instanceof Array) obj = { root: obj };
-
-			let xmlBuilder = new xml2js.Builder();
-			let xml = xmlBuilder.buildObject(obj);
-			let fileName = path.basename(p).replace(path.extname(p), ".xml");
-
-			Utils.ensureFolder(destinationDir);
-			fs.writeFileSync(path.join(destinationDir, fileName), xml);
-		});
-	}
-}

package/src/builder/e2e/e2eBuilder.ts

@@ -1,23 +0,0 @@
-import * as path from "path";
-
-import { BaseBuilder, BuilderConfig } from "../baseBuilder";
-import { Utils } from "../../utils";
-
-export class E2EBuilder extends BaseBuilder {
-	constructor(config: BuilderConfig) {
-		super(config);
-	}
-
-	run(): void | Promise<void> {
-		this.config.packages.forEach(pkg => {
-			let sourceDir = path.join(this.config.paths.source, pkg.name, "e2e");
-			if (Utils.ensurePath(sourceDir)) {
-				let targetDir = path.join(this.config.paths.build, "e2e", pkg.name);
-				Utils.copyFolder(sourceDir, targetDir);
-				let hgFolder = path.join(targetDir, ".hg");
-				Utils.clearFolder(hgFolder);
-				Utils.removeEmptyFolders(targetDir);
-			}
-		});
-	}
-}

package/src/builder/schema/schemaBuilder.ts

@@ -1,156 +0,0 @@
-import { BaseBuilder, BuilderConfig } from "../baseBuilder";
-import { Utils, Logger } from "../../utils";
-import * as Path from "path";
-import * as fs from "fs";
-import * as TJS from "typescript-json-schema";
-
-interface schemaFile {
-	path: string;
-	schemaName: string;
-}
-
-const tempInterfaceExt = "Ext";
-
-export class SchemaBuilder extends BaseBuilder {
-	constructor(config: BuilderConfig) {
-		super(config);
-	}
-
-	run(): void | Promise<void> {
-		this.config.packages.forEach(pkg => {
-			if (!pkg.isLegacy) return;
-			Logger.info(`Generating schema for ${pkg.name}...`)
-			let sourcePath = Path.join(this.config.paths.source, pkg.name, "ui");
-			if (!Utils.ensurePath(sourcePath) || !pkg.modules) return;
-			if (this.config.options.multiple) {
-				pkg.modules.forEach(module => {
-					let modulePath = Path.join(sourcePath, module.name);
-					if (!Utils.ensurePath(modulePath)) return;
-					let schemaFiles = this._findInterfaces(modulePath);
-					this._createSchemaFiles(sourcePath, modulePath, schemaFiles);
-				});
-			} else {
-				let interfaces = new Map<string, schemaFile[]>()
-				pkg.modules.forEach(module => {
-					let modulePath = Path.join(sourcePath, module.name);
-					if (!Utils.ensurePath(modulePath)) return;
-					let schemaFiles = this._findInterfaces(modulePath);
-					for (let file of schemaFiles) {
-						if (!interfaces.has(file.schemaName)) interfaces.set(file.schemaName, []);
-						interfaces.get(file.schemaName).push(file);
-					}
-				});
-				this._createSchemaFile(sourcePath, interfaces);
-			}
-		});
-	}
-
-	private _findInterfaces(path: string): schemaFile[] {
-		let interfacePaths: schemaFile[] = [];
-		let files = fs.readdirSync(path);
-		files.forEach(file => {
-			let filePath = Path.join(path, file);
-			let stat = fs.statSync(filePath);
-			if (stat.isDirectory()) {
-				interfacePaths.push(...this._findInterfaces(filePath));
-			} else {
-				let regex = /(.*)\.schema\.ts$/.exec(file);
-				if (regex) interfacePaths.push({ path: filePath, schemaName: regex[1] });
-			}
-		});
-		return interfacePaths;
-	}
-
-	private _createSchemaFiles(path: string, modulePath: string, schemaFiles: schemaFile[]): void {
-		if (schemaFiles.length === 0) return;
-		this._createSchema(path, modulePath, schemaFiles.map(f => f.path), schemaFiles.map(f => f.schemaName));
-	}
-
-	private _createSchemaFile(path: string, interfaces: Map<string, schemaFile[]>): void {
-		let symbolsPath: string[] = [];
-		let tempFiles: string[] = [];
-		let symbols: string[] = [];
-		let extSymbols: string[] = [];
-		interfaces.forEach((interf, name) => {
-			if (interf.length > 1) {
-				let tempFile = this._createTempFile(path, name, interf);
-				symbolsPath.push(tempFile);
-				tempFiles.push(tempFile);
-				extSymbols.push(interf[0].schemaName + tempInterfaceExt)
-			} else {
-				symbolsPath.push(interf[0].path);
-				symbols.push(interf[0].schemaName);
-			}
-		});
-
-		this._createSchema(path, path, symbolsPath, symbols, extSymbols);
-		this._deleteTempFiles(tempFiles);
-	}
-
-	private _createSchema(sourcePath: string, schemaPath: string, symbolsPath: string[], symbolsName: string[], extSymbolsName?: string[]) {
-		const settings: TJS.PartialArgs = {
-			ignoreErrors: true,
-			validationKeywords: ["markdownDescription", "defaultSnippets", "title"],
-			required: true,
-			excludePrivate: true
-		};
-		const tsConfigPath = Path.join(sourcePath, "tsconfig.json");
-		if (!Utils.ensurePath(tsConfigPath)) {
-			Logger.info(`File ${tsConfigPath} not found. Skipping...`);
-			return;
-		}
-		logger.disableLogger();
-		const program = TJS.programFromConfig(tsConfigPath, symbolsPath);
-		const generator = TJS.buildGenerator(program, settings);
-		let schema = generator.getSchemaForSymbols(extSymbolsName ? symbolsName.concat(extSymbolsName) : symbolsName);
-		if (extSymbolsName && schema.definitions) {
-			extSymbolsName.forEach(symbol => {
-				schema.definitions[symbol.slice(0, symbol.length - tempInterfaceExt.length)] = schema.definitions[symbol];
-				delete schema.definitions[symbol];
-			})
-			let orderedDefinitions = Object.keys(schema.definitions).sort().reduce((obj, key) => {obj[key] = schema.definitions[key]; return obj}, {});
-			schema.definitions = orderedDefinitions;
-		}
-		logger.enableLogger();
-		Utils.ensureFolder(schemaPath);
-		fs.writeFileSync(Path.join(schemaPath, "json-schema.json"), JSON.stringify(schema, null, 4));
-	}
-
-	private _createTempFile(path: string, schemaName: string, schemaFiles: schemaFile[]): string {
-		if (!schemaFiles || schemaFiles.length == 0) return null;
-		let fileContent = schemaFiles.map((schemaFile, idx) => {
-			return `import {${schemaName} as ${schemaName + idx}} from "${schemaFile.path.replace(/\\/g, "\\\\").replace(/\.ts$/g,"")}"`;
-		}).join("\n");
-		fileContent += `\ninterface ${schemaName + tempInterfaceExt} extends ${schemaFiles.map((f, idx) => schemaName + idx).join(", ")} {}`;
-		let tempFilePath = Path.join(path, `tempSchema${schemaName}.ts`);
-		fs.writeFileSync(tempFilePath, fileContent, {encoding: "utf8"});
-		return tempFilePath;
-	}
-
-	private _deleteTempFiles(paths: string[]): void {
-		paths.forEach(path => fs.unlinkSync(path));
-	}
-}
-
-let logger = function()
-{
-    let oldConsoleLog = null;
-	let oldConsoleWarn = null
-    let pub = {enableLogger: null, disableLogger: null};
-
-    pub.enableLogger =  function enableLogger() 
-                        {
-                            if(oldConsoleLog != null) console.log = oldConsoleLog;
-							if(oldConsoleWarn != null) console.warn = oldConsoleWarn;
-                        };
-
-    pub.disableLogger = function disableLogger()
-                        {
-                            oldConsoleLog = console.log;
-							oldConsoleWarn = console.warn;
-                            console.log = function() {};
-							console.warn = function() {};
-                        };
-
-    return pub;
-}();