valtech-components 2.0.821 → 2.0.823

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

@@ -0,0 +1,220 @@
+import { Injectable } from '@angular/core';
+import { MODAL_SIZES, DEFAULT_MODAL_CONFIRM_BUTTON, DEFAULT_MODAL_CANCEL_BUTTON, } from './types';
+import { SimpleModalContentComponent } from './simple-modal-content.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular/standalone";
+/**
+ * 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(modalController) {
+        this.modalController = modalController;
+    }
+    /**
+     * Opens a modal with a component.
+     * @param options - Modal configuration
+     * @returns Promise resolving to the modal result
+     */
+    async open(options) {
+        // A sheet modal (breakpoints present) gets its height from the breakpoints
+        // and must span the full viewport width. Applying a size preset's
+        // `--width`/`--height` here collapses the sheet (e.g. `auto` → shrink to
+        // content) or fights the breakpoint height. So when it's a sheet we skip
+        // the size preset entirely.
+        const isSheet = !!options.breakpoints?.breakpoints?.length;
+        const size = isSheet ? undefined : 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. Skipped for sheet modals — their dimensions
+        // come from the breakpoints (Ionic spans the sheet full-width and uses the
+        // breakpoint values for height).
+        if (!isSheet && (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 || '50vh');
+        }
+        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) {
+        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: [{ token: i1.ModalController }], 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',
+                }]
+        }], ctorParameters: () => [{ type: i1.ModalController }] });
+//# 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, 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';\nimport { SimpleModalContentComponent } from './simple-modal-content.component';\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  constructor(private modalController: 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    // A sheet modal (breakpoints present) gets its height from the breakpoints\n    // and must span the full viewport width. Applying a size preset's\n    // `--width`/`--height` here collapses the sheet (e.g. `auto` → shrink to\n    // content) or fights the breakpoint height. So when it's a sheet we skip\n    // the size preset entirely.\n    const isSheet = !!options.breakpoints?.breakpoints?.length;\n    const size = isSheet ? undefined : 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. Skipped for sheet modals — their dimensions\n    // come from the breakpoints (Ionic spans the sheet full-width and uses the\n    // breakpoint values for height).\n    if (!isSheet && (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 || '50vh');\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    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: [":host{display:flex;flex-direction:column;height:100%;min-height:0}ion-header{flex-shrink:0}ion-content{flex:1 1 auto;min-height:0;--padding-top: 16px;--padding-bottom: 16px;--padding-start: 16px;--padding-end: 16px}ion-footer{flex-shrink:0}.button-container{display:flex;justify-content:flex-end;gap:8px;padding:8px 0}ion-footer ion-toolbar{--padding-start: 16px;--padding-end: 16px}:host ::ng-deep ul,:host ::ng-deep ol{padding-left:20px;margin:8px 0}:host ::ng-deep li{margin:4px 0}:host ::ng-deep p{margin:8px 0}\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: [":host{display:flex;flex-direction:column;height:100%;min-height:0}ion-header{flex-shrink:0}ion-content{flex:1 1 auto;min-height:0;--padding-top: 16px;--padding-bottom: 16px;--padding-start: 16px;--padding-end: 16px}ion-footer{flex-shrink:0}.button-container{display:flex;justify-content:flex-end;gap:8px;padding:8px 0}ion-footer ion-toolbar{--padding-start: 16px;--padding-end: 16px}:host ::ng-deep ul,:host ::ng-deep ol{padding-left:20px;margin:8px 0}:host ::ng-deep li{margin:4px 0}:host ::ng-deep p{margin:8px 0}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], buttons: [{
+                type: Input
+            }], showCloseButton: [{
+                type: Input
+            }], _modalRef: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxlLW1vZGFsLWNvbnRlbnQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9zZXJ2aWNlcy9tb2RhbC9zaW1wbGUtbW9kYWwtY29udGVudC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2pELE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQy9JLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDcEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQUc5QyxRQUFRLENBQUMsRUFBRSxZQUFZLEVBQUUsQ0FBQyxDQUFDO0FBRTNCOzs7R0FHRztBQXFHSCxNQUFNLE9BQU8sMkJBQTJCO0lBcEd4QztRQXFHVyxVQUFLLEdBQVcsRUFBRSxDQUFDO1FBQ25CLFlBQU8sR0FBVyxFQUFFLENBQUM7UUFDckIsWUFBTyxHQUFrQixFQUFFLENBQUM7UUFDNUIsb0JBQWUsR0FBWSxJQUFJLENBQUM7S0FvQjFDO0lBZkMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxNQUFtQjtRQUNyQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNuQixNQUFNLE1BQU0sR0FBRyxNQUFNLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUN0QywwQ0FBMEM7WUFDMUMsSUFBSSxNQUFNLEtBQUssS0FBSyxFQUFFLENBQUM7Z0JBQ3JCLE9BQU87WUFDVCxDQUFDO1FBQ0gsQ0FBQztRQUVELElBQUksQ0FBQyxTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsSUFBSSxJQUFJLFNBQVMsQ0FBQyxDQUFDO0lBQy9ELENBQUM7SUFFRCxTQUFTLENBQUMsSUFBWTtRQUNwQixJQUFJLENBQUMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDM0MsQ0FBQzsrR0F2QlUsMkJBQTJCO21HQUEzQiwyQkFBMkIsb05BaEc1Qjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMENULDhrQkEzQ1MsWUFBWSwrQkFBRSxTQUFTLG9HQUFFLFVBQVUsbUZBQUUsUUFBUSxpRkFBRSxVQUFVLDhFQUFFLFNBQVMsb1BBQUUsT0FBTywySkFBRSxVQUFVLHdLQUFFLFNBQVMsb0dBQUUsVUFBVTs7NEZBaUcvRywyQkFBMkI7a0JBcEd2QyxTQUFTOytCQUNFLDBCQUEwQixjQUN4QixJQUFJLFdBQ1AsQ0FBQyxZQUFZLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxVQUFVLENBQUMsWUFDakg7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBDVDs4QkF1RFEsS0FBSztzQkFBYixLQUFLO2dCQUNHLE9BQU87c0JBQWYsS0FBSztnQkFDRyxPQUFPO3NCQUFmLEtBQUs7Z0JBQ0csZUFBZTtzQkFBdkIsS0FBSztnQkFHRyxTQUFTO3NCQUFqQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IElvbkhlYWRlciwgSW9uVG9vbGJhciwgSW9uVGl0bGUsIElvbkJ1dHRvbnMsIElvbkJ1dHRvbiwgSW9uSWNvbiwgSW9uQ29udGVudCwgSW9uRm9vdGVyLCBJb25TcGlubmVyIH0gZnJvbSAnQGlvbmljL2FuZ3VsYXIvc3RhbmRhbG9uZSc7XG5pbXBvcnQgeyBhZGRJY29ucyB9IGZyb20gJ2lvbmljb25zJztcbmltcG9ydCB7IGNsb3NlT3V0bGluZSB9IGZyb20gJ2lvbmljb25zL2ljb25zJztcbmltcG9ydCB7IE1vZGFsQnV0dG9uIH0gZnJvbSAnLi90eXBlcyc7XG5cbmFkZEljb25zKHsgY2xvc2VPdXRsaW5lIH0pO1xuXG4vKipcbiAqIEludGVybmFsIGNvbXBvbmVudCBmb3Igc2ltcGxlIGNvbnRlbnQgbW9kYWxzLlxuICogVXNlZCBieSBNb2RhbFNlcnZpY2Uub3BlblNpbXBsZSgpXG4gKi9cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3ZhbC1zaW1wbGUtbW9kYWwtY29udGVudCcsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIElvbkhlYWRlciwgSW9uVG9vbGJhciwgSW9uVGl0bGUsIElvbkJ1dHRvbnMsIElvbkJ1dHRvbiwgSW9uSWNvbiwgSW9uQ29udGVudCwgSW9uRm9vdGVyLCBJb25TcGlubmVyXSxcbiAgdGVtcGxhdGU6IGBcbiAgICA8aW9uLWhlYWRlcj5cbiAgICAgIDxpb24tdG9vbGJhcj5cbiAgICAgICAgPGlvbi10aXRsZT57eyB0aXRsZSB9fTwvaW9uLXRpdGxlPlxuICAgICAgICBAaWYgKHNob3dDbG9zZUJ1dHRvbikge1xuICAgICAgICAgIDxpb24tYnV0dG9ucyBzbG90PVwiZW5kXCI+XG4gICAgICAgICAgICA8aW9uLWJ1dHRvbiAoY2xpY2spPVwib25EaXNtaXNzKCdjbG9zZScpXCI+XG4gICAgICAgICAgICAgIDxpb24taWNvbiBzbG90PVwiaWNvbi1vbmx5XCIgbmFtZT1cImNsb3NlLW91dGxpbmVcIj48L2lvbi1pY29uPlxuICAgICAgICAgICAgPC9pb24tYnV0dG9uPlxuICAgICAgICAgIDwvaW9uLWJ1dHRvbnM+XG4gICAgICAgIH1cbiAgICAgIDwvaW9uLXRvb2xiYXI+XG4gICAgPC9pb24taGVhZGVyPlxuXG4gICAgPGlvbi1jb250ZW50IGNsYXNzPVwiaW9uLXBhZGRpbmdcIj5cbiAgICAgIDxkaXYgW2lubmVySFRNTF09XCJjb250ZW50XCI+PC9kaXY+XG4gICAgPC9pb24tY29udGVudD5cblxuICAgIEBpZiAoYnV0dG9ucyAmJiBidXR0b25zLmxlbmd0aCA+IDApIHtcbiAgICAgIDxpb24tZm9vdGVyPlxuICAgICAgICA8aW9uLXRvb2xiYXI+XG4gICAgICAgICAgPGRpdiBjbGFzcz1cImJ1dHRvbi1jb250YWluZXJcIj5cbiAgICAgICAgICAgIEBmb3IgKGJ1dHRvbiBvZiBidXR0b25zOyB0cmFjayBidXR0b24udGV4dCkge1xuICAgICAgICAgICAgICA8aW9uLWJ1dHRvblxuICAgICAgICAgICAgICAgIFtjb2xvcl09XCJidXR0b24uY29sb3IgfHwgJ21lZGl1bSdcIlxuICAgICAgICAgICAgICAgIFtmaWxsXT1cImJ1dHRvbi5maWxsIHx8ICdzb2xpZCdcIlxuICAgICAgICAgICAgICAgIFtzaXplXT1cImJ1dHRvbi5zaXplIHx8ICdkZWZhdWx0J1wiXG4gICAgICAgICAgICAgICAgW2Rpc2FibGVkXT1cImJ1dHRvbi5kaXNhYmxlZCB8fCBidXR0b24ubG9hZGluZ1wiXG4gICAgICAgICAgICAgICAgW2NsYXNzXT1cImJ1dHRvbi5jc3NDbGFzc1wiXG4gICAgICAgICAgICAgICAgKGNsaWNrKT1cIm9uQnV0dG9uQ2xpY2soYnV0dG9uKVwiXG4gICAgICAgICAgICAgID5cbiAgICAgICAgICAgICAgICBAaWYgKGJ1dHRvbi5sb2FkaW5nKSB7XG4gICAgICAgICAgICAgICAgICA8aW9uLXNwaW5uZXIgbmFtZT1cImNyZXNjZW50XCI+PC9pb24tc3Bpbm5lcj5cbiAgICAgICAgICAgICAgICB9IEBlbHNlIHtcbiAgICAgICAgICAgICAgICAgIHt7IGJ1dHRvbi50ZXh0IH19XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICA8L2lvbi1idXR0b24+XG4gICAgICAgICAgICB9XG4gICAgICAgICAgPC9kaXY+XG4gICAgICAgIDwvaW9uLXRvb2xiYXI+XG4gICAgICA8L2lvbi1mb290ZXI+XG4gICAgfVxuICBgLFxuICBzdHlsZXM6IFtgXG4gICAgOmhvc3Qge1xuICAgICAgZGlzcGxheTogZmxleDtcbiAgICAgIGZsZXgtZGlyZWN0aW9uOiBjb2x1bW47XG4gICAgICBoZWlnaHQ6IDEwMCU7XG4gICAgICBtaW4taGVpZ2h0OiAwO1xuICAgIH1cblxuICAgIGlvbi1oZWFkZXIge1xuICAgICAgZmxleC1zaHJpbms6IDA7XG4gICAgfVxuXG4gICAgaW9uLWNvbnRlbnQge1xuICAgICAgZmxleDogMSAxIGF1dG87XG4gICAgICBtaW4taGVpZ2h0OiAwO1xuICAgICAgLS1wYWRkaW5nLXRvcDogMTZweDtcbiAgICAgIC0tcGFkZGluZy1ib3R0b206IDE2cHg7XG4gICAgICAtLXBhZGRpbmctc3RhcnQ6IDE2cHg7XG4gICAgICAtLXBhZGRpbmctZW5kOiAxNnB4O1xuICAgIH1cblxuICAgIGlvbi1mb290ZXIge1xuICAgICAgZmxleC1zaHJpbms6IDA7XG4gICAgfVxuXG4gICAgLmJ1dHRvbi1jb250YWluZXIge1xuICAgICAgZGlzcGxheTogZmxleDtcbiAgICAgIGp1c3RpZnktY29udGVudDogZmxleC1lbmQ7XG4gICAgICBnYXA6IDhweDtcbiAgICAgIHBhZGRpbmc6IDhweCAwO1xuICAgIH1cblxuICAgIGlvbi1mb290ZXIgaW9uLXRvb2xiYXIge1xuICAgICAgLS1wYWRkaW5nLXN0YXJ0OiAxNnB4O1xuICAgICAgLS1wYWRkaW5nLWVuZDogMTZweDtcbiAgICB9XG5cbiAgICAvKiBMaXN0IHN0eWxpbmcgZm9yIGlubmVySFRNTCBjb250ZW50ICovXG4gICAgOmhvc3QgOjpuZy1kZWVwIHVsLFxuICAgIDpob3N0IDo6bmctZGVlcCBvbCB7XG4gICAgICBwYWRkaW5nLWxlZnQ6IDIwcHg7XG4gICAgICBtYXJnaW46IDhweCAwO1xuICAgIH1cblxuICAgIDpob3N0IDo6bmctZGVlcCBsaSB7XG4gICAgICBtYXJnaW46IDRweCAwO1xuICAgIH1cblxuICAgIDpob3N0IDo6bmctZGVlcCBwIHtcbiAgICAgIG1hcmdpbjogOHB4IDA7XG4gICAgfVxuICBgXSxcbn0pXG5leHBvcnQgY2xhc3MgU2ltcGxlTW9kYWxDb250ZW50Q29tcG9uZW50IHtcbiAgQElucHV0KCkgdGl0bGU6IHN0cmluZyA9ICcnO1xuICBASW5wdXQoKSBjb250ZW50OiBzdHJpbmcgPSAnJztcbiAgQElucHV0KCkgYnV0dG9uczogTW9kYWxCdXR0b25bXSA9IFtdO1xuICBASW5wdXQoKSBzaG93Q2xvc2VCdXR0b246IGJvb2xlYW4gPSB0cnVlO1xuXG4gIC8vIEluamVjdGVkIGJ5IE1vZGFsU2VydmljZVxuICBASW5wdXQoKSBfbW9kYWxSZWY6IHsgZGlzbWlzczogKGRhdGE/OiBhbnksIHJvbGU/OiBzdHJpbmcpID0+IFByb21pc2U8Ym9vbGVhbj4gfTtcblxuICBhc3luYyBvbkJ1dHRvbkNsaWNrKGJ1dHRvbjogTW9kYWxCdXR0b24pOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBpZiAoYnV0dG9uLmhhbmRsZXIpIHtcbiAgICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IGJ1dHRvbi5oYW5kbGVyKCk7XG4gICAgICAvLyBJZiBoYW5kbGVyIHJldHVybnMgZmFsc2UsIGRvbid0IGRpc21pc3NcbiAgICAgIGlmIChyZXN1bHQgPT09IGZhbHNlKSB7XG4gICAgICAgIHJldHVybjtcbiAgICAgIH1cbiAgICB9XG5cbiAgICB0aGlzLl9tb2RhbFJlZj8uZGlzbWlzcyh1bmRlZmluZWQsIGJ1dHRvbi5yb2xlIHx8ICdjb25maXJtJyk7XG4gIH1cblxuICBvbkRpc21pc3Mocm9sZTogc3RyaW5nKTogdm9pZCB7XG4gICAgdGhpcy5fbW9kYWxSZWY/LmRpc21pc3ModW5kZWZpbmVkLCByb2xlKTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,26 @@
+/**
+ * Default modal sizes.
+ */
+export const MODAL_SIZES = {
+    small: { width: '320px', height: '220px' },
+    medium: { width: '500px', height: '400px' },
+    large: { width: '800px', height: '80vh' },
+    full: { width: '100%', height: '100%' },
+    auto: { width: 'auto', height: '50vh' },
+};
+/**
+ * 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/index.mjs

@@ -0,0 +1,3 @@
+export * from './navigation.service';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL25hdmlnYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbmF2aWdhdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19