refactor: switch to even simpler approach

Author: crisbeto

src/e2e-app/block-scroll-strategy/block-scroll-strategy-e2e.ts

@@ -1,5 +1,5 @@
 import {Component} from '@angular/core';
-import {ScrollStrategyOptions, ScrollStrategy} from '@angular/material';
+import {Overlay, ScrollStrategy} from '@angular/material';
 
 @Component({
   moduleId: module.id,
@@ -8,6 +8,6 @@ import {ScrollStrategyOptions, ScrollStrategy} from '@angular/material';
   styleUrls: ['block-scroll-strategy-e2e.css'],
 })
 export class BlockScrollStrategyE2E {
-  constructor(private _scrollStrategyOptions: ScrollStrategyOptions) { }
-  scrollStrategy: ScrollStrategy = this._scrollStrategyOptions.block();
+  constructor(private _overlay: Overlay) { }
+  scrollStrategy: ScrollStrategy = this._overlay.scrollStrategies.block();
 }

src/lib/autocomplete/autocomplete-trigger.ts

@@ -13,7 +13,7 @@ import {
 } from '@angular/core';
 import {ControlValueAccessor, NG_VALUE_ACCESSOR} from '@angular/forms';
 import {DOCUMENT} from '@angular/platform-browser';
-import {Overlay, OverlayRef, OverlayState, TemplatePortal, ScrollStrategyOptions} from '../core';
+import {Overlay, OverlayRef, OverlayState, TemplatePortal} from '../core';
 import {MdAutocomplete} from './autocomplete';
 import {PositionStrategy} from '../core/overlay/position/position-strategy';
 import {ConnectedPositionStrategy} from '../core/overlay/position/connected-position-strategy';
@@ -103,7 +103,6 @@ export class MdAutocompleteTrigger implements ControlValueAccessor, OnDestroy {
   constructor(private _element: ElementRef, private _overlay: Overlay,
               private _viewContainerRef: ViewContainerRef,
               private _changeDetectorRef: ChangeDetectorRef,
-              private _scrollStrategyOptions: ScrollStrategyOptions,
               @Optional() private _dir: Dir, private _zone: NgZone,
               @Optional() @Host() private _inputContainer: MdInputContainer,
               @Optional() @Inject(DOCUMENT) private _document: any) {}
@@ -367,7 +366,7 @@ export class MdAutocompleteTrigger implements ControlValueAccessor, OnDestroy {
     overlayState.positionStrategy = this._getOverlayPosition();
     overlayState.width = this._getHostWidth();
     overlayState.direction = this._dir ? this._dir.value : 'ltr';
-    overlayState.scrollStrategy = this._scrollStrategyOptions.reposition;
+    overlayState.scrollStrategy = this._overlay.scrollStrategies.reposition();
     return overlayState;
   }
 

src/lib/core/overlay/overlay-directives.ts

@@ -16,7 +16,7 @@ import {
 import {Overlay, OVERLAY_PROVIDERS} from './overlay';
 import {OverlayRef} from './overlay-ref';
 import {TemplatePortal} from '../portal/portal';
-import {OverlayState, OverlayStateScrollStrategy} from './overlay-state';
+import {OverlayState} from './overlay-state';
 import {
     ConnectionPositionPair,
     ConnectedOverlayPositionChange
@@ -25,7 +25,6 @@ import {PortalModule} from '../portal/portal-directives';
 import {ConnectedPositionStrategy} from './position/connected-position-strategy';
 import {Dir, LayoutDirection} from '../rtl/dir';
 import {Scrollable} from './scroll/scrollable';
-import {ScrollStrategyOptions} from './scroll/scroll-strategy-options';
 import {ScrollStrategy} from './scroll/scroll-strategy';
 import {coerceBooleanProperty} from '../coercion/boolean-property';
 import {ESCAPE} from '../keyboard/keycodes';
@@ -124,7 +123,7 @@ export class ConnectedOverlayDirective implements OnDestroy, OnChanges {
   @Input() backdropClass: string;
 
   /** Strategy to be used when handling scroll events while the overlay is open. */
-  @Input() scrollStrategy: OverlayStateScrollStrategy = this._scrollStrategyOptions.reposition;
+  @Input() scrollStrategy: ScrollStrategy = this._overlay.scrollStrategies.reposition();
 
   /** Whether the overlay is open. */
   @Input() open: boolean = false;
@@ -156,7 +155,6 @@ export class ConnectedOverlayDirective implements OnDestroy, OnChanges {
   constructor(
       private _overlay: Overlay,
       private _renderer: Renderer2,
-      private _scrollStrategyOptions: ScrollStrategyOptions,
       templateRef: TemplateRef<any>,
       viewContainerRef: ViewContainerRef,
       @Optional() private _dir: Dir) {

src/lib/core/overlay/overlay-ref.ts

@@ -23,13 +23,7 @@ export class OverlayRef implements PortalHost {
       private _scrollStrategy: ScrollStrategy,
       private _ngZone: NgZone) {
 
-    let scrollStrategyConfig = null;
-
-    if (_state.scrollStrategy && typeof _state.scrollStrategy !== 'function') {
-      scrollStrategyConfig = _state.scrollStrategy.config;
-    }
-
-    _scrollStrategy.attach(this, scrollStrategyConfig);
+    _scrollStrategy.attach(this);
   }
 
   /** The overlay's HTML element */

src/lib/core/overlay/overlay-state.ts

@@ -1,9 +1,7 @@
 import {PositionStrategy} from './position/position-strategy';
 import {LayoutDirection} from '../rtl/dir';
-import {ScrollStrategyOption} from './scroll/scroll-strategy-options';
+import {ScrollStrategy} from './scroll/scroll-strategy';
 
-export type OverlayStateScrollStrategy = {strategy: ScrollStrategyOption; config: any} |
-                                         ScrollStrategyOption;
 
 /**
  * OverlayState is a bag of values for either the initial configuration or current state of an
@@ -14,7 +12,7 @@ export class OverlayState {
   positionStrategy: PositionStrategy;
 
   /** Strategy to be used when handling scroll events while the overlay is open. */
-  scrollStrategy: OverlayStateScrollStrategy;
+  scrollStrategy: ScrollStrategy;
 
   /** Custom class to add to the overlay pane. */
   panelClass: string = '';

src/lib/core/overlay/overlay.spec.ts

@@ -9,12 +9,7 @@ import {OverlayRef} from './overlay-ref';
 import {PositionStrategy} from './position/position-strategy';
 import {OverlayModule} from './overlay-directives';
 import {ViewportRuler} from './position/viewport-ruler';
-import {
-  ScrollStrategy,
-  ScrollStrategyOptions,
-  ScrollStrategyOption,
-  ScrollDispatcher,
-} from './scroll/index';
+import {ScrollStrategy, ScrollDispatcher} from './scroll/index';
 
 
 describe('Overlay', () => {
@@ -27,22 +22,13 @@ describe('Overlay', () => {
   beforeEach(async(() => {
     TestBed.configureTestingModule({
       imports: [OverlayModule, PortalModule, OverlayTestModule],
-      providers: [
-        ScrollDispatcher,
-        ViewportRuler,
-        {
-          provide: ScrollStrategyOptions,
-          useClass: ScrollStrategyOptionsOverride,
-          deps: [ScrollDispatcher, ViewportRuler]
-        },
-        {
-          provide: OverlayContainer,
-          useFactory: () => {
-            overlayContainerElement = document.createElement('div');
-            return {getContainerElement: () => overlayContainerElement};
-          }
+      providers: [{
+        provide: OverlayContainer,
+        useFactory: () => {
+          overlayContainerElement = document.createElement('div');
+          return {getContainerElement: () => overlayContainerElement};
         }
-      ]
+      }]
     }).compileComponents();
   }));
 
@@ -371,15 +357,10 @@ describe('Overlay', () => {
     let overlayRef: OverlayRef;
 
     beforeEach(() => {
-    });
-
-    beforeEach(inject([ScrollStrategyOptions], (scrollOptions: ScrollStrategyOptionsOverride) => {
       config = new OverlayState();
-      config.scrollStrategy = scrollOptions.fake;
+      fakeScrollStrategy = config.scrollStrategy = new FakeScrollStrategy();
       overlayRef = overlay.create(config);
-      fakeScrollStrategy =
-          scrollOptions.instances[scrollOptions.instances.length - 1] as FakeScrollStrategy;
-    }));
+    });
 
     it('should attach the overlay ref to the scroll strategy', () => {
       expect(fakeScrollStrategy.overlayRef).toBe(overlayRef,
@@ -495,19 +476,3 @@ class FakeScrollStrategy implements ScrollStrategy {
     this.isEnabled = false;
   }
 }
-
-
-class ScrollStrategyOptionsOverride extends ScrollStrategyOptions {
-  constructor(scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler) {
-    super(scrollDispatcher, viewportRuler);
-  }
-
-  // used for accessing the current instance in unit tests.
-  public instances: ScrollStrategy[] = [];
-
-  fake: ScrollStrategyOption = () => {
-    let instance = new FakeScrollStrategy();
-    this.instances.push(instance);
-    return instance;
-  }
-}

src/lib/core/overlay/overlay.ts

@@ -32,10 +32,10 @@ let defaultState = new OverlayState();
  */
 @Injectable()
 export class Overlay {
-  constructor(private _overlayContainer: OverlayContainer,
+  constructor(public scrollStrategies: ScrollStrategyOptions,
+              private _overlayContainer: OverlayContainer,
               private _componentFactoryResolver: ComponentFactoryResolver,
               private _positionBuilder: OverlayPositionBuilder,
-              private _scrollStrategyOptions: ScrollStrategyOptions,
               private _appRef: ApplicationRef,
               private _injector: Injector,
               private _ngZone: NgZone) { }
@@ -86,24 +86,10 @@ export class Overlay {
    * @param state
    */
   private _createOverlayRef(pane: HTMLElement, state: OverlayState): OverlayRef {
-    let scrollStrategy = this._createScrollStrategy(state);
+    let scrollStrategy = state.scrollStrategy || this.scrollStrategies.noop();
     let portalHost = this._createPortalHost(pane);
     return new OverlayRef(portalHost, pane, state, scrollStrategy, this._ngZone);
   }
-
-  /**
-   * Creates a scroll strategy for the given overlay state.
-   * @param state
-   */
-  private _createScrollStrategy(state: OverlayState): ScrollStrategy {
-    if (state.scrollStrategy) {
-      return typeof state.scrollStrategy === 'function' ?
-          state.scrollStrategy() :
-          state.scrollStrategy.strategy();
-    }
-
-    return this._scrollStrategyOptions.noop();
-  }
 }
 
 /** Providers for Overlay and its related injectables. */

src/lib/core/overlay/scroll/block-scroll-strategy.spec.ts

@@ -9,7 +9,6 @@ import {
   OverlayState,
   Overlay,
   OverlayRef,
-  ScrollStrategyOptions,
 } from '../../core';
 
 
@@ -26,15 +25,14 @@ describe('BlockScrollStrategy', () => {
     }).compileComponents();
   }));
 
-  beforeEach(inject([Overlay, ViewportRuler, ScrollStrategyOptions],
-    (o: Overlay, v: ViewportRuler, sso: ScrollStrategyOptions) => {
+  beforeEach(inject([Overlay, ViewportRuler], (overlay: Overlay, viewportRuler: ViewportRuler) => {
       let overlayState = new OverlayState();
 
-      overlayState.scrollStrategy = sso.block;
-      overlayRef = o.create(overlayState);
+      overlayState.scrollStrategy = overlay.scrollStrategies.block();
+      overlayRef = overlay.create(overlayState);
       componentPortal = new ComponentPortal(FocacciaMsg);
 
-      viewport = v;
+      viewport = viewportRuler;
       forceScrollElement = document.createElement('div');
       document.body.appendChild(forceScrollElement);
       forceScrollElement.style.width = '100px';

src/lib/core/overlay/scroll/close-scroll-strategy.spec.ts

@@ -10,7 +10,6 @@ import {
   OverlayModule,
   ScrollStrategy,
   ScrollDispatcher,
-  ScrollStrategyOptions,
 } from '../../core';
 
 
@@ -34,10 +33,10 @@ describe('CloseScrollStrategy', () => {
     TestBed.compileComponents();
   }));
 
-  beforeEach(inject([Overlay, ScrollStrategyOptions], (o: Overlay, sso: ScrollStrategyOptions) => {
+  beforeEach(inject([Overlay], (overlay: Overlay) => {
     let overlayState = new OverlayState();
-    overlayState.scrollStrategy = sso.close;
-    overlayRef = o.create(overlayState);
+    overlayState.scrollStrategy = overlay.scrollStrategies.close();
+    overlayRef = overlay.create(overlayState);
     componentPortal = new ComponentPortal(MozarellaMsg);
   }));
 

src/lib/core/overlay/scroll/index.ts

@@ -9,7 +9,7 @@ export {ScrollDispatcher} from './scroll-dispatcher';
 
 // Export pre-defined scroll strategies and interface to build custom ones.
 export {ScrollStrategy} from './scroll-strategy';
-export {ScrollStrategyOptions, ScrollStrategyOption} from './scroll-strategy-options';
+export {ScrollStrategyOptions} from './scroll-strategy-options';
 export {RepositionScrollStrategy} from './reposition-scroll-strategy';
 export {CloseScrollStrategy} from './close-scroll-strategy';
 export {NoopScrollStrategy} from './noop-scroll-strategy';

src/lib/core/overlay/scroll/reposition-scroll-strategy.spec.ts

@@ -10,7 +10,6 @@ import {
   OverlayModule,
   ScrollStrategy,
   ScrollDispatcher,
-  ScrollStrategyOptions,
 } from '../../core';
 
 
@@ -34,10 +33,10 @@ describe('RepositionScrollStrategy', () => {
     TestBed.compileComponents();
   }));
 
-  beforeEach(inject([Overlay, ScrollStrategyOptions], (o: Overlay, sso: ScrollStrategyOptions) => {
+  beforeEach(inject([Overlay], (overlay: Overlay) => {
     let overlayState = new OverlayState();
-    overlayState.scrollStrategy = sso.reposition;
-    overlayRef = o.create(overlayState);
+    overlayState.scrollStrategy = overlay.scrollStrategies.reposition();
+    overlayRef = overlay.create(overlayState);
     componentPortal = new ComponentPortal(PastaMsg);
   }));
 

src/lib/core/overlay/scroll/reposition-scroll-strategy.ts

@@ -16,17 +16,17 @@ export interface RepositionScrollStrategyConfig {
 export class RepositionScrollStrategy implements ScrollStrategy {
   private _scrollSubscription: Subscription|null = null;
   private _overlayRef: OverlayRef;
-  private _config: RepositionScrollStrategyConfig;
 
-  constructor(private _scrollDispatcher: ScrollDispatcher) { }
+  constructor(
+    private _scrollDispatcher: ScrollDispatcher,
+    private _config: RepositionScrollStrategyConfig) { }
 
-  attach(overlayRef: OverlayRef, config?: RepositionScrollStrategyConfig) {
+  attach(overlayRef: OverlayRef) {
     if (this._overlayRef) {
       throw getMdScrollStrategyAlreadyAttachedError();
     }
 
     this._overlayRef = overlayRef;
-    this._config = config;
   }
 
   enable() {

src/lib/core/overlay/scroll/scroll-strategy-options.ts

@@ -1,13 +1,14 @@
 import {Injectable} from '@angular/core';
 import {ScrollStrategy} from './scroll-strategy';
-import {RepositionScrollStrategy} from './reposition-scroll-strategy';
 import {CloseScrollStrategy} from './close-scroll-strategy';
 import {NoopScrollStrategy} from './noop-scroll-strategy';
 import {BlockScrollStrategy} from './block-scroll-strategy';
 import {ScrollDispatcher} from './scroll-dispatcher';
 import {ViewportRuler} from '../position/viewport-ruler';
-
-export type ScrollStrategyOption = () => ScrollStrategy;
+import {
+  RepositionScrollStrategy,
+  RepositionScrollStrategyConfig,
+} from './reposition-scroll-strategy';
 
 
 /**
@@ -20,8 +21,10 @@ export class ScrollStrategyOptions {
     private _scrollDispatcher: ScrollDispatcher,
     private _viewportRuler: ViewportRuler) { }
 
-  noop: ScrollStrategyOption = () => new NoopScrollStrategy();
-  close: ScrollStrategyOption = () => new CloseScrollStrategy(this._scrollDispatcher);
-  block: ScrollStrategyOption = () => new BlockScrollStrategy(this._viewportRuler);
-  reposition: ScrollStrategyOption = () => new RepositionScrollStrategy(this._scrollDispatcher);
+  noop = () => new NoopScrollStrategy();
+  close = () => new CloseScrollStrategy(this._scrollDispatcher);
+  block = () => new BlockScrollStrategy(this._viewportRuler);
+  reposition = (config?: RepositionScrollStrategyConfig) => {
+    return new RepositionScrollStrategy(this._scrollDispatcher, config);
+  }
 }