pdm-ui-kit 0.4.2 → 1.1.0

package/esm2020/{lib/components/toggle-group → src/toggle}/toggle-group.component.mjs

@@ -28,4 +28,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
             }], valueChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -38,4 +38,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
             }], pressedChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/toggle/toggle.module.mjs

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

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

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

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

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

package/esm2020/src/tooltip/tooltip.component.mjs

@@ -0,0 +1,176 @@
+import { ChangeDetectionStrategy, Component, HostListener, Input, 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 PdmTooltipComponent {
+    constructor(overlay, viewContainerRef, elementRef, cdr) {
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this.text = "";
+        this.side = "top";
+        this.className = "";
+        this.open = false;
+        this.overlayRef = null;
+    }
+    ngOnDestroy() {
+        this.destroyOverlay();
+    }
+    onMouseEnter() {
+        this.show();
+    }
+    onMouseLeave() {
+        this.hide();
+    }
+    onFocusIn() {
+        this.show();
+    }
+    onFocusOut() {
+        this.hide();
+    }
+    show() {
+        if (this.open || !this.text)
+            return;
+        this.open = true;
+        this.cdr.markForCheck();
+        this.createOverlay();
+    }
+    hide() {
+        if (!this.open)
+            return;
+        this.open = false;
+        this.cdr.markForCheck();
+        this.destroyOverlay();
+    }
+    createOverlay() {
+        if (this.overlayRef)
+            return;
+        const triggerEl = this.elementRef.nativeElement.querySelector(":scope > *") ||
+            this.elementRef.nativeElement;
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(triggerEl)
+            .withPositions(this.getPositionConfigs())
+            .withFlexibleDimensions(false)
+            .withPush(true);
+        const panelClass = mergeOverlayPanelClass(OVERLAY_BASE_Z_INDEX);
+        this.overlayRef = this.overlay.create({
+            positionStrategy,
+            panelClass,
+        });
+        const portal = new TemplatePortal(this.tooltipTemplate, this.viewContainerRef);
+        this.overlayRef.attach(portal);
+    }
+    destroyOverlay() {
+        if (this.overlayRef) {
+            this.overlayRef.detach();
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    getPositionConfigs() {
+        const offset = 4;
+        switch (this.side) {
+            case "bottom":
+                return [
+                    {
+                        originX: "center",
+                        originY: "bottom",
+                        overlayX: "center",
+                        overlayY: "top",
+                        offsetY: offset,
+                    },
+                    {
+                        originX: "center",
+                        originY: "top",
+                        overlayX: "center",
+                        overlayY: "bottom",
+                        offsetY: -offset,
+                    },
+                ];
+            case "left":
+                return [
+                    {
+                        originX: "start",
+                        originY: "center",
+                        overlayX: "end",
+                        overlayY: "center",
+                        offsetX: -offset,
+                    },
+                    {
+                        originX: "end",
+                        originY: "center",
+                        overlayX: "start",
+                        overlayY: "center",
+                        offsetX: offset,
+                    },
+                ];
+            case "right":
+                return [
+                    {
+                        originX: "end",
+                        originY: "center",
+                        overlayX: "start",
+                        overlayY: "center",
+                        offsetX: offset,
+                    },
+                    {
+                        originX: "start",
+                        originY: "center",
+                        overlayX: "end",
+                        overlayY: "center",
+                        offsetX: -offset,
+                    },
+                ];
+            case "top":
+            default:
+                return [
+                    {
+                        originX: "center",
+                        originY: "top",
+                        overlayX: "center",
+                        overlayY: "bottom",
+                        offsetY: -offset,
+                    },
+                    {
+                        originX: "center",
+                        originY: "bottom",
+                        overlayX: "center",
+                        overlayY: "top",
+                        offsetY: offset,
+                    },
+                ];
+        }
+    }
+}
+PdmTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmTooltipComponent, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PdmTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: PdmTooltipComponent, selector: "pdm-tooltip", inputs: { text: "text", side: "side", className: "className" }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "focusin": "onFocusIn()", "focusout": "onFocusOut()" } }, viewQueries: [{ propertyName: "tooltipTemplate", first: true, predicate: ["tooltipTemplate"], descendants: true }], ngImport: i0, template: "<span\n  class=\"relative inline-flex\"\n  [ngClass]=\"className\"\n  (mouseenter)=\"onMouseEnter()\"\n  (mouseleave)=\"onMouseLeave()\"\n  (focusin)=\"onFocusIn()\"\n  (focusout)=\"onFocusOut()\"\n>\n  <ng-content></ng-content>\n\n  <!-- Template for CDK Overlay -->\n  <ng-template #tooltipTemplate>\n    <span\n      class=\"pointer-events-none overflow-hidden rounded-md bg-foreground px-3 py-1.5 text-xs text-background animate-in fade-in-0 zoom-in-95\"\n    >\n      {{ text }}\n    </span>\n  </ng-template>\n</span>\n", styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "pdm-tooltip", changeDetection: ChangeDetectionStrategy.OnPush, template: "<span\n  class=\"relative inline-flex\"\n  [ngClass]=\"className\"\n  (mouseenter)=\"onMouseEnter()\"\n  (mouseleave)=\"onMouseLeave()\"\n  (focusin)=\"onFocusIn()\"\n  (focusout)=\"onFocusOut()\"\n>\n  <ng-content></ng-content>\n\n  <!-- Template for CDK Overlay -->\n  <ng-template #tooltipTemplate>\n    <span\n      class=\"pointer-events-none overflow-hidden rounded-md bg-foreground px-3 py-1.5 text-xs text-background animate-in fade-in-0 zoom-in-95\"\n    >\n      {{ text }}\n    </span>\n  </ng-template>\n</span>\n", styles: [":host{display:inline-flex}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { text: [{
+                type: Input
+            }], side: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], tooltipTemplate: [{
+                type: ViewChild,
+                args: ["tooltipTemplate"]
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ["mouseenter"]
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ["mouseleave"]
+            }], onFocusIn: [{
+                type: HostListener,
+                args: ["focusin"]
+            }], onFocusOut: [{
+                type: HostListener,
+                args: ["focusout"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.component.js","sourceRoot":"","sources":["../../../../../src/tooltip/tooltip.component.ts","../../../../../src/tooltip/tooltip.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tChangeDetectorRef,\n\tComponent,\n\tElementRef,\n\tHostListener,\n\tInput,\n\tOnDestroy,\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-tooltip\",\n\ttemplateUrl: \"./tooltip.component.html\",\n\tstyles: [\":host { display: inline-flex; }\"],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PdmTooltipComponent implements OnDestroy {\n\t@Input() text = \"\";\n\t@Input() side: \"top\" | \"right\" | \"bottom\" | \"left\" = \"top\";\n\t@Input() className = \"\";\n\n\t@ViewChild(\"tooltipTemplate\") tooltipTemplate: any;\n\n\topen = false;\n\tprivate overlayRef: OverlayRef | null = 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\tngOnDestroy(): void {\n\t\tthis.destroyOverlay();\n\t}\n\n\t@HostListener(\"mouseenter\")\n\tonMouseEnter(): void {\n\t\tthis.show();\n\t}\n\n\t@HostListener(\"mouseleave\")\n\tonMouseLeave(): void {\n\t\tthis.hide();\n\t}\n\n\t@HostListener(\"focusin\")\n\tonFocusIn(): void {\n\t\tthis.show();\n\t}\n\n\t@HostListener(\"focusout\")\n\tonFocusOut(): void {\n\t\tthis.hide();\n\t}\n\n\tprivate show(): void {\n\t\tif (this.open || !this.text) return;\n\n\t\tthis.open = true;\n\t\tthis.cdr.markForCheck();\n\t\tthis.createOverlay();\n\t}\n\n\tprivate hide(): void {\n\t\tif (!this.open) return;\n\n\t\tthis.open = false;\n\t\tthis.cdr.markForCheck();\n\t\tthis.destroyOverlay();\n\t}\n\n\tprivate createOverlay(): void {\n\t\tif (this.overlayRef) return;\n\n\t\tconst triggerEl =\n\t\t\tthis.elementRef.nativeElement.querySelector(\":scope > *\") ||\n\t\t\tthis.elementRef.nativeElement;\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(OVERLAY_BASE_Z_INDEX);\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.tooltipTemplate,\n\t\t\tthis.viewContainerRef,\n\t\t);\n\t\tthis.overlayRef.attach(portal);\n\t}\n\n\tprivate destroyOverlay(): void {\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\tconst offset = 4;\n\n\t\tswitch (this.side) {\n\t\t\tcase \"bottom\":\n\t\t\t\treturn [\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"center\",\n\t\t\t\t\t\toriginY: \"bottom\",\n\t\t\t\t\t\toverlayX: \"center\",\n\t\t\t\t\t\toverlayY: \"top\",\n\t\t\t\t\t\toffsetY: offset,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"center\",\n\t\t\t\t\t\toriginY: \"top\",\n\t\t\t\t\t\toverlayX: \"center\",\n\t\t\t\t\t\toverlayY: \"bottom\",\n\t\t\t\t\t\toffsetY: -offset,\n\t\t\t\t\t},\n\t\t\t\t];\n\t\t\tcase \"left\":\n\t\t\t\treturn [\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"start\",\n\t\t\t\t\t\toriginY: \"center\",\n\t\t\t\t\t\toverlayX: \"end\",\n\t\t\t\t\t\toverlayY: \"center\",\n\t\t\t\t\t\toffsetX: -offset,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"end\",\n\t\t\t\t\t\toriginY: \"center\",\n\t\t\t\t\t\toverlayX: \"start\",\n\t\t\t\t\t\toverlayY: \"center\",\n\t\t\t\t\t\toffsetX: offset,\n\t\t\t\t\t},\n\t\t\t\t];\n\t\t\tcase \"right\":\n\t\t\t\treturn [\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"end\",\n\t\t\t\t\t\toriginY: \"center\",\n\t\t\t\t\t\toverlayX: \"start\",\n\t\t\t\t\t\toverlayY: \"center\",\n\t\t\t\t\t\toffsetX: offset,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"start\",\n\t\t\t\t\t\toriginY: \"center\",\n\t\t\t\t\t\toverlayX: \"end\",\n\t\t\t\t\t\toverlayY: \"center\",\n\t\t\t\t\t\toffsetX: -offset,\n\t\t\t\t\t},\n\t\t\t\t];\n\t\t\tcase \"top\":\n\t\t\tdefault:\n\t\t\t\treturn [\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"center\",\n\t\t\t\t\t\toriginY: \"top\",\n\t\t\t\t\t\toverlayX: \"center\",\n\t\t\t\t\t\toverlayY: \"bottom\",\n\t\t\t\t\t\toffsetY: -offset,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\toriginX: \"center\",\n\t\t\t\t\t\toriginY: \"bottom\",\n\t\t\t\t\t\toverlayX: \"center\",\n\t\t\t\t\t\toverlayY: \"top\",\n\t\t\t\t\t\toffsetY: offset,\n\t\t\t\t\t},\n\t\t\t\t];\n\t\t}\n\t}\n}\n","<span\n  class=\"relative inline-flex\"\n  [ngClass]=\"className\"\n  (mouseenter)=\"onMouseEnter()\"\n  (mouseleave)=\"onMouseLeave()\"\n  (focusin)=\"onFocusIn()\"\n  (focusout)=\"onFocusOut()\"\n>\n  <ng-content></ng-content>\n\n  <!-- Template for CDK Overlay -->\n  <ng-template #tooltipTemplate>\n    <span\n      class=\"pointer-events-none overflow-hidden rounded-md bg-foreground px-3 py-1.5 text-xs text-background animate-in fade-in-0 zoom-in-95\"\n    >\n      {{ text }}\n    </span>\n  </ng-template>\n</span>\n"]}

package/esm2020/src/tooltip/tooltip.module.mjs

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

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

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

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

@@ -0,0 +1,3 @@
+export * from "./responsive";
+export * from "./z-index";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy91dGlscy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcmVzcG9uc2l2ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vei1pbmRleFwiO1xuIl19

package/esm2020/src/utils/responsive.mjs

@@ -0,0 +1,143 @@
+/**
+ * Sistema de responsive utilities para PDM UI Kit
+ *
+ * Proporciona constantes, tipos y helpers para manejar responsive design
+ * de forma consistente en todos los componentes.
+ */
+/**
+ * Breakpoints estándar de Tailwind CSS
+ * Mobile-first approach: los estilos base son para mobile, los breakpoints son MIN-WIDTH
+ */
+export const BREAKPOINTS = {
+    sm: '640px',
+    md: '768px',
+    lg: '1024px',
+    xl: '1280px',
+    '2xl': '1536px' // extra large desktop
+};
+/**
+ * Helper para generar clases responsive de forma programática
+ *
+ * @example
+ * responsive({ default: 'block', sm: 'flex', lg: 'grid' })
+ * // Returns: 'block sm:flex lg:grid'
+ */
+export function responsive(config) {
+    const classes = [];
+    if (config.default) {
+        classes.push(config.default);
+    }
+    ['sm', 'md', 'lg', 'xl', '2xl'].forEach(bp => {
+        if (config[bp]) {
+            classes.push(`${bp}:${config[bp]}`);
+        }
+    });
+    return classes.join(' ');
+}
+/**
+ * Helper para overflow responsive
+ * Maneja el caso común de scroll en mobile, auto en desktop
+ *
+ * @example
+ * overflowResponsive('x', 'scroll', 'auto')
+ * // Returns: 'overflow-x-scroll sm:overflow-x-auto'
+ */
+export function overflowResponsive(axis, mobile, desktop) {
+    const axisClass = axis === 'both' ? 'overflow' : `overflow-${axis}`;
+    const mobileClass = `${axisClass}-${mobile}`;
+    if (!desktop || desktop === mobile) {
+        return mobileClass;
+    }
+    return `${mobileClass} sm:${axisClass}-${desktop}`;
+}
+/**
+ * Helper para spacing responsive
+ * Útil para padding/margin que necesita ajustarse por breakpoint
+ *
+ * @example
+ * spacingResponsive('px', { default: '4', sm: '6', lg: '8' })
+ * // Returns: 'px-4 sm:px-6 lg:px-8'
+ */
+export function spacingResponsive(property, values) {
+    return responsive(Object.entries(values).reduce((acc, [key, value]) => {
+        acc[key] = `${property}-${value}`;
+        return acc;
+    }, {}));
+}
+/**
+ * Helper para width responsive
+ *
+ * @example
+ * widthResponsive({ default: 'full', sm: 'auto', lg: '1/2' })
+ * // Returns: 'w-full sm:w-auto lg:w-1/2'
+ */
+export function widthResponsive(values) {
+    return responsive(Object.entries(values).reduce((acc, [key, value]) => {
+        acc[key] = `w-${value}`;
+        return acc;
+    }, {}));
+}
+/**
+ * Clases comunes para containers responsive
+ * Pensadas para wrappers que contienen contenido que puede desbordar
+ */
+export const RESPONSIVE_CONTAINER = {
+    // Container con scroll horizontal en mobile, contenido visible en desktop
+    tableWrapper: 'relative w-full overflow-x-auto sm:overflow-x-visible',
+    // Container con padding negativo en mobile para scroll edge-to-edge
+    tableWrapperFullBleed: 'relative w-full -mx-4 px-4 overflow-x-auto sm:mx-0 sm:px-0 sm:overflow-x-visible',
+    // Container con max-width responsive
+    contentWrapper: 'w-full mx-auto px-4 sm:px-6 lg:px-8 max-w-screen-2xl',
+    // Container para modals/dialogs
+    modalWrapper: 'w-full max-w-lg mx-auto px-4 sm:px-0',
+    // Container para forms
+    formWrapper: 'w-full max-w-md mx-auto space-y-4'
+};
+/**
+ * Clases comunes para display responsive
+ */
+export const RESPONSIVE_DISPLAY = {
+    // Ocultar en mobile, mostrar en desktop
+    hideOnMobile: 'hidden sm:block',
+    // Mostrar solo en mobile
+    showOnMobile: 'block sm:hidden',
+    // Stack en mobile, flex en desktop
+    stackToFlex: 'flex flex-col sm:flex-row',
+    // Stack en mobile, grid en desktop
+    stackToGrid: 'grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3'
+};
+/**
+ * Clases para table responsive strategies
+ */
+export const TABLE_RESPONSIVE = {
+    // Scroll horizontal (default, más simple)
+    scroll: {
+        wrapper: 'relative w-full overflow-x-auto',
+        table: 'w-full min-w-full',
+        cell: 'whitespace-nowrap'
+    },
+    // Permitir wrap del contenido
+    wrap: {
+        wrapper: 'relative w-full overflow-x-auto',
+        table: 'w-full',
+        cell: 'whitespace-normal break-words'
+    },
+    // Stack en mobile (cada fila se convierte en card)
+    // Requiere lógica adicional en el componente
+    stack: {
+        wrapper: 'relative w-full',
+        table: 'w-full',
+        row: 'block sm:table-row border-b sm:border-b-0',
+        cell: 'block sm:table-cell py-2 sm:py-0 before:content-[attr(data-label)] before:font-medium before:inline-block before:w-32 sm:before:content-none'
+    },
+    // Collapse: ocultar columnas menos importantes en mobile
+    // Se usa con clases de visibility en las columnas específicas
+    collapse: {
+        wrapper: 'relative w-full overflow-x-auto',
+        table: 'w-full',
+        cell: 'whitespace-nowrap',
+        // Estas clases se aplican a columnas opcionales
+        optionalColumn: 'hidden md:table-cell'
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"responsive.js","sourceRoot":"","sources":["../../../../../src/utils/responsive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Sistema de responsive utilities para PDM UI Kit\n * \n * Proporciona constantes, tipos y helpers para manejar responsive design\n * de forma consistente en todos los componentes.\n */\n\n/**\n * Breakpoints estándar de Tailwind CSS\n * Mobile-first approach: los estilos base son para mobile, los breakpoints son MIN-WIDTH\n */\nexport const BREAKPOINTS = {\n  sm: '640px',   // tablet portrait\n  md: '768px',   // tablet landscape\n  lg: '1024px',  // desktop\n  xl: '1280px',  // large desktop\n  '2xl': '1536px' // extra large desktop\n} as const;\n\nexport type Breakpoint = keyof typeof BREAKPOINTS;\n\n/**\n * Estrategias de overflow para componentes que pueden desbordar\n */\nexport type OverflowStrategy = \n  | 'auto'        // Scroll automático cuando sea necesario\n  | 'scroll'      // Siempre scroll\n  | 'hidden'      // Ocultar contenido que desborda\n  | 'visible';    // Permitir desbordamiento\n\n/**\n * Estrategias responsive para tablas\n */\nexport type TableResponsiveStrategy = \n  | 'scroll'      // Scroll horizontal en mobile (default, más simple)\n  | 'stack'       // Convertir filas en cards verticales en mobile\n  | 'wrap'        // Permitir que el contenido haga wrap\n  | 'collapse';   // Colapsar columnas menos importantes en mobile\n\n/**\n * Helper para generar clases responsive de forma programática\n * \n * @example\n * responsive({ default: 'block', sm: 'flex', lg: 'grid' })\n * // Returns: 'block sm:flex lg:grid'\n */\nexport function responsive<T extends string>(\n  config: Partial<Record<Breakpoint | 'default', T>>\n): string {\n  const classes: string[] = [];\n  \n  if (config.default) {\n    classes.push(config.default);\n  }\n  \n  (['sm', 'md', 'lg', 'xl', '2xl'] as Breakpoint[]).forEach(bp => {\n    if (config[bp]) {\n      classes.push(`${bp}:${config[bp]}`);\n    }\n  });\n  \n  return classes.join(' ');\n}\n\n/**\n * Helper para overflow responsive\n * Maneja el caso común de scroll en mobile, auto en desktop\n * \n * @example\n * overflowResponsive('x', 'scroll', 'auto')\n * // Returns: 'overflow-x-scroll sm:overflow-x-auto'\n */\nexport function overflowResponsive(\n  axis: 'x' | 'y' | 'both',\n  mobile: OverflowStrategy,\n  desktop?: OverflowStrategy\n): string {\n  const axisClass = axis === 'both' ? 'overflow' : `overflow-${axis}`;\n  const mobileClass = `${axisClass}-${mobile}`;\n  \n  if (!desktop || desktop === mobile) {\n    return mobileClass;\n  }\n  \n  return `${mobileClass} sm:${axisClass}-${desktop}`;\n}\n\n/**\n * Helper para spacing responsive\n * Útil para padding/margin que necesita ajustarse por breakpoint\n * \n * @example\n * spacingResponsive('px', { default: '4', sm: '6', lg: '8' })\n * // Returns: 'px-4 sm:px-6 lg:px-8'\n */\nexport function spacingResponsive(\n  property: 'p' | 'px' | 'py' | 'pt' | 'pr' | 'pb' | 'pl' | 'm' | 'mx' | 'my' | 'mt' | 'mr' | 'mb' | 'ml',\n  values: Partial<Record<Breakpoint | 'default', string>>\n): string {\n  return responsive(\n    Object.entries(values).reduce((acc, [key, value]) => {\n      acc[key as Breakpoint | 'default'] = `${property}-${value}` as any;\n      return acc;\n    }, {} as Record<Breakpoint | 'default', string>)\n  );\n}\n\n/**\n * Helper para width responsive\n * \n * @example\n * widthResponsive({ default: 'full', sm: 'auto', lg: '1/2' })\n * // Returns: 'w-full sm:w-auto lg:w-1/2'\n */\nexport function widthResponsive(\n  values: Partial<Record<Breakpoint | 'default', string>>\n): string {\n  return responsive(\n    Object.entries(values).reduce((acc, [key, value]) => {\n      acc[key as Breakpoint | 'default'] = `w-${value}` as any;\n      return acc;\n    }, {} as Record<Breakpoint | 'default', string>)\n  );\n}\n\n/**\n * Clases comunes para containers responsive\n * Pensadas para wrappers que contienen contenido que puede desbordar\n */\nexport const RESPONSIVE_CONTAINER = {\n  // Container con scroll horizontal en mobile, contenido visible en desktop\n  tableWrapper: 'relative w-full overflow-x-auto sm:overflow-x-visible',\n  \n  // Container con padding negativo en mobile para scroll edge-to-edge\n  tableWrapperFullBleed: 'relative w-full -mx-4 px-4 overflow-x-auto sm:mx-0 sm:px-0 sm:overflow-x-visible',\n  \n  // Container con max-width responsive\n  contentWrapper: 'w-full mx-auto px-4 sm:px-6 lg:px-8 max-w-screen-2xl',\n  \n  // Container para modals/dialogs\n  modalWrapper: 'w-full max-w-lg mx-auto px-4 sm:px-0',\n  \n  // Container para forms\n  formWrapper: 'w-full max-w-md mx-auto space-y-4'\n} as const;\n\n/**\n * Clases comunes para display responsive\n */\nexport const RESPONSIVE_DISPLAY = {\n  // Ocultar en mobile, mostrar en desktop\n  hideOnMobile: 'hidden sm:block',\n  \n  // Mostrar solo en mobile\n  showOnMobile: 'block sm:hidden',\n  \n  // Stack en mobile, flex en desktop\n  stackToFlex: 'flex flex-col sm:flex-row',\n  \n  // Stack en mobile, grid en desktop\n  stackToGrid: 'grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3'\n} as const;\n\n/**\n * Clases para table responsive strategies\n */\nexport const TABLE_RESPONSIVE = {\n  // Scroll horizontal (default, más simple)\n  scroll: {\n    wrapper: 'relative w-full overflow-x-auto',\n    table: 'w-full min-w-full',\n    cell: 'whitespace-nowrap'\n  },\n  \n  // Permitir wrap del contenido\n  wrap: {\n    wrapper: 'relative w-full overflow-x-auto',\n    table: 'w-full',\n    cell: 'whitespace-normal break-words'\n  },\n  \n  // Stack en mobile (cada fila se convierte en card)\n  // Requiere lógica adicional en el componente\n  stack: {\n    wrapper: 'relative w-full',\n    table: 'w-full',\n    row: 'block sm:table-row border-b sm:border-b-0',\n    cell: 'block sm:table-cell py-2 sm:py-0 before:content-[attr(data-label)] before:font-medium before:inline-block before:w-32 sm:before:content-none'\n  },\n  \n  // Collapse: ocultar columnas menos importantes en mobile\n  // Se usa con clases de visibility en las columnas específicas\n  collapse: {\n    wrapper: 'relative w-full overflow-x-auto',\n    table: 'w-full',\n    cell: 'whitespace-nowrap',\n    // Estas clases se aplican a columnas opcionales\n    optionalColumn: 'hidden md:table-cell'\n  }\n} as const;\n"]}

package/esm2020/src/utils/z-index.mjs

@@ -0,0 +1,90 @@
+/**
+ * Z-Index Scale - Sistema centralizado de z-index
+ *
+ * JERARQUÍA (de menor a mayor):
+ * 1. base (z-0) - Elementos normales del DOM
+ * 2. dropdown (z-10) - Selects, combobox, date-pickers
+ * 3. sticky (z-20) - Headers, navigation bars
+ * 4. drawerBackdrop (z-30) - Backdrop de drawers
+ * 5. drawer (z-40) - Sidebar drawer, sheets laterales
+ * 6. modalBackdrop (z-40) - Backdrop de modals ( mismo nivel que drawer)
+ * 7. modal (z-50) - Dialogs, alert-dialogs
+ * 8. popover (z-[70]) - Tooltips, dropdowns DENTRO de modals
+ * 9. toast (z-[100]) - Notificaciones que deben estar sobre TODO
+ *
+ * REGLA CRÍTICA:
+ * - Componentes overlay (select options, dropdown menu, tooltip) SIEMPRE z-[70] o mayor
+ * - Esto permite que funcionen DENTRO de modals (z-50)
+ * - Backdrop de modal debe ser z-40 para estar DEBAJO del contenido del modal (z-50)
+ */
+export const Z_INDEX = {
+    /**
+     * Base - contenido normal del DOM
+     */
+    base: "z-0",
+    /**
+     * Dropdown - Selects, combobox, date-pickers
+     * Debe estar SOBRE contenido normal pero BAJO overlays
+     */
+    dropdown: "z-10",
+    /**
+     * Sticky - Headers, navigation fija
+     */
+    sticky: "z-20",
+    /**
+     * Drawer backdrop - Backdrop de sidebar drawer
+     * Debe estar DEBAJO del drawer panel y DEBAJO de modals
+     */
+    drawerBackdrop: "z-30",
+    /**
+     * Drawer - Sidebar drawer, sheets laterales
+     * Debe estar SOBRE su backdrop pero BAJO modals
+     */
+    drawer: "z-40",
+    /**
+     * Modal backdrop - Backdrop de dialogs
+     * Mismo nivel que drawer backdrop (z-40)
+     */
+    modalBackdrop: "z-40",
+    /**
+     * Modal - Dialogs, alert-dialogs
+     * Debe estar SOBRE su backdrop
+     */
+    modal: "z-50",
+    /**
+     * Popover - Tooltips, dropdowns, selects options DENTRO de modals
+     * CRÍTICO: Debe ser MAYOR que modal (z-50) para aparecer sobre modals
+     * USAR SIEMPRE mergeOverlayPanelClass() para asegurar este valor
+     */
+    popover: "z-[70]",
+    /**
+     * Toast - Notificaciones globales
+     * Debe estar sobre TODO
+     */
+    toast: "z-[100]",
+};
+/**
+ * Helper para debugging z-index issues
+ */
+export function logZIndexStack(element) {
+    if (typeof window === "undefined")
+        return;
+    let current = element;
+    const stack = [];
+    while (current && current !== document.body) {
+        const computed = window.getComputedStyle(current);
+        const zIndex = computed.zIndex;
+        const position = computed.position;
+        if (zIndex !== "auto") {
+            stack.push({
+                element: current.tagName +
+                    (current.className ? `.${current.className.split(" ")[0]}` : ""),
+                zIndex,
+                position,
+            });
+        }
+        current = current.parentElement;
+    }
+    console.table(stack);
+}
+//# sourceMappingURL=data:application/json;base64,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