feat(refoundry): publish a new package for refactoring.

This package isnt public or stable yet, so no documentation.

Also included fixes for:
- Fixes angular#2887.

Author: hansl

lib/packages.js

@@ -16,12 +16,19 @@ const packages =
       return { name: pkgName, root: path.join(packageRoot, pkgName) };
     })
     .reduce((packages, pkg) => {
-      let pkgJson = JSON.parse(fs.readFileSync(path.join(pkg.root, 'package.json'), 'utf8'));
+      const packageJsonPath = path.join(pkg.root, 'package.json');
+      let pkgJson;
+      try {
+        pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      } catch (e) {
+        console.error(`Error while parsing "${packageJsonPath}":\n${e.stack}`);
+        process.exit(1);
+      }
       let name = pkgJson['name'];
 
       packages[name] = {
         dist: path.join(__dirname, '../dist', pkg.name),
-        packageJson: path.join(pkg.root, 'package.json'),
+        packageJson: packageJsonPath,
         root: pkg.root,
         relative: path.relative(path.dirname(__dirname), pkg.root),
         main: path.resolve(pkg.root, 'src/index.ts')

package.json

@@ -76,7 +76,7 @@
     "less-loader": "^2.2.3",
     "loader-utils": "^0.2.16",
     "lodash": "^4.11.1",
-    "magic-string": "^0.16.0",
+    "magic-string": "^0.19.0",
     "markdown-it": "4.3.0",
     "markdown-it-terminal": "0.0.3",
     "minimatch": "^3.0.3",

packages/@ngtools/refactory/README.md

@@ -0,0 +1,39 @@
+# Angular Ahead-of-Time Webpack Plugin
+
+Webpack plugin that AoT compiles your Angular components and modules.
+
+## Usage
+In your webpack config, add the following plugin and loader:
+
+```typescript
+import {AotPlugin} from '@ngtools/webpack'
+
+exports = { /* ... */
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        loader: '@ngtools/webpack',
+      }
+    ]
+  },
+
+  plugins: [
+    new AotPlugin({
+      tsConfigPath: 'path/to/tsconfig.json',
+      entryModule: 'path/to/app.module#AppModule'
+    })
+  ]
+}
+```
+
+The loader works with the webpack plugin to compile your TypeScript. It's important to include both, and to not include any other TypeScript compiler loader.
+
+## Options
+
+* `tsConfigPath`. The path to the `tsconfig.json` file. This is required. In your `tsconfig.json`, you can pass options to the Angular Compiler with `angularCompilerOptions`.
+* `basePath`. Optional. The root to use by the compiler to resolve file paths. By default, use the `tsConfigPath` root.
+* `entryModule`. Optional if specified in `angularCompilerOptions`. The path and classname of the main application module. This follows the format `path/to/file#ClassName`.
+* `mainPath`. Optional if `entryModule` is specified. The `main.ts` file containing the bootstrap code. The plugin will use AST to determine the `entryModule`.
+* `skipCodeGeneration`. Optional, defaults to false. Disable code generation and do not refactor the code to bootstrap. This replaces `templateUrl: "string"` with `template: require("string")` (and similar for styles) to allow for webpack to properly link the resources.
+* `typeChecking`. Optional, defaults to true. Enable type checking through your application. This will slow down compilation, but show syntactic and semantic errors in webpack.

packages/@ngtools/refactory/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@ngtools/refactory",
+  "version": "0.0.1",
+  "description": "Library for refactoring angular 2 apps and code.",
+  "main": "./src/index.js",
+  "typings": "src/index.d.ts",
+  "license": "MIT",
+  "keywords": [
+    "ngtools",
+    "angular",
+    "refactor",
+    "typescript",
+    "library"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular/angular-cli.git"
+  },
+  "author": "angular",
+  "bugs": {
+    "url": "https://github.com/angular/angular-cli/issues"
+  },
+  "homepage": "https://github.com/angular/angular-cli/tree/master/packages/@ngtools/refactory",
+  "engines": {
+    "node": ">= 4.1.0",
+    "npm": ">= 3.0.0"
+  },
+  "dependencies": {
+    "magic-string": "^0.19.0",
+    "minimatch": "^3.0.0",
+    "source-map": "^0.5.6"
+  },
+  "peerDependencies": {
+    "typescript": "^2.0.2"
+  }
+}

packages/@ngtools/refactory/src/definitions.d.ts

@@ -0,0 +1,4 @@
+
+export interface Constructor<T> {
+  new (...args: any[]): T;
+}

packages/@ngtools/refactory/src/host.ts

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+
+export interface RefactoryHost {
+  readonly basePath: string;
+
+  stat(filePath: string): fs.Stats | null;
+
+  write(filePath: string, content: string): void;
+  read(filePath: string): string;
+  exists(filePath: string): boolean;
+
+  list(dirPath: string): string[];
+  isDirectory(dirPath: string): boolean;
+}
+
+
+export class InvalidRefactoryHost implements RefactoryHost {
+  get basePath(): string { throw new Error('Unimplemented: basePath'); }
+
+  write(filePath: string, content: string): void { throw new Error('Unimplemented: write'); }
+  read(filePath: string): string { throw new Error('Unimplemented: read'); }
+  exists(filePath: string): boolean { throw new Error('Unimplemented: exists'); }
+
+  list(dirPath: string): string[] { throw new Error('Unimplemented: list'); }
+  isDirectory(dirPath: string): boolean { throw new Error('Unimplemented: isDirectory'); }
+
+  stat(dirPath: string): fs.Stats { throw new Error('Unimplemented: stat'); }
+}
+
+
+export class NullRefactoryHost implements RefactoryHost {
+  constructor(public readonly basePath: string) {}
+
+  write(filePath: string, content: string): void { throw new Error('Unimplemented: write'); }
+  read(filePath: string): string { throw new Error('Unimplemented: read'); }
+  exists(filePath: string): boolean { return false; }
+
+  list(dirPath: string): string[] { return []; }
+  isDirectory(dirPath: string): boolean { return false; }
+
+  stat(dirPath: string): fs.Stats { return null; }
+}
+
+
+export class NodeRefactoryHost implements RefactoryHost {
+  constructor(private _basePath: string = '/') {}
+  private _normalize(p: string) {
+    return path.normalize(path.isAbsolute(p) ? p : path.join(this._basePath, p));
+  }
+
+  get basePath(): string { return this._basePath; }
+
+  stat(filePath: string): fs.Stats {
+    return fs.statSync(filePath);
+  }
+
+  write(filePath: string, content: string): void {
+    fs.writeFileSync(this._normalize(filePath), content, 'utf8');
+  }
+  read(filePath: string): string {
+    return fs.readFileSync(this._normalize(filePath), 'utf8');
+  }
+  exists(filePath: string): boolean {
+    return fs.existsSync(this._normalize(filePath));
+  }
+  list(dirPath: string): string[] {
+    return fs.readdirSync(this._normalize(dirPath));
+  }
+  isDirectory(dirPath: string): boolean {
+    return fs.statSync(this._normalize(dirPath)).isDirectory();
+  }
+}

packages/@ngtools/refactory/src/index.ts

@@ -0,0 +1,10 @@
+
+export {Refactory} from './refactory';
+
+// Hosts
+export {RefactoryHost, NullRefactoryHost, NodeRefactoryHost, InvalidRefactoryHost} from './host';
+export {VirtualRefactoryHost} from './utils/virtual_refactory_host'
+export * from './utils/host_adapters';
+
+// Languages
+export * from './language/index';

packages/@ngtools/refactory/src/language/file.ts

@@ -0,0 +1,23 @@
+import {Refactory} from '../refactory';
+import {StaticSymbol} from './symbol';
+
+export abstract class File {
+  constructor(protected _filePath: string, protected _refactory: Refactory) {}
+
+  get path() { return this._filePath; }
+  get refactory() { return this._refactory; }
+
+  abstract resolveSymbol(name: string): StaticSymbol;
+}
+
+export class NonExistentFile extends File {
+  resolveSymbol(name: string): StaticSymbol {
+    throw new Error(`Trying to resolve symbol "${name}" in non existent file "${this.path}".`);
+  }
+}
+
+export class UnknownFile extends File {
+  resolveSymbol(name: string): StaticSymbol {
+    throw new Error(`Trying to resolve symbol "${name}" in an unknown file language.`);
+  }
+}

packages/@ngtools/refactory/src/language/index.ts

@@ -0,0 +1,7 @@
+
+export * from './file';
+export * from './symbol';
+
+
+// Typescript
+export * from './typescript/index';

packages/@ngtools/refactory/src/language/symbol.ts

@@ -0,0 +1,11 @@
+import {File} from './file';
+
+
+export class StaticSymbol {
+  constructor(protected _name: string, protected _file: File) {}
+
+  get file() { return this._file; }
+  get name() { return this._name; }
+}
+
+export class UnknownStaticSymbol extends StaticSymbol {}