@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/core/popover/popover.module.mjs

@@ -0,0 +1,22 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { QdPopoverOnClickDirective } from './popover-on-click/popover-on-click.directive';
+import { QdPopoverOnHoverDirective } from './popover-on-hover/popover-on-hover.directive';
+import { QdPopoverService } from './popover.service';
+import { QdPopoverComponent } from './popover/popover.component';
+import * as i0 from "@angular/core";
+export class QdPopoverModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverModule, declarations: [QdPopoverComponent, QdPopoverOnClickDirective, QdPopoverOnHoverDirective], imports: [CommonModule], exports: [QdPopoverOnClickDirective, QdPopoverOnHoverDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverModule, providers: [QdPopoverService], imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [QdPopoverComponent, QdPopoverOnClickDirective, QdPopoverOnHoverDirective],
+                    exports: [QdPopoverOnClickDirective, QdPopoverOnHoverDirective],
+                    providers: [QdPopoverService]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3FkLXVpL3NyYy9saWIvY29yZS9wb3BvdmVyL3BvcG92ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLCtDQUErQyxDQUFDO0FBQzFGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLCtDQUErQyxDQUFDO0FBQzFGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDOztBQVFqRSxNQUFNLE9BQU8sZUFBZTt1R0FBZixlQUFlO3dHQUFmLGVBQWUsaUJBSlgsa0JBQWtCLEVBQUUseUJBQXlCLEVBQUUseUJBQXlCLGFBRDdFLFlBQVksYUFFWix5QkFBeUIsRUFBRSx5QkFBeUI7d0dBR25ELGVBQWUsYUFGZixDQUFDLGdCQUFnQixDQUFDLFlBSG5CLFlBQVk7OzJGQUtYLGVBQWU7a0JBTjNCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixZQUFZLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSx5QkFBeUIsRUFBRSx5QkFBeUIsQ0FBQztvQkFDeEYsT0FBTyxFQUFFLENBQUMseUJBQXlCLEVBQUUseUJBQXlCLENBQUM7b0JBQy9ELFNBQVMsRUFBRSxDQUFDLGdCQUFnQixDQUFDO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUWRQb3BvdmVyT25DbGlja0RpcmVjdGl2ZSB9IGZyb20gJy4vcG9wb3Zlci1vbi1jbGljay9wb3BvdmVyLW9uLWNsaWNrLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBRZFBvcG92ZXJPbkhvdmVyRGlyZWN0aXZlIH0gZnJvbSAnLi9wb3BvdmVyLW9uLWhvdmVyL3BvcG92ZXItb24taG92ZXIuZGlyZWN0aXZlJztcbmltcG9ydCB7IFFkUG9wb3ZlclNlcnZpY2UgfSBmcm9tICcuL3BvcG92ZXIuc2VydmljZSc7XG5pbXBvcnQgeyBRZFBvcG92ZXJDb21wb25lbnQgfSBmcm9tICcuL3BvcG92ZXIvcG9wb3Zlci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbUWRQb3BvdmVyQ29tcG9uZW50LCBRZFBvcG92ZXJPbkNsaWNrRGlyZWN0aXZlLCBRZFBvcG92ZXJPbkhvdmVyRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW1FkUG9wb3Zlck9uQ2xpY2tEaXJlY3RpdmUsIFFkUG9wb3Zlck9uSG92ZXJEaXJlY3RpdmVdLFxuICBwcm92aWRlcnM6IFtRZFBvcG92ZXJTZXJ2aWNlXVxufSlcbmV4cG9ydCBjbGFzcyBRZFBvcG92ZXJNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/core/popover/popover.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class QdPopoverService {
+    closeHandler = new Subject();
+    closeAllOverlays(excludedPopovers = []) {
+        this.closeHandler.next(excludedPopovers);
+    }
+    subscribe(callback) {
+        return this.closeHandler.subscribe(callback);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xZC11aS9zcmMvbGliL2NvcmUvcG9wb3Zlci9wb3BvdmVyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFnQixNQUFNLE1BQU0sQ0FBQzs7QUFNN0MsTUFBTSxPQUFPLGdCQUFnQjtJQUNuQixZQUFZLEdBQUcsSUFBSSxPQUFPLEVBQXdCLENBQUM7SUFFM0QsZ0JBQWdCLENBQUMsbUJBQXlDLEVBQUU7UUFDMUQsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRUQsU0FBUyxDQUFDLFFBQThCO1FBQ3RDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDL0MsQ0FBQzt1R0FUVSxnQkFBZ0I7MkdBQWhCLGdCQUFnQjs7MkZBQWhCLGdCQUFnQjtrQkFENUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN1YmplY3QsIFN1YnNjcmlwdGlvbiB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgUWRQb3BvdmVyQ29tcG9uZW50IH0gZnJvbSAnLi9wb3BvdmVyL3BvcG92ZXIuY29tcG9uZW50JztcblxuZXhwb3J0IHR5cGUgUG9wb3ZlckNsb3NlQ2FsbGJhY2sgPSAoZXhjbHVkZWRQb3BvdmVyczogUWRQb3BvdmVyQ29tcG9uZW50W10pID0+IHZvaWQ7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBRZFBvcG92ZXJTZXJ2aWNlIHtcbiAgcHJpdmF0ZSBjbG9zZUhhbmRsZXIgPSBuZXcgU3ViamVjdDxRZFBvcG92ZXJDb21wb25lbnRbXT4oKTtcblxuICBjbG9zZUFsbE92ZXJsYXlzKGV4Y2x1ZGVkUG9wb3ZlcnM6IFFkUG9wb3ZlckNvbXBvbmVudFtdID0gW10pOiB2b2lkIHtcbiAgICB0aGlzLmNsb3NlSGFuZGxlci5uZXh0KGV4Y2x1ZGVkUG9wb3ZlcnMpO1xuICB9XG5cbiAgc3Vic2NyaWJlKGNhbGxiYWNrOiBQb3BvdmVyQ2xvc2VDYWxsYmFjayk6IFN1YnNjcmlwdGlvbiB7XG4gICAgcmV0dXJuIHRoaXMuY2xvc2VIYW5kbGVyLnN1YnNjcmliZShjYWxsYmFjayk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/core/projection-guard/projection-guard.component.mjs

@@ -0,0 +1,33 @@
+import { Component, ElementRef, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdProjectionGuardComponent {
+    elementRef;
+    isDisabled = false;
+    warningMessage = 'QD-UI | QdProjectionGuard - This content is not supported and cannot be displayed:';
+    wildcardSlot;
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    ngAfterContentInit() {
+        if (this.isDisabled)
+            return;
+        this.wildcardSlot = this.elementRef.nativeElement;
+        if (!this.wildcardSlot.children.length)
+            return;
+        Array.from(this.wildcardSlot.children).forEach(el => console.warn(this.warningMessage, el));
+    }
+    ngAfterViewInit() {
+        this.elementRef.nativeElement.remove();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdProjectionGuardComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdProjectionGuardComponent, selector: "qd-projection-guard", inputs: { isDisabled: "isDisabled", warningMessage: "warningMessage" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: [":host{display:none!important;position:absolute}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdProjectionGuardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-projection-guard', template: '<ng-content></ng-content>', styles: [":host{display:none!important;position:absolute}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { isDisabled: [{
+                type: Input
+            }], warningMessage: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/rwd-disabled/rwd-disabled.directive.mjs

@@ -0,0 +1,14 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdRwdDisabledDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdRwdDisabledDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: QdRwdDisabledDirective, selector: "[qdRwdDisabled]", host: { classAttribute: "qd-rwd-disabled" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdRwdDisabledDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[qdRwdDisabled]',
+                    host: { class: 'qd-rwd-disabled' }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicndkLWRpc2FibGVkLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9jb3JlL3J3ZC1kaXNhYmxlZC9yd2QtZGlzYWJsZWQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTTFDLE1BQU0sT0FBTyxzQkFBc0I7dUdBQXRCLHNCQUFzQjsyRkFBdEIsc0JBQXNCOzsyRkFBdEIsc0JBQXNCO2tCQUpsQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxpQkFBaUI7b0JBQzNCLElBQUksRUFBRSxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBRTtpQkFDbkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3FkUndkRGlzYWJsZWRdJyxcbiAgaG9zdDogeyBjbGFzczogJ3FkLXJ3ZC1kaXNhYmxlZCcgfVxufSlcbmV4cG9ydCBjbGFzcyBRZFJ3ZERpc2FibGVkRGlyZWN0aXZlIHt9XG4iXX0=

package/esm2022/lib/core/rxjs/delay-and-hold.operator.mjs

@@ -0,0 +1,52 @@
+import { debounce, distinctUntilChanged, EMPTY, map, of, pairwise, switchMap, timer } from 'rxjs';
+import { concatMap, startWith } from 'rxjs/operators';
+import { QdFormOptionsRequestState } from '../../forms/model/form-options-resolver';
+/**
+ * Delays the emission of a value (like a loading spinner) for a given time and keeps it visible for at least a minimum duration.
+ *
+ * Time →
+ * Status:   IDLE         PENDING                SUCCESS
+ *            |-------------|--------------------|---------->
+ *                 |
+ *                 |--- appearAfter (e.g. 400ms) ---|
+ *                               |
+ *                               v
+ * Feedback:  OFF  ..........(waiting)..........  ON    |<--- minVisible (e.g. 300ms) --->|  OFF
+ *
+ * - appearAfter:
+ *   Number of milliseconds to wait before showing the value after the trigger condition is true.
+ *   Example: 400 means the spinner appears 400 ms after PENDING starts.
+ *
+ * - minVisible:
+ *   Minimum milliseconds the value stays visible, even if the state changes sooner.
+ *   Example: 300 means the spinner will be shown for at least 300 ms.
+ *
+ * - triggerState:
+ *   Function (curr, prev) that decides when to start the delay.
+ *   Default: when the current state is PENDING and the previous state was not ERROR.
+ *
+ * - holdState:
+ *   Function (state) that decides how long to keep the value visible.
+ *   Default: as long as the state is PENDING.
+ *
+ *
+ * @example
+ * delayedRequestState$ = requestState$.pipe(
+ *   delayAndHold(
+ *     400, // wait 400 ms before showing
+ *     300, // show at least 300 ms
+ *     (curr, prev) => curr === QdFormOptionsRequestState.PENDING && prev !== QdFormOptionsRequestState.ERROR,
+ *     (state) => state === QdFormOptionsRequestState.PENDING
+ *   )
+ * );
+ *
+ * @example with defaults
+ * myStream.pipe(delayAndHold());
+ */
+export function qdDelayAndHold(options = {}) {
+    const { appearAfter = 400, minVisible = 300, triggerState = (curr, prev) => curr === QdFormOptionsRequestState.PENDING && prev !== QdFormOptionsRequestState.ERROR, holdState = (state) => state === QdFormOptionsRequestState.PENDING } = options;
+    return (source$) => source$.pipe(distinctUntilChanged(), startWith(undefined), pairwise(), debounce(([prev, curr]) => (triggerState(curr, prev) ? timer(appearAfter) : of(true))), map(([, curr]) => curr), concatMap(state => holdState(state)
+        ? timer(minVisible).pipe(switchMap(() => EMPTY), startWith(state))
+        : of(state)));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXktYW5kLWhvbGQub3BlcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3FkLXVpL3NyYy9saWIvY29yZS9yeGpzL2RlbGF5LWFuZC1ob2xkLm9wZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsb0JBQW9CLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBYyxFQUFFLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDOUcsT0FBTyxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV0RCxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQVNwRjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F5Q0c7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUFJLFVBQW9DLEVBQUU7SUFDdEUsTUFBTSxFQUNKLFdBQVcsR0FBRyxHQUFHLEVBQ2pCLFVBQVUsR0FBRyxHQUFHLEVBQ2hCLFlBQVksR0FBRyxDQUFDLElBQUksRUFBRSxJQUFJLEVBQVcsRUFBRSxDQUNyQyxJQUFJLEtBQUsseUJBQXlCLENBQUMsT0FBTyxJQUFJLElBQUksS0FBSyx5QkFBeUIsQ0FBQyxLQUFLLEVBQ3hGLFNBQVMsR0FBRyxDQUFDLEtBQUssRUFBVyxFQUFFLENBQUMsS0FBSyxLQUFLLHlCQUF5QixDQUFDLE9BQU8sRUFDNUUsR0FBRyxPQUFPLENBQUM7SUFFWixPQUFPLENBQUMsT0FBc0IsRUFBaUIsRUFBRSxDQUMvQyxPQUFPLENBQUMsSUFBSSxDQUNWLG9CQUFvQixFQUFFLEVBQ3RCLFNBQVMsQ0FBQyxTQUFjLENBQUMsRUFDekIsUUFBUSxFQUFFLEVBQ1YsUUFBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUN0RixHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUN2QixTQUFTLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FDaEIsU0FBUyxDQUFDLEtBQUssQ0FBQztRQUNkLENBQUMsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsSUFBSSxDQUNwQixTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLEVBQ3RCLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FDakI7UUFDSCxDQUFDLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUNkLENBQ0YsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBkZWJvdW5jZSwgZGlzdGluY3RVbnRpbENoYW5nZWQsIEVNUFRZLCBtYXAsIE9ic2VydmFibGUsIG9mLCBwYWlyd2lzZSwgc3dpdGNoTWFwLCB0aW1lciB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgY29uY2F0TWFwLCBzdGFydFdpdGggfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmltcG9ydCB7IFFkRm9ybU9wdGlvbnNSZXF1ZXN0U3RhdGUgfSBmcm9tICcuLi8uLi9mb3Jtcy9tb2RlbC9mb3JtLW9wdGlvbnMtcmVzb2x2ZXInO1xuXG5pbnRlcmZhY2UgUWREZWxheUFuZEhvbGRPcHRpb25zPFQ+IHtcbiAgYXBwZWFyQWZ0ZXI/OiBudW1iZXI7XG4gIG1pblZpc2libGU/OiBudW1iZXI7XG4gIHRyaWdnZXJTdGF0ZT86IChjdXJyOiBULCBwcmV2OiBUKSA9PiBib29sZWFuO1xuICBob2xkU3RhdGU/OiAoc3RhdGU6IFQpID0+IGJvb2xlYW47XG59XG5cbi8qKlxuICogRGVsYXlzIHRoZSBlbWlzc2lvbiBvZiBhIHZhbHVlIChsaWtlIGEgbG9hZGluZyBzcGlubmVyKSBmb3IgYSBnaXZlbiB0aW1lIGFuZCBrZWVwcyBpdCB2aXNpYmxlIGZvciBhdCBsZWFzdCBhIG1pbmltdW0gZHVyYXRpb24uXG4gKlxuICogVGltZSDihpJcbiAqIFN0YXR1czogICBJRExFICAgICAgICAgUEVORElORyAgICAgICAgICAgICAgICBTVUNDRVNTXG4gKiAgICAgICAgICAgIHwtLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0+XG4gKiAgICAgICAgICAgICAgICAgfFxuICogICAgICAgICAgICAgICAgIHwtLS0gYXBwZWFyQWZ0ZXIgKGUuZy4gNDAwbXMpIC0tLXxcbiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHxcbiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZcbiAqIEZlZWRiYWNrOiAgT0ZGICAuLi4uLi4uLi4uKHdhaXRpbmcpLi4uLi4uLi4uLiAgT04gICAgfDwtLS0gbWluVmlzaWJsZSAoZS5nLiAzMDBtcykgLS0tPnwgIE9GRlxuICpcbiAqIC0gYXBwZWFyQWZ0ZXI6XG4gKiAgIE51bWJlciBvZiBtaWxsaXNlY29uZHMgdG8gd2FpdCBiZWZvcmUgc2hvd2luZyB0aGUgdmFsdWUgYWZ0ZXIgdGhlIHRyaWdnZXIgY29uZGl0aW9uIGlzIHRydWUuXG4gKiAgIEV4YW1wbGU6IDQwMCBtZWFucyB0aGUgc3Bpbm5lciBhcHBlYXJzIDQwMCBtcyBhZnRlciBQRU5ESU5HIHN0YXJ0cy5cbiAqXG4gKiAtIG1pblZpc2libGU6XG4gKiAgIE1pbmltdW0gbWlsbGlzZWNvbmRzIHRoZSB2YWx1ZSBzdGF5cyB2aXNpYmxlLCBldmVuIGlmIHRoZSBzdGF0ZSBjaGFuZ2VzIHNvb25lci5cbiAqICAgRXhhbXBsZTogMzAwIG1lYW5zIHRoZSBzcGlubmVyIHdpbGwgYmUgc2hvd24gZm9yIGF0IGxlYXN0IDMwMCBtcy5cbiAqXG4gKiAtIHRyaWdnZXJTdGF0ZTpcbiAqICAgRnVuY3Rpb24gKGN1cnIsIHByZXYpIHRoYXQgZGVjaWRlcyB3aGVuIHRvIHN0YXJ0IHRoZSBkZWxheS5cbiAqICAgRGVmYXVsdDogd2hlbiB0aGUgY3VycmVudCBzdGF0ZSBpcyBQRU5ESU5HIGFuZCB0aGUgcHJldmlvdXMgc3RhdGUgd2FzIG5vdCBFUlJPUi5cbiAqXG4gKiAtIGhvbGRTdGF0ZTpcbiAqICAgRnVuY3Rpb24gKHN0YXRlKSB0aGF0IGRlY2lkZXMgaG93IGxvbmcgdG8ga2VlcCB0aGUgdmFsdWUgdmlzaWJsZS5cbiAqICAgRGVmYXVsdDogYXMgbG9uZyBhcyB0aGUgc3RhdGUgaXMgUEVORElORy5cbiAqXG4gKlxuICogQGV4YW1wbGVcbiAqIGRlbGF5ZWRSZXF1ZXN0U3RhdGUkID0gcmVxdWVzdFN0YXRlJC5waXBlKFxuICogICBkZWxheUFuZEhvbGQoXG4gKiAgICAgNDAwLCAvLyB3YWl0IDQwMCBtcyBiZWZvcmUgc2hvd2luZ1xuICogICAgIDMwMCwgLy8gc2hvdyBhdCBsZWFzdCAzMDAgbXNcbiAqICAgICAoY3VyciwgcHJldikgPT4gY3VyciA9PT0gUWRGb3JtT3B0aW9uc1JlcXVlc3RTdGF0ZS5QRU5ESU5HICYmIHByZXYgIT09IFFkRm9ybU9wdGlvbnNSZXF1ZXN0U3RhdGUuRVJST1IsXG4gKiAgICAgKHN0YXRlKSA9PiBzdGF0ZSA9PT0gUWRGb3JtT3B0aW9uc1JlcXVlc3RTdGF0ZS5QRU5ESU5HXG4gKiAgIClcbiAqICk7XG4gKlxuICogQGV4YW1wbGUgd2l0aCBkZWZhdWx0c1xuICogbXlTdHJlYW0ucGlwZShkZWxheUFuZEhvbGQoKSk7XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBxZERlbGF5QW5kSG9sZDxUPihvcHRpb25zOiBRZERlbGF5QW5kSG9sZE9wdGlvbnM8VD4gPSB7fSk6IChzb3VyY2UkOiBPYnNlcnZhYmxlPFQ+KSA9PiBPYnNlcnZhYmxlPFQ+IHtcbiAgY29uc3Qge1xuICAgIGFwcGVhckFmdGVyID0gNDAwLFxuICAgIG1pblZpc2libGUgPSAzMDAsXG4gICAgdHJpZ2dlclN0YXRlID0gKGN1cnIsIHByZXYpOiBib29sZWFuID0+XG4gICAgICBjdXJyID09PSBRZEZvcm1PcHRpb25zUmVxdWVzdFN0YXRlLlBFTkRJTkcgJiYgcHJldiAhPT0gUWRGb3JtT3B0aW9uc1JlcXVlc3RTdGF0ZS5FUlJPUixcbiAgICBob2xkU3RhdGUgPSAoc3RhdGUpOiBib29sZWFuID0+IHN0YXRlID09PSBRZEZvcm1PcHRpb25zUmVxdWVzdFN0YXRlLlBFTkRJTkdcbiAgfSA9IG9wdGlvbnM7XG5cbiAgcmV0dXJuIChzb3VyY2UkOiBPYnNlcnZhYmxlPFQ+KTogT2JzZXJ2YWJsZTxUPiA9PlxuICAgIHNvdXJjZSQucGlwZShcbiAgICAgIGRpc3RpbmN0VW50aWxDaGFuZ2VkKCksXG4gICAgICBzdGFydFdpdGgodW5kZWZpbmVkIGFzIFQpLFxuICAgICAgcGFpcndpc2UoKSxcbiAgICAgIGRlYm91bmNlKChbcHJldiwgY3Vycl0pID0+ICh0cmlnZ2VyU3RhdGUoY3VyciwgcHJldikgPyB0aW1lcihhcHBlYXJBZnRlcikgOiBvZih0cnVlKSkpLFxuICAgICAgbWFwKChbLCBjdXJyXSkgPT4gY3VyciksXG4gICAgICBjb25jYXRNYXAoc3RhdGUgPT5cbiAgICAgICAgaG9sZFN0YXRlKHN0YXRlKVxuICAgICAgICAgID8gdGltZXIobWluVmlzaWJsZSkucGlwZShcbiAgICAgICAgICAgICAgc3dpdGNoTWFwKCgpID0+IEVNUFRZKSxcbiAgICAgICAgICAgICAgc3RhcnRXaXRoKHN0YXRlKVxuICAgICAgICAgICAgKVxuICAgICAgICAgIDogb2Yoc3RhdGUpXG4gICAgICApXG4gICAgKTtcbn1cbiJdfQ==

package/esm2022/lib/core/services/breakpoint.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { combineLatest, concat, fromEvent } from 'rxjs';
+import { debounceTime, map, startWith, take } from 'rxjs/operators';
+import { breakpoints } from '../model/breakpoint.interface';
+import * as i0 from "@angular/core";
+export class QdBreakpointService {
+    _breakpoints = breakpoints;
+    get breakpoints() {
+        return this._breakpoints;
+    }
+    getMatchingBreakpoint() {
+        const queries = Object.values(this.breakpoints).map(bp => `(min-width: ${bp}px)`);
+        const matches$ = queries.map(query => {
+            const mql = window.matchMedia(query);
+            return fromEvent(mql, 'change').pipe(map(event => event.matches), startWith(mql.matches));
+        });
+        const breakpoint = combineLatest(matches$).pipe(map(matches => (Object.keys(this.breakpoints)[matches.lastIndexOf(true)] || Object.keys(this.breakpoints)[0])));
+        return concat(breakpoint.pipe(take(1)), breakpoint.pipe(debounceTime(100)));
+    }
+    isViewportBelow(breakpoint) {
+        return this.getMatchingBreakpoint().pipe(map(currentBreakpoint => {
+            return this.breakpoints[currentBreakpoint] < this.breakpoints[breakpoint];
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdBreakpointService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdBreakpointService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdBreakpointService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/element.service.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdElementService {
+    isOverflown(element) {
+        return element.scrollHeight > element.clientHeight || element.scrollWidth > element.clientWidth;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdElementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdElementService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdElementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xZC11aS9zcmMvbGliL2NvcmUvc2VydmljZXMvZWxlbWVudC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxnQkFBZ0I7SUFDM0IsV0FBVyxDQUFDLE9BQW9CO1FBQzlCLE9BQU8sT0FBTyxDQUFDLFlBQVksR0FBRyxPQUFPLENBQUMsWUFBWSxJQUFJLE9BQU8sQ0FBQyxXQUFXLEdBQUcsT0FBTyxDQUFDLFdBQVcsQ0FBQztJQUNsRyxDQUFDO3VHQUhVLGdCQUFnQjsyR0FBaEIsZ0JBQWdCLGNBRmYsTUFBTTs7MkZBRVAsZ0JBQWdCO2tCQUg1QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgUWRFbGVtZW50U2VydmljZSB7XG4gIGlzT3ZlcmZsb3duKGVsZW1lbnQ6IEhUTUxFbGVtZW50KTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIGVsZW1lbnQuc2Nyb2xsSGVpZ2h0ID4gZWxlbWVudC5jbGllbnRIZWlnaHQgfHwgZWxlbWVudC5zY3JvbGxXaWR0aCA+IGVsZW1lbnQuY2xpZW50V2lkdGg7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/core/services/event-broker.service.mjs

@@ -0,0 +1,76 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, EMPTY, shareReplay } from 'rxjs';
+import { distinctUntilChanged, filter } from 'rxjs/operators';
+import { isEqual } from 'lodash';
+import * as i0 from "@angular/core";
+/**
+ * Inspired by Kafka's message broker architecture, the QdEventBrokerService provides a lightweight, event-driven
+ * communication layer within the Quadrel framework.
+ *
+ * #### Usage:
+ *
+ * **Produce an Event**
+ * Use the `produce` method to send an event to a specific topic.
+ *
+ * ```typescript
+ * eventBrokerService.produce('userLoggedIn', { userId: 123, name: 'John Doe' });
+ * ```
+ *
+ * **Consuming an Event**
+ * Subscribe to a topic to receive updates when an event is produced.
+ *
+ * ```typescript
+ * eventBrokerService.consume<{ userId: number; name: string }>('userLoggedIn')
+ *   .subscribe(event => {
+ *     console.log('User logged in:', event.payload);
+ *   });
+ * ```
+ *
+ * **Unsubscribing from a Topic**
+ * Calling `unsubscribeFrom(topic)` removes the topic and closes its event stream.
+ * This affects all consumers** subscribed to the topic, as no more updates will be sent.
+ *
+ * ```typescript
+ * eventBrokerService.unsubscribeFrom('userLoggedIn');
+ * ```
+ * After this method is called, subscribing to the topic will return an empty stream.
+ *
+ * **Ensuring Topic Existence**
+ * The `produce` method automatically creates a topic if it does not exist. However, topics are only removed when
+ * explicitly unsubscribed using `unsubscribeFrom()`.
+ *
+ * **What are Topics?**
+ * A **topic** is a named communication channel where events are published and consumed.
+ * Topics allow different parts of an application to exchange information **without being directly connected**.
+ * This makes the system more flexible and easier to maintain.
+ */
+export class QdEventBrokerService {
+    _topics = new Map();
+    produce(topic, payload) {
+        this.ensureTopicExists(topic);
+        this._topics.get(topic).next({ topic, payload });
+    }
+    consume(topic) {
+        if (!this._topics.has(topic)) {
+            console.warn(`QD-UI | QdEventBrokerService - Topic "${topic}" does not exist.`);
+            return EMPTY;
+        }
+        return this._topics.get(topic).pipe(filter(event => event.payload != null), distinctUntilChanged((prev, curr) => isEqual(prev, curr)), shareReplay(1));
+    }
+    unsubscribeFrom(topic) {
+        const subject = this._topics.get(topic);
+        if (subject && !subject.closed)
+            subject.complete();
+        this._topics.delete(topic);
+    }
+    ensureTopicExists(topic) {
+        if (!this._topics.has(topic))
+            this._topics.set(topic, new BehaviorSubject({ topic, payload: undefined }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdEventBrokerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdEventBrokerService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdEventBrokerService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/push-events.service.mjs

@@ -0,0 +1,153 @@
+import { Injectable } from '@angular/core';
+import { NEVER, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for handling real-time server-sent events.
+ *
+ * ### Benefits
+ *
+ * - **Real-Time Interaction**: Enables live updates without user actions or polling.
+ * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.
+ * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.
+ *
+ * ### Usage
+ *
+ * ```ts
+ * // Start the connection to the events
+ * pushEventsService.connect('http://service-endpint/events');
+ *
+ * // Subscribe to the event (Side Effect)
+ * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));
+ *
+ * // Unsubscribe to prevent memory leaks
+ * subscription.unsubscribe();
+ *
+ * // Disconnect the connection
+ * pushEventsService.disconnect();
+ * ```
+ */
+export class QdPushEventsService {
+    _eventSource;
+    _eventSubscriptionSubjects = new Map();
+    _listeners = [];
+    _heartbeatTimeout;
+    _reconnectDelayTime = 10000;
+    _heartbeatReconnectDelayTime = 100;
+    /**
+     * Establishes an EventSource connection to the given URL.
+     * Automatically reconnects if heartbeat fails or is delayed.
+     * Subscribers are retained across reconnections.
+     *
+     * @param url The backend URL for the event stream.
+     */
+    connect(url) {
+        if (this.isConnectedOrConnecting())
+            return;
+        if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED)
+            this._eventSource = new EventSource(url);
+        this._eventSource.onerror = (err) => {
+            if (this._eventSource.readyState === EventSource.CLOSED)
+                this.reconnect();
+            this.logError('SSE connection error:', err);
+        };
+        this._eventSource.addEventListener('HEARTBEAT', message => {
+            if (this._heartbeatTimeout)
+                clearTimeout(this._heartbeatTimeout);
+            const interval = JSON.parse(message.data).interval;
+            this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);
+        });
+        this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);
+        this.addEventListenersForExistingSubscriptions();
+    }
+    /**
+     * Closes the EventSource connection and clears all listeners.
+     * Subscribers are preserved for reconnection.
+     */
+    disconnect() {
+        if (!this._eventSource) {
+            this.logWarn('No active connection to disconnect.');
+            return;
+        }
+        this.removeAllEventListenersFromEventSource();
+        this._eventSource.close();
+    }
+    /**
+     * Returns an Observable for the specified event name.
+     * If not connected, returns `NEVER` and logs an error.
+     * Automatically adds a listener for the event if needed.
+     *
+     * @param eventName The event type ('RESOURCE_CREATED', 'RESOURCE_UPDATED', 'RESOURCE_DELETED').
+     * @returns Observable<MessageEvent> The event stream.
+     */
+    observe(eventName) {
+        if (!this._eventSource) {
+            this.logError('Cannot observe events without a connection. Call connect() first.');
+            return NEVER;
+        }
+        if (!this._eventSubscriptionSubjects.has(eventName)) {
+            this._eventSubscriptionSubjects.set(eventName, new Subject());
+            this.addEventListenerForEventName(eventName);
+        }
+        return this._eventSubscriptionSubjects.get(eventName).asObservable();
+    }
+    /**
+     * Removes all listeners and clears all subscriptions.
+     * The EventSource connection remains open.
+     */
+    unobserveAll() {
+        this.removeAllEventListenersFromEventSource();
+        this._eventSubscriptionSubjects.clear();
+    }
+    /**
+     * Checks if the EventSource is connected or in the process of connecting.
+     */
+    isConnectedOrConnecting() {
+        return (this._eventSource &&
+            (this._eventSource.readyState === EventSource.OPEN || this._eventSource.readyState === EventSource.CONNECTING));
+    }
+    reconnect() {
+        if (!this.isConnectedOrConnecting()) {
+            this.disconnect();
+            this.connect(this._eventSource.url);
+        }
+    }
+    addEventListenerForEventName(eventName) {
+        const callback = (messageEvent) => {
+            const subject = this._eventSubscriptionSubjects.get(eventName);
+            if (subject)
+                subject.next(messageEvent);
+        };
+        this._eventSource.addEventListener(eventName, callback);
+        this._listeners.push([eventName, callback]);
+    }
+    addEventListenersForExistingSubscriptions() {
+        this._eventSubscriptionSubjects.forEach((subject, eventName) => this.addEventListenerToEventSource(eventName, (messageEvent) => subject.next(messageEvent)));
+    }
+    addEventListenerToEventSource(eventName, callback) {
+        this._eventSource.addEventListener(eventName, callback);
+        this._listeners.push([eventName, callback]);
+    }
+    removeAllEventListenersFromEventSource() {
+        if (!this._eventSource) {
+            this.logWarn('Cannot remove listeners: No active connection.');
+            return;
+        }
+        this._listeners.forEach(([eventName, callback]) => this._eventSource.removeEventListener(eventName, callback));
+        this._listeners = [];
+    }
+    logWarn(message) {
+        console.warn(`QD-UI | QdPushEventsService - ${message}`);
+    }
+    logError(message, err) {
+        console.error(`QD-UI | QdPushEventsService - ${message}`, err);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"push-events.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/core/services/push-events.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { NEVER, Observable, Subject } from 'rxjs';\n\ntype EventName = 'RESOURCE_CREATED' | 'RESOURCE_UPDATED' | 'RESOURCE_DELETED';\n\n/**\n * Service for handling real-time server-sent events.\n *\n * ### Benefits\n *\n * - **Real-Time Interaction**: Enables live updates without user actions or polling.\n * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.\n * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.\n *\n * ### Usage\n *\n * ```ts\n * // Start the connection to the events\n * pushEventsService.connect('http://service-endpint/events');\n *\n * // Subscribe to the event (Side Effect)\n * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));\n *\n * // Unsubscribe to prevent memory leaks\n * subscription.unsubscribe();\n *\n * // Disconnect the connection\n * pushEventsService.disconnect();\n * ```\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class QdPushEventsService {\n  private _eventSource!: EventSource;\n  private _eventSubscriptionSubjects = new Map<string, Subject<MessageEvent>>();\n  private _listeners: [string, (message: MessageEvent) => void][] = [];\n  private _heartbeatTimeout!: ReturnType<typeof setTimeout>;\n  private _reconnectDelayTime = 10000;\n  private _heartbeatReconnectDelayTime = 100;\n\n  /**\n   * Establishes an EventSource connection to the given URL.\n   * Automatically reconnects if heartbeat fails or is delayed.\n   * Subscribers are retained across reconnections.\n   *\n   * @param url The backend URL for the event stream.\n   */\n  connect(url: string): void {\n    if (this.isConnectedOrConnecting()) return;\n\n    if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED)\n      this._eventSource = new EventSource(url);\n\n    this._eventSource.onerror = (err: Event): void => {\n      if (this._eventSource.readyState === EventSource.CLOSED) this.reconnect();\n\n      this.logError('SSE connection error:', err);\n    };\n\n    this._eventSource.addEventListener('HEARTBEAT', message => {\n      if (this._heartbeatTimeout) clearTimeout(this._heartbeatTimeout);\n\n      const interval = JSON.parse(message.data).interval;\n\n      this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);\n    });\n\n    this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);\n\n    this.addEventListenersForExistingSubscriptions();\n  }\n\n  /**\n   * Closes the EventSource connection and clears all listeners.\n   * Subscribers are preserved for reconnection.\n   */\n  disconnect(): void {\n    if (!this._eventSource) {\n      this.logWarn('No active connection to disconnect.');\n\n      return;\n    }\n\n    this.removeAllEventListenersFromEventSource();\n\n    this._eventSource.close();\n  }\n\n  /**\n   * Returns an Observable for the specified event name.\n   * If not connected, returns `NEVER` and logs an error.\n   * Automatically adds a listener for the event if needed.\n   *\n   * @param eventName The event type ('RESOURCE_CREATED', 'RESOURCE_UPDATED', 'RESOURCE_DELETED').\n   * @returns Observable<MessageEvent> The event stream.\n   */\n  observe(eventName: EventName): Observable<MessageEvent> {\n    if (!this._eventSource) {\n      this.logError('Cannot observe events without a connection. Call connect() first.');\n\n      return NEVER;\n    }\n\n    if (!this._eventSubscriptionSubjects.has(eventName)) {\n      this._eventSubscriptionSubjects.set(eventName, new Subject<MessageEvent>());\n\n      this.addEventListenerForEventName(eventName);\n    }\n\n    return this._eventSubscriptionSubjects.get(eventName)!.asObservable();\n  }\n\n  /**\n   * Removes all listeners and clears all subscriptions.\n   * The EventSource connection remains open.\n   */\n  unobserveAll(): void {\n    this.removeAllEventListenersFromEventSource();\n    this._eventSubscriptionSubjects.clear();\n  }\n\n  /**\n   * Checks if the EventSource is connected or in the process of connecting.\n   */\n  isConnectedOrConnecting(): boolean {\n    return (\n      this._eventSource &&\n      (this._eventSource.readyState === EventSource.OPEN || this._eventSource.readyState === EventSource.CONNECTING)\n    );\n  }\n\n  private reconnect(): void {\n    if (!this.isConnectedOrConnecting()) {\n      this.disconnect();\n      this.connect(this._eventSource.url);\n    }\n  }\n\n  private addEventListenerForEventName(eventName: EventName): void {\n    const callback = (messageEvent: MessageEvent): void => {\n      const subject = this._eventSubscriptionSubjects.get(eventName);\n\n      if (subject) subject.next(messageEvent);\n    };\n\n    this._eventSource.addEventListener(eventName, callback);\n    this._listeners.push([eventName, callback]);\n  }\n\n  private addEventListenersForExistingSubscriptions(): void {\n    this._eventSubscriptionSubjects.forEach((subject, eventName) =>\n      this.addEventListenerToEventSource(eventName as EventName, (messageEvent: MessageEvent) =>\n        subject.next(messageEvent)\n      )\n    );\n  }\n\n  private addEventListenerToEventSource(eventName: EventName, callback: (messageEvent: MessageEvent) => void): void {\n    this._eventSource.addEventListener(eventName, callback);\n    this._listeners.push([eventName, callback]);\n  }\n\n  private removeAllEventListenersFromEventSource(): void {\n    if (!this._eventSource) {\n      this.logWarn('Cannot remove listeners: No active connection.');\n\n      return;\n    }\n\n    this._listeners.forEach(([eventName, callback]) => this._eventSource.removeEventListener(eventName, callback));\n    this._listeners = [];\n  }\n\n  private logWarn(message: string): void {\n    console.warn(`QD-UI | QdPushEventsService - ${message}`);\n  }\n\n  private logError(message: string, err?: Event): void {\n    console.error(`QD-UI | QdPushEventsService - ${message}`, err);\n  }\n}\n"]}

package/esm2022/lib/core/services/scrolling.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdScrollingService {
+    scrollIntoViewIfNeeded(element, borderDirection = 'top', targetBorderDistance = 0) {
+        this.scrollIntoView(element, borderDirection, targetBorderDistance, true);
+    }
+    scrollIntoView(element, borderDirection = 'top', targetBorderDistance = 0, onlyIfOutsideView = false) {
+        const borderDistances = this.getBorderDistances(element);
+        if (onlyIfOutsideView && this.isInViewport(borderDistances))
+            return;
+        switch (borderDirection) {
+            case 'top':
+                window.scrollBy({ behavior: 'smooth', top: -(targetBorderDistance - borderDistances.top) });
+                break;
+            case 'left':
+                window.scrollBy({ behavior: 'smooth', left: -(targetBorderDistance - borderDistances.left) });
+                break;
+            case 'right':
+                window.scrollBy({ behavior: 'smooth', left: targetBorderDistance - borderDistances.right });
+                break;
+            case 'bottom':
+                window.scrollBy({ behavior: 'smooth', top: targetBorderDistance - borderDistances.bottom });
+                break;
+        }
+    }
+    getBorderDistances(element) {
+        const boundingClientRect = element.getBoundingClientRect();
+        return {
+            top: boundingClientRect.top,
+            left: boundingClientRect.left,
+            right: (window.innerWidth || document.documentElement.clientWidth) - boundingClientRect.right,
+            bottom: (window.innerHeight || document.documentElement.clientHeight) - boundingClientRect.bottom
+        };
+    }
+    isInViewport(borderDistances) {
+        return Object.values(borderDistances).every(distance => distance > 0);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdScrollingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdScrollingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdScrollingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/translate.service.mjs

@@ -0,0 +1,48 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class QdTranslateService {
+    translateService;
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    translate(translatable) {
+        let translation;
+        if (translatable.i18n) {
+            translation = this.translateService.instant(translatable.i18n);
+        }
+        else if (translatable.translation) {
+            translation = translatable.translation[this.translateService.currentLang || 'de'];
+            if (translation === undefined) {
+                console.error(`Language "${this.translateService.currentLang}" is not implemented!`);
+            }
+        }
+        return translation || '';
+    }
+    get currentLang() {
+        return this.translateService.currentLang;
+    }
+    get onLangChange() {
+        return this.translateService.onLangChange;
+    }
+    get instant() {
+        return this.translateService.instant;
+    }
+    get use() {
+        return this.translateService.use;
+    }
+    get getTranslation() {
+        return this.translateService.getTranslation;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTranslateService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTranslateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTranslateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/tools/constantCase.tools.mjs

@@ -0,0 +1,3 @@
+import { upperCase } from 'lodash';
+export const constantCase = (str) => upperCase(str).replace(/ /g, '_');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRDYXNlLnRvb2xzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xZC11aS9zcmMvbGliL2NvcmUvdG9vbHMvY29uc3RhbnRDYXNlLnRvb2xzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFFbkMsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsR0FBVyxFQUFVLEVBQUUsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHVwcGVyQ2FzZSB9IGZyb20gJ2xvZGFzaCc7XG5cbmV4cG9ydCBjb25zdCBjb25zdGFudENhc2UgPSAoc3RyOiBzdHJpbmcpOiBzdHJpbmcgPT4gdXBwZXJDYXNlKHN0cikucmVwbGFjZSgvIC9nLCAnXycpO1xuIl19

package/esm2022/lib/core/tools/convertPxToRem.tools.mjs

@@ -0,0 +1,3 @@
+import globalVars from '../../../global-vars.json';
+export const convertPxToRem = (pixel) => `${parseFloat((pixel / globalVars.base.fontsize).toFixed(3))}rem`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydFB4VG9SZW0udG9vbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3FkLXVpL3NyYy9saWIvY29yZS90b29scy9jb252ZXJ0UHhUb1JlbS50b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFVBQVUsTUFBTSwyQkFBMkIsQ0FBQztBQUVuRCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxLQUFhLEVBQVUsRUFBRSxDQUN0RCxHQUFHLFVBQVUsQ0FBQyxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZ2xvYmFsVmFycyBmcm9tICcuLi8uLi8uLi9nbG9iYWwtdmFycy5qc29uJztcblxuZXhwb3J0IGNvbnN0IGNvbnZlcnRQeFRvUmVtID0gKHBpeGVsOiBudW1iZXIpOiBzdHJpbmcgPT5cbiAgYCR7cGFyc2VGbG9hdCgocGl4ZWwgLyBnbG9iYWxWYXJzLmJhc2UuZm9udHNpemUpLnRvRml4ZWQoMykpfXJlbWA7XG4iXX0=

package/esm2022/lib/core/tooltip/model/tooltip-content.interface.mjs

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