chore(tslint): prefer-const

Author: christopherthielen

src/directives/uiSref.ts

@@ -146,20 +146,20 @@ export class UISref implements OnChanges {
   }
 
   private update() {
-    let $state = this._router.stateService;
+    const $state = this._router.stateService;
     if (this._emit) {
-      let newTarget = $state.target(this.state, this.params, this.getOptions());
+      const newTarget = $state.target(this.state, this.params, this.getOptions());
       this.targetState$.next(newTarget);
     }
 
     if (this._anchorUISref) {
-      let href = $state.href(this.state, this.params, this.getOptions());
+      const href = $state.href(this.state, this.params, this.getOptions());
       this._anchorUISref.update(href);
     }
   }
 
   getOptions() {
-    let defaultOpts: TransitionOptions = {
+    const defaultOpts: TransitionOptions = {
       relative: this._parent && this._parent.context && this._parent.context.name,
       inherit: true ,
       source: "sref"

src/directives/uiSrefStatus.ts

@@ -55,17 +55,17 @@ const inactiveStatus: SrefStatus = {
  */
 const pathMatches = (target: TargetState): Predicate<PathNode[]> => {
   if (!target.exists()) return () => false;
-  let state: StateObject = target.$state();
-  let targetParamVals = target.params();
-  let targetPath: PathNode[] = PathUtils.buildPath(target);
-  let paramSchema: Param[] = targetPath.map(node => node.paramSchema)
+  const state: StateObject = target.$state();
+  const targetParamVals = target.params();
+  const targetPath: PathNode[] = PathUtils.buildPath(target);
+  const paramSchema: Param[] = targetPath.map(node => node.paramSchema)
       .reduce(unnestR, [])
       .filter((param: Param) => targetParamVals.hasOwnProperty(param.id));
 
   return (path: PathNode[]) => {
-    let tailNode = tail(path);
+    const tailNode = tail(path);
     if (!tailNode || tailNode.state !== state) return false;
-    let paramValues = PathUtils.paramValues(path);
+    const paramValues = PathUtils.paramValues(path);
     return Param.equals(paramSchema, paramValues, targetParamVals);
   };
 };
@@ -93,9 +93,9 @@ function getSrefStatus(event: TransEvt, srefTarget: TargetState): SrefStatus {
   const pathMatchesTarget = pathMatches(srefTarget);
   const tc = event.trans.treeChanges();
 
-  let isStartEvent = event.evt === 'start';
-  let isSuccessEvent = event.evt === 'success';
-  let activePath: PathNode[] = isSuccessEvent ? tc.to : tc.from;
+  const isStartEvent = event.evt === 'start';
+  const isSuccessEvent = event.evt === 'success';
+  const activePath: PathNode[] = isSuccessEvent ? tc.to : tc.from;
 
   const isActive = () =>
       spreadToSubPaths([], activePath)
@@ -208,12 +208,12 @@ export class UISrefStatus {
   ngAfterContentInit() {
     // Map each transition start event to a stream of:
     // start -> (success|error)
-    let transEvents$: Observable<TransEvt> = switchMap.call(this._globals.start$, (trans: Transition) => {
+    const transEvents$: Observable<TransEvt> = switchMap.call(this._globals.start$, (trans: Transition) => {
       const event = (evt: string) => ({evt, trans} as TransEvt);
 
-      let transStart$ = of(event("start"));
-      let transResult = trans.promise.then(() => event("success"), () => event("error"));
-      let transFinish$ = fromPromise(transResult);
+      const transStart$ = of(event("start"));
+      const transResult = trans.promise.then(() => event("success"), () => event("error"));
+      const transFinish$ = fromPromise(transResult);
 
       return concat.call(transStart$, transFinish$);
     });
@@ -224,15 +224,15 @@ export class UISrefStatus {
     this._srefs$ = new BehaviorSubject(this._srefs.toArray());
     this._srefChangesSub = this._srefs.changes.subscribe(srefs => this._srefs$.next(srefs));
 
-    let targetStates$: Observable<TargetState[]> =
+    const targetStates$: Observable<TargetState[]> =
         switchMap.call(this._srefs$, (srefs: UISref[]) =>
             combineLatest<TargetState[]>(srefs.map(sref => sref.targetState$)));
 
     // Calculate the status of each UISref based on the transition event.
     // Reduce the statuses (if multiple) by or-ing each flag.
     this._subscription = switchMap.call(transEvents$, (evt: TransEvt) => {
       return map.call(targetStates$, (targets: TargetState[]) => {
-        let statuses: SrefStatus[] = targets.map(target => getSrefStatus(evt, target));
+        const statuses: SrefStatus[] = targets.map(target => getSrefStatus(evt, target));
         return statuses.reduce(mergeSrefStatus);
       });
     }).subscribe(this._setStatus.bind(this));

src/directives/uiView.ts

@@ -205,15 +205,15 @@ export class UIView {
   private _applyUpdatedConfig(config: Ng2ViewConfig) {
     this._uiViewData.config = config;
     // Create the Injector for the routed component
-    let context = new ResolveContext(config.path);
-    let componentInjector = this._getComponentInjector(context);
+    const context = new ResolveContext(config.path);
+    const componentInjector = this._getComponentInjector(context);
 
     // Get the component class from the view declaration. TODO: allow promises?
-    let componentClass = config.viewDecl.component;
+    const componentClass = config.viewDecl.component;
 
     // Create the component
-    let compFactoryResolver = componentInjector.get(ComponentFactoryResolver);
-    let compFactory = compFactoryResolver.resolveComponentFactory(componentClass);
+    const compFactoryResolver = componentInjector.get(ComponentFactoryResolver);
+    const compFactory = compFactoryResolver.resolveComponentFactory(componentClass);
     this._componentRef = this._componentTarget.createComponent(compFactory, undefined, componentInjector);
 
     // Wire resolves to @Input()s
@@ -232,15 +232,15 @@ export class UIView {
    */
   private _getComponentInjector(context: ResolveContext): Injector {
     // Map resolves to "useValue: providers"
-    let resolvables = context.getTokens().map(token => context.getResolvable(token)).filter(r => r.resolved);
-    let newProviders = resolvables.map(r => ({ provide: r.token, useValue: r.data }));
+    const resolvables = context.getTokens().map(token => context.getResolvable(token)).filter(r => r.resolved);
+    const newProviders = resolvables.map(r => ({ provide: r.token, useValue: r.data }));
 
-    let parentInject = { context: this._uiViewData.config.viewDecl.$context, fqn: this._uiViewData.fqn };
+    const parentInject = { context: this._uiViewData.config.viewDecl.$context, fqn: this._uiViewData.fqn };
     newProviders.push({ provide: UIView.PARENT_INJECT, useValue: parentInject });
 
-    let parentComponentInjector = this.viewContainerRef.injector;
-    let moduleInjector = context.getResolvable(NATIVE_INJECTOR_TOKEN).data;
-    let mergedParentInjector = new MergeInjector(moduleInjector, parentComponentInjector);
+    const parentComponentInjector = this.viewContainerRef.injector;
+    const moduleInjector = context.getResolvable(NATIVE_INJECTOR_TOKEN).data;
+    const mergedParentInjector = new MergeInjector(moduleInjector, parentComponentInjector);
 
     return ReflectiveInjector.resolveAndCreate(newProviders, mergedParentInjector);
   }

src/lazyLoad/lazyLoadNgModule.ts

@@ -132,34 +132,34 @@ export function loadModuleFactory(moduleToLoad: NgModuleToLoad, ng2Injector: Inj
  * @internalapi
  */
 export function applyNgModule(transition: Transition, ng2Module: NgModuleRef<any>, parentInjector: Injector, lazyLoadState: StateDeclaration): LazyLoadResult {
-  let injector = ng2Module.injector;
-  let uiRouter: UIRouter = injector.get(UIRouter);
-  let registry = uiRouter.stateRegistry;
+  const injector = ng2Module.injector;
+  const uiRouter: UIRouter = injector.get(UIRouter);
+  const registry = uiRouter.stateRegistry;
 
-  let originalName = lazyLoadState.name;
-  let originalState = registry.get(originalName);
+  const originalName = lazyLoadState.name;
+  const originalState = registry.get(originalName);
   // Check if it's a future state (ends with .**)
-  let isFuture = /^(.*)\.\*\*$/.exec(originalName);
+  const isFuture = /^(.*)\.\*\*$/.exec(originalName);
   // Final name (without the .**)
-  let replacementName = isFuture && isFuture[1];
+  const replacementName = isFuture && isFuture[1];
 
-  let newRootModules = multiProviderParentChildDelta(parentInjector, injector, UIROUTER_ROOT_MODULE)
+  const newRootModules = multiProviderParentChildDelta(parentInjector, injector, UIROUTER_ROOT_MODULE)
       .reduce(uniqR, []) as RootModule[];
-  let newChildModules= multiProviderParentChildDelta(parentInjector, injector, UIROUTER_MODULE_TOKEN)
+  const newChildModules= multiProviderParentChildDelta(parentInjector, injector, UIROUTER_MODULE_TOKEN)
       .reduce(uniqR, []) as StatesModule[];
 
   if (newRootModules.length) {
     console.log(newRootModules); // tslint:disable-line:no-console
     throw new Error('Lazy loaded modules should not contain a UIRouterModule.forRoot() module');
   }
 
-  let newStateObjects: StateObject[] = newChildModules
+  const newStateObjects: StateObject[] = newChildModules
       .map(module => applyModuleConfig(uiRouter, injector, module))
       .reduce(unnestR, [])
       .reduce(uniqR, []);
 
   if (isFuture) {
-    let replacementState = registry.get(replacementName);
+    const replacementState = registry.get(replacementName);
     if (!replacementState || replacementState === originalState) {
       throw new Error(`The Future State named '${originalName}' lazy loaded an NgModule. ` +
           `The lazy loaded NgModule must have a state named '${replacementName}' ` +
@@ -172,7 +172,7 @@ export function applyNgModule(transition: Transition, ng2Module: NgModuleRef<any
   // Supply the newly loaded states with the Injector from the lazy loaded NgModule.
   // If a tree of states is lazy loaded, only add the injector to the root of the lazy loaded tree.
   // The children will get the injector by resolve inheritance.
-  let newParentStates = newStateObjects.filter(state => !inArray(newStateObjects, state.parent));
+  const newParentStates = newStateObjects.filter(state => !inArray(newStateObjects, state.parent));
 
   // Add the Injector to the top of the lazy loaded state tree as a resolve
   newParentStates.forEach(state => state.resolvables.push(Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector)));
@@ -191,7 +191,7 @@ export function applyNgModule(transition: Transition, ng2Module: NgModuleRef<any
  * @internalapi
  */
 export function multiProviderParentChildDelta(parent: Injector, child: Injector, token: any) {
-  let childVals: RootModule[] = child.get(token, []);
-  let parentVals: RootModule[] = parent.get(token, []);
+  const childVals: RootModule[] = child.get(token, []);
+  const parentVals: RootModule[] = parent.get(token, []);
   return childVals.filter(val => parentVals.indexOf(val) === -1);
 }

src/location/locationService.ts

@@ -21,8 +21,8 @@ export class Ng2LocationServices extends BaseLocationServices {
   }
 
   _set(state: any, title: string, url: string, replace: boolean): any {
-    let { path, search, hash } = parseUrl(url);
-    let urlWithHash = path + (hash ? "#" + hash : "");
+    const { path, search, hash } = parseUrl(url);
+    const urlWithHash = path + (hash ? "#" + hash : "");
 
     if (replace) {
       this._locationStrategy.replaceState(state, title, urlWithHash, search);

src/mergeInjector.ts

@@ -28,7 +28,7 @@ export class MergeInjector implements Injector {
    */
   get(token: any, notFoundValue?: any): any {
     for (let i = 0; i < this.injectors.length; i++) {
-      let val = this.injectors[i].get(token, MergeInjector.NOT_FOUND);
+      const val = this.injectors[i].get(token, MergeInjector.NOT_FOUND);
       if (val !== MergeInjector.NOT_FOUND) return val;
     }
 

src/providers.ts

@@ -116,7 +116,7 @@ export function uiRouterFactory(locationStrategy: LocationStrategy, rootModules:
 
   // ----------------- Create router -----------------
   // Create a new ng2 UIRouter and configure it for ng2
-  let router = new UIRouter();
+  const router = new UIRouter();
 
   // Add RxJS plugin
   router.plugin(UIRouterRx);
@@ -135,16 +135,16 @@ export function uiRouterFactory(locationStrategy: LocationStrategy, rootModules:
   router.locationConfig = new Ng2LocationConfig(router, locationStrategy);
 
   // Apply ng2 ui-view handling code
-  let viewConfigFactory = (path: PathNode[], config: Ng2ViewDeclaration) => new Ng2ViewConfig(path, config);
+  const viewConfigFactory = (path: PathNode[], config: Ng2ViewDeclaration) => new Ng2ViewConfig(path, config);
   router.viewService._pluginapi._viewConfigFactory("ng2", viewConfigFactory);
 
   // Apply statebuilder decorator for ng2 NgModule registration
-  let registry = router.stateRegistry;
+  const registry = router.stateRegistry;
   registry.decorator('views', ng2ViewsBuilder);
   registry.decorator('lazyLoad', ng2LazyLoadBuilder);
 
   // Prep the tree of NgModule by placing the root NgModule's Injector on the root state.
-  let ng2InjectorResolvable = Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector);
+  const ng2InjectorResolvable = Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector);
   registry.root().resolvables.push(ng2InjectorResolvable);
 
   // Auto-flush the parameter type queue

src/statebuilders/lazyLoad.ts

@@ -48,6 +48,6 @@ import { loadNgModule } from "../lazyLoad/lazyLoadNgModule";
  *
  */
 export function ng2LazyLoadBuilder(state: StateObject, parent: BuilderFunction) {
-  let loadNgModuleFn = state['loadChildren'];
+  const loadNgModuleFn = state['loadChildren'];
   return loadNgModuleFn ? loadNgModule(loadNgModuleFn) : state.lazyLoad;
 }

src/statebuilders/views.ts

@@ -17,7 +17,7 @@ import {ViewService} from "@uirouter/core";
  * applies the state-level configuration to a view named `$default`.
  */
 export function ng2ViewsBuilder(state: StateObject) {
-  let views: { [key: string]: Ng2ViewDeclaration } = {},
+  const views: { [key: string]: Ng2ViewDeclaration } = {},
       viewsObject = state.views || {"$default": pick(state, ["component", "bindings"])};
 
   forEach(viewsObject, function (config: Ng2ViewDeclaration, name: string) {
@@ -29,7 +29,7 @@ export function ng2ViewsBuilder(state: StateObject) {
     config.$context = state;
     config.$name = name;
 
-    let normalized = ViewService.normalizeUIViewTarget(config.$context, config.$name);
+    const normalized = ViewService.normalizeUIViewTarget(config.$context, config.$name);
     config.$uiViewName = normalized.uiViewName;
     config.$uiViewContextAnchor = normalized.uiViewContextAnchor;
 

src/uiRouterConfig.ts

@@ -9,7 +9,7 @@ export function applyModuleConfig(uiRouter: UIRouter, injector: Injector, module
     module.config(uiRouter, injector, module);
   }
 
-  let states = module.states || [];
+  const states = module.states || [];
   return states.map(state => uiRouter.stateRegistry.register(state));
 }