Integrate a new feature called "blacklisting" which allows you to explicitly specify routes that you wish to render inside the Route declaration itself ({server: true})

Author: clbond

package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-ssr",
-  "version": "0.10.7",
+  "version": "0.10.9",
   "description": "Angular server-side rendering implementation",
   "main": "build/index.js",
   "typings": "build/index.d.ts",

source/application/builder/builder.ts

@@ -57,6 +57,9 @@ export interface ApplicationBuilder<V> {
   // your application bootstraps.
   preboot(preboot?: PrebootConfiguration | boolean): void;
 
+  // Enable or disable blacklisting (all server-rendered routes must be marked with server: true
+  blacklist(blacklist?: boolean): void;
+
   // Configure how long we will wait for the application to stabilize itself before assuming it
   // never will stabilize and failing the render operation. For build-time rendering, this can
   // be a comfortably high number. For on-demand rendering, you should set this very low so

source/application/builder/impl/application.ts

@@ -34,14 +34,19 @@ export class ApplicationImpl<V, M> implements Application<V> {
         this.render.routes = renderableRoutes(await this.discoverRoutes());
       }
 
+      if (this.render.blacklist) { // route blacklisting
+        this.render.routes = this.render.routes.filter((r: Route & {server?: boolean}) => r.server === true);
+      }
+
       if (this.render.routes.length === 0) {
         observe.complete();
       }
       else {
-        this.renderToStream(this.render).subscribe(
-          observe.next.bind(observe),
-          observe.error.bind(observe),
-          observe.complete.bind(observe));
+        this.renderToStream(this.render)
+          .subscribe(
+            observe.next.bind(observe),
+            observe.error.bind(observe),
+            observe.complete.bind(observe));
       }
     });
   }

source/application/builder/impl/builder.ts

@@ -72,6 +72,12 @@ export class ApplicationBuilderImpl<V> implements ApplicationBuilder<V> {
     this.operation.preboot = config;
   }
 
+  blacklist(enable?: boolean) {
+    if (enable != null) {
+      this.operation.blacklist = enable;
+    }
+  }
+
   stateReader<R>(stateReader?: ApplicationStateReader<R>) {
     this.operation.stateReader = stateReader;
   }

source/application/operation.ts

@@ -72,6 +72,9 @@ export interface RenderOperation {
 
   // Do not fail the entire render process if some routes fail to render
   pessimistic?: boolean;
+
+  // Enable 'blacklist by default' route rendering behaviour (each route you wish to render must be marked with `server: true')
+  blacklist?: boolean;
 }
 
 // A render operation is an operation that forks into multiple concurrent suboperations,

source/bin/options/options.ts

@@ -1,6 +1,7 @@
 import {FileReference, PrebootConfiguration, Project, OutputProducer} from '../../index';
 
 export interface CommandLineOptions {
+  blacklist?: boolean;
   debug: boolean;
   output: OutputProducer;
   preboot: PrebootConfiguration | boolean;

source/bin/options/parse.ts

@@ -82,14 +82,20 @@ export const parseCommandLineOptions = (): CommandLineOptions => {
     preboot,
     project,
     templateDocument: template.content(),
-    webpack
+    webpack,
+    blacklist
   };
 };
 
+// Enable preboot integration
 let enablePreboot: boolean = false;
 
+// Inline CSS resources in the compiled HTML output
 let enableInline: boolean = true;
 
+// Enable 'blacklist by default' route rendering behaviour (each route you wish to render must be marked with `server: true')
+let blacklist: boolean = false;
+
 const createOutput = (options): OutputProducer =>
   options['ipc']
     ? createInterprocessOutput(options)
@@ -124,12 +130,15 @@ const parseCommandLine = () => {
     .option('-a, --application <applicationID>', 'Optional application ID if your CLI configuration contains multiple apps')
     .option('-P, --preboot [boolean | json-file | json-text]', 'Enable or disable preboot with optional configuration file or JSON text (otherwise automatically find the root element and use defaults)')
     .option('-i, --inline [boolean]', 'Inline of resources referenced in links')
-    .option('-I, --ipc', 'Send rendered documents to parent process through IPC instead of writing them to disk', false);
+    .option('-I, --ipc', 'Send rendered documents to parent process through IPC instead of writing them to disk', false)
+    .option('-b, --blacklist [boolean]', 'Blacklist all routes by default such that all routes which should be rendered must be specially marked with "server: true" in the route definition', false)
 
-  options.on('preboot', value => enablePreboot = value || true);
+  options.on('preboot', value => enablePreboot = value == null ? true : value);
 
   options.on('inline', value => enableInline = value == null ? true : value);
 
+  options.on('blacklist', value => blacklist = value == null ? false : value);
+
   return options.parse(process.argv);
 };
 

source/bin/render.ts

@@ -28,6 +28,8 @@ const builder = applicationBuilderFromSource(options.project, options.templateDo
 
 builder.preboot(options.preboot);
 
+builder.blacklist(options.blacklist);
+
 // Since we are doing rendering at build time, there is no need to enforce quick zone stabilization.
 // We can bump it up so that the process does not fail if an HTTP request takes a long time or
 // something along those lines prevents the app zone from stabilizing quickly.

source/route/extract.ts

@@ -2,7 +2,7 @@ import {NgModuleRef} from '@angular/core';
 
 import {Location} from '@angular/common';
 
-import {Router, Routes} from '@angular/router';
+import {Router, Routes, Route as AngularRoute} from '@angular/router';
 
 import {Route} from './route';
 import {ApplicationFallbackOptions} from '../static';
@@ -58,12 +58,12 @@ export const extractRoutesFromRouter = (router: Router, location: Location): Arr
 
   const flatten = (parent: Array<string>, routes: Routes): Array<Route> =>
     routes.reduce(
-      (prev, route) => {
+      (prev, route: AngularRoute & {server?: boolean}) => {
         const prepared = location.prepareExternalUrl(parent.concat(route.path || []).join('/'));
 
         const path = prepared.replace(/(^\.|\*\*?)/g, String()).split(/\//g).filter(v => v);
 
-        return prev.concat({path}, flatten(path, route.children || []));
+        return prev.concat({path, server: route.server}, flatten(path, route.children || []));
       },
       empty);
 
@@ -72,7 +72,7 @@ export const extractRoutesFromRouter = (router: Router, location: Location): Arr
 
 const singleRoute: Route = {path: []};
 
-export const extractRoutesFromModule = <M>(moduleRef: NgModuleRef<M>): Array<Route> => {
+const extractRoutesFromModule = <M>(moduleRef: NgModuleRef<M>): Array<Route> => {
   const router: Router = moduleRef.injector.get(Router, null);
   if (router == null) {
     return [singleRoute];
@@ -83,10 +83,6 @@ export const extractRoutesFromModule = <M>(moduleRef: NgModuleRef<M>): Array<Rou
   return extractRoutesFromRouter(router, location);
 };
 
-export const applicationRenderableRoutes = async <M>(operation: RouteExtractionOperation<M>): Promise<Array<Route>> => {
-  return renderableRoutes(await applicationRoutes(operation));
-};
-
 export const renderableRoutes = (routes: Array<Route>): Array<Route> => {
   const isParameter = (segment: string) => segment.startsWith(':');
 

source/route/route.ts

@@ -1,5 +1,6 @@
 export interface Route {
   path: Array<string>;
+  server?: boolean;
   parameters?: Map<string, string>;
   queryString?: string;
 }