@angular/material 2.0.0-beta.0 → 2.0.0-beta.12

package/core/overlay/overlay-state.d.ts

@@ -1,24 +0,0 @@
-import { PositionStrategy } from './position/position-strategy';
-import { LayoutDirection } from '../rtl/dir';
-/**
- * OverlayState is a bag of values for either the initial configuration or current state of an
- * overlay.
- */
-export declare class OverlayState {
-    /** Strategy with which to position the overlay. */
-    positionStrategy: PositionStrategy;
-    /** Whether the overlay has a backdrop. */
-    hasBackdrop: boolean;
-    /** Custom class to add to the backdrop **/
-    backdropClass: string;
-    /** The width of the overlay panel. If a number is provided, pixel units are assumed. **/
-    width: number | string;
-    /** The height of the overlay panel. If a number is provided, pixel units are assumed. **/
-    height: number | string;
-    /** The min-width of the overlay panel. If a number is provided, pixel units are assumed. **/
-    minWidth: number | string;
-    /** The min-height of the overlay panel. If a number is provided, pixel units are assumed. **/
-    minHeight: number | string;
-    /** The direction of the text in the overlay panel. */
-    direction: LayoutDirection;
-}

package/core/overlay/overlay-state.js

@@ -1,17 +0,0 @@
-/**
- * OverlayState is a bag of values for either the initial configuration or current state of an
- * overlay.
- */
-export var OverlayState = (function () {
-    function OverlayState() {
-        /** Whether the overlay has a backdrop. */
-        this.hasBackdrop = false;
-        /** Custom class to add to the backdrop **/
-        this.backdropClass = 'cdk-overlay-dark-backdrop';
-        /** The direction of the text in the overlay panel. */
-        this.direction = 'ltr';
-    }
-    return OverlayState;
-}());
-
-//# sourceMappingURL=overlay-state.js.map

package/core/overlay/overlay-state.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["core/overlay/overlay-state.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAAA;QAIE,0CAA0C;QAC1C,gBAAW,GAAY,KAAK,CAAC;QAE7B,2CAA2C;QAC3C,kBAAa,GAAW,2BAA2B,CAAC;QAcpD,sDAAsD;QACtD,cAAS,GAAoB,KAAK,CAAC;IAMrC,CAAC;IAAD,mBAAC;AAAD,CA7BA,AA6BC,IAAA","file":"overlay-state.js","sourcesContent":["import {PositionStrategy} from './position/position-strategy';\nimport {LayoutDirection} from '../rtl/dir';\n\n\n/**\n * OverlayState is a bag of values for either the initial configuration or current state of an\n * overlay.\n */\nexport class OverlayState {\n  /** Strategy with which to position the overlay. */\n  positionStrategy: PositionStrategy;\n\n  /** Whether the overlay has a backdrop. */\n  hasBackdrop: boolean = false;\n\n  /** Custom class to add to the backdrop **/\n  backdropClass: string = 'cdk-overlay-dark-backdrop';\n\n  /** The width of the overlay panel. If a number is provided, pixel units are assumed. **/\n  width: number | string;\n\n  /** The height of the overlay panel. If a number is provided, pixel units are assumed. **/\n  height: number | string;\n\n  /** The min-width of the overlay panel. If a number is provided, pixel units are assumed. **/\n  minWidth: number | string;\n\n  /** The min-height of the overlay panel. If a number is provided, pixel units are assumed. **/\n  minHeight: number | string;\n\n  /** The direction of the text in the overlay panel. */\n  direction: LayoutDirection = 'ltr';\n\n  // TODO(jelbourn): configuration still to add\n  // - focus trap\n  // - disable pointer events\n  // - z-index\n}\n"]}

package/core/overlay/overlay-state.metadata.json

@@ -1 +0,0 @@
-[{"__symbolic":"module","version":2,"metadata":{"OverlayState":{"__symbolic":"class"}}},{"__symbolic":"module","metadata":{"OverlayState":{"__symbolic":"class"}},"version":1}]

package/core/overlay/overlay.d.ts

@@ -1,54 +0,0 @@
-import { ComponentFactoryResolver, ApplicationRef, Injector, NgZone } from '@angular/core';
-import { OverlayState } from './overlay-state';
-import { OverlayRef } from './overlay-ref';
-import { OverlayPositionBuilder } from './position/overlay-position-builder';
-import { ViewportRuler } from './position/viewport-ruler';
-import { OverlayContainer } from './overlay-container';
-import { ScrollDispatcher } from './scroll/scroll-dispatcher';
-/**
- * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
- * used as a low-level building building block for other components. Dialogs, tooltips, menus,
- * selects, etc. can all be built using overlays. The service should primarily be used by authors
- * of re-usable components rather than developers building end-user applications.
- *
- * An overlay *is* a PortalHost, so any kind of Portal can be loaded into one.
- */
-export declare class Overlay {
-    private _overlayContainer;
-    private _componentFactoryResolver;
-    private _positionBuilder;
-    private _appRef;
-    private _injector;
-    private _ngZone;
-    constructor(_overlayContainer: OverlayContainer, _componentFactoryResolver: ComponentFactoryResolver, _positionBuilder: OverlayPositionBuilder, _appRef: ApplicationRef, _injector: Injector, _ngZone: NgZone);
-    /**
-     * Creates an overlay.
-     * @param state State to apply to the overlay.
-     * @returns Reference to the created overlay.
-     */
-    create(state?: OverlayState): OverlayRef;
-    /**
-     * Returns a position builder that can be used, via fluent API,
-     * to construct and configure a position strategy.
-     */
-    position(): OverlayPositionBuilder;
-    /**
-     * Creates the DOM element for an overlay and appends it to the overlay container.
-     * @returns Newly-created pane element
-     */
-    private _createPaneElement();
-    /**
-     * Create a DomPortalHost into which the overlay content can be loaded.
-     * @param pane The DOM element to turn into a portal host.
-     * @returns A portal host for the given DOM element.
-     */
-    private _createPortalHost(pane);
-    /**
-     * Creates an OverlayRef for an overlay in the given DOM element.
-     * @param pane DOM element for the overlay
-     * @param state
-     */
-    private _createOverlayRef(pane, state);
-}
-/** Providers for Overlay and its related injectables. */
-export declare const OVERLAY_PROVIDERS: (typeof ViewportRuler | typeof ScrollDispatcher | typeof OverlayPositionBuilder | typeof OverlayContainer | typeof Overlay)[];

package/core/overlay/overlay.js

@@ -1,97 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { ComponentFactoryResolver, Injectable, ApplicationRef, Injector, NgZone } from '@angular/core';
-import { OverlayState } from './overlay-state';
-import { DomPortalHost } from '../portal/dom-portal-host';
-import { OverlayRef } from './overlay-ref';
-import { OverlayPositionBuilder } from './position/overlay-position-builder';
-import { ViewportRuler } from './position/viewport-ruler';
-import { OverlayContainer } from './overlay-container';
-import { ScrollDispatcher } from './scroll/scroll-dispatcher';
-/** Next overlay unique ID. */
-var nextUniqueId = 0;
-/** The default state for newly created overlays. */
-var defaultState = new OverlayState();
-/**
- * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
- * used as a low-level building building block for other components. Dialogs, tooltips, menus,
- * selects, etc. can all be built using overlays. The service should primarily be used by authors
- * of re-usable components rather than developers building end-user applications.
- *
- * An overlay *is* a PortalHost, so any kind of Portal can be loaded into one.
- */
-export var Overlay = (function () {
-    function Overlay(_overlayContainer, _componentFactoryResolver, _positionBuilder, _appRef, _injector, _ngZone) {
-        this._overlayContainer = _overlayContainer;
-        this._componentFactoryResolver = _componentFactoryResolver;
-        this._positionBuilder = _positionBuilder;
-        this._appRef = _appRef;
-        this._injector = _injector;
-        this._ngZone = _ngZone;
-    }
-    /**
-     * Creates an overlay.
-     * @param state State to apply to the overlay.
-     * @returns Reference to the created overlay.
-     */
-    Overlay.prototype.create = function (state) {
-        if (state === void 0) { state = defaultState; }
-        return this._createOverlayRef(this._createPaneElement(), state);
-    };
-    /**
-     * Returns a position builder that can be used, via fluent API,
-     * to construct and configure a position strategy.
-     */
-    Overlay.prototype.position = function () {
-        return this._positionBuilder;
-    };
-    /**
-     * Creates the DOM element for an overlay and appends it to the overlay container.
-     * @returns Newly-created pane element
-     */
-    Overlay.prototype._createPaneElement = function () {
-        var pane = document.createElement('div');
-        pane.id = "cdk-overlay-" + nextUniqueId++;
-        pane.classList.add('cdk-overlay-pane');
-        this._overlayContainer.getContainerElement().appendChild(pane);
-        return pane;
-    };
-    /**
-     * Create a DomPortalHost into which the overlay content can be loaded.
-     * @param pane The DOM element to turn into a portal host.
-     * @returns A portal host for the given DOM element.
-     */
-    Overlay.prototype._createPortalHost = function (pane) {
-        return new DomPortalHost(pane, this._componentFactoryResolver, this._appRef, this._injector);
-    };
-    /**
-     * Creates an OverlayRef for an overlay in the given DOM element.
-     * @param pane DOM element for the overlay
-     * @param state
-     */
-    Overlay.prototype._createOverlayRef = function (pane, state) {
-        return new OverlayRef(this._createPortalHost(pane), pane, state, this._ngZone);
-    };
-    Overlay = __decorate([
-        Injectable(), 
-        __metadata('design:paramtypes', [OverlayContainer, ComponentFactoryResolver, OverlayPositionBuilder, ApplicationRef, Injector, NgZone])
-    ], Overlay);
-    return Overlay;
-}());
-/** Providers for Overlay and its related injectables. */
-export var OVERLAY_PROVIDERS = [
-    ViewportRuler,
-    OverlayPositionBuilder,
-    Overlay,
-    OverlayContainer,
-    ScrollDispatcher,
-];
-
-//# sourceMappingURL=overlay.js.map

package/core/overlay/overlay.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["core/overlay/overlay.ts"],"names":[],"mappings":";;;;;;;;;OAAO,EACL,wBAAwB,EACxB,UAAU,EACV,cAAc,EACd,QAAQ,EACR,MAAM,EACP,MAAM,eAAe;OACf,EAAC,YAAY,EAAC,MAAM,iBAAiB;OACrC,EAAC,aAAa,EAAC,MAAM,2BAA2B;OAChD,EAAC,UAAU,EAAC,MAAM,eAAe;OACjC,EAAC,sBAAsB,EAAC,MAAM,qCAAqC;OACnE,EAAC,aAAa,EAAC,MAAM,2BAA2B;OAChD,EAAC,gBAAgB,EAAC,MAAM,qBAAqB;OAC7C,EAAC,gBAAgB,EAAC,MAAM,4BAA4B;AAE3D,8BAA8B;AAC9B,IAAI,YAAY,GAAG,CAAC,CAAC;AAErB,oDAAoD;AACpD,IAAI,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;AAGtC;;;;;;;GAOG;AAEH;IACE,iBAAoB,iBAAmC,EACnC,yBAAmD,EACnD,gBAAwC,EACxC,OAAuB,EACvB,SAAmB,EACnB,OAAe;QALf,sBAAiB,GAAjB,iBAAiB,CAAkB;QACnC,8BAAyB,GAAzB,yBAAyB,CAA0B;QACnD,qBAAgB,GAAhB,gBAAgB,CAAwB;QACxC,YAAO,GAAP,OAAO,CAAgB;QACvB,cAAS,GAAT,SAAS,CAAU;QACnB,YAAO,GAAP,OAAO,CAAQ;IAAG,CAAC;IAEvC;;;;OAIG;IACH,wBAAM,GAAN,UAAO,KAAkC;QAAlC,qBAAkC,GAAlC,oBAAkC;QACvC,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,KAAK,CAAC,CAAC;IAClE,CAAC;IAED;;;OAGG;IACH,0BAAQ,GAAR;QACE,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACK,oCAAkB,GAA1B;QACE,IAAI,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,EAAE,GAAG,iBAAe,YAAY,EAAI,CAAC;QAC1C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAEvC,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAE/D,MAAM,CAAC,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACK,mCAAiB,GAAzB,UAA0B,IAAiB;QACzC,MAAM,CAAC,IAAI,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,yBAAyB,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC/F,CAAC;IAED;;;;OAIG;IACK,mCAAiB,GAAzB,UAA0B,IAAiB,EAAE,KAAmB;QAC9D,MAAM,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACjF,CAAC;IAxDF;QAAC,UAAU,EAAE;;eAAA;IAyDd,cAAC;AAAD,CAxDA,AAwDC,IAAA;AAED,yDAAyD;AACzD,OAAO,IAAM,iBAAiB,GAAG;IAC/B,aAAa;IACb,sBAAsB;IACtB,OAAO;IACP,gBAAgB;IAChB,gBAAgB;CACjB,CAAC","file":"overlay.js","sourcesContent":["import {\n  ComponentFactoryResolver,\n  Injectable,\n  ApplicationRef,\n  Injector,\n  NgZone,\n} from '@angular/core';\nimport {OverlayState} from './overlay-state';\nimport {DomPortalHost} from '../portal/dom-portal-host';\nimport {OverlayRef} from './overlay-ref';\nimport {OverlayPositionBuilder} from './position/overlay-position-builder';\nimport {ViewportRuler} from './position/viewport-ruler';\nimport {OverlayContainer} from './overlay-container';\nimport {ScrollDispatcher} from './scroll/scroll-dispatcher';\n\n/** Next overlay unique ID. */\nlet nextUniqueId = 0;\n\n/** The default state for newly created overlays. */\nlet defaultState = new OverlayState();\n\n\n/**\n * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be\n * used as a low-level building building block for other components. Dialogs, tooltips, menus,\n * selects, etc. can all be built using overlays. The service should primarily be used by authors\n * of re-usable components rather than developers building end-user applications.\n *\n * An overlay *is* a PortalHost, so any kind of Portal can be loaded into one.\n */\n @Injectable()\nexport class Overlay {\n  constructor(private _overlayContainer: OverlayContainer,\n              private _componentFactoryResolver: ComponentFactoryResolver,\n              private _positionBuilder: OverlayPositionBuilder,\n              private _appRef: ApplicationRef,\n              private _injector: Injector,\n              private _ngZone: NgZone) {}\n\n  /**\n   * Creates an overlay.\n   * @param state State to apply to the overlay.\n   * @returns Reference to the created overlay.\n   */\n  create(state: OverlayState = defaultState): OverlayRef {\n    return this._createOverlayRef(this._createPaneElement(), state);\n  }\n\n  /**\n   * Returns a position builder that can be used, via fluent API,\n   * to construct and configure a position strategy.\n   */\n  position(): OverlayPositionBuilder {\n    return this._positionBuilder;\n  }\n\n  /**\n   * Creates the DOM element for an overlay and appends it to the overlay container.\n   * @returns Newly-created pane element\n   */\n  private _createPaneElement(): HTMLElement {\n    let pane = document.createElement('div');\n    pane.id = `cdk-overlay-${nextUniqueId++}`;\n    pane.classList.add('cdk-overlay-pane');\n\n    this._overlayContainer.getContainerElement().appendChild(pane);\n\n    return pane;\n  }\n\n  /**\n   * Create a DomPortalHost into which the overlay content can be loaded.\n   * @param pane The DOM element to turn into a portal host.\n   * @returns A portal host for the given DOM element.\n   */\n  private _createPortalHost(pane: HTMLElement): DomPortalHost {\n    return new DomPortalHost(pane, this._componentFactoryResolver, this._appRef, this._injector);\n  }\n\n  /**\n   * Creates an OverlayRef for an overlay in the given DOM element.\n   * @param pane DOM element for the overlay\n   * @param state\n   */\n  private _createOverlayRef(pane: HTMLElement, state: OverlayState): OverlayRef {\n    return new OverlayRef(this._createPortalHost(pane), pane, state, this._ngZone);\n  }\n}\n\n/** Providers for Overlay and its related injectables. */\nexport const OVERLAY_PROVIDERS = [\n  ViewportRuler,\n  OverlayPositionBuilder,\n  Overlay,\n  OverlayContainer,\n  ScrollDispatcher,\n];\n"]}

package/core/overlay/overlay.metadata.json

@@ -1 +0,0 @@
-[{"__symbolic":"module","version":2,"metadata":{"Overlay":{"__symbolic":"class","decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable"}}],"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./overlay-container","name":"OverlayContainer"},{"__symbolic":"reference","module":"@angular/core","name":"ComponentFactoryResolver"},{"__symbolic":"reference","module":"./position/overlay-position-builder","name":"OverlayPositionBuilder"},{"__symbolic":"reference","module":"@angular/core","name":"ApplicationRef"},{"__symbolic":"reference","module":"@angular/core","name":"Injector"},{"__symbolic":"reference","module":"@angular/core","name":"NgZone"}]}],"create":[{"__symbolic":"method"}],"position":[{"__symbolic":"method"}],"_createPaneElement":[{"__symbolic":"method"}],"_createPortalHost":[{"__symbolic":"method"}],"_createOverlayRef":[{"__symbolic":"method"}]}},"OVERLAY_PROVIDERS":[{"__symbolic":"reference","module":"./position/viewport-ruler","name":"ViewportRuler"},{"__symbolic":"reference","module":"./position/overlay-position-builder","name":"OverlayPositionBuilder"},{"__symbolic":"reference","name":"Overlay"},{"__symbolic":"reference","module":"./overlay-container","name":"OverlayContainer"},{"__symbolic":"reference","module":"./scroll/scroll-dispatcher","name":"ScrollDispatcher"}]}},{"__symbolic":"module","metadata":{"Overlay":{"__symbolic":"class","decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable"}}],"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./overlay-container","name":"OverlayContainer"},{"__symbolic":"reference","module":"@angular/core","name":"ComponentFactoryResolver"},{"__symbolic":"reference","module":"./position/overlay-position-builder","name":"OverlayPositionBuilder"},{"__symbolic":"reference","module":"@angular/core","name":"ApplicationRef"},{"__symbolic":"reference","module":"@angular/core","name":"Injector"},{"__symbolic":"reference","module":"@angular/core","name":"NgZone"}]}],"create":[{"__symbolic":"method"}],"position":[{"__symbolic":"method"}],"_createPaneElement":[{"__symbolic":"method"}],"_createPortalHost":[{"__symbolic":"method"}],"_createOverlayRef":[{"__symbolic":"method"}]}},"OVERLAY_PROVIDERS":[{"__symbolic":"reference","module":"./position/viewport-ruler","name":"ViewportRuler"},{"__symbolic":"reference","module":"./position/overlay-position-builder","name":"OverlayPositionBuilder"},{"__symbolic":"reference","name":"Overlay"},{"__symbolic":"reference","module":"./overlay-container","name":"OverlayContainer"},{"__symbolic":"reference","module":"./scroll/scroll-dispatcher","name":"ScrollDispatcher"}]},"version":1}]

package/core/overlay/position/connected-position-strategy.d.ts

@@ -1,133 +0,0 @@
-import { PositionStrategy } from './position-strategy';
-import { ElementRef } from '@angular/core';
-import { ViewportRuler } from './viewport-ruler';
-import { ConnectionPositionPair, OriginConnectionPosition, OverlayConnectionPosition, ConnectedOverlayPositionChange } from './connected-position';
-import { Subject } from 'rxjs/Subject';
-import { Observable } from 'rxjs/Observable';
-import { Scrollable } from '../scroll/scrollable';
-/**
- * Container to hold the bounding positions of a particular element with respect to the viewport,
- * where top and bottom are the y-axis coordinates of the bounding rectangle and left and right are
- * the x-axis coordinates.
- */
-export declare type ElementBoundingPositions = {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-};
-/**
- * A strategy for positioning overlays. Using this strategy, an overlay is given an
- * implicit position relative some origin element. The relative position is defined in terms of
- * a point on the origin element that is connected to a point on the overlay element. For example,
- * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner
- * of the overlay.
- */
-export declare class ConnectedPositionStrategy implements PositionStrategy {
-    private _connectedTo;
-    private _originPos;
-    private _overlayPos;
-    private _viewportRuler;
-    private _dir;
-    /** The offset in pixels for the overlay connection point on the x-axis */
-    private _offsetX;
-    /** The offset in pixels for the overlay connection point on the y-axis */
-    private _offsetY;
-    /** The Scrollable containers used to check scrollable view properties on position change. */
-    private scrollables;
-    /** Whether the we're dealing with an RTL context */
-    readonly _isRtl: boolean;
-    /** Ordered list of preferred positions, from most to least desirable. */
-    _preferredPositions: ConnectionPositionPair[];
-    /** The origin element against which the overlay will be positioned. */
-    private _origin;
-    _onPositionChange: Subject<ConnectedOverlayPositionChange>;
-    /** Emits an event when the connection point changes. */
-    readonly onPositionChange: Observable<ConnectedOverlayPositionChange>;
-    constructor(_connectedTo: ElementRef, _originPos: OriginConnectionPosition, _overlayPos: OverlayConnectionPosition, _viewportRuler: ViewportRuler);
-    /** Ordered list of preferred positions, from most to least desirable. */
-    readonly positions: ConnectionPositionPair[];
-    /**
-     * To be used to for any cleanup after the element gets destroyed.
-     */
-    dispose(): void;
-    /**
-     * Updates the position of the overlay element, using whichever preferred position relative
-     * to the origin fits on-screen.
-     * @docs-private
-     *
-     * @param element Element to which to apply the CSS styles.
-     * @returns Resolves when the styles have been applied.
-     */
-    apply(element: HTMLElement): Promise<void>;
-    /**
-     * Sets the list of Scrollable containers that host the origin element so that
-     * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
-     * Scrollable must be an ancestor element of the strategy's origin element.
-     */
-    withScrollableContainers(scrollables: Scrollable[]): void;
-    /**
-     * Adds a new preferred fallback position.
-     * @param originPos
-     * @param overlayPos
-     */
-    withFallbackPosition(originPos: OriginConnectionPosition, overlayPos: OverlayConnectionPosition): this;
-    /**
-     * Sets the layout direction so the overlay's position can be adjusted to match.
-     * @param dir New layout direction.
-     */
-    withDirection(dir: 'ltr' | 'rtl'): this;
-    /**
-     * Sets an offset for the overlay's connection point on the x-axis
-     * @param offset New offset in the X axis.
-     */
-    withOffsetX(offset: number): this;
-    /**
-     * Sets an offset for the overlay's connection point on the y-axis
-     * @param  offset New offset in the Y axis.
-     */
-    withOffsetY(offset: number): this;
-    /**
-     * Gets the horizontal (x) "start" dimension based on whether the overlay is in an RTL context.
-     * @param rect
-     */
-    private _getStartX(rect);
-    /**
-     * Gets the horizontal (x) "end" dimension based on whether the overlay is in an RTL context.
-     * @param rect
-     */
-    private _getEndX(rect);
-    /**
-     * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.
-     * @param originRect
-     * @param pos
-     */
-    private _getOriginConnectionPoint(originRect, pos);
-    /**
-     * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and
-     * origin point to which the overlay should be connected, as well as how much of the element
-     * would be inside the viewport at that position.
-     */
-    private _getOverlayPoint(originPoint, overlayRect, viewportRect, pos);
-    /**
-     * Gets the view properties of the trigger and overlay, including whether they are clipped
-     * or completely outside the view of any of the strategy's scrollables.
-     */
-    private getScrollableViewProperties(overlay);
-    /** Whether the element is completely out of the view of any of the containers. */
-    private isElementOutsideView(elementBounds, containersBounds);
-    /** Whether the element is clipped by any of the containers. */
-    private isElementClipped(elementBounds, containersBounds);
-    /**
-     * Physically positions the overlay element to the given coordinate.
-     * @param element
-     * @param overlayPoint
-     */
-    private _setElementPosition(element, overlayPoint);
-    /** Returns the bounding positions of the provided element with respect to the viewport. */
-    private _getElementBounds(element);
-    /**
-     * Subtracts the amount that an element is overflowing on an axis from it's length.
-     */
-    private _subtractOverflows(length, ...overflows);
-}

package/core/overlay/position/connected-position-strategy.js

@@ -1,292 +0,0 @@
-import { ConnectionPositionPair, ConnectedOverlayPositionChange } from './connected-position';
-import { Subject } from 'rxjs/Subject';
-/**
- * A strategy for positioning overlays. Using this strategy, an overlay is given an
- * implicit position relative some origin element. The relative position is defined in terms of
- * a point on the origin element that is connected to a point on the overlay element. For example,
- * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner
- * of the overlay.
- */
-export var ConnectedPositionStrategy = (function () {
-    function ConnectedPositionStrategy(_connectedTo, _originPos, _overlayPos, _viewportRuler) {
-        this._connectedTo = _connectedTo;
-        this._originPos = _originPos;
-        this._overlayPos = _overlayPos;
-        this._viewportRuler = _viewportRuler;
-        this._dir = 'ltr';
-        /** The offset in pixels for the overlay connection point on the x-axis */
-        this._offsetX = 0;
-        /** The offset in pixels for the overlay connection point on the y-axis */
-        this._offsetY = 0;
-        /** The Scrollable containers used to check scrollable view properties on position change. */
-        this.scrollables = [];
-        /** Ordered list of preferred positions, from most to least desirable. */
-        this._preferredPositions = [];
-        this._onPositionChange = new Subject();
-        this._origin = this._connectedTo.nativeElement;
-        this.withFallbackPosition(_originPos, _overlayPos);
-    }
-    Object.defineProperty(ConnectedPositionStrategy.prototype, "_isRtl", {
-        /** Whether the we're dealing with an RTL context */
-        get: function () {
-            return this._dir === 'rtl';
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ConnectedPositionStrategy.prototype, "onPositionChange", {
-        /** Emits an event when the connection point changes. */
-        get: function () {
-            return this._onPositionChange.asObservable();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ConnectedPositionStrategy.prototype, "positions", {
-        /** Ordered list of preferred positions, from most to least desirable. */
-        get: function () {
-            return this._preferredPositions;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * To be used to for any cleanup after the element gets destroyed.
-     */
-    ConnectedPositionStrategy.prototype.dispose = function () { };
-    /**
-     * Updates the position of the overlay element, using whichever preferred position relative
-     * to the origin fits on-screen.
-     * @docs-private
-     *
-     * @param element Element to which to apply the CSS styles.
-     * @returns Resolves when the styles have been applied.
-     */
-    ConnectedPositionStrategy.prototype.apply = function (element) {
-        // We need the bounding rects for the origin and the overlay to determine how to position
-        // the overlay relative to the origin.
-        var originRect = this._origin.getBoundingClientRect();
-        var overlayRect = element.getBoundingClientRect();
-        // We use the viewport rect to determine whether a position would go off-screen.
-        var viewportRect = this._viewportRuler.getViewportRect();
-        // Fallback point if none of the fallbacks fit into the viewport.
-        var fallbackPoint = null;
-        // We want to place the overlay in the first of the preferred positions such that the
-        // overlay fits on-screen.
-        for (var _i = 0, _a = this._preferredPositions; _i < _a.length; _i++) {
-            var pos = _a[_i];
-            // Get the (x, y) point of connection on the origin, and then use that to get the
-            // (top, left) coordinate for the overlay at `pos`.
-            var originPoint = this._getOriginConnectionPoint(originRect, pos);
-            var overlayPoint = this._getOverlayPoint(originPoint, overlayRect, viewportRect, pos);
-            // If the overlay in the calculated position fits on-screen, put it there and we're done.
-            if (overlayPoint.fitsInViewport) {
-                this._setElementPosition(element, overlayPoint);
-                // Notify that the position has been changed along with its change properties.
-                var scrollableViewProperties = this.getScrollableViewProperties(element);
-                var positionChange = new ConnectedOverlayPositionChange(pos, scrollableViewProperties);
-                this._onPositionChange.next(positionChange);
-                return Promise.resolve(null);
-            }
-            else if (!fallbackPoint || fallbackPoint.visibleArea < overlayPoint.visibleArea) {
-                fallbackPoint = overlayPoint;
-            }
-        }
-        // If none of the preferred positions were in the viewport, take the one
-        // with the largest visible area.
-        this._setElementPosition(element, fallbackPoint);
-        return Promise.resolve(null);
-    };
-    /**
-     * Sets the list of Scrollable containers that host the origin element so that
-     * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
-     * Scrollable must be an ancestor element of the strategy's origin element.
-     */
-    ConnectedPositionStrategy.prototype.withScrollableContainers = function (scrollables) {
-        this.scrollables = scrollables;
-    };
-    /**
-     * Adds a new preferred fallback position.
-     * @param originPos
-     * @param overlayPos
-     */
-    ConnectedPositionStrategy.prototype.withFallbackPosition = function (originPos, overlayPos) {
-        this._preferredPositions.push(new ConnectionPositionPair(originPos, overlayPos));
-        return this;
-    };
-    /**
-     * Sets the layout direction so the overlay's position can be adjusted to match.
-     * @param dir New layout direction.
-     */
-    ConnectedPositionStrategy.prototype.withDirection = function (dir) {
-        this._dir = dir;
-        return this;
-    };
-    /**
-     * Sets an offset for the overlay's connection point on the x-axis
-     * @param offset New offset in the X axis.
-     */
-    ConnectedPositionStrategy.prototype.withOffsetX = function (offset) {
-        this._offsetX = offset;
-        return this;
-    };
-    /**
-     * Sets an offset for the overlay's connection point on the y-axis
-     * @param  offset New offset in the Y axis.
-     */
-    ConnectedPositionStrategy.prototype.withOffsetY = function (offset) {
-        this._offsetY = offset;
-        return this;
-    };
-    /**
-     * Gets the horizontal (x) "start" dimension based on whether the overlay is in an RTL context.
-     * @param rect
-     */
-    ConnectedPositionStrategy.prototype._getStartX = function (rect) {
-        return this._isRtl ? rect.right : rect.left;
-    };
-    /**
-     * Gets the horizontal (x) "end" dimension based on whether the overlay is in an RTL context.
-     * @param rect
-     */
-    ConnectedPositionStrategy.prototype._getEndX = function (rect) {
-        return this._isRtl ? rect.left : rect.right;
-    };
-    /**
-     * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.
-     * @param originRect
-     * @param pos
-     */
-    ConnectedPositionStrategy.prototype._getOriginConnectionPoint = function (originRect, pos) {
-        var originStartX = this._getStartX(originRect);
-        var originEndX = this._getEndX(originRect);
-        var x;
-        if (pos.originX == 'center') {
-            x = originStartX + (originRect.width / 2);
-        }
-        else {
-            x = pos.originX == 'start' ? originStartX : originEndX;
-        }
-        var y;
-        if (pos.originY == 'center') {
-            y = originRect.top + (originRect.height / 2);
-        }
-        else {
-            y = pos.originY == 'top' ? originRect.top : originRect.bottom;
-        }
-        return { x: x, y: y };
-    };
-    /**
-     * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and
-     * origin point to which the overlay should be connected, as well as how much of the element
-     * would be inside the viewport at that position.
-     */
-    ConnectedPositionStrategy.prototype._getOverlayPoint = function (originPoint, overlayRect, viewportRect, pos) {
-        // Calculate the (overlayStartX, overlayStartY), the start of the potential overlay position
-        // relative to the origin point.
-        var overlayStartX;
-        if (pos.overlayX == 'center') {
-            overlayStartX = -overlayRect.width / 2;
-        }
-        else if (pos.overlayX === 'start') {
-            overlayStartX = this._isRtl ? -overlayRect.width : 0;
-        }
-        else {
-            overlayStartX = this._isRtl ? 0 : -overlayRect.width;
-        }
-        var overlayStartY;
-        if (pos.overlayY == 'center') {
-            overlayStartY = -overlayRect.height / 2;
-        }
-        else {
-            overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;
-        }
-        // The (x, y) coordinates of the overlay.
-        var x = originPoint.x + overlayStartX + this._offsetX;
-        var y = originPoint.y + overlayStartY + this._offsetY;
-        // How much the overlay would overflow at this position, on each side.
-        var leftOverflow = viewportRect.left - x;
-        var rightOverflow = (x + overlayRect.width) - viewportRect.right;
-        var topOverflow = viewportRect.top - y;
-        var bottomOverflow = (y + overlayRect.height) - viewportRect.bottom;
-        // Visible parts of the element on each axis.
-        var visibleWidth = this._subtractOverflows(overlayRect.width, leftOverflow, rightOverflow);
-        var visibleHeight = this._subtractOverflows(overlayRect.height, topOverflow, bottomOverflow);
-        // The area of the element that's within the viewport.
-        var visibleArea = visibleWidth * visibleHeight;
-        var fitsInViewport = (overlayRect.width * overlayRect.height) === visibleArea;
-        return { x: x, y: y, fitsInViewport: fitsInViewport, visibleArea: visibleArea };
-    };
-    /**
-     * Gets the view properties of the trigger and overlay, including whether they are clipped
-     * or completely outside the view of any of the strategy's scrollables.
-     */
-    ConnectedPositionStrategy.prototype.getScrollableViewProperties = function (overlay) {
-        var _this = this;
-        var originBounds = this._getElementBounds(this._origin);
-        var overlayBounds = this._getElementBounds(overlay);
-        var scrollContainerBounds = this.scrollables.map(function (scrollable) {
-            return _this._getElementBounds(scrollable.getElementRef().nativeElement);
-        });
-        return {
-            isOriginClipped: this.isElementClipped(originBounds, scrollContainerBounds),
-            isOriginOutsideView: this.isElementOutsideView(originBounds, scrollContainerBounds),
-            isOverlayClipped: this.isElementClipped(overlayBounds, scrollContainerBounds),
-            isOverlayOutsideView: this.isElementOutsideView(overlayBounds, scrollContainerBounds),
-        };
-    };
-    /** Whether the element is completely out of the view of any of the containers. */
-    ConnectedPositionStrategy.prototype.isElementOutsideView = function (elementBounds, containersBounds) {
-        return containersBounds.some(function (containerBounds) {
-            var outsideAbove = elementBounds.bottom < containerBounds.top;
-            var outsideBelow = elementBounds.top > containerBounds.bottom;
-            var outsideLeft = elementBounds.right < containerBounds.left;
-            var outsideRight = elementBounds.left > containerBounds.right;
-            return outsideAbove || outsideBelow || outsideLeft || outsideRight;
-        });
-    };
-    /** Whether the element is clipped by any of the containers. */
-    ConnectedPositionStrategy.prototype.isElementClipped = function (elementBounds, containersBounds) {
-        return containersBounds.some(function (containerBounds) {
-            var clippedAbove = elementBounds.top < containerBounds.top;
-            var clippedBelow = elementBounds.bottom > containerBounds.bottom;
-            var clippedLeft = elementBounds.left < containerBounds.left;
-            var clippedRight = elementBounds.right > containerBounds.right;
-            return clippedAbove || clippedBelow || clippedLeft || clippedRight;
-        });
-    };
-    /**
-     * Physically positions the overlay element to the given coordinate.
-     * @param element
-     * @param overlayPoint
-     */
-    ConnectedPositionStrategy.prototype._setElementPosition = function (element, overlayPoint) {
-        element.style.left = overlayPoint.x + 'px';
-        element.style.top = overlayPoint.y + 'px';
-    };
-    /** Returns the bounding positions of the provided element with respect to the viewport. */
-    ConnectedPositionStrategy.prototype._getElementBounds = function (element) {
-        var boundingClientRect = element.getBoundingClientRect();
-        return {
-            top: boundingClientRect.top,
-            right: boundingClientRect.left + boundingClientRect.width,
-            bottom: boundingClientRect.top + boundingClientRect.height,
-            left: boundingClientRect.left
-        };
-    };
-    /**
-     * Subtracts the amount that an element is overflowing on an axis from it's length.
-     */
-    ConnectedPositionStrategy.prototype._subtractOverflows = function (length) {
-        var overflows = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            overflows[_i - 1] = arguments[_i];
-        }
-        return overflows.reduce(function (currentValue, currentOverflow) {
-            return currentValue - Math.max(currentOverflow, 0);
-        }, length);
-    };
-    return ConnectedPositionStrategy;
-}());
-
-//# sourceMappingURL=connected-position-strategy.js.map