Just Use Prettier™

Author: christopherthielen

src/directives/uiSref.ts

@@ -1,7 +1,17 @@
 /** @ng2api @module directives */
 /** */
 import { UIRouter, extend, Obj, TransitionOptions, TargetState, isNumber } from '@uirouter/core';
-import { Directive, Inject, Input, Optional, ElementRef, Renderer2, OnChanges, SimpleChanges, HostListener } from '@angular/core';
+import {
+  Directive,
+  Inject,
+  Input,
+  Optional,
+  ElementRef,
+  Renderer2,
+  OnChanges,
+  SimpleChanges,
+  HostListener,
+} from '@angular/core';
 import { UIView, ParentUIViewInject } from './uiView';
 import { ReplaySubject } from 'rxjs/ReplaySubject';
 import { Subscription } from 'rxjs/Subscription';
@@ -12,7 +22,7 @@ import { Subscription } from 'rxjs/Subscription';
  */
 @Directive({ selector: 'a[uiSref]' })
 export class AnchorUISref {
-  constructor(public _el: ElementRef, public _renderer: Renderer2) { }
+  constructor(public _el: ElementRef, public _renderer: Renderer2) {}
   openInNewTab() {
     return this._el.nativeElement.target === '_blank';
   }
@@ -71,7 +81,6 @@ export class AnchorUISref {
   exportAs: 'uiSref',
 })
 export class UISref implements OnChanges {
-
   /**
    * `@Input('uiSref')` The name of the state to link to
    *
@@ -112,9 +121,9 @@ export class UISref implements OnChanges {
   /** @internalapi */ private _parent: ParentUIViewInject;
 
   constructor(
-      _router: UIRouter,
-      @Optional() _anchorUISref: AnchorUISref,
-      @Inject(UIView.PARENT_INJECT) parent: ParentUIViewInject,
+    _router: UIRouter,
+    @Optional() _anchorUISref: AnchorUISref,
+    @Inject(UIView.PARENT_INJECT) parent: ParentUIViewInject,
   ) {
     this._router = _router;
     this._anchorUISref = _anchorUISref;
@@ -124,11 +133,20 @@ export class UISref implements OnChanges {
   }
 
   /** @internalapi */
-  set 'uiSref'(val: string) { this.state = val; this.update(); }
+  set uiSref(val: string) {
+    this.state = val;
+    this.update();
+  }
   /** @internalapi */
-  set 'uiParams'(val: Obj) { this.params = val; this.update(); }
+  set uiParams(val: Obj) {
+    this.params = val;
+    this.update();
+  }
   /** @internalapi */
-  set 'uiOptions'(val: TransitionOptions) { this.options = val; this.update(); }
+  set uiOptions(val: TransitionOptions) {
+    this.options = val;
+    this.update();
+  }
 
   ngOnInit() {
     this._emit = true;
@@ -161,16 +179,20 @@ export class UISref implements OnChanges {
   getOptions() {
     const defaultOpts: TransitionOptions = {
       relative: this._parent && this._parent.context && this._parent.context.name,
-      inherit: true ,
-      source: 'sref'
+      inherit: true,
+      source: 'sref',
     };
     return extend(defaultOpts, this.options || {});
   }
 
   /** When triggered by a (click) event, this function transitions to the UISref's target state */
   @HostListener('click', ['$event.button', '$event.ctrlKey', '$event.metaKey'])
   go(button: number, ctrlKey: boolean, metaKey: boolean) {
-    if (this._anchorUISref && (this._anchorUISref.openInNewTab() || button || !isNumber(button) || ctrlKey || metaKey) || !this.state) {
+    if (
+      (this._anchorUISref &&
+        (this._anchorUISref.openInNewTab() || button || !isNumber(button) || ctrlKey || metaKey)) ||
+      !this.state
+    ) {
       return;
     }
 

src/directives/uiSrefActive.ts

@@ -82,15 +82,20 @@ import { Subscription } from 'rxjs/Subscription';
  * ```
  */
 @Directive({
-  selector: '[uiSrefActive],[uiSrefActiveEq]'
+  selector: '[uiSrefActive],[uiSrefActiveEq]',
 })
 export class UISrefActive {
-
   private _classes: string[] = [];
-  @Input('uiSrefActive') set active(val: string) { this._classes = val.split(/\s+/)};
+  @Input('uiSrefActive')
+  set active(val: string) {
+    this._classes = val.split(/\s+/);
+  }
 
   private _classesEq: string[] = [];
-  @Input('uiSrefActiveEq') set activeEq(val: string) { this._classesEq = val.split(/\s+/)};
+  @Input('uiSrefActiveEq')
+  set activeEq(val: string) {
+    this._classesEq = val.split(/\s+/);
+  }
 
   private _subscription: Subscription;
   constructor(uiSrefStatus: UISrefStatus, rnd: Renderer, @Host() host: ElementRef) {

src/directives/uiSrefStatus.ts

@@ -3,7 +3,18 @@
 import { Directive, Output, EventEmitter, ContentChildren, QueryList } from '@angular/core';
 import { UISref } from './uiSref';
 import {
-  PathNode, Transition, TargetState, StateObject, anyTrueR, tail, unnestR, Predicate, UIRouterGlobals, Param, PathUtils, StateOrName
+  PathNode,
+  Transition,
+  TargetState,
+  StateObject,
+  anyTrueR,
+  tail,
+  unnestR,
+  Predicate,
+  UIRouterGlobals,
+  Param,
+  PathUtils,
+  StateOrName,
 } from '@uirouter/core';
 
 import { Subscription } from 'rxjs/Subscription';
@@ -18,7 +29,10 @@ import { map } from 'rxjs/operator/map';
 import { concat } from 'rxjs/operator/concat';
 
 /** @internalapi */
-interface TransEvt { evt: string; trans: Transition; }
+interface TransEvt {
+  evt: string;
+  trans: Transition;
+}
 
 /**
  * UISref status emitted from [[UISrefStatus]]
@@ -58,9 +72,10 @@ const pathMatches = (target: TargetState): Predicate<PathNode[]> => {
   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));
+  const paramSchema: Param[] = targetPath
+    .map(node => node.paramSchema)
+    .reduce(unnestR, [])
+    .filter((param: Param) => targetParamVals.hasOwnProperty(param.id));
 
   return (path: PathNode[]) => {
     const tailNode = tail(path);
@@ -98,22 +113,21 @@ function getSrefStatus(event: TransEvt, srefTarget: TargetState): SrefStatus {
   const activePath: PathNode[] = isSuccessEvent ? tc.to : tc.from;
 
   const isActive = () =>
-      spreadToSubPaths([], activePath)
-          .map(pathMatchesTarget)
-          .reduce(anyTrueR, false);
+    spreadToSubPaths([], activePath)
+      .map(pathMatchesTarget)
+      .reduce(anyTrueR, false);
 
-  const isExact = () =>
-      pathMatchesTarget(activePath);
+  const isExact = () => pathMatchesTarget(activePath);
 
   const isEntering = () =>
-      spreadToSubPaths(tc.retained, tc.entering)
-          .map(pathMatchesTarget)
-          .reduce(anyTrueR, false);
+    spreadToSubPaths(tc.retained, tc.entering)
+      .map(pathMatchesTarget)
+      .reduce(anyTrueR, false);
 
   const isExiting = () =>
-      spreadToSubPaths(tc.retained, tc.exiting)
-          .map(pathMatchesTarget)
-          .reduce(anyTrueR, false);
+    spreadToSubPaths(tc.retained, tc.exiting)
+      .map(pathMatchesTarget)
+      .reduce(anyTrueR, false);
 
   return {
     active: isActive(),
@@ -185,13 +199,14 @@ function mergeSrefStatus(left: SrefStatus, right: SrefStatus): SrefStatus {
  */
 @Directive({
   selector: '[uiSrefStatus],[uiSrefActive],[uiSrefActiveEq]',
-  exportAs: 'uiSrefStatus'
+  exportAs: 'uiSrefStatus',
 })
 export class UISrefStatus {
   /** current statuses of the state/params the uiSref directive is linking to */
   @Output('uiSrefStatus') uiSrefStatus = new EventEmitter<SrefStatus>(false);
   /** Monitor all child components for UISref(s) */
-  @ContentChildren(UISref, { descendants: true }) private _srefs: QueryList<UISref>;
+  @ContentChildren(UISref, { descendants: true })
+  private _srefs: QueryList<UISref>;
 
   /** The current status */
   status: SrefStatus;
@@ -224,18 +239,20 @@ export class UISrefStatus {
     this._srefs$ = new BehaviorSubject(this._srefs.toArray());
     this._srefChangesSub = this._srefs.changes.subscribe(srefs => this._srefs$.next(srefs));
 
-    const targetStates$: Observable<TargetState[]> =
-        switchMap.call(this._srefs$, (srefs: UISref[]) =>
-            combineLatest<TargetState[]>(srefs.map(sref => sref.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[]) => {
-        const statuses: SrefStatus[] = targets.map(target => getSrefStatus(evt, target));
-        return statuses.reduce(mergeSrefStatus);
-      });
-    }).subscribe(this._setStatus.bind(this));
+    this._subscription = switchMap
+      .call(transEvents$, (evt: TransEvt) => {
+        return map.call(targetStates$, (targets: TargetState[]) => {
+          const statuses: SrefStatus[] = targets.map(target => getSrefStatus(evt, target));
+          return statuses.reduce(mergeSrefStatus);
+        });
+      })
+      .subscribe(this._setStatus.bind(this));
   }
 
   ngOnDestroy() {

src/directives/uiView.ts

@@ -1,13 +1,34 @@
 /** @ng2api @module directives */
 /** */
 import {
-  Component, ComponentFactoryResolver, ViewContainerRef, Input, ComponentRef, Type, ReflectiveInjector, ViewChild,
-  Injector, Inject, ComponentFactory
+  Component,
+  ComponentFactoryResolver,
+  ViewContainerRef,
+  Input,
+  ComponentRef,
+  Type,
+  ReflectiveInjector,
+  ViewChild,
+  Injector,
+  Inject,
+  ComponentFactory,
 } from '@angular/core';
 
 import {
-  UIRouter, isFunction, Transition, parse, TransitionHookFn, StateDeclaration, inArray, trace, ViewContext, ViewConfig,
-  ActiveUIView, ResolveContext, NATIVE_INJECTOR_TOKEN, flattenR
+  UIRouter,
+  isFunction,
+  Transition,
+  parse,
+  TransitionHookFn,
+  StateDeclaration,
+  inArray,
+  trace,
+  ViewContext,
+  ViewConfig,
+  ActiveUIView,
+  ResolveContext,
+  NATIVE_INJECTOR_TOKEN,
+  flattenR,
 } from '@uirouter/core';
 import { Ng2ViewConfig } from '../statebuilders/views';
 import { MergeInjector } from '../mergeInjector';
@@ -91,28 +112,32 @@ const ng2ComponentInputs = (factory: ComponentFactory<any>): InputMapping[] => {
   template: `
     <ng-template #componentTarget></ng-template>
     <ng-content *ngIf="!_componentRef"></ng-content>
-  `
+  `,
 })
 export class UIView {
   static PARENT_INJECT = 'UIView.PARENT_INJECT';
 
-  @ViewChild('componentTarget', { read: ViewContainerRef }) _componentTarget: ViewContainerRef;
+  @ViewChild('componentTarget', { read: ViewContainerRef })
+  _componentTarget: ViewContainerRef;
   @Input('name') name: string;
-  @Input('ui-view') set _name(val: string) { this.name = val; }
+  @Input('ui-view')
+  set _name(val: string) {
+    this.name = val;
+  }
   /** The reference to the component currently inside the viewport */
   _componentRef: ComponentRef<any>;
   /** Deregisters the ui-view from the view service */
   private _deregisterUIView: Function;
   /** Deregisters the master uiCanExit transition hook */
   private _deregisterHook: Function;
   /** Data about the this UIView */
-  private _uiViewData: ActiveUIView = <any> {};
+  private _uiViewData: ActiveUIView = <any>{};
   private _parent: ParentUIViewInject;
 
   constructor(
-      public router: UIRouter,
-      @Inject(UIView.PARENT_INJECT) parent,
-      public viewContainerRef: ViewContainerRef,
+    public router: UIRouter,
+    @Inject(UIView.PARENT_INJECT) parent,
+    public viewContainerRef: ViewContainerRef,
   ) {
     this._parent = parent;
   }
@@ -136,7 +161,7 @@ export class UIView {
       fqn: parentFqn ? parentFqn + '.' + name : name,
       creationContext: this._parent.context,
       configUpdated: this._viewConfigUpdated.bind(this),
-      config: undefined
+      config: undefined,
     };
 
     this._deregisterHook = router.transitionService.onBefore({}, trans => this._applyUiCanExitHook(trans));
@@ -232,7 +257,10 @@ export class UIView {
    */
   private _getComponentInjector(context: ResolveContext): Injector {
     // Map resolves to "useValue: providers"
-    const resolvables = context.getTokens().map(token => context.getResolvable(token)).filter(r => r.resolved);
+    const resolvables = context
+      .getTokens()
+      .map(token => context.getResolvable(token))
+      .filter(r => r.resolved);
     const newProviders = resolvables.map(r => ({ provide: r.token, useValue: r.data }));
 
     const parentInject = { context: this._uiViewData.config.viewDecl.$context, fqn: this._uiViewData.fqn };
@@ -259,25 +287,29 @@ export class UIView {
     // return the `_foo` property
     const renamedInputProp = (prop: string) => {
       const input = factory.inputs.find(i => i.templateName === prop);
-      return input && input.propName || prop;
+      return (input && input.propName) || prop;
     };
 
     // Supply resolve data to component as specified in the state's `bindings: {}`
-    const explicitInputTuples = explicitBoundProps
-        .reduce((acc, key) => acc.concat([{ prop: renamedInputProp(key), token: bindings[key] }]), []);
+    const explicitInputTuples = explicitBoundProps.reduce(
+      (acc, key) => acc.concat([{ prop: renamedInputProp(key), token: bindings[key] }]),
+      [],
+    );
 
     // Supply resolve data to matching @Input('prop') or inputs: ['prop']
-    const implicitInputTuples = ng2ComponentInputs(factory)
-        .filter(tuple => !inArray(explicitBoundProps, tuple.prop));
+    const implicitInputTuples = ng2ComponentInputs(factory).filter(tuple => !inArray(explicitBoundProps, tuple.prop));
 
     const addResolvable = (tuple: InputMapping) => ({
       prop: tuple.prop,
       resolvable: context.getResolvable(tuple.token),
     });
 
-    explicitInputTuples.concat(implicitInputTuples)
-        .map(addResolvable)
-        .filter(tuple => tuple.resolvable && tuple.resolvable.resolved)
-        .forEach(tuple => { component[tuple.prop] = tuple.resolvable.data; });
+    explicitInputTuples
+      .concat(implicitInputTuples)
+      .map(addResolvable)
+      .filter(tuple => tuple.resolvable && tuple.resolvable.resolved)
+      .forEach(tuple => {
+        component[tuple.prop] = tuple.resolvable.data;
+      });
   }
 }

src/interface.ts

@@ -132,7 +132,7 @@ export interface Ng2StateDeclaration extends StateDeclaration, Ng2ViewDeclaratio
    * if _any view_ for a state is declared in the `views` object, then _all of the state's views_ must be defined in
    * the `views` object.
    */
-  views?: { [key: string]: Ng2ViewDeclaration; };
+  views?: { [key: string]: Ng2ViewDeclaration };
 
   /**
    * A string or function used to lazy load an `NgModule`