@skyux/core 5.7.1 → 6.0.0-beta.0

package/esm2020/lib/modules/affix/affix.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable, RendererFactory2, } from '@angular/core';
+import { SkyAffixer } from './affixer';
+import * as i0 from "@angular/core";
+export class SkyAffixService {
+    constructor(rendererFactory) {
+        this.renderer = rendererFactory.createRenderer(undefined, undefined);
+    }
+    /**
+     * Creates an instance of [[SkyAffixer]].
+     * @param affixed The element to be affixed.
+     */
+    createAffixer(affixed) {
+        return new SkyAffixer(affixed.nativeElement, this.renderer);
+    }
+}
+SkyAffixService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyAffixService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyAffixService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyAffixService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyAffixService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZmaXguc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9hZmZpeC9hZmZpeC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxVQUFVLEVBRVYsZ0JBQWdCLEdBQ2pCLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxXQUFXLENBQUM7O0FBS3ZDLE1BQU0sT0FBTyxlQUFlO0lBRzFCLFlBQVksZUFBaUM7UUFDM0MsSUFBSSxDQUFDLFFBQVEsR0FBRyxlQUFlLENBQUMsY0FBYyxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYSxDQUFDLE9BQW1CO1FBQ3RDLE9BQU8sSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUQsQ0FBQzs7NEdBYlUsZUFBZTtnSEFBZixlQUFlLGNBRmQsTUFBTTsyRkFFUCxlQUFlO2tCQUgzQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIEVsZW1lbnRSZWYsXG4gIEluamVjdGFibGUsXG4gIFJlbmRlcmVyMixcbiAgUmVuZGVyZXJGYWN0b3J5Mixcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreUFmZml4ZXIgfSBmcm9tICcuL2FmZml4ZXInO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgU2t5QWZmaXhTZXJ2aWNlIHtcbiAgcHJpdmF0ZSByZW5kZXJlcjogUmVuZGVyZXIyO1xuXG4gIGNvbnN0cnVjdG9yKHJlbmRlcmVyRmFjdG9yeTogUmVuZGVyZXJGYWN0b3J5Mikge1xuICAgIHRoaXMucmVuZGVyZXIgPSByZW5kZXJlckZhY3RvcnkuY3JlYXRlUmVuZGVyZXIodW5kZWZpbmVkLCB1bmRlZmluZWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgW1tTa3lBZmZpeGVyXV0uXG4gICAqIEBwYXJhbSBhZmZpeGVkIFRoZSBlbGVtZW50IHRvIGJlIGFmZml4ZWQuXG4gICAqL1xuICBwdWJsaWMgY3JlYXRlQWZmaXhlcihhZmZpeGVkOiBFbGVtZW50UmVmKTogU2t5QWZmaXhlciB7XG4gICAgcmV0dXJuIG5ldyBTa3lBZmZpeGVyKGFmZml4ZWQubmF0aXZlRWxlbWVudCwgdGhpcy5yZW5kZXJlcik7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/modules/affix/affixer.mjs

@@ -0,0 +1,349 @@
+import { Subject, fromEvent } from 'rxjs';
+import { SkyAffixAutoFitContext } from './affix-auto-fit-context';
+import { getInversePlacement, getNextPlacement } from './affix-utils';
+import { getElementOffset, getOverflowParents, isOffsetFullyVisibleWithinParent, isOffsetPartiallyVisibleWithinParent, } from './dom-utils';
+const DEFAULT_AFFIX_CONFIG = {
+    autoFitContext: SkyAffixAutoFitContext.OverflowParent,
+    enableAutoFit: false,
+    horizontalAlignment: 'center',
+    isSticky: false,
+    placement: 'above',
+};
+export class SkyAffixer {
+    constructor(affixedElement, renderer) {
+        this.affixedElement = affixedElement;
+        this.renderer = renderer;
+        this._offsetChange = new Subject();
+        this._overflowScroll = new Subject();
+        this._placementChange = new Subject();
+    }
+    /**
+     * Fires when the affixed element's offset changes.
+     */
+    get offsetChange() {
+        return this._offsetChange.asObservable();
+    }
+    /**
+     * Fires when the base element's nearest overflow parent is scrolling. This is useful if you need
+     * to perform an additional action during the scroll event but don't want to generate another
+     * event listener.
+     */
+    get overflowScroll() {
+        return this._overflowScroll.asObservable();
+    }
+    /**
+     * Fires when the placement value changes. A `null` value indicates that a suitable
+     * placement could not be found.
+     */
+    get placementChange() {
+        return this._placementChange.asObservable();
+    }
+    get config() {
+        return this._config;
+    }
+    set config(value) {
+        const merged = { ...DEFAULT_AFFIX_CONFIG, ...value };
+        // Make sure none of the values are undefined.
+        Object.keys(merged).forEach((k) => {
+            if (merged[k] === undefined) {
+                merged[k] = DEFAULT_AFFIX_CONFIG[k];
+            }
+        });
+        this._config = merged;
+    }
+    /**
+     * Affixes an element to a base element.
+     * @param baseElement The base element.
+     * @param config Configuration for the affix action.
+     */
+    affixTo(baseElement, config) {
+        this.reset();
+        this.config = config;
+        this.baseElement = baseElement;
+        this.overflowParents = getOverflowParents(baseElement);
+        this.affix();
+        if (this.config.isSticky) {
+            this.addScrollListeners();
+            this.addResizeListener();
+        }
+    }
+    /**
+     * Re-runs the affix calculation.
+     */
+    reaffix() {
+        // Reset current placement to preferred placement.
+        this.currentPlacement = this.config.placement;
+        this.affix();
+    }
+    /**
+     * Destroys the affixer.
+     */
+    destroy() {
+        this.reset();
+        this._placementChange.complete();
+        this._offsetChange.complete();
+        this._overflowScroll.complete();
+        this._offsetChange =
+            this._placementChange =
+                this._overflowScroll =
+                    undefined;
+    }
+    affix() {
+        this.baseRect = this.baseElement.getBoundingClientRect();
+        this.affixedRect = this.affixedElement.getBoundingClientRect();
+        const offset = this.getOffset();
+        if (this.isNewOffset(offset)) {
+            this.renderer.setStyle(this.affixedElement, 'top', `${offset.top}px`);
+            this.renderer.setStyle(this.affixedElement, 'left', `${offset.left}px`);
+            this._offsetChange.next({ offset });
+        }
+    }
+    getOffset() {
+        const parent = this.getAutoFitContextParent();
+        const maxAttempts = 4;
+        let attempts = 0;
+        let isAffixedElementFullyVisible = false;
+        let offset;
+        let placement = this.config.placement;
+        do {
+            offset = this.getPreferredOffset(placement);
+            isAffixedElementFullyVisible = isOffsetFullyVisibleWithinParent(parent, offset, this.config.autoFitOverflowOffset);
+            if (!this.config.enableAutoFit) {
+                break;
+            }
+            if (!isAffixedElementFullyVisible) {
+                placement =
+                    attempts % 2 === 0
+                        ? getInversePlacement(placement)
+                        : getNextPlacement(placement);
+            }
+            attempts++;
+        } while (!isAffixedElementFullyVisible && attempts < maxAttempts);
+        if (isAffixedElementFullyVisible) {
+            if (this.isBaseElementVisible()) {
+                this.notifyPlacementChange(placement);
+            }
+            else {
+                /* tslint:disable-next-line:no-null-keyword */
+                this.notifyPlacementChange(null);
+            }
+            return offset;
+        }
+        if (this.config.enableAutoFit) {
+            /* tslint:disable-next-line:no-null-keyword */
+            this.notifyPlacementChange(null);
+        }
+        // No suitable placement was found, so revert to preferred placement.
+        return this.getPreferredOffset(this.config.placement);
+    }
+    getPreferredOffset(placement) {
+        const affixedRect = this.affixedRect;
+        const baseRect = this.baseRect;
+        const horizontalAlignment = this.config.horizontalAlignment;
+        const verticalAlignment = this.config.verticalAlignment;
+        const enableAutoFit = this.config.enableAutoFit;
+        let top;
+        let left;
+        if (placement === 'above' || placement === 'below') {
+            if (placement === 'above') {
+                top = baseRect.top - affixedRect.height;
+                switch (verticalAlignment) {
+                    case 'top':
+                        top = top + affixedRect.height;
+                        break;
+                    case 'middle':
+                        top = top + affixedRect.height / 2;
+                        break;
+                    case 'bottom':
+                    default:
+                        break;
+                }
+            }
+            else {
+                top = baseRect.bottom;
+                switch (verticalAlignment) {
+                    case 'top':
+                    default:
+                        break;
+                    case 'middle':
+                        top = top - affixedRect.height / 2;
+                        break;
+                    case 'bottom':
+                        top = top - affixedRect.height;
+                        break;
+                }
+            }
+            switch (horizontalAlignment) {
+                case 'left':
+                    left = baseRect.left;
+                    break;
+                case 'center':
+                default:
+                    left = baseRect.left + baseRect.width / 2 - affixedRect.width / 2;
+                    break;
+                case 'right':
+                    left = baseRect.right - affixedRect.width;
+                    break;
+            }
+        }
+        else {
+            if (placement === 'left') {
+                left = baseRect.left - affixedRect.width;
+            }
+            else {
+                left = baseRect.right;
+            }
+            switch (verticalAlignment) {
+                case 'top':
+                    top = baseRect.top;
+                    break;
+                case 'middle':
+                default:
+                    top = baseRect.top + baseRect.height / 2 - affixedRect.height / 2;
+                    break;
+                case 'bottom':
+                    top = baseRect.bottom - affixedRect.height;
+                    break;
+            }
+        }
+        let offset = { left, top };
+        if (enableAutoFit) {
+            offset = this.adjustOffsetToOverflowParent({ ...offset }, placement);
+        }
+        offset.bottom = offset.top + affixedRect.height;
+        offset.right = offset.left + affixedRect.width;
+        return offset;
+    }
+    /**
+     * Slightly adjust the offset to fit within the scroll parent's boundaries if
+     * the affixed element would otherwise be clipped.
+     */
+    adjustOffsetToOverflowParent(offset, placement) {
+        const parent = this.getAutoFitContextParent();
+        const parentOffset = getElementOffset(parent, this.config.autoFitOverflowOffset);
+        const affixedRect = this.affixedRect;
+        const baseRect = this.baseRect;
+        // A pixel value representing the leeway between the edge of the overflow parent and the edge
+        // of the base element before it dissapears from view.
+        // If the visible portion of the base element is less than this pixel value, the auto-fit
+        // functionality attempts to find another placement.
+        const defaultPixelTolerance = 40;
+        let pixelTolerance;
+        const originalOffsetTop = offset.top;
+        const originalOffsetLeft = offset.left;
+        /* tslint:disable-next-line:switch-default */
+        switch (placement) {
+            case 'above':
+            case 'below':
+                // Keep the affixed element within the overflow parent.
+                if (offset.left < parentOffset.left) {
+                    offset.left = parentOffset.left;
+                }
+                else if (offset.left + affixedRect.width > parentOffset.right) {
+                    offset.left = parentOffset.right - affixedRect.width;
+                }
+                // Use a smaller pixel tolerance if the base element width is less than the default.
+                pixelTolerance = Math.min(defaultPixelTolerance, baseRect.width);
+                // Make sure the affixed element never detaches from the base element.
+                if (offset.left + pixelTolerance > baseRect.right ||
+                    offset.left + affixedRect.width - pixelTolerance < baseRect.left) {
+                    offset.left = originalOffsetLeft;
+                }
+                break;
+            case 'left':
+            case 'right':
+                // Keep the affixed element within the overflow parent.
+                if (offset.top < parentOffset.top) {
+                    offset.top = parentOffset.top;
+                }
+                else if (offset.top + affixedRect.height > parentOffset.bottom) {
+                    offset.top = parentOffset.bottom - affixedRect.height;
+                }
+                // Use a smaller pixel tolerance if the base element height is less than the default.
+                pixelTolerance = Math.min(defaultPixelTolerance, baseRect.height);
+                // Make sure the affixed element never detaches from the base element.
+                if (offset.top + pixelTolerance > baseRect.bottom ||
+                    offset.top + affixedRect.height - pixelTolerance < baseRect.top) {
+                    offset.top = originalOffsetTop;
+                }
+                break;
+        }
+        return offset;
+    }
+    getImmediateOverflowParent() {
+        return this.overflowParents[this.overflowParents.length - 1];
+    }
+    getAutoFitContextParent() {
+        const bodyElement = this.overflowParents[0];
+        return this.config.autoFitContext === SkyAffixAutoFitContext.OverflowParent
+            ? this.getImmediateOverflowParent()
+            : bodyElement;
+    }
+    notifyPlacementChange(placement) {
+        if (this.currentPlacement !== placement) {
+            this.currentPlacement = placement;
+            this._placementChange.next({
+                placement,
+            });
+        }
+    }
+    reset() {
+        this.removeScrollListeners();
+        this.removeResizeListener();
+        this._config =
+            this.affixedRect =
+                this.baseElement =
+                    this.baseRect =
+                        this.currentPlacement =
+                            this.currentOffset =
+                                this.overflowParents =
+                                    undefined;
+    }
+    isNewOffset(offset) {
+        if (this.currentOffset === undefined) {
+            this.currentOffset = offset;
+            return true;
+        }
+        if (this.currentOffset.top === offset.top &&
+            this.currentOffset.left === offset.left) {
+            return false;
+        }
+        this.currentOffset = offset;
+        return true;
+    }
+    isBaseElementVisible() {
+        return isOffsetPartiallyVisibleWithinParent(this.getImmediateOverflowParent(), {
+            top: this.baseRect.top,
+            left: this.baseRect.left,
+            right: this.baseRect.right,
+            bottom: this.baseRect.bottom,
+        }, this.config.autoFitOverflowOffset);
+    }
+    addScrollListeners() {
+        this.scrollListeners = this.overflowParents.map((parentElement) => {
+            const overflow = parentElement === document.body ? 'window' : parentElement;
+            return this.renderer.listen(overflow, 'scroll', () => {
+                this.affix();
+                this._overflowScroll.next();
+            });
+        });
+    }
+    addResizeListener() {
+        this.resizeListener = fromEvent(window, 'resize').subscribe(() => this.affix());
+    }
+    removeResizeListener() {
+        if (this.resizeListener) {
+            this.resizeListener.unsubscribe();
+            this.resizeListener = undefined;
+        }
+    }
+    removeScrollListeners() {
+        if (this.scrollListeners) {
+            // Remove renderer-generated listeners by calling the listener itself.
+            // https://github.com/angular/angular/issues/9368#issuecomment-227199778
+            this.scrollListeners.forEach((listener) => listener());
+            this.scrollListeners = undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"affixer.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/affix/affixer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Renderer2 } from '@angular/core';\n\nimport { Observable, Subject, Subscription, fromEvent } from 'rxjs';\n\nimport { SkyAffixAutoFitContext } from './affix-auto-fit-context';\nimport { SkyAffixConfig } from './affix-config';\nimport { SkyAffixOffset } from './affix-offset';\nimport { SkyAffixOffsetChange } from './affix-offset-change';\nimport { SkyAffixPlacement } from './affix-placement';\nimport { SkyAffixPlacementChange } from './affix-placement-change';\nimport { getInversePlacement, getNextPlacement } from './affix-utils';\nimport {\n  getElementOffset,\n  getOverflowParents,\n  isOffsetFullyVisibleWithinParent,\n  isOffsetPartiallyVisibleWithinParent,\n} from './dom-utils';\n\nconst DEFAULT_AFFIX_CONFIG: SkyAffixConfig = {\n  autoFitContext: SkyAffixAutoFitContext.OverflowParent,\n  enableAutoFit: false,\n  horizontalAlignment: 'center',\n  isSticky: false,\n  placement: 'above',\n};\n\nexport class SkyAffixer {\n  /**\n   * Fires when the affixed element's offset changes.\n   */\n  public get offsetChange(): Observable<SkyAffixOffsetChange> {\n    return this._offsetChange.asObservable();\n  }\n\n  /**\n   * Fires when the base element's nearest overflow parent is scrolling. This is useful if you need\n   * to perform an additional action during the scroll event but don't want to generate another\n   * event listener.\n   */\n  public get overflowScroll(): Observable<void> {\n    return this._overflowScroll.asObservable();\n  }\n\n  /**\n   * Fires when the placement value changes. A `null` value indicates that a suitable\n   * placement could not be found.\n   */\n  public get placementChange(): Observable<SkyAffixPlacementChange> {\n    return this._placementChange.asObservable();\n  }\n\n  private get config(): SkyAffixConfig {\n    return this._config;\n  }\n\n  private set config(value: SkyAffixConfig) {\n    const merged = { ...DEFAULT_AFFIX_CONFIG, ...value };\n\n    // Make sure none of the values are undefined.\n    Object.keys(merged).forEach((k: keyof SkyAffixConfig) => {\n      if (merged[k] === undefined) {\n        (merged as any)[k] = DEFAULT_AFFIX_CONFIG[k];\n      }\n    });\n\n    this._config = merged;\n  }\n\n  private affixedRect: ClientRect;\n\n  private baseElement: HTMLElement;\n\n  private baseRect: ClientRect;\n\n  private currentOffset: SkyAffixOffset;\n\n  private currentPlacement: SkyAffixPlacement;\n\n  private overflowParents: HTMLElement[];\n\n  private resizeListener: Subscription;\n\n  private scrollListeners: (() => void)[];\n\n  private _config: SkyAffixConfig;\n\n  private _offsetChange = new Subject<SkyAffixOffsetChange>();\n\n  private _overflowScroll = new Subject<void>();\n\n  private _placementChange = new Subject<SkyAffixPlacementChange>();\n\n  constructor(\n    private affixedElement: HTMLElement,\n    private renderer: Renderer2\n  ) {}\n\n  /**\n   * Affixes an element to a base element.\n   * @param baseElement The base element.\n   * @param config Configuration for the affix action.\n   */\n  public affixTo(baseElement: HTMLElement, config?: SkyAffixConfig): void {\n    this.reset();\n\n    this.config = config;\n    this.baseElement = baseElement;\n    this.overflowParents = getOverflowParents(baseElement);\n\n    this.affix();\n\n    if (this.config.isSticky) {\n      this.addScrollListeners();\n      this.addResizeListener();\n    }\n  }\n\n  /**\n   * Re-runs the affix calculation.\n   */\n  public reaffix(): void {\n    // Reset current placement to preferred placement.\n    this.currentPlacement = this.config.placement;\n    this.affix();\n  }\n\n  /**\n   * Destroys the affixer.\n   */\n  public destroy(): void {\n    this.reset();\n    this._placementChange.complete();\n    this._offsetChange.complete();\n    this._overflowScroll.complete();\n\n    this._offsetChange =\n      this._placementChange =\n      this._overflowScroll =\n        undefined;\n  }\n\n  private affix(): void {\n    this.baseRect = this.baseElement.getBoundingClientRect();\n    this.affixedRect = this.affixedElement.getBoundingClientRect();\n\n    const offset = this.getOffset();\n\n    if (this.isNewOffset(offset)) {\n      this.renderer.setStyle(this.affixedElement, 'top', `${offset.top}px`);\n      this.renderer.setStyle(this.affixedElement, 'left', `${offset.left}px`);\n      this._offsetChange.next({ offset });\n    }\n  }\n\n  private getOffset(): SkyAffixOffset {\n    const parent = this.getAutoFitContextParent();\n\n    const maxAttempts = 4;\n    let attempts = 0;\n\n    let isAffixedElementFullyVisible = false;\n    let offset: SkyAffixOffset;\n    let placement = this.config.placement;\n\n    do {\n      offset = this.getPreferredOffset(placement);\n      isAffixedElementFullyVisible = isOffsetFullyVisibleWithinParent(\n        parent,\n        offset,\n        this.config.autoFitOverflowOffset\n      );\n\n      if (!this.config.enableAutoFit) {\n        break;\n      }\n\n      if (!isAffixedElementFullyVisible) {\n        placement =\n          attempts % 2 === 0\n            ? getInversePlacement(placement)\n            : getNextPlacement(placement);\n      }\n\n      attempts++;\n    } while (!isAffixedElementFullyVisible && attempts < maxAttempts);\n\n    if (isAffixedElementFullyVisible) {\n      if (this.isBaseElementVisible()) {\n        this.notifyPlacementChange(placement);\n      } else {\n        /* tslint:disable-next-line:no-null-keyword */\n        this.notifyPlacementChange(null);\n      }\n\n      return offset;\n    }\n\n    if (this.config.enableAutoFit) {\n      /* tslint:disable-next-line:no-null-keyword */\n      this.notifyPlacementChange(null);\n    }\n\n    // No suitable placement was found, so revert to preferred placement.\n    return this.getPreferredOffset(this.config.placement);\n  }\n\n  private getPreferredOffset(placement: SkyAffixPlacement): SkyAffixOffset {\n    const affixedRect = this.affixedRect;\n    const baseRect = this.baseRect;\n\n    const horizontalAlignment = this.config.horizontalAlignment;\n    const verticalAlignment = this.config.verticalAlignment;\n    const enableAutoFit = this.config.enableAutoFit;\n\n    let top: number;\n    let left: number;\n\n    if (placement === 'above' || placement === 'below') {\n      if (placement === 'above') {\n        top = baseRect.top - affixedRect.height;\n\n        switch (verticalAlignment) {\n          case 'top':\n            top = top + affixedRect.height;\n            break;\n          case 'middle':\n            top = top + affixedRect.height / 2;\n            break;\n          case 'bottom':\n          default:\n            break;\n        }\n      } else {\n        top = baseRect.bottom;\n\n        switch (verticalAlignment) {\n          case 'top':\n          default:\n            break;\n          case 'middle':\n            top = top - affixedRect.height / 2;\n            break;\n          case 'bottom':\n            top = top - affixedRect.height;\n            break;\n        }\n      }\n\n      switch (horizontalAlignment) {\n        case 'left':\n          left = baseRect.left;\n          break;\n\n        case 'center':\n        default:\n          left = baseRect.left + baseRect.width / 2 - affixedRect.width / 2;\n          break;\n\n        case 'right':\n          left = baseRect.right - affixedRect.width;\n          break;\n      }\n    } else {\n      if (placement === 'left') {\n        left = baseRect.left - affixedRect.width;\n      } else {\n        left = baseRect.right;\n      }\n\n      switch (verticalAlignment) {\n        case 'top':\n          top = baseRect.top;\n          break;\n\n        case 'middle':\n        default:\n          top = baseRect.top + baseRect.height / 2 - affixedRect.height / 2;\n          break;\n\n        case 'bottom':\n          top = baseRect.bottom - affixedRect.height;\n          break;\n      }\n    }\n\n    let offset: SkyAffixOffset = { left, top };\n    if (enableAutoFit) {\n      offset = this.adjustOffsetToOverflowParent({ ...offset }, placement);\n    }\n\n    offset.bottom = offset.top + affixedRect.height;\n    offset.right = offset.left + affixedRect.width;\n\n    return offset;\n  }\n\n  /**\n   * Slightly adjust the offset to fit within the scroll parent's boundaries if\n   * the affixed element would otherwise be clipped.\n   */\n  private adjustOffsetToOverflowParent(\n    offset: SkyAffixOffset,\n    placement: SkyAffixPlacement\n  ): SkyAffixOffset {\n    const parent = this.getAutoFitContextParent();\n    const parentOffset = getElementOffset(\n      parent,\n      this.config.autoFitOverflowOffset\n    );\n\n    const affixedRect = this.affixedRect;\n    const baseRect = this.baseRect;\n\n    // A pixel value representing the leeway between the edge of the overflow parent and the edge\n    // of the base element before it dissapears from view.\n    // If the visible portion of the base element is less than this pixel value, the auto-fit\n    // functionality attempts to find another placement.\n    const defaultPixelTolerance = 40;\n    let pixelTolerance: number;\n\n    const originalOffsetTop = offset.top;\n    const originalOffsetLeft = offset.left;\n\n    /* tslint:disable-next-line:switch-default */\n    switch (placement) {\n      case 'above':\n      case 'below':\n        // Keep the affixed element within the overflow parent.\n        if (offset.left < parentOffset.left) {\n          offset.left = parentOffset.left;\n        } else if (offset.left + affixedRect.width > parentOffset.right) {\n          offset.left = parentOffset.right - affixedRect.width;\n        }\n\n        // Use a smaller pixel tolerance if the base element width is less than the default.\n        pixelTolerance = Math.min(defaultPixelTolerance, baseRect.width);\n\n        // Make sure the affixed element never detaches from the base element.\n        if (\n          offset.left + pixelTolerance > baseRect.right ||\n          offset.left + affixedRect.width - pixelTolerance < baseRect.left\n        ) {\n          offset.left = originalOffsetLeft;\n        }\n\n        break;\n\n      case 'left':\n      case 'right':\n        // Keep the affixed element within the overflow parent.\n        if (offset.top < parentOffset.top) {\n          offset.top = parentOffset.top;\n        } else if (offset.top + affixedRect.height > parentOffset.bottom) {\n          offset.top = parentOffset.bottom - affixedRect.height;\n        }\n\n        // Use a smaller pixel tolerance if the base element height is less than the default.\n        pixelTolerance = Math.min(defaultPixelTolerance, baseRect.height);\n\n        // Make sure the affixed element never detaches from the base element.\n        if (\n          offset.top + pixelTolerance > baseRect.bottom ||\n          offset.top + affixedRect.height - pixelTolerance < baseRect.top\n        ) {\n          offset.top = originalOffsetTop;\n        }\n\n        break;\n    }\n\n    return offset;\n  }\n\n  private getImmediateOverflowParent(): HTMLElement {\n    return this.overflowParents[this.overflowParents.length - 1];\n  }\n\n  private getAutoFitContextParent(): HTMLElement {\n    const bodyElement = this.overflowParents[0];\n\n    return this.config.autoFitContext === SkyAffixAutoFitContext.OverflowParent\n      ? this.getImmediateOverflowParent()\n      : bodyElement;\n  }\n\n  private notifyPlacementChange(placement: SkyAffixPlacement | null): void {\n    if (this.currentPlacement !== placement) {\n      this.currentPlacement = placement;\n      this._placementChange.next({\n        placement,\n      });\n    }\n  }\n\n  private reset(): void {\n    this.removeScrollListeners();\n    this.removeResizeListener();\n\n    this._config =\n      this.affixedRect =\n      this.baseElement =\n      this.baseRect =\n      this.currentPlacement =\n      this.currentOffset =\n      this.overflowParents =\n        undefined;\n  }\n\n  private isNewOffset(offset: SkyAffixOffset): boolean {\n    if (this.currentOffset === undefined) {\n      this.currentOffset = offset;\n      return true;\n    }\n\n    if (\n      this.currentOffset.top === offset.top &&\n      this.currentOffset.left === offset.left\n    ) {\n      return false;\n    }\n\n    this.currentOffset = offset;\n\n    return true;\n  }\n\n  private isBaseElementVisible(): boolean {\n    return isOffsetPartiallyVisibleWithinParent(\n      this.getImmediateOverflowParent(),\n      {\n        top: this.baseRect.top,\n        left: this.baseRect.left,\n        right: this.baseRect.right,\n        bottom: this.baseRect.bottom,\n      },\n      this.config.autoFitOverflowOffset\n    );\n  }\n\n  private addScrollListeners(): void {\n    this.scrollListeners = this.overflowParents.map((parentElement) => {\n      const overflow =\n        parentElement === document.body ? 'window' : parentElement;\n      return this.renderer.listen(overflow, 'scroll', () => {\n        this.affix();\n        this._overflowScroll.next();\n      });\n    });\n  }\n\n  private addResizeListener(): void {\n    this.resizeListener = fromEvent(window, 'resize').subscribe(() =>\n      this.affix()\n    );\n  }\n\n  private removeResizeListener(): void {\n    if (this.resizeListener) {\n      this.resizeListener.unsubscribe();\n      this.resizeListener = undefined;\n    }\n  }\n\n  private removeScrollListeners(): void {\n    if (this.scrollListeners) {\n      // Remove renderer-generated listeners by calling the listener itself.\n      // https://github.com/angular/angular/issues/9368#issuecomment-227199778\n      this.scrollListeners.forEach((listener) => listener());\n      this.scrollListeners = undefined;\n    }\n  }\n}\n"]}

package/esm2020/lib/modules/affix/dom-utils.mjs

@@ -0,0 +1,77 @@
+/**
+ * Returns the offset values of a given element.
+ * @param element The HTML element.
+ * @param bufferOffset An optional offset to add/subtract to the element's actual offset.
+ */
+export function getElementOffset(element, bufferOffset = {}) {
+    const bufferOffsetBottom = bufferOffset.bottom || 0;
+    const bufferOffsetLeft = bufferOffset.left || 0;
+    const bufferOffsetRight = bufferOffset.right || 0;
+    const bufferOffsetTop = bufferOffset.top || 0;
+    let top;
+    let left;
+    let right;
+    let bottom;
+    if (element === document.body) {
+        left = 0;
+        top = 0;
+        right = document.documentElement.clientWidth;
+        bottom = document.documentElement.clientHeight;
+    }
+    else {
+        const clientRect = element.getBoundingClientRect();
+        left = clientRect.left;
+        top = clientRect.top;
+        right = clientRect.right;
+        bottom = clientRect.bottom;
+    }
+    bottom -= bufferOffsetBottom;
+    left += bufferOffsetLeft;
+    right -= bufferOffsetRight;
+    top += bufferOffsetTop;
+    return {
+        bottom,
+        left,
+        right,
+        top,
+    };
+}
+export function getOverflowParents(child) {
+    const bodyElement = window.document.body;
+    const results = [bodyElement];
+    let parentElement = child.parentNode;
+    while (parentElement !== undefined &&
+        parentElement !== bodyElement &&
+        parentElement instanceof HTMLElement) {
+        const overflowY = window
+            .getComputedStyle(parentElement, undefined)
+            .overflowY.toLowerCase();
+        if (overflowY === 'auto' ||
+            overflowY === 'hidden' ||
+            overflowY === 'scroll') {
+            results.push(parentElement);
+        }
+        parentElement = parentElement.parentNode;
+    }
+    return results;
+}
+/**
+ * Confirms offset is fully visible within a parent element.
+ * @param parent
+ * @param offset
+ */
+export function isOffsetFullyVisibleWithinParent(parent, offset, bufferOffset) {
+    const parentOffset = getElementOffset(parent, bufferOffset);
+    return !(parentOffset.top > offset.top ||
+        parentOffset.right < offset.right ||
+        parentOffset.bottom < offset.bottom ||
+        parentOffset.left > offset.left);
+}
+export function isOffsetPartiallyVisibleWithinParent(parent, offset, bufferOffset) {
+    const parentOffset = getElementOffset(parent, bufferOffset);
+    return !(parentOffset.top >= offset.bottom ||
+        parentOffset.right <= offset.left ||
+        parentOffset.bottom <= offset.top ||
+        parentOffset.left >= offset.right);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/dock/dock-dom-adapter.service.mjs

@@ -0,0 +1,80 @@
+import { Injectable, RendererFactory2, } from '@angular/core';
+import { Subject, fromEvent as observableFromEvent } from 'rxjs';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import { MutationObserverService } from '../mutation/mutation-observer-service';
+import * as i0 from "@angular/core";
+import * as i1 from "../mutation/mutation-observer-service";
+/**
+ * @internal
+ */
+export class SkyDockDomAdapterService {
+    constructor(mutationService, rendererFactory) {
+        this.mutationService = mutationService;
+        this.ngUnsubscribe = new Subject();
+        this.renderer = rendererFactory.createRenderer(undefined, undefined);
+    }
+    ngOnDestroy() {
+        if (this.observer) {
+            this.observer.disconnect();
+        }
+        this.ngUnsubscribe.next();
+        if (this.styleElement) {
+            this.destroyStyleElement();
+        }
+        this.currentDockHeight =
+            this.ngUnsubscribe =
+                this.observer =
+                    this.styleElement =
+                        undefined;
+    }
+    setSticky(elementRef) {
+        this.renderer.addClass(elementRef.nativeElement, 'sky-dock-sticky');
+    }
+    setZIndex(zIndex, elementRef) {
+        this.renderer.setStyle(elementRef.nativeElement, 'z-index', zIndex);
+    }
+    unbindDock(elementRef) {
+        this.renderer.addClass(elementRef.nativeElement, 'sky-dock-unbound');
+    }
+    watchDomChanges(elementRef) {
+        this.observer = this.mutationService.create(() => {
+            this.adjustBodyStyles(elementRef);
+        });
+        this.observer.observe(elementRef.nativeElement, {
+            attributes: true,
+            childList: true,
+            characterData: true,
+            subtree: true,
+        });
+        observableFromEvent(window, 'resize')
+            .pipe(debounceTime(250), takeUntil(this.ngUnsubscribe))
+            .subscribe(() => this.adjustBodyStyles(elementRef));
+    }
+    adjustBodyStyles(elementRef) {
+        const dockHeight = elementRef.nativeElement.getBoundingClientRect().height;
+        if (dockHeight === this.currentDockHeight) {
+            return;
+        }
+        // Create a style element to avoid overwriting any existing inline body styles.
+        const styleElement = this.renderer.createElement('style');
+        const textNode = this.renderer.createText(`body { margin-bottom: ${dockHeight}px; }`);
+        // Apply a `data-` attribute to make unit testing easier.
+        this.renderer.setAttribute(styleElement, 'data-test-selector', 'sky-layout-dock-bottom-styles');
+        this.renderer.appendChild(styleElement, textNode);
+        this.renderer.appendChild(document.head, styleElement);
+        if (this.styleElement) {
+            this.destroyStyleElement();
+        }
+        this.currentDockHeight = dockHeight;
+        this.styleElement = styleElement;
+    }
+    destroyStyleElement() {
+        this.renderer.removeChild(document.head, this.styleElement);
+    }
+}
+SkyDockDomAdapterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDockDomAdapterService, deps: [{ token: i1.MutationObserverService }, { token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyDockDomAdapterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDockDomAdapterService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDockDomAdapterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MutationObserverService }, { type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/dock/dock-insert-component-config.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jay1pbnNlcnQtY29tcG9uZW50LWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9kb2NrL2RvY2staW5zZXJ0LWNvbXBvbmVudC1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFN0YXRpY1Byb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreURvY2tJdGVtQ29uZmlnIH0gZnJvbSAnLi9kb2NrLWl0ZW0tY29uZmlnJztcblxuZXhwb3J0IGludGVyZmFjZSBTa3lEb2NrSW5zZXJ0Q29tcG9uZW50Q29uZmlnIGV4dGVuZHMgU2t5RG9ja0l0ZW1Db25maWcge1xuICAvKipcbiAgICogU3RhdGljIHByb3ZpZGVycyB0byBpbmplY3QgaW50byB0aGUgaXRlbSdzIGNvbXBvbmVudC5cbiAgICovXG4gIHByb3ZpZGVycz86IFN0YXRpY1Byb3ZpZGVyW107XG59XG4iXX0=

package/esm2020/lib/modules/dock/dock-item-config.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jay1pdGVtLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9kb2NrL2RvY2staXRlbS1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29uZmlndXJhdGlvbiB0byBiZSB1c2VkIGJ5IHRoZSBkb2NraW5nIGFjdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTa3lEb2NrSXRlbUNvbmZpZyB7XG4gIC8qKlxuICAgKiBUaGUgc3RhY2sgb3JkZXIgb2YgdGhlIGl0ZW0uIFRoZSBoaWdoZXIgdGhlIG51bWJlciwgdGhlIGhpZ2hlclxuICAgKiB0aGUgaXRlbSB3aWxsIGJlIHBsYWNlZCBpbiB0aGUgZG9jay4gQnkgZGVmYXVsdCwgbmV3IGl0ZW1zIHdpbGwgYmUgcGxhY2VkIGF0XG4gICAqIHRoZSB0b3Agb2YgdGhlIHN0YWNrLlxuICAgKi9cbiAgc3RhY2tPcmRlcj86IG51bWJlcjtcbn1cbiJdfQ==

package/esm2020/lib/modules/dock/dock-item-reference.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jay1pdGVtLXJlZmVyZW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9kb2NrL2RvY2staXRlbS1yZWZlcmVuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBkb2NrIGl0ZW0ncyBjb21wb25lbnQgcmVmZXJlbmNlLlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2t5RG9ja0l0ZW1SZWZlcmVuY2U8VD4ge1xuICBjb21wb25lbnRSZWY6IENvbXBvbmVudFJlZjxUPjtcblxuICBzdGFja09yZGVyOiBudW1iZXI7XG59XG4iXX0=