@skyux/core 5.6.2 → 6.0.0-beta.0

package/esm2020/lib/modules/media-query/media-query.service.mjs

@@ -0,0 +1,121 @@
+import { Injectable, NgZone } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { SkyMediaBreakpoints } from './media-breakpoints';
+import * as i0 from "@angular/core";
+export class SkyMediaQueryService {
+    constructor(zone) {
+        this.zone = zone;
+        this.currentSubject = new BehaviorSubject(this.current);
+        this._current = SkyMediaBreakpoints.md;
+        this.breakpoints = [
+            {
+                mediaQueryString: SkyMediaQueryService.xs,
+                name: SkyMediaBreakpoints.xs,
+            },
+            {
+                mediaQueryString: SkyMediaQueryService.sm,
+                name: SkyMediaBreakpoints.sm,
+            },
+            {
+                mediaQueryString: SkyMediaQueryService.md,
+                name: SkyMediaBreakpoints.md,
+            },
+            {
+                mediaQueryString: SkyMediaQueryService.lg,
+                name: SkyMediaBreakpoints.lg,
+            },
+        ];
+        this.mediaQueries = [];
+        this.addListeners();
+    }
+    /**
+     * Returns the current breakpoint.
+     */
+    get current() {
+        return this._current;
+    }
+    ngOnDestroy() {
+        this.removeListeners();
+        this.currentSubject.complete();
+    }
+    /**
+     * Suscribes to screen size changes.
+     * @param listener Specifies a function that is called when breakpoints change.
+     */
+    subscribe(listener) {
+        return this.currentSubject.subscribe({
+            next: (breakpoints) => {
+                listener(breakpoints);
+            },
+        });
+    }
+    /**
+     * @internal
+     */
+    destroy() {
+        this.removeListeners();
+        this.currentSubject.complete();
+    }
+    addListeners() {
+        this.mediaQueries = this.breakpoints.map((breakpoint) => {
+            const mq = matchMedia(breakpoint.mediaQueryString);
+            const listener = (event) => {
+                // Run the check outside of Angular's change detection since Angular
+                // does not wrap matchMedia listeners in NgZone.
+                // See: https://blog.assaf.co/angular-2-change-detection-zones-and-an-example/
+                this.zone.run(() => {
+                    if (event.matches) {
+                        this.notifyBreakpointChange(breakpoint.name);
+                    }
+                });
+            };
+            mq.addListener(listener);
+            if (mq.matches) {
+                this.notifyBreakpointChange(breakpoint.name);
+            }
+            return {
+                mediaQueryList: mq,
+                listener,
+            };
+        });
+    }
+    removeListeners() {
+        this.mediaQueries.forEach((mediaQuery) => {
+            mediaQuery.mediaQueryList.removeListener(mediaQuery.listener);
+        });
+        this.mediaQueries = [];
+    }
+    notifyBreakpointChange(breakpoint) {
+        this._current = breakpoint;
+        this.currentSubject.next(breakpoint);
+    }
+}
+/**
+ * The size for the `xs` breakpoint.
+ * @default "(max-width: 767px)"
+ */
+SkyMediaQueryService.xs = '(max-width: 767px)';
+/**
+ * The size for the `sm` breakpoint.
+ * @default "(min-width: 768px) and (max-width: 991px)"
+ */
+SkyMediaQueryService.sm = '(min-width: 768px) and (max-width: 991px)';
+/**
+ * The size for the `md` breakpoint.
+ * @default "(min-width: 992px) and (max-width: 1199px)"
+ */
+SkyMediaQueryService.md = '(min-width: 992px) and (max-width: 1199px)';
+/**
+ * The size for the `lg` breakpoint.
+ * @default "(min-width: 1200px)"
+ */
+SkyMediaQueryService.lg = '(min-width: 1200px)';
+SkyMediaQueryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyMediaQueryService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyMediaQueryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyMediaQueryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyMediaQueryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media-query.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/media-query/media-query.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy } from '@angular/core';\n\nimport { BehaviorSubject, Subscription } from 'rxjs';\n\nimport { SkyMediaBreakpoints } from './media-breakpoints';\nimport { SkyMediaQueryListener } from './media-query-listener';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SkyMediaQueryService implements OnDestroy {\n  /**\n   * The size for the `xs` breakpoint.\n   * @default \"(max-width: 767px)\"\n   */\n  public static xs = '(max-width: 767px)';\n\n  /**\n   * The size for the `sm` breakpoint.\n   * @default \"(min-width: 768px) and (max-width: 991px)\"\n   */\n  public static sm = '(min-width: 768px) and (max-width: 991px)';\n\n  /**\n   * The size for the `md` breakpoint.\n   * @default \"(min-width: 992px) and (max-width: 1199px)\"\n   */\n  public static md = '(min-width: 992px) and (max-width: 1199px)';\n\n  /**\n   * The size for the `lg` breakpoint.\n   * @default \"(min-width: 1200px)\"\n   */\n  public static lg = '(min-width: 1200px)';\n\n  /**\n   * Returns the current breakpoint.\n   */\n  public get current(): SkyMediaBreakpoints {\n    return this._current;\n  }\n\n  private currentSubject = new BehaviorSubject<SkyMediaBreakpoints>(\n    this.current\n  );\n\n  private _current = SkyMediaBreakpoints.md;\n\n  private breakpoints: {\n    mediaQueryString: string;\n    name: SkyMediaBreakpoints;\n  }[] = [\n    {\n      mediaQueryString: SkyMediaQueryService.xs,\n      name: SkyMediaBreakpoints.xs,\n    },\n    {\n      mediaQueryString: SkyMediaQueryService.sm,\n      name: SkyMediaBreakpoints.sm,\n    },\n    {\n      mediaQueryString: SkyMediaQueryService.md,\n      name: SkyMediaBreakpoints.md,\n    },\n    {\n      mediaQueryString: SkyMediaQueryService.lg,\n      name: SkyMediaBreakpoints.lg,\n    },\n  ];\n\n  private mediaQueries: {\n    mediaQueryList: MediaQueryList;\n    listener: (event: any) => void;\n  }[] = [];\n\n  constructor(private zone: NgZone) {\n    this.addListeners();\n  }\n\n  public ngOnDestroy(): void {\n    this.removeListeners();\n    this.currentSubject.complete();\n  }\n\n  /**\n   * Suscribes to screen size changes.\n   * @param listener Specifies a function that is called when breakpoints change.\n   */\n  public subscribe(listener: SkyMediaQueryListener): Subscription {\n    return this.currentSubject.subscribe({\n      next: (breakpoints: SkyMediaBreakpoints) => {\n        listener(breakpoints);\n      },\n    });\n  }\n\n  /**\n   * @internal\n   */\n  public destroy(): void {\n    this.removeListeners();\n    this.currentSubject.complete();\n  }\n\n  private addListeners(): void {\n    this.mediaQueries = this.breakpoints.map((breakpoint: any) => {\n      const mq = matchMedia(breakpoint.mediaQueryString);\n\n      const listener = (event: any) => {\n        // Run the check outside of Angular's change detection since Angular\n        // does not wrap matchMedia listeners in NgZone.\n        // See: https://blog.assaf.co/angular-2-change-detection-zones-and-an-example/\n        this.zone.run(() => {\n          if (event.matches) {\n            this.notifyBreakpointChange(breakpoint.name);\n          }\n        });\n      };\n\n      mq.addListener(listener);\n\n      if (mq.matches) {\n        this.notifyBreakpointChange(breakpoint.name);\n      }\n\n      return {\n        mediaQueryList: mq,\n        listener,\n      };\n    });\n  }\n\n  private removeListeners(): void {\n    this.mediaQueries.forEach((mediaQuery) => {\n      mediaQuery.mediaQueryList.removeListener(mediaQuery.listener);\n    });\n    this.mediaQueries = [];\n  }\n\n  private notifyBreakpointChange(breakpoint: SkyMediaBreakpoints): void {\n    this._current = breakpoint;\n    this.currentSubject.next(breakpoint);\n  }\n}\n"]}

package/esm2020/lib/modules/mutation/mutation-observer-service.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MutationObserverService {
+    create(callback) {
+        return new MutationObserver(callback);
+    }
+}
+MutationObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: MutationObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MutationObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: MutationObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: MutationObserverService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXV0YXRpb24tb2JzZXJ2ZXItc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9tdXRhdGlvbi9tdXRhdGlvbi1vYnNlcnZlci1zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyx1QkFBdUI7SUFDM0IsTUFBTSxDQUFDLFFBQWE7UUFDekIsT0FBTyxJQUFJLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7O29IQUhVLHVCQUF1Qjt3SEFBdkIsdUJBQXVCLGNBRnRCLE1BQU07MkZBRVAsdUJBQXVCO2tCQUhuQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIE11dGF0aW9uT2JzZXJ2ZXJTZXJ2aWNlIHtcbiAgcHVibGljIGNyZWF0ZShjYWxsYmFjazogYW55KTogTXV0YXRpb25PYnNlcnZlciB7XG4gICAgcmV0dXJuIG5ldyBNdXRhdGlvbk9ic2VydmVyKGNhbGxiYWNrKTtcbiAgfVxufVxuIl19

package/esm2020/lib/modules/numeric/numeric-symbol.mjs

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

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

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { SkyI18nModule } from '@skyux/i18n';
+import { SkyCoreResourcesModule } from '../shared/sky-core-resources.module';
+import { SkyNumericPipe } from './numeric.pipe';
+import * as i0 from "@angular/core";
+export class SkyNumericModule {
+}
+SkyNumericModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyNumericModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericModule, declarations: [SkyNumericPipe], imports: [SkyI18nModule, SkyCoreResourcesModule], exports: [SkyNumericPipe] });
+SkyNumericModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericModule, providers: [SkyNumericPipe], imports: [[SkyI18nModule, SkyCoreResourcesModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SkyNumericPipe],
+                    providers: [SkyNumericPipe],
+                    imports: [SkyI18nModule, SkyCoreResourcesModule],
+                    exports: [SkyNumericPipe],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtZXJpYy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvbnVtZXJpYy9udW1lcmljLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFNUMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFN0UsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQVFoRCxNQUFNLE9BQU8sZ0JBQWdCOzs2R0FBaEIsZ0JBQWdCOzhHQUFoQixnQkFBZ0IsaUJBTFosY0FBYyxhQUVuQixhQUFhLEVBQUUsc0JBQXNCLGFBQ3JDLGNBQWM7OEdBRWIsZ0JBQWdCLGFBSmhCLENBQUMsY0FBYyxDQUFDLFlBQ2xCLENBQUMsYUFBYSxFQUFFLHNCQUFzQixDQUFDOzJGQUdyQyxnQkFBZ0I7a0JBTjVCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsY0FBYyxDQUFDO29CQUM5QixTQUFTLEVBQUUsQ0FBQyxjQUFjLENBQUM7b0JBQzNCLE9BQU8sRUFBRSxDQUFDLGFBQWEsRUFBRSxzQkFBc0IsQ0FBQztvQkFDaEQsT0FBTyxFQUFFLENBQUMsY0FBYyxDQUFDO2lCQUMxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTa3lJMThuTW9kdWxlIH0gZnJvbSAnQHNreXV4L2kxOG4nO1xuXG5pbXBvcnQgeyBTa3lDb3JlUmVzb3VyY2VzTW9kdWxlIH0gZnJvbSAnLi4vc2hhcmVkL3NreS1jb3JlLXJlc291cmNlcy5tb2R1bGUnO1xuXG5pbXBvcnQgeyBTa3lOdW1lcmljUGlwZSB9IGZyb20gJy4vbnVtZXJpYy5waXBlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbU2t5TnVtZXJpY1BpcGVdLFxuICBwcm92aWRlcnM6IFtTa3lOdW1lcmljUGlwZV0sXG4gIGltcG9ydHM6IFtTa3lJMThuTW9kdWxlLCBTa3lDb3JlUmVzb3VyY2VzTW9kdWxlXSxcbiAgZXhwb3J0czogW1NreU51bWVyaWNQaXBlXSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5TnVtZXJpY01vZHVsZSB7fVxuIl19

package/esm2020/lib/modules/numeric/numeric.options.mjs

@@ -0,0 +1,41 @@
+/**
+ * Provides arguments for the number to format.
+ */
+export class NumericOptions {
+    constructor() {
+        /**
+         * Specifies the maximum number of digits after the decimal separator.
+         * @default 1
+         */
+        this.digits = 1;
+        /**
+         * Specifies how to format the number. Options are `currency` or `number`.
+         * @default "number"
+         */
+        this.format = 'number';
+        /**
+         * Specifies the format of the currency.
+         * @default "standard"
+         */
+        this.currencySign = 'standard';
+        /**
+         * Specifies the ISO4217 currency code to use for currency formatting. If you do not specify a
+         * currency code, the component uses the browser's culture to determine the currency unless your
+         * SPA provides a different culture with `SkyAppLocaleProvider`.
+         * @default "USD"
+         */
+        this.iso = 'USD';
+        /**
+         * Indicates whether to shorten numbers to rounded numbers and abbreviation characters
+         * such as K for thousands, M for millions, B for billions, and T for trillions.
+         */
+        this.truncate = true;
+        /**
+         * Specifies the starting point after which numbers are shortened to rounded numbers
+         * and abbreviation characters.
+         * @default 0
+         */
+        this.truncateAfter = 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/numeric/numeric.pipe.mjs

@@ -0,0 +1,82 @@
+import { ChangeDetectorRef, Pipe, } from '@angular/core';
+import { SkyAppLocaleProvider } from '@skyux/i18n';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { NumericOptions } from './numeric.options';
+import { SkyNumericService } from './numeric.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/i18n";
+import * as i2 from "./numeric.service";
+/**
+ * Shortens numbers to rounded numbers and abbreviation characters such as K for thousands,
+ * M for millions, B for billions, and T for trillions. The pipe also formats for currency.
+ * Be sure you have a space after the two curly brackets opening the pipe and
+ * a space before the two curly brackets closing the pipe or it will not work.
+ * Usage:
+ * ```
+ * {{ value | skyNumeric(config) }}
+ * ```
+ */
+export class SkyNumericPipe {
+    constructor(localeProvider, numericService, changeDetector) {
+        this.localeProvider = localeProvider;
+        this.numericService = numericService;
+        this.changeDetector = changeDetector;
+        this.ngUnsubscribe = new Subject();
+        this.localeProvider
+            .getLocaleInfo()
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((localeInfo) => {
+            this.providerLocale = localeInfo.locale;
+            numericService.currentLocale = this.providerLocale;
+            this.changeDetector.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    transform(value, config) {
+        const newCacheKey = (config ? JSON.stringify(config, Object.keys(config).sort()) : '') +
+            `${value}_${config?.locale || this.providerLocale}`;
+        /* If the value and locale are the same as the last transform then return the previous value
+        instead of reformatting. */
+        if (this.formattedValue && this.cacheKey === newCacheKey) {
+            return this.formattedValue;
+        }
+        const options = new NumericOptions();
+        // The default number of digits is `1`. When truncate is disabled, set digits
+        // to `0` to avoid the unnecessary addition of `.0` at the end of the formatted number.
+        if (config && config.truncate === false && config.digits === undefined) {
+            options.digits = 0;
+        }
+        // If the minimum digits is less than the set maximum digits then throw an error
+        if (config &&
+            config.minDigits &&
+            config.digits &&
+            config.minDigits > config.digits) {
+            throw new Error('The `digits` property must be greater than or equal to the `minDigits` property');
+            // If there is a minimum digits given but not a maximum then default the maximum to the minimum
+        }
+        else if (config && config.minDigits && !config.digits) {
+            options.digits = config.minDigits;
+        }
+        Object.assign(options, config);
+        // Assign properties for proper result caching.
+        this.rawValue = value;
+        this.lastTransformLocale = config?.locale ?? this.providerLocale;
+        this.cacheKey = newCacheKey;
+        this.formattedValue = this.numericService.formatNumber(value, options);
+        return this.formattedValue;
+    }
+}
+SkyNumericPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericPipe, deps: [{ token: i1.SkyAppLocaleProvider }, { token: i2.SkyNumericService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+SkyNumericPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericPipe, name: "skyNumeric", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'skyNumeric',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyAppLocaleProvider }, { type: i2.SkyNumericService }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,188 @@
+import { Injectable } from '@angular/core';
+import { SkyIntlNumberFormatStyle, SkyLibResourcesService } from '@skyux/i18n';
+import { SkyNumberFormatUtility } from '../shared/number-format/number-format-utility';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/i18n";
+export class SkyNumericService {
+    constructor(resourcesService) {
+        this.resourcesService = resourcesService;
+        this.symbolIndex = [
+            { value: 1e12, label: this.getSymbol('skyux_numeric_trillions_symbol') },
+            { value: 1e9, label: this.getSymbol('skyux_numeric_billions_symbol') },
+            { value: 1e6, label: this.getSymbol('skyux_numeric_millions_symbol') },
+            { value: 1e3, label: this.getSymbol('skyux_numeric_thousands_symbol') },
+        ];
+    }
+    /**
+     * The browser's current locale.
+     * @internal
+     */
+    set currentLocale(value) {
+        this._locale = value;
+    }
+    get currentLocale() {
+        return this._locale || 'en-US';
+    }
+    /**
+     * Shortens with or without symbol (K/M/B/T) depending on value of number.
+     * @param value The number to format.
+     * @param options Format options.
+     */
+    formatNumber(value, options) {
+        /* tslint:disable-next-line:no-null-keyword */
+        if (isNaN(value) || value === null) {
+            return '';
+        }
+        const decimalPlaceRegExp = /\.0+$|(\.[0-9]*[1-9])0+$/;
+        // Get the symbol for the number after rounding, since rounding could push the number
+        // into a different symbol range.
+        let roundedNumber = this.roundNumber(value, options.digits);
+        const roundedNumberAbs = Math.abs(roundedNumber);
+        let suffix = '';
+        for (let i = 0; i < this.symbolIndex.length; i++) {
+            let symbol = this.symbolIndex[i];
+            if (options.truncate &&
+                roundedNumberAbs >= options.truncateAfter &&
+                roundedNumberAbs >= symbol.value) {
+                roundedNumber = this.roundNumber(value / symbol.value, options.digits);
+                if (Math.abs(roundedNumber) === 1000 && i > 0) {
+                    // Rounding caused the number to cross into the range of the next symbol.
+                    symbol = this.symbolIndex[i - 1];
+                    roundedNumber /= 1000;
+                }
+                suffix = symbol.label;
+                break;
+            }
+        }
+        let output = roundedNumber.toString().replace(decimalPlaceRegExp, '$1') + suffix;
+        this.storeShortenSymbol(output);
+        const locale = options.locale || this.currentLocale;
+        let digits;
+        let isDecimal;
+        // Checks the string entered for format. Using toLowerCase to ignore case.
+        switch (options.format?.toLowerCase()) {
+            // In a case where a decimal value was not shortened and
+            // the digit input is 2 or higher, it forces 2 digits.
+            // For example, this prevents a value like $15.50 from displaying as $15.5.
+            // Note: This will need to be reviewed if we support currencies with
+            // three decimal digits.
+            case 'currency':
+                isDecimal = value % 1 !== 0;
+                if (options.minDigits) {
+                    digits = `1.${options.minDigits}-${options.digits}`;
+                }
+                else if (isDecimal && options.digits >= 2) {
+                    digits = `1.2-${options.digits}`;
+                }
+                else {
+                    digits = `1.0-${options.digits}`;
+                }
+                output = SkyNumberFormatUtility.formatNumber(locale, parseFloat(output), SkyIntlNumberFormatStyle.Currency, digits, options.iso, 
+                // Angular 5+ needs a string for this parameter, but Angular 4 needs a boolean.
+                // To support both versions we can supply 'symbol' which will evaluate truthy for Angular 4
+                // and the appropriate string value for Angular 5+.
+                // See: https://angular.io/api/common/CurrencyPipe#parameters
+                'symbol', options.currencySign);
+                break;
+            // The following is a catch-all to ensure that if
+            // anything but currency (or a future option) are entered,
+            // it will be treated like a number.
+            default:
+                // Ensures localization of the number to ensure comma and
+                // decimal separator
+                if (options.minDigits) {
+                    digits = `1.${options.minDigits}-${options.digits}`;
+                }
+                else if (options.truncate) {
+                    digits = `1.0-${options.digits}`;
+                }
+                else {
+                    digits = `1.${options.digits}-${options.digits}`;
+                }
+                output = SkyNumberFormatUtility.formatNumber(locale, parseFloat(output), SkyIntlNumberFormatStyle.Decimal, digits);
+                break;
+        }
+        if (options.truncate) {
+            output = this.replaceShortenSymbol(output);
+        }
+        return output;
+    }
+    /**
+     * Rounds a given number
+     *
+     * JS's limitation - numbers bigger than Number.MIN_SAFE_INTEGER or Number.MAX_SAFE_INTEGER
+     * are not guaranteed to be represented or rounded correctly
+     * @param value - value to round
+     * @param precision - what precision to round with, defaults to 0 decimal places
+     */
+    roundNumber(value, precision = 0) {
+        if (precision < 0) {
+            throw new Error('SkyInvalidArgument: precision must be >= 0');
+        }
+        /* tslint:disable-next-line:no-null-keyword */
+        /* Sanity check - ignoring coverage but should not ignore if we make this method public */
+        /* istanbul ignore next */
+        if (isNaN(value) || value === null) {
+            return 0;
+        }
+        const scaledValue = this.scaleNumberByPowerOfTen(value, precision, true);
+        const scaledRoundedValue = Math.round(scaledValue);
+        const unscaledRoundedValue = this.scaleNumberByPowerOfTen(scaledRoundedValue, precision, false);
+        return unscaledRoundedValue;
+    }
+    /**
+     * Scales a given number by a power of 10
+     * @param value - value to scale
+     * @param scalar - 10^scalar
+     * @param scaleUp - whether to increase or decrease the value
+     */
+    scaleNumberByPowerOfTen(value, scalar, scaleUp) {
+        const valueStr = value.toString().toLowerCase();
+        const isExponentFormat = valueStr.includes('e');
+        if (isExponentFormat) {
+            const [base, exp] = valueStr.split('e');
+            const newExp = scaleUp ? Number(exp) + scalar : Number(exp) - scalar;
+            return Number(`${base}e${newExp}`);
+        }
+        else {
+            const e = scaleUp ? 'e' : 'e-';
+            return Number(`${value}${e}${scalar}`);
+        }
+    }
+    /**
+     * Stores the symbol added from shortening to reapply later.
+     * @param value The string to derive the shorten symbol from.
+     */
+    storeShortenSymbol(value) {
+        const symbols = this.symbolIndex.map((s) => s.label);
+        const regexp = new RegExp(symbols.join('|'), 'ig');
+        const match = value.match(regexp);
+        this.shortSymbol = match ? match.toString() : '';
+    }
+    /**
+     * Must have previously called storeShortenSymbol to have something to replace.
+     * Finds the last number in the formatted number, gets the index of the position
+     * after that character and re-inserts the symbol.
+     * Works regardless of currency symbol position.
+     * @param value The string to modify.
+     */
+    replaceShortenSymbol(value) {
+        const result = /(\d)(?!.*\d)/g.exec(value);
+        const pos = result.index + result.length;
+        const output = value.substring(0, pos) + this.shortSymbol + value.substring(pos);
+        return output;
+    }
+    getSymbol(key) {
+        // TODO: Need to implement the async `getString` method in a breaking change.
+        return this.resourcesService.getStringForLocale({ locale: 'en_US' }, key);
+    }
+}
+SkyNumericService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericService, deps: [{ token: i1.SkyLibResourcesService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyNumericService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericService, providedIn: 'any' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyNumericService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyLibResourcesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"numeric.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/numeric/numeric.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SkyIntlNumberFormatStyle, SkyLibResourcesService } from '@skyux/i18n';\n\nimport { SkyNumberFormatUtility } from '../shared/number-format/number-format-utility';\n\nimport { SkyNumericSymbol } from './numeric-symbol';\nimport { NumericOptions } from './numeric.options';\n\n@Injectable({\n  providedIn: 'any',\n})\nexport class SkyNumericService {\n  /**\n   * The browser's current locale.\n   * @internal\n   */\n  public set currentLocale(value: string) {\n    this._locale = value;\n  }\n\n  public get currentLocale(): string {\n    return this._locale || 'en-US';\n  }\n\n  /**\n   * @internal\n   */\n  public shortSymbol: string;\n\n  private symbolIndex: SkyNumericSymbol[] = [\n    { value: 1e12, label: this.getSymbol('skyux_numeric_trillions_symbol') },\n    { value: 1e9, label: this.getSymbol('skyux_numeric_billions_symbol') },\n    { value: 1e6, label: this.getSymbol('skyux_numeric_millions_symbol') },\n    { value: 1e3, label: this.getSymbol('skyux_numeric_thousands_symbol') },\n  ];\n\n  private _locale: string;\n\n  constructor(private resourcesService: SkyLibResourcesService) {}\n\n  /**\n   * Shortens with or without symbol (K/M/B/T) depending on value of number.\n   * @param value The number to format.\n   * @param options Format options.\n   */\n  public formatNumber(value: number, options: NumericOptions): string {\n    /* tslint:disable-next-line:no-null-keyword */\n    if (isNaN(value) || value === null) {\n      return '';\n    }\n\n    const decimalPlaceRegExp = /\\.0+$|(\\.[0-9]*[1-9])0+$/;\n\n    // Get the symbol for the number after rounding, since rounding could push the number\n    // into a different symbol range.\n    let roundedNumber = this.roundNumber(value, options.digits);\n    const roundedNumberAbs = Math.abs(roundedNumber);\n\n    let suffix = '';\n\n    for (let i = 0; i < this.symbolIndex.length; i++) {\n      let symbol = this.symbolIndex[i];\n\n      if (\n        options.truncate &&\n        roundedNumberAbs >= options.truncateAfter &&\n        roundedNumberAbs >= symbol.value\n      ) {\n        roundedNumber = this.roundNumber(value / symbol.value, options.digits);\n\n        if (Math.abs(roundedNumber) === 1000 && i > 0) {\n          // Rounding caused the number to cross into the range of the next symbol.\n          symbol = this.symbolIndex[i - 1];\n          roundedNumber /= 1000;\n        }\n\n        suffix = symbol.label;\n\n        break;\n      }\n    }\n\n    let output =\n      roundedNumber.toString().replace(decimalPlaceRegExp, '$1') + suffix;\n\n    this.storeShortenSymbol(output);\n\n    const locale = options.locale || this.currentLocale;\n\n    let digits: string;\n    let isDecimal: boolean;\n\n    // Checks the string entered for format. Using toLowerCase to ignore case.\n    switch (options.format?.toLowerCase()) {\n      // In a case where a decimal value was not shortened and\n      // the digit input is 2 or higher, it forces 2 digits.\n      // For example, this prevents a value like $15.50 from displaying as $15.5.\n      // Note: This will need to be reviewed if we support currencies with\n      // three decimal digits.\n      case 'currency':\n        isDecimal = value % 1 !== 0;\n\n        if (options.minDigits) {\n          digits = `1.${options.minDigits}-${options.digits}`;\n        } else if (isDecimal && options.digits >= 2) {\n          digits = `1.2-${options.digits}`;\n        } else {\n          digits = `1.0-${options.digits}`;\n        }\n\n        output = SkyNumberFormatUtility.formatNumber(\n          locale,\n          parseFloat(output),\n          SkyIntlNumberFormatStyle.Currency,\n          digits,\n          options.iso,\n          // Angular 5+ needs a string for this parameter, but Angular 4 needs a boolean.\n          // To support both versions we can supply 'symbol' which will evaluate truthy for Angular 4\n          // and the appropriate string value for Angular 5+.\n          // See: https://angular.io/api/common/CurrencyPipe#parameters\n          'symbol' as any,\n          options.currencySign\n        );\n        break;\n\n      // The following is a catch-all to ensure that if\n      // anything but currency (or a future option) are entered,\n      // it will be treated like a number.\n      default:\n        // Ensures localization of the number to ensure comma and\n        // decimal separator\n        if (options.minDigits) {\n          digits = `1.${options.minDigits}-${options.digits}`;\n        } else if (options.truncate) {\n          digits = `1.0-${options.digits}`;\n        } else {\n          digits = `1.${options.digits}-${options.digits}`;\n        }\n\n        output = SkyNumberFormatUtility.formatNumber(\n          locale,\n          parseFloat(output),\n          SkyIntlNumberFormatStyle.Decimal,\n          digits\n        );\n        break;\n    }\n\n    if (options.truncate) {\n      output = this.replaceShortenSymbol(output);\n    }\n\n    return output;\n  }\n\n  /**\n   * Rounds a given number\n   *\n   * JS's limitation - numbers bigger than Number.MIN_SAFE_INTEGER or Number.MAX_SAFE_INTEGER\n   * are not guaranteed to be represented or rounded correctly\n   * @param value - value to round\n   * @param precision - what precision to round with, defaults to 0 decimal places\n   */\n  private roundNumber(value: number, precision: number = 0): number {\n    if (precision < 0) {\n      throw new Error('SkyInvalidArgument: precision must be >= 0');\n    }\n\n    /* tslint:disable-next-line:no-null-keyword */\n    /* Sanity check - ignoring coverage but should not ignore if we make this method public */\n    /* istanbul ignore next */\n    if (isNaN(value) || value === null) {\n      return 0;\n    }\n\n    const scaledValue: number = this.scaleNumberByPowerOfTen(\n      value,\n      precision,\n      true\n    );\n    const scaledRoundedValue: number = Math.round(scaledValue);\n    const unscaledRoundedValue: number = this.scaleNumberByPowerOfTen(\n      scaledRoundedValue,\n      precision,\n      false\n    );\n\n    return unscaledRoundedValue;\n  }\n\n  /**\n   * Scales a given number by a power of 10\n   * @param value - value to scale\n   * @param scalar - 10^scalar\n   * @param scaleUp - whether to increase or decrease the value\n   */\n  private scaleNumberByPowerOfTen(\n    value: number,\n    scalar: number,\n    scaleUp: boolean\n  ): number {\n    const valueStr: string = value.toString().toLowerCase();\n    const isExponentFormat: boolean = valueStr.includes('e');\n\n    if (isExponentFormat) {\n      const [base, exp] = valueStr.split('e');\n      const newExp = scaleUp ? Number(exp) + scalar : Number(exp) - scalar;\n      return Number(`${base}e${newExp}`);\n    } else {\n      const e = scaleUp ? 'e' : 'e-';\n      return Number(`${value}${e}${scalar}`);\n    }\n  }\n\n  /**\n   * Stores the symbol added from shortening to reapply later.\n   * @param value The string to derive the shorten symbol from.\n   */\n  private storeShortenSymbol(value: string): void {\n    const symbols: string[] = this.symbolIndex.map((s) => s.label);\n    const regexp = new RegExp(symbols.join('|'), 'ig');\n    const match = value.match(regexp);\n    this.shortSymbol = match ? match.toString() : '';\n  }\n\n  /**\n   * Must have previously called storeShortenSymbol to have something to replace.\n   * Finds the last number in the formatted number, gets the index of the position\n   * after that character and re-inserts the symbol.\n   * Works regardless of currency symbol position.\n   * @param value The string to modify.\n   */\n  private replaceShortenSymbol(value: string): string {\n    const result = /(\\d)(?!.*\\d)/g.exec(value);\n    const pos = result.index + result.length;\n    const output =\n      value.substring(0, pos) + this.shortSymbol + value.substring(pos);\n\n    return output;\n  }\n\n  private getSymbol(key: string): string {\n    // TODO: Need to implement the async `getString` method in a breaking change.\n    return this.resourcesService.getStringForLocale({ locale: 'en_US' }, key);\n  }\n}\n"]}

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

@@ -0,0 +1,41 @@
+import { Injectable, RendererFactory2 } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @internal
+ */
+export class SkyOverlayAdapterService {
+    constructor(rendererFactory) {
+        this.renderer = rendererFactory.createRenderer(undefined, undefined);
+    }
+    restrictBodyScroll() {
+        // Create a style element to avoid overwriting any existing inline body styles.
+        const styleElement = this.renderer.createElement('style');
+        const textNode = this.renderer.createText('body { overflow: hidden }');
+        // Apply a `data-` attribute to make unit testing easier.
+        this.renderer.setAttribute(styleElement, 'data-test-selector', 'sky-overlay-restrict-scroll-styles');
+        this.renderer.appendChild(styleElement, textNode);
+        this.renderer.appendChild(document.head, styleElement);
+        if (this.styleElement) {
+            this.destroyStyleElement();
+        }
+        this.styleElement = styleElement;
+    }
+    releaseBodyScroll() {
+        this.destroyStyleElement();
+    }
+    destroyStyleElement() {
+        /* istanbul ignore else */
+        if (this.styleElement.parentElement === document.head) {
+            this.renderer.removeChild(document.head, this.styleElement);
+        }
+    }
+}
+SkyOverlayAdapterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyOverlayAdapterService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyOverlayAdapterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyOverlayAdapterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyOverlayAdapterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2020/lib/modules/overlay/overlay-context.mjs

@@ -0,0 +1,10 @@
+/**
+ * Provides contextual information to each overlay created.
+ * @internal
+ */
+export class SkyOverlayContext {
+    constructor(config) {
+        this.config = config;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS1jb250ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2NvcmUvc3JjL2xpYi9tb2R1bGVzL292ZXJsYXkvb3ZlcmxheS1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7R0FHRztBQUNILE1BQU0sT0FBTyxpQkFBaUI7SUFDNUIsWUFBNEIsTUFBd0I7UUFBeEIsV0FBTSxHQUFOLE1BQU0sQ0FBa0I7SUFBRyxDQUFDO0NBQ3pEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5T3ZlcmxheUNvbmZpZyB9IGZyb20gJy4vb3ZlcmxheS1jb25maWcnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGNvbnRleHR1YWwgaW5mb3JtYXRpb24gdG8gZWFjaCBvdmVybGF5IGNyZWF0ZWQuXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNsYXNzIFNreU92ZXJsYXlDb250ZXh0IHtcbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IGNvbmZpZzogU2t5T3ZlcmxheUNvbmZpZykge31cbn1cbiJdfQ==