migration to typescript

dist/clean.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs-extra");
+var path = require("path");
+var tasks = require("./tasks");
+var lodash_1 = require("lodash");
+var minimist = require("minimist");
+var options = minimist(process.argv.slice(2), {});
+fs.emptyDirSync('.BuildOutput');
+lodash_1.forEach(tasks.getTasks(options.taskroot), function (task) {
+    var targetNodeCommonDir = path.join(task.directory, "common");
+    var taskNodeModules = path.join(task.directory, "node_modules");
+    var targetPowershellCommonDir = path.join(task.directory, "ps_modules");
+    fs.removeSync(targetNodeCommonDir);
+    fs.removeSync(targetPowershellCommonDir);
+    if (options.modules == "true") {
+        fs.removeSync(taskNodeModules);
+    }
+    ;
+});

dist/extension-version.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var minimist = require("minimist");
+var semver = require("semver");
+function getSemanticVersion() {
+    var options = minimist(process.argv.slice(2), {});
+    var version = options.version;
+    if (!version) {
+        version = "0.0.0";
+        console.log('No version argument provided, fallback to default version: ' + version);
+    }
+    else {
+        console.log('Found version: ' + version);
+    }
+    if (!semver.valid(version)) {
+        throw new Error('Package: invalid semver version: ' + version);
+    }
+    var patch = semver.patch(version);
+    if (!options.noversiontransform) {
+        patch *= 1000;
+        var prerelease = semver.prerelease(version);
+        if (prerelease) {
+            ;
+            patch += parseInt(prerelease[1]);
+        }
+        else {
+            patch += 999;
+        }
+    }
+    var result = {
+        major: semver.major(version),
+        minor: semver.minor(version),
+        patch: patch,
+        getVersionString: function () {
+            return this.major.toString() + '.' + this.minor.toString() + '.' + this.patch.toString();
+        }
+    };
+    console.log('Extension Version: ' + result.getVersionString());
+    return result;
+}
+exports.getSemanticVersion = getSemanticVersion;
+;

dist/install.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var async_1 = require("async");
+var path = require("path");
+var child_process_1 = require("child_process");
+var tasks_1 = require("./tasks");
+var npmInstall = function (project) {
+    return function (done) {
+        var child = child_process_1.exec('npm install', {
+            cwd: project.directory
+        }, function (error, stdout, stderr) {
+            if (error) {
+                console.error('execution error:', error);
+                done(error);
+                return;
+            }
+            console.log("npm install done for " + project.name);
+            if (stdout) {
+                console.log(stdout);
+            }
+            if (stderr) {
+                console.error(stderr);
+            }
+            var nodeModulesPath = path.join(project.directory, 'node_modules');
+            var powerShellModules = require("glob").sync(path.join(project.directory, "node_modules", "**", "*.psm1"));
+            if (powerShellModules.length > 0) {
+                var fs = require("fs-extra");
+                var taskFilePath = path.join(project.directory, 'task.json');
+                var task = fs.existsSync(taskFilePath) ? fs.readJsonSync(taskFilePath) : {};
+                if (task.execution.PowerShell3) {
+                    var psModulesPath = path.join(project.directory, 'ps_modules');
+                    fs.ensureDirSync(psModulesPath);
+                    for (var i = 0; i < powerShellModules.length; i++) {
+                        var powerShellModulePath = powerShellModules[i];
+                        var powerShellModuleDirName = path.dirname(powerShellModulePath);
+                        var powerShellModuleFolderName = path.basename(powerShellModuleDirName);
+                        fs.copySync(powerShellModuleDirName, path.join(psModulesPath, powerShellModuleFolderName), { clobber: true, dereference: true });
+                        console.log(powerShellModuleFolderName + " copied in ps_modules for " + project.name);
+                    }
+                }
+            }
+            done();
+        });
+    };
+};
+var installTasks = tasks_1.getTasks().map(npmInstall);
+installTasks.unshift(npmInstall({
+    directory: __dirname,
+    name: "BuildScripts"
+}));
+async_1.series(installTasks, function (err) {
+    if (err) {
+        console.error("Failed to install child dependencies");
+        throw err;
+    }
+});

dist/node-modclean.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var minimist = require("minimist");
+var tasks = require("./tasks");
+var async_1 = require("async");
+var path = require("path");
+var fs = require("fs");
+var modclean = require('modclean');
+var runModclean = function (project) {
+    return function (done) {
+        if (fs.existsSync(path.join(project.directory, "node_modules"))) {
+            var modcleanOptions = {
+                cwd: project.directory
+            };
+            var options = minimist(process.argv.slice(2), {});
+            if (options.patterns) {
+                modcleanOptions.patterns = options.patterns.split(',');
+            }
+            if (options.additionalpatterns) {
+                modcleanOptions.additionalPatterns = options.additionalpatterns.split(',');
+            }
+            if (options.ignorepatterns) {
+                modcleanOptions.ignorePatterns = options.ignorepatterns.split(',');
+            }
+            modclean(modcleanOptions, function (err, results) {
+                // called once cleaning is complete.
+                if (err) {
+                    console.error("exec error: " + err);
+                    done(err);
+                    return;
+                }
+                console.log(results.length + " files removed!");
+                done();
+            });
+        }
+        else {
+            console.log("modclean skipped for " + project.name);
+            done();
+        }
+    };
+};
+var cleanTasks = tasks.getTasks().map(runModclean);
+async_1.series(cleanTasks, function (err) {
+    if (err) {
+        console.error("Failed to run  modclean");
+        throw err;
+    }
+});

dist/package.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = require("path");
+var child_process_1 = require("child_process");
+var fs = require("fs-extra");
+var async_1 = require("async");
+var extension_version_1 = require("./extension-version");
+var tasks = require("./tasks");
+;
+var currentDirectory = process.cwd();
+var buildOutputDirectory = path.join(currentDirectory, '.BuildOutput');
+var extensionDirectory = path.join(currentDirectory, 'Extension');
+var tasksDirectory = path.join(currentDirectory, 'Tasks');
+fs.ensureDirSync(buildOutputDirectory);
+var version = extension_version_1.getSemanticVersion();
+var configuration = require(path.join(currentDirectory, 'configuration.json'));
+var createExtensionTasks = configuration.environments.map(function (env) {
+    var environmentDirectory = path.join(buildOutputDirectory, env.Name);
+    var environmentTasksDirectory = path.join(environmentDirectory, 'Tasks');
+    fs.ensureDirSync(environmentDirectory);
+    fs.copySync(extensionDirectory, environmentDirectory, { overwrite: true, dereference: true });
+    fs.copySync(tasksDirectory, environmentTasksDirectory, { overwrite: true, dereference: true });
+    var extensionFilePath = path.join(environmentDirectory, 'vss-extension.json');
+    var extension = fs.readJsonSync(extensionFilePath);
+    extension.id += env.VssExtensionIdSuffix;
+    extension.name += env.DisplayNamesSuffix;
+    extension.version = version.getVersionString();
+    extension.galleryFlags = env.VssExtensionGalleryFlags;
+    extension.contributions = [];
+    var patchTasks = tasks.getTasks(environmentTasksDirectory).map(function (taskDirectory) {
+        var taskFilePath = path.join(taskDirectory.directory, 'task.json');
+        var task = fs.readJsonSync(taskFilePath);
+        task.id = env.TaskIds[taskDirectory.name];
+        if (task.id) {
+            task.friendlyName += env.DisplayNamesSuffix;
+            task.version.Major = version.major;
+            task.version.Minor = version.minor;
+            task.version.Patch = version.patch;
+            if (task.helpMarkDown) {
+                task.helpMarkDown = task.helpMarkDown.replace('#{Version}#', version.getVersionString());
+            }
+            fs.writeJsonSync(taskFilePath, task);
+            var taskLocFilePath = path.join(taskDirectory.directory, 'task.loc.json');
+            if (fs.existsSync(taskLocFilePath)) {
+                var taskLoc = fs.readJsonSync(taskLocFilePath);
+                taskLoc.id = env.TaskIds[taskDirectory.name];
+                taskLoc.friendlyName += env.DisplayNamesSuffix;
+                taskLoc.version.Major = version.major;
+                taskLoc.version.Minor = version.minor;
+                taskLoc.version.Patch = version.patch;
+                if (taskLoc.helpMarkDown) {
+                    taskLoc.helpMarkDown = taskLoc.helpMarkDown.replace('#{Version}#', version.getVersionString());
+                }
+                fs.writeJsonSync(taskLocFilePath, taskLoc);
+                var locfilesDirectory = path.join(taskDirectory.directory, 'Strings/resources.resjson');
+                if (fs.existsSync(locfilesDirectory)) {
+                    var langs = fs.readdirSync(locfilesDirectory);
+                    for (var index = 0; index < langs.length; index++) {
+                        var element = langs[index];
+                        var resourceFile = path.join(locfilesDirectory, element, "resources.resjson");
+                        if (fs.existsSync(resourceFile)) {
+                            var resource = fs.readJsonSync(resourceFile);
+                            resource["loc.helpMarkDown"] = resource["loc.helpMarkDown"].replace('#{Version}#', version.getVersionString());
+                            fs.writeJsonSync(resourceFile, resource);
+                        }
+                    }
+                }
+            }
+            var taskId = taskDirectory.name.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^[-]+/, "");
+            extension.contributions.push({
+                id: taskId + "-task",
+                type: "ms.vss-distributed-task.task",
+                description: task.description,
+                targets: [
+                    "ms.vss-distributed-task.tasks"
+                ],
+                properties: {
+                    "name": "Tasks/" + taskDirectory.name
+                }
+            });
+        }
+        else {
+            fs.removeSync(taskDirectory.directory);
+        }
+    });
+    fs.writeJsonSync(extensionFilePath, extension);
+    var cmdline = 'tfx extension create --root "' + environmentDirectory
+        + '" --manifest-globs "' + extensionFilePath
+        + '" --output-path "' + environmentDirectory + '"';
+    return function (done) {
+        var child = child_process_1.exec(cmdline, {}, function (error, stdout, stderr) {
+            if (error) {
+                console.error("exec error: " + error);
+                done(error);
+                return;
+            }
+            console.log("tfx extension create done for " + env.Name);
+            if (stdout) {
+                console.log(stdout);
+            }
+            if (stderr) {
+                console.error(stderr);
+            }
+            done();
+        });
+    };
+});
+async_1.series(createExtensionTasks, function (err) {
+    if (err) {
+        console.error("Failed to create extensions.");
+        throw err;
+    }
+});

prebuild.js → dist/prebuild.js

@@ -1,40 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 var fs = require("fs-extra");
 var path = require("path");
-var tasks = require('./tasks.js');
-var collection = require('lodash/collection');
-
+var tasks = require("./tasks");
+var lodash_1 = require("lodash");
 var currentDirectory = process.cwd();
 var nodeCommonFilesRoot = path.join(currentDirectory, 'Common', 'Node');
 var powershellCommonFilesRoot = path.join(currentDirectory, 'Common', 'PowerShell3');
 var tasksRoot = path.join(currentDirectory, 'Tasks');
-
 var nodeFiles = fs.existsSync(nodeCommonFilesRoot) ? fs.readdirSync(nodeCommonFilesRoot) : [];
 var powershellFiles = fs.existsSync(powershellCommonFilesRoot) ? fs.readdirSync(powershellCommonFilesRoot) : [];
-
-collection.forEach(tasks.getTasks(), (task) => {
+lodash_1.forEach(tasks.getTasks(), function (task) {
     var targetNodeCommonDir = path.join(task.directory, "common");
     var taskNodeModules = path.join(task.directory, "node_modules");
     var targetPowershellCommonDir = path.join(task.directory, "ps_modules");
-
     var taskFilePath = path.join(task.directory, 'task.json');
     var taskFile = fs.existsSync(taskFilePath) ? fs.readJsonSync(taskFilePath) : {};
-
     if (taskFile.execution.Node) {
         fs.ensureDirSync(targetNodeCommonDir);
         fs.ensureDirSync(taskNodeModules);
-        collection.forEach(nodeFiles, (commonFile) => {
+        lodash_1.forEach(nodeFiles, function (commonFile) {
             var targetFile = path.join(targetNodeCommonDir, commonFile);
             console.log(targetFile);
-            fs.copySync(path.join(nodeCommonFilesRoot, commonFile), targetFile, { clobber: true });
+            fs.copySync(path.join(nodeCommonFilesRoot, commonFile), targetFile, { overwrite: true });
         });
     }
-
     if (taskFile.execution.PowerShell3) {
         fs.ensureDirSync(targetPowershellCommonDir);
-        collection.forEach(powershellFiles, (commonFile) => {
+        lodash_1.forEach(powershellFiles, function (commonFile) {
             var targetFile = path.join(targetPowershellCommonDir, commonFile);
             console.log(targetFile);
-            fs.copySync(path.join(powershellCommonFilesRoot, commonFile), targetFile, { clobber: true });
+            fs.copySync(path.join(powershellCommonFilesRoot, commonFile), targetFile, { overwrite: true });
         });
     }
-});
+});

dist/tasks.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs");
+var path = require("path");
+function getTasks(tasksRoot) {
+    if (!tasksRoot) {
+        var currentDirectory = process.cwd();
+        tasksRoot = path.join(currentDirectory, 'Tasks');
+    }
+    var tasks = fs.readdirSync(tasksRoot);
+    return tasks
+        .map(function (task) {
+        var taskDir = path.join(tasksRoot, task);
+        return {
+            directory: taskDir,
+            name: task
+        };
+    })
+        .filter(function (task) { return fs.statSync(task.directory).isDirectory(); });
+}
+exports.getTasks = getTasks;