feat: add support for Angular v11 (#118) by @beeman

Author: beeman

src/deploy/actions.ts

@@ -1,7 +1,11 @@
-import { BuilderContext } from '@angular-devkit/architect';
+import {
+  BuilderContext,
+  targetFromTargetString,
+} from '@angular-devkit/architect';
 import { json, logging } from '@angular-devkit/core';
 
 import { Schema } from './schema';
+import { BuildTarget } from '../interfaces';
 
 export default async function deploy(
   engine: {
@@ -12,7 +16,7 @@ export default async function deploy(
     ) => Promise<void>;
   },
   context: BuilderContext,
-  projectRoot: string,
+  buildTarget: BuildTarget,
   options: Schema
 ) {
   if (options.noBuild) {
@@ -26,7 +30,7 @@ export default async function deploy(
       ? options.configuration
       : 'production';
     const overrides = {
-      ...(options.baseHref && { baseHref: options.baseHref })
+      ...(options.baseHref && { baseHref: options.baseHref }),
     };
 
     context.logger.info(
@@ -41,7 +45,7 @@ export default async function deploy(
       {
         target: 'build',
         project: context.target.project,
-        configuration
+        configuration,
       },
       overrides as json.JsonObject
     );
@@ -52,8 +56,17 @@ export default async function deploy(
     }
   }
 
+  const buildOptions = await context.getTargetOptions(
+    targetFromTargetString(buildTarget.name)
+  );
+  if (!buildOptions.outputPath || typeof buildOptions.outputPath !== 'string') {
+    throw new Error(
+      `Cannot read the output path option of the Angular project '${buildTarget.name}' in angular.json`
+    );
+  }
+
   await engine.run(
-    projectRoot,
+    buildOptions.outputPath,
     options,
     (context.logger as unknown) as logging.LoggerApi
   );

src/deploy/builder.ts

@@ -1,58 +1,27 @@
 import {
   BuilderContext,
   BuilderOutput,
-  createBuilder
+  createBuilder,
 } from '@angular-devkit/architect';
-import { asWindowsPath, experimental, normalize } from '@angular-devkit/core';
-import { NodeJsSyncHost } from '@angular-devkit/core/node';
-import os from 'os';
-import * as path from 'path';
 
 import * as engine from '../engine/engine';
 import deploy from './actions';
 import { Schema } from './schema';
 
 // Call the createBuilder() function to create a builder. This mirrors
 // createJobHandler() but add typings specific to Architect Builders.
-export default createBuilder<any>(
+export default createBuilder(
   async (options: Schema, context: BuilderContext): Promise<BuilderOutput> => {
-    try {
-      // The project root is added to a BuilderContext.
-      const root = normalize(context.workspaceRoot);
-      const workspace = new experimental.workspace.Workspace(
-        root,
-        new NodeJsSyncHost()
-      );
-      await workspace
-        .loadWorkspaceFromHost(normalize('angular.json'))
-        .toPromise();
-
-      if (!context.target) {
-        throw new Error('Cannot deploy the application without a target');
-      }
-
-      const targets = workspace.getProjectTargets(context.target.project);
-
-      if (
-        !targets ||
-        !targets.build ||
-        !targets.build.options ||
-        !targets.build.options.outputPath
-      ) {
-        throw new Error('Cannot find the project output directory');
-      }
+    if (!context.target) {
+      throw new Error('Cannot deploy the application without a target');
+    }
 
-      const isWin = os.platform() === 'win32';
-      const workspaceRoot = !isWin
-        ? workspace.root
-        : asWindowsPath(workspace.root);
+    const buildTarget = {
+      name: `${context.target.project}:build:production`,
+    };
 
-      await deploy(
-        engine,
-        context,
-        path.join(workspaceRoot, targets.build.options.outputPath),
-        options
-      );
+    try {
+      await deploy(engine, context, buildTarget, options);
     } catch (e) {
       context.logger.error('❌ An error occurred when trying to deploy:');
       context.logger.error(e.message);

src/interfaces.ts

@@ -2,3 +2,21 @@ export interface GHPages {
   publish(dir: string, options: any, callback: (error: any) => void);
   clean?(): void;
 }
+
+export interface WorkspaceProject {
+  projectType?: string;
+  architect?: Record<
+    string,
+    { builder: string; options?: Record<string, any> }
+  >;
+}
+
+export interface Workspace {
+  defaultProject?: string;
+  projects: Record<string, WorkspaceProject>;
+}
+
+export interface BuildTarget {
+  name: string;
+  options?: { [name: string]: any };
+}

src/ng-add.ts

@@ -1,35 +1,31 @@
-import { experimental, JsonParseMode, parseJson } from '@angular-devkit/core';
+import { JsonParseMode, parseJson } from '@angular-devkit/core';
 import {
   SchematicContext,
   SchematicsException,
-  Tree
+  Tree,
 } from '@angular-devkit/schematics';
+import { Workspace } from './interfaces';
 
-function getWorkspace(
-  host: Tree
-): { path: string; workspace: experimental.workspace.WorkspaceSchema } {
+function getWorkspace(host: Tree): { path: string; workspace: Workspace } {
   const possibleFiles = ['/angular.json', '/.angular.json'];
-  const path = possibleFiles.filter(path => host.exists(path))[0];
+  const path = possibleFiles.filter((path) => host.exists(path))[0];
 
   const configBuffer = host.read(path);
   if (configBuffer === null) {
     throw new SchematicsException(`Could not find angular.json`);
   }
   const content = configBuffer.toString();
 
-  let workspace: experimental.workspace.WorkspaceSchema;
+  let workspace: Workspace;
   try {
-    workspace = (parseJson(
-      content,
-      JsonParseMode.Loose
-    ) as {}) as experimental.workspace.WorkspaceSchema;
+    workspace = (parseJson(content, JsonParseMode.Loose) as {}) as Workspace;
   } catch (e) {
     throw new SchematicsException(`Could not parse angular.json: ` + e.message);
   }
 
   return {
     path,
-    workspace
+    workspace,
   };
 }
 interface NgAddOptions {
@@ -78,7 +74,7 @@ export const ngAdd = (options: NgAddOptions) => (
 
   project.architect['deploy'] = {
     builder: 'angular-cli-ghpages:deploy',
-    options: {}
+    options: {},
   };
 
   tree.overwrite(workspacePath, JSON.stringify(workspace, null, 2));