valtech-components 2.0.404 → 2.0.406

package/esm2022/lib/services/modal/modal.service.mjs

@@ -0,0 +1,213 @@
+import { Injectable, inject } from '@angular/core';
+import { ModalController } from '@ionic/angular/standalone';
+import { MODAL_SIZES, DEFAULT_MODAL_CONFIRM_BUTTON, DEFAULT_MODAL_CANCEL_BUTTON, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * ModalService
+ *
+ * A service for creating and managing modals with various configurations.
+ *
+ * @example Basic component modal
+ * ```typescript
+ * const result = await modalService.open({
+ *   component: MyFormComponent,
+ *   componentProps: { userId: 123 },
+ *   header: { title: 'Edit User', showCloseButton: true },
+ *   size: 'medium'
+ * });
+ *
+ * if (result.role === 'confirm') {
+ *   console.log('Saved:', result.data);
+ * }
+ * ```
+ *
+ * @example Simple content modal
+ * ```typescript
+ * await modalService.openSimple({
+ *   title: 'Terms of Service',
+ *   content: '<p>Terms content here...</p>',
+ *   size: 'large',
+ *   showCloseButton: true
+ * });
+ * ```
+ *
+ * @example Sheet modal (mobile)
+ * ```typescript
+ * const result = await modalService.openSheet({
+ *   component: FilterComponent,
+ *   breakpoints: {
+ *     initialBreakpoint: 0.5,
+ *     breakpoints: [0, 0.5, 1],
+ *     showHandle: true
+ *   }
+ * });
+ * ```
+ */
+export class ModalService {
+    constructor() {
+        this.modalController = inject(ModalController);
+    }
+    /**
+     * Opens a modal with a component.
+     * @param options - Modal configuration
+     * @returns Promise resolving to the modal result
+     */
+    async open(options) {
+        const size = MODAL_SIZES[options.size || 'medium'];
+        const cssClasses = this.buildCssClasses(options);
+        const modal = await this.modalController.create({
+            component: options.component,
+            componentProps: {
+                ...options.componentProps,
+                // Pass modal reference for dismiss from within component
+                _modalRef: {
+                    dismiss: (data, role) => modal.dismiss(data, role),
+                },
+            },
+            id: options.id,
+            showBackdrop: options.showBackdrop ?? true,
+            backdropDismiss: options.backdropDismiss ?? true,
+            keyboardClose: options.keyboardClose ?? true,
+            cssClass: cssClasses,
+            mode: options.mode,
+            animated: options.animated ?? true,
+            canDismiss: this.normalizeCanDismiss(options.canDismiss ?? true),
+            presentingElement: options.presentingElement,
+            // Sheet modal options
+            initialBreakpoint: options.breakpoints?.initialBreakpoint,
+            breakpoints: options.breakpoints?.breakpoints,
+            handle: options.breakpoints?.showHandle,
+            handleBehavior: options.breakpoints?.handleBehavior,
+        });
+        // Apply custom size styles
+        if (options.width || options.height || size) {
+            const modalEl = modal;
+            modalEl.style.setProperty('--width', options.width || size.width || 'auto');
+            modalEl.style.setProperty('--height', options.height || size.height || 'auto');
+        }
+        await modal.present();
+        const { data, role } = await modal.onDidDismiss();
+        return { data, role };
+    }
+    /**
+     * Opens a simple content modal without a custom component.
+     * Uses Ionic's alert-like styling but with modal capabilities.
+     * @param options - Simple modal configuration
+     * @returns Promise resolving to the modal result
+     */
+    async openSimple(options) {
+        // Import the simple modal component dynamically
+        const { SimpleModalContentComponent } = await import('./simple-modal-content.component');
+        return this.open({
+            component: SimpleModalContentComponent,
+            componentProps: {
+                title: options.title,
+                content: options.content,
+                buttons: options.buttons || [DEFAULT_MODAL_CANCEL_BUTTON, DEFAULT_MODAL_CONFIRM_BUTTON],
+                showCloseButton: options.showCloseButton ?? true,
+            },
+            size: options.size || 'medium',
+            backdropDismiss: options.backdropDismiss ?? true,
+            cssClass: ['simple-modal', options.cssClass].filter(Boolean).join(' '),
+        });
+    }
+    /**
+     * Opens a confirmation modal.
+     * @param title - Modal title
+     * @param message - Modal message
+     * @param confirmButton - Confirm button config (optional)
+     * @param cancelButton - Cancel button config (optional)
+     * @returns Promise resolving to true if confirmed
+     */
+    async confirm(title, message, confirmButton, cancelButton) {
+        const result = await this.openSimple({
+            title,
+            content: message,
+            size: 'small',
+            showCloseButton: false,
+            backdropDismiss: false,
+            buttons: [
+                { ...DEFAULT_MODAL_CANCEL_BUTTON, ...cancelButton },
+                { ...DEFAULT_MODAL_CONFIRM_BUTTON, ...confirmButton },
+            ],
+        });
+        return result.role === 'confirm';
+    }
+    /**
+     * Opens a sheet modal (iOS-style bottom sheet).
+     * @param options - Modal configuration with sheet-specific options
+     * @returns Promise resolving to the modal result
+     */
+    async openSheet(options) {
+        return this.open({
+            ...options,
+            breakpoints: {
+                initialBreakpoint: options.initialBreakpoint ?? 0.5,
+                breakpoints: options.breakpoints ?? [0, 0.5, 1],
+                showHandle: options.showHandle ?? true,
+            },
+            cssClass: ['sheet-modal', options.cssClass].filter(Boolean).join(' '),
+        });
+    }
+    /**
+     * Opens a fullscreen modal.
+     * @param options - Modal configuration
+     * @returns Promise resolving to the modal result
+     */
+    async openFullscreen(options) {
+        return this.open({
+            ...options,
+            size: 'full',
+            cssClass: ['fullscreen-modal', options.cssClass].filter(Boolean).join(' '),
+        });
+    }
+    /**
+     * Dismisses the top-most modal.
+     * @param data - Optional data to return
+     * @param role - Optional role
+     */
+    async dismiss(data, role) {
+        return this.modalController.dismiss(data, role);
+    }
+    /**
+     * Gets the top-most modal.
+     */
+    async getTop() {
+        return this.modalController.getTop();
+    }
+    normalizeCanDismiss(canDismiss) {
+        if (typeof canDismiss === 'boolean') {
+            return canDismiss;
+        }
+        // Wrap the function to ensure it returns a Promise
+        return async (data, role) => {
+            const result = canDismiss();
+            return Promise.resolve(result);
+        };
+    }
+    buildCssClasses(options) {
+        const classes = ['val-modal'];
+        if (options.size) {
+            classes.push(`modal-${options.size}`);
+        }
+        if (options.header) {
+            classes.push('modal-with-header');
+        }
+        if (options.footer) {
+            classes.push('modal-with-footer');
+        }
+        if (options.cssClass) {
+            classes.push(options.cssClass);
+        }
+        return classes.join(' ');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/modal/modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, Type } from '@angular/core';\nimport { ModalController } from '@ionic/angular/standalone';\nimport {\n  ModalMetadata,\n  SimpleModalMetadata,\n  ModalResult,\n  ModalButton,\n  MODAL_SIZES,\n  DEFAULT_MODAL_CONFIRM_BUTTON,\n  DEFAULT_MODAL_CANCEL_BUTTON,\n} from './types';\n\n/**\n * ModalService\n *\n * A service for creating and managing modals with various configurations.\n *\n * @example Basic component modal\n * ```typescript\n * const result = await modalService.open({\n *   component: MyFormComponent,\n *   componentProps: { userId: 123 },\n *   header: { title: 'Edit User', showCloseButton: true },\n *   size: 'medium'\n * });\n *\n * if (result.role === 'confirm') {\n *   console.log('Saved:', result.data);\n * }\n * ```\n *\n * @example Simple content modal\n * ```typescript\n * await modalService.openSimple({\n *   title: 'Terms of Service',\n *   content: '<p>Terms content here...</p>',\n *   size: 'large',\n *   showCloseButton: true\n * });\n * ```\n *\n * @example Sheet modal (mobile)\n * ```typescript\n * const result = await modalService.openSheet({\n *   component: FilterComponent,\n *   breakpoints: {\n *     initialBreakpoint: 0.5,\n *     breakpoints: [0, 0.5, 1],\n *     showHandle: true\n *   }\n * });\n * ```\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModalService {\n  private modalController = inject(ModalController);\n\n  /**\n   * Opens a modal with a component.\n   * @param options - Modal configuration\n   * @returns Promise resolving to the modal result\n   */\n  async open<T = any, R = any>(options: ModalMetadata<T>): Promise<ModalResult<R>> {\n    const size = MODAL_SIZES[options.size || 'medium'];\n    const cssClasses = this.buildCssClasses(options);\n\n    const modal = await this.modalController.create({\n      component: options.component,\n      componentProps: {\n        ...options.componentProps,\n        // Pass modal reference for dismiss from within component\n        _modalRef: {\n          dismiss: (data?: any, role?: string) => modal.dismiss(data, role),\n        },\n      },\n      id: options.id,\n      showBackdrop: options.showBackdrop ?? true,\n      backdropDismiss: options.backdropDismiss ?? true,\n      keyboardClose: options.keyboardClose ?? true,\n      cssClass: cssClasses,\n      mode: options.mode,\n      animated: options.animated ?? true,\n      canDismiss: this.normalizeCanDismiss(options.canDismiss ?? true),\n      presentingElement: options.presentingElement,\n      // Sheet modal options\n      initialBreakpoint: options.breakpoints?.initialBreakpoint,\n      breakpoints: options.breakpoints?.breakpoints,\n      handle: options.breakpoints?.showHandle,\n      handleBehavior: options.breakpoints?.handleBehavior,\n    });\n\n    // Apply custom size styles\n    if (options.width || options.height || size) {\n      const modalEl = modal as HTMLIonModalElement;\n      modalEl.style.setProperty('--width', options.width || size.width || 'auto');\n      modalEl.style.setProperty('--height', options.height || size.height || 'auto');\n    }\n\n    await modal.present();\n    const { data, role } = await modal.onDidDismiss();\n\n    return { data, role };\n  }\n\n  /**\n   * Opens a simple content modal without a custom component.\n   * Uses Ionic's alert-like styling but with modal capabilities.\n   * @param options - Simple modal configuration\n   * @returns Promise resolving to the modal result\n   */\n  async openSimple(options: SimpleModalMetadata): Promise<ModalResult> {\n    // Import the simple modal component dynamically\n    const { SimpleModalContentComponent } = await import('./simple-modal-content.component');\n\n    return this.open({\n      component: SimpleModalContentComponent,\n      componentProps: {\n        title: options.title,\n        content: options.content,\n        buttons: options.buttons || [DEFAULT_MODAL_CANCEL_BUTTON, DEFAULT_MODAL_CONFIRM_BUTTON],\n        showCloseButton: options.showCloseButton ?? true,\n      },\n      size: options.size || 'medium',\n      backdropDismiss: options.backdropDismiss ?? true,\n      cssClass: ['simple-modal', options.cssClass].filter(Boolean).join(' '),\n    });\n  }\n\n  /**\n   * Opens a confirmation modal.\n   * @param title - Modal title\n   * @param message - Modal message\n   * @param confirmButton - Confirm button config (optional)\n   * @param cancelButton - Cancel button config (optional)\n   * @returns Promise resolving to true if confirmed\n   */\n  async confirm(\n    title: string,\n    message: string,\n    confirmButton?: Partial<ModalButton>,\n    cancelButton?: Partial<ModalButton>\n  ): Promise<boolean> {\n    const result = await this.openSimple({\n      title,\n      content: message,\n      size: 'small',\n      showCloseButton: false,\n      backdropDismiss: false,\n      buttons: [\n        { ...DEFAULT_MODAL_CANCEL_BUTTON, ...cancelButton },\n        { ...DEFAULT_MODAL_CONFIRM_BUTTON, ...confirmButton },\n      ],\n    });\n\n    return result.role === 'confirm';\n  }\n\n  /**\n   * Opens a sheet modal (iOS-style bottom sheet).\n   * @param options - Modal configuration with sheet-specific options\n   * @returns Promise resolving to the modal result\n   */\n  async openSheet<T = any, R = any>(\n    options: Omit<ModalMetadata<T>, 'breakpoints'> & {\n      initialBreakpoint?: number;\n      breakpoints?: number[];\n      showHandle?: boolean;\n    }\n  ): Promise<ModalResult<R>> {\n    return this.open({\n      ...options,\n      breakpoints: {\n        initialBreakpoint: options.initialBreakpoint ?? 0.5,\n        breakpoints: options.breakpoints ?? [0, 0.5, 1],\n        showHandle: options.showHandle ?? true,\n      },\n      cssClass: ['sheet-modal', options.cssClass].filter(Boolean).join(' '),\n    });\n  }\n\n  /**\n   * Opens a fullscreen modal.\n   * @param options - Modal configuration\n   * @returns Promise resolving to the modal result\n   */\n  async openFullscreen<T = any, R = any>(options: ModalMetadata<T>): Promise<ModalResult<R>> {\n    return this.open({\n      ...options,\n      size: 'full',\n      cssClass: ['fullscreen-modal', options.cssClass].filter(Boolean).join(' '),\n    });\n  }\n\n  /**\n   * Dismisses the top-most modal.\n   * @param data - Optional data to return\n   * @param role - Optional role\n   */\n  async dismiss(data?: any, role?: string): Promise<boolean> {\n    return this.modalController.dismiss(data, role);\n  }\n\n  /**\n   * Gets the top-most modal.\n   */\n  async getTop(): Promise<HTMLIonModalElement | undefined> {\n    return this.modalController.getTop();\n  }\n\n  private normalizeCanDismiss(\n    canDismiss: boolean | (() => boolean | Promise<boolean>)\n  ): boolean | ((data?: any, role?: string) => Promise<boolean>) {\n    if (typeof canDismiss === 'boolean') {\n      return canDismiss;\n    }\n    // Wrap the function to ensure it returns a Promise\n    return async (data?: any, role?: string) => {\n      const result = canDismiss();\n      return Promise.resolve(result);\n    };\n  }\n\n  private buildCssClasses(options: ModalMetadata): string {\n    const classes: string[] = ['val-modal'];\n\n    if (options.size) {\n      classes.push(`modal-${options.size}`);\n    }\n\n    if (options.header) {\n      classes.push('modal-with-header');\n    }\n\n    if (options.footer) {\n      classes.push('modal-with-footer');\n    }\n\n    if (options.cssClass) {\n      classes.push(options.cssClass);\n    }\n\n    return classes.join(' ');\n  }\n}\n"]}

package/esm2022/lib/services/modal/simple-modal-content.component.mjs

@@ -0,0 +1,133 @@
+import { CommonModule } from '@angular/common';
+import { Component, Input } from '@angular/core';
+import { IonHeader, IonToolbar, IonTitle, IonButtons, IonButton, IonIcon, IonContent, IonFooter, IonSpinner } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { closeOutline } from 'ionicons/icons';
+import * as i0 from "@angular/core";
+addIcons({ closeOutline });
+/**
+ * Internal component for simple content modals.
+ * Used by ModalService.openSimple()
+ */
+export class SimpleModalContentComponent {
+    constructor() {
+        this.title = '';
+        this.content = '';
+        this.buttons = [];
+        this.showCloseButton = true;
+    }
+    async onButtonClick(button) {
+        if (button.handler) {
+            const result = await button.handler();
+            // If handler returns false, don't dismiss
+            if (result === false) {
+                return;
+            }
+        }
+        this._modalRef?.dismiss(undefined, button.role || 'confirm');
+    }
+    onDismiss(role) {
+        this._modalRef?.dismiss(undefined, role);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SimpleModalContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SimpleModalContentComponent, isStandalone: true, selector: "val-simple-modal-content", inputs: { title: "title", content: "content", buttons: "buttons", showCloseButton: "showCloseButton", _modalRef: "_modalRef" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-title>{{ title }}</ion-title>
+        @if (showCloseButton) {
+          <ion-buttons slot="end">
+            <ion-button (click)="onDismiss('close')">
+              <ion-icon slot="icon-only" name="close-outline"></ion-icon>
+            </ion-button>
+          </ion-buttons>
+        }
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <div [innerHTML]="content"></div>
+    </ion-content>
+
+    @if (buttons && buttons.length > 0) {
+      <ion-footer>
+        <ion-toolbar>
+          <div class="button-container">
+            @for (button of buttons; track button.text) {
+              <ion-button
+                [color]="button.color || 'medium'"
+                [fill]="button.fill || 'solid'"
+                [size]="button.size || 'default'"
+                [disabled]="button.disabled || button.loading"
+                [class]="button.cssClass"
+                (click)="onButtonClick(button)"
+              >
+                @if (button.loading) {
+                  <ion-spinner name="crescent"></ion-spinner>
+                } @else {
+                  {{ button.text }}
+                }
+              </ion-button>
+            }
+          </div>
+        </ion-toolbar>
+      </ion-footer>
+    }
+  `, isInline: true, styles: [".button-container{display:flex;justify-content:flex-end;gap:8px;padding:8px 0}ion-content{--padding-top: 16px;--padding-bottom: 16px}ion-footer ion-toolbar{--padding-start: 16px;--padding-end: 16px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonFooter, selector: "ion-footer", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SimpleModalContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-simple-modal-content', standalone: true, imports: [CommonModule, IonHeader, IonToolbar, IonTitle, IonButtons, IonButton, IonIcon, IonContent, IonFooter, IonSpinner], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-title>{{ title }}</ion-title>
+        @if (showCloseButton) {
+          <ion-buttons slot="end">
+            <ion-button (click)="onDismiss('close')">
+              <ion-icon slot="icon-only" name="close-outline"></ion-icon>
+            </ion-button>
+          </ion-buttons>
+        }
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <div [innerHTML]="content"></div>
+    </ion-content>
+
+    @if (buttons && buttons.length > 0) {
+      <ion-footer>
+        <ion-toolbar>
+          <div class="button-container">
+            @for (button of buttons; track button.text) {
+              <ion-button
+                [color]="button.color || 'medium'"
+                [fill]="button.fill || 'solid'"
+                [size]="button.size || 'default'"
+                [disabled]="button.disabled || button.loading"
+                [class]="button.cssClass"
+                (click)="onButtonClick(button)"
+              >
+                @if (button.loading) {
+                  <ion-spinner name="crescent"></ion-spinner>
+                } @else {
+                  {{ button.text }}
+                }
+              </ion-button>
+            }
+          </div>
+        </ion-toolbar>
+      </ion-footer>
+    }
+  `, styles: [".button-container{display:flex;justify-content:flex-end;gap:8px;padding:8px 0}ion-content{--padding-top: 16px;--padding-bottom: 16px}ion-footer ion-toolbar{--padding-start: 16px;--padding-end: 16px}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], buttons: [{
+                type: Input
+            }], showCloseButton: [{
+                type: Input
+            }], _modalRef: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/modal/types.mjs

@@ -0,0 +1,26 @@
+/**
+ * Default modal sizes.
+ */
+export const MODAL_SIZES = {
+    small: { width: '300px', height: 'auto' },
+    medium: { width: '500px', height: 'auto' },
+    large: { width: '800px', height: '80vh' },
+    full: { width: '100%', height: '100%' },
+    auto: { width: 'auto', height: 'auto' },
+};
+/**
+ * Default modal buttons.
+ */
+export const DEFAULT_MODAL_CONFIRM_BUTTON = {
+    text: 'Confirm',
+    role: 'confirm',
+    color: 'primary',
+    fill: 'solid',
+};
+export const DEFAULT_MODAL_CANCEL_BUTTON = {
+    text: 'Cancel',
+    role: 'cancel',
+    color: 'medium',
+    fill: 'clear',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/navigation.service.mjs

@@ -56,13 +56,13 @@ export class NavigationService {
     back() {
         this.location.back();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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