@yuuvis/client-core 2.2.0 → 2.3.1

package/index.d.ts

@@ -39,8 +39,7 @@ export * from './lib/service/logger/logger.interface';
 export * from './lib/service/notification/notification.service';
 export * from './lib/service/object-config/object-config.interface';
 export * from './lib/service/object-config/object-config.service';
-export * from './lib/service/pending-changes/pending-changes-guard.service';
-export * from './lib/service/pending-changes/pending-changes.service';
+export * from './lib/service/pending-changes';
 export * from './lib/service/prediction/prediction.interface';
 export * from './lib/service/prediction/prediction.service';
 export * from './lib/service/retention/retention.service';

package/lib/service/pending-changes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './pending-changes-guard.service';
+export * from './pending-changes-dialog.guard.service';
+export * from './pending-changes.service';
+export * from './pending-changes-tab.guard.directive';

package/lib/service/pending-changes/pending-changes-dialog.guard.service.d.ts

@@ -0,0 +1,128 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service that provides guards for Material Dialog close operations.
+ *
+ * This service allows you to intercept and control dialog close events,
+ * enabling confirmation dialogs or preventing accidental closure when
+ * there are unsaved changes or pending operations.
+ *
+ * @example
+ * ```typescript
+ * readonly #dialogCloseGuard = inject(DialogCloseGuard);
+ *
+ * openDialog() {
+ *   const dialogRef = this.dialog.open(MyComponent);
+ *
+ *   // Prevent dialog from closing if there are unsaved changes
+ *   this.#dialogCloseGuard.dialogCanClose(dialogRef, () => {
+ *     return this.hasUnsavedChanges() ? this.confirmClose() : true;
+ *   }).subscribe();
+ * }
+ * ```
+ */
+export declare class DialogCloseGuard {
+    #private;
+    /**
+     * Guards against dialog closure when the backdrop is clicked.
+     *
+     * This method disables the default close behavior and only allows the dialog
+     * to close when the provided check function returns true. The check is triggered
+     * specifically when the user clicks on the dialog backdrop.
+     *
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @param checkFunction - Function that determines if the dialog can be closed.
+     *                        Can return a boolean directly or an Observable<boolean>
+     * @returns Observable<boolean> - Emits true when the dialog can be closed via backdrop click
+     *
+     * @example
+     * ```typescript
+     * this.dialogCloseGuard.checkBackdropCanClose(dialogRef, () => {
+     *   return this.formIsDirty ? this.showConfirmDialog() : true;
+     * }).subscribe(canClose => {
+     *   if (canClose) {
+     *     dialogRef.close();
+     *   }
+     * });
+     * ```
+     */
+    checkBackdropCanClose(dialogRef: MatDialogRef<any>, checkFunction: () => boolean | Observable<boolean>): Observable<boolean>;
+    /**
+     * Guards against dialog closure when the Escape key is pressed.
+     *
+     * This method disables the default close behavior and only allows the dialog
+     * to close when the provided check function returns true. The check is triggered
+     * specifically when the user presses the Escape key.
+     *
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @param checkFunction - Function that determines if the dialog can be closed.
+     *                        Can return a boolean directly or an Observable<boolean>
+     * @returns Observable<boolean> - Emits true when the dialog can be closed via Escape key
+     *
+     * @example
+     * ```typescript
+     * this.dialogCloseGuard.checkKeydownEventsCanClose(dialogRef, () => {
+     *   return this.hasUnsavedChanges ? this.confirmDiscardChanges() : true;
+     * }).subscribe(canClose => {
+     *   if (canClose) {
+     *     dialogRef.close();
+     *   }
+     * });
+     * ```
+     */
+    checkKeydownEventsCanClose(dialogRef: MatDialogRef<any>, checkFunction: () => boolean | Observable<boolean>): Observable<boolean>;
+    /**
+     * Comprehensive dialog close guard that handles both backdrop clicks and Escape key presses.
+     *
+     * This method provides a unified approach to guard dialog closure by monitoring both
+     * backdrop clicks and Escape key events. When either event occurs, it runs the provided
+     * check function and automatically closes the dialog if the check passes.
+     *
+     * This is the most convenient method when you want to guard against all common
+     * dialog close scenarios with a single setup.
+     *
+     * @template T - The type of data that the dialog returns
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @param checkFunction - Function that determines if the dialog can be closed.
+     *                        Can return a boolean directly or an Observable<boolean>
+     * @returns Observable<false | void> - Emits false if the dialog cannot be closed,
+     *                                    or void when the dialog is successfully closed
+     *
+     * @example
+     * ```typescript
+     * // Simple boolean check
+     * this.dialogCloseGuard.dialogCanClose(dialogRef, () => !this.hasUnsavedChanges).subscribe();
+     *
+     * // Async check with confirmation dialog
+     * this.dialogCloseGuard.dialogCanClose(dialogRef, () => {
+     *   return this.hasUnsavedChanges
+     *     ? this.confirmationService.confirm('Discard changes?')
+     *     : of(true);
+     * }).subscribe();
+     * ```
+     */
+    preventCloseUntil<T>(dialogRef: MatDialogRef<T>, checkFunction: () => boolean | Observable<boolean>): Observable<false | void>;
+    /**
+     * Specialized dialog close guard that automatically checks for pending changes.
+     *
+     * This convenience method provides automatic pending changes detection without
+     * requiring a custom check function. It integrates with the PendingChangesService
+     * to determine if there are any unsaved changes, and handles both backdrop clicks
+     * and Escape key presses automatically.
+     *
+     * This method is ideal when you want to prevent dialog closure if there are
+     * pending changes anywhere in the application, without having to implement
+     * custom change detection logic.
+     *
+     * @template T - The type of data that the dialog returns
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @returns Observable<false | void> - Emits false if there are pending changes
+     *                                    preventing closure, or void when the dialog
+     *                                    is successfully closed
+     *
+     */
+    pendingChangesDialogCanClose<T>(dialogRef: MatDialogRef<T>): Observable<false | void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogCloseGuard>;
+}

package/lib/service/pending-changes/pending-changes-tab.guard.directive.d.ts

@@ -0,0 +1,9 @@
+import { DoCheck } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TabGuardDirective implements DoCheck {
+    #private;
+    constructor();
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabGuardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabGuardDirective, "mat-tab-group[yuvTabGuardDisable]", never, {}, {}, never, never, true, never>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuuvis/client-core",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "author": "OPTIMAL SYSTEMS GmbH <npm@optimal-systems.de>",
   "license": "MIT",
   "peerDependencies": {