@ionic/angular 8.8.16-dev.11784913436.1a334b43 → 8.8.16-dev.11784914346.10d0804c

package/directives/validators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './max-validator';
+export * from './min-validator';

package/directives/validators/max-validator.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from '@angular/core';
+import { MaxValidator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Provider which adds `MaxValidator` to the `NG_VALIDATORS` multi-provider list.
+ */
+export declare const ION_MAX_VALIDATOR: Provider;
+export declare class IonMaxValidator extends MaxValidator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonMaxValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonMaxValidator, "ion-input[type=number][max][formControlName],ion-input[type=number][max][formControl],ion-input[type=number][max][ngModel]", never, {}, {}, never, never, false, never>;
+}

package/directives/validators/min-validator.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from '@angular/core';
+import { MinValidator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Provider which adds `MinValidator` to the `NG_VALIDATORS` multi-provider list.
+ */
+export declare const ION_MIN_VALIDATOR: Provider;
+export declare class IonMinValidator extends MinValidator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonMinValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonMinValidator, "ion-input[type=number][min][formControlName],ion-input[type=number][min][formControl],ion-input[type=number][min][ngModel]", never, {}, {}, never, never, false, never>;
+}

package/esm2022/app-initialize.mjs

@@ -0,0 +1,29 @@
+import { raf } from '@ionic/angular/common';
+import { setupConfig } from '@ionic/core';
+import { defineCustomElements } from '@ionic/core/loader';
+// TODO(FW-2827): types
+export const appInitialize = (config, doc, zone) => {
+    return () => {
+        const win = doc.defaultView;
+        if (win && typeof window !== 'undefined') {
+            setupConfig({
+                ...config,
+                _zoneGate: (h) => zone.run(h),
+            });
+            const aelFn = '__zone_symbol__addEventListener' in doc.body ? '__zone_symbol__addEventListener' : 'addEventListener';
+            return defineCustomElements(win, {
+                exclude: ['ion-tabs'],
+                syncQueue: true,
+                raf,
+                jmp: (h) => zone.runOutsideAngular(h),
+                ael(elm, eventName, cb, opts) {
+                    elm[aelFn](eventName, cb, opts);
+                },
+                rel(elm, eventName, cb, opts) {
+                    elm.removeEventListener(eventName, cb, opts);
+                },
+            });
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/directives/control-value-accessors/index.mjs

@@ -0,0 +1,2 @@
+export * from './value-accessor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9jb21tb24vc3JjL2RpcmVjdGl2ZXMvY29udHJvbC12YWx1ZS1hY2Nlc3NvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdmFsdWUtYWNjZXNzb3InO1xuIl19

package/esm2022/common/directives/control-value-accessors/value-accessor.mjs

@@ -0,0 +1,153 @@
+import { Directive, HostListener } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { raf } from '../../utils/util';
+import * as i0 from "@angular/core";
+// TODO(FW-2827): types
+class ValueAccessor {
+    injector;
+    elementRef;
+    onChange = () => {
+        /**/
+    };
+    onTouched = () => {
+        /**/
+    };
+    lastValue;
+    statusChanges;
+    constructor(injector, elementRef) {
+        this.injector = injector;
+        this.elementRef = elementRef;
+    }
+    writeValue(value) {
+        this.elementRef.nativeElement.value = this.lastValue = value;
+        setIonicClasses(this.elementRef);
+    }
+    /**
+     * Notifies the ControlValueAccessor of a change in the value of the control.
+     *
+     * This is called by each of the ValueAccessor directives when we want to update
+     * the status and validity of the form control. For example with text components this
+     * is called when the ionInput event is fired. For select components this is called
+     * when the ionChange event is fired.
+     *
+     * This also updates the Ionic form status classes on the element.
+     *
+     * @param el The component element.
+     * @param value The new value of the control.
+     */
+    handleValueChange(el, value) {
+        if (el === this.elementRef.nativeElement) {
+            if (value !== this.lastValue) {
+                this.lastValue = value;
+                this.onChange(value);
+            }
+            setIonicClasses(this.elementRef);
+        }
+    }
+    _handleBlurEvent(el) {
+        if (el === this.elementRef.nativeElement) {
+            this.onTouched();
+            setIonicClasses(this.elementRef);
+            // When ion-radio is blurred, el and this.elementRef.nativeElement are
+            // different so we need to check if the closest ion-radio-group is the same
+            // as this.elementRef.nativeElement and if so, we need to mark the radio group
+            // as touched
+        }
+        else if (el.closest('ion-radio-group') === this.elementRef.nativeElement) {
+            this.onTouched();
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.elementRef.nativeElement.disabled = isDisabled;
+    }
+    ngOnDestroy() {
+        if (this.statusChanges) {
+            this.statusChanges.unsubscribe();
+        }
+    }
+    ngAfterViewInit() {
+        let ngControl;
+        try {
+            ngControl = this.injector.get(NgControl);
+        }
+        catch {
+            /* No FormControl or ngModel binding */
+        }
+        if (!ngControl) {
+            return;
+        }
+        // Listen for changes in validity, disabled, or pending states
+        if (ngControl.statusChanges) {
+            this.statusChanges = ngControl.statusChanges.subscribe(() => setIonicClasses(this.elementRef));
+        }
+        /**
+         * TODO FW-2787: Remove this in favor of https://github.com/angular/angular/issues/10887
+         * whenever it is implemented.
+         */
+        const formControl = ngControl.control;
+        if (formControl) {
+            const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine'];
+            methodsToPatch.forEach((method) => {
+                if (typeof formControl[method] !== 'undefined') {
+                    const oldFn = formControl[method].bind(formControl);
+                    formControl[method] = (...params) => {
+                        oldFn(...params);
+                        setIonicClasses(this.elementRef);
+                    };
+                }
+            });
+        }
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ValueAccessor, host: { listeners: { "ionBlur": "_handleBlurEvent($event.target)" } }, ngImport: i0 });
+}
+export { ValueAccessor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValueAccessor, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.ElementRef }]; }, propDecorators: { _handleBlurEvent: [{
+                type: HostListener,
+                args: ['ionBlur', ['$event.target']]
+            }] } });
+export const setIonicClasses = (element) => {
+    raf(() => {
+        const input = element.nativeElement;
+        const hasValue = input.value != null && input.value.toString().length > 0;
+        const classes = getClasses(input);
+        setClasses(input, classes);
+        const item = input.closest('ion-item');
+        if (item) {
+            if (hasValue) {
+                setClasses(item, [...classes, 'item-has-value']);
+            }
+            else {
+                setClasses(item, classes);
+            }
+        }
+    });
+};
+const getClasses = (element) => {
+    const classList = element.classList;
+    const classes = [];
+    for (let i = 0; i < classList.length; i++) {
+        const item = classList.item(i);
+        if (item !== null && startsWith(item, 'ng-')) {
+            classes.push(`ion-${item.substring(3)}`);
+        }
+    }
+    return classes;
+};
+const setClasses = (element, classes) => {
+    const classList = element.classList;
+    classList.remove('ion-valid', 'ion-invalid', 'ion-touched', 'ion-untouched', 'ion-dirty', 'ion-pristine');
+    classList.add(...classes);
+};
+const startsWith = (input, search) => {
+    return input.substring(0, search.length) === search;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"value-accessor.js","sourceRoot":"","sources":["../../../../../common/src/directives/control-value-accessors/value-accessor.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ElementRef, Injector, OnDestroy, Directive, HostListener } from '@angular/core';\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\nimport { Subscription } from 'rxjs';\n\nimport { raf } from '../../utils/util';\n\n// TODO(FW-2827): types\n\n@Directive()\nexport class ValueAccessor implements ControlValueAccessor, AfterViewInit, OnDestroy {\n  private onChange: (value: any) => void = () => {\n    /**/\n  };\n  private onTouched: () => void = () => {\n    /**/\n  };\n  protected lastValue: any;\n  private statusChanges?: Subscription;\n\n  constructor(protected injector: Injector, protected elementRef: ElementRef) {}\n\n  writeValue(value: any): void {\n    this.elementRef.nativeElement.value = this.lastValue = value;\n    setIonicClasses(this.elementRef);\n  }\n\n  /**\n   * Notifies the ControlValueAccessor of a change in the value of the control.\n   *\n   * This is called by each of the ValueAccessor directives when we want to update\n   * the status and validity of the form control. For example with text components this\n   * is called when the ionInput event is fired. For select components this is called\n   * when the ionChange event is fired.\n   *\n   * This also updates the Ionic form status classes on the element.\n   *\n   * @param el The component element.\n   * @param value The new value of the control.\n   */\n  handleValueChange(el: HTMLElement, value: any): void {\n    if (el === this.elementRef.nativeElement) {\n      if (value !== this.lastValue) {\n        this.lastValue = value;\n        this.onChange(value);\n      }\n      setIonicClasses(this.elementRef);\n    }\n  }\n\n  @HostListener('ionBlur', ['$event.target'])\n  _handleBlurEvent(el: any): void {\n    if (el === this.elementRef.nativeElement) {\n      this.onTouched();\n      setIonicClasses(this.elementRef);\n\n      // When ion-radio is blurred, el and this.elementRef.nativeElement are\n      // different so we need to check if the closest ion-radio-group is the same\n      // as this.elementRef.nativeElement and if so, we need to mark the radio group\n      // as touched\n    } else if (el.closest('ion-radio-group') === this.elementRef.nativeElement) {\n      this.onTouched();\n    }\n  }\n\n  registerOnChange(fn: (value: any) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.elementRef.nativeElement.disabled = isDisabled;\n  }\n\n  ngOnDestroy(): void {\n    if (this.statusChanges) {\n      this.statusChanges.unsubscribe();\n    }\n  }\n\n  ngAfterViewInit(): void {\n    let ngControl;\n    try {\n      ngControl = this.injector.get<NgControl>(NgControl);\n    } catch {\n      /* No FormControl or ngModel binding */\n    }\n\n    if (!ngControl) {\n      return;\n    }\n\n    // Listen for changes in validity, disabled, or pending states\n    if (ngControl.statusChanges) {\n      this.statusChanges = ngControl.statusChanges.subscribe(() => setIonicClasses(this.elementRef));\n    }\n\n    /**\n     * TODO FW-2787: Remove this in favor of https://github.com/angular/angular/issues/10887\n     * whenever it is implemented.\n     */\n    const formControl = ngControl.control as any;\n    if (formControl) {\n      const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine'];\n      methodsToPatch.forEach((method) => {\n        if (typeof formControl[method] !== 'undefined') {\n          const oldFn = formControl[method].bind(formControl);\n          formControl[method] = (...params: any[]) => {\n            oldFn(...params);\n            setIonicClasses(this.elementRef);\n          };\n        }\n      });\n    }\n  }\n}\n\nexport const setIonicClasses = (element: ElementRef): void => {\n  raf(() => {\n    const input = element.nativeElement as HTMLInputElement;\n    const hasValue = input.value != null && input.value.toString().length > 0;\n    const classes = getClasses(input);\n    setClasses(input, classes);\n    const item = input.closest('ion-item');\n    if (item) {\n      if (hasValue) {\n        setClasses(item, [...classes, 'item-has-value']);\n      } else {\n        setClasses(item, classes);\n      }\n    }\n  });\n};\n\nconst getClasses = (element: HTMLElement) => {\n  const classList = element.classList;\n  const classes: string[] = [];\n  for (let i = 0; i < classList.length; i++) {\n    const item = classList.item(i);\n    if (item !== null && startsWith(item, 'ng-')) {\n      classes.push(`ion-${item.substring(3)}`);\n    }\n  }\n  return classes;\n};\n\nconst setClasses = (element: HTMLElement, classes: string[]) => {\n  const classList = element.classList;\n  classList.remove('ion-valid', 'ion-invalid', 'ion-touched', 'ion-untouched', 'ion-dirty', 'ion-pristine');\n  classList.add(...classes);\n};\n\nconst startsWith = (input: string, search: string): boolean => {\n  return input.substring(0, search.length) === search;\n};\n"]}

package/esm2022/common/directives/navigation/back-button.mjs

@@ -0,0 +1,61 @@
+import { __decorate } from "tslib";
+import { HostListener, Optional, Directive } from '@angular/core';
+import { ProxyCmp } from '../../utils/proxy';
+import * as i0 from "@angular/core";
+import * as i1 from "./router-outlet";
+import * as i2 from "../../providers/nav-controller";
+import * as i3 from "../../providers/config";
+const BACK_BUTTON_INPUTS = ['color', 'defaultHref', 'disabled', 'icon', 'mode', 'routerAnimation', 'text', 'type'];
+let IonBackButton = class IonBackButton {
+    routerOutlet;
+    navCtrl;
+    config;
+    r;
+    z;
+    el;
+    constructor(routerOutlet, navCtrl, config, r, z, c) {
+        this.routerOutlet = routerOutlet;
+        this.navCtrl = navCtrl;
+        this.config = config;
+        this.r = r;
+        this.z = z;
+        c.detach();
+        this.el = this.r.nativeElement;
+    }
+    /**
+     * @internal
+     */
+    onClick(ev) {
+        const defaultHref = this.defaultHref || this.config.get('backButtonDefaultHref');
+        if (this.routerOutlet?.canGoBack()) {
+            this.navCtrl.setDirection('back', undefined, undefined, this.routerAnimation);
+            this.routerOutlet.pop();
+            ev.preventDefault();
+        }
+        else if (defaultHref != null) {
+            this.navCtrl.navigateBack(defaultHref, { animation: this.routerAnimation });
+            ev.preventDefault();
+        }
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IonBackButton, deps: [{ token: i1.IonRouterOutlet, optional: true }, { token: i2.NavController }, { token: i3.Config }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: IonBackButton, inputs: { color: "color", defaultHref: "defaultHref", disabled: "disabled", icon: "icon", mode: "mode", routerAnimation: "routerAnimation", text: "text", type: "type" }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 });
+};
+IonBackButton = __decorate([
+    ProxyCmp({
+        inputs: BACK_BUTTON_INPUTS,
+    })
+], IonBackButton);
+export { IonBackButton };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IonBackButton, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: BACK_BUTTON_INPUTS,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IonRouterOutlet, decorators: [{
+                    type: Optional
+                }] }, { type: i2.NavController }, { type: i3.Config }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/directives/navigation/nav-params.mjs

@@ -0,0 +1,47 @@
+/**
+ * @description
+ * NavParams are an object that exists on a page and can contain data for that particular view.
+ * Similar to how data was pass to a view in V1 with `$stateParams`, NavParams offer a much more flexible
+ * option with a simple `get` method.
+ *
+ * @usage
+ * ```ts
+ * import { NavParams } from '@ionic/angular';
+ *
+ * export class MyClass{
+ *
+ *  constructor(navParams: NavParams){
+ *    // userParams is an object we have in our nav-parameters
+ *    navParams.get('userParams');
+ *  }
+ *
+ * }
+ * ```
+ */
+export class NavParams {
+    data;
+    constructor(data = {}) {
+        this.data = data;
+        console.warn(`[Ionic Warning]: NavParams has been deprecated in favor of using Angular's input API. Developers should migrate to either the @Input decorator or the Signals-based input API.`);
+    }
+    /**
+     * Get the value of a nav-parameter for the current view
+     *
+     * ```ts
+     * import { NavParams } from 'ionic-angular';
+     *
+     * export class MyClass{
+     *  constructor(public navParams: NavParams){
+     *    // userParams is an object we have in our nav-parameters
+     *    this.navParams.get('userParams');
+     *  }
+     * }
+     * ```
+     *
+     * @param param Which param you want to look up
+     */
+    get(param) {
+        return this.data[param];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/directives/navigation/nav.mjs

@@ -0,0 +1,49 @@
+import { __decorate } from "tslib";
+import { Directive, } from '@angular/core';
+import { ProxyCmp, proxyOutputs } from '../../utils/proxy';
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/angular-delegate";
+const NAV_INPUTS = ['animated', 'animation', 'root', 'rootParams', 'swipeGesture'];
+const NAV_METHODS = [
+    'push',
+    'insert',
+    'insertPages',
+    'pop',
+    'popTo',
+    'popToRoot',
+    'removeIndex',
+    'setRoot',
+    'setPages',
+    'getActive',
+    'getByIndex',
+    'canGoBack',
+    'getPrevious',
+];
+let IonNav = class IonNav {
+    z;
+    el;
+    constructor(ref, environmentInjector, injector, angularDelegate, z, c) {
+        this.z = z;
+        c.detach();
+        this.el = ref.nativeElement;
+        ref.nativeElement.delegate = angularDelegate.create(environmentInjector, injector);
+        proxyOutputs(this, this.el, ['ionNavDidChange', 'ionNavWillChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IonNav, deps: [{ token: i0.ElementRef }, { token: i0.EnvironmentInjector }, { token: i0.Injector }, { token: i1.AngularDelegate }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: IonNav, inputs: { animated: "animated", animation: "animation", root: "root", rootParams: "rootParams", swipeGesture: "swipeGesture" }, ngImport: i0 });
+};
+IonNav = __decorate([
+    ProxyCmp({
+        inputs: NAV_INPUTS,
+        methods: NAV_METHODS,
+    })
+], IonNav);
+export { IonNav };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IonNav, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: NAV_INPUTS,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.EnvironmentInjector }, { type: i0.Injector }, { type: i1.AngularDelegate }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/directives/navigation/router-link-delegate.mjs

@@ -0,0 +1,190 @@
+import { Directive, HostListener, Input, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../providers/nav-controller";
+import * as i3 from "@angular/router";
+/**
+ * Adds support for Ionic routing directions and animations to the base Angular router link directive.
+ *
+ * When the router link is clicked, the directive will assign the direction and
+ * animation so that the routing integration will transition correctly.
+ */
+class RouterLinkDelegateDirective {
+    locationStrategy;
+    navCtrl;
+    elementRef;
+    router;
+    routerLink;
+    routerDirection = 'forward';
+    routerAnimation;
+    constructor(locationStrategy, navCtrl, elementRef, router, routerLink) {
+        this.locationStrategy = locationStrategy;
+        this.navCtrl = navCtrl;
+        this.elementRef = elementRef;
+        this.router = router;
+        this.routerLink = routerLink;
+    }
+    ngOnInit() {
+        this.updateTargetUrlAndHref();
+        this.updateTabindex();
+        /**
+         * Ionic components like `ion-item` render a native anchor in their shadow DOM,
+         * so a modifier click (ctrl/meta/shift/alt) or a non-`_self` target should let
+         * the browser handle the navigation natively (new tab, new window, download)
+         * instead of navigating in-app.
+         *
+         * We listen in the capture phase so this runs before Angular's `RouterLink`
+         * handler and our own bubble-phase `onClick`. On a native-navigation intent it
+         * stops propagation to cancel the in-app navigation, but leaves `preventDefault`
+         * alone so the native anchor can still act.
+         */
+        this.elementRef.nativeElement.addEventListener('click', this.onCaptureClick, { capture: true });
+    }
+    ngOnChanges() {
+        this.updateTargetUrlAndHref();
+    }
+    ngOnDestroy() {
+        this.elementRef.nativeElement.removeEventListener('click', this.onCaptureClick, { capture: true });
+    }
+    onCaptureClick = (ev) => {
+        if (this.opensNatively(ev)) {
+            ev.stopImmediatePropagation();
+        }
+    };
+    /**
+     * True when the browser should handle the click natively instead of routing
+     * in-app: a modifier was held (ctrl/meta/shift/alt), or the host targets
+     * something other than `_self`. This mirrors the modifier set Angular's own
+     * `RouterLink` guards on, so an Ionic `routerLink` behaves like a plain anchor
+     * for new-tab, new-window, and download intents.
+     */
+    opensNatively(ev) {
+        if (ev instanceof MouseEvent && (ev.ctrlKey || ev.metaKey || ev.shiftKey || ev.altKey)) {
+            return true;
+        }
+        const target = this.elementRef.nativeElement.target;
+        return target != null && target !== '' && target !== '_self';
+    }
+    /**
+     * The `tabindex` is set to `0` by default on the host element when
+     * the `routerLink` directive is used. This causes issues with Ionic
+     * components that wrap an `a` or `button` element, such as `ion-item`.
+     * See issue https://github.com/angular/angular/issues/28345
+     *
+     * This method removes the `tabindex` attribute from the host element
+     * to allow the Ionic component to manage the focus state correctly.
+     */
+    updateTabindex() {
+        // Ionic components that render a native anchor or button element
+        const ionicComponents = [
+            'ION-BACK-BUTTON',
+            'ION-BREADCRUMB',
+            'ION-BUTTON',
+            'ION-CARD',
+            'ION-FAB-BUTTON',
+            'ION-ITEM',
+            'ION-ITEM-OPTION',
+            'ION-MENU-BUTTON',
+            'ION-SEGMENT-BUTTON',
+            'ION-TAB-BUTTON',
+        ];
+        const hostElement = this.elementRef.nativeElement;
+        if (ionicComponents.includes(hostElement.tagName)) {
+            if (hostElement.getAttribute('tabindex') === '0') {
+                hostElement.removeAttribute('tabindex');
+            }
+        }
+    }
+    updateTargetUrlAndHref() {
+        if (this.routerLink?.urlTree) {
+            const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree));
+            this.elementRef.nativeElement.href = href;
+        }
+    }
+    /**
+     * @internal
+     */
+    onClick(ev) {
+        this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation);
+        /**
+         * This prevents the browser from
+         * performing a page reload when pressing
+         * an Ionic component with routerLink.
+         * The page reload interferes with routing
+         * and causes ion-back-button to disappear
+         * since the local history is wiped on reload.
+         */
+        ev.preventDefault();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RouterLinkDelegateDirective, deps: [{ token: i1.LocationStrategy }, { token: i2.NavController }, { token: i0.ElementRef }, { token: i3.Router }, { token: i3.RouterLink, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: RouterLinkDelegateDirective, selector: ":not(a):not(area)[routerLink]", inputs: { routerDirection: "routerDirection", routerAnimation: "routerAnimation" }, host: { listeners: { "click": "onClick($event)" } }, usesOnChanges: true, ngImport: i0 });
+}
+export { RouterLinkDelegateDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RouterLinkDelegateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: ':not(a):not(area)[routerLink]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocationStrategy }, { type: i2.NavController }, { type: i0.ElementRef }, { type: i3.Router }, { type: i3.RouterLink, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { routerDirection: [{
+                type: Input
+            }], routerAnimation: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+class RouterLinkWithHrefDelegateDirective {
+    locationStrategy;
+    navCtrl;
+    elementRef;
+    router;
+    routerLink;
+    routerDirection = 'forward';
+    routerAnimation;
+    constructor(locationStrategy, navCtrl, elementRef, router, routerLink) {
+        this.locationStrategy = locationStrategy;
+        this.navCtrl = navCtrl;
+        this.elementRef = elementRef;
+        this.router = router;
+        this.routerLink = routerLink;
+    }
+    ngOnInit() {
+        this.updateTargetUrlAndHref();
+    }
+    ngOnChanges() {
+        this.updateTargetUrlAndHref();
+    }
+    updateTargetUrlAndHref() {
+        if (this.routerLink?.urlTree) {
+            const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree));
+            this.elementRef.nativeElement.href = href;
+        }
+    }
+    /**
+     * @internal
+     */
+    onClick() {
+        this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RouterLinkWithHrefDelegateDirective, deps: [{ token: i1.LocationStrategy }, { token: i2.NavController }, { token: i0.ElementRef }, { token: i3.Router }, { token: i3.RouterLink, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: RouterLinkWithHrefDelegateDirective, selector: "a[routerLink],area[routerLink]", inputs: { routerDirection: "routerDirection", routerAnimation: "routerAnimation" }, host: { listeners: { "click": "onClick()" } }, usesOnChanges: true, ngImport: i0 });
+}
+export { RouterLinkWithHrefDelegateDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RouterLinkWithHrefDelegateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'a[routerLink],area[routerLink]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocationStrategy }, { type: i2.NavController }, { type: i0.ElementRef }, { type: i3.Router }, { type: i3.RouterLink, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { routerDirection: [{
+                type: Input
+            }], routerAnimation: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router-link-delegate.js","sourceRoot":"","sources":["../../../../../common/src/directives/navigation/router-link-delegate.ts"],"names":[],"mappings":"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","sourcesContent":["import { LocationStrategy } from '@angular/common';\nimport { ElementRef, OnChanges, OnDestroy, OnInit, Directive, HostListener, Input, Optional } from '@angular/core';\nimport { Router, RouterLink } from '@angular/router';\nimport type { AnimationBuilder, RouterDirection } from '@ionic/core/components';\n\nimport { NavController } from '../../providers/nav-controller';\n\n/**\n * Adds support for Ionic routing directions and animations to the base Angular router link directive.\n *\n * When the router link is clicked, the directive will assign the direction and\n * animation so that the routing integration will transition correctly.\n */\n@Directive({\n  selector: ':not(a):not(area)[routerLink]',\n})\nexport class RouterLinkDelegateDirective implements OnInit, OnChanges, OnDestroy {\n  @Input()\n  routerDirection: RouterDirection = 'forward';\n\n  @Input()\n  routerAnimation?: AnimationBuilder;\n\n  constructor(\n    private locationStrategy: LocationStrategy,\n    private navCtrl: NavController,\n    private elementRef: ElementRef,\n    private router: Router,\n    @Optional() private routerLink?: RouterLink\n  ) {}\n\n  ngOnInit(): void {\n    this.updateTargetUrlAndHref();\n    this.updateTabindex();\n\n    /**\n     * Ionic components like `ion-item` render a native anchor in their shadow DOM,\n     * so a modifier click (ctrl/meta/shift/alt) or a non-`_self` target should let\n     * the browser handle the navigation natively (new tab, new window, download)\n     * instead of navigating in-app.\n     *\n     * We listen in the capture phase so this runs before Angular's `RouterLink`\n     * handler and our own bubble-phase `onClick`. On a native-navigation intent it\n     * stops propagation to cancel the in-app navigation, but leaves `preventDefault`\n     * alone so the native anchor can still act.\n     */\n    this.elementRef.nativeElement.addEventListener('click', this.onCaptureClick, { capture: true });\n  }\n\n  ngOnChanges(): void {\n    this.updateTargetUrlAndHref();\n  }\n\n  ngOnDestroy(): void {\n    this.elementRef.nativeElement.removeEventListener('click', this.onCaptureClick, { capture: true });\n  }\n\n  private onCaptureClick = (ev: Event): void => {\n    if (this.opensNatively(ev)) {\n      ev.stopImmediatePropagation();\n    }\n  };\n\n  /**\n   * True when the browser should handle the click natively instead of routing\n   * in-app: a modifier was held (ctrl/meta/shift/alt), or the host targets\n   * something other than `_self`. This mirrors the modifier set Angular's own\n   * `RouterLink` guards on, so an Ionic `routerLink` behaves like a plain anchor\n   * for new-tab, new-window, and download intents.\n   */\n  private opensNatively(ev: Event): boolean {\n    if (ev instanceof MouseEvent && (ev.ctrlKey || ev.metaKey || ev.shiftKey || ev.altKey)) {\n      return true;\n    }\n\n    const target = this.elementRef.nativeElement.target;\n    return target != null && target !== '' && target !== '_self';\n  }\n\n  /**\n   * The `tabindex` is set to `0` by default on the host element when\n   * the `routerLink` directive is used. This causes issues with Ionic\n   * components that wrap an `a` or `button` element, such as `ion-item`.\n   * See issue https://github.com/angular/angular/issues/28345\n   *\n   * This method removes the `tabindex` attribute from the host element\n   * to allow the Ionic component to manage the focus state correctly.\n   */\n  private updateTabindex() {\n    // Ionic components that render a native anchor or button element\n    const ionicComponents = [\n      'ION-BACK-BUTTON',\n      'ION-BREADCRUMB',\n      'ION-BUTTON',\n      'ION-CARD',\n      'ION-FAB-BUTTON',\n      'ION-ITEM',\n      'ION-ITEM-OPTION',\n      'ION-MENU-BUTTON',\n      'ION-SEGMENT-BUTTON',\n      'ION-TAB-BUTTON',\n    ];\n    const hostElement = this.elementRef.nativeElement;\n\n    if (ionicComponents.includes(hostElement.tagName)) {\n      if (hostElement.getAttribute('tabindex') === '0') {\n        hostElement.removeAttribute('tabindex');\n      }\n    }\n  }\n\n  private updateTargetUrlAndHref() {\n    if (this.routerLink?.urlTree) {\n      const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree));\n      this.elementRef.nativeElement.href = href;\n    }\n  }\n\n  /**\n   * @internal\n   */\n  @HostListener('click', ['$event'])\n  onClick(ev: UIEvent): void {\n    this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation);\n\n    /**\n     * This prevents the browser from\n     * performing a page reload when pressing\n     * an Ionic component with routerLink.\n     * The page reload interferes with routing\n     * and causes ion-back-button to disappear\n     * since the local history is wiped on reload.\n     */\n    ev.preventDefault();\n  }\n}\n\n@Directive({\n  selector: 'a[routerLink],area[routerLink]',\n})\nexport class RouterLinkWithHrefDelegateDirective implements OnInit, OnChanges {\n  @Input()\n  routerDirection: RouterDirection = 'forward';\n\n  @Input()\n  routerAnimation?: AnimationBuilder;\n\n  constructor(\n    private locationStrategy: LocationStrategy,\n    private navCtrl: NavController,\n    private elementRef: ElementRef,\n    private router: Router,\n    @Optional() private routerLink?: RouterLink\n  ) {}\n\n  ngOnInit(): void {\n    this.updateTargetUrlAndHref();\n  }\n\n  ngOnChanges(): void {\n    this.updateTargetUrlAndHref();\n  }\n\n  private updateTargetUrlAndHref() {\n    if (this.routerLink?.urlTree) {\n      const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree));\n      this.elementRef.nativeElement.href = href;\n    }\n  }\n\n  /**\n   * @internal\n   */\n  @HostListener('click')\n  onClick(): void {\n    this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation);\n  }\n}\n"]}