@skyux/core 8.7.2 → 9.0.0-alpha.1

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

@@ -0,0 +1,398 @@
+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 {
+    /**
+     * Fires when the affixed element's offset changes.
+     */
+    get offsetChange() {
+        return this.#offsetChangeObs;
+    }
+    /**
+     * 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.#overflowScrollObs;
+    }
+    /**
+     * Fires when the placement value changes. A `null` value indicates that a suitable
+     * placement could not be found.
+     */
+    get placementChange() {
+        return this.#placementChangeObs;
+    }
+    get #config() {
+        return this.#_config;
+    }
+    set #config(value) {
+        const merged = {
+            ...DEFAULT_AFFIX_CONFIG,
+            ...value,
+        };
+        // Make sure none of the values are undefined.
+        let key;
+        for (key in merged) {
+            if (merged[key] === undefined) {
+                merged[key] = DEFAULT_AFFIX_CONFIG[key];
+            }
+        }
+        this.#_config = merged;
+    }
+    #affixedElement;
+    #baseElement;
+    #currentOffset;
+    #currentPlacement;
+    #offsetChange;
+    #offsetChangeObs;
+    #overflowParents = [];
+    #overflowScroll;
+    #overflowScrollObs;
+    #placementChange;
+    #placementChangeObs;
+    #renderer;
+    #resizeListener;
+    #scrollListeners;
+    #_config = DEFAULT_AFFIX_CONFIG;
+    constructor(affixedElement, renderer) {
+        this.#affixedElement = affixedElement;
+        this.#renderer = renderer;
+        this.#offsetChange = new Subject();
+        this.#overflowScroll = new Subject();
+        this.#placementChange = new Subject();
+        this.#offsetChangeObs = this.#offsetChange.asObservable();
+        this.#overflowScrollObs = this.#overflowScroll.asObservable();
+        this.#placementChangeObs = this.#placementChange.asObservable();
+    }
+    /**
+     * 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();
+        }
+    }
+    getConfig() {
+        return this.#config;
+    }
+    /**
+     * 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();
+    }
+    #affix() {
+        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;
+        const autoFitOverflowOffset = this.#config.autoFitOverflowOffset || {
+            bottom: 0,
+            left: 0,
+            right: 0,
+            top: 0,
+        };
+        if (this.#config.position === 'absolute') {
+            autoFitOverflowOffset.top =
+                (autoFitOverflowOffset.top || 0) + window.scrollY;
+        }
+        do {
+            offset = this.#getPreferredOffset(placement);
+            isAffixedElementFullyVisible = isOffsetFullyVisibleWithinParent(parent, offset, 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 {
+                this.#notifyPlacementChange(null);
+            }
+            return offset;
+        }
+        if (this.#config.enableAutoFit) {
+            this.#notifyPlacementChange(null);
+        }
+        // No suitable placement was found, so revert to preferred placement.
+        return this.#getPreferredOffset(this.#config.placement);
+    }
+    #getRect(baseElement) {
+        const baseDomRect = baseElement.getBoundingClientRect();
+        const baseRect = {
+            top: baseDomRect.top,
+            bottom: baseDomRect.bottom,
+            left: baseDomRect.left,
+            right: baseDomRect.right,
+            width: baseDomRect.width,
+            height: baseDomRect.height,
+        };
+        if (this.#config.position === 'absolute') {
+            baseRect.top += window.scrollY;
+            baseRect.bottom = baseRect.top + baseDomRect.height;
+        }
+        return baseRect;
+    }
+    #getPreferredOffset(placement) {
+        if (!this.#baseElement) {
+            return { top: 0, left: 0, bottom: 0, right: 0 };
+        }
+        const affixedRect = this.#getRect(this.#affixedElement);
+        const baseRect = this.#getRect(this.#baseElement);
+        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;
+            }
+        }
+        const offset = { top, left, bottom: 0, right: 0 };
+        if (enableAutoFit) {
+            const adjustments = this.#adjustOffsetToOverflowParent({ top, left }, placement, this.#baseElement);
+            offset.top = adjustments.top;
+            offset.left = adjustments.left;
+        }
+        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, baseElement) {
+        const parent = this.#getAutoFitContextParent();
+        const parentOffset = getElementOffset(parent, this.#config.autoFitOverflowOffset);
+        const affixedRect = this.#getRect(this.#affixedElement);
+        const baseRect = this.#getRect(baseElement);
+        // A pixel value representing the leeway between the edge of the overflow parent and the edge
+        // of the base element before it disappears 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;
+        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 ?? undefined;
+            this.#placementChange.next({
+                placement,
+            });
+        }
+    }
+    #reset() {
+        this.#removeScrollListeners();
+        this.#removeResizeListener();
+        this.#overflowParents = [];
+        this.#config =
+            this.#baseElement =
+                this.#currentPlacement =
+                    this.#currentOffset =
+                        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() {
+        if (!this.#baseElement) {
+            return false;
+        }
+        const baseRect = this.#baseElement.getBoundingClientRect();
+        return isOffsetPartiallyVisibleWithinParent(this.#getImmediateOverflowParent(), {
+            top: baseRect.top,
+            left: baseRect.left,
+            right: baseRect.right,
+            bottom: 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 { AffixRect } from './affix-rect';\nimport { getInversePlacement, getNextPlacement } from './affix-utils';\nimport {\n  getElementOffset,\n  getOverflowParents,\n  isOffsetFullyVisibleWithinParent,\n  isOffsetPartiallyVisibleWithinParent,\n} from './dom-utils';\n\n/**\n * Make specific properties required, so that we don't have to\n * do null checks throughout this file.\n */\ntype AffixConfigOrDefaults = SkyAffixConfig &\n  Required<\n    Pick<\n      SkyAffixConfig,\n      | 'autoFitContext'\n      | 'enableAutoFit'\n      | 'horizontalAlignment'\n      | 'isSticky'\n      | 'placement'\n    >\n  >;\n\nconst DEFAULT_AFFIX_CONFIG: AffixConfigOrDefaults = {\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.#offsetChangeObs;\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.#overflowScrollObs;\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.#placementChangeObs;\n  }\n\n  get #config(): AffixConfigOrDefaults {\n    return this.#_config;\n  }\n\n  set #config(value: SkyAffixConfig | undefined) {\n    const merged: AffixConfigOrDefaults = {\n      ...DEFAULT_AFFIX_CONFIG,\n      ...value,\n    };\n\n    // Make sure none of the values are undefined.\n    let key: keyof typeof merged;\n    for (key in merged) {\n      if (merged[key] === undefined) {\n        (merged as any)[key] = DEFAULT_AFFIX_CONFIG[key];\n      }\n    }\n\n    this.#_config = merged;\n  }\n\n  #affixedElement: HTMLElement;\n\n  #baseElement: HTMLElement | undefined;\n\n  #currentOffset: SkyAffixOffset | undefined;\n\n  #currentPlacement: SkyAffixPlacement | undefined;\n\n  #offsetChange: Subject<SkyAffixOffsetChange>;\n\n  #offsetChangeObs: Observable<SkyAffixOffsetChange>;\n\n  #overflowParents: HTMLElement[] = [];\n\n  #overflowScroll: Subject<void>;\n\n  #overflowScrollObs: Observable<void>;\n\n  #placementChange: Subject<SkyAffixPlacementChange>;\n\n  #placementChangeObs: Observable<SkyAffixPlacementChange>;\n\n  #renderer: Renderer2;\n\n  #resizeListener: Subscription | undefined;\n\n  #scrollListeners: (() => void)[] | undefined;\n\n  #_config: AffixConfigOrDefaults = DEFAULT_AFFIX_CONFIG;\n\n  constructor(affixedElement: HTMLElement, renderer: Renderer2) {\n    this.#affixedElement = affixedElement;\n    this.#renderer = renderer;\n\n    this.#offsetChange = new Subject<SkyAffixOffsetChange>();\n    this.#overflowScroll = new Subject<void>();\n    this.#placementChange = new Subject<SkyAffixPlacementChange>();\n\n    this.#offsetChangeObs = this.#offsetChange.asObservable();\n    this.#overflowScrollObs = this.#overflowScroll.asObservable();\n    this.#placementChangeObs = this.#placementChange.asObservable();\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  public getConfig(): SkyAffixConfig {\n    return this.#config;\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\n  #affix(): void {\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\n      this.#offsetChange.next({ offset });\n    }\n  }\n\n  #getOffset(): SkyAffixOffset {\n    const parent = this.#getAutoFitContextParent();\n\n    const maxAttempts = 4;\n    let attempts = 0;\n\n    let isAffixedElementFullyVisible = false;\n    let offset: Required<SkyAffixOffset>;\n    let placement = this.#config.placement;\n\n    const autoFitOverflowOffset = this.#config.autoFitOverflowOffset || {\n      bottom: 0,\n      left: 0,\n      right: 0,\n      top: 0,\n    };\n\n    if (this.#config.position === 'absolute') {\n      autoFitOverflowOffset.top =\n        (autoFitOverflowOffset.top || 0) + window.scrollY;\n    }\n\n    do {\n      offset = this.#getPreferredOffset(placement);\n      isAffixedElementFullyVisible = isOffsetFullyVisibleWithinParent(\n        parent,\n        offset,\n        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        this.#notifyPlacementChange(null);\n      }\n\n      return offset;\n    }\n\n    if (this.#config.enableAutoFit) {\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  #getRect(baseElement: HTMLElement): AffixRect {\n    const baseDomRect = baseElement.getBoundingClientRect();\n\n    const baseRect: AffixRect = {\n      top: baseDomRect.top,\n      bottom: baseDomRect.bottom,\n      left: baseDomRect.left,\n      right: baseDomRect.right,\n      width: baseDomRect.width,\n      height: baseDomRect.height,\n    };\n\n    if (this.#config.position === 'absolute') {\n      baseRect.top += window.scrollY;\n      baseRect.bottom = baseRect.top + baseDomRect.height;\n    }\n\n    return baseRect;\n  }\n\n  #getPreferredOffset(placement: SkyAffixPlacement): Required<SkyAffixOffset> {\n    if (!this.#baseElement) {\n      return { top: 0, left: 0, bottom: 0, right: 0 };\n    }\n\n    const affixedRect = this.#getRect(this.#affixedElement);\n    const baseRect = this.#getRect(this.#baseElement);\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    const offset: Required<SkyAffixOffset> = { top, left, bottom: 0, right: 0 };\n\n    if (enableAutoFit) {\n      const adjustments = this.#adjustOffsetToOverflowParent(\n        { top, left },\n        placement,\n        this.#baseElement\n      );\n      offset.top = adjustments.top;\n      offset.left = adjustments.left;\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  #adjustOffsetToOverflowParent(\n    offset: { top: number; left: number },\n    placement: SkyAffixPlacement,\n    baseElement: HTMLElement\n  ): { top: number; left: number } {\n    const parent = this.#getAutoFitContextParent();\n    const parentOffset = getElementOffset(\n      parent,\n      this.#config.autoFitOverflowOffset\n    );\n\n    const affixedRect = this.#getRect(this.#affixedElement);\n    const baseRect = this.#getRect(baseElement);\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 disappears 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    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  #getImmediateOverflowParent(): HTMLElement {\n    return this.#overflowParents[this.#overflowParents.length - 1];\n  }\n\n  #getAutoFitContextParent(): HTMLElement {\n    const bodyElement = this.#overflowParents[0];\n\n    return this.#config.autoFitContext === SkyAffixAutoFitContext.OverflowParent\n      ? this.#getImmediateOverflowParent()\n      : bodyElement;\n  }\n\n  #notifyPlacementChange(placement: SkyAffixPlacement | null): void {\n    if (this.#currentPlacement !== placement) {\n      this.#currentPlacement = placement ?? undefined;\n      this.#placementChange.next({\n        placement,\n      });\n    }\n  }\n\n  #reset(): void {\n    this.#removeScrollListeners();\n    this.#removeResizeListener();\n\n    this.#overflowParents = [];\n\n    this.#config =\n      this.#baseElement =\n      this.#currentPlacement =\n      this.#currentOffset =\n        undefined;\n  }\n\n  #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  #isBaseElementVisible(): boolean {\n    if (!this.#baseElement) {\n      return false;\n    }\n\n    const baseRect = this.#baseElement.getBoundingClientRect();\n\n    return isOffsetPartiallyVisibleWithinParent(\n      this.#getImmediateOverflowParent(),\n      {\n        top: baseRect.top,\n        left: baseRect.left,\n        right: baseRect.right,\n        bottom: baseRect.bottom,\n      },\n      this.#config.autoFitOverflowOffset\n    );\n  }\n\n  #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  #addResizeListener(): void {\n    this.#resizeListener = fromEvent(window, 'resize').subscribe(() =>\n      this.#affix()\n    );\n  }\n\n  #removeResizeListener(): void {\n    if (this.#resizeListener) {\n      this.#resizeListener.unsubscribe();\n      this.#resizeListener = undefined;\n    }\n  }\n\n  #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/esm2022/lib/modules/default-input-provider/default-input-provider.mjs

@@ -0,0 +1,26 @@
+import { ReplaySubject } from 'rxjs';
+/**
+ * @internal
+ * An API to provide default Angular component input values to child components.
+ */
+export class SkyDefaultInputProvider {
+    #props = {};
+    setValue(componentName, inputName, value) {
+        const subject = this.#getSubject(componentName, inputName);
+        subject.next(value);
+    }
+    getValue(componentName, inputName) {
+        const test = this.#getSubject(componentName, inputName);
+        return test.asObservable();
+    }
+    #getSubject(componentName, inputName) {
+        const componentSubjects = this.#props[componentName] || {};
+        const inputSubject = componentSubjects[inputName];
+        if (!inputSubject) {
+            componentSubjects[inputName] = new ReplaySubject(1);
+            this.#props[componentName] = componentSubjects;
+        }
+        return componentSubjects[inputName];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,81 @@
+import { Injectable, } from '@angular/core';
+import { Subject, fromEvent as observableFromEvent } from 'rxjs';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../mutation/mutation-observer-service";
+/**
+ * @internal
+ */
+export class SkyDockDomAdapterService {
+    #currentDockHeight;
+    #mutationSvc;
+    #ngUnsubscribe = new Subject();
+    #observer;
+    #renderer;
+    #styleElement;
+    constructor(mutationSvc, rendererFactory) {
+        this.#mutationSvc = mutationSvc;
+        this.#renderer = rendererFactory.createRenderer(undefined, null);
+    }
+    ngOnDestroy() {
+        if (this.#observer) {
+            this.#observer.disconnect();
+        }
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+        if (this.#styleElement) {
+            this.#destroyStyleElement();
+        }
+        this.#currentDockHeight = 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.#mutationSvc.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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDockDomAdapterService, deps: [{ token: i1.SkyMutationObserverService }, { token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDockDomAdapterService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDockDomAdapterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SkyMutationObserverService }, { type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/dock/dock-item.mjs

@@ -0,0 +1,31 @@
+import { Subject } from 'rxjs';
+/**
+ * Represents a single item added to the dock.
+ */
+export class SkyDockItem {
+    /**
+     * An event that emits when the item is removed from the dock.
+     */
+    get destroyed() {
+        return this.#destroyedObs;
+    }
+    #destroyed = new Subject();
+    #destroyedObs;
+    /**
+     * @param componentInstance The item's component instance.
+     * @param stackOrder The assigned stack order of the docked item.
+     */
+    constructor(componentInstance, stackOrder) {
+        this.componentInstance = componentInstance;
+        this.stackOrder = stackOrder;
+        this.#destroyedObs = this.#destroyed.asObservable();
+    }
+    /**
+     * Removes the item from the dock.
+     */
+    destroy() {
+        this.#destroyed.next();
+        this.#destroyed.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jay1pdGVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2NvcmUvc3JjL2xpYi9tb2R1bGVzL2RvY2svZG9jay1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFM0M7O0dBRUc7QUFDSCxNQUFNLE9BQU8sV0FBVztJQUN0Qjs7T0FFRztJQUNILElBQVcsU0FBUztRQUNsQixPQUFPLElBQUksQ0FBQyxhQUFhLENBQUM7SUFDNUIsQ0FBQztJQUVELFVBQVUsR0FBRyxJQUFJLE9BQU8sRUFBUSxDQUFDO0lBRWpDLGFBQWEsQ0FBbUI7SUFFaEM7OztPQUdHO0lBQ0gsWUFDa0IsaUJBQW9CLEVBQ3BCLFVBQWtCO1FBRGxCLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBRztRQUNwQixlQUFVLEdBQVYsVUFBVSxDQUFRO1FBRWxDLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUN0RCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxPQUFPO1FBQ1osSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzdCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgc2luZ2xlIGl0ZW0gYWRkZWQgdG8gdGhlIGRvY2suXG4gKi9cbmV4cG9ydCBjbGFzcyBTa3lEb2NrSXRlbTxUPiB7XG4gIC8qKlxuICAgKiBBbiBldmVudCB0aGF0IGVtaXRzIHdoZW4gdGhlIGl0ZW0gaXMgcmVtb3ZlZCBmcm9tIHRoZSBkb2NrLlxuICAgKi9cbiAgcHVibGljIGdldCBkZXN0cm95ZWQoKTogT2JzZXJ2YWJsZTx2b2lkPiB7XG4gICAgcmV0dXJuIHRoaXMuI2Rlc3Ryb3llZE9icztcbiAgfVxuXG4gICNkZXN0cm95ZWQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuXG4gICNkZXN0cm95ZWRPYnM6IE9ic2VydmFibGU8dm9pZD47XG5cbiAgLyoqXG4gICAqIEBwYXJhbSBjb21wb25lbnRJbnN0YW5jZSBUaGUgaXRlbSdzIGNvbXBvbmVudCBpbnN0YW5jZS5cbiAgICogQHBhcmFtIHN0YWNrT3JkZXIgVGhlIGFzc2lnbmVkIHN0YWNrIG9yZGVyIG9mIHRoZSBkb2NrZWQgaXRlbS5cbiAgICovXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyByZWFkb25seSBjb21wb25lbnRJbnN0YW5jZTogVCxcbiAgICBwdWJsaWMgcmVhZG9ubHkgc3RhY2tPcmRlcjogbnVtYmVyXG4gICkge1xuICAgIHRoaXMuI2Rlc3Ryb3llZE9icyA9IHRoaXMuI2Rlc3Ryb3llZC5hc09ic2VydmFibGUoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZW1vdmVzIHRoZSBpdGVtIGZyb20gdGhlIGRvY2suXG4gICAqL1xuICBwdWJsaWMgZGVzdHJveSgpOiB2b2lkIHtcbiAgICB0aGlzLiNkZXN0cm95ZWQubmV4dCgpO1xuICAgIHRoaXMuI2Rlc3Ryb3llZC5jb21wbGV0ZSgpO1xuICB9XG59XG4iXX0=