@skyux/core 8.7.0 → 9.0.0-alpha.0

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

@@ -0,0 +1,124 @@
+import { Injectable, Injector, } from '@angular/core';
+import { SkyOverlayContext } from './overlay-context';
+import { SkyOverlayInstance } from './overlay-instance';
+import { SkyOverlayComponent } from './overlay.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./overlay-adapter.service";
+/**
+ * This service is used to create new overlays.
+ * @dynamic
+ */
+export class SkyOverlayService {
+    static { this.overlays = []; }
+    #adapter;
+    #applicationRef;
+    #componentFactoryResolver;
+    #injector;
+    // TODO: Replace deprecated `ComponentFactoryResolver`.
+    constructor(applicationRef, componentFactoryResolver, injector, adapter) {
+        this.#applicationRef = applicationRef;
+        this.#componentFactoryResolver = componentFactoryResolver;
+        this.#injector = injector;
+        this.#adapter = adapter;
+    }
+    /**
+     * Creates an empty overlay. Use the returned `SkyOverlayInstance` to append content.
+     * @param config Configuration for the overlay.
+     */
+    create(config) {
+        const settings = this.#prepareConfig(config);
+        if (settings.enableScroll === false) {
+            this.#adapter.restrictBodyScroll();
+        }
+        const componentRef = this.#createOverlay(settings);
+        const instance = new SkyOverlayInstance(settings, componentRef);
+        instance.closed.subscribe(() => {
+            // Only execute the service's close method if the instance still exists.
+            // This is needed to address a race condition if the deprecated instance.close method is used instead.
+            if (SkyOverlayService.overlays.indexOf(instance) > -1) {
+                this.close(instance);
+            }
+        });
+        SkyOverlayService.overlays.push(instance);
+        return instance;
+    }
+    /**
+     * Closes (and destroys) an overlay instance.
+     * @param instance The instance to close.
+     */
+    close(instance) {
+        this.#destroyOverlay(instance);
+        this.#applicationRef.detachView(instance.componentRef.hostView);
+        instance.componentRef.destroy();
+        // In some cases, Angular keeps dynamically-generated component's nodes in the DOM during
+        // unit tests. This can make querying difficult because the older DOM nodes still exist and
+        // produce inconsistent results.
+        // Angular Material's overlay appears to do the same thing:
+        // https://github.com/angular/components/blob/master/src/cdk/portal/dom-portal-outlet.ts#L143-L145
+        // (Ignoring coverage since this branch will only be hit by consumer unit tests.)
+        const componentElement = instance.componentRef.location.nativeElement;
+        /* istanbul ignore if */
+        if (componentElement.parentNode !== null) {
+            componentElement.parentNode.removeChild(componentElement);
+        }
+    }
+    /**
+     * Closes all overlay instances.
+     */
+    closeAll() {
+        // The `close` event handler for each instance alters the array's length asynchronously,
+        // so the only "safe" index to call is zero.
+        while (SkyOverlayService.overlays.length > 0) {
+            this.close(SkyOverlayService.overlays[0]);
+        }
+    }
+    #createOverlay(config) {
+        const injector = Injector.create({
+            parent: this.#injector,
+            providers: [
+                {
+                    provide: SkyOverlayContext,
+                    useValue: new SkyOverlayContext(config),
+                },
+            ],
+        });
+        const componentRef = this.#componentFactoryResolver
+            .resolveComponentFactory(SkyOverlayComponent)
+            .create(injector);
+        this.#applicationRef.attachView(componentRef.hostView);
+        const domElem = componentRef.hostView
+            .rootNodes[0];
+        document.body.appendChild(domElem);
+        return componentRef;
+    }
+    #prepareConfig(config = {}) {
+        const defaults = {
+            closeOnNavigation: true,
+            enableClose: false,
+            enablePointerEvents: false,
+            enableScroll: true,
+            showBackdrop: false,
+            wrapperClass: '',
+        };
+        return { ...defaults, ...config };
+    }
+    #destroyOverlay(instance) {
+        SkyOverlayService.overlays.splice(SkyOverlayService.overlays.indexOf(instance), 1);
+        if (instance.config.enableScroll === false) {
+            // Only release the body scroll if no other overlay wishes it to be disabled.
+            const anotherOverlayDisablesScroll = SkyOverlayService.overlays.some((o) => !o.config.enableScroll);
+            if (!anotherOverlayDisablesScroll) {
+                this.#adapter.releaseBodyScroll();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayService, deps: [{ token: i0.ApplicationRef }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i1.SkyOverlayAdapterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ApplicationRef }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i1.SkyOverlayAdapterService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/overlay/overlay.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,UAAU,EACV,QAAQ,GACT,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;;;AAE1D;;;GAGG;AAIH,MAAM,OAAO,iBAAiB;aACb,aAAQ,GAAyB,EAAE,AAA3B,CAA4B;IAEnD,QAAQ,CAA2B;IAEnC,eAAe,CAAiB;IAEhC,yBAAyB,CAA2B;IAEpD,SAAS,CAAW;IAEpB,uDAAuD;IACvD,YACE,cAA8B,EAC9B,wBAAkD,EAClD,QAAkB,EAClB,OAAiC;QAEjC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,IAAI,CAAC,yBAAyB,GAAG,wBAAwB,CAAC;QAC1D,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,MAAyB;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAE7C,IAAI,QAAQ,CAAC,YAAY,KAAK,KAAK,EAAE;YACnC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CAAC;SACpC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,kBAAkB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAEhE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE;YAC7B,wEAAwE;YACxE,sGAAsG;YACtG,IAAI,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE;gBACrD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;aACtB;QACH,CAAC,CAAC,CAAC;QAEH,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE1C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,QAA4B;QACvC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAChE,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAEhC,yFAAyF;QACzF,2FAA2F;QAC3F,gCAAgC;QAChC,2DAA2D;QAC3D,kGAAkG;QAClG,iFAAiF;QACjF,MAAM,gBAAgB,GAAG,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC;QACtE,wBAAwB;QACxB,IAAI,gBAAgB,CAAC,UAAU,KAAK,IAAI,EAAE;YACxC,gBAAgB,CAAC,UAAU,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;SAC3D;IACH,CAAC;IAED;;OAEG;IACI,QAAQ;QACb,wFAAwF;QACxF,4CAA4C;QAC5C,OAAO,iBAAiB,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;SAC3C;IACH,CAAC;IAED,cAAc,CAAC,MAAwB;QACrC,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC/B,MAAM,EAAE,IAAI,CAAC,SAAS;YACtB,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,iBAAiB;oBAC1B,QAAQ,EAAE,IAAI,iBAAiB,CAAC,MAAM,CAAC;iBACxC;aACF;SACF,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,IAAI,CAAC,yBAAyB;aAChD,uBAAuB,CAAC,mBAAmB,CAAC;aAC5C,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEpB,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAEvD,MAAM,OAAO,GAAI,YAAY,CAAC,QAAiC;aAC5D,SAAS,CAAC,CAAC,CAAgB,CAAC;QAE/B,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAEnC,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,cAAc,CAAC,SAA2B,EAAE;QAC1C,MAAM,QAAQ,GAAqB;YACjC,iBAAiB,EAAE,IAAI;YACvB,WAAW,EAAE,KAAK;YAClB,mBAAmB,EAAE,KAAK;YAC1B,YAAY,EAAE,IAAI;YAClB,YAAY,EAAE,KAAK;YACnB,YAAY,EAAE,EAAE;SACjB,CAAC;QAEF,OAAO,EAAE,GAAG,QAAQ,EAAE,GAAG,MAAM,EAAE,CAAC;IACpC,CAAC;IAED,eAAe,CAAC,QAA4B;QAC1C,iBAAiB,CAAC,QAAQ,CAAC,MAAM,CAC/B,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC5C,CAAC,CACF,CAAC;QAEF,IAAI,QAAQ,CAAC,MAAM,CAAC,YAAY,KAAK,KAAK,EAAE;YAC1C,6EAA6E;YAC7E,MAAM,4BAA4B,GAAG,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAClE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAC9B,CAAC;YACF,IAAI,CAAC,4BAA4B,EAAE;gBACjC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC;aACnC;SACF;IACH,CAAC;8GAzIU,iBAAiB;kHAAjB,iBAAiB,cAFhB,MAAM;;2FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {\n  ApplicationRef,\n  ComponentFactoryResolver,\n  ComponentRef,\n  EmbeddedViewRef,\n  Injectable,\n  Injector,\n} from '@angular/core';\n\nimport { SkyOverlayAdapterService } from './overlay-adapter.service';\nimport { SkyOverlayConfig } from './overlay-config';\nimport { SkyOverlayContext } from './overlay-context';\nimport { SkyOverlayInstance } from './overlay-instance';\nimport { SkyOverlayComponent } from './overlay.component';\n\n/**\n * This service is used to create new overlays.\n * @dynamic\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class SkyOverlayService {\n  private static overlays: SkyOverlayInstance[] = [];\n\n  #adapter: SkyOverlayAdapterService;\n\n  #applicationRef: ApplicationRef;\n\n  #componentFactoryResolver: ComponentFactoryResolver;\n\n  #injector: Injector;\n\n  // TODO: Replace deprecated `ComponentFactoryResolver`.\n  constructor(\n    applicationRef: ApplicationRef,\n    componentFactoryResolver: ComponentFactoryResolver,\n    injector: Injector,\n    adapter: SkyOverlayAdapterService\n  ) {\n    this.#applicationRef = applicationRef;\n    this.#componentFactoryResolver = componentFactoryResolver;\n    this.#injector = injector;\n    this.#adapter = adapter;\n  }\n\n  /**\n   * Creates an empty overlay. Use the returned `SkyOverlayInstance` to append content.\n   * @param config Configuration for the overlay.\n   */\n  public create(config?: SkyOverlayConfig): SkyOverlayInstance {\n    const settings = this.#prepareConfig(config);\n\n    if (settings.enableScroll === false) {\n      this.#adapter.restrictBodyScroll();\n    }\n\n    const componentRef = this.#createOverlay(settings);\n    const instance = new SkyOverlayInstance(settings, componentRef);\n\n    instance.closed.subscribe(() => {\n      // Only execute the service's close method if the instance still exists.\n      // This is needed to address a race condition if the deprecated instance.close method is used instead.\n      if (SkyOverlayService.overlays.indexOf(instance) > -1) {\n        this.close(instance);\n      }\n    });\n\n    SkyOverlayService.overlays.push(instance);\n\n    return instance;\n  }\n\n  /**\n   * Closes (and destroys) an overlay instance.\n   * @param instance The instance to close.\n   */\n  public close(instance: SkyOverlayInstance): void {\n    this.#destroyOverlay(instance);\n    this.#applicationRef.detachView(instance.componentRef.hostView);\n    instance.componentRef.destroy();\n\n    // In some cases, Angular keeps dynamically-generated component's nodes in the DOM during\n    // unit tests. This can make querying difficult because the older DOM nodes still exist and\n    // produce inconsistent results.\n    // Angular Material's overlay appears to do the same thing:\n    // https://github.com/angular/components/blob/master/src/cdk/portal/dom-portal-outlet.ts#L143-L145\n    // (Ignoring coverage since this branch will only be hit by consumer unit tests.)\n    const componentElement = instance.componentRef.location.nativeElement;\n    /* istanbul ignore if */\n    if (componentElement.parentNode !== null) {\n      componentElement.parentNode.removeChild(componentElement);\n    }\n  }\n\n  /**\n   * Closes all overlay instances.\n   */\n  public closeAll(): void {\n    // The `close` event handler for each instance alters the array's length asynchronously,\n    // so the only \"safe\" index to call is zero.\n    while (SkyOverlayService.overlays.length > 0) {\n      this.close(SkyOverlayService.overlays[0]);\n    }\n  }\n\n  #createOverlay(config: SkyOverlayConfig): ComponentRef<SkyOverlayComponent> {\n    const injector = Injector.create({\n      parent: this.#injector,\n      providers: [\n        {\n          provide: SkyOverlayContext,\n          useValue: new SkyOverlayContext(config),\n        },\n      ],\n    });\n\n    const componentRef = this.#componentFactoryResolver\n      .resolveComponentFactory(SkyOverlayComponent)\n      .create(injector);\n\n    this.#applicationRef.attachView(componentRef.hostView);\n\n    const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\n      .rootNodes[0] as HTMLElement;\n\n    document.body.appendChild(domElem);\n\n    return componentRef;\n  }\n\n  #prepareConfig(config: SkyOverlayConfig = {}): SkyOverlayConfig {\n    const defaults: SkyOverlayConfig = {\n      closeOnNavigation: true,\n      enableClose: false,\n      enablePointerEvents: false,\n      enableScroll: true,\n      showBackdrop: false,\n      wrapperClass: '',\n    };\n\n    return { ...defaults, ...config };\n  }\n\n  #destroyOverlay(instance: SkyOverlayInstance): void {\n    SkyOverlayService.overlays.splice(\n      SkyOverlayService.overlays.indexOf(instance),\n      1\n    );\n\n    if (instance.config.enableScroll === false) {\n      // Only release the body scroll if no other overlay wishes it to be disabled.\n      const anotherOverlayDisablesScroll = SkyOverlayService.overlays.some(\n        (o) => !o.config.enableScroll\n      );\n      if (!anotherOverlayDisablesScroll) {\n        this.#adapter.releaseBodyScroll();\n      }\n    }\n  }\n}\n"]}

package/{esm2020 → esm2022}/lib/modules/percent-pipe/percent-pipe.module.mjs

@@ -4,11 +4,11 @@ import { SkyCoreResourcesModule } from '../shared/sky-core-resources.module';
 import { SkyPercentPipe } from './percent.pipe';
 import * as i0 from "@angular/core";
 export class SkyPercentPipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipeModule, declarations: [SkyPercentPipe], imports: [CommonModule, SkyCoreResourcesModule], exports: [SkyPercentPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipeModule, providers: [SkyPercentPipe], imports: [CommonModule, SkyCoreResourcesModule] }); }
 }
-SkyPercentPipeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyPercentPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SkyPercentPipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SkyPercentPipeModule, declarations: [SkyPercentPipe], imports: [CommonModule, SkyCoreResourcesModule], exports: [SkyPercentPipe] });
-SkyPercentPipeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyPercentPipeModule, providers: [SkyPercentPipe], imports: [CommonModule, SkyCoreResourcesModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyPercentPipeModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipeModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [SkyPercentPipe],
@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     exports: [SkyPercentPipe],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyY2VudC1waXBlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9wZXJjZW50LXBpcGUvcGVyY2VudC1waXBlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUU3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7O0FBUWhELE1BQU0sT0FBTyxvQkFBb0I7O2lIQUFwQixvQkFBb0I7a0hBQXBCLG9CQUFvQixpQkFMaEIsY0FBYyxhQUVuQixZQUFZLEVBQUUsc0JBQXNCLGFBQ3BDLGNBQWM7a0hBRWIsb0JBQW9CLGFBSnBCLENBQUMsY0FBYyxDQUFDLFlBQ2pCLFlBQVksRUFBRSxzQkFBc0I7MkZBR25DLG9CQUFvQjtrQkFOaEMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxjQUFjLENBQUM7b0JBQzlCLFNBQVMsRUFBRSxDQUFDLGNBQWMsQ0FBQztvQkFDM0IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLHNCQUFzQixDQUFDO29CQUMvQyxPQUFPLEVBQUUsQ0FBQyxjQUFjLENBQUM7aUJBQzFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreUNvcmVSZXNvdXJjZXNNb2R1bGUgfSBmcm9tICcuLi9zaGFyZWQvc2t5LWNvcmUtcmVzb3VyY2VzLm1vZHVsZSc7XG5cbmltcG9ydCB7IFNreVBlcmNlbnRQaXBlIH0gZnJvbSAnLi9wZXJjZW50LnBpcGUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtTa3lQZXJjZW50UGlwZV0sXG4gIHByb3ZpZGVyczogW1NreVBlcmNlbnRQaXBlXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgU2t5Q29yZVJlc291cmNlc01vZHVsZV0sXG4gIGV4cG9ydHM6IFtTa3lQZXJjZW50UGlwZV0sXG59KVxuZXhwb3J0IGNsYXNzIFNreVBlcmNlbnRQaXBlTW9kdWxlIHt9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyY2VudC1waXBlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jb3JlL3NyYy9saWIvbW9kdWxlcy9wZXJjZW50LXBpcGUvcGVyY2VudC1waXBlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUU3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7O0FBUWhELE1BQU0sT0FBTyxvQkFBb0I7OEdBQXBCLG9CQUFvQjsrR0FBcEIsb0JBQW9CLGlCQUxoQixjQUFjLGFBRW5CLFlBQVksRUFBRSxzQkFBc0IsYUFDcEMsY0FBYzsrR0FFYixvQkFBb0IsYUFKcEIsQ0FBQyxjQUFjLENBQUMsWUFDakIsWUFBWSxFQUFFLHNCQUFzQjs7MkZBR25DLG9CQUFvQjtrQkFOaEMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxjQUFjLENBQUM7b0JBQzlCLFNBQVMsRUFBRSxDQUFDLGNBQWMsQ0FBQztvQkFDM0IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLHNCQUFzQixDQUFDO29CQUMvQyxPQUFPLEVBQUUsQ0FBQyxjQUFjLENBQUM7aUJBQzFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNreUNvcmVSZXNvdXJjZXNNb2R1bGUgfSBmcm9tICcuLi9zaGFyZWQvc2t5LWNvcmUtcmVzb3VyY2VzLm1vZHVsZSc7XG5cbmltcG9ydCB7IFNreVBlcmNlbnRQaXBlIH0gZnJvbSAnLi9wZXJjZW50LnBpcGUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtTa3lQZXJjZW50UGlwZV0sXG4gIHByb3ZpZGVyczogW1NreVBlcmNlbnRQaXBlXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgU2t5Q29yZVJlc291cmNlc01vZHVsZV0sXG4gIGV4cG9ydHM6IFtTa3lQZXJjZW50UGlwZV0sXG59KVxuZXhwb3J0IGNsYXNzIFNreVBlcmNlbnRQaXBlTW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/modules/percent-pipe/percent.pipe.mjs

@@ -0,0 +1,56 @@
+import { Pipe } from '@angular/core';
+import { SkyIntlNumberFormatStyle } from '@skyux/i18n';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyNumberFormatUtility } from '../shared/number-format/number-format-utility';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/i18n";
+export class SkyPercentPipe {
+    get defaultLocale() {
+        return this.#defaultLocale;
+    }
+    #defaultFormat = '1.0-2';
+    #defaultLocale = 'en-US';
+    #format;
+    #formattedValue = '';
+    #locale;
+    #ngUnsubscribe = new Subject();
+    #value;
+    constructor(localeProvider) {
+        localeProvider
+            .getLocaleInfo()
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((localeInfo) => {
+            this.#defaultLocale = localeInfo.locale;
+            this.#updateFormattedValue();
+        });
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    transform(value, format, locale) {
+        this.#value = value;
+        this.#format = format;
+        this.#locale = locale;
+        this.#updateFormattedValue();
+        return this.#formattedValue;
+    }
+    #updateFormattedValue() {
+        const locale = this.#locale || this.#defaultLocale;
+        const format = this.#format || this.#defaultFormat;
+        this.#formattedValue = this.#value
+            ? SkyNumberFormatUtility.formatNumber(locale, this.#value, SkyIntlNumberFormatStyle.Percent, format)
+            : '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipe, deps: [{ token: i1.SkyAppLocaleProvider }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipe, name: "skyPercent", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPercentPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'skyPercent',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyAppLocaleProvider }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/resize-observer/resize-observer-media-query.service.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyMediaBreakpoints } from '../media-query/media-breakpoints';
+import * as i0 from "@angular/core";
+import * as i1 from "./resize-observer.service";
+const DEFAULT_BREAKPOINT = SkyMediaBreakpoints.md;
+/**
+ * Acts like `SkyMediaQueryService` for a container element, emitting the same responsive breakpoints.
+ */
+export class SkyResizeObserverMediaQueryService {
+    /**
+     * Returns the current breakpoint.
+     */
+    get current() {
+        return this.#currentBreakpoint;
+    }
+    #breakpoints = [
+        {
+            check: (width) => width > 0 && width <= 767,
+            name: SkyMediaBreakpoints.xs,
+        },
+        {
+            check: (width) => width > 767 && width <= 991,
+            name: SkyMediaBreakpoints.sm,
+        },
+        {
+            check: (width) => width > 991 && width <= 1199,
+            name: SkyMediaBreakpoints.md,
+        },
+        {
+            check: (width) => width > 1199,
+            name: SkyMediaBreakpoints.lg,
+        },
+    ];
+    #currentBreakpoint = DEFAULT_BREAKPOINT;
+    #currentBreakpointObs = new ReplaySubject(1);
+    #ngUnsubscribe = new Subject();
+    #resizeObserverSvc;
+    #target;
+    constructor(resizeObserverSvc) {
+        this.#resizeObserverSvc = resizeObserverSvc;
+    }
+    ngOnDestroy() {
+        this.unobserve();
+        this.#target = undefined;
+        this.#currentBreakpointObs.complete();
+    }
+    /**
+     * @internal
+     */
+    destroy() {
+        this.ngOnDestroy();
+    }
+    /**
+     * Sets the container element to watch. The `SkyResizeObserverMediaQueryService` will only observe one element at a
+     * time. Any previous subscriptions will be unsubscribed when a new element is observed.
+     */
+    observe(element) {
+        if (this.#target) {
+            if (this.#target === element) {
+                return this;
+            }
+            this.unobserve();
+        }
+        this.#target = element;
+        this.#checkWidth(element);
+        this.#resizeObserverSvc
+            .observe(element)
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((value) => {
+            const breakpoint = this.#checkBreakpoint(value.contentRect.width);
+            if (breakpoint && breakpoint !== this.current) {
+                this.#updateBreakpoint(breakpoint);
+            }
+        });
+        return this;
+    }
+    /**
+     * Stop watching the container element.
+     */
+    unobserve() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    /**
+     * Subscribes to element size changes that cross breakpoints.
+     */
+    subscribe(listener) {
+        return this.#currentBreakpointObs
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((value) => {
+            listener(value);
+        });
+    }
+    #updateBreakpoint(breakpoint) {
+        this.#currentBreakpoint = breakpoint;
+        this.#currentBreakpointObs.next(breakpoint);
+    }
+    #checkBreakpoint(width) {
+        const breakpoint = this.#breakpoints.find((breakpoint) => breakpoint.check(width));
+        return breakpoint ? breakpoint.name : undefined;
+    }
+    #checkWidth(el) {
+        const width = el.nativeElement.offsetWidth || 0;
+        const breakpoint = this.#checkBreakpoint(width);
+        if (breakpoint && breakpoint !== this.#currentBreakpoint) {
+            this.#updateBreakpoint(breakpoint);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyResizeObserverMediaQueryService, deps: [{ token: i1.SkyResizeObserverService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyResizeObserverMediaQueryService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyResizeObserverMediaQueryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyResizeObserverService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize-observer-media-query.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/resize-observer/resize-observer-media-query.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable, OnDestroy } from '@angular/core';\n\nimport { ReplaySubject, Subject, Subscription } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyMediaBreakpoints } from '../media-query/media-breakpoints';\nimport { SkyMediaQueryListener } from '../media-query/media-query-listener';\n\nimport { SkyResizeObserverService } from './resize-observer.service';\n\nconst DEFAULT_BREAKPOINT = SkyMediaBreakpoints.md;\n\n/**\n * Acts like `SkyMediaQueryService` for a container element, emitting the same responsive breakpoints.\n */\n@Injectable({\n  providedIn: 'any',\n})\nexport class SkyResizeObserverMediaQueryService implements OnDestroy {\n  /**\n   * Returns the current breakpoint.\n   */\n  public get current(): SkyMediaBreakpoints {\n    return this.#currentBreakpoint;\n  }\n\n  #breakpoints: {\n    check: (width: number) => boolean;\n    name: SkyMediaBreakpoints;\n  }[] = [\n    {\n      check: (width: number) => width > 0 && width <= 767,\n      name: SkyMediaBreakpoints.xs,\n    },\n    {\n      check: (width: number) => width > 767 && width <= 991,\n      name: SkyMediaBreakpoints.sm,\n    },\n    {\n      check: (width: number) => width > 991 && width <= 1199,\n      name: SkyMediaBreakpoints.md,\n    },\n    {\n      check: (width: number) => width > 1199,\n      name: SkyMediaBreakpoints.lg,\n    },\n  ];\n\n  #currentBreakpoint: SkyMediaBreakpoints = DEFAULT_BREAKPOINT;\n\n  #currentBreakpointObs = new ReplaySubject<SkyMediaBreakpoints>(1);\n\n  #ngUnsubscribe = new Subject<void>();\n\n  #resizeObserverSvc: SkyResizeObserverService;\n\n  #target: ElementRef | undefined;\n\n  constructor(resizeObserverSvc: SkyResizeObserverService) {\n    this.#resizeObserverSvc = resizeObserverSvc;\n  }\n\n  public ngOnDestroy(): void {\n    this.unobserve();\n\n    this.#target = undefined;\n    this.#currentBreakpointObs.complete();\n  }\n\n  /**\n   * @internal\n   */\n  public destroy(): void {\n    this.ngOnDestroy();\n  }\n\n  /**\n   * Sets the container element to watch. The `SkyResizeObserverMediaQueryService` will only observe one element at a\n   * time. Any previous subscriptions will be unsubscribed when a new element is observed.\n   */\n  public observe(element: ElementRef): SkyResizeObserverMediaQueryService {\n    if (this.#target) {\n      if (this.#target === element) {\n        return this;\n      }\n\n      this.unobserve();\n    }\n\n    this.#target = element;\n\n    this.#checkWidth(element);\n\n    this.#resizeObserverSvc\n      .observe(element)\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((value) => {\n        const breakpoint = this.#checkBreakpoint(value.contentRect.width);\n        if (breakpoint && breakpoint !== this.current) {\n          this.#updateBreakpoint(breakpoint);\n        }\n      });\n    return this;\n  }\n\n  /**\n   * Stop watching the container element.\n   */\n  public unobserve(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n  }\n\n  /**\n   * Subscribes to element size changes that cross breakpoints.\n   */\n  public subscribe(listener: SkyMediaQueryListener): Subscription {\n    return this.#currentBreakpointObs\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((value) => {\n        listener(value);\n      });\n  }\n\n  #updateBreakpoint(breakpoint: SkyMediaBreakpoints) {\n    this.#currentBreakpoint = breakpoint;\n    this.#currentBreakpointObs.next(breakpoint);\n  }\n\n  #checkBreakpoint(width: number): SkyMediaBreakpoints | undefined {\n    const breakpoint = this.#breakpoints.find((breakpoint) =>\n      breakpoint.check(width)\n    );\n\n    return breakpoint ? breakpoint.name : undefined;\n  }\n\n  #checkWidth(el: ElementRef): void {\n    const width = (el.nativeElement as HTMLElement).offsetWidth || 0;\n    const breakpoint = this.#checkBreakpoint(width);\n\n    if (breakpoint && breakpoint !== this.#currentBreakpoint) {\n      this.#updateBreakpoint(breakpoint);\n    }\n  }\n}\n"]}

package/esm2022/lib/modules/resize-observer/resize-observer.service.mjs

@@ -0,0 +1,77 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { finalize } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Service to create rxjs observables for changes to the content box dimensions of elements.
+ */
+export class SkyResizeObserverService {
+    #resizeObserver;
+    #tracking = [];
+    #zone;
+    constructor(zone) {
+        this.#zone = zone;
+        this.#resizeObserver = new ResizeObserver((entries) => {
+            entries.forEach((entry) => this.#callback(entry));
+        });
+    }
+    ngOnDestroy() {
+        this.#resizeObserver.disconnect();
+    }
+    /**
+     * Create rxjs observable to get size changes for an element ref.
+     */
+    observe(element) {
+        return this.#observeAndTrack(element).subjectObservable;
+    }
+    #observeAndTrack(element) {
+        const checkTracking = this.#tracking.findIndex((value) => {
+            return !value.subject.closed && value.element === element.nativeElement;
+        });
+        if (checkTracking === -1) {
+            this.#resizeObserver.observe(element.nativeElement);
+        }
+        const subject = new Subject();
+        const subjectObservable = subject.pipe(finalize(() => {
+            // Are there any other tracking entries still watching this element?
+            const checkTracking = this.#tracking.findIndex((value) => {
+                return (value.subject !== subject &&
+                    !value.subject.closed &&
+                    value.element === element.nativeElement);
+            });
+            if (checkTracking === -1) {
+                this.#resizeObserver.unobserve(element.nativeElement);
+            }
+        }));
+        const tracking = {
+            element: element.nativeElement,
+            subject,
+            subjectObservable,
+        };
+        this.#tracking.push(tracking);
+        return tracking;
+    }
+    #callback(entry) {
+        this.#tracking
+            .filter((value) => !(value.subject.closed || value.subject.isStopped))
+            .forEach((value) => {
+            /* istanbul ignore else */
+            if (value.element === entry.target) {
+                // Execute the callback within NgZone because Angular does not "monkey patch"
+                // ResizeObserver like it does for other features in the DOM.
+                this.#zone.run(() => {
+                    value.subject.next(entry);
+                });
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyResizeObserverService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyResizeObserverService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyResizeObserverService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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