Enable npm as package manager for ns applications

Author: Fatme Havaluova

.idea/nativescript-cli.iml

@@ -50,3 +50,7 @@ $injector.require("mobilePlatformsCapabilities", "./mobile-platforms-capabilitie
 $injector.require("commandsServiceProvider", "./providers/commands-service-provider");
 
 $injector.require("logcatPrinter", "./providers/logcat-printer");
+
+$injector.require("broccoliBuilder", "./tools/broccoli/builder");
+$injector.require("nodeModulesTree", "./tools/broccoli/trees/node-modules-tree");
+$injector.require("broccoliPluginWrapper", "./tools/broccoli/broccoli-plugin-wrapper");

lib/bootstrap.ts

@@ -3,6 +3,10 @@
 export var APP_FOLDER_NAME = "app";
 export var APP_RESOURCES_FOLDER_NAME = "App_Resources";
 export var PROJECT_FRAMEWORK_FOLDER_NAME = "framework";
+export var NATIVESCRIPT_KEY_NAME = "nativescript";
+export var NODE_MODULES_FOLDER_NAME = "node_modules";
+export var PACKAGE_JSON_FILE_NAME = "package.json";
+export var NODE_MODULE_CACHE_PATH_KEY_NAME = "node-modules-cache-path";
 
 export class ReleaseType {
 	static MAJOR = "major";

lib/constants.ts

@@ -3,5 +3,6 @@ declare module "shelljs" {
 	function cp(arg: string, sourcePath: string[], destinationPath: string): void;
 	function sed(arg: string, oldValue: any, newValue: string, filePath: string): void;
 	function mv(source: string[], destination: string): void;
+	function rm(option: string, filePath: string): void;
 	function grep(what: any, where: string): any;
 }

lib/definitions/shelljs.d.ts

@@ -9,6 +9,8 @@ import helpers = require("./../common/helpers");
 import semver = require("semver");
 
 export class PlatformService implements IPlatformService {
+	private static TNS_MODULES_FOLDER_NAME = "tns_modules";
+	
 	constructor(private $devicesServices: Mobile.IDevicesServices,
 		private $errors: IErrors,
 		private $fs: IFileSystem,
@@ -19,7 +21,8 @@ export class PlatformService implements IPlatformService {
 		private $projectDataService: IProjectDataService,
 		private $prompter: IPrompter,
 		private $commandsService: ICommandsService,
-		private $options: IOptions) { }
+		private $options: IOptions,
+		private $broccoliBuilder: IBroccoliBuilder) { }
 
 	public addPlatforms(platforms: string[]): IFuture<void> {
 		return (() => {
@@ -169,14 +172,16 @@ export class PlatformService implements IPlatformService {
 					files.push(filePath);
 				}
 			});
-
 			this.processPlatformSpecificFiles(platform, files).wait();
 
-			this.$logger.out("Project successfully prepared");
+			// Process node_modules folder
+			var tnsModulesDestinationPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, PlatformService.TNS_MODULES_FOLDER_NAME);
+			this.$broccoliBuilder.prepareNodeModules(tnsModulesDestinationPath, this.$projectData.projectDir).wait();
 
+			this.$logger.out("Project successfully prepared");
 		}).future<void>()();
 	}
-
+		
 	public buildPlatform(platform: string): IFuture<void> {
 		return (() => {
 			platform = platform.toLowerCase();

lib/services/platform-service.ts

@@ -0,0 +1,20 @@
+///<reference path="../../.d.ts"/>
+"use strict";
+
+import broccoliPluginWrapperLib = require("./broccoli-plugin-wrapper");
+
+/**
+ * Makes writing plugins easy.
+ *
+ * Factory method that takes a class that implements the BroccoliPluginWrapper interface and returns
+ * an instance of BroccoliTree.
+ *
+ * @param pluginClass
+ * @returns {BroccoliPluginWrapper}
+ */
+
+type BroccoliPluginWrapperFactory = (inputTree: BroccoliTree, ...options: any[]) => BroccoliTree;
+
+export function wrapBroccoliPlugin(pluginClass: any): BroccoliPluginWrapperFactory {
+  return function() { return new broccoliPluginWrapperLib.BroccoliPluginWrapper(pluginClass, arguments); };
+}

lib/tools/broccoli/broccoli-plugin-wrapper-factory.ts

@@ -0,0 +1,59 @@
+///<reference path="../../.d.ts"/>
+"use strict";
+
+import fs = require('fs');
+import path = require('path');
+import {TreeDiffer} from './tree-differ';
+
+export class BroccoliPluginWrapper implements BroccoliTree {
+  treeDiffer: TreeDiffer;
+  wrappedPlugin: IBroccoliPlugin = null;
+  inputTree: any = null;
+  description: string = null;
+  absoluteOutputPath: string = null;
+  treeRootDirName: string = null;
+  projectDir: string = null;
+  $injector: IInjector = null;
+
+  // props monkey-patched by broccoli builder:
+  inputPath: string = null;
+  cachePath: string = null;
+  outputPath: string = null;
+
+  constructor(private pluginClass: any, wrappedPluginArguments: any) { 
+      this.inputTree = wrappedPluginArguments[0];
+      this.description = this.pluginClass.name;
+      this.absoluteOutputPath = wrappedPluginArguments[1];
+      this.treeRootDirName = wrappedPluginArguments[2];
+      this.projectDir = wrappedPluginArguments[3];
+      this.$injector = $injector.resolve("injector");
+  }
+
+  rebuild(): void {
+      try {
+        this.init();
+  
+        let diffResult = this.treeDiffer.diffTree(this.absoluteOutputPath, this.treeRootDirName);        
+        this.wrappedPlugin.rebuild(diffResult);
+  
+      } catch (e) {
+        e.message = `[${this.description}]: ${e.message}`;
+        throw e;
+      }
+  }
+
+  private init() {
+      this.treeDiffer = new TreeDiffer(this.inputPath);
+      this.wrappedPlugin = this.$injector.resolve(this.pluginClass, 
+        { inputPath: this.inputPath, 
+          cachePath: this.cachePath, 
+          outputRoot: this.absoluteOutputPath, 
+          projectDir: this.projectDir });
+  }
+
+  cleanup() {
+    if (this.wrappedPlugin.cleanup) {
+      this.wrappedPlugin.cleanup();
+    }
+  }
+}

lib/tools/broccoli/broccoli-plugin-wrapper.ts

@@ -0,0 +1,170 @@
+/// <reference path="../../.d.ts" />
+
+
+interface BroccoliTree {
+  /**
+   * Contains the fs path for the input tree when the plugin takes only one input tree.
+   *
+   * For plugins that take multiple trees see the `inputPaths` property.
+   *
+   * This property is set just before the first rebuild and doesn't change afterwards.
+   */
+  inputPath: string;
+
+  /**
+   * Contains the array of fs paths for input trees.
+   *
+   * For plugins that take only one input tree, it might be more convenient to use the `inputPath`
+   *property instead.
+   *
+   * This property is set just before the first rebuild and doesn't change afterwards.
+   *
+   * If the inputPath is outside of broccoli's temp directory, then it's lifetime is not managed by
+   *the builder.
+   * If the inputPath is within broccoli's temp directory it is an outputPath (and output directory)
+   *of another plugin.
+   * This means that while the `outputPath` doesn't change, the underlying directory is frequently
+   *recreated.
+   */
+  inputPaths?: string[];
+
+  /**
+   * Contains the fs paths for the output trees.
+   *
+   * This property is set just before the first rebuild and doesn't change afterwards.
+   *
+   * The underlying directory is also created by the builder just before the first rebuild.
+   * This directory is destroyed and recreated upon each rebuild.
+   */
+  outputPath?: string;
+
+  /**
+   * Contains the fs paths for a cache directory available to the plugin.
+   *
+   * This property is set just before the first rebuild and doesn't change afterwards.
+   *
+   * The underlying directory is also created by the builder just before the first rebuild.
+   * The lifetime of the directory is associated with the lifetime of the plugin.
+   */
+  cachePath?: string;
+
+  inputTree?: BroccoliTree;
+  inputTrees?: BroccoliTree[];
+
+  /**
+   * Description or name of the plugin used for reporting.
+   *
+   * If missing `tree.constructor.name` is usually used instead.
+   */
+  description?: string;
+
+  rebuild(): any;
+  cleanup(): void;
+}
+
+
+interface OldBroccoliTree {
+  read?(readTree: (tree: BroccoliTree) => any): any;
+}
+
+
+
+interface BroccoliBuilder {
+  /**
+   * Triggers a build and returns a promise for the build result
+   */
+  build(): IFuture<BuildResult>;
+
+
+  /**
+   * Cleans up the whole build tree by calling `.cleanup()` method on all trees that are part of the
+   * pipeline.
+   */
+  cleanup(): IFuture<any>;
+}
+
+
+interface BuildResult {
+  /**
+   * Directory that contains result of the build.
+   *
+   * This directory will contains symlinks, so it is not safe to just use it as is.
+   *
+   * Use `copy-dereference` npm package to create a safe-to-use replica of the build artifacts.
+   */
+  directory: string;
+
+
+  /**
+   * The DAG (graph) of all trees in the build pipeline.
+   */
+  graph: BroccoliNode;
+
+  /**
+   * Total time it took to make the build.
+   */
+  totalTime: number;
+}
+
+
+
+interface BroccoliNode {
+  ///**
+  // * Id of the current node
+  // */
+  // id: number; //only in master
+
+  /**
+   * Time spent processing the current node during a single rebuild.
+   */
+  selfTime: number;
+
+
+  /**
+   * Time spent processing the current node and its subtrees during a single rebuild.
+   */
+  totalTime: number;
+
+
+  /**
+   * Tree associated with the current node.
+   */
+  tree: BroccoliTree;
+
+
+  /**
+   * Child nodes with references to trees that are input for the tree of the current node.
+   */
+  subtrees: BroccoliNode[];
+
+
+  /**
+   * Parent nodes with references to trees that are consume the output of processing the current
+   * tree.
+   */
+  parents: BroccoliNode[];
+
+
+  /**
+   * Path to the directory containing the output of processing the current tree.
+   */
+  directory: string;
+}
+
+interface IBroccoliBuilder {
+   prepareNodeModules(outputPath: string,  projectDir: string): IFuture<void>;
+}
+
+interface IDiffResult {
+  changedDirectories: string[];
+  removedDirectories: string[];
+}
+
+interface IBroccoliPlugin {
+  rebuild(diff: IDiffResult): any;
+  cleanup? () : void;
+}
+
+interface INodeModulesTree {
+   makeNodeModulesTree(absoluteOutputPath: string, projectDir: string): any;
+}

lib/tools/broccoli/broccoli.d.ts

@@ -0,0 +1,63 @@
+///<reference path="../../.d.ts"/>
+"use strict";
+
+let broccoli = require('broccoli');
+let path = require('path');
+import Future = require("fibers/future");
+import {TreeDiffer} from './tree-differ';
+import destCopy = require('./node-modules-dest-copy');
+
+export class Builder implements IBroccoliBuilder {
+  constructor(private $fs: IFileSystem,
+    private $nodeModulesTree: INodeModulesTree,
+    private $projectDataService: IProjectDataService,
+    private $logger: ILogger) { }
+  
+  public prepareNodeModules(absoluteOutputPath: string, projectDir: string): IFuture<void> {
+    return (() => {
+      // TODO: figure out a better way for doing this
+      this.$projectDataService.initialize(projectDir);
+      let cachedNodeModulesPath = this.$projectDataService.getValue("node-modules-cache-path").wait();
+      if (cachedNodeModulesPath && this.$fs.exists(cachedNodeModulesPath).wait()) {
+        let diffTree = new TreeDiffer(cachedNodeModulesPath);
+        let diffTreeResult = diffTree.diffTree(path.join(projectDir, absoluteOutputPath, "node_modules"));
+        
+        if(diffTreeResult.changedDirectories.length > 0 || diffTreeResult.removedDirectories.length > 0) {
+          this.rebuildNodeModulesTree(absoluteOutputPath, projectDir).wait();
+        }
+      } else { 
+         this.rebuildNodeModulesTree(absoluteOutputPath, projectDir).wait();
+      }
+    }).future<void>()();
+  }
+
+  private rebuildNodeModulesTree(outputPath: string, projectDir: string): IFuture<any> {
+    let nodeModulesBuilder = this.makeNodeModulesBuilder(outputPath, projectDir);
+    return this.rebuild(nodeModulesBuilder);
+  }
+
+  private makeNodeModulesBuilder(outputPath: string, projectDir: string): BroccoliBuilder {
+    let tree = this.$nodeModulesTree.makeNodeModulesTree(outputPath, projectDir);
+    return new broccoli.Builder(tree);
+  }
+
+  private rebuild(builder: any): IFuture<any> {
+    let future = new Future<any>();
+    builder.build()
+        .then((result: any) => {
+              future.return(result);
+        })
+        .catch((err: any) => {
+              if(err.file) {
+                this.$logger.error("File: " + err.file); 
+              }
+              if(err.statck) {
+                this.$logger.error(err.stack);
+              }
+              future.throw(err.toString());                        
+        });
+    
+    return future;
+  }
+}
+$injector.register("broccoliBuilder", Builder);