@kirbydesign/designsystem 11.0.0 → 11.1.1

package/shared/floating/index.d.ts

@@ -1,6 +1,140 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, EventEmitter, Renderer2 } from '@angular/core';
+import { Placement, Strategy } from '@floating-ui/dom';
+import * as i1 from '@kirbydesign/designsystem/shared/portal';
+import { PortalDirective } from '@kirbydesign/designsystem/shared/portal';
+
+type TriggerEvent = 'hover' | 'click' | 'focus';
+declare enum FloatingOffset {
+    none = 0,
+    small = 4,
+    medium = 8
+}
+declare enum OutletSelector {
+    tag = "tag",
+    id = "id",
+    class = "class",
+    name = "name"
+}
+interface PortalOutletConfig {
+    selector: OutletSelector;
+    value: string;
+}
 /**
- * Generated bundle index. Do not edit.
+ * @summary FloatingDirective is a utility that lets you declarative anchor "popup" containers to another element.
+ *
+ * Uses floating-ui, with this directive wraps the functionality: https://floating-ui.com/docs/getting-started
+ *
+ * Uses PortalDirective to enable functionality for portaling the floated content. This should be used when needed
+ * and not as the default option.
  */
-/// <amd-module name="@kirbydesign/designsystem/shared/floating" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-shared-floating.d.ts.map
+declare class FloatingDirective implements OnInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    private portalDirective;
+    /**
+     * Reference to the element for which the host should anchor to
+     * */
+    set reference(ref: ElementRef<HTMLElement> | undefined);
+    get reference(): ElementRef<HTMLElement> | undefined;
+    /**
+     * How the host should be placed relative to the reference. Can be affected by middleware
+     * */
+    set placement(placement: Placement);
+    get placement(): Placement;
+    /**
+     * The strategy for how the host should be positioned.
+     * */
+    set strategy(strategy: Strategy);
+    get strategy(): Strategy;
+    /**
+     * Defines when the host should be displayed/hidden, i.e. click will attach a click listener to the reference
+     * that makes the host toggle display. Supports multiple triggers, to provide functionality for combinations
+     * like click/focus.
+     * */
+    set triggers(eventTriggers: Array<TriggerEvent>);
+    get triggers(): Array<TriggerEvent>;
+    /**
+     * The HTMLElement for which the content should portal into.
+     * Providing an outlet enables the portal, if nothing is provided, the provided strategy is used.
+     * This should be used when there's issues with the stacking context, and not as a default option.
+     * */
+    set DOMPortalOutlet(outlet: HTMLElement | undefined);
+    get DOMPortalOutlet(): HTMLElement | undefined;
+    /**
+     * Defines how to automatically find and assign DOMPortalOutlet if none is provided in DOMPortalOutlet.
+     * If nothing is provided here and in DOMPortalOutlet, the provided strategy is used
+     * */
+    set portalOutletConfig(config: PortalOutletConfig | undefined);
+    get portalOutletConfig(): PortalOutletConfig | undefined;
+    /**
+     * Prevent host from being toggled if set.
+     * */
+    isDisabled: boolean;
+    /**
+     * Displaces the floating element from its core placement along the specified axes.
+     * */
+    offset: FloatingOffset;
+    /**
+     * Moves the floating element along the specified axes in order to keep it in view.
+     * This does not always work as expected, so don't "just" set it.
+     * */
+    shift: boolean;
+    /**
+     * Chooses the placement that has the most space available automatically.
+     * */
+    autoPlacement: boolean;
+    /**
+     * Enables hiding the host by events. See variable names.
+     * */
+    closeOnSelect: boolean;
+    closeOnEscapeKey: boolean;
+    closeOnBackdrop: boolean;
+    /**
+     * Enables the option to be notified when the host changes display. The new display value is provided.
+     * */
+    displayChanged: EventEmitter<boolean>;
+    onEscapeKeyPressed(): void;
+    private _placement;
+    private _strategy;
+    private _providedPortalOutlet;
+    private _portalOutletConfig;
+    private _triggers;
+    private _reference;
+    private autoUpdaterRef;
+    private isShown;
+    private referenceEventListenerDisposeFns;
+    private documentClickEventListenerDisposeFn;
+    private hostClickEventListenerDisposeFn;
+    private triggerEventMap;
+    private HTMLElements;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2, portalDirective: PortalDirective);
+    ngOnInit(): void;
+    show(): void;
+    hide(): void;
+    toggleShow(): void;
+    private addFloatStylingToHostElement;
+    private setDisplayStyling;
+    private updateHostElementPosition;
+    private getMiddlewareConfig;
+    private autoUpdatePosition;
+    private setPositionStylingOnHostElement;
+    private setupEventHandling;
+    private attachDocumentClickEventHandler;
+    private attachHostClickEventHandler;
+    private attachTriggerEventToReferenceElement;
+    private handleClickInsideHostElement;
+    private handleClickOutsideHostElement;
+    private getOutletElement;
+    private getHTMLElements;
+    private tearDownReferenceElementEventHandling;
+    private tearDownDocumentClickEventHandling;
+    private removeAutoUpdaterRef;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingDirective, "[kirbyFloating]", never, { "reference": { "alias": "reference"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "strategy": { "alias": "strategy"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "DOMPortalOutlet": { "alias": "DOMPortalOutlet"; "required": false; }; "portalOutletConfig": { "alias": "portalOutletConfig"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "shift": { "alias": "shift"; "required": false; }; "autoPlacement": { "alias": "autoPlacement"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; }; }, { "displayChanged": "displayChanged"; }, never, never, true, [{ directive: typeof i1.PortalDirective; inputs: {}; outputs: {}; }]>;
+}
+
+export { FloatingDirective, FloatingOffset, OutletSelector };
+export type { PortalOutletConfig, TriggerEvent };
+//# sourceMappingURL=index.d.ts.map

package/shared/floating/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../shared/floating/src/floating.directive.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AA2BM;AAEN;AACE;AACA;AACA;AACD;AAED;AACE;AACA;AACA;AACA;AACD;;;;AAKA;AASD;;;;;;;AAOG;AACH;AAuLI;AACA;AACA;AAlLF;;AAEK;;;AAcL;;AAEK;AACL;;AAWA;;AAEK;AACL;;AAWA;;;;AAIK;;AAOL;AAIA;;;;AAIK;AACL;AAMA;AAIA;;;AAGK;AACL;AAQA;AAIA;;AAEK;;AAGL;;AAEK;;AAGL;;;AAGK;;AAGL;;AAEK;;AAGL;;AAEK;;;;AAKL;;AAEK;AACY;AAGV;;;;;;;;;;;;;;AAoDG;AAKH;AAKA;AAcA;AAaA;AAQP;AAYA;AAQA;AAgBA;AAgBA;AAcA;AAMA;AAUA;AAYA;AAYA;AAiBA;AAMA;AAcA;AAqBA;AAMA;AAWA;AAYA;;;;AAWD;;;"}

package/shared/index.d.ts

@@ -1,6 +1,152 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef, Type, OnInit, ComponentFactoryResolver, ViewContainerRef, Renderer2 } from '@angular/core';
+import { ThemeColor } from '@kirbydesign/core';
+import { LineClampHelper } from '@kirbydesign/designsystem/helpers';
+
 /**
- * Generated bundle index. Do not edit.
+ * Factory that creates a new ResizeObserver and allows us to stub it out in unit tests.
+ * @docs-private
  */
-/// <amd-module name="@kirbydesign/designsystem/shared" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-shared.d.ts.map
+declare class ResizeObserverFactory {
+    create(callback: ResizeObserverCallback): ResizeObserver | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverFactory>;
+}
+
+declare class ResizeObserverService implements OnDestroy {
+    private _resizeObserverFactory;
+    private observer;
+    private observedElements;
+    constructor(_resizeObserverFactory: ResizeObserverFactory);
+    observe(elementOrRef: Element | ElementRef<Element>, action: (entry: ResizeObserverEntry) => void): void;
+    ngOnDestroy(): void;
+    unobserve(elementOrRef: Element | ElementRef<Element>): void;
+    private handleResize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
+}
+
+declare class ThemeColorDirective {
+    private _isDefault;
+    get isDefault(): boolean;
+    private _isPrimary;
+    get isPrimary(): boolean;
+    private _isSecondary;
+    get isSecondary(): boolean;
+    private _isTertiary;
+    get isTertiary(): boolean;
+    private _isSuccess;
+    get isSuccess(): boolean;
+    private _isWarning;
+    get isWarning(): boolean;
+    private _isDanger;
+    get isDanger(): boolean;
+    private _isLight;
+    get isLight(): boolean;
+    private _isMedium;
+    get isMedium(): boolean;
+    private _isDark;
+    get isDark(): boolean;
+    private _isWhite;
+    get isWhite(): boolean;
+    private _isBrightnessWhite;
+    get isBrightnessWhite(): boolean;
+    private _isBrightnessLight;
+    get isBrightnessLight(): boolean;
+    private _isBrightnessDark;
+    get isBrightnessDark(): boolean;
+    set themeColor(value: ThemeColor);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeColorDirective, "kirby-avatar[themeColor],             kirby-card[themeColor],             kirby-icon[themeColor],             kirby-progress-circle-ring[themeColor],             kirby-modal-footer[themeColor],             kirby-empty-state[themeColor]", never, { "themeColor": { "alias": "themeColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface ComponentConfiguration {
+    component: Type<any>;
+    data: any;
+}
+
+declare class ComponentLoaderDirective implements OnInit {
+    private componentFactoryResolver;
+    private viewContainerRef;
+    private renderer;
+    configuration: ComponentConfiguration;
+    cssClass: string;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, renderer: Renderer2);
+    ngOnInit(): void;
+    loadCard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentLoaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentLoaderDirective, "[kirbyLoadComponent]", never, { "configuration": { "alias": "kirbyLoadComponent"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface DynamicComponent {
+    data: any;
+}
+
+interface FitHeadingConfig {
+    maxLines: number;
+}
+declare class FitHeadingDirective implements OnInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    private resizeObserverService;
+    private lineClampHelper;
+    config?: FitHeadingConfig;
+    private isObservingHostElement;
+    private hostElementClone;
+    private isScalingHeader;
+    private headingSizes;
+    constructor(elementRef: ElementRef, renderer: Renderer2, resizeObserverService: ResizeObserverService, lineClampHelper: LineClampHelper);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private observeResize;
+    private scaleHeader;
+    private canFitHeading;
+    private generateHostElementClone;
+    private setSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FitHeadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FitHeadingDirective, "h1[kirbyFitHeading],h2[kirbyFitHeading],h3[kirbyFitHeading],[kirbyFitHeading]", never, { "config": { "alias": "kirbyFitHeading"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function findItemLabel(element: HTMLElement): HTMLElement;
+declare function setAccessibleLabel(element: HTMLElement): string;
+declare function inheritAriaLabelText(element: HTMLElement): string;
+/**
+ * Forwards specified attributes from a source element to a target element.
+ *
+ * @param sourceElement - The HTML element from which attributes will be removed from.
+ * @param attributes - An array of attribute names to inherit from the source element.
+ * @param renderer - An instance of Angular's Renderer2.
+ * @param targetElement - (Optional) The HTML element to which the attributes should be applied.
+ *                        If not provided, the attributes will only be removed from the source element.
+ *
+ * @returns A record of the inherited attributes and their values. If no attributes are inherited, an empty object is returned.
+ */
+declare function forwardAttributes(sourceElement: HTMLElement, attributes: string[], renderer: Renderer2, targetElement?: HTMLElement): Record<string, any>;
+
+interface Translation {
+    $code: string;
+    back: string;
+    close: string;
+    nextMonth: string;
+    nextSlide: string;
+    previousMonth: string;
+    previousSlide: string;
+    selectYear: string;
+    readMore: string;
+    more: string;
+}
+
+declare class TranslationService {
+    private localeId;
+    private activeTranslation;
+    private translations;
+    constructor(localeId: string);
+    private setActiveTranslation;
+    get(key: keyof Translation): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationService>;
+}
+
+export { ComponentLoaderDirective, FitHeadingDirective, ResizeObserverFactory, ResizeObserverService, ThemeColorDirective, TranslationService, findItemLabel, forwardAttributes, inheritAriaLabelText, setAccessibleLabel };
+export type { ComponentConfiguration, DynamicComponent, FitHeadingConfig };
+//# sourceMappingURL=index.d.ts.map

package/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../shared/src/resize-observer/resize-observer.factory.ts","../../shared/src/resize-observer/resize-observer.service.ts","../../shared/src/theme-color/theme-color.directive.ts","../../shared/src/component-configuration.ts","../../shared/src/component-loader.directive.ts","../../shared/src/dynamic-component.ts","../../shared/src/fit-heading/fit-heading.directive.ts","../../shared/src/controls/label-helpers.ts","../../shared/src/translation/translation.interface.ts","../../shared/src/translation/translation.service.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;AACA;;;AAGG;AACH;AAEE;;;AAGD;;ACPD;AAOc;;;AAAQ;AAIpB;;;AA8BA;;;AAQD;;AC/CD;;AAYE;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;;AAMA;AAKA;;;AAiBD;;;AClHC;;AAED;;ACOD;AAUI;AACA;AACA;;;;;;;;AAkBH;;;;ACxCA;;;;ACeA;AAED;AA+BI;AACA;AACA;AACA;;;;;;AAHQ;AAMV;AAQA;AASA;AAcA;AAwBA;AAMA;AAQA;;;AAID;;AC/HD;AASA;AAQA;AASA;;;;;;;;;;AAUG;AACH;;;;;;;;;;;;;AC5BC;;ACJD;AAOiC;;;AAAQ;AAIvC;AAcA;;;AAGD;;;"}

package/shared/portal/index.d.ts

@@ -1,6 +1,38 @@
+import { CdkPortalOutlet, Portal, DomPortal } from '@angular/cdk/portal';
+import * as i0 from '@angular/core';
+import { ElementRef, ComponentFactoryResolver, ViewContainerRef } from '@angular/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * @summary PortalDirective is a utility that lets you portal the host element into another DOM element.
+ * This is designed to be beneficial when there's issues with the stacking context.
+ *
+ * Extends CdkPortalOutlet to gain functionality for attaching/detaching the host element, and for proper cleanup.
+ *
+ * Using portal directive to reposition HTML elements, might break angular functionality and/or styling, so use
+ * with care.
  */
-/// <amd-module name="@kirbydesign/designsystem/shared/portal" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-shared-portal.d.ts.map
+declare class PortalDirective extends CdkPortalOutlet {
+    private elementRef;
+    private componentFactoryResolver;
+    private viewContainerRef;
+    private _outlet;
+    /** The DOM element for which the host element should be appended as a child. */
+    set outlet(outlet: HTMLElement | undefined);
+    get outlet(): HTMLElement | undefined;
+    /**
+     * Override portal to handle if user provides a portal of another type than DOMPortal, which CdkPortal would
+     * otherwise allow. This can be modified to handle other portal types in the future, should the need arise
+     */
+    set portal(portal: Portal<unknown> | null);
+    constructor(elementRef: ElementRef, componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef);
+    /**
+     * Nearly identical to super class, yet we want to use provided outlet instead of directive host as new content
+     * parent which is otherwise the default for CdKPortal
+     */
+    attachDomPortal: (portal: DomPortal) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalDirective, "[kirbyPortal]", never, { "outlet": { "alias": "outlet"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { PortalDirective };
+//# sourceMappingURL=index.d.ts.map

package/shared/portal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../shared/portal/src/portal.directive.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;AAQG;AACH,cAAA,eAAA,SAAA,eAAA;AAmCI;AACA;AACA;;;AA7BF,uBAAA,WAAA;AAQA,kBAAA,WAAA;AAIA;;;AAGG;;;AAmBH;;;AAGG;AACa,8BAAA,SAAA;;;AA0BjB;;;;"}

package/slide/index.d.ts

@@ -1,6 +1,66 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/slide" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-slide.d.ts.map
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnChanges, ChangeDetectorRef, ElementRef, TemplateRef, EventEmitter, SimpleChanges, Renderer2 } from '@angular/core';
+import { Swiper, SwiperOptions } from 'swiper';
+import { PlatformService } from '@kirbydesign/designsystem/helpers';
+import { TranslationService } from '@kirbydesign/designsystem/shared';
+import * as i4 from '@angular/common';
+import * as i5 from '@kirbydesign/designsystem/button';
+import * as i6 from '@kirbydesign/designsystem/icon';
+
+declare class SlideDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlideDirective, "[kirbySlide]", never, {}, {}, never, never, false, never>;
+}
+
+type SelectedSlide = {
+    slide: any;
+    index: number;
+};
+type KirbySwiperOptions = SwiperOptions;
+type SwiperContainer = HTMLElement & {
+    initialize: () => void;
+    swiper: Swiper;
+};
+declare class SlidesComponent implements OnInit, AfterViewInit, OnChanges {
+    private platform;
+    private cdr;
+    private translations;
+    constructor(platform: PlatformService, cdr: ChangeDetectorRef, translations: TranslationService);
+    swiperContainer: ElementRef<SwiperContainer>;
+    slideTemplate: TemplateRef<SlideDirective>;
+    slidesOptions?: KirbySwiperOptions;
+    title: string;
+    slides: unknown[];
+    showNavigation: boolean;
+    slideChange: EventEmitter<SelectedSlide>;
+    _paginationId: string;
+    _prevButtonId: string;
+    _nextButtonId: string;
+    _isTouch: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    slideTo(index: number): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getDefaultConfig;
+    private getNoControlsConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlidesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlidesComponent, "kirby-slides", never, { "slidesOptions": { "alias": "slidesOptions"; "required": false; }; "title": { "alias": "title"; "required": false; }; "slides": { "alias": "slides"; "required": false; }; "showNavigation": { "alias": "showNavigation"; "required": false; }; }, { "slideChange": "slideChange"; }, ["slideTemplate"], ["h1,h2,h3,h4,h5,h6", "button[kirby-button]"], false, never>;
+}
+
+declare class SlideStretchHeightDirective {
+    private elementRef;
+    private renderer;
+    constructor(elementRef: ElementRef, renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideStretchHeightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlideStretchHeightDirective, "[slideStretchHeight]", never, {}, {}, never, never, false, never>;
+}
+
+declare class SlideModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SlideModule, [typeof SlidesComponent, typeof SlideDirective, typeof SlideStretchHeightDirective], [typeof i4.CommonModule, typeof i5.ButtonComponent, typeof i6.IconModule], [typeof SlidesComponent, typeof SlideDirective, typeof SlideStretchHeightDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SlideModule>;
+}
+
+export { SlideDirective, SlideModule, SlideStretchHeightDirective, SlidesComponent };
+export type { KirbySwiperOptions, SelectedSlide };
+//# sourceMappingURL=index.d.ts.map

package/slide/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../slide/src/slide.directive.ts","../../slide/src/slides.component.ts","../../slide/src/slide-stretch-height.directive.ts","../../slide/src/slide.module.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;;;;;;AAEA;;;AAI8B;;ACyBxB;;;;AAKA;AACN;;;;AAEA;AASI;AACA;AACA;;AAG4B;AAEvB;;;;;AAQG;AAEV;AACA;AACA;;;;;AAuBA;AAOA;AAyCA;;;AAGD;;AC3ID;AAOI;AACA;AADQ;;;AAKX;;ACHD;;;;AAM2B;;;"}

package/slide-button/index.d.ts

@@ -1,6 +1,35 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/slide-button" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-slide-button.d.ts.map
+import * as i0 from '@angular/core';
+import { OnDestroy, AfterViewInit, EventEmitter, ElementRef, ChangeDetectorRef, Renderer2 } from '@angular/core';
+
+declare class SlideButtonComponent implements OnDestroy, AfterViewInit {
+    private changeDetectionRef;
+    private elementRef;
+    private renderer;
+    text: string;
+    expand: 'block';
+    slideDone: EventEmitter<any>;
+    slidingPercentageChanged: EventEmitter<number>;
+    hiddenButton: ElementRef<HTMLButtonElement>;
+    private _attributesToForward;
+    readonly slideDoneFadeTime = 500;
+    readonly slideResetTime = 100;
+    isSlideDone: boolean;
+    pctInTens: number;
+    get value(): number;
+    set value(v: number);
+    private _value;
+    private resetSliderIntervalTimer;
+    private calculatePctInTens;
+    constructor(changeDetectionRef: ChangeDetectorRef, elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onSliderMouseup(): void;
+    onSliderValueChange(val: string): void;
+    onSliderMousedown(): void;
+    handleSlideDone(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlideButtonComponent, "kirby-slide-button", never, { "text": { "alias": "text"; "required": false; }; "expand": { "alias": "expand"; "required": false; }; }, { "slideDone": "slideDone"; "slidingPercentageChanged": "slidingPercentageChanged"; }, never, never, true, never>;
+}
+
+export { SlideButtonComponent };
+//# sourceMappingURL=index.d.ts.map

package/slide-button/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../slide-button/src/slide-button.component.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAgBA,cAAA,oBAAA,YAAA,SAAA,EAAA,aAAA;AAwCI;AACA;AACA;AAlCO;;AAGC,eAAA,YAAA;AACA,8BAAA,YAAA;AAGV,kBAAA,UAAA,CAAA,iBAAA;;;;AAOA;AACA;;AAKA;;;AAOA;AAKU,oCAAA,iBAAA,cAAA,UAAA,CAAA,WAAA,aAAA,SAAA;AAKV;AASA;;;;;;;AAoCD;;;;"}

package/spinner/index.d.ts

@@ -1,6 +1,16 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/spinner" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-spinner.d.ts.map
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/common';
+
+declare class SpinnerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "kirby-spinner", never, {}, {}, never, never, false, never>;
+}
+
+declare class SpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpinnerModule, [typeof SpinnerComponent], [typeof i2.CommonModule], [typeof SpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpinnerModule>;
+}
+
+export { SpinnerComponent, SpinnerModule };
+//# sourceMappingURL=index.d.ts.map

package/spinner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../spinner/src/spinner.component.ts","../../spinner/src/spinner.module.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAEA,cAAA,gBAAA;;;AAOgC;;ACJhC,cAAA,aAAA;;;;AAM6B;;;;"}

package/tab-navigation/index.d.ts

@@ -1,6 +1,58 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/tab-navigation" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-tab-navigation.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, EventEmitter, Renderer2, ElementRef } from '@angular/core';
+import { WindowRef } from '@kirbydesign/designsystem/types';
+import { KeyboardHandlerService } from '@kirbydesign/designsystem/dropdown';
+import * as i3 from '@angular/common';
+
+declare class TabNavigationComponent implements AfterViewInit {
+    private window;
+    private keyboardHandlerService;
+    private renderer;
+    private elementRef;
+    readonly DEBOUNCE_TIME_MS = 250;
+    private tabBar;
+    private tabs;
+    private tabBarElement;
+    private tabElements;
+    private tabButtonElements;
+    private _attributesToForward;
+    get selectedIndex(): number;
+    set selectedIndex(index: number);
+    private _selectedIndex;
+    get focusIndex(): number;
+    set focusIndex(index: number);
+    private _focusIndex;
+    selectedIndexChange: EventEmitter<number>;
+    constructor(window: WindowRef, keyboardHandlerService: KeyboardHandlerService, renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    onItemSelect(event: PointerEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    private selectTab;
+    private focusTab;
+    private scrollToTab;
+    private setTabElements;
+    private updateTabElementsOnChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabNavigationComponent, "kirby-tab-navigation", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, ["tabs"], ["*"], false, never>;
+}
+
+declare class TabNavigationItemComponent implements AfterViewInit {
+    private elementRef;
+    private renderer;
+    private _attributesToForward;
+    label: string;
+    truncate: boolean;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabNavigationItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabNavigationItemComponent, "kirby-tab-navigation-item", never, { "label": { "alias": "label"; "required": false; }; "truncate": { "alias": "truncate"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class TabNavigationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabNavigationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabNavigationModule, [typeof TabNavigationComponent, typeof TabNavigationItemComponent], [typeof i3.CommonModule], [typeof TabNavigationComponent, typeof TabNavigationItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabNavigationModule>;
+}
+
+export { TabNavigationComponent, TabNavigationItemComponent, TabNavigationModule };
+//# sourceMappingURL=index.d.ts.map

package/tab-navigation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../tab-navigation/src/tab-navigation/tab-navigation.component.ts","../../tab-navigation/src/tab-navigation-item/tab-navigation-item.component.ts","../../tab-navigation/src/tab-navigation.module.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;;;AAmBA,cAAA,sBAAA,YAAA,aAAA;AAwDI;AACA;AACA;AACA;AAnDF;;;;;;;;AAmBA;;;AAeA;;AAWA,yBAAA,YAAA;AAGU,wBAAA,SAAA,0BAAA,sBAAA,YAAA,SAAA,cAAA,UAAA,CAAA,WAAA;AAMV;;;AAoCA;AAMA;AAUA;AAmBA;AAiBA;;;AAOD;;ACtKD,cAAA,0BAAA,YAAA,aAAA;AAkBI;AACA;;AAPF;AAGA;;AAOA;;;AASD;;ACpCD,cAAA,mBAAA;;;;AAKmC;;;;"}

package/tabs/index.d.ts

@@ -1,6 +1,49 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/tabs" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-tabs.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter, QueryList } from '@angular/core';
+import * as i5 from '@ionic/angular/standalone';
+import { IonRouterOutlet, IonTabs } from '@ionic/angular/standalone';
+export { IonRouterOutlet } from '@ionic/angular/standalone';
+import * as rxjs from 'rxjs';
+import * as i3 from '@kirbydesign/designsystem/icon';
+import { IconComponent } from '@kirbydesign/designsystem/icon';
+import * as i4 from '@angular/common';
+
+declare class TabsService {
+    private outletSubject$;
+    outlet$: rxjs.Observable<IonRouterOutlet>;
+    setOutlet(outlet: IonRouterOutlet): void;
+    resetOutlet(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabsService>;
+}
+
+declare class TabsComponent implements AfterViewInit, OnDestroy {
+    private tabsService;
+    tabBarBottomHidden: boolean;
+    tabs: IonTabs;
+    constructor(tabsService: TabsService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "kirby-tab-bar", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class TabButtonComponent {
+    tab: string;
+    click: EventEmitter<Event>;
+    icons: QueryList<IconComponent>;
+    onClick(event: Event, isSelected: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabButtonComponent, "kirby-tab-button", never, { "tab": { "alias": "tab"; "required": false; }; }, { "click": "click"; }, ["icons"], ["kirby-icon:not([selected-tab])", "kirby-icon[selected-tab]", "*", "kirby-badge"], false, never>;
+}
+
+declare const selectedTabClickEvent = "kirbySelectedTabClick";
+
+declare class TabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, [typeof TabsComponent, typeof TabButtonComponent], [typeof i3.IconModule, typeof i4.CommonModule, typeof i5.IonTabs, typeof i5.IonTabBar, typeof i5.IonTabButton], [typeof TabsComponent, typeof TabButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
+}
+
+export { TabButtonComponent, TabsComponent, TabsModule, TabsService, selectedTabClickEvent };
+//# sourceMappingURL=index.d.ts.map

package/tabs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../tabs/src/tabs.service.ts","../../tabs/src/tabs.component.ts","../../tabs/src/tab-button/tab-button.component.ts","../../tabs/src/tab-button/tab-button.events.ts","../../tabs/src/tabs.module.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;AAIA,cAAA,WAAA;;AAKS,aAAO,IAAA,CAAA,UAAA,CAAA,eAAA;;;;;AASf;;ACbD,cAAA,aAAA,YAAA,aAAA,EAAA,SAAA;AAWc;AAHZ;;AAGoB,6BAAA,WAAA;;;;;AASrB;;ACpBD,cAAA,kBAAA;;AAQY,WAAA,YAAA,CAAA,KAAA;AACsB,WAAA,SAAA,CAAA,aAAA;AAEhC,mBAAA,KAAA;;;AAQD;;ACxBD,cAAA,qBAAA;;ACSA,cAAA,UAAA;;;;AAM0B;;;;"}