@angular/cdk
Version:
Angular Material Component Development Kit
244 lines • 22.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/cdk/overlay/position/connected-position-strategy.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { ConnectionPositionPair, } from './connected-position';
import { FlexibleConnectedPositionStrategy } from './flexible-connected-position-strategy';
/**
* A strategy for positioning overlays. Using this strategy, an overlay is given an
* implicit position relative to 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.
* @deprecated Use `FlexibleConnectedPositionStrategy` instead.
* \@breaking-change 8.0.0
*/
export class ConnectedPositionStrategy {
/**
* @param {?} originPos
* @param {?} overlayPos
* @param {?} connectedTo
* @param {?} viewportRuler
* @param {?} document
* @param {?} platform
* @param {?} overlayContainer
*/
constructor(originPos, overlayPos, connectedTo, viewportRuler, document, platform, overlayContainer) {
/**
* Ordered list of preferred positions, from most to least desirable.
*/
this._preferredPositions = [];
// Since the `ConnectedPositionStrategy` is deprecated and we don't want to maintain
// the extra logic, we create an instance of the positioning strategy that has some
// defaults that make it behave as the old position strategy and to which we'll
// proxy all of the API calls.
this._positionStrategy = new FlexibleConnectedPositionStrategy(connectedTo, viewportRuler, document, platform, overlayContainer)
.withFlexibleDimensions(false)
.withPush(false)
.withViewportMargin(0);
this.withFallbackPosition(originPos, overlayPos);
}
/**
* Whether the we're dealing with an RTL context
* @return {?}
*/
get _isRtl() {
return this._overlayRef.getDirection() === 'rtl';
}
/**
* Emits an event when the connection point changes.
* @return {?}
*/
get onPositionChange() {
return this._positionStrategy.positionChanges;
}
/**
* Ordered list of preferred positions, from most to least desirable.
* @return {?}
*/
get positions() {
return this._preferredPositions;
}
/**
* Attach this position strategy to an overlay.
* @param {?} overlayRef
* @return {?}
*/
attach(overlayRef) {
this._overlayRef = overlayRef;
this._positionStrategy.attach(overlayRef);
if (this._direction) {
overlayRef.setDirection(this._direction);
this._direction = null;
}
}
/**
* Disposes all resources used by the position strategy.
* @return {?}
*/
dispose() {
this._positionStrategy.dispose();
}
/**
* \@docs-private
* @return {?}
*/
detach() {
this._positionStrategy.detach();
}
/**
* Updates the position of the overlay element, using whichever preferred position relative
* to the origin fits on-screen.
* \@docs-private
* @return {?}
*/
apply() {
this._positionStrategy.apply();
}
/**
* Re-positions the overlay element with the trigger in its last calculated position,
* even if a position higher in the "preferred positions" list would now fit. This
* allows one to re-align the panel without changing the orientation of the panel.
* @return {?}
*/
recalculateLastPosition() {
this._positionStrategy.reapplyLastPosition();
}
/**
* 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.
* @param {?} scrollables
* @return {?}
*/
withScrollableContainers(scrollables) {
this._positionStrategy.withScrollableContainers(scrollables);
}
/**
* Adds a new preferred fallback position.
* @template THIS
* @this {THIS}
* @param {?} originPos
* @param {?} overlayPos
* @param {?=} offsetX
* @param {?=} offsetY
* @return {THIS}
*/
withFallbackPosition(originPos, overlayPos, offsetX, offsetY) {
/** @type {?} */
const position = new ConnectionPositionPair(originPos, overlayPos, offsetX, offsetY);
(/** @type {?} */ (this))._preferredPositions.push(position);
(/** @type {?} */ (this))._positionStrategy.withPositions((/** @type {?} */ (this))._preferredPositions);
return (/** @type {?} */ (this));
}
/**
* Sets the layout direction so the overlay's position can be adjusted to match.
* @template THIS
* @this {THIS}
* @param {?} dir New layout direction.
* @return {THIS}
*/
withDirection(dir) {
// Since the direction might be declared before the strategy is attached,
// we save the value in a temporary property and we'll transfer it to the
// overlay ref on attachment.
if ((/** @type {?} */ (this))._overlayRef) {
(/** @type {?} */ (this))._overlayRef.setDirection(dir);
}
else {
(/** @type {?} */ (this))._direction = dir;
}
return (/** @type {?} */ (this));
}
/**
* Sets an offset for the overlay's connection point on the x-axis
* @template THIS
* @this {THIS}
* @param {?} offset New offset in the X axis.
* @return {THIS}
*/
withOffsetX(offset) {
(/** @type {?} */ (this))._positionStrategy.withDefaultOffsetX(offset);
return (/** @type {?} */ (this));
}
/**
* Sets an offset for the overlay's connection point on the y-axis
* @template THIS
* @this {THIS}
* @param {?} offset New offset in the Y axis.
* @return {THIS}
*/
withOffsetY(offset) {
(/** @type {?} */ (this))._positionStrategy.withDefaultOffsetY(offset);
return (/** @type {?} */ (this));
}
/**
* Sets whether the overlay's position should be locked in after it is positioned
* initially. When an overlay is locked in, it won't attempt to reposition itself
* when the position is re-applied (e.g. when the user scrolls away).
* @template THIS
* @this {THIS}
* @param {?} isLocked Whether the overlay should locked in.
* @return {THIS}
*/
withLockedPosition(isLocked) {
(/** @type {?} */ (this))._positionStrategy.withLockedPosition(isLocked);
return (/** @type {?} */ (this));
}
/**
* Overwrites the current set of positions with an array of new ones.
* @template THIS
* @this {THIS}
* @param {?} positions Position pairs to be set on the strategy.
* @return {THIS}
*/
withPositions(positions) {
(/** @type {?} */ (this))._preferredPositions = positions.slice();
(/** @type {?} */ (this))._positionStrategy.withPositions((/** @type {?} */ (this))._preferredPositions);
return (/** @type {?} */ (this));
}
/**
* Sets the origin element, relative to which to position the overlay.
* @template THIS
* @this {THIS}
* @param {?} origin Reference to the new origin element.
* @return {THIS}
*/
setOrigin(origin) {
(/** @type {?} */ (this))._positionStrategy.setOrigin(origin);
return (/** @type {?} */ (this));
}
}
if (false) {
/**
* Reference to the underlying position strategy to which all the API calls are proxied.
* \@docs-private
* @type {?}
*/
ConnectedPositionStrategy.prototype._positionStrategy;
/**
* The overlay to which this strategy is attached.
* @type {?}
* @private
*/
ConnectedPositionStrategy.prototype._overlayRef;
/**
* @type {?}
* @private
*/
ConnectedPositionStrategy.prototype._direction;
/**
* Ordered list of preferred positions, from most to least desirable.
* @type {?}
*/
ConnectedPositionStrategy.prototype._preferredPositions;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connected-position-strategy.js","sourceRoot":"","sources":["../../../../../../../src/cdk/overlay/position/connected-position-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Direction} from '@angular/cdk/bidi';\nimport {Platform} from '@angular/cdk/platform';\nimport {CdkScrollable, ViewportRuler} from '@angular/cdk/scrolling';\nimport {ElementRef} from '@angular/core';\nimport {Observable} from 'rxjs';\n\nimport {OverlayContainer} from '../overlay-container';\nimport {OverlayReference} from '../overlay-reference';\n\nimport {\n  ConnectedOverlayPositionChange,\n  ConnectionPositionPair,\n  OriginConnectionPosition,\n  OverlayConnectionPosition,\n} from './connected-position';\nimport {FlexibleConnectedPositionStrategy} from './flexible-connected-position-strategy';\nimport {PositionStrategy} from './position-strategy';\n\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * implicit position relative to some origin element. The relative position is defined in terms of\n * a point on the origin element that is connected to a point on the overlay element. For example,\n * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner\n * of the overlay.\n * @deprecated Use `FlexibleConnectedPositionStrategy` instead.\n * @breaking-change 8.0.0\n */\nexport class ConnectedPositionStrategy implements PositionStrategy {\n  /**\n   * Reference to the underlying position strategy to which all the API calls are proxied.\n   * @docs-private\n   */\n  _positionStrategy: FlexibleConnectedPositionStrategy;\n\n  /** The overlay to which this strategy is attached. */\n  private _overlayRef: OverlayReference;\n\n  private _direction: Direction | null;\n\n  /** Whether the we're dealing with an RTL context */\n  get _isRtl() {\n    return this._overlayRef.getDirection() === 'rtl';\n  }\n\n  /** Ordered list of preferred positions, from most to least desirable. */\n  _preferredPositions: ConnectionPositionPair[] = [];\n\n  /** Emits an event when the connection point changes. */\n  get onPositionChange(): Observable<ConnectedOverlayPositionChange> {\n    return this._positionStrategy.positionChanges;\n  }\n\n  constructor(\n      originPos: OriginConnectionPosition, overlayPos: OverlayConnectionPosition,\n      connectedTo: ElementRef<HTMLElement>, viewportRuler: ViewportRuler, document: Document,\n      platform: Platform, overlayContainer: OverlayContainer) {\n    // Since the `ConnectedPositionStrategy` is deprecated and we don't want to maintain\n    // the extra logic, we create an instance of the positioning strategy that has some\n    // defaults that make it behave as the old position strategy and to which we'll\n    // proxy all of the API calls.\n    this._positionStrategy = new FlexibleConnectedPositionStrategy(\n                                 connectedTo, viewportRuler, document, platform, overlayContainer)\n                                 .withFlexibleDimensions(false)\n                                 .withPush(false)\n                                 .withViewportMargin(0);\n\n    this.withFallbackPosition(originPos, overlayPos);\n  }\n\n  /** Ordered list of preferred positions, from most to least desirable. */\n  get positions(): ConnectionPositionPair[] {\n    return this._preferredPositions;\n  }\n\n  /** Attach this position strategy to an overlay. */\n  attach(overlayRef: OverlayReference): void {\n    this._overlayRef = overlayRef;\n    this._positionStrategy.attach(overlayRef);\n\n    if (this._direction) {\n      overlayRef.setDirection(this._direction);\n      this._direction = null;\n    }\n  }\n\n  /** Disposes all resources used by the position strategy. */\n  dispose() {\n    this._positionStrategy.dispose();\n  }\n\n  /** @docs-private */\n  detach() {\n    this._positionStrategy.detach();\n  }\n\n  /**\n   * Updates the position of the overlay element, using whichever preferred position relative\n   * to the origin fits on-screen.\n   * @docs-private\n   */\n  apply(): void {\n    this._positionStrategy.apply();\n  }\n\n  /**\n   * Re-positions the overlay element with the trigger in its last calculated position,\n   * even if a position higher in the \"preferred positions\" list would now fit. This\n   * allows one to re-align the panel without changing the orientation of the panel.\n   */\n  recalculateLastPosition(): void {\n    this._positionStrategy.reapplyLastPosition();\n  }\n\n  /**\n   * Sets the list of Scrollable containers that host the origin element so that\n   * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every\n   * Scrollable must be an ancestor element of the strategy's origin element.\n   */\n  withScrollableContainers(scrollables: CdkScrollable[]) {\n    this._positionStrategy.withScrollableContainers(scrollables);\n  }\n\n  /**\n   * Adds a new preferred fallback position.\n   * @param originPos\n   * @param overlayPos\n   */\n  withFallbackPosition(\n      originPos: OriginConnectionPosition,\n      overlayPos: OverlayConnectionPosition,\n      offsetX?: number,\n      offsetY?: number): this {\n\n    const position = new ConnectionPositionPair(originPos, overlayPos, offsetX, offsetY);\n    this._preferredPositions.push(position);\n    this._positionStrategy.withPositions(this._preferredPositions);\n    return this;\n  }\n\n  /**\n   * Sets the layout direction so the overlay's position can be adjusted to match.\n   * @param dir New layout direction.\n   */\n  withDirection(dir: 'ltr' | 'rtl'): this {\n    // Since the direction might be declared before the strategy is attached,\n    // we save the value in a temporary property and we'll transfer it to the\n    // overlay ref on attachment.\n    if (this._overlayRef) {\n      this._overlayRef.setDirection(dir);\n    } else {\n      this._direction = dir;\n    }\n\n    return this;\n  }\n\n  /**\n   * Sets an offset for the overlay's connection point on the x-axis\n   * @param offset New offset in the X axis.\n   */\n  withOffsetX(offset: number): this {\n    this._positionStrategy.withDefaultOffsetX(offset);\n    return this;\n  }\n\n  /**\n   * Sets an offset for the overlay's connection point on the y-axis\n   * @param  offset New offset in the Y axis.\n   */\n  withOffsetY(offset: number): this {\n    this._positionStrategy.withDefaultOffsetY(offset);\n    return this;\n  }\n\n  /**\n   * Sets whether the overlay's position should be locked in after it is positioned\n   * initially. When an overlay is locked in, it won't attempt to reposition itself\n   * when the position is re-applied (e.g. when the user scrolls away).\n   * @param isLocked Whether the overlay should locked in.\n   */\n  withLockedPosition(isLocked: boolean): this {\n    this._positionStrategy.withLockedPosition(isLocked);\n    return this;\n  }\n\n  /**\n   * Overwrites the current set of positions with an array of new ones.\n   * @param positions Position pairs to be set on the strategy.\n   */\n  withPositions(positions: ConnectionPositionPair[]): this {\n    this._preferredPositions = positions.slice();\n    this._positionStrategy.withPositions(this._preferredPositions);\n    return this;\n  }\n\n  /**\n   * Sets the origin element, relative to which to position the overlay.\n   * @param origin Reference to the new origin element.\n   */\n  setOrigin(origin: ElementRef): this {\n    this._positionStrategy.setOrigin(origin);\n    return this;\n  }\n}\n"]}