@kirbydesign/designsystem 11.0.0 → 11.1.1

package/modal/index.d.ts

@@ -1,6 +1,494 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, InjectionToken, OnInit, TemplateRef, Injector, ChangeDetectorRef, Renderer2, NgZone, EnvironmentInjector, OnChanges, EventEmitter, SimpleChanges } from '@angular/core';
+import { ActivatedRoute, Router, Routes, Params, Route, Data, CanDeactivateFn } from '@angular/router';
+import { KirbyAnimation, ThemeColor, PlatformService } from '@kirbydesign/designsystem/helpers';
+import { Observable } from 'rxjs';
+import { ModalController as ModalController$1, AnimationBuilder, IonContent } from '@ionic/angular/standalone';
+import { WindowRef } from '@kirbydesign/designsystem/types';
+import { OverlayEventDetail as OverlayEventDetail$1 } from '@ionic/core/components';
+import { TranslationService, ResizeObserverService } from '@kirbydesign/designsystem/shared';
+
+interface OverlayEventDetail<T = any> {
+    data?: T;
+    role?: string;
+}
+interface Overlay {
+    dismiss: (data?: any) => Promise<boolean>;
+    onWillDismiss: Promise<OverlayEventDetail>;
+    onDidDismiss: Promise<OverlayEventDetail>;
+    isDismissing?: boolean;
+}
+interface ModalRouteActivation {
+    route: ActivatedRoute;
+    isNewModal: boolean;
+}
+declare abstract class Modal {
+    didPresent: Promise<void>;
+    willClose: Promise<void>;
+    close: (data?: any) => Promise<void>;
+    scrollToTop: (scrollDuration?: KirbyAnimation.Duration) => void;
+    scrollToBottom: (scrollDuration?: KirbyAnimation.Duration) => void;
+    scrollDisabled: boolean;
+    canDismiss: ShowAlertCallback;
+}
 /**
- * Generated bundle index. Do not edit.
+ * WARNING: This is for internal use only and should not be used outside of Kirby.
  */
-/// <amd-module name="@kirbydesign/designsystem/modal" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-modal.d.ts.map
+declare enum ModalElementType {
+    PAGE_PROGRESS = 0,
+    FOOTER = 1,
+    TITLE = 2
+}
+/**
+ * WARNING: This is for internal use only and should not be used outside of Kirby.
+ */
+declare abstract class ModalElementsAdvertiser {
+    addModalElement: (type: ModalElementType, elementRef: ElementRef<HTMLElement>) => void;
+    removeModalElement: (type: ModalElementType, elementRef: ElementRef<HTMLElement>) => void;
+}
+/**
+ * WARNING: This is for internal use only and should not be used outside of Kirby.
+ */
+declare abstract class ModalElementComponent implements AfterViewInit, OnDestroy {
+    private modalElementType;
+    private elementRef;
+    private modalElementsAdvertiser;
+    private get isContainedInModal();
+    constructor(modalElementType: ModalElementType, elementRef: ElementRef<HTMLElement>, modalElementsAdvertiser: ModalElementsAdvertiser);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalElementComponent, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalElementComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+interface ActionSheetItem {
+    id: string;
+    text: string;
+}
+
+interface ActionSheetConfig {
+    header?: string;
+    subheader?: string;
+    items: Array<ActionSheetItem>;
+    cancelButtonText?: string;
+}
+
+interface AlertConfig {
+    title: string | Observable<string>;
+    message?: string | Observable<string>;
+    cancelBtn?: string | Observable<string>;
+    icon?: {
+        name: string;
+        themeColor?: string;
+    };
+    okBtn?: string | Observable<string> | {
+        text: string | Observable<string>;
+        isDestructive: boolean;
+    };
+}
+
+declare class ModalNavigationService {
+    private router;
+    private route;
+    constructor(router: Router, route: ActivatedRoute);
+    isModalRoute(url: string): boolean;
+    private getCurrentActivatedRoute;
+    private getModalRoutes;
+    private getModuleRootPath;
+    private getCurrentRoutePaths;
+    private getRoutePathsWithoutChildSegments;
+    private findChildRouteForUrl;
+    private pathContainsChildRouteWithUrlParams;
+    private getRoutePaths;
+    private getRoutePath;
+    private getModalRoutePath;
+    private getModalRoutePaths;
+    private isNewModalWindow;
+    private navigationEndListener$;
+    private waitForCurrentThenGetNavigationEndStream;
+    private modalRouteActivatedFor;
+    private modalRouteDeactivatedFor;
+    private modalRouteSetContainsPath;
+    getModalNavigation(routeConfig: Routes[], moduleRootRoutePath?: string): Promise<{
+        activated$: Observable<ModalRouteActivation>;
+        deactivated$: Observable<boolean>;
+    }>;
+    navigateToModal(path: string | string[], queryParams?: Params): Promise<boolean>;
+    navigateWithinModal(relativePath: string, queryParams?: Params): Promise<boolean>;
+    navigateOutOfModalOutlet(): Promise<boolean>;
+    private getBackdropRoute;
+    handleBrowserBackButton(modal: HTMLIonModalElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalNavigationService>;
+}
+
+declare class DrawerSupplementaryAction {
+    iconName: string;
+    action: Function;
+}
+
+type ModalFlavor = 'modal' | 'drawer' | 'compact';
+type ModalSize = 'small' | 'medium' | 'large' | 'full-height';
+type ShowAlertCallback = () => boolean | AlertConfig | Promise<boolean | AlertConfig>;
+interface ModalConfig {
+    collapseTitle?: boolean;
+    component?: any;
+    size?: ModalSize;
+    customHeight?: string;
+    modalRoute?: ActivatedRoute;
+    siblingModalRouteActivated$?: Observable<ActivatedRoute>;
+    flavor?: ModalFlavor;
+    componentProps?: {
+        [key: string]: any;
+    };
+    canDismiss?: ShowAlertCallback;
+    drawerSupplementaryAction?: DrawerSupplementaryAction;
+    interactWithBackground?: boolean;
+    cssClass?: string | string[];
+    htmlAttributes?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Here we extend Data and Route from Angular to create a covariant type ModalEnabledRoutes.
+ * This can be used in place of the Routes type when configuring route-based modals in the array
+ * of routes passed to RouterModule in applications.
+ */
+type RoutedModalConfig = Omit<ModalConfig, 'component'>;
+interface ModalConfigRouteData extends Data {
+    modalConfig?: RoutedModalConfig;
+}
+interface ModalEnabledRoute extends Route {
+    data?: ModalConfigRouteData;
+    children?: ModalEnabledRoutes;
+}
+type ModalEnabledRoutes = ModalEnabledRoute[];
+
+declare const COMPONENT_PROPS: InjectionToken<string>;
+
+declare class AlertComponent implements AfterViewInit {
+    private elementRef;
+    private windowRef;
+    readonly BLUR_WRAPPER_DELAY_IN_MS = 50;
+    private alertWrapper;
+    private scrollY;
+    title$: Observable<string>;
+    set title(title: string | Observable<string>);
+    message$: Observable<string>;
+    set message(message: string | Observable<string>);
+    iconName: string;
+    iconThemeColor: ThemeColor | `${ThemeColor}`;
+    okBtn$: Observable<string>;
+    set okBtn(okBtn: string | Observable<string>);
+    okBtnIsDestructive: boolean;
+    cancelBtn$: Observable<string>;
+    set cancelBtn(cancelBtn: string | Observable<string>);
+    constructor(elementRef: ElementRef<HTMLElement>, windowRef: WindowRef);
+    ngAfterViewInit(): void;
+    onFocusChange(): void;
+    onCancel(): void;
+    onOk(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "kirby-alert", never, { "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "iconThemeColor": { "alias": "iconThemeColor"; "required": false; }; "okBtn": { "alias": "okBtn"; "required": false; }; "okBtnIsDestructive": { "alias": "okBtnIsDestructive"; "required": false; }; "cancelBtn": { "alias": "cancelBtn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AlertHelper {
+    private ionicModalController;
+    constructor(ionicModalController: ModalController$1);
+    showAlert(config: AlertConfig): Promise<Overlay>;
+    private getComponentProps;
+    private getOkBtn;
+    getOkBtnIsDestructive(config: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertHelper>;
+}
+
+declare class CanDismissHelper {
+    private alertHelper;
+    constructor(alertHelper: AlertHelper);
+    getCanDismissCallback(callback: ShowAlertCallback): () => Promise<boolean>;
+    showAlert(config: AlertConfig): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanDismissHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanDismissHelper>;
+}
+
+declare class ModalWrapperComponent implements Modal, AfterViewInit, OnInit, OnDestroy, ModalElementsAdvertiser {
+    private changeDetector;
+    private injector;
+    private elementRef;
+    private renderer;
+    private zone;
+    private resizeObserverService;
+    private windowRef;
+    private platform;
+    private canDismissHelper;
+    private environmentInjector;
+    translations: TranslationService;
+    get _hasCollapsibleTitle(): boolean;
+    static readonly KEYBOARD_HIDE_DELAY_IN_MS = 100;
+    scrollY: number;
+    private readonly VIEWPORT_RESIZE_DEBOUNCE_TIME;
+    set scrollDisabled(disabled: boolean);
+    set canDismiss(callback: ShowAlertCallback);
+    config: ModalConfig;
+    content: TemplateRef<any>;
+    componentPropsInjector: Injector;
+    modalWrapperInjector: Injector;
+    templateRef: TemplateRef<any>;
+    private toolbarButtonsQuery;
+    private ionContent;
+    private ionContentElement;
+    private ionHeaderElement;
+    private ionToolbarElement;
+    private ionTitleElement;
+    private routerOutlet;
+    private _contentTitleElement;
+    get contentTitleElement(): ElementRef<HTMLElement>;
+    private keyboardVisible;
+    private toolbarButtons;
+    private delayedClose;
+    private delayedCloseTimeoutId;
+    private initialViewportHeight;
+    private viewportResized;
+    private ionModalElement?;
+    private ionModalDialog?;
+    private readonly ionModalDidPresent;
+    readonly didPresent: Promise<void>;
+    private readonly ionModalWillDismiss;
+    readonly willClose: Promise<void>;
+    private viewportResize;
+    private viewportResize$;
+    private mutationObserverUnobserveFn;
+    private _intersectionObserver;
+    private get intersectionObserver();
+    scrollEventsEnabled: boolean;
+    isContentScrolled: boolean;
+    private destroy$;
+    get _isDrawer(): boolean;
+    willClose$: Observable<void>;
+    private modalElementsMoverDelegate;
+    constructor(changeDetector: ChangeDetectorRef, injector: Injector, elementRef: ElementRef<HTMLElement>, renderer: Renderer2, zone: NgZone, resizeObserverService: ResizeObserverService, windowRef: WindowRef, platform: PlatformService, canDismissHelper: CanDismissHelper, environmentInjector: EnvironmentInjector, translations: TranslationService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private _currentFooter;
+    private set currentFooter(value);
+    private get currentFooter();
+    addModalElement(type: ModalElementType, modalElement: ElementRef<HTMLElement>): void;
+    removeModalElement(type: ModalElementType, modalElement: ElementRef<HTMLElement>): void;
+    private initializeResizeModalToModalWrapper;
+    private initializeSizing;
+    private initializeModalRoute;
+    private onSiblingModalRouteActivated;
+    private patchScrollElementSize;
+    private observeModalFullHeight;
+    private getIonModalWrapperElement;
+    private observeHeaderResize;
+    private listenForIonModalDidPresent;
+    private listenForIonModalWillDismiss;
+    private listenForScroll;
+    private observeTitleContentChanges;
+    private setAriaLabelFromTitleContent;
+    private setAriaLabel;
+    private focusModalTitle;
+    scrollToTop(scrollDuration?: KirbyAnimation.Duration): void;
+    scrollToBottom(scrollDuration?: KirbyAnimation.Duration): void;
+    close(data?: any): Promise<void>;
+    onFocusChange(): void;
+    _onKeyboardShow(keyboardHeight: number): void;
+    _onKeyboardHide(): void;
+    private toggleContentMaxHeight;
+    private setKeyboardVisibility;
+    private getKeyboardOverlap;
+    private setCssVar;
+    private toggleCssClass;
+    private setKeyboardOverlap;
+    onHeaderTouchStart(event: TouchEvent): void;
+    _onWindowResize(): void;
+    private setViewportHeight;
+    private observeViewportResize;
+    private onViewportResize;
+    blurActiveElement(): void;
+    private createModalWrapperIntersectionObserver;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalWrapperComponent, "kirby-modal-wrapper", never, { "scrollDisabled": { "alias": "scrollDisabled"; "required": false; }; "config": { "alias": "config"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, ["templateRef"], never, true, never>;
+}
+
+declare class ModalCompactWrapperComponent implements Modal, OnInit {
+    private injector;
+    private elementRef;
+    private windowRef;
+    private canDismissHelper;
+    private renderer;
+    config: ModalConfig;
+    content: TemplateRef<any>;
+    scrollY: number;
+    scrollDisabled: boolean;
+    componentPropsInjector: Injector;
+    private ionModalElement;
+    private readonly ionModalDidPresent;
+    private readonly ionModalWillDismiss;
+    readonly didPresent: Promise<void>;
+    readonly willClose: Promise<void>;
+    constructor(injector: Injector, elementRef: ElementRef<HTMLElement>, windowRef: WindowRef, canDismissHelper: CanDismissHelper, renderer: Renderer2);
+    ngOnInit(): void;
+    private listenForIonModalDidPresent;
+    private listenForIonModalWillDismiss;
+    private setAriaLabel;
+    close(data?: any): Promise<void>;
+    set canDismiss(callback: ShowAlertCallback);
+    scrollToTop: (_?: any) => void;
+    scrollToBottom: (_?: any) => void;
+    onFocusChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalCompactWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalCompactWrapperComponent, "kirby-modal-compact-wrapper", never, { "config": { "alias": "config"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ActionSheetHelper {
+    private ionicModalController;
+    constructor(ionicModalController: ModalController$1);
+    showActionSheet(config: ActionSheetConfig): Promise<Overlay>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionSheetHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionSheetHelper>;
+}
+
+declare class ModalAnimationBuilderService {
+    private platform;
+    constructor(platform: PlatformService);
+    private readonly easingEnter;
+    private readonly easingLeave;
+    private readonly duration;
+    private readonly SwipeToCloseDefaults;
+    enterAnimation(currentBackdrop?: HTMLIonBackdropElement): AnimationBuilder;
+    leaveAnimation(currentBackdrop?: HTMLIonBackdropElement): AnimationBuilder;
+    private createEnterAnimation;
+    private createLeaveAnimation;
+    /**
+     * Gets the root context of a shadow dom element
+     * On newer browsers this will be the shadowRoot,
+     * but for older browser this may just be the
+     * element itself.
+     *
+     * Useful for whenever you need to explicitly
+     * do "myElement.shadowRoot!.querySelector(...)".
+     */
+    private getElementRoot;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalAnimationBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalAnimationBuilderService>;
+}
+
+declare class ModalHelper {
+    private ionicModalController;
+    private modalAnimationBuilder;
+    private modalNavigationService;
+    private windowRef;
+    private canDismissHelper;
+    constructor(ionicModalController: ModalController$1, modalAnimationBuilder: ModalAnimationBuilderService, modalNavigationService: ModalNavigationService, windowRef: WindowRef, canDismissHelper: CanDismissHelper);
+    private isModalOpening;
+    showModalWindow(config: ModalConfig): Promise<Overlay>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalHelper>;
+}
+
+declare class ModalController implements OnDestroy {
+    private modalHelper;
+    private actionSheetHelper;
+    private alertHelper;
+    private modalNavigationService;
+    private routeConfig;
+    private overlays;
+    private readonly noOverlayRegisteredErrorMessage;
+    private destroy$;
+    constructor(modalHelper: ModalHelper, actionSheetHelper: ActionSheetHelper, alertHelper: AlertHelper, modalNavigationService: ModalNavigationService, routeConfig: Routes[]);
+    initialize(moduleRootRoutePath?: string): Promise<void>;
+    private onModalRouteActivated;
+    private onModalRouteDeactivated;
+    showModal(config: ModalConfig, onClose?: (data?: any) => void): Promise<void>;
+    navigateToModal(path: string | string[], queryParams?: Params): Promise<boolean>;
+    navigateWithinModal(relativePath: string, queryParams?: Params): Promise<boolean>;
+    private showModalRoute;
+    showActionSheet(config: ActionSheetConfig, onClose?: (data?: any) => void): Promise<void>;
+    showAlert(config: AlertConfig, onClose?: (result: boolean) => void): Promise<void>;
+    private showAndRegisterOverlay;
+    hideTopmost(data?: any): Promise<boolean>;
+    hideAll(): Promise<void>;
+    getTopMost(): Overlay | null;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalController, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalController>;
+}
+
+declare const CanDismissModalGuard: CanDeactivateFn<unknown>;
+
+declare class ModalComponent implements OnChanges, OnInit {
+    private canDismissHelper;
+    private modalNavigationService;
+    private windowRef;
+    private elementRef;
+    modalElement: ElementRef<HTMLIonModalElement>;
+    ionContent: IonContent;
+    template: TemplateRef<unknown>;
+    isOpen: boolean;
+    trigger: string;
+    size: ModalSize;
+    scrollDisabled: boolean;
+    set canDismiss(canDismiss: ShowAlertCallback | boolean);
+    collapseTitle: boolean;
+    customHeight: string;
+    flavor: ModalFlavor;
+    drawerSupplementaryAction?: DrawerSupplementaryAction;
+    interactWithBackground: boolean;
+    willPresent: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
+    didPresent: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
+    didDismiss: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
+    willDismiss: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
+    /**
+     * We populate the ModalConfig with defaults here. This ensures that we can
+     * guard for `if (key in this._config)` and only update the config when any of these
+     * inputs change.
+     */
+    _config: ModalConfig;
+    _canDismiss: ShowAlertCallback | boolean;
+    constructor(canDismissHelper: CanDismissHelper, modalNavigationService: ModalNavigationService, windowRef: WindowRef, elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    scrollToTop(scrollDuration?: KirbyAnimation.Duration): void;
+    scrollToBottom(scrollDuration?: KirbyAnimation.Duration): void;
+    _onWillPresent(event: CustomEvent<OverlayEventDetail$1>): void;
+    _onDidPresent(event: CustomEvent<OverlayEventDetail$1>): void;
+    _onWillDismiss(event: CustomEvent<OverlayEventDetail$1>): void;
+    _onDidDismiss(event: CustomEvent<OverlayEventDetail$1>): void;
+    private updateModalConfigOnChange;
+    private forwardAriaLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "kirby-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "size": { "alias": "size"; "required": false; }; "scrollDisabled": { "alias": "scrollDisabled"; "required": false; }; "canDismiss": { "alias": "canDismiss"; "required": false; }; "collapseTitle": { "alias": "collapseTitle"; "required": false; }; "customHeight": { "alias": "customHeight"; "required": false; }; "flavor": { "alias": "flavor"; "required": false; }; "drawerSupplementaryAction": { "alias": "drawerSupplementaryAction"; "required": false; }; "interactWithBackground": { "alias": "interactWithBackground"; "required": false; }; }, { "willPresent": "willPresent"; "didPresent": "didPresent"; "didDismiss": "didDismiss"; "willDismiss": "willDismiss"; }, ["template"], never, true, never>;
+}
+
+declare class ModalFooterComponent extends ModalElementComponent {
+    snapToKeyboard: boolean;
+    type: 'inline' | 'fixed';
+    themeColor: 'white' | 'light';
+    get _cssClass(): ("light" | "white" | "inline" | "fixed")[];
+    constructor(elementRef: ElementRef<HTMLElement>, modalElementsAdvertiser: ModalElementsAdvertiser);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalFooterComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalFooterComponent, "kirby-modal-footer", never, { "snapToKeyboard": { "alias": "snapToKeyboard"; "required": false; }; "type": { "alias": "type"; "required": false; }; "themeColor": { "alias": "themeColor"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ActionSheetComponent {
+    cancelButtonText: string;
+    hideCancel: boolean;
+    disabled: boolean;
+    header: string;
+    subheader: string;
+    items: Array<ActionSheetItem>;
+    cancel: EventEmitter<any>;
+    itemSelect: EventEmitter<ActionSheetItem>;
+    onItemSelect(selection: ActionSheetItem): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionSheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionSheetComponent, "kirby-action-sheet", never, { "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "hideCancel": { "alias": "hideCancel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "header": { "alias": "header"; "required": false; }; "subheader": { "alias": "subheader"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, { "cancel": "cancel"; "itemSelect": "itemSelect"; }, never, never, true, never>;
+}
+
+export { ActionSheetComponent, ActionSheetHelper, AlertComponent, AlertHelper, COMPONENT_PROPS, CanDismissHelper, CanDismissModalGuard, DrawerSupplementaryAction, Modal, ModalCompactWrapperComponent, ModalComponent, ModalController, ModalElementComponent, ModalElementType, ModalElementsAdvertiser, ModalFooterComponent, ModalHelper, ModalNavigationService, ModalWrapperComponent };
+export type { ActionSheetConfig, ActionSheetItem, AlertConfig, ModalConfig, ModalEnabledRoutes, ModalFlavor, ModalRouteActivation, ModalSize, Overlay, OverlayEventDetail, RoutedModalConfig, ShowAlertCallback };
+//# sourceMappingURL=index.d.ts.map

package/modal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../modal/src/modal.interfaces.ts","../../modal/src/modal/action-sheet/config/action-sheet-item.ts","../../modal/src/modal/action-sheet/config/action-sheet-config.ts","../../modal/src/modal/alert/config/alert-config.ts","../../modal/src/modal-navigation.service.ts","../../modal/src/modal-wrapper/config/drawer-supplementary-action.ts","../../modal/src/modal-wrapper/config/modal-config.ts","../../modal/src/modal-wrapper/config/modal-config.helper.ts","../../modal/src/modal/alert/alert.component.ts","../../modal/src/modal/services/alert.helper.ts","../../modal/src/modal/services/can-dismiss.helper.ts","../../modal/src/modal-wrapper/modal-wrapper.component.ts","../../modal/src/modal-wrapper/compact/modal-compact-wrapper.component.ts","../../modal/src/modal/services/action-sheet.helper.ts","../../modal/src/modal/services/modal-animation-builder.service.ts","../../modal/src/modal/services/modal.helper.ts","../../modal/src/modal/services/modal.controller.ts","../../modal/src/modal/services/can-dismiss-modal-guard.ts","../../modal/src/modal/modal-component/modal.component.ts","../../modal/src/modal/footer/modal-footer.component.ts","../../modal/src/modal/action-sheet/action-sheet.component.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;AAKM;;;AAGL;;;AAIC;AACA;;AAED;;;;AAKA;AAED;AACE;AACA;;;;;;AAMD;AACD;;AAEG;AACH;AACE;AACA;AACA;AACD;AAED;;AAEG;AACH;AACE;AACA;AACD;AAED;;AAEG;AACH;AAUI;AACA;AACY;;AAFJ;;;;;AAgBX;;;;;AC1EA;;;;;ACEC;;AAED;;;ACJC;;;AAIA;;;;;AASM;;;AAGP;;ACJD;AAGI;AACA;AADQ;AAIV;AAIA;;;;AAiEA;AAcA;AAcA;AA2BA;AAMA;AAaA;AAcA;AAMA;;;AAiCA;AAkBA;AAqBA;AAyBM;AAGO;AAA8C;;AAyBrD;AAUA;AAOA;AAiBN;;;;AAwBD;;AChXD;;;AAIC;;ACEK;AACA;AAEA;;;;;;;AAQJ;;AAEA;AAAmB;;;;;AAMnB;AACA;AAAmB;;AACpB;AAED;;;;AAIG;AACG;AAEN;;AAEC;AAED;;;AAGC;AAEK;;AC3CN;;ACeA;AAiDI;AACA;;;;AA9BF;;AAMA;;;AAOS;AAET;;;AAOA;;;AAWA;;;;;;AAqBD;;ACnFD;AAEc;AAAQ;;AAmBpB;AAUA;;;;AAiBD;;ACnDD;AAEc;AAAQ;;;;;AAkBrB;;AC2BD;AAmHI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AAtGT;AAKA;;AAGA;AAEA;AAIA;;AAKS;;;AAKkB;;;;;;;;;AAmB3B;;;;;;;;;AAmBA;;AAEA;;;;;;;;;;AAkBA;AAKA;;;AAsBA;AAqBA;;;;;;AAuEA;AAkBA;AAOA;AAQA;AAUA;AAgBA;AAWA;AAIA;AAOA;AASA;AASA;AAgCA;;AAcA;AAYA;AAcA;AAIA;;;;;AAmDA;AAgBA;AASA;AAQA;AAMA;AAMA;;;AAsCA;AAKA;AAMA;;AA4BA;;;;AAwCD;;ACpoBD;AAuBI;AACA;AACA;AACA;AACA;;AAjBO;;AAGT;;;AAIA;AACA;;;;AAYA;AAYA;AASA;AASA;;AAcA;;;;;;AAaD;;AClGD;AAEc;AAAQ;;;;AAsCrB;;AC3CD;AAEc;AAAQ;AAEpB;AACA;AACA;AACA;AAIO;AA4HA;;;AA+JP;;;;;;;;AAQG;;;;AAIJ;;ACxSD;AAGI;AACA;AACA;AACA;AACA;AAJQ;;;;;AAsHX;;AC1HD;AAOI;AACA;AACA;AACA;AAC4B;;AAR9B;;AAIU;AAOJ;AASN;AA0BA;AAWa;AAIA;AAIA;;AAsBA;AAUA;;;AAkCA;;AAcb;;;AAID;;AChKD;;AC2BA;AAwDI;AACA;AACA;AACA;AA7CF;;AAE6C;AAEpC;;;AAGA;AACT;AAOS;;;;;AAOC;AACA;AACA;AACA;AAEV;;;;AAIG;;AAQH;AAGU;AAMV;AAIA;AAIO;AAIA;AAIA;AAQA;AAKA;AAQA;AAIP;AASA;;;AAOD;;AC1ID;AAUE;AAGA;AAGA;AAEA;;;;AAWD;;ACtCD;AAOW;;;;;AAKA;AACC;AACA;;;;;AASX;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirbydesign/designsystem",
-  "version": "11.0.0",
+  "version": "11.1.1",
   "description": "The Kirby Design Angular Components.",
   "author": "kirby@bankdata.dk",
   "repository": {
@@ -21,18 +21,18 @@
   "dependencies": {
     "@floating-ui/dom": "^1.1.0",
     "@fontsource/roboto": "4.2.1",
-    "@kirbydesign/core": "0.0.74",
+    "@kirbydesign/core": "0.0.76",
     "inputmask": "5.0.8",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/cdk": "^18.0.0 || ^19.0.0",
-    "@angular/common": "^18.0.0 || ^19.0.0",
-    "@angular/core": "^18.0.0 || ^19.0.0",
-    "@angular/forms": "^18.0.0 || ^19.0.0",
-    "@angular/router": "^18.0.0 || ^19.0.0",
-    "@ionic/angular": "8.2.7",
-    "@stencil/core": "4.23.1",
+    "@angular/cdk": "^18.0.0 || ^19.0.0 || ^20.0.0",
+    "@angular/common": "^18.0.0 || ^19.0.0 || ^20.0.0",
+    "@angular/core": "^18.0.0 || ^19.0.0 || ^20.0.0",
+    "@angular/forms": "^18.0.0 || ^19.0.0 || ^20.0.0",
+    "@angular/router": "^18.0.0 || ^19.0.0 || ^20.0.0",
+    "@ionic/angular": "8.6.3",
+    "@stencil/core": "^4.33.1",
     "chart.js": "^3.9.1",
     "chartjs-adapter-date-fns": "^2.0.0",
     "chartjs-plugin-annotation": "^1.0.2",
@@ -61,14 +61,14 @@
       "types": "./action-group/index.d.ts",
       "default": "./fesm2022/kirbydesign-designsystem-action-group.mjs"
     },
-    "./avatar": {
-      "types": "./avatar/index.d.ts",
-      "default": "./fesm2022/kirbydesign-designsystem-avatar.mjs"
-    },
     "./badge": {
       "types": "./badge/index.d.ts",
       "default": "./fesm2022/kirbydesign-designsystem-badge.mjs"
     },
+    "./avatar": {
+      "types": "./avatar/index.d.ts",
+      "default": "./fesm2022/kirbydesign-designsystem-avatar.mjs"
+    },
     "./button": {
       "types": "./button/index.d.ts",
       "default": "./fesm2022/kirbydesign-designsystem-button.mjs"
@@ -221,14 +221,14 @@
       "types": "./tabs/index.d.ts",
       "default": "./fesm2022/kirbydesign-designsystem-tabs.mjs"
     },
-    "./testing": {
-      "types": "./testing/index.d.ts",
-      "default": "./fesm2022/kirbydesign-designsystem-testing.mjs"
-    },
     "./testing-base": {
       "types": "./testing-base/index.d.ts",
       "default": "./fesm2022/kirbydesign-designsystem-testing-base.mjs"
     },
+    "./testing": {
+      "types": "./testing/index.d.ts",
+      "default": "./fesm2022/kirbydesign-designsystem-testing.mjs"
+    },
     "./testing-jasmine": {
       "types": "./testing-jasmine/index.d.ts",
       "default": "./fesm2022/kirbydesign-designsystem-testing-jasmine.mjs"