@skyux/core 5.9.4 → 6.0.0-beta.10

package/esm2020/index.mjs

@@ -0,0 +1,64 @@
+export * from './lib/modules/adapter-service/adapter.module';
+export * from './lib/modules/adapter-service/adapter.service';
+export * from './lib/modules/adapter-service/focusable-children-options';
+export * from './lib/modules/affix/affix-auto-fit-context';
+export * from './lib/modules/affix/affix-config';
+export * from './lib/modules/affix/affix-horizontal-alignment';
+export * from './lib/modules/affix/affix-offset';
+export * from './lib/modules/affix/affix-offset-change';
+export * from './lib/modules/affix/affix-placement';
+export * from './lib/modules/affix/affix-placement-change';
+export * from './lib/modules/affix/affix-vertical-alignment';
+export * from './lib/modules/affix/affix.module';
+export * from './lib/modules/affix/affix.service';
+export * from './lib/modules/affix/affixer';
+export * from './lib/modules/dock/dock-insert-component-config';
+export * from './lib/modules/dock/dock-item';
+export * from './lib/modules/dock/dock-item-config';
+export * from './lib/modules/dock/dock-location';
+export * from './lib/modules/dock/dock-options';
+export * from './lib/modules/dock/dock.module';
+export * from './lib/modules/dock/dock.service';
+export * from './lib/modules/dynamic-component/dynamic-component-location';
+export * from './lib/modules/dynamic-component/dynamic-component-options';
+export * from './lib/modules/dynamic-component/dynamic-component.module';
+export * from './lib/modules/dynamic-component/dynamic-component.service';
+export * from './lib/modules/format/app-format';
+export * from './lib/modules/id/id.module';
+export * from './lib/modules/log/log.module';
+export * from './lib/modules/log/log.service';
+export * from './lib/modules/log/types/log-level';
+export * from './lib/modules/log/types/log-level-token';
+export * from './lib/modules/media-query/media-breakpoints';
+export * from './lib/modules/media-query/media-query-listener';
+export * from './lib/modules/media-query/media-query.module';
+export * from './lib/modules/media-query/media-query.service';
+export * from './lib/modules/mutation/mutation-observer-service';
+export * from './lib/modules/numeric/numeric-symbol';
+export * from './lib/modules/numeric/numeric.module';
+export * from './lib/modules/numeric/numeric.options';
+export * from './lib/modules/numeric/numeric.pipe';
+export * from './lib/modules/numeric/numeric.service';
+export * from './lib/modules/overlay/overlay-config';
+export * from './lib/modules/overlay/overlay-instance';
+export * from './lib/modules/overlay/overlay.module';
+export * from './lib/modules/overlay/overlay.service';
+export * from './lib/modules/percent-pipe/percent-pipe.module';
+export * from './lib/modules/percent-pipe/percent.pipe';
+export * from './lib/modules/resize-observer/resize-observer.service';
+export * from './lib/modules/resize-observer/resize-observer-media-query.service';
+export * from './lib/modules/scrollable-host/scrollable-host.service';
+export * from './lib/modules/title/set-title-args';
+export * from './lib/modules/title/title.service';
+export * from './lib/modules/ui-config/ui-config.service';
+export * from './lib/modules/viewkeeper/viewkeeper-host-options';
+export * from './lib/modules/viewkeeper/viewkeeper-options';
+export * from './lib/modules/viewkeeper/viewkeeper.module';
+export * from './lib/modules/viewkeeper/viewkeeper.service';
+export * from './lib/modules/window/window-ref';
+// Components and directives must be exported to support Angular's "partial" Ivy compiler.
+// Obscure names are used to indicate types are not part of the public API.
+export { SkyAffixDirective as λ1 } from './lib/modules/affix/affix.directive';
+export { SkyIdDirective as λ2 } from './lib/modules/id/id.directive';
+export { SkyViewkeeperDirective as λ3 } from './lib/modules/viewkeeper/viewkeeper.directive';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/adapter-service/adapter.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated The `SkyCoreAdapterService` no longer needs the `SkyCoreAdapterModule`.
+ * The `SkyCoreAdapterModule` can be removed from your project.
+ */
+export class SkyCoreAdapterModule {
+}
+SkyCoreAdapterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyCoreAdapterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterModule });
+SkyCoreAdapterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRhcHRlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvYWRhcHRlci1zZXJ2aWNlL2FkYXB0ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRXpDOzs7R0FHRztBQUVILE1BQU0sT0FBTyxvQkFBb0I7O2lIQUFwQixvQkFBb0I7a0hBQXBCLG9CQUFvQjtrSEFBcEIsb0JBQW9COzJGQUFwQixvQkFBb0I7a0JBRGhDLFFBQVE7bUJBQUMsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgVGhlIGBTa3lDb3JlQWRhcHRlclNlcnZpY2VgIG5vIGxvbmdlciBuZWVkcyB0aGUgYFNreUNvcmVBZGFwdGVyTW9kdWxlYC5cbiAqIFRoZSBgU2t5Q29yZUFkYXB0ZXJNb2R1bGVgIGNhbiBiZSByZW1vdmVkIGZyb20geW91ciBwcm9qZWN0LlxuICovXG5ATmdNb2R1bGUoe30pXG5leHBvcnQgY2xhc3MgU2t5Q29yZUFkYXB0ZXJNb2R1bGUge31cbiJdfQ==

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

@@ -0,0 +1,225 @@
+import { Injectable, RendererFactory2, } from '@angular/core';
+import { SkyMediaBreakpoints } from '../media-query/media-breakpoints';
+import * as i0 from "@angular/core";
+const SKY_TABBABLE_SELECTOR = [
+    'a[href]',
+    'area[href]',
+    'input:not([disabled])',
+    'button:not([disabled])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    'iframe',
+    'object',
+    'embed',
+    '*[contenteditable=true]:not([disabled])',
+    '*[tabindex]:not([disabled])',
+].join(', ');
+export class SkyCoreAdapterService {
+    constructor(rendererFactory) {
+        this.rendererFactory = rendererFactory;
+        this.renderer = this.rendererFactory.createRenderer(undefined, undefined);
+    }
+    /**
+     * Set the responsive container CSS class for a given element.
+     *
+     * @param elementRef - The element that will recieve the new CSS class.
+     * @param breakpoint - The SkyMediaBreakpoint will determine which class
+     * gets set. For example a SkyMediaBreakpoint of `xs` will set a CSS class of `sky-responsive-container-xs`.
+     */
+    setResponsiveContainerClass(elementRef, breakpoint) {
+        const nativeEl = elementRef.nativeElement;
+        this.renderer.removeClass(nativeEl, 'sky-responsive-container-xs');
+        this.renderer.removeClass(nativeEl, 'sky-responsive-container-sm');
+        this.renderer.removeClass(nativeEl, 'sky-responsive-container-md');
+        this.renderer.removeClass(nativeEl, 'sky-responsive-container-lg');
+        let newClass;
+        switch (breakpoint) {
+            case SkyMediaBreakpoints.xs: {
+                newClass = 'sky-responsive-container-xs';
+                break;
+            }
+            case SkyMediaBreakpoints.sm: {
+                newClass = 'sky-responsive-container-sm';
+                break;
+            }
+            case SkyMediaBreakpoints.md: {
+                newClass = 'sky-responsive-container-md';
+                break;
+            }
+            default: {
+                newClass = 'sky-responsive-container-lg';
+                break;
+            }
+        }
+        this.renderer.addClass(nativeEl, newClass);
+    }
+    /**
+     * This method temporarily enables/disables pointer events.
+     * This is helpful to prevent iFrames from interfering with drag events.
+     *
+     * @param enable - Set to `true` to enable pointer events. Set to `false` to disable.
+     */
+    toggleIframePointerEvents(enable) {
+        const iframes = document.querySelectorAll('iframe');
+        for (let i = 0; i < iframes.length; i++) {
+            // Setting to empty string will allow iframe to fall back to its prior CSS assignment.
+            iframes[i].style.pointerEvents = enable ? '' : 'none';
+        }
+    }
+    /**
+     * Focuses on the first element found with an `autofocus` attribute inside the supplied `elementRef`.
+     *
+     * @param elementRef - The element to search within.
+     * @return Returns `true` if a child element with autofocus is found.
+     */
+    applyAutoFocus(elementRef) {
+        if (!elementRef) {
+            return false;
+        }
+        const elementWithAutoFocus = elementRef.nativeElement.querySelector('[autofocus]');
+        // Child was found with the autofocus property. Set focus and return true.
+        if (elementWithAutoFocus) {
+            elementWithAutoFocus.focus();
+            return true;
+        }
+        // No children were found with autofocus property. Return false.
+        return false;
+    }
+    /**
+     * Sets focus on the first focusable child of the `elementRef` parameter.
+     * If no focusable children are found, and `focusOnContainerIfNoChildrenFound` is `true`,
+     * focus will be set on the container element.
+     *
+     * @param elementRef - The element to search within.
+     * @param containerSelector - A CSS selector indicating the container that should
+     * recieve focus if no focusable children are found.
+     * @param focusOnContainerIfNoChildrenFound - It set to `true`, the container will
+     * recieve focus if no focusable children are found.
+     */
+    getFocusableChildrenAndApplyFocus(elementRef, containerSelector, focusOnContainerIfNoChildrenFound = false) {
+        const containerElement = elementRef.nativeElement.querySelector(containerSelector);
+        if (containerElement) {
+            const focusableChildren = this.getFocusableChildren(containerElement);
+            // Focus first focusable child if available. Otherwise, set focus on container.
+            if (!this.focusFirstElement(focusableChildren) &&
+                focusOnContainerIfNoChildrenFound) {
+                containerElement.focus();
+            }
+        }
+    }
+    /**
+     * Returns an array of all focusable children of provided `element`.
+     *
+     * @param element - The HTMLElement to search within.
+     * @param options - Options for getting focusable children.
+     */
+    getFocusableChildren(element, options) {
+        if (!element) {
+            return [];
+        }
+        let elements = Array.prototype.slice.call(element.querySelectorAll(SKY_TABBABLE_SELECTOR));
+        // Unless ignoreTabIndex = true, filter out elements with tabindex = -1.
+        if (!options || !options.ignoreTabIndex) {
+            elements = elements.filter((el) => {
+                return el.tabIndex !== -1;
+            });
+        }
+        // Unless ignoreVisibility = true, filter out elements that are not visible.
+        if (!options || !options.ignoreVisibility) {
+            elements = elements.filter((el) => {
+                return this.isVisible(el);
+            });
+        }
+        return elements;
+    }
+    /**
+     * Returns the clientWidth of the provided elementRef.
+     * @param elementRef - The element to calculate width from.
+     */
+    getWidth(elementRef) {
+        return elementRef.nativeElement.clientWidth;
+    }
+    /**
+     * Checks if an event target has a higher z-index than a given element.
+     * @param target The event target element.
+     * @param element The element to test against. A z-index must be explicitly set for this element.
+     */
+    isTargetAboveElement(target, element) {
+        const zIndex = getComputedStyle(element).zIndex;
+        let el = target;
+        while (el) {
+            // Getting the computed style only works for elements that exist in the DOM.
+            // In certain scenarios, an element is removed after a click event; by the time the event
+            // bubbles up to other elements, however, the element has been removed and the computed style returns empty.
+            // In this case, we'll need to check the z-index directly, via the style property.
+            const targetZIndex = getComputedStyle(el).zIndex || el.style.zIndex;
+            if (targetZIndex !== '' &&
+                targetZIndex !== 'auto' &&
+                +targetZIndex > +zIndex) {
+                return true;
+            }
+            el = el.parentElement;
+        }
+        return false;
+    }
+    /**
+     * Remove inline height styles from the provided elements.
+     * @param elementRef - The element to search within.
+     * @param selector - The CSS selector to use when finding elements for removing height.
+     */
+    resetHeight(elementRef, selector) {
+        const children = elementRef.nativeElement.querySelectorAll(selector);
+        /* istanbul ignore else */
+        if (children.length > 0) {
+            for (let i = 0; i < children.length; i++) {
+                // Setting style attributes with Web API requires null instead of undefined.
+                children[i].style.height = null;
+            }
+        }
+    }
+    /**
+     * Sets all element heights to match the height of the tallest element.
+     * @param elementRef - The element to search within.
+     * @param selector - The CSS selector to use when finding elements for syncing height.
+     */
+    syncMaxHeight(elementRef, selector) {
+        const children = elementRef.nativeElement.querySelectorAll(selector);
+        /* istanbul ignore else */
+        if (children.length > 0) {
+            let maxHeight = 0;
+            for (let i = 0; i < children.length; i++) {
+                maxHeight = Math.max(maxHeight, children[i].offsetHeight);
+            }
+            for (let i = 0; i < children.length; i++) {
+                children[i].style.height = maxHeight + 'px';
+            }
+        }
+    }
+    focusFirstElement(list) {
+        if (list.length > 0) {
+            list[0].focus();
+            return true;
+        }
+        return false;
+    }
+    isVisible(element) {
+        const style = window.getComputedStyle(element);
+        const isHidden = style.display === 'none' || style.visibility === 'hidden';
+        if (isHidden) {
+            return false;
+        }
+        const hasBounds = !!(element.offsetWidth ||
+            element.offsetHeight ||
+            element.getClientRects().length);
+        return hasBounds;
+    }
+}
+SkyCoreAdapterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyCoreAdapterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyCoreAdapterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/adapter-service/adapter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ElementRef,\n  Injectable,\n  Renderer2,\n  RendererFactory2,\n} from '@angular/core';\n\nimport { SkyMediaBreakpoints } from '../media-query/media-breakpoints';\n\nimport { SkyFocusableChildrenOptions } from './focusable-children-options';\n\nconst SKY_TABBABLE_SELECTOR = [\n  'a[href]',\n  'area[href]',\n  'input:not([disabled])',\n  'button:not([disabled])',\n  'select:not([disabled])',\n  'textarea:not([disabled])',\n  'iframe',\n  'object',\n  'embed',\n  '*[contenteditable=true]:not([disabled])',\n  '*[tabindex]:not([disabled])',\n].join(', ');\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SkyCoreAdapterService {\n  private renderer: Renderer2;\n\n  constructor(private rendererFactory: RendererFactory2) {\n    this.renderer = this.rendererFactory.createRenderer(undefined, undefined);\n  }\n\n  /**\n   * Set the responsive container CSS class for a given element.\n   *\n   * @param elementRef - The element that will recieve the new CSS class.\n   * @param breakpoint - The SkyMediaBreakpoint will determine which class\n   * gets set. For example a SkyMediaBreakpoint of `xs` will set a CSS class of `sky-responsive-container-xs`.\n   */\n  public setResponsiveContainerClass(\n    elementRef: ElementRef,\n    breakpoint: SkyMediaBreakpoints\n  ): void {\n    const nativeEl: HTMLElement = elementRef.nativeElement;\n\n    this.renderer.removeClass(nativeEl, 'sky-responsive-container-xs');\n    this.renderer.removeClass(nativeEl, 'sky-responsive-container-sm');\n    this.renderer.removeClass(nativeEl, 'sky-responsive-container-md');\n    this.renderer.removeClass(nativeEl, 'sky-responsive-container-lg');\n\n    let newClass: string;\n\n    switch (breakpoint) {\n      case SkyMediaBreakpoints.xs: {\n        newClass = 'sky-responsive-container-xs';\n        break;\n      }\n      case SkyMediaBreakpoints.sm: {\n        newClass = 'sky-responsive-container-sm';\n        break;\n      }\n      case SkyMediaBreakpoints.md: {\n        newClass = 'sky-responsive-container-md';\n        break;\n      }\n      default: {\n        newClass = 'sky-responsive-container-lg';\n        break;\n      }\n    }\n\n    this.renderer.addClass(nativeEl, newClass);\n  }\n\n  /**\n   * This method temporarily enables/disables pointer events.\n   * This is helpful to prevent iFrames from interfering with drag events.\n   *\n   * @param enable - Set to `true` to enable pointer events. Set to `false` to disable.\n   */\n  public toggleIframePointerEvents(enable: boolean): void {\n    const iframes = document.querySelectorAll('iframe');\n    for (let i = 0; i < iframes.length; i++) {\n      // Setting to empty string will allow iframe to fall back to its prior CSS assignment.\n      iframes[i].style.pointerEvents = enable ? '' : 'none';\n    }\n  }\n\n  /**\n   * Focuses on the first element found with an `autofocus` attribute inside the supplied `elementRef`.\n   *\n   * @param elementRef - The element to search within.\n   * @return Returns `true` if a child element with autofocus is found.\n   */\n  public applyAutoFocus(elementRef: ElementRef): boolean {\n    if (!elementRef) {\n      return false;\n    }\n\n    const elementWithAutoFocus =\n      elementRef.nativeElement.querySelector('[autofocus]');\n\n    // Child was found with the autofocus property. Set focus and return true.\n    if (elementWithAutoFocus) {\n      elementWithAutoFocus.focus();\n      return true;\n    }\n\n    // No children were found with autofocus property. Return false.\n    return false;\n  }\n\n  /**\n   * Sets focus on the first focusable child of the `elementRef` parameter.\n   * If no focusable children are found, and `focusOnContainerIfNoChildrenFound` is `true`,\n   * focus will be set on the container element.\n   *\n   * @param elementRef - The element to search within.\n   * @param containerSelector - A CSS selector indicating the container that should\n   * recieve focus if no focusable children are found.\n   * @param focusOnContainerIfNoChildrenFound - It set to `true`, the container will\n   * recieve focus if no focusable children are found.\n   */\n  public getFocusableChildrenAndApplyFocus(\n    elementRef: ElementRef,\n    containerSelector: string,\n    focusOnContainerIfNoChildrenFound: boolean = false\n  ): void {\n    const containerElement =\n      elementRef.nativeElement.querySelector(containerSelector);\n\n    if (containerElement) {\n      const focusableChildren = this.getFocusableChildren(containerElement);\n\n      // Focus first focusable child if available. Otherwise, set focus on container.\n      if (\n        !this.focusFirstElement(focusableChildren) &&\n        focusOnContainerIfNoChildrenFound\n      ) {\n        containerElement.focus();\n      }\n    }\n  }\n\n  /**\n   * Returns an array of all focusable children of provided `element`.\n   *\n   * @param element - The HTMLElement to search within.\n   * @param options - Options for getting focusable children.\n   */\n  public getFocusableChildren(\n    element: HTMLElement,\n    options?: SkyFocusableChildrenOptions\n  ): HTMLElement[] {\n    if (!element) {\n      return [];\n    }\n\n    let elements = Array.prototype.slice.call(\n      element.querySelectorAll(SKY_TABBABLE_SELECTOR)\n    );\n\n    // Unless ignoreTabIndex = true, filter out elements with tabindex = -1.\n    if (!options || !options.ignoreTabIndex) {\n      elements = elements.filter((el: HTMLElement) => {\n        return el.tabIndex !== -1;\n      });\n    }\n\n    // Unless ignoreVisibility = true, filter out elements that are not visible.\n    if (!options || !options.ignoreVisibility) {\n      elements = elements.filter((el: HTMLElement) => {\n        return this.isVisible(el);\n      });\n    }\n\n    return elements;\n  }\n\n  /**\n   * Returns the clientWidth of the provided elementRef.\n   * @param elementRef - The element to calculate width from.\n   */\n  public getWidth(elementRef: ElementRef): number {\n    return elementRef.nativeElement.clientWidth;\n  }\n\n  /**\n   * Checks if an event target has a higher z-index than a given element.\n   * @param target The event target element.\n   * @param element The element to test against. A z-index must be explicitly set for this element.\n   */\n  public isTargetAboveElement(\n    target: EventTarget,\n    element: HTMLElement\n  ): boolean {\n    const zIndex: string = getComputedStyle(element).zIndex;\n\n    let el: HTMLElement = target as HTMLElement;\n\n    while (el) {\n      // Getting the computed style only works for elements that exist in the DOM.\n      // In certain scenarios, an element is removed after a click event; by the time the event\n      // bubbles up to other elements, however, the element has been removed and the computed style returns empty.\n      // In this case, we'll need to check the z-index directly, via the style property.\n      const targetZIndex: string =\n        getComputedStyle(el).zIndex || el.style.zIndex;\n      if (\n        targetZIndex !== '' &&\n        targetZIndex !== 'auto' &&\n        +targetZIndex > +zIndex\n      ) {\n        return true;\n      }\n\n      el = el.parentElement as HTMLElement;\n    }\n\n    return false;\n  }\n\n  /**\n   * Remove inline height styles from the provided elements.\n   * @param elementRef - The element to search within.\n   * @param selector - The CSS selector to use when finding elements for removing height.\n   */\n  public resetHeight(elementRef: ElementRef, selector: string): void {\n    const children = elementRef.nativeElement.querySelectorAll(selector);\n    /* istanbul ignore else */\n    if (children.length > 0) {\n      for (let i = 0; i < children.length; i++) {\n        // Setting style attributes with Web API requires null instead of undefined.\n        children[i].style.height = null;\n      }\n    }\n  }\n\n  /**\n   * Sets all element heights to match the height of the tallest element.\n   * @param elementRef - The element to search within.\n   * @param selector - The CSS selector to use when finding elements for syncing height.\n   */\n  public syncMaxHeight(elementRef: ElementRef, selector: string): void {\n    const children = elementRef.nativeElement.querySelectorAll(selector);\n    /* istanbul ignore else */\n    if (children.length > 0) {\n      let maxHeight = 0;\n      for (let i = 0; i < children.length; i++) {\n        maxHeight = Math.max(maxHeight, children[i].offsetHeight);\n      }\n      for (let i = 0; i < children.length; i++) {\n        children[i].style.height = maxHeight + 'px';\n      }\n    }\n  }\n\n  private focusFirstElement(list: Array<HTMLElement>): boolean {\n    if (list.length > 0) {\n      list[0].focus();\n      return true;\n    }\n    return false;\n  }\n\n  private isVisible(element: HTMLElement): boolean {\n    const style = window.getComputedStyle(element);\n    const isHidden = style.display === 'none' || style.visibility === 'hidden';\n    if (isHidden) {\n      return false;\n    }\n\n    const hasBounds = !!(\n      element.offsetWidth ||\n      element.offsetHeight ||\n      element.getClientRects().length\n    );\n    return hasBounds;\n  }\n}\n"]}

package/esm2020/lib/modules/adapter-service/focusable-children-options.mjs

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

package/esm2020/lib/modules/affix/affix-auto-fit-context.mjs

@@ -0,0 +1,12 @@
+export var SkyAffixAutoFitContext;
+(function (SkyAffixAutoFitContext) {
+    /**
+     * Auto-fit functionality will respect the nearest overflow parent element's dimensions.
+     */
+    SkyAffixAutoFitContext[SkyAffixAutoFitContext["OverflowParent"] = 0] = "OverflowParent";
+    /**
+     * Auto-fit functionality will respect the browser viewport dimensions.
+     */
+    SkyAffixAutoFitContext[SkyAffixAutoFitContext["Viewport"] = 1] = "Viewport";
+})(SkyAffixAutoFitContext || (SkyAffixAutoFitContext = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZmaXgtYXV0by1maXQtY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9hZmZpeC9hZmZpeC1hdXRvLWZpdC1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHNCQVVYO0FBVkQsV0FBWSxzQkFBc0I7SUFDaEM7O09BRUc7SUFDSCx1RkFBa0IsQ0FBQTtJQUVsQjs7T0FFRztJQUNILDJFQUFZLENBQUE7QUFDZCxDQUFDLEVBVlcsc0JBQXNCLEtBQXRCLHNCQUFzQixRQVVqQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFNreUFmZml4QXV0b0ZpdENvbnRleHQge1xuICAvKipcbiAgICogQXV0by1maXQgZnVuY3Rpb25hbGl0eSB3aWxsIHJlc3BlY3QgdGhlIG5lYXJlc3Qgb3ZlcmZsb3cgcGFyZW50IGVsZW1lbnQncyBkaW1lbnNpb25zLlxuICAgKi9cbiAgT3ZlcmZsb3dQYXJlbnQgPSAwLFxuXG4gIC8qKlxuICAgKiBBdXRvLWZpdCBmdW5jdGlvbmFsaXR5IHdpbGwgcmVzcGVjdCB0aGUgYnJvd3NlciB2aWV3cG9ydCBkaW1lbnNpb25zLlxuICAgKi9cbiAgVmlld3BvcnQgPSAxLFxufVxuIl19

package/esm2020/lib/modules/affix/affix-config.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/affix/affix-horizontal-alignment.mjs

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

package/esm2020/lib/modules/affix/affix-offset-change.mjs

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

package/esm2020/lib/modules/affix/affix-offset.mjs

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

package/esm2020/lib/modules/affix/affix-placement-change.mjs

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

package/esm2020/lib/modules/affix/affix-placement.mjs

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

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

@@ -0,0 +1,18 @@
+export function getNextPlacement(placement) {
+    const placements = ['above', 'right', 'below', 'left'];
+    let index = placements.indexOf(placement) + 1;
+    if (index >= placements.length) {
+        index = 0;
+    }
+    return placements[index];
+}
+export function getInversePlacement(placement) {
+    const pairings = {
+        above: 'below',
+        below: 'above',
+        right: 'left',
+        left: 'right',
+    };
+    return pairings[placement];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZmaXgtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvYWZmaXgvYWZmaXgtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixTQUE0QjtJQUU1QixNQUFNLFVBQVUsR0FBd0IsQ0FBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUU1RSxJQUFJLEtBQUssR0FBRyxVQUFVLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUM5QyxJQUFJLEtBQUssSUFBSSxVQUFVLENBQUMsTUFBTSxFQUFFO1FBQzlCLEtBQUssR0FBRyxDQUFDLENBQUM7S0FDWDtJQUVELE9BQU8sVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQzNCLENBQUM7QUFFRCxNQUFNLFVBQVUsbUJBQW1CLENBQ2pDLFNBQTRCO0lBRTVCLE1BQU0sUUFBUSxHQUF1QztRQUNuRCxLQUFLLEVBQUUsT0FBTztRQUNkLEtBQUssRUFBRSxPQUFPO1FBQ2QsS0FBSyxFQUFFLE1BQU07UUFDYixJQUFJLEVBQUUsT0FBTztLQUNkLENBQUM7SUFFRixPQUFPLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUM3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5QWZmaXhQbGFjZW1lbnQgfSBmcm9tICcuL2FmZml4LXBsYWNlbWVudCc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXROZXh0UGxhY2VtZW50KFxuICBwbGFjZW1lbnQ6IFNreUFmZml4UGxhY2VtZW50XG4pOiBTa3lBZmZpeFBsYWNlbWVudCB7XG4gIGNvbnN0IHBsYWNlbWVudHM6IFNreUFmZml4UGxhY2VtZW50W10gPSBbJ2Fib3ZlJywgJ3JpZ2h0JywgJ2JlbG93JywgJ2xlZnQnXTtcblxuICBsZXQgaW5kZXggPSBwbGFjZW1lbnRzLmluZGV4T2YocGxhY2VtZW50KSArIDE7XG4gIGlmIChpbmRleCA+PSBwbGFjZW1lbnRzLmxlbmd0aCkge1xuICAgIGluZGV4ID0gMDtcbiAgfVxuXG4gIHJldHVybiBwbGFjZW1lbnRzW2luZGV4XTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEludmVyc2VQbGFjZW1lbnQoXG4gIHBsYWNlbWVudDogU2t5QWZmaXhQbGFjZW1lbnRcbik6IFNreUFmZml4UGxhY2VtZW50IHtcbiAgY29uc3QgcGFpcmluZ3M6IHsgW186IHN0cmluZ106IFNreUFmZml4UGxhY2VtZW50IH0gPSB7XG4gICAgYWJvdmU6ICdiZWxvdycsXG4gICAgYmVsb3c6ICdhYm92ZScsXG4gICAgcmlnaHQ6ICdsZWZ0JyxcbiAgICBsZWZ0OiAncmlnaHQnLFxuICB9O1xuXG4gIHJldHVybiBwYWlyaW5nc1twbGFjZW1lbnRdO1xufVxuIl19

package/esm2020/lib/modules/affix/affix-vertical-alignment.mjs

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

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

@@ -0,0 +1,100 @@
+import { Directive, ElementRef, EventEmitter, Input, Output, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyAffixAutoFitContext } from './affix-auto-fit-context';
+import { SkyAffixService } from './affix.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./affix.service";
+/**
+ * Affixes the host element to a base element.
+ */
+export class SkyAffixDirective {
+    constructor(elementRef, affixService) {
+        this.affixService = affixService;
+        /**
+         * Fires when the affixed element's offset changes.
+         */
+        this.affixOffsetChange = new EventEmitter();
+        /**
+         * Fires when the affixed element's overflow container is scrolled.
+         */
+        this.affixOverflowScroll = new EventEmitter();
+        /**
+         * Fires when the placement value changes.
+         */
+        this.affixPlacementChange = new EventEmitter();
+        this.ngUnsubscribe = new Subject();
+        this.affixer = this.affixService.createAffixer(elementRef);
+        this.affixer.offsetChange
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((change) => this.affixOffsetChange.emit(change));
+        this.affixer.overflowScroll
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((change) => this.affixOverflowScroll.emit(change));
+        this.affixer.placementChange
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((change) => this.affixPlacementChange.emit(change));
+    }
+    ngOnChanges(changes) {
+        /* istanbul ignore else */
+        if (changes.affixAutoFitContext ||
+            changes.affixAutoFitOverflowOffset ||
+            changes.affixEnableAutoFit ||
+            changes.affixHorizontalAlignment ||
+            changes.affixIsSticky ||
+            changes.affixPlacement ||
+            changes.affixVerticalAlignment) {
+            this.updateAlignment();
+        }
+    }
+    ngOnDestroy() {
+        this.affixOffsetChange.complete();
+        this.affixOverflowScroll.complete();
+        this.affixPlacementChange.complete();
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+        this.affixer.destroy();
+    }
+    updateAlignment() {
+        this.affixer.affixTo(this.skyAffixTo, {
+            autoFitContext: this.affixAutoFitContext,
+            autoFitOverflowOffset: this.affixAutoFitOverflowOffset,
+            enableAutoFit: this.affixEnableAutoFit,
+            horizontalAlignment: this.affixHorizontalAlignment,
+            isSticky: this.affixIsSticky,
+            placement: this.affixPlacement,
+            verticalAlignment: this.affixVerticalAlignment,
+        });
+    }
+}
+SkyAffixDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixDirective, deps: [{ token: i0.ElementRef }, { token: i1.SkyAffixService }], target: i0.ɵɵFactoryTarget.Directive });
+SkyAffixDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: SkyAffixDirective, selector: "[skyAffixTo]", inputs: { skyAffixTo: "skyAffixTo", affixAutoFitContext: "affixAutoFitContext", affixAutoFitOverflowOffset: "affixAutoFitOverflowOffset", affixEnableAutoFit: "affixEnableAutoFit", affixHorizontalAlignment: "affixHorizontalAlignment", affixIsSticky: "affixIsSticky", affixPlacement: "affixPlacement", affixVerticalAlignment: "affixVerticalAlignment" }, outputs: { affixOffsetChange: "affixOffsetChange", affixOverflowScroll: "affixOverflowScroll", affixPlacementChange: "affixPlacementChange" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[skyAffixTo]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.SkyAffixService }]; }, propDecorators: { skyAffixTo: [{
+                type: Input
+            }], affixAutoFitContext: [{
+                type: Input
+            }], affixAutoFitOverflowOffset: [{
+                type: Input
+            }], affixEnableAutoFit: [{
+                type: Input
+            }], affixHorizontalAlignment: [{
+                type: Input
+            }], affixIsSticky: [{
+                type: Input
+            }], affixPlacement: [{
+                type: Input
+            }], affixVerticalAlignment: [{
+                type: Input
+            }], affixOffsetChange: [{
+                type: Output
+            }], affixOverflowScroll: [{
+                type: Output
+            }], affixPlacementChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"affix.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/affix/affix.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyAffixAutoFitContext } from './affix-auto-fit-context';\nimport { SkyAffixHorizontalAlignment } from './affix-horizontal-alignment';\nimport { SkyAffixOffset } from './affix-offset';\nimport { SkyAffixOffsetChange } from './affix-offset-change';\nimport { SkyAffixPlacement } from './affix-placement';\nimport { SkyAffixPlacementChange } from './affix-placement-change';\nimport { SkyAffixVerticalAlignment } from './affix-vertical-alignment';\nimport { SkyAffixService } from './affix.service';\nimport { SkyAffixer } from './affixer';\n\n/**\n * Affixes the host element to a base element.\n */\n@Directive({\n  selector: '[skyAffixTo]',\n})\nexport class SkyAffixDirective implements OnChanges, OnDestroy {\n  /**\n   * The base element to affix the host element.\n   */\n  @Input()\n  public skyAffixTo: HTMLElement;\n\n  /**\n   * Sets the `autoFitContext` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixAutoFitContext: SkyAffixAutoFitContext;\n\n  /**\n   * Sets the `autoFitOverflowOffset` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixAutoFitOverflowOffset: SkyAffixOffset;\n\n  /**\n   * Sets the `enableAutoFit` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixEnableAutoFit: boolean;\n\n  /**\n   * Sets the `horizontalAlignment` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixHorizontalAlignment: SkyAffixHorizontalAlignment;\n\n  /**\n   * Sets the `isSticky` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixIsSticky: boolean;\n\n  /**\n   * Sets the `placement` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixPlacement: SkyAffixPlacement;\n\n  /**\n   * Sets the `verticalAlignment` property of [[SkyAffixConfig]].\n   */\n  @Input()\n  public affixVerticalAlignment: SkyAffixVerticalAlignment;\n\n  /**\n   * Fires when the affixed element's offset changes.\n   */\n  @Output()\n  public affixOffsetChange = new EventEmitter<SkyAffixOffsetChange>();\n\n  /**\n   * Fires when the affixed element's overflow container is scrolled.\n   */\n  @Output()\n  public affixOverflowScroll = new EventEmitter<void>();\n\n  /**\n   * Fires when the placement value changes.\n   */\n  @Output()\n  public affixPlacementChange = new EventEmitter<SkyAffixPlacementChange>();\n\n  private affixer: SkyAffixer;\n\n  private ngUnsubscribe = new Subject<void>();\n\n  constructor(elementRef: ElementRef, private affixService: SkyAffixService) {\n    this.affixer = this.affixService.createAffixer(elementRef);\n\n    this.affixer.offsetChange\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((change) => this.affixOffsetChange.emit(change));\n\n    this.affixer.overflowScroll\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((change) => this.affixOverflowScroll.emit(change));\n\n    this.affixer.placementChange\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((change) => this.affixPlacementChange.emit(change));\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    /* istanbul ignore else */\n    if (\n      changes.affixAutoFitContext ||\n      changes.affixAutoFitOverflowOffset ||\n      changes.affixEnableAutoFit ||\n      changes.affixHorizontalAlignment ||\n      changes.affixIsSticky ||\n      changes.affixPlacement ||\n      changes.affixVerticalAlignment\n    ) {\n      this.updateAlignment();\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.affixOffsetChange.complete();\n    this.affixOverflowScroll.complete();\n    this.affixPlacementChange.complete();\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n    this.affixer.destroy();\n  }\n\n  private updateAlignment(): void {\n    this.affixer.affixTo(this.skyAffixTo, {\n      autoFitContext: this.affixAutoFitContext,\n      autoFitOverflowOffset: this.affixAutoFitOverflowOffset,\n      enableAutoFit: this.affixEnableAutoFit,\n      horizontalAlignment: this.affixHorizontalAlignment,\n      isSticky: this.affixIsSticky,\n      placement: this.affixPlacement,\n      verticalAlignment: this.affixVerticalAlignment,\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { SkyAffixDirective } from './affix.directive';
+import * as i0 from "@angular/core";
+export class SkyAffixModule {
+}
+SkyAffixModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyAffixModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixModule, declarations: [SkyAffixDirective], imports: [CommonModule], exports: [SkyAffixDirective] });
+SkyAffixModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    exports: [SkyAffixDirective],
+                    declarations: [SkyAffixDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZmaXgubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2NvcmUvc3JjL2xpYi9tb2R1bGVzL2FmZml4L2FmZml4Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFPdEQsTUFBTSxPQUFPLGNBQWM7OzJHQUFkLGNBQWM7NEdBQWQsY0FBYyxpQkFGVixpQkFBaUIsYUFGdEIsWUFBWSxhQUNaLGlCQUFpQjs0R0FHaEIsY0FBYyxZQUpoQixDQUFDLFlBQVksQ0FBQzsyRkFJWixjQUFjO2tCQUwxQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsaUJBQWlCLENBQUM7b0JBQzVCLFlBQVksRUFBRSxDQUFDLGlCQUFpQixDQUFDO2lCQUNsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBTa3lBZmZpeERpcmVjdGl2ZSB9IGZyb20gJy4vYWZmaXguZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtTa3lBZmZpeERpcmVjdGl2ZV0sXG4gIGRlY2xhcmF0aW9uczogW1NreUFmZml4RGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5QWZmaXhNb2R1bGUge31cbiJdfQ==

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.3.2", ngImport: i0, type: SkyAffixService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyAffixService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyAffixService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZmaXguc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9hZmZpeC9hZmZpeC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxVQUFVLEVBRVYsZ0JBQWdCLEdBQ2pCLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxXQUFXLENBQUM7O0FBS3ZDLE1BQU0sT0FBTyxlQUFlO0lBRzFCLFlBQVksZUFBaUM7UUFDM0MsSUFBSSxDQUFDLFFBQVEsR0FBRyxlQUFlLENBQUMsY0FBYyxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYSxDQUFDLE9BQW1CO1FBQ3RDLE9BQU8sSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUQsQ0FBQzs7NEdBYlUsZUFBZTtnSEFBZixlQUFlLGNBRmQsTUFBTTsyRkFFUCxlQUFlO2tCQUgzQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIEVsZW1lbnRSZWYsXG4gIEluamVjdGFibGUsXG4gIFJlbmRlcmVyMixcbiAgUmVuZGVyZXJGYWN0b3J5Mixcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreUFmZml4ZXIgfSBmcm9tICcuL2FmZml4ZXInO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgU2t5QWZmaXhTZXJ2aWNlIHtcbiAgcHJpdmF0ZSByZW5kZXJlcjogUmVuZGVyZXIyO1xuXG4gIGNvbnN0cnVjdG9yKHJlbmRlcmVyRmFjdG9yeTogUmVuZGVyZXJGYWN0b3J5Mikge1xuICAgIHRoaXMucmVuZGVyZXIgPSByZW5kZXJlckZhY3RvcnkuY3JlYXRlUmVuZGVyZXIodW5kZWZpbmVkLCB1bmRlZmluZWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgW1tTa3lBZmZpeGVyXV0uXG4gICAqIEBwYXJhbSBhZmZpeGVkIFRoZSBlbGVtZW50IHRvIGJlIGFmZml4ZWQuXG4gICAqL1xuICBwdWJsaWMgY3JlYXRlQWZmaXhlcihhZmZpeGVkOiBFbGVtZW50UmVmKTogU2t5QWZmaXhlciB7XG4gICAgcmV0dXJuIG5ldyBTa3lBZmZpeGVyKGFmZml4ZWQubmF0aXZlRWxlbWVudCwgdGhpcy5yZW5kZXJlcik7XG4gIH1cbn1cbiJdfQ==