merge @ionic/ng-toolit and @ionic/schematics-angular

Author: imhoffd

.gitignore

@@ -0,0 +1,7 @@
+package-lock.json
+node_modules
+**/*.js
+**/*.d.ts
+!builders/**/schema.d.ts
+!schematics/**/schema.d.ts
+!schematics/*/files/**/*

.npmignore

@@ -0,0 +1,4 @@
+# having this file excludes .gitignore entries
+
+tsconfig.json
+tslint.js

.npmrc

@@ -0,0 +1 @@
+package-lock=false

README.md

@@ -1 +1,3 @@
-# angular-toolkit
+# @ionic/angular-toolkit
+
+ Angular Schematics and Builders for `@ionic/angular` apps.

builders.json

@@ -0,0 +1,14 @@
+{
+  "builders": {
+    "cordova-build": {
+      "class": "./builders/cordova-build",
+      "schema": "./builders/cordova-build/schema.json",
+      "description": "Perform a browser build with Cordova assets."
+    },
+    "cordova-serve": {
+      "class": "./builders/cordova-serve",
+      "schema": "./builders/cordova-serve/schema.json",
+      "description": "Run the dev-server with Cordova assets."
+    }
+  }
+}

builders/cordova-build/index.ts

@@ -0,0 +1,76 @@
+import { BuildEvent, Builder, BuilderConfiguration, BuilderContext } from '@angular-devkit/architect';
+import { BrowserBuilder } from '@angular-devkit/build-angular/src/browser';
+import { BrowserBuilderSchema } from '@angular-devkit/build-angular/src/browser/schema';
+import { getSystemPath, join, normalize } from '@angular-devkit/core';
+import { Observable, of } from 'rxjs';
+import { concatMap, tap } from 'rxjs/operators';
+
+import { CordovaBuildBuilderSchema } from './schema';
+
+export { CordovaBuildBuilderSchema };
+
+export class CordovaBuildBuilder implements Builder<CordovaBuildBuilderSchema> {
+  constructor(public context: BuilderContext) {}
+
+  run(builderConfig: BuilderConfiguration<CordovaBuildBuilderSchema>): Observable<BuildEvent> {
+    const browserBuilder = new BrowserBuilder(this.context); // TODO: shouldn't this use `architect.getBuilder()`?
+
+    return this.buildBrowserConfig(builderConfig.options).pipe(
+      concatMap(browserConfig => browserBuilder.run(browserConfig))
+    );
+  }
+
+  buildBrowserConfig(options: CordovaBuildBuilderSchema): Observable<BuilderConfiguration<BrowserBuilderSchema>> {
+    let browserConfig: BuilderConfiguration<BrowserBuilderSchema>;
+
+    return of(null).pipe(// tslint:disable-line:no-null-keyword
+      concatMap(() => this._getBrowserConfig(options)),
+      tap(config => browserConfig = config),
+      tap(() => this.prepareBrowserConfig(options, browserConfig.options)),
+      concatMap(() => of(browserConfig))
+    );
+  }
+
+  // Mutates browserOptions
+  prepareBrowserConfig(options: CordovaBuildBuilderSchema, browserOptions: BrowserBuilderSchema) {
+    const cordovaBasePath = normalize(options.cordovaBasePath ? options.cordovaBasePath : '.');
+
+    // We always need to output the build to `www` because it is a hard
+    // requirement of Cordova.
+    browserOptions.outputPath = join(cordovaBasePath, normalize('www'));
+
+    if (options.cordovaAssets) {
+      const platformWWWPath = join(cordovaBasePath, normalize(`platforms/${options.platform}/platform_www`));
+
+      // Add Cordova www assets that were generated whenever platform(s) and
+      // plugin(s) are added. This includes `cordova.js`,
+      // `cordova_plugins.js`, and all plugin JS.
+      browserOptions.assets.push({
+        glob: '**/*',
+        input: getSystemPath(platformWWWPath),
+        output: './',
+      });
+
+      // Register `cordova.js` as a global script so it is included in
+      // `index.html`.
+      browserOptions.scripts.push({
+        input: getSystemPath(join(platformWWWPath, normalize('cordova.js'))),
+        bundleName: 'cordova',
+        lazy: false,
+      });
+    }
+  }
+
+  protected _getBrowserConfig(options: CordovaBuildBuilderSchema): Observable<BuilderConfiguration<BrowserBuilderSchema>> {
+    const { architect } = this.context;
+    const [ project, target, configuration ] = options.browserTarget.split(':');
+    const browserTargetSpec = { project, target, configuration, overrides: {} };
+    const builderConfig = architect.getBuilderConfiguration<BrowserBuilderSchema>(browserTargetSpec);
+
+    return architect.getBuilderDescription(builderConfig).pipe(
+      concatMap(browserDescription => architect.validateBuilderOptions(builderConfig, browserDescription))
+    );
+  }
+}
+
+export default CordovaBuildBuilder;

builders/cordova-build/schema.d.ts

@@ -0,0 +1,7 @@
+export interface CordovaBuildBuilderSchema {
+  browserTarget: string;
+  platform: string;
+  cordovaBasePath?: string;
+  sourceMap?: boolean;
+  cordovaAssets?: boolean;
+}

builders/cordova-build/schema.json

@@ -0,0 +1,33 @@
+{
+  "title": "Cordova build for Ionic",
+  "description": "Options for Cordova build for Ionic.",
+  "type": "object",
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "Target to build."
+    },
+    "platform": {
+      "type": "string",
+      "description": "Cordova platform to use during build."
+    },
+    "cordovaBasePath": {
+      "type": "string",
+      "description": "Path to cordova directory"
+    },
+    "sourceMap":  {
+      "type": "boolean",
+      "description": "Create source-map file"
+    },
+    "cordovaAssets": {
+      "type": "boolean",
+      "description": "Bundle Cordova assets with build",
+      "default": true
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "browserTarget",
+    "platform"
+  ]
+}

builders/cordova-serve/index.ts

@@ -0,0 +1,56 @@
+import { BuildEvent, Builder, BuilderConfiguration, BuilderContext, BuilderDescription } from '@angular-devkit/architect';
+import { BrowserBuilderSchema } from '@angular-devkit/build-angular/src/browser/schema';
+import { DevServerBuilder, DevServerBuilderOptions } from '@angular-devkit/build-angular/src/dev-server';
+import { Path, virtualFs } from '@angular-devkit/core';
+import * as ζfs from 'fs';
+import { Observable, of } from 'rxjs';
+import { concatMap, tap } from 'rxjs/operators';
+
+import { CordovaBuildBuilder, CordovaBuildBuilderSchema } from '../cordova-build';
+
+import { CordovaServeBuilderSchema } from './schema';
+
+export class CordovaServeBuilder implements Builder<CordovaServeBuilderSchema> {
+  constructor(public context: BuilderContext) {}
+
+  run(builderConfig: BuilderConfiguration<CordovaServeBuilderSchema>): Observable<BuildEvent> {
+    const [ project, target, configuration ] = builderConfig.options.devServerTarget.split(':');
+    const { port, host, proxyConfig } = builderConfig.options;
+    const devServerTargetSpec = { project, target, configuration, overrides: { port, host, proxyConfig } };
+    const devServerBuilderConfig = this.context.architect.getBuilderConfiguration<DevServerBuilderOptions>(devServerTargetSpec);
+
+    let devServerDescription: BuilderDescription;
+
+    return this.context.architect.getBuilderDescription(devServerBuilderConfig).pipe(
+      tap(description => devServerDescription = description),
+      concatMap(() => this.context.architect.validateBuilderOptions(devServerBuilderConfig, devServerDescription)),
+      concatMap(() => of(new CordovaDevServerBuilder(this.context, builderConfig.options))),
+      // concatMap(() => of(this.context.architect.getBuilder(devServerDescription, this.context))),
+      concatMap(builder => builder.run(devServerBuilderConfig))
+    );
+  }
+}
+
+class CordovaDevServerBuilder extends DevServerBuilder {
+  constructor(context: BuilderContext, public cordovaServeOptions: CordovaServeBuilderSchema) {
+    super(context);
+  }
+
+  // run(builderConfig: BuilderConfiguration</* DevServerBuilderOptions */any>): Observable<BuildEvent> {
+  //   return super.run(builderConfig);
+  // }
+
+  buildWebpackConfig(root: Path, projectRoot: Path, host: virtualFs.Host<ζfs.Stats>, browserOptions: BrowserBuilderSchema) {
+    const { platform } = this.cordovaServeOptions;
+    const [ project, target, configuration ] = this.cordovaServeOptions.cordovaBuildTarget.split(':');
+    const cordovaBuildTargetSpec = { project, target, configuration, overrides: { platform } };
+    const cordovaBuildTargetConfig = this.context.architect.getBuilderConfiguration<CordovaBuildBuilderSchema>(cordovaBuildTargetSpec);
+
+    const builder = new CordovaBuildBuilder(this.context);
+    builder.prepareBrowserConfig(cordovaBuildTargetConfig.options, browserOptions);
+
+    return super.buildWebpackConfig(root, projectRoot, host, browserOptions);
+  }
+}
+
+export default CordovaServeBuilder;

builders/cordova-serve/schema.d.ts

@@ -0,0 +1,10 @@
+export interface CordovaServeBuilderSchema {
+  cordovaBuildTarget: string;
+  devServerTarget: string;
+  platform: string;
+  port?: number;
+  host?: string;
+  proxyConfig?: string;
+  cordovaBasePath?: string;
+  sourceMap?: boolean;
+}