@skyux/core 8.7.0 → 9.0.0-alpha.0

package/esm2022/lib/modules/viewkeeper/viewkeeper.directive.mjs

@@ -0,0 +1,131 @@
+import { Directive, Input, Optional, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../mutation/mutation-observer-service";
+import * as i2 from "./viewkeeper.service";
+import * as i3 from "../scrollable-host/scrollable-host.service";
+export class SkyViewkeeperDirective {
+    set skyViewkeeper(value) {
+        this.#_skyViewkeeper = value;
+        this.#detectElements();
+    }
+    get skyViewkeeper() {
+        return this.#_skyViewkeeper;
+    }
+    #_skyViewkeeper;
+    #currentViewkeeperEls;
+    #el;
+    #mutationObserverSvc;
+    #observer;
+    #scrollableHostSvc;
+    #scrollableHostWatchUnsubscribe;
+    #viewkeepers = [];
+    #viewkeeperSvc;
+    constructor(el, mutationObserverSvc, viewkeeperSvc, scrollableHostSvc) {
+        this.#el = el;
+        this.#mutationObserverSvc = mutationObserverSvc;
+        this.#viewkeeperSvc = viewkeeperSvc;
+        this.#scrollableHostSvc = scrollableHostSvc;
+    }
+    ngOnInit() {
+        this.#observer = this.#mutationObserverSvc.create(() => this.#detectElements());
+        this.#observer.observe(this.#el.nativeElement, {
+            childList: true,
+            subtree: true,
+        });
+    }
+    ngOnDestroy() {
+        /*istanbul ignore else*/
+        if (this.#observer) {
+            this.#observer.disconnect();
+        }
+        /*istanbul ignore else*/
+        if (this.#scrollableHostWatchUnsubscribe) {
+            this.#scrollableHostWatchUnsubscribe.next();
+            this.#scrollableHostWatchUnsubscribe.complete();
+        }
+        this.#destroyViewkeepers();
+    }
+    #destroyViewkeepers() {
+        for (const viewkeeper of this.#viewkeepers) {
+            this.#viewkeeperSvc.destroy(viewkeeper);
+        }
+        this.#viewkeepers = [];
+    }
+    #getViewkeeperEls() {
+        let viewkeeperEls = [];
+        if (this.skyViewkeeper) {
+            viewkeeperEls = [];
+            for (const item of this.skyViewkeeper) {
+                const matchingEls = Array.from(this.#el.nativeElement.querySelectorAll(item));
+                viewkeeperEls = [...viewkeeperEls, ...matchingEls];
+            }
+        }
+        return viewkeeperEls;
+    }
+    #viewkeeperElsChanged(viewkeeperEls) {
+        if (!viewkeeperEls !== !this.#currentViewkeeperEls) {
+            return true;
+        }
+        if (viewkeeperEls && this.#currentViewkeeperEls) {
+            if (viewkeeperEls.length !== this.#currentViewkeeperEls.length) {
+                return true;
+            }
+            for (let i = 0, n = viewkeeperEls.length; i < n; i++) {
+                if (viewkeeperEls[i] !== this.#currentViewkeeperEls[i]) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    #detectElements() {
+        const viewkeeperEls = this.#getViewkeeperEls();
+        if (this.#viewkeeperElsChanged(viewkeeperEls)) {
+            if (this.#scrollableHostWatchUnsubscribe) {
+                this.#scrollableHostWatchUnsubscribe.next();
+                this.#scrollableHostWatchUnsubscribe.complete();
+                this.#scrollableHostWatchUnsubscribe = new Subject();
+            }
+            else {
+                this.#scrollableHostWatchUnsubscribe = new Subject();
+            }
+            if (this.#scrollableHostSvc) {
+                this.#scrollableHostSvc
+                    .watchScrollableHost(this.#el)
+                    .pipe(takeUntil(this.#scrollableHostWatchUnsubscribe))
+                    .subscribe((scrollableHost) => {
+                    this.#destroyViewkeepers();
+                    let previousViewkeeperEl;
+                    for (const viewkeeperEl of viewkeeperEls) {
+                        this.#viewkeepers.push(this.#viewkeeperSvc.create({
+                            boundaryEl: this.#el.nativeElement,
+                            scrollableHost: scrollableHost instanceof HTMLElement
+                                ? scrollableHost
+                                : undefined,
+                            el: viewkeeperEl,
+                            setWidth: true,
+                            verticalOffsetEl: previousViewkeeperEl,
+                        }));
+                        previousViewkeeperEl = viewkeeperEl;
+                    }
+                });
+            }
+            this.#currentViewkeeperEls = viewkeeperEls;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperDirective, deps: [{ token: i0.ElementRef }, { token: i1.SkyMutationObserverService }, { token: i2.SkyViewkeeperService }, { token: i3.SkyScrollableHostService, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: SkyViewkeeperDirective, selector: "[skyViewkeeper]", inputs: { skyViewkeeper: "skyViewkeeper" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[skyViewkeeper]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.SkyMutationObserverService }, { type: i2.SkyViewkeeperService }, { type: i3.SkyScrollableHostService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { skyViewkeeper: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewkeeper.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/viewkeeper/viewkeeper.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyMutationObserverService } from '../mutation/mutation-observer-service';\nimport { SkyScrollableHostService } from '../scrollable-host/scrollable-host.service';\n\nimport { SkyViewkeeper } from './viewkeeper';\nimport { SkyViewkeeperService } from './viewkeeper.service';\n\n@Directive({\n  selector: '[skyViewkeeper]',\n})\nexport class SkyViewkeeperDirective implements OnInit, OnDestroy {\n  @Input()\n  public set skyViewkeeper(value: string[] | undefined) {\n    this.#_skyViewkeeper = value;\n\n    this.#detectElements();\n  }\n\n  public get skyViewkeeper(): string[] | undefined {\n    return this.#_skyViewkeeper;\n  }\n\n  #_skyViewkeeper: string[] | undefined;\n\n  #currentViewkeeperEls: HTMLElement[] | undefined;\n\n  #el: ElementRef;\n\n  #mutationObserverSvc: SkyMutationObserverService;\n\n  #observer: MutationObserver | undefined;\n\n  #scrollableHostSvc: SkyScrollableHostService | undefined;\n\n  #scrollableHostWatchUnsubscribe: Subject<void> | undefined;\n\n  #viewkeepers: SkyViewkeeper[] = [];\n\n  #viewkeeperSvc: SkyViewkeeperService;\n\n  constructor(\n    el: ElementRef,\n    mutationObserverSvc: SkyMutationObserverService,\n    viewkeeperSvc: SkyViewkeeperService,\n    @Optional() scrollableHostSvc?: SkyScrollableHostService\n  ) {\n    this.#el = el;\n    this.#mutationObserverSvc = mutationObserverSvc;\n    this.#viewkeeperSvc = viewkeeperSvc;\n    this.#scrollableHostSvc = scrollableHostSvc;\n  }\n\n  public ngOnInit(): void {\n    this.#observer = this.#mutationObserverSvc.create(() =>\n      this.#detectElements()\n    );\n\n    this.#observer.observe(this.#el.nativeElement, {\n      childList: true,\n      subtree: true,\n    });\n  }\n\n  public ngOnDestroy(): void {\n    /*istanbul ignore else*/\n    if (this.#observer) {\n      this.#observer.disconnect();\n    }\n\n    /*istanbul ignore else*/\n    if (this.#scrollableHostWatchUnsubscribe) {\n      this.#scrollableHostWatchUnsubscribe.next();\n      this.#scrollableHostWatchUnsubscribe.complete();\n    }\n\n    this.#destroyViewkeepers();\n  }\n\n  #destroyViewkeepers(): void {\n    for (const viewkeeper of this.#viewkeepers) {\n      this.#viewkeeperSvc.destroy(viewkeeper);\n    }\n\n    this.#viewkeepers = [];\n  }\n\n  #getViewkeeperEls(): HTMLElement[] {\n    let viewkeeperEls: HTMLElement[] = [];\n\n    if (this.skyViewkeeper) {\n      viewkeeperEls = [];\n\n      for (const item of this.skyViewkeeper) {\n        const matchingEls = Array.from(\n          (this.#el.nativeElement as HTMLElement).querySelectorAll(item)\n        ) as HTMLElement[];\n\n        viewkeeperEls = [...viewkeeperEls, ...matchingEls];\n      }\n    }\n\n    return viewkeeperEls;\n  }\n\n  #viewkeeperElsChanged(viewkeeperEls: HTMLElement[]): boolean {\n    if (!viewkeeperEls !== !this.#currentViewkeeperEls) {\n      return true;\n    }\n\n    if (viewkeeperEls && this.#currentViewkeeperEls) {\n      if (viewkeeperEls.length !== this.#currentViewkeeperEls.length) {\n        return true;\n      }\n\n      for (let i = 0, n = viewkeeperEls.length; i < n; i++) {\n        if (viewkeeperEls[i] !== this.#currentViewkeeperEls[i]) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  #detectElements(): void {\n    const viewkeeperEls = this.#getViewkeeperEls();\n\n    if (this.#viewkeeperElsChanged(viewkeeperEls)) {\n      if (this.#scrollableHostWatchUnsubscribe) {\n        this.#scrollableHostWatchUnsubscribe.next();\n        this.#scrollableHostWatchUnsubscribe.complete();\n        this.#scrollableHostWatchUnsubscribe = new Subject();\n      } else {\n        this.#scrollableHostWatchUnsubscribe = new Subject();\n      }\n\n      if (this.#scrollableHostSvc) {\n        this.#scrollableHostSvc\n          .watchScrollableHost(this.#el)\n          .pipe(takeUntil(this.#scrollableHostWatchUnsubscribe))\n          .subscribe((scrollableHost) => {\n            this.#destroyViewkeepers();\n\n            let previousViewkeeperEl: HTMLElement | undefined;\n\n            for (const viewkeeperEl of viewkeeperEls) {\n              this.#viewkeepers.push(\n                this.#viewkeeperSvc.create({\n                  boundaryEl: this.#el.nativeElement,\n                  scrollableHost:\n                    scrollableHost instanceof HTMLElement\n                      ? scrollableHost\n                      : undefined,\n                  el: viewkeeperEl,\n                  setWidth: true,\n                  verticalOffsetEl: previousViewkeeperEl,\n                })\n              );\n\n              previousViewkeeperEl = viewkeeperEl;\n            }\n          });\n      }\n\n      this.#currentViewkeeperEls = viewkeeperEls;\n    }\n  }\n}\n"]}

package/esm2022/lib/modules/viewkeeper/viewkeeper.mjs

@@ -0,0 +1,283 @@
+const CLS_VIEWKEEPER_FIXED = 'sky-viewkeeper-fixed';
+const EVT_AFTER_VIEWKEEPER_SYNC = 'afterViewkeeperSync';
+let styleEl;
+let nextIdIndex;
+function ensureStyleEl() {
+    if (!styleEl) {
+        styleEl = document.createElement('style');
+        const css = document.createTextNode(`
+.${CLS_VIEWKEEPER_FIXED} {
+  position: fixed !important;
+  z-index: 999;
+  opacity: 0.95;
+  overflow: hidden;
+}
+
+.sky-theme-modern .${CLS_VIEWKEEPER_FIXED} {
+  box-shadow: 0px 1px 8px -1px rgba(0, 0, 0, 0.3);
+  opacity: initial;
+}
+`);
+        styleEl.appendChild(css);
+        document.head.appendChild(styleEl);
+    }
+}
+function nextId() {
+    nextIdIndex = (nextIdIndex || 0) + 1;
+    return 'viewkeeper-' + nextIdIndex;
+}
+function getOffset(el, scrollableHost) {
+    const rect = el.getBoundingClientRect();
+    const parent = scrollableHost ? scrollableHost : document.documentElement;
+    return {
+        top: rect.top + parent.scrollTop,
+        left: rect.left + parent.scrollLeft,
+    };
+}
+function px(value) {
+    let pxValue = value ? value.toString() : '';
+    if (typeof value === 'number') {
+        pxValue = value + 'px';
+    }
+    return pxValue;
+}
+function setElPosition(el, left, top, width, marginTop, clipTop, clipLeft) {
+    el.style.top = px(top);
+    el.style.left = px(left);
+    el.style.marginTop = px(marginTop);
+    el.style.clipPath =
+        clipTop || clipLeft ? `inset(${px(clipTop)} 0 0 ${px(clipLeft)})` : 'none';
+    /*istanbul ignore else*/
+    /* sanity check */
+    if (width !== null) {
+        el.style.width = px(width);
+    }
+}
+function getHeightWithMargin(el) {
+    const computedStyle = getComputedStyle(el);
+    return (el.offsetHeight +
+        parseInt(computedStyle.marginTop, 10) +
+        parseInt(computedStyle.marginBottom, 10));
+}
+function createCustomEvent(name) {
+    const evt = document.createEvent('CustomEvent');
+    evt.initCustomEvent(name, false, false, undefined);
+    return evt;
+}
+export class SkyViewkeeper {
+    #boundaryEl;
+    #el;
+    #id;
+    #setWidth;
+    #verticalOffset;
+    #verticalOffsetEl;
+    #viewportMarginTop = 0;
+    #currentElFixedLeft;
+    #currentElFixedTop;
+    #currentElFixedWidth;
+    #currentElClipLeft;
+    #currentElClipTop;
+    #isDestroyed = false;
+    #scrollableHost;
+    #syncElPositionHandler;
+    #intersectionObserver;
+    constructor(options) {
+        options = options || /* istanbul ignore next */ {};
+        this.#el = options.el;
+        this.#boundaryEl = options.boundaryEl;
+        if (!this.#el) {
+            throw new Error('[SkyViewkeeper] The option `el` is required.');
+        }
+        if (!this.#boundaryEl) {
+            throw new Error('[SkyViewkeeper] The option `boundaryEl` is required.');
+        }
+        const el = this.#el;
+        const boundaryEl = this.#boundaryEl;
+        this.#setWidth = !!options.setWidth;
+        this.#id = nextId();
+        this.#scrollableHost = options.scrollableHost;
+        this.#verticalOffset = options.verticalOffset || 0;
+        this.#verticalOffsetEl = options.verticalOffsetEl;
+        // Only set viewport margin if the scrollable host is undefined.
+        if (!this.#scrollableHost) {
+            this.#viewportMarginTop = options.viewportMarginTop ?? 0;
+        }
+        this.#syncElPositionHandler = () => this.syncElPosition(el, boundaryEl);
+        if (this.#verticalOffsetEl) {
+            this.#verticalOffsetEl.addEventListener(EVT_AFTER_VIEWKEEPER_SYNC, this.#syncElPositionHandler);
+        }
+        window.addEventListener('scroll', this.#syncElPositionHandler, true);
+        window.addEventListener('resize', this.#syncElPositionHandler);
+        window.addEventListener('orientationchange', this.#syncElPositionHandler);
+        ensureStyleEl();
+        this.syncElPosition(el, boundaryEl);
+    }
+    syncElPosition(el, boundaryEl) {
+        const verticalOffset = this.#calculateVerticalOffset();
+        // When the element isn't visible, its size can't be calculated, so don't attempt syncing position in this case.
+        if (el.offsetWidth === 0 && el.offsetHeight === 0) {
+            return;
+        }
+        const boundaryInfo = this.#getBoundaryInfo(el, boundaryEl);
+        const fixedStyles = this.#getFixedStyles(boundaryInfo, verticalOffset);
+        const doFixEl = this.#shouldFixEl(el, boundaryInfo, verticalOffset);
+        if (this.#needsUpdating(doFixEl, fixedStyles)) {
+            if (doFixEl) {
+                this.#fixEl(el, boundaryInfo, fixedStyles);
+            }
+            else {
+                this.#unfixEl(el);
+            }
+        }
+        const evt = createCustomEvent(EVT_AFTER_VIEWKEEPER_SYNC);
+        el.dispatchEvent(evt);
+    }
+    destroy() {
+        if (!this.#isDestroyed) {
+            this.#intersectionObserver?.disconnect();
+            window.removeEventListener('scroll', this.#syncElPositionHandler, true);
+            window.removeEventListener('resize', this.#syncElPositionHandler);
+            window.removeEventListener('orientationchange', this.#syncElPositionHandler);
+            if (this.#el) {
+                this.#unfixEl(this.#el);
+            }
+            if (this.#verticalOffsetEl) {
+                this.#verticalOffsetEl.removeEventListener(EVT_AFTER_VIEWKEEPER_SYNC, this.#syncElPositionHandler);
+            }
+            this.#el = this.#boundaryEl = this.#verticalOffsetEl = undefined;
+            this.#isDestroyed = true;
+        }
+    }
+    #getSpacerId() {
+        return this.#id + '-spacer';
+    }
+    #unfixEl(el) {
+        const spacerEl = document.getElementById(this.#getSpacerId());
+        /*istanbul ignore else*/
+        if (spacerEl?.parentElement) {
+            spacerEl.parentElement.removeChild(spacerEl);
+        }
+        el.classList.remove(CLS_VIEWKEEPER_FIXED);
+        this.#currentElFixedLeft =
+            this.#currentElFixedTop =
+                this.#currentElFixedWidth =
+                    undefined;
+        let width = '';
+        if (this.#setWidth) {
+            width = 'auto';
+        }
+        setElPosition(el, '', '', width, '', 0, 0);
+    }
+    #calculateVerticalOffset() {
+        let offset = this.#verticalOffset;
+        if (this.#verticalOffsetEl) {
+            const verticalOffsetElTopStyle = this.#verticalOffsetEl.style.top;
+            const verticalOffsetElTop = parseInt(verticalOffsetElTopStyle, 10) || 0;
+            offset += this.#verticalOffsetEl.offsetHeight + verticalOffsetElTop;
+        }
+        else if (this.#scrollableHost) {
+            offset += this.#scrollableHost.getBoundingClientRect().top;
+        }
+        return offset;
+    }
+    #shouldFixEl(el, boundaryInfo, verticalOffset) {
+        let anchorTop;
+        if (boundaryInfo.spacerEl) {
+            anchorTop = getOffset(boundaryInfo.spacerEl, this.#scrollableHost).top;
+        }
+        else {
+            anchorTop = getOffset(el, this.#scrollableHost).top;
+        }
+        const doFixEl = boundaryInfo.scrollTop + verticalOffset + this.#viewportMarginTop >
+            anchorTop;
+        return doFixEl;
+    }
+    #getFixedStyles(boundaryInfo, verticalOffset) {
+        // If the element needs to be fixed, this will calculate its position.  The position
+        // will be 0 (fully visible) unless the user is scrolling the boundary out of view.
+        // In that case, the element should begin to scroll out of view with the
+        // rest of the boundary by setting its top position to a negative value.
+        const elTop = boundaryInfo.boundaryBottom -
+            boundaryInfo.elHeight -
+            boundaryInfo.scrollTop;
+        const elClipTop = elTop < verticalOffset ? verticalOffset - elTop : 0;
+        const elFixedTop = Math.min(elTop, verticalOffset);
+        const elFixedWidth = boundaryInfo.boundaryEl.getBoundingClientRect().width;
+        const elFixedLeft = boundaryInfo.boundaryOffset.left - boundaryInfo.scrollLeft;
+        const elClipLeft = elFixedLeft < 0 ? 0 - elFixedLeft : 0;
+        return {
+            elFixedLeft,
+            elFixedTop,
+            elFixedWidth,
+            elClipLeft,
+            elClipTop,
+        };
+    }
+    #needsUpdating(doFixEl, fixedStyles) {
+        if ((doFixEl &&
+            this.#currentElFixedLeft === fixedStyles.elFixedLeft &&
+            this.#currentElFixedTop === fixedStyles.elFixedTop &&
+            this.#currentElClipLeft === fixedStyles.elClipLeft &&
+            this.#currentElClipTop === fixedStyles.elClipTop &&
+            this.#currentElFixedWidth === fixedStyles.elFixedWidth) ||
+            (!doFixEl &&
+                !(this.#currentElFixedLeft !== undefined &&
+                    this.#currentElFixedLeft !== null))) {
+            // The element is either currently fixed and its position and width do not need
+            // to change, or the element is not currently fixed and does not need to be fixed.
+            // No changes are needed.
+            return false;
+        }
+        return true;
+    }
+    #fixEl(el, boundaryInfo, fixedStyles) {
+        /* istanbul ignore else */
+        /* sanity check */
+        if (!boundaryInfo.spacerEl) {
+            const spacerHeight = boundaryInfo.elHeight;
+            const spacerEl = document.createElement('div');
+            spacerEl.id = boundaryInfo.spacerId;
+            spacerEl.style.height = px(spacerHeight);
+            /*istanbul ignore else*/
+            if (el.parentNode) {
+                el.parentNode.insertBefore(spacerEl, el.nextSibling);
+            }
+        }
+        el.classList.add(CLS_VIEWKEEPER_FIXED);
+        this.#currentElFixedTop = fixedStyles.elFixedTop;
+        this.#currentElFixedLeft = fixedStyles.elFixedLeft;
+        this.#currentElClipTop = fixedStyles.elClipTop;
+        this.#currentElClipLeft = fixedStyles.elClipLeft;
+        this.#currentElFixedWidth = fixedStyles.elFixedWidth;
+        let width = 0;
+        if (this.#setWidth) {
+            width = fixedStyles.elFixedWidth;
+        }
+        setElPosition(el, fixedStyles.elFixedLeft, fixedStyles.elFixedTop, width, this.#viewportMarginTop, fixedStyles.elClipTop, fixedStyles.elClipLeft);
+    }
+    #getBoundaryInfo(el, boundaryEl) {
+        const spacerId = this.#getSpacerId();
+        const spacerEl = document.getElementById(spacerId);
+        const boundaryOffset = getOffset(boundaryEl, this.#scrollableHost);
+        const boundaryTop = boundaryOffset.top;
+        const boundaryBottom = boundaryTop + boundaryEl.getBoundingClientRect().height;
+        const scrollLeft = this.#scrollableHost
+            ? this.#scrollableHost.scrollLeft
+            : document.documentElement.scrollLeft;
+        const scrollTop = this.#scrollableHost
+            ? this.#scrollableHost.scrollTop
+            : document.documentElement.scrollTop;
+        const elHeight = getHeightWithMargin(el);
+        return {
+            boundaryBottom,
+            boundaryOffset,
+            boundaryEl,
+            elHeight,
+            scrollLeft,
+            scrollTop,
+            spacerId,
+            spacerEl,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewkeeper.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/viewkeeper/viewkeeper.ts"],"names":[],"mappings":"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","sourcesContent":["import { SkyViewkeeperBoundaryInfo } from './viewkeeper-boundary-info';\nimport { SkyViewkeeperFixedStyles } from './viewkeeper-fixed-styles';\nimport { SkyViewkeeperOffset } from './viewkeeper-offset';\nimport { SkyViewkeeperOptions } from './viewkeeper-options';\n\nconst CLS_VIEWKEEPER_FIXED = 'sky-viewkeeper-fixed';\nconst EVT_AFTER_VIEWKEEPER_SYNC = 'afterViewkeeperSync';\n\nlet styleEl: HTMLStyleElement;\nlet nextIdIndex: number;\n\nfunction ensureStyleEl(): void {\n  if (!styleEl) {\n    styleEl = document.createElement('style');\n\n    const css = document.createTextNode(`\n.${CLS_VIEWKEEPER_FIXED} {\n  position: fixed !important;\n  z-index: 999;\n  opacity: 0.95;\n  overflow: hidden;\n}\n\n.sky-theme-modern .${CLS_VIEWKEEPER_FIXED} {\n  box-shadow: 0px 1px 8px -1px rgba(0, 0, 0, 0.3);\n  opacity: initial;\n}\n`);\n\n    styleEl.appendChild(css);\n\n    document.head.appendChild(styleEl);\n  }\n}\n\nfunction nextId(): string {\n  nextIdIndex = (nextIdIndex || 0) + 1;\n\n  return 'viewkeeper-' + nextIdIndex;\n}\n\nfunction getOffset(\n  el: HTMLElement,\n  scrollableHost?: HTMLElement\n): SkyViewkeeperOffset {\n  const rect = el.getBoundingClientRect();\n  const parent = scrollableHost ? scrollableHost : document.documentElement;\n\n  return {\n    top: rect.top + parent.scrollTop,\n    left: rect.left + parent.scrollLeft,\n  };\n}\n\nfunction px(value: number | string): string {\n  let pxValue = value ? value.toString() : '';\n\n  if (typeof value === 'number') {\n    pxValue = value + 'px';\n  }\n\n  return pxValue;\n}\n\nfunction setElPosition(\n  el: HTMLElement,\n  left: number | string,\n  top: number | string,\n  width: number | string,\n  marginTop: number | string,\n  clipTop: number | string,\n  clipLeft: number | string\n): void {\n  el.style.top = px(top);\n  el.style.left = px(left);\n  el.style.marginTop = px(marginTop);\n  el.style.clipPath =\n    clipTop || clipLeft ? `inset(${px(clipTop)} 0 0 ${px(clipLeft)})` : 'none';\n\n  /*istanbul ignore else*/\n  /* sanity check */\n  if (width !== null) {\n    el.style.width = px(width);\n  }\n}\n\nfunction getHeightWithMargin(el: HTMLElement): number {\n  const computedStyle = getComputedStyle(el);\n\n  return (\n    el.offsetHeight +\n    parseInt(computedStyle.marginTop, 10) +\n    parseInt(computedStyle.marginBottom, 10)\n  );\n}\n\nfunction createCustomEvent(name: any): CustomEvent<any> {\n  const evt = document.createEvent('CustomEvent');\n\n  evt.initCustomEvent(name, false, false, undefined);\n\n  return evt;\n}\n\nexport class SkyViewkeeper {\n  #boundaryEl: HTMLElement | undefined;\n\n  #el: HTMLElement | undefined;\n\n  #id: string;\n\n  #setWidth: boolean;\n\n  #verticalOffset: number;\n\n  #verticalOffsetEl: HTMLElement | undefined;\n\n  #viewportMarginTop = 0;\n\n  #currentElFixedLeft: number | undefined;\n\n  #currentElFixedTop: number | undefined;\n\n  #currentElFixedWidth: number | undefined;\n\n  #currentElClipLeft: number | undefined;\n\n  #currentElClipTop: number | undefined;\n\n  #isDestroyed = false;\n\n  #scrollableHost: HTMLElement | undefined;\n\n  #syncElPositionHandler: () => void;\n\n  #intersectionObserver: IntersectionObserver | undefined;\n\n  constructor(options: SkyViewkeeperOptions) {\n    options = options || /* istanbul ignore next */ {};\n\n    this.#el = options.el;\n    this.#boundaryEl = options.boundaryEl;\n\n    if (!this.#el) {\n      throw new Error('[SkyViewkeeper] The option `el` is required.');\n    }\n\n    if (!this.#boundaryEl) {\n      throw new Error('[SkyViewkeeper] The option `boundaryEl` is required.');\n    }\n\n    const el = this.#el;\n    const boundaryEl = this.#boundaryEl;\n\n    this.#setWidth = !!options.setWidth;\n    this.#id = nextId();\n    this.#scrollableHost = options.scrollableHost;\n    this.#verticalOffset = options.verticalOffset || 0;\n    this.#verticalOffsetEl = options.verticalOffsetEl;\n\n    // Only set viewport margin if the scrollable host is undefined.\n    if (!this.#scrollableHost) {\n      this.#viewportMarginTop = options.viewportMarginTop ?? 0;\n    }\n\n    this.#syncElPositionHandler = () => this.syncElPosition(el, boundaryEl);\n\n    if (this.#verticalOffsetEl) {\n      this.#verticalOffsetEl.addEventListener(\n        EVT_AFTER_VIEWKEEPER_SYNC,\n        this.#syncElPositionHandler\n      );\n    }\n\n    window.addEventListener('scroll', this.#syncElPositionHandler, true);\n    window.addEventListener('resize', this.#syncElPositionHandler);\n    window.addEventListener('orientationchange', this.#syncElPositionHandler);\n\n    ensureStyleEl();\n\n    this.syncElPosition(el, boundaryEl);\n  }\n\n  public syncElPosition(el: HTMLElement, boundaryEl: HTMLElement): void {\n    const verticalOffset = this.#calculateVerticalOffset();\n\n    // When the element isn't visible, its size can't be calculated, so don't attempt syncing position in this case.\n    if (el.offsetWidth === 0 && el.offsetHeight === 0) {\n      return;\n    }\n\n    const boundaryInfo = this.#getBoundaryInfo(el, boundaryEl);\n    const fixedStyles = this.#getFixedStyles(boundaryInfo, verticalOffset);\n\n    const doFixEl = this.#shouldFixEl(el, boundaryInfo, verticalOffset);\n\n    if (this.#needsUpdating(doFixEl, fixedStyles)) {\n      if (doFixEl) {\n        this.#fixEl(el, boundaryInfo, fixedStyles);\n      } else {\n        this.#unfixEl(el);\n      }\n    }\n\n    const evt = createCustomEvent(EVT_AFTER_VIEWKEEPER_SYNC);\n\n    el.dispatchEvent(evt);\n  }\n\n  public destroy(): void {\n    if (!this.#isDestroyed) {\n      this.#intersectionObserver?.disconnect();\n      window.removeEventListener('scroll', this.#syncElPositionHandler, true);\n      window.removeEventListener('resize', this.#syncElPositionHandler);\n      window.removeEventListener(\n        'orientationchange',\n        this.#syncElPositionHandler\n      );\n\n      if (this.#el) {\n        this.#unfixEl(this.#el);\n      }\n\n      if (this.#verticalOffsetEl) {\n        this.#verticalOffsetEl.removeEventListener(\n          EVT_AFTER_VIEWKEEPER_SYNC,\n          this.#syncElPositionHandler\n        );\n      }\n\n      this.#el = this.#boundaryEl = this.#verticalOffsetEl = undefined;\n\n      this.#isDestroyed = true;\n    }\n  }\n\n  #getSpacerId(): string {\n    return this.#id + '-spacer';\n  }\n\n  #unfixEl(el: HTMLElement): void {\n    const spacerEl = document.getElementById(this.#getSpacerId());\n\n    /*istanbul ignore else*/\n    if (spacerEl?.parentElement) {\n      spacerEl.parentElement.removeChild(spacerEl);\n    }\n\n    el.classList.remove(CLS_VIEWKEEPER_FIXED);\n\n    this.#currentElFixedLeft =\n      this.#currentElFixedTop =\n      this.#currentElFixedWidth =\n        undefined;\n\n    let width = '';\n\n    if (this.#setWidth) {\n      width = 'auto';\n    }\n\n    setElPosition(el, '', '', width, '', 0, 0);\n  }\n\n  #calculateVerticalOffset(): number {\n    let offset = this.#verticalOffset;\n\n    if (this.#verticalOffsetEl) {\n      const verticalOffsetElTopStyle = this.#verticalOffsetEl.style.top;\n      const verticalOffsetElTop = parseInt(verticalOffsetElTopStyle, 10) || 0;\n\n      offset += this.#verticalOffsetEl.offsetHeight + verticalOffsetElTop;\n    } else if (this.#scrollableHost) {\n      offset += this.#scrollableHost.getBoundingClientRect().top;\n    }\n\n    return offset;\n  }\n\n  #shouldFixEl(\n    el: HTMLElement,\n    boundaryInfo: SkyViewkeeperBoundaryInfo,\n    verticalOffset: number\n  ): boolean {\n    let anchorTop: number;\n\n    if (boundaryInfo.spacerEl) {\n      anchorTop = getOffset(boundaryInfo.spacerEl, this.#scrollableHost).top;\n    } else {\n      anchorTop = getOffset(el, this.#scrollableHost).top;\n    }\n\n    const doFixEl =\n      boundaryInfo.scrollTop + verticalOffset + this.#viewportMarginTop >\n      anchorTop;\n\n    return doFixEl;\n  }\n\n  #getFixedStyles(\n    boundaryInfo: SkyViewkeeperBoundaryInfo,\n    verticalOffset: number\n  ): SkyViewkeeperFixedStyles {\n    // If the element needs to be fixed, this will calculate its position.  The position\n    // will be 0 (fully visible) unless the user is scrolling the boundary out of view.\n    // In that case, the element should begin to scroll out of view with the\n    // rest of the boundary by setting its top position to a negative value.\n    const elTop =\n      boundaryInfo.boundaryBottom -\n      boundaryInfo.elHeight -\n      boundaryInfo.scrollTop;\n    const elClipTop = elTop < verticalOffset ? verticalOffset - elTop : 0;\n    const elFixedTop = Math.min(elTop, verticalOffset);\n\n    const elFixedWidth = boundaryInfo.boundaryEl.getBoundingClientRect().width;\n    const elFixedLeft =\n      boundaryInfo.boundaryOffset.left - boundaryInfo.scrollLeft;\n    const elClipLeft = elFixedLeft < 0 ? 0 - elFixedLeft : 0;\n\n    return {\n      elFixedLeft,\n      elFixedTop,\n      elFixedWidth,\n      elClipLeft,\n      elClipTop,\n    };\n  }\n\n  #needsUpdating(\n    doFixEl: boolean,\n    fixedStyles: SkyViewkeeperFixedStyles\n  ): boolean {\n    if (\n      (doFixEl &&\n        this.#currentElFixedLeft === fixedStyles.elFixedLeft &&\n        this.#currentElFixedTop === fixedStyles.elFixedTop &&\n        this.#currentElClipLeft === fixedStyles.elClipLeft &&\n        this.#currentElClipTop === fixedStyles.elClipTop &&\n        this.#currentElFixedWidth === fixedStyles.elFixedWidth) ||\n      (!doFixEl &&\n        !(\n          this.#currentElFixedLeft !== undefined &&\n          this.#currentElFixedLeft !== null\n        ))\n    ) {\n      // The element is either currently fixed and its position and width do not need\n      // to change, or the element is not currently fixed and does not need to be fixed.\n      // No changes are needed.\n      return false;\n    }\n\n    return true;\n  }\n\n  #fixEl(\n    el: HTMLElement,\n    boundaryInfo: SkyViewkeeperBoundaryInfo,\n    fixedStyles: SkyViewkeeperFixedStyles\n  ): void {\n    /* istanbul ignore else */\n    /* sanity check */\n    if (!boundaryInfo.spacerEl) {\n      const spacerHeight = boundaryInfo.elHeight;\n\n      const spacerEl = document.createElement('div');\n      spacerEl.id = boundaryInfo.spacerId;\n      spacerEl.style.height = px(spacerHeight);\n\n      /*istanbul ignore else*/\n      if (el.parentNode) {\n        el.parentNode.insertBefore(spacerEl, el.nextSibling);\n      }\n    }\n\n    el.classList.add(CLS_VIEWKEEPER_FIXED);\n\n    this.#currentElFixedTop = fixedStyles.elFixedTop;\n    this.#currentElFixedLeft = fixedStyles.elFixedLeft;\n    this.#currentElClipTop = fixedStyles.elClipTop;\n    this.#currentElClipLeft = fixedStyles.elClipLeft;\n    this.#currentElFixedWidth = fixedStyles.elFixedWidth;\n\n    let width = 0;\n\n    if (this.#setWidth) {\n      width = fixedStyles.elFixedWidth;\n    }\n\n    setElPosition(\n      el,\n      fixedStyles.elFixedLeft,\n      fixedStyles.elFixedTop,\n      width,\n      this.#viewportMarginTop,\n      fixedStyles.elClipTop,\n      fixedStyles.elClipLeft\n    );\n  }\n\n  #getBoundaryInfo(\n    el: HTMLElement,\n    boundaryEl: HTMLElement\n  ): SkyViewkeeperBoundaryInfo {\n    const spacerId = this.#getSpacerId();\n\n    const spacerEl = document.getElementById(spacerId);\n\n    const boundaryOffset = getOffset(boundaryEl, this.#scrollableHost);\n    const boundaryTop = boundaryOffset.top;\n    const boundaryBottom =\n      boundaryTop + boundaryEl.getBoundingClientRect().height;\n\n    const scrollLeft = this.#scrollableHost\n      ? this.#scrollableHost.scrollLeft\n      : document.documentElement.scrollLeft;\n    const scrollTop = this.#scrollableHost\n      ? this.#scrollableHost.scrollTop\n      : document.documentElement.scrollTop;\n\n    const elHeight = getHeightWithMargin(el);\n\n    return {\n      boundaryBottom,\n      boundaryOffset,\n      boundaryEl,\n      elHeight,\n      scrollLeft,\n      scrollTop,\n      spacerId,\n      spacerEl,\n    };\n  }\n}\n"]}

package/{esm2020 → esm2022}/lib/modules/viewkeeper/viewkeeper.module.mjs

@@ -2,15 +2,15 @@ import { NgModule } from '@angular/core';
 import { SkyViewkeeperDirective } from './viewkeeper.directive';
 import * as i0 from "@angular/core";
 export class SkyViewkeeperModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperModule, declarations: [SkyViewkeeperDirective], exports: [SkyViewkeeperDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperModule }); }
 }
-SkyViewkeeperModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyViewkeeperModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SkyViewkeeperModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SkyViewkeeperModule, declarations: [SkyViewkeeperDirective], exports: [SkyViewkeeperDirective] });
-SkyViewkeeperModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyViewkeeperModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyViewkeeperModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [SkyViewkeeperDirective],
                     exports: [SkyViewkeeperDirective],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlld2tlZXBlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvdmlld2tlZXBlci92aWV3a2VlcGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQU1oRSxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsaUJBSGYsc0JBQXNCLGFBQzNCLHNCQUFzQjtpSEFFckIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBSi9CLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ3RDLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixDQUFDO2lCQUNsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreVZpZXdrZWVwZXJEaXJlY3RpdmUgfSBmcm9tICcuL3ZpZXdrZWVwZXIuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbU2t5Vmlld2tlZXBlckRpcmVjdGl2ZV0sXG4gIGV4cG9ydHM6IFtTa3lWaWV3a2VlcGVyRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5Vmlld2tlZXBlck1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlld2tlZXBlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvdmlld2tlZXBlci92aWV3a2VlcGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQU1oRSxNQUFNLE9BQU8sbUJBQW1COzhHQUFuQixtQkFBbUI7K0dBQW5CLG1CQUFtQixpQkFIZixzQkFBc0IsYUFDM0Isc0JBQXNCOytHQUVyQixtQkFBbUI7OzJGQUFuQixtQkFBbUI7a0JBSi9CLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ3RDLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixDQUFDO2lCQUNsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreVZpZXdrZWVwZXJEaXJlY3RpdmUgfSBmcm9tICcuL3ZpZXdrZWVwZXIuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbU2t5Vmlld2tlZXBlckRpcmVjdGl2ZV0sXG4gIGV4cG9ydHM6IFtTa3lWaWV3a2VlcGVyRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5Vmlld2tlZXBlck1vZHVsZSB7fVxuIl19

package/esm2022/lib/modules/viewkeeper/viewkeeper.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable, Optional } from '@angular/core';
+import { SkyViewkeeper } from './viewkeeper';
+import * as i0 from "@angular/core";
+import * as i1 from "./viewkeeper-host-options";
+/**
+ * Provides methods for creating and destroying viewkeeper instances.
+ */
+export class SkyViewkeeperService {
+    #hostOptions;
+    constructor(hostOptions) {
+        this.#hostOptions = hostOptions;
+    }
+    /**
+     *
+     * @param options Creates a viewkeeper instance, applying host options where applicable.
+     */
+    create(options) {
+        options = Object.assign({}, this.#hostOptions || {}, options);
+        return new SkyViewkeeper(options);
+    }
+    /**
+     * Destroys a viewkeeper instance.
+     * @param vk Viewkeeper instance to destroy.
+     */
+    destroy(vk) {
+        vk.destroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperService, deps: [{ token: i1.SkyViewkeeperHostOptions, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyViewkeeperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyViewkeeperHostOptions, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/modules/window/window-ref.mjs

@@ -18,13 +18,13 @@ export class SkyAppWindowRef {
     get nativeWindow() {
         return getWindow();
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAppWindowRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAppWindowRef, providedIn: 'root' }); }
 }
-SkyAppWindowRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyAppWindowRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-SkyAppWindowRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyAppWindowRef, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyAppWindowRef, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAppWindowRef, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93LXJlZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy93aW5kb3cvd2luZG93LXJlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUzQzs7R0FFRztBQUNILE1BQU0sVUFBVSxTQUFTO0lBQ3ZCLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRDs7OztHQUlHO0FBSUgsTUFBTSxPQUFPLGVBQWU7SUFDMUI7O09BRUc7SUFDSCxJQUFXLFlBQVk7UUFDckIsT0FBTyxTQUFTLEVBQUUsQ0FBQztJQUNyQixDQUFDOzs0R0FOVSxlQUFlO2dIQUFmLGVBQWUsY0FGZCxNQUFNOzJGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0V2luZG93KCk6IGFueSB7XG4gIHJldHVybiB3aW5kb3c7XG59XG5cbi8qKlxuICogVGhlIGFwcGxpY2F0aW9uIHdpbmRvdyByZWZlcmVuY2Ugc2VydmljZSByZWZlcmVuY2VzIHRoZSBnbG9iYWwgd2luZG93IHZhcmlhYmxlLlxuICogQWZ0ZXIgdXNlcnMgaW5qZWN0IFNreUFwcFdpbmRvd1JlZiBpbnRvIGEgY29tcG9uZW50LCB0aGV5IGNhbiB1c2UgdGhlIHNlcnZpY2UgdG8gaW50ZXJhY3Qgd2l0aFxuICogd2luZG93IHByb3BlcnRpZXMgYW5kIGV2ZW50IGhhbmRsZXJzIGJ5IHJlZmVyZW5jaW5nIGl0cyBuYXRpdmVXaW5kb3cgcHJvcGVydHkuXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBTa3lBcHBXaW5kb3dSZWYge1xuICAvKipcbiAgICogVGhlIGdsb2JhbCBgd2luZG93YCB2YXJpYWJsZS5cbiAgICovXG4gIHB1YmxpYyBnZXQgbmF0aXZlV2luZG93KCk6IGFueSB7XG4gICAgcmV0dXJuIGdldFdpbmRvdygpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93LXJlZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy93aW5kb3cvd2luZG93LXJlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUzQzs7R0FFRztBQUNILE1BQU0sVUFBVSxTQUFTO0lBQ3ZCLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRDs7OztHQUlHO0FBSUgsTUFBTSxPQUFPLGVBQWU7SUFDMUI7O09BRUc7SUFDSCxJQUFXLFlBQVk7UUFDckIsT0FBTyxTQUFTLEVBQUUsQ0FBQztJQUNyQixDQUFDOzhHQU5VLGVBQWU7a0hBQWYsZUFBZSxjQUZkLE1BQU07OzJGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0V2luZG93KCk6IGFueSB7XG4gIHJldHVybiB3aW5kb3c7XG59XG5cbi8qKlxuICogVGhlIGFwcGxpY2F0aW9uIHdpbmRvdyByZWZlcmVuY2Ugc2VydmljZSByZWZlcmVuY2VzIHRoZSBnbG9iYWwgd2luZG93IHZhcmlhYmxlLlxuICogQWZ0ZXIgdXNlcnMgaW5qZWN0IFNreUFwcFdpbmRvd1JlZiBpbnRvIGEgY29tcG9uZW50LCB0aGV5IGNhbiB1c2UgdGhlIHNlcnZpY2UgdG8gaW50ZXJhY3Qgd2l0aFxuICogd2luZG93IHByb3BlcnRpZXMgYW5kIGV2ZW50IGhhbmRsZXJzIGJ5IHJlZmVyZW5jaW5nIGl0cyBuYXRpdmVXaW5kb3cgcHJvcGVydHkuXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBTa3lBcHBXaW5kb3dSZWYge1xuICAvKipcbiAgICogVGhlIGdsb2JhbCBgd2luZG93YCB2YXJpYWJsZS5cbiAgICovXG4gIHB1YmxpYyBnZXQgbmF0aXZlV2luZG93KCk6IGFueSB7XG4gICAgcmV0dXJuIGdldFdpbmRvdygpO1xuICB9XG59XG4iXX0=

package/esm2022/testing/core-testing.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { SkyMediaQueryService, SkyUIConfigService } from '@skyux/core';
+import { MockSkyMediaQueryService } from './mock-media-query.service';
+import { MockSkyUIConfigService } from './mock-ui-config.service';
+import * as i0 from "@angular/core";
+/**
+ * @internal
+ */
+export class SkyCoreTestingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyCoreTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyCoreTestingModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyCoreTestingModule, providers: [
+            { provide: SkyMediaQueryService, useClass: MockSkyMediaQueryService },
+            {
+                provide: SkyUIConfigService,
+                useClass: MockSkyUIConfigService,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyCoreTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        { provide: SkyMediaQueryService, useClass: MockSkyMediaQueryService },
+                        {
+                            provide: SkyUIConfigService,
+                            useClass: MockSkyUIConfigService,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZS10ZXN0aW5nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3Rlc3Rpbmcvc3JjL2NvcmUtdGVzdGluZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFdkUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7O0FBRWxFOztHQUVHO0FBVUgsTUFBTSxPQUFPLG9CQUFvQjs4R0FBcEIsb0JBQW9COytHQUFwQixvQkFBb0I7K0dBQXBCLG9CQUFvQixhQVJwQjtZQUNULEVBQUUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLFFBQVEsRUFBRSx3QkFBd0IsRUFBRTtZQUNyRTtnQkFDRSxPQUFPLEVBQUUsa0JBQWtCO2dCQUMzQixRQUFRLEVBQUUsc0JBQXNCO2FBQ2pDO1NBQ0Y7OzJGQUVVLG9CQUFvQjtrQkFUaEMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUU7d0JBQ1QsRUFBRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsUUFBUSxFQUFFLHdCQUF3QixFQUFFO3dCQUNyRTs0QkFDRSxPQUFPLEVBQUUsa0JBQWtCOzRCQUMzQixRQUFRLEVBQUUsc0JBQXNCO3lCQUNqQztxQkFDRjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTa3lNZWRpYVF1ZXJ5U2VydmljZSwgU2t5VUlDb25maWdTZXJ2aWNlIH0gZnJvbSAnQHNreXV4L2NvcmUnO1xuXG5pbXBvcnQgeyBNb2NrU2t5TWVkaWFRdWVyeVNlcnZpY2UgfSBmcm9tICcuL21vY2stbWVkaWEtcXVlcnkuc2VydmljZSc7XG5pbXBvcnQgeyBNb2NrU2t5VUlDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi9tb2NrLXVpLWNvbmZpZy5zZXJ2aWNlJztcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbXG4gICAgeyBwcm92aWRlOiBTa3lNZWRpYVF1ZXJ5U2VydmljZSwgdXNlQ2xhc3M6IE1vY2tTa3lNZWRpYVF1ZXJ5U2VydmljZSB9LFxuICAgIHtcbiAgICAgIHByb3ZpZGU6IFNreVVJQ29uZmlnU2VydmljZSxcbiAgICAgIHVzZUNsYXNzOiBNb2NrU2t5VUlDb25maWdTZXJ2aWNlLFxuICAgIH0sXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIFNreUNvcmVUZXN0aW5nTW9kdWxlIHt9XG4iXX0=