pdm-ui-kit 0.4.2 → 1.1.0

package/esm2020/src/overlay/pdm-outside-click.directive.mjs

@@ -0,0 +1,86 @@
+import { Directive, ElementRef, EventEmitter, Inject, Input, Output, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Emits `(pdmOutsideClick)` whenever a `pointerdown` event fires outside the host element.
+ *
+ * Uses the CAPTURE phase so it intercepts clicks even when inner elements call
+ * `stopPropagation()` (e.g. CDK overlay panels).
+ *
+ * SSR-safe: no listener is registered when running on the server.
+ *
+ * @example
+ * ```html
+ * <div [pdmOutsideClick]
+ *      (pdmOutsideClick)="close()"
+ *      [pdmOutsideClickDisabled]="!open">
+ * </div>
+ * ```
+ */
+export class PdmOutsideClickDirective {
+    constructor(elementRef, document, platformId) {
+        this.elementRef = elementRef;
+        this.document = document;
+        /** When `true`, the outside-click listener is inactive. */
+        this.pdmOutsideClickDisabled = false;
+        /**
+         * Additional elements to exclude from the "outside" check.
+         * Useful when the trigger lives outside the host (e.g. a menubar button
+         * that opens a floating panel bound to a different root element).
+         */
+        this.pdmOutsideClickExclude = [];
+        /** Fires when a `pointerdown` lands outside the host (and excluded elements). */
+        this.pdmOutsideClick = new EventEmitter();
+        this.isBrowser = isPlatformBrowser(platformId);
+    }
+    ngOnInit() {
+        if (!this.isBrowser)
+            return;
+        this.boundHandler = (event) => this.onPointerDown(event);
+        this.document.addEventListener('pointerdown', this.boundHandler, { capture: true });
+    }
+    ngOnDestroy() {
+        if (!this.isBrowser || !this.boundHandler)
+            return;
+        this.document.removeEventListener('pointerdown', this.boundHandler, { capture: true });
+    }
+    onPointerDown(event) {
+        if (this.pdmOutsideClickDisabled)
+            return;
+        const target = event.target;
+        if (!target)
+            return;
+        // Check if click is inside the host element.
+        if (this.elementRef.nativeElement.contains(target))
+            return;
+        // Check if click is inside any excluded element.
+        for (const excluded of this.pdmOutsideClickExclude) {
+            const el = excluded instanceof ElementRef ? excluded.nativeElement : excluded;
+            if (el && el.contains(target))
+                return;
+        }
+        this.pdmOutsideClick.emit(event);
+    }
+}
+PdmOutsideClickDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmOutsideClickDirective, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
+PdmOutsideClickDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: PdmOutsideClickDirective, selector: "[pdmOutsideClick]", inputs: { pdmOutsideClickDisabled: "pdmOutsideClickDisabled", pdmOutsideClickExclude: "pdmOutsideClickExclude" }, outputs: { pdmOutsideClick: "pdmOutsideClick" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmOutsideClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pdmOutsideClick]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; }, propDecorators: { pdmOutsideClickDisabled: [{
+                type: Input
+            }], pdmOutsideClickExclude: [{
+                type: Input
+            }], pdmOutsideClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/overlay/pdm-outside-click.module.mjs

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

package/esm2020/src/overlay/pdm-overlay-options.mjs

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

package/esm2020/src/overlay/pdm-ui-kit-src-overlay.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGRtLXVpLWtpdC1zcmMtb3ZlcmxheS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9vdmVybGF5L3BkbS11aS1raXQtc3JjLW92ZXJsYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/src/overlay/public-api.mjs

@@ -0,0 +1,6 @@
+export * from "./pdm-overlay-options";
+export * from "./create-flexible-position-strategy";
+export * from "./pdm-outside-click.directive";
+export * from "./pdm-outside-click.module";
+export * from "./z-index-helper";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9vdmVybGF5L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGRtLW92ZXJsYXktb3B0aW9uc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY3JlYXRlLWZsZXhpYmxlLXBvc2l0aW9uLXN0cmF0ZWd5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wZG0tb3V0c2lkZS1jbGljay5kaXJlY3RpdmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BkbS1vdXRzaWRlLWNsaWNrLm1vZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vei1pbmRleC1oZWxwZXJcIjtcbiJdfQ==

package/esm2020/src/overlay/z-index-helper.mjs

@@ -0,0 +1,69 @@
+/**
+ * Z-Index helper for overlay components.
+ *
+ * CRITICAL: Consumer custom panelClass MUST NOT replace the base z-index.
+ * This helper ensures z-index is preserved when merging custom classes.
+ */
+/**
+ * Base z-index class for overlays - MUST be included in any overlay panel.
+ * This ensures overlays appear above modals (z-50) and drawers (z-40).
+ */
+export const OVERLAY_BASE_Z_INDEX = "z-[70]";
+/**
+ * Merge consumer's panelClass with our base z-index.
+ * Consumer classes are APPENDED, not replacing our z-index guarantee.
+ *
+ * @param baseZIndex - Base z-index class to enforce (default: OVERLAY_BASE_Z_INDEX)
+ * @param consumerClasses - Optional additional classes from consumer
+ * @returns Array of classes safe for CDK Overlay panelClass
+ */
+export function mergeOverlayPanelClass(baseZIndex = OVERLAY_BASE_Z_INDEX, consumerClasses) {
+    const baseClasses = baseZIndex.split(" ");
+    if (!consumerClasses) {
+        return baseClasses;
+    }
+    const consumerClassArray = Array.isArray(consumerClasses)
+        ? consumerClasses
+        : consumerClasses.split(" ");
+    // Consumer classes are appended AFTER base classes
+    // This ensures z-index from baseClasses is preserved first
+    return [...baseClasses, ...consumerClassArray];
+}
+/**
+ * Create OverlayConfig with guaranteed z-index.
+ * Use this instead of direct OverlayConfig to ensure z-index enforcement.
+ *
+ * @param baseConfig - Base overlay configuration
+ * @param consumerPanelClass - Optional consumer panelClass to merge
+ * @returns OverlayConfig with z-index guarantee
+ */
+export function createZIndexEnforcedOverlay(baseConfig, consumerPanelClass) {
+    const mergedClasses = mergeOverlayPanelClass(OVERLAY_BASE_Z_INDEX, consumerPanelClass);
+    const existingPanelClass = baseConfig.panelClass;
+    if (existingPanelClass) {
+        const existingArray = Array.isArray(existingPanelClass)
+            ? existingPanelClass
+            : existingPanelClass.split(" ");
+        return {
+            ...baseConfig,
+            panelClass: [...mergedClasses, ...existingArray],
+        };
+    }
+    return {
+        ...baseConfig,
+        panelClass: mergedClasses,
+    };
+}
+/**
+ * Helper to extract z-index from a class string for debugging.
+ */
+export function extractZIndex(classes) {
+    const classArray = Array.isArray(classes) ? classes : classes.split(" ");
+    for (const cls of classArray) {
+        if (cls.startsWith("z-") || cls.startsWith("z-[")) {
+            return cls;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/{lib/components → src}/pagination/pagination.component.mjs

@@ -1,8 +1,8 @@
 import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
-import * as i2 from "../icon/icon.component";
-import * as i3 from "../select/select.component";
+import * as i2 from "pdm-ui-kit/src/icon";
+import * as i3 from "pdm-ui-kit/src/select";
 export class PdmPaginationComponent {
     constructor() {
         this.page = 1;
@@ -69,4 +69,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
             }], rowsPerPageChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../../../src/lib/components/pagination/pagination.component.ts","../../../../../../src/lib/components/pagination/pagination.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;;;;;AAQhG,MAAM,OAAO,sBAAsB;IALnC;QAMW,SAAI,GAAG,CAAC,CAAC;QACT,cAAS,GAAG,CAAC,CAAC;QACd,eAAU,GAAG,CAAC,CAAC;QACf,cAAS,GAAG,EAAE,CAAC;QACf,qBAAgB,GAAG,eAAe,CAAC;QACnC,gBAAW,GAAG,EAAE,CAAC;QACjB,uBAAkB,GAAa,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAE/C,eAAU,GAAG,IAAI,YAAY,EAAU,CAAC;QACxC,sBAAiB,GAAG,IAAI,YAAY,EAAU,CAAC;KAsC1D;IApCC,IAAI,wBAAwB;QAC1B,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC7C,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;YACpB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;SACrB,CAAC,CAAC,CAAC;IACN,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,YAAY;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YACzC,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;SACvD;QAED,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;YAC3D,OAAO;SACR;QAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED,wBAAwB,CAAC,KAAa;QACpC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;YACpE,OAAO;SACR;QAED,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;;mHA/CU,sBAAsB;uGAAtB,sBAAsB,qVCRnC,wzFAmEA;2FD3Da,sBAAsB;kBALlC,SAAS;+BACE,gBAAgB,mBAET,uBAAuB,CAAC,MAAM;8BAGtC,IAAI;sBAAZ,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBAEI,UAAU;sBAAnB,MAAM;gBACG,iBAAiB;sBAA1B,MAAM","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';\nimport type { PdmNativeSelectOption } from '../native-select/native-select.component';\n\n@Component({\n  selector: 'pdm-pagination',\n  templateUrl: './pagination.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PdmPaginationComponent {\n  @Input() page = 1;\n  @Input() pageCount = 1;\n  @Input() maxVisible = 4;\n  @Input() className = '';\n  @Input() rowsPerPageLabel = 'Rows per page';\n  @Input() rowsPerPage = 10;\n  @Input() rowsPerPageOptions: number[] = [10, 20, 30, 50];\n\n  @Output() pageChange = new EventEmitter<number>();\n  @Output() rowsPerPageChange = new EventEmitter<number>();\n\n  get rowsPerPageSelectOptions(): PdmNativeSelectOption[] {\n    return this.rowsPerPageOptions.map((value) => ({\n      label: String(value),\n      value: String(value)\n    }));\n  }\n\n  get rowsPerPageValue(): string {\n    return String(this.rowsPerPage);\n  }\n\n  get visiblePages(): Array<number | 'ellipsis'> {\n    const total = Math.max(1, this.pageCount);\n    if (total <= Math.max(1, this.maxVisible)) {\n      return Array.from({ length: total }, (_, i) => i + 1);\n    }\n\n    return [1, 2, 'ellipsis', total];\n  }\n\n  setPage(next: number): void {\n    if (next < 1 || next > this.pageCount || next === this.page) {\n      return;\n    }\n\n    this.pageChange.emit(next);\n  }\n\n  onRowsPerPageChangeValue(value: string): void {\n    const next = Number(value);\n    if (!Number.isFinite(next) || next <= 0 || next === this.rowsPerPage) {\n      return;\n    }\n\n    this.rowsPerPageChange.emit(next);\n  }\n}\n","<nav\n  aria-label=\"Pagination\"\n  [ngClass]=\"[\n    'mx-auto flex w-full flex-wrap items-center justify-center gap-4',\n    className,\n  ]\"\n>\n  <div class=\"flex items-center gap-3\" *ngIf=\"rowsPerPageOptions.length > 0\">\n    <span class=\"text-sm font-medium text-foreground\">{{\n      rowsPerPageLabel\n    }}</span>\n    <pdm-select\n      [value]=\"rowsPerPageValue\"\n      [options]=\"rowsPerPageSelectOptions\"\n      [placeholder]=\"rowsPerPageValue\"\n      className=\"w-[100px] sm:w-[120px]\"\n      (valueChange)=\"onRowsPerPageChangeValue($event)\"\n    ></pdm-select>\n  </div>\n\n  <ul class=\"m-0 flex list-none items-center gap-1 p-0\">\n    <li>\n      <button\n        type=\"button\"\n        class=\"inline-flex h-9 appearance-none box-border items-center justify-center gap-1 rounded-md border-0 bg-transparent px-2 text-sm text-foreground hover:bg-accent disabled:opacity-50 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2\"\n        [disabled]=\"page <= 1\"\n        (click)=\"setPage(page - 1)\"\n      >\n        <pdm-icon name=\"chevron-left\" [size]=\"14\"></pdm-icon>\n        Previous\n      </button>\n    </li>\n    <li *ngFor=\"let pageNumber of visiblePages\">\n      <ng-container *ngIf=\"pageNumber === 'ellipsis'; else pageButton\">\n        <span\n          class=\"inline-flex h-9 min-w-9 items-center justify-center px-2 text-sm text-muted-foreground\"\n          >...</span\n        >\n      </ng-container>\n      <ng-template #pageButton>\n        <button\n          type=\"button\"\n          [ngClass]=\"[\n            'inline-flex h-9 min-w-9 items-center justify-center rounded-md px-2 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n            pageNumber === page\n              ? 'appearance-none box-border border border-solid border-border bg-muted text-foreground shadow-sm'\n              : 'appearance-none box-border border-0 bg-transparent text-foreground hover:bg-accent hover:text-accent-foreground',\n          ]\"\n          (click)=\"setPage(+pageNumber)\"\n        >\n          {{ pageNumber }}\n        </button>\n      </ng-template>\n    </li>\n    <li>\n      <button\n        type=\"button\"\n        class=\"inline-flex h-9 appearance-none box-border items-center justify-center gap-1 rounded-md border-0 bg-transparent px-2 text-sm text-foreground hover:bg-accent disabled:opacity-50 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2\"\n        [disabled]=\"page >= pageCount\"\n        (click)=\"setPage(page + 1)\"\n      >\n        Next\n        <pdm-icon name=\"chevron-right\" [size]=\"14\"></pdm-icon>\n      </button>\n    </li>\n  </ul>\n</nav>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../../src/pagination/pagination.component.ts","../../../../../src/pagination/pagination.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;;;;;AAQhG,MAAM,OAAO,sBAAsB;IALnC;QAMW,SAAI,GAAG,CAAC,CAAC;QACT,cAAS,GAAG,CAAC,CAAC;QACd,eAAU,GAAG,CAAC,CAAC;QACf,cAAS,GAAG,EAAE,CAAC;QACf,qBAAgB,GAAG,eAAe,CAAC;QACnC,gBAAW,GAAG,EAAE,CAAC;QACjB,uBAAkB,GAAa,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAE/C,eAAU,GAAG,IAAI,YAAY,EAAU,CAAC;QACxC,sBAAiB,GAAG,IAAI,YAAY,EAAU,CAAC;KAsC1D;IApCC,IAAI,wBAAwB;QAC1B,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC7C,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;YACpB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;SACrB,CAAC,CAAC,CAAC;IACN,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,YAAY;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YACzC,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;SACvD;QAED,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;YAC3D,OAAO;SACR;QAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED,wBAAwB,CAAC,KAAa;QACpC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;YACpE,OAAO;SACR;QAED,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;;mHA/CU,sBAAsB;uGAAtB,sBAAsB,qVCRnC,wzFAmEA;2FD3Da,sBAAsB;kBALlC,SAAS;+BACE,gBAAgB,mBAET,uBAAuB,CAAC,MAAM;8BAGtC,IAAI;sBAAZ,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBAEI,UAAU;sBAAnB,MAAM;gBACG,iBAAiB;sBAA1B,MAAM","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';\nimport type { PdmNativeSelectOption } from 'pdm-ui-kit/src/native-select';\n\n@Component({\n  selector: 'pdm-pagination',\n  templateUrl: './pagination.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PdmPaginationComponent {\n  @Input() page = 1;\n  @Input() pageCount = 1;\n  @Input() maxVisible = 4;\n  @Input() className = '';\n  @Input() rowsPerPageLabel = 'Rows per page';\n  @Input() rowsPerPage = 10;\n  @Input() rowsPerPageOptions: number[] = [10, 20, 30, 50];\n\n  @Output() pageChange = new EventEmitter<number>();\n  @Output() rowsPerPageChange = new EventEmitter<number>();\n\n  get rowsPerPageSelectOptions(): PdmNativeSelectOption[] {\n    return this.rowsPerPageOptions.map((value) => ({\n      label: String(value),\n      value: String(value)\n    }));\n  }\n\n  get rowsPerPageValue(): string {\n    return String(this.rowsPerPage);\n  }\n\n  get visiblePages(): Array<number | 'ellipsis'> {\n    const total = Math.max(1, this.pageCount);\n    if (total <= Math.max(1, this.maxVisible)) {\n      return Array.from({ length: total }, (_, i) => i + 1);\n    }\n\n    return [1, 2, 'ellipsis', total];\n  }\n\n  setPage(next: number): void {\n    if (next < 1 || next > this.pageCount || next === this.page) {\n      return;\n    }\n\n    this.pageChange.emit(next);\n  }\n\n  onRowsPerPageChangeValue(value: string): void {\n    const next = Number(value);\n    if (!Number.isFinite(next) || next <= 0 || next === this.rowsPerPage) {\n      return;\n    }\n\n    this.rowsPerPageChange.emit(next);\n  }\n}\n","<nav\n  aria-label=\"Pagination\"\n  [ngClass]=\"[\n    'mx-auto flex w-full flex-wrap items-center justify-center gap-4',\n    className,\n  ]\"\n>\n  <div class=\"flex items-center gap-3\" *ngIf=\"rowsPerPageOptions.length > 0\">\n    <span class=\"text-sm font-medium text-foreground\">{{\n      rowsPerPageLabel\n    }}</span>\n    <pdm-select\n      [value]=\"rowsPerPageValue\"\n      [options]=\"rowsPerPageSelectOptions\"\n      [placeholder]=\"rowsPerPageValue\"\n      className=\"w-[100px] sm:w-[120px]\"\n      (valueChange)=\"onRowsPerPageChangeValue($event)\"\n    ></pdm-select>\n  </div>\n\n  <ul class=\"m-0 flex list-none items-center gap-1 p-0\">\n    <li>\n      <button\n        type=\"button\"\n        class=\"inline-flex h-9 appearance-none box-border items-center justify-center gap-1 rounded-md border-0 bg-transparent px-2 text-sm text-foreground hover:bg-accent disabled:opacity-50 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2\"\n        [disabled]=\"page <= 1\"\n        (click)=\"setPage(page - 1)\"\n      >\n        <pdm-icon name=\"chevron-left\" [size]=\"14\"></pdm-icon>\n        Previous\n      </button>\n    </li>\n    <li *ngFor=\"let pageNumber of visiblePages\">\n      <ng-container *ngIf=\"pageNumber === 'ellipsis'; else pageButton\">\n        <span\n          class=\"inline-flex h-9 min-w-9 items-center justify-center px-2 text-sm text-muted-foreground\"\n          >...</span\n        >\n      </ng-container>\n      <ng-template #pageButton>\n        <button\n          type=\"button\"\n          [ngClass]=\"[\n            'inline-flex h-9 min-w-9 items-center justify-center rounded-md px-2 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n            pageNumber === page\n              ? 'appearance-none box-border border border-solid border-border bg-muted text-foreground shadow-sm'\n              : 'appearance-none box-border border-0 bg-transparent text-foreground hover:bg-accent hover:text-accent-foreground',\n          ]\"\n          (click)=\"setPage(+pageNumber)\"\n        >\n          {{ pageNumber }}\n        </button>\n      </ng-template>\n    </li>\n    <li>\n      <button\n        type=\"button\"\n        class=\"inline-flex h-9 appearance-none box-border items-center justify-center gap-1 rounded-md border-0 bg-transparent px-2 text-sm text-foreground hover:bg-accent disabled:opacity-50 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2\"\n        [disabled]=\"page >= pageCount\"\n        (click)=\"setPage(page + 1)\"\n      >\n        Next\n        <pdm-icon name=\"chevron-right\" [size]=\"14\"></pdm-icon>\n      </button>\n    </li>\n  </ul>\n</nav>\n"]}

package/esm2020/src/pagination/pagination.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { PdmIconModule } from "pdm-ui-kit/src/icon";
+import { PdmSelectModule } from "pdm-ui-kit/src/select";
+import { PdmPaginationComponent } from "./pagination.component";
+import * as i0 from "@angular/core";
+const COMPONENTS = [PdmPaginationComponent];
+export class PdmPaginationModule {
+}
+PdmPaginationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPaginationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PdmPaginationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: PdmPaginationModule, declarations: [PdmPaginationComponent], imports: [CommonModule, PdmIconModule, PdmSelectModule], exports: [PdmPaginationComponent] });
+PdmPaginationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPaginationModule, imports: [CommonModule, PdmIconModule, PdmSelectModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPaginationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, PdmIconModule, PdmSelectModule],
+                    declarations: COMPONENTS,
+                    exports: COMPONENTS,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcGFnaW5hdGlvbi9wYWdpbmF0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQUVoRSxNQUFNLFVBQVUsR0FBRyxDQUFDLHNCQUFzQixDQUFDLENBQUM7QUFPNUMsTUFBTSxPQUFPLG1CQUFtQjs7Z0hBQW5CLG1CQUFtQjtpSEFBbkIsbUJBQW1CLGlCQVBaLHNCQUFzQixhQUcvQixZQUFZLEVBQUUsYUFBYSxFQUFFLGVBQWUsYUFIbkMsc0JBQXNCO2lIQU83QixtQkFBbUIsWUFKckIsWUFBWSxFQUFFLGFBQWEsRUFBRSxlQUFlOzJGQUkxQyxtQkFBbUI7a0JBTC9CLFFBQVE7bUJBQUM7b0JBQ1QsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGFBQWEsRUFBRSxlQUFlLENBQUM7b0JBQ3ZELFlBQVksRUFBRSxVQUFVO29CQUN4QixPQUFPLEVBQUUsVUFBVTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uXCI7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBQZG1JY29uTW9kdWxlIH0gZnJvbSBcInBkbS11aS1raXQvc3JjL2ljb25cIjtcbmltcG9ydCB7IFBkbVNlbGVjdE1vZHVsZSB9IGZyb20gXCJwZG0tdWkta2l0L3NyYy9zZWxlY3RcIjtcbmltcG9ydCB7IFBkbVBhZ2luYXRpb25Db21wb25lbnQgfSBmcm9tIFwiLi9wYWdpbmF0aW9uLmNvbXBvbmVudFwiO1xuXG5jb25zdCBDT01QT05FTlRTID0gW1BkbVBhZ2luYXRpb25Db21wb25lbnRdO1xuXG5ATmdNb2R1bGUoe1xuXHRpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBQZG1JY29uTW9kdWxlLCBQZG1TZWxlY3RNb2R1bGVdLFxuXHRkZWNsYXJhdGlvbnM6IENPTVBPTkVOVFMsXG5cdGV4cG9ydHM6IENPTVBPTkVOVFMsXG59KVxuZXhwb3J0IGNsYXNzIFBkbVBhZ2luYXRpb25Nb2R1bGUge31cbiJdfQ==

package/esm2020/src/pagination/pdm-ui-kit-src-pagination.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGRtLXVpLWtpdC1zcmMtcGFnaW5hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wYWdpbmF0aW9uL3BkbS11aS1raXQtc3JjLXBhZ2luYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/src/pagination/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './pagination.component';
+export * from './pagination.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wYWdpbmF0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wYWdpbmF0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BhZ2luYXRpb24ubW9kdWxlJztcbiJdfQ==

package/esm2020/src/popover/pdm-ui-kit-src-popover.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGRtLXVpLWtpdC1zcmMtcG9wb3Zlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wb3BvdmVyL3BkbS11aS1raXQtc3JjLXBvcG92ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/src/popover/popover.component.mjs

@@ -0,0 +1,162 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostListener, Input, Output, ViewChild, } from "@angular/core";
+import { TemplatePortal } from "@angular/cdk/portal";
+import { mergeOverlayPanelClass, OVERLAY_BASE_Z_INDEX, } from "pdm-ui-kit/src/overlay";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+export class PdmPopoverComponent {
+    constructor(overlay, viewContainerRef, elementRef, cdr) {
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this._open = false;
+        this.triggerText = "Open";
+        this.className = "";
+        this.panelClassName = "";
+        this.showTrigger = true;
+        this.openChange = new EventEmitter();
+        this.overlayRef = null;
+        this.outsideClickSub = null;
+    }
+    ngOnInit() { }
+    ngOnDestroy() {
+        this.destroyOverlay();
+    }
+    set open(value) {
+        if (this._open === !!value)
+            return;
+        if (value) {
+            this.openPanel();
+        }
+        else {
+            this.closePanel();
+        }
+    }
+    get open() {
+        return this._open;
+    }
+    toggle() {
+        this.open = !this.open;
+    }
+    onEsc() {
+        if (this.open) {
+            this.open = false;
+            this.openChange.emit(false);
+        }
+    }
+    openPanel() {
+        if (this.overlayRef)
+            return;
+        const triggerEl = this.triggerRef?.nativeElement;
+        if (!triggerEl)
+            return;
+        this._open = true;
+        this.openChange.emit(true);
+        this.cdr.markForCheck();
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(triggerEl)
+            .withPositions(this.getPositionConfigs())
+            .withFlexibleDimensions(false)
+            .withPush(true);
+        const panelClass = mergeOverlayPanelClass(OVERLAY_BASE_Z_INDEX, this.panelClassName);
+        this.overlayRef = this.overlay.create({
+            positionStrategy,
+            panelClass,
+        });
+        const portal = new TemplatePortal(this.panelTemplateRef, this.viewContainerRef);
+        this.overlayRef.attach(portal);
+        // Close on click outside
+        this.outsideClickSub = this.overlayRef
+            .outsidePointerEvents()
+            .subscribe(() => {
+            this.open = false;
+            this.openChange.emit(false);
+        });
+        this.cdr.markForCheck();
+    }
+    closePanel() {
+        if (!this.overlayRef)
+            return;
+        this._open = false;
+        this.openChange.emit(false);
+        this.cdr.markForCheck();
+        this.destroyOverlay();
+    }
+    destroyOverlay() {
+        if (this.outsideClickSub) {
+            this.outsideClickSub.unsubscribe();
+            this.outsideClickSub = null;
+        }
+        if (this.overlayRef) {
+            this.overlayRef.detach();
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    getPositionConfigs() {
+        return [
+            // Bottom (default)
+            {
+                originX: "start",
+                originY: "bottom",
+                overlayX: "start",
+                overlayY: "top",
+                offsetY: 8,
+            },
+            // Top (fallback)
+            {
+                originX: "start",
+                originY: "top",
+                overlayX: "start",
+                overlayY: "bottom",
+                offsetY: -8,
+            },
+            // Right
+            {
+                originX: "end",
+                originY: "bottom",
+                overlayX: "start",
+                overlayY: "top",
+                offsetY: 8,
+            },
+            // Left
+            {
+                originX: "start",
+                originY: "bottom",
+                overlayX: "end",
+                overlayY: "top",
+                offsetY: 8,
+            },
+        ];
+    }
+}
+PdmPopoverComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPopoverComponent, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PdmPopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: PdmPopoverComponent, selector: "pdm-popover", inputs: { triggerText: "triggerText", className: "className", panelClassName: "panelClassName", showTrigger: "showTrigger", open: "open" }, outputs: { openChange: "openChange" }, host: { listeners: { "document:keydown.escape": "onEsc()" } }, viewQueries: [{ propertyName: "triggerRef", first: true, predicate: ["triggerEl"], descendants: true }, { propertyName: "panelTemplateRef", first: true, predicate: ["panelTemplate"], descendants: true }], ngImport: i0, template: "<div class=\"relative inline-block\" [ngClass]=\"className\">\n  <button\n    #triggerEl\n    *ngIf=\"showTrigger\"\n    type=\"button\"\n    class=\"inline-flex h-9 appearance-none box-border items-center justify-center rounded-md border border-solid border-input bg-background px-3 text-sm font-medium text-foreground shadow-sm\"\n    [attr.aria-expanded]=\"open\"\n    [attr.aria-haspopup]=\"'dialog'\"\n    (click)=\"toggle()\"\n  >\n    {{ triggerText }}\n  </button>\n\n  <!-- Trigger slot for custom trigger -->\n  <ng-content select=\"[pdmPopoverTrigger]\"></ng-content>\n\n  <!-- Template for CDK Overlay -->\n  <ng-template #panelTemplate>\n    <div\n      class=\"min-w-80 rounded-md border border-solid border-border bg-popover p-4 text-popover-foreground shadow-md\"\n    >\n      <ng-content></ng-content>\n    </div>\n  </ng-template>\n</div>\n", styles: [":host{display:inline-block}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPopoverComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "pdm-popover", changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"relative inline-block\" [ngClass]=\"className\">\n  <button\n    #triggerEl\n    *ngIf=\"showTrigger\"\n    type=\"button\"\n    class=\"inline-flex h-9 appearance-none box-border items-center justify-center rounded-md border border-solid border-input bg-background px-3 text-sm font-medium text-foreground shadow-sm\"\n    [attr.aria-expanded]=\"open\"\n    [attr.aria-haspopup]=\"'dialog'\"\n    (click)=\"toggle()\"\n  >\n    {{ triggerText }}\n  </button>\n\n  <!-- Trigger slot for custom trigger -->\n  <ng-content select=\"[pdmPopoverTrigger]\"></ng-content>\n\n  <!-- Template for CDK Overlay -->\n  <ng-template #panelTemplate>\n    <div\n      class=\"min-w-80 rounded-md border border-solid border-border bg-popover p-4 text-popover-foreground shadow-md\"\n    >\n      <ng-content></ng-content>\n    </div>\n  </ng-template>\n</div>\n", styles: [":host{display:inline-block}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { triggerText: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], panelClassName: [{
+                type: Input
+            }], showTrigger: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }], triggerRef: [{
+                type: ViewChild,
+                args: ["triggerEl"]
+            }], panelTemplateRef: [{
+                type: ViewChild,
+                args: ["panelTemplate"]
+            }], open: [{
+                type: Input
+            }], onEsc: [{
+                type: HostListener,
+                args: ["document:keydown.escape"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.component.js","sourceRoot":"","sources":["../../../../../src/popover/popover.component.ts","../../../../../src/popover/popover.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tChangeDetectorRef,\n\tComponent,\n\tElementRef,\n\tEventEmitter,\n\tHostListener,\n\tInput,\n\tOnDestroy,\n\tOnInit,\n\tOutput,\n\tViewChild,\n\tViewContainerRef,\n} from \"@angular/core\";\nimport { Overlay, OverlayRef, ConnectedPosition } from \"@angular/cdk/overlay\";\nimport { TemplatePortal } from \"@angular/cdk/portal\";\nimport {\n\tmergeOverlayPanelClass,\n\tOVERLAY_BASE_Z_INDEX,\n} from \"pdm-ui-kit/src/overlay\";\n\n@Component({\n\tselector: \"pdm-popover\",\n\ttemplateUrl: \"./popover.component.html\",\n\tstyles: [\":host { display: inline-block; }\"],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PdmPopoverComponent implements OnInit, OnDestroy {\n\tprivate _open = false;\n\n\t@Input() triggerText = \"Open\";\n\t@Input() className = \"\";\n\t@Input() panelClassName = \"\";\n\t@Input() showTrigger = true;\n\n\t@Output() openChange = new EventEmitter<boolean>();\n\n\t@ViewChild(\"triggerEl\") private triggerRef?: ElementRef<HTMLElement>;\n\t@ViewChild(\"panelTemplate\") private panelTemplateRef: any;\n\n\tprivate overlayRef: OverlayRef | null = null;\n\tprivate outsideClickSub: any = null;\n\n\tconstructor(\n\t\tprivate readonly overlay: Overlay,\n\t\tprivate readonly viewContainerRef: ViewContainerRef,\n\t\tprivate readonly elementRef: ElementRef<HTMLElement>,\n\t\tprivate readonly cdr: ChangeDetectorRef,\n\t) {}\n\n\tngOnInit(): void {}\n\tngOnDestroy(): void {\n\t\tthis.destroyOverlay();\n\t}\n\n\t@Input()\n\tset open(value: boolean) {\n\t\tif (this._open === !!value) return;\n\n\t\tif (value) {\n\t\t\tthis.openPanel();\n\t\t} else {\n\t\t\tthis.closePanel();\n\t\t}\n\t}\n\tget open(): boolean {\n\t\treturn this._open;\n\t}\n\n\ttoggle(): void {\n\t\tthis.open = !this.open;\n\t}\n\n\t@HostListener(\"document:keydown.escape\")\n\tonEsc(): void {\n\t\tif (this.open) {\n\t\t\tthis.open = false;\n\t\t\tthis.openChange.emit(false);\n\t\t}\n\t}\n\n\tprivate openPanel(): void {\n\t\tif (this.overlayRef) return;\n\n\t\tconst triggerEl = this.triggerRef?.nativeElement;\n\t\tif (!triggerEl) return;\n\n\t\tthis._open = true;\n\t\tthis.openChange.emit(true);\n\t\tthis.cdr.markForCheck();\n\n\t\tconst positionStrategy = this.overlay\n\t\t\t.position()\n\t\t\t.flexibleConnectedTo(triggerEl)\n\t\t\t.withPositions(this.getPositionConfigs())\n\t\t\t.withFlexibleDimensions(false)\n\t\t\t.withPush(true);\n\n\t\tconst panelClass = mergeOverlayPanelClass(\n\t\t\tOVERLAY_BASE_Z_INDEX,\n\t\t\tthis.panelClassName,\n\t\t);\n\n\t\tthis.overlayRef = this.overlay.create({\n\t\t\tpositionStrategy,\n\t\t\tpanelClass,\n\t\t});\n\n\t\tconst portal = new TemplatePortal(\n\t\t\tthis.panelTemplateRef,\n\t\t\tthis.viewContainerRef,\n\t\t);\n\t\tthis.overlayRef.attach(portal);\n\n\t\t// Close on click outside\n\t\tthis.outsideClickSub = this.overlayRef\n\t\t\t.outsidePointerEvents()\n\t\t\t.subscribe(() => {\n\t\t\t\tthis.open = false;\n\t\t\t\tthis.openChange.emit(false);\n\t\t\t});\n\n\t\tthis.cdr.markForCheck();\n\t}\n\n\tprivate closePanel(): void {\n\t\tif (!this.overlayRef) return;\n\n\t\tthis._open = false;\n\t\tthis.openChange.emit(false);\n\t\tthis.cdr.markForCheck();\n\t\tthis.destroyOverlay();\n\t}\n\n\tprivate destroyOverlay(): void {\n\t\tif (this.outsideClickSub) {\n\t\t\tthis.outsideClickSub.unsubscribe();\n\t\t\tthis.outsideClickSub = null;\n\t\t}\n\t\tif (this.overlayRef) {\n\t\t\tthis.overlayRef.detach();\n\t\t\tthis.overlayRef.dispose();\n\t\t\tthis.overlayRef = null;\n\t\t}\n\t}\n\n\tprivate getPositionConfigs(): ConnectedPosition[] {\n\t\treturn [\n\t\t\t// Bottom (default)\n\t\t\t{\n\t\t\t\toriginX: \"start\",\n\t\t\t\toriginY: \"bottom\",\n\t\t\t\toverlayX: \"start\",\n\t\t\t\toverlayY: \"top\",\n\t\t\t\toffsetY: 8,\n\t\t\t},\n\t\t\t// Top (fallback)\n\t\t\t{\n\t\t\t\toriginX: \"start\",\n\t\t\t\toriginY: \"top\",\n\t\t\t\toverlayX: \"start\",\n\t\t\t\toverlayY: \"bottom\",\n\t\t\t\toffsetY: -8,\n\t\t\t},\n\t\t\t// Right\n\t\t\t{\n\t\t\t\toriginX: \"end\",\n\t\t\t\toriginY: \"bottom\",\n\t\t\t\toverlayX: \"start\",\n\t\t\t\toverlayY: \"top\",\n\t\t\t\toffsetY: 8,\n\t\t\t},\n\t\t\t// Left\n\t\t\t{\n\t\t\t\toriginX: \"start\",\n\t\t\t\toriginY: \"bottom\",\n\t\t\t\toverlayX: \"end\",\n\t\t\t\toverlayY: \"top\",\n\t\t\t\toffsetY: 8,\n\t\t\t},\n\t\t];\n\t}\n}\n","<div class=\"relative inline-block\" [ngClass]=\"className\">\n  <button\n    #triggerEl\n    *ngIf=\"showTrigger\"\n    type=\"button\"\n    class=\"inline-flex h-9 appearance-none box-border items-center justify-center rounded-md border border-solid border-input bg-background px-3 text-sm font-medium text-foreground shadow-sm\"\n    [attr.aria-expanded]=\"open\"\n    [attr.aria-haspopup]=\"'dialog'\"\n    (click)=\"toggle()\"\n  >\n    {{ triggerText }}\n  </button>\n\n  <!-- Trigger slot for custom trigger -->\n  <ng-content select=\"[pdmPopoverTrigger]\"></ng-content>\n\n  <!-- Template for CDK Overlay -->\n  <ng-template #panelTemplate>\n    <div\n      class=\"min-w-80 rounded-md border border-solid border-border bg-popover p-4 text-popover-foreground shadow-md\"\n    >\n      <ng-content></ng-content>\n    </div>\n  </ng-template>\n</div>\n"]}

package/esm2020/src/popover/popover.module.mjs

@@ -0,0 +1,22 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PdmPopoverComponent } from './popover.component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    PdmPopoverComponent,
+];
+export class PdmPopoverModule {
+}
+PdmPopoverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PdmPopoverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: PdmPopoverModule, declarations: [PdmPopoverComponent], imports: [CommonModule, OverlayModule], exports: [PdmPopoverComponent] });
+PdmPopoverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPopoverModule, imports: [CommonModule, OverlayModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmPopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OverlayModule],
+                    declarations: COMPONENTS,
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcG9wb3Zlci9wb3BvdmVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDckQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUJBQXFCLENBQUM7O0FBRTFELE1BQU0sVUFBVSxHQUFHO0lBQ2pCLG1CQUFtQjtDQUNwQixDQUFDO0FBT0YsTUFBTSxPQUFPLGdCQUFnQjs7NkdBQWhCLGdCQUFnQjs4R0FBaEIsZ0JBQWdCLGlCQVIzQixtQkFBbUIsYUFJVCxZQUFZLEVBQUUsYUFBYSxhQUpyQyxtQkFBbUI7OEdBUVIsZ0JBQWdCLFlBSmpCLFlBQVksRUFBRSxhQUFhOzJGQUkxQixnQkFBZ0I7a0JBTDVCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztvQkFDdEMsWUFBWSxFQUFFLFVBQVU7b0JBQ3hCLE9BQU8sRUFBRSxVQUFVO2lCQUNwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT3ZlcmxheU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9vdmVybGF5JztcbmltcG9ydCB7IFBkbVBvcG92ZXJDb21wb25lbnQgfSBmcm9tICcuL3BvcG92ZXIuY29tcG9uZW50JztcblxuY29uc3QgQ09NUE9ORU5UUyA9IFtcbiAgUGRtUG9wb3ZlckNvbXBvbmVudCxcbl07XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIE92ZXJsYXlNb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IENPTVBPTkVOVFMsXG4gIGV4cG9ydHM6IENPTVBPTkVOVFNcbn0pXG5leHBvcnQgY2xhc3MgUGRtUG9wb3Zlck1vZHVsZSB7fVxuIl19

package/esm2020/src/popover/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './popover.component';
+export * from './popover.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wb3BvdmVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wb3BvdmVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BvcG92ZXIubW9kdWxlJztcbiJdfQ==

package/esm2020/src/progress/pdm-ui-kit-src-progress.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGRtLXVpLWtpdC1zcmMtcHJvZ3Jlc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvZ3Jlc3MvcGRtLXVpLWtpdC1zcmMtcHJvZ3Jlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/src/progress/progress.component.mjs

@@ -0,0 +1,33 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PdmProgressComponent {
+    constructor() {
+        this.value = 0;
+        this.max = 100;
+        this.indeterminate = false;
+        this.className = '';
+    }
+    get width() {
+        if (this.indeterminate)
+            return '100%';
+        const safeMax = this.max > 0 ? this.max : 100;
+        const pct = Math.min(100, Math.max(0, (this.value / safeMax) * 100));
+        return pct + '%';
+    }
+}
+PdmProgressComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmProgressComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+PdmProgressComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: PdmProgressComponent, selector: "pdm-progress", inputs: { value: "value", max: "max", indeterminate: "indeterminate", className: "className" }, ngImport: i0, template: "<div\n  role=\"progressbar\"\n  [attr.aria-valuemin]=\"0\"\n  [attr.aria-valuemax]=\"max\"\n  [attr.aria-valuenow]=\"indeterminate ? null : value\"\n  [ngClass]=\"['relative h-1.5 w-full overflow-hidden rounded-full bg-muted', className]\"\n>\n  <div [ngClass]=\"['h-full bg-foreground transition-all', indeterminate ? 'animate-pulse' : '']\" [style.width]=\"width\"></div>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmProgressComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pdm-progress', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  role=\"progressbar\"\n  [attr.aria-valuemin]=\"0\"\n  [attr.aria-valuemax]=\"max\"\n  [attr.aria-valuenow]=\"indeterminate ? null : value\"\n  [ngClass]=\"['relative h-1.5 w-full overflow-hidden rounded-full bg-muted', className]\"\n>\n  <div [ngClass]=\"['h-full bg-foreground transition-all', indeterminate ? 'animate-pulse' : '']\" [style.width]=\"width\"></div>\n</div>\n" }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], indeterminate: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/progress/progress.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { PdmProgressComponent } from './progress.component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    PdmProgressComponent,
+];
+export class PdmProgressModule {
+}
+PdmProgressModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmProgressModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PdmProgressModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: PdmProgressModule, declarations: [PdmProgressComponent], imports: [CommonModule], exports: [PdmProgressComponent] });
+PdmProgressModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmProgressModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmProgressModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: COMPONENTS,
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3MubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3Byb2dyZXNzL3Byb2dyZXNzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQzs7QUFFNUQsTUFBTSxVQUFVLEdBQUc7SUFDakIsb0JBQW9CO0NBQ3JCLENBQUM7QUFPRixNQUFNLE9BQU8saUJBQWlCOzs4R0FBakIsaUJBQWlCOytHQUFqQixpQkFBaUIsaUJBUjVCLG9CQUFvQixhQUlWLFlBQVksYUFKdEIsb0JBQW9COytHQVFULGlCQUFpQixZQUpsQixZQUFZOzJGQUlYLGlCQUFpQjtrQkFMN0IsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxVQUFVO29CQUN4QixPQUFPLEVBQUUsVUFBVTtpQkFDcEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFBkbVByb2dyZXNzQ29tcG9uZW50IH0gZnJvbSAnLi9wcm9ncmVzcy5jb21wb25lbnQnO1xuXG5jb25zdCBDT01QT05FTlRTID0gW1xuICBQZG1Qcm9ncmVzc0NvbXBvbmVudCxcbl07XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IENPTVBPTkVOVFMsXG4gIGV4cG9ydHM6IENPTVBPTkVOVFNcbn0pXG5leHBvcnQgY2xhc3MgUGRtUHJvZ3Jlc3NNb2R1bGUge31cbiJdfQ==

package/esm2020/src/progress/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './progress.component';
+export * from './progress.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wcm9ncmVzcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHJvZ3Jlc3MuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZ3Jlc3MubW9kdWxlJztcbiJdfQ==