@ionic/angular 8.0.0-dev.11709245047.1565a499 → 8.0.0-dev.11711035263.183d2423

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

@@ -8,5 +8,5 @@ import * as i0 from "@angular/core";
 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>;
+    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

@@ -8,5 +8,5 @@ import * as i0 from "@angular/core";
 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>;
+    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/common/directives/control-value-accessors/value-accessor.mjs

@@ -0,0 +1,145 @@
+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
+export 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);
+        }
+    }
+    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 });
+}
+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  }\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,46 @@
+/**
+ * @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;
+    }
+    /**
+     * 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,123 @@
+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.
+ */
+export 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();
+    }
+    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(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 });
+}
+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']]
+            }] } });
+export 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 });
+}
+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,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