问Angular 2 AOT编译错误-创建路由时对象的新实例

EN

 export class RouteBuilder {
  private routeConfigBuilders: RouteConfigBuilder[] = [];
  private currentRouteConfig: RouteConfigBuilder;

  public add(routeConfigBuilder: IRouteConfigBuilder): RouteBuilder {
    this.routeConfigBuilders.push(RouteConfigBuilder.get(routeConfigBuilder));
    return this;
  }

  public build(): Routes {
    const routes: Routes = [];
    let routeConfig: IRouteConfig;

    for (const routeConfigBuilder of this.routeConfigBuilders) {
      routeConfig = routeConfigBuilder.build();
      routes.push(this.routeConfigToRoute(routeConfig));
    }

    return routes;
  }

  private routeConfigToRoute(routeConfig: IRouteConfig): Route {
    const route: Route = {};

    for (const prop in routeConfig) {
      if (routeConfig[prop]
        || ((typeof routeConfig[prop] === 'string')
          && (routeConfig[prop] === ''))
      ) {

        if ((prop === 'loadChildren')
          && !((typeof routeConfig[prop] === 'string'))
        ) {
          route[prop] = () => routeConfig[prop];
        } else if (prop === 'addChildrenCallback') {
          route['children'] = routeConfig[prop]().build();
        } else {
          route[prop] = routeConfig[prop];
        }
      }
    }

    return route;
  }

}

export function appRoutes() {
  return new RouteBuilder()
    // always first
    .add({
      path: '',
      redirectTo: 'dashboard',
      pathMatch: 'full'
    })

    .add({
      path: '',
      loadChildren: AuthModule
    })

    .add({
      path: '',
      loadChildren: FeaturesModule,
      canActivate: [AuthGuard]
    })

    // always last
    .add({
      path: '**',
      component: PageNotFoundComponent
    })

    .build();
}


@NgModule({
  imports: [
    RouterModule.forRoot(appRoutes())
  ],
  exports: [
    RouterModule
  ]
})
export class AppRoutingModule { }

import { Type } from '@angular/core';


interface IRouteInfo {
  title: string;
  withoutNavigate?: boolean;
}

interface IRouteData {
  info: IRouteInfo;
}

export interface IRouteConfig {
  path: string;
  component?: Type<any>;
  loadChildren?: Type<any>;
  data?: IRouteData;
  addChildrenCallback?: Function;
  redirectTo?: string;
  pathMatch?: string;
  canActivate?: any[];
}

export interface IRouteConfigBuilder {
  path: string;
  component?: Type<any>;
  loadChildren?: any;
  title?: string;
  withoutNavigate?: boolean;
  addChildrenCallback?: Function;
  redirectTo?: string;
  pathMatch?: string;
  canActivate?: any[];
}

export class RouteConfigBuilder {
  private routeConfigBuilder: IRouteConfigBuilder;

  public static get(routeConfigBuilder: IRouteConfigBuilder) {
    return new RouteConfigBuilder(routeConfigBuilder);
  }

  constructor(routeConfigBuilder: IRouteConfigBuilder) {
    this.routeConfigBuilder = routeConfigBuilder;
  }

  public build(): IRouteConfig {
    const routeConfig: IRouteConfig = {
      path: this.routeConfigBuilder.path,
      component: this.routeConfigBuilder.component,
      loadChildren: this.routeConfigBuilder.loadChildren,
      addChildrenCallback: this.routeConfigBuilder.addChildrenCallback,
      redirectTo: this.routeConfigBuilder.redirectTo,
      pathMatch: this.routeConfigBuilder.pathMatch,
      canActivate: this.routeConfigBuilder.canActivate
    };

    if (this.canBuildData()) {
      routeConfig.data = {
        info: {
          title: this.routeConfigBuilder.title,
          withoutNavigate: this.routeConfigBuilder.withoutNavigate
        }
      };
    }

    return routeConfig;
  }

  private canBuildData(): boolean {
    return (this.routeConfigBuilder.title || this.routeConfigBuilder.withoutNavigate) ? true : false;
  }
}