Switch 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;
+    }
+});

package.js → dist/package.js

@@ -1,89 +1,73 @@
-var path = require('path');
-var exec = require('child_process').exec;
-
-var fs = require('fs-extra');
-var series = require("async/series");
-
-var extensionVersion = require('./extension-version.js');
-var tasks = require('./tasks.js');
-
+"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 = extensionVersion.getSemanticVersion();
-
+var version = extension_version_1.getSemanticVersion();
 var configuration = require(path.join(currentDirectory, 'configuration.json'));
-var createExtensionTasks = configuration.environments.map((env) => {
-
+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, { clobber: true, dereference: true });
-    fs.copySync(tasksDirectory, environmentTasksDirectory, { clobber: true, dereference: true });
-
+    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((taskDirectory) => {
+    if (extension.contributions === undefined) {
+        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)){
+                        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",
@@ -101,40 +85,31 @@ var createExtensionTasks = configuration.environments.map((env) => {
             fs.removeSync(taskDirectory.directory);
         }
     });
-
     fs.writeJsonSync(extensionFilePath, extension);
-
     var cmdline = 'tfx extension create --root "' + environmentDirectory
         + '" --manifest-globs "' + extensionFilePath
         + '" --output-path "' + environmentDirectory + '"';
-
-    return (done) => {
-        var child = exec(cmdline, {}, (error, stdout, stderr) => {
-
+    return function (done) {
+        var child = child_process_1.exec(cmdline, {}, function (error, stdout, stderr) {
             if (error) {
-                console.error(`exec error: ${error}`);
+                console.error("exec error: " + error);
                 done(error);
                 return;
             }
-
-            console.log(`tfx extension create done for ${env.Name}`);
-
+            console.log("tfx extension create done for " + env.Name);
             if (stdout) {
                 console.log(stdout);
             }
-
             if (stderr) {
                 console.error(stderr);
             }
-
             done();
         });
     };
 });
-
-series(createExtensionTasks, (err) => {
+async_1.series(createExtensionTasks, function (err) {
     if (err) {
         console.error("Failed to create extensions.");
         throw err;
     }
-});
+});