@ionic/angular 8.8.9-dev.11779411201.1a483e09 → 8.8.9-dev.11780349068.18c33698

package/common/providers/dom-controller.d.ts

@@ -1,16 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class DomController {
-    /**
-     * Schedules a task to run during the READ phase of the next frame.
-     * This task should only read the DOM, but never modify it.
-     */
-    read(cb: RafCallback): void;
-    /**
-     * Schedules a task to run during the WRITE phase of the next frame.
-     * This task should write the DOM, but never READ it.
-     */
-    write(cb: RafCallback): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DomController, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DomController>;
-}
-export type RafCallback = (timeStamp?: number) => void;

package/common/providers/menu-controller.d.ts

@@ -1,78 +0,0 @@
-import type { MenuControllerI, AnimationBuilder, MenuI, Animation } from '@ionic/core/components';
-export declare class MenuController implements MenuControllerI {
-    private menuController;
-    constructor(menuController: MenuControllerI);
-    /**
-     * Programmatically open the Menu.
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return returns a promise when the menu is fully opened
-     */
-    open(menuId?: string): Promise<boolean>;
-    /**
-     * Programmatically close the Menu. If no `menuId` is given as the first
-     * argument then it'll close any menu which is open. If a `menuId`
-     * is given then it'll close that exact menu.
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return returns a promise when the menu is fully closed
-     */
-    close(menuId?: string): Promise<boolean>;
-    /**
-     * Toggle the menu. If it's closed, it will open, and if opened, it
-     * will close.
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return returns a promise when the menu has been toggled
-     */
-    toggle(menuId?: string): Promise<boolean>;
-    /**
-     * Used to enable or disable a menu. For example, there could be multiple
-     * left menus, but only one of them should be able to be opened at the same
-     * time. If there are multiple menus on the same side, then enabling one menu
-     * will also automatically disable all the others that are on the same side.
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return Returns the instance of the menu, which is useful for chaining.
-     */
-    enable(shouldEnable: boolean, menuId?: string): Promise<HTMLIonMenuElement | undefined>;
-    /**
-     * Used to enable or disable the ability to swipe open the menu.
-     * @param shouldEnable  True if it should be swipe-able, false if not.
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return Returns the instance of the menu, which is useful for chaining.
-     */
-    swipeGesture(shouldEnable: boolean, menuId?: string): Promise<HTMLIonMenuElement | undefined>;
-    /**
-     * @param [menuId] Optionally get the menu by its id, or side.
-     * @return Returns true if the specified menu is currently open, otherwise false.
-     * If the menuId is not specified, it returns true if ANY menu is currenly open.
-     */
-    isOpen(menuId?: string): Promise<boolean>;
-    /**
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return Returns true if the menu is currently enabled, otherwise false.
-     */
-    isEnabled(menuId?: string): Promise<boolean>;
-    /**
-     * Used to get a menu instance. If a `menuId` is not provided then it'll
-     * return the first menu found. If a `menuId` is `left` or `right`, then
-     * it'll return the enabled menu on that side. Otherwise, if a `menuId` is
-     * provided, then it'll try to find the menu using the menu's `id`
-     * property. If a menu is not found then it'll return `null`.
-     * @param [menuId]  Optionally get the menu by its id, or side.
-     * @return Returns the instance of the menu if found, otherwise `null`.
-     */
-    get(menuId?: string): Promise<HTMLIonMenuElement | undefined>;
-    /**
-     * @return Returns the instance of the menu already opened, otherwise `null`.
-     */
-    getOpen(): Promise<HTMLIonMenuElement | undefined>;
-    /**
-     * @return Returns an array of all menu instances.
-     */
-    getMenus(): Promise<HTMLIonMenuElement[]>;
-    registerAnimation(name: string, animation: AnimationBuilder): void;
-    isAnimating(): Promise<boolean>;
-    _getOpenSync(): HTMLIonMenuElement | undefined;
-    _createAnimation(type: string, menuCmp: MenuI): Promise<Animation>;
-    _register(menu: MenuI): void;
-    _unregister(menu: MenuI): void;
-    _setOpen(menu: MenuI, shouldOpen: boolean, animated: boolean): Promise<boolean>;
-}

package/common/providers/nav-controller.d.ts

@@ -1,116 +0,0 @@
-import { Location } from '@angular/common';
-import { NavigationExtras, Router, UrlSerializer, UrlTree } from '@angular/router';
-import type { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core/components';
-import { IonRouterOutlet } from '../directives/navigation/router-outlet';
-import { Platform } from './platform';
-import * as i0 from "@angular/core";
-export interface AnimationOptions {
-    animated?: boolean;
-    animation?: AnimationBuilder;
-    animationDirection?: 'forward' | 'back';
-}
-export interface NavigationOptions extends NavigationExtras, AnimationOptions {
-}
-export declare class NavController {
-    private location;
-    private serializer;
-    private router?;
-    private topOutlet?;
-    private direction;
-    private animated?;
-    private animationBuilder?;
-    private guessDirection;
-    private guessAnimation?;
-    private lastNavId;
-    constructor(platform: Platform, location: Location, serializer: UrlSerializer, router?: Router | undefined);
-    /**
-     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
-     * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.
-     *
-     * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),
-     * and that it will show a "forward" animation by default.
-     *
-     * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:
-     *
-     * ```html
-     * <a routerLink="/path/to/page" routerDirection="forward">Link</a>
-     * ```
-     */
-    navigateForward(url: string | UrlTree | any[], options?: NavigationOptions): Promise<boolean>;
-    /**
-     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
-     * it's equivalent to calling:
-     *
-     * ```ts
-     * this.navController.setDirection('back');
-     * this.router.navigateByUrl(path);
-     * ```
-     *
-     * Going **back** means that all the pages in the stack until the navigated page is found will be popped,
-     * and that it will show a "back" animation by default.
-     *
-     * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:
-     *
-     * ```html
-     * <a routerLink="/path/to/page" routerDirection="back">Link</a>
-     * ```
-     */
-    navigateBack(url: string | UrlTree | any[], options?: NavigationOptions): Promise<boolean>;
-    /**
-     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
-     * it's equivalent to calling:
-     *
-     * ```ts
-     * this.navController.setDirection('root');
-     * this.router.navigateByUrl(path);
-     * ```
-     *
-     * Going **root** means that all existing pages in the stack will be removed,
-     * and the navigated page will become the single page in the stack.
-     *
-     * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:
-     *
-     * ```html
-     * <a routerLink="/path/to/page" routerDirection="root">Link</a>
-     * ```
-     */
-    navigateRoot(url: string | UrlTree | any[], options?: NavigationOptions): Promise<boolean>;
-    /**
-     * Same as [Location](https://angular.io/api/common/Location)'s back() method.
-     * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation
-     * by default.
-     */
-    back(options?: AnimationOptions): void;
-    /**
-     * This methods goes back in the context of Ionic's stack navigation.
-     *
-     * It recursively finds the top active `ion-router-outlet` and calls `pop()`.
-     * This is the recommended way to go back when you are using `ion-router-outlet`.
-     *
-     * Resolves to `true` if it was able to pop.
-     */
-    pop(): Promise<boolean>;
-    /**
-     * This methods specifies the direction of the next navigation performed by the Angular router.
-     *
-     * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.
-     *
-     * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.
-     */
-    setDirection(direction: RouterDirection, animated?: boolean, animationDirection?: 'forward' | 'back', animationBuilder?: AnimationBuilder): void;
-    /**
-     * @internal
-     */
-    setTopOutlet(outlet: IonRouterOutlet): void;
-    /**
-     * @internal
-     */
-    consumeTransition(): {
-        direction: RouterDirection;
-        animation: NavDirection | undefined;
-        animationBuilder: AnimationBuilder | undefined;
-    };
-    private navigate;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NavController, [null, null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NavController>;
-}

package/common/providers/platform.d.ts

@@ -1,174 +0,0 @@
-import { NgZone } from '@angular/core';
-import type { BackButtonEventDetail, KeyboardEventDetail, Platforms } from '@ionic/core/components';
-import { Subscription, Subject } from 'rxjs';
-import * as i0 from "@angular/core";
-export interface BackButtonEmitter extends Subject<BackButtonEventDetail> {
-    subscribeWithPriority(priority: number, callback: (processNextHandler: () => void) => Promise<any> | void): Subscription;
-}
-export declare class Platform {
-    private doc;
-    private _readyPromise;
-    private win;
-    /**
-     * @hidden
-     */
-    backButton: BackButtonEmitter;
-    /**
-     * The keyboardDidShow event emits when the
-     * on-screen keyboard is presented.
-     */
-    keyboardDidShow: Subject<KeyboardEventDetail>;
-    /**
-     * The keyboardDidHide event emits when the
-     * on-screen keyboard is hidden.
-     */
-    keyboardDidHide: Subject<void>;
-    /**
-     * The pause event emits when the native platform puts the application
-     * into the background, typically when the user switches to a different
-     * application. This event would emit when a Cordova app is put into
-     * the background, however, it would not fire on a standard web browser.
-     */
-    pause: Subject<void>;
-    /**
-     * The resume event emits when the native platform pulls the application
-     * out from the background. This event would emit when a Cordova app comes
-     * out from the background, however, it would not fire on a standard web browser.
-     */
-    resume: Subject<void>;
-    /**
-     * The resize event emits when the browser window has changed dimensions. This
-     * could be from a browser window being physically resized, or from a device
-     * changing orientation.
-     */
-    resize: Subject<void>;
-    constructor(doc: any, zone: NgZone);
-    /**
-     * @returns returns true/false based on platform.
-     * @description
-     * Depending on the platform the user is on, `is(platformName)` will
-     * return `true` or `false`. Note that the same app can return `true`
-     * for more than one platform name. For example, an app running from
-     * an iPad would return `true` for the platform names: `mobile`,
-     * `ios`, `ipad`, and `tablet`. Additionally, if the app was running
-     * from Cordova then `cordova` would be true, and if it was running
-     * from a web browser on the iPad then `mobileweb` would be `true`.
-     *
-     * ```
-     * import { Platform } from 'ionic-angular';
-     *
-     * @Component({...})
-     * export MyPage {
-     *   constructor(public platform: Platform) {
-     *     if (this.platform.is('ios')) {
-     *       // This will only print when on iOS
-     *       console.log('I am an iOS device!');
-     *     }
-     *   }
-     * }
-     * ```
-     *
-     * | Platform Name   | Description                        |
-     * |-----------------|------------------------------------|
-     * | android         | on a device running Android.       |
-     * | capacitor       | on a device running Capacitor.     |
-     * | cordova         | on a device running Cordova.       |
-     * | ios             | on a device running iOS.           |
-     * | ipad            | on an iPad device.                 |
-     * | iphone          | on an iPhone device.               |
-     * | phablet         | on a phablet device.               |
-     * | tablet          | on a tablet device.                |
-     * | electron        | in Electron on a desktop device.   |
-     * | pwa             | as a PWA app.                      |
-     * | mobile          | on a mobile device.                |
-     * | mobileweb       | on a mobile device in a browser.   |
-     * | desktop         | on a desktop device.               |
-     * | hybrid          | is a cordova or capacitor app.     |
-     *
-     */
-    is(platformName: Platforms): boolean;
-    /**
-     * @returns the array of platforms
-     * @description
-     * Depending on what device you are on, `platforms` can return multiple values.
-     * Each possible value is a hierarchy of platforms. For example, on an iPhone,
-     * it would return `mobile`, `ios`, and `iphone`.
-     *
-     * ```
-     * import { Platform } from 'ionic-angular';
-     *
-     * @Component({...})
-     * export MyPage {
-     *   constructor(public platform: Platform) {
-     *     // This will print an array of the current platforms
-     *     console.log(this.platform.platforms());
-     *   }
-     * }
-     * ```
-     */
-    platforms(): string[];
-    /**
-     * Returns a promise when the platform is ready and native functionality
-     * can be called. If the app is running from within a web browser, then
-     * the promise will resolve when the DOM is ready. When the app is running
-     * from an application engine such as Cordova, then the promise will
-     * resolve when Cordova triggers the `deviceready` event.
-     *
-     * The resolved value is the `readySource`, which states which platform
-     * ready was used. For example, when Cordova is ready, the resolved ready
-     * source is `cordova`. The default ready source value will be `dom`. The
-     * `readySource` is useful if different logic should run depending on the
-     * platform the app is running from. For example, only Cordova can execute
-     * the status bar plugin, so the web should not run status bar plugin logic.
-     *
-     * ```
-     * import { Component } from '@angular/core';
-     * import { Platform } from 'ionic-angular';
-     *
-     * @Component({...})
-     * export MyApp {
-     *   constructor(public platform: Platform) {
-     *     this.platform.ready().then((readySource) => {
-     *       console.log('Platform ready from', readySource);
-     *       // Platform now ready, execute any required native code
-     *     });
-     *   }
-     * }
-     * ```
-     */
-    ready(): Promise<string>;
-    /**
-     * Returns if this app is using right-to-left language direction or not.
-     * We recommend the app's `index.html` file already has the correct `dir`
-     * attribute value set, such as `<html dir="ltr">` or `<html dir="rtl">`.
-     * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir)
-     */
-    get isRTL(): boolean;
-    /**
-     * Get the query string parameter
-     */
-    getQueryParam(key: string): string | null;
-    /**
-     * Returns `true` if the app is in landscape mode.
-     */
-    isLandscape(): boolean;
-    /**
-     * Returns `true` if the app is in portrait mode.
-     */
-    isPortrait(): boolean;
-    testUserAgent(expression: string): boolean;
-    /**
-     * Get the current url.
-     */
-    url(): string;
-    /**
-     * Gets the width of the platform's viewport using `window.innerWidth`.
-     */
-    width(): number;
-    /**
-     * Gets the height of the platform's viewport using `window.innerHeight`.
-     */
-    height(): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Platform, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Platform>;
-}

package/common/types/interfaces.d.ts

@@ -1,8 +0,0 @@
-export interface IonicGlobal {
-    config?: any;
-    asyncQueue?: boolean;
-}
-export interface IonicWindow extends Window {
-    Ionic: IonicGlobal;
-    __zone_symbol__requestAnimationFrame?: (ts: FrameRequestCallback) => number;
-}

package/common/types/ionic-lifecycle-hooks.d.ts

@@ -1,27 +0,0 @@
-/**
- *  https://ionicframework.com/docs/api/router-outlet#life-cycle-hooks
- */
-export interface ViewWillEnter {
-    /**
-     * Fired when the component routing to is about to animate into view.
-     */
-    ionViewWillEnter(): void;
-}
-export interface ViewDidEnter {
-    /**
-     * Fired when the component routing to has finished animating.
-     */
-    ionViewDidEnter(): void;
-}
-export interface ViewWillLeave {
-    /**
-     * Fired when the component routing from is about to animate.
-     */
-    ionViewWillLeave(): void;
-}
-export interface ViewDidLeave {
-    /**
-     * Fired when the component routing to has finished animating.
-     */
-    ionViewDidLeave(): void;
-}

package/common/types/overlay-options.d.ts

@@ -1,16 +0,0 @@
-import type { Injector } from '@angular/core';
-import type { ComponentRef, ModalOptions as CoreModalOptions, PopoverOptions as CorePopoverOptions } from '@ionic/core/components';
-/**
- * Modal options with Angular-specific injector support.
- * Extends @ionic/core ModalOptions with an optional injector property.
- */
-export type ModalOptions<T extends ComponentRef = ComponentRef> = CoreModalOptions<T> & {
-    injector?: Injector;
-};
-/**
- * Popover options with Angular-specific injector support.
- * Extends @ionic/core PopoverOptions with an optional injector property.
- */
-export type PopoverOptions<T extends ComponentRef = ComponentRef> = CorePopoverOptions<T> & {
-    injector?: Injector;
-};

package/common/utils/overlay.d.ts

@@ -1,21 +0,0 @@
-export interface ControllerShape<Opts, HTMLElm> {
-    create(options: Opts): Promise<HTMLElm>;
-    dismiss(data?: any, role?: string, id?: string): Promise<boolean>;
-    getTop(): Promise<HTMLElm | undefined>;
-}
-export declare class OverlayBaseController<Opts, Overlay> implements ControllerShape<Opts, Overlay> {
-    private ctrl;
-    constructor(ctrl: ControllerShape<Opts, Overlay>);
-    /**
-     * Creates a new overlay
-     */
-    create(opts?: Opts): Promise<Overlay>;
-    /**
-     * When `id` is not provided, it dismisses the top overlay.
-     */
-    dismiss(data?: any, role?: string, id?: string): Promise<boolean>;
-    /**
-     * Returns the top overlay.
-     */
-    getTop(): Promise<Overlay | undefined>;
-}

package/common/utils/proxy.d.ts

@@ -1,8 +0,0 @@
-export declare const proxyInputs: (Cmp: any, inputs: string[]) => void;
-export declare const proxyMethods: (Cmp: any, methods: string[]) => void;
-export declare const proxyOutputs: (instance: any, el: any, events: string[]) => void;
-export declare function ProxyCmp(opts: {
-    defineCustomElementFn?: () => void;
-    inputs?: any;
-    methods?: any;
-}): (cls: any) => any;

package/common/utils/routing.d.ts

@@ -1,28 +0,0 @@
-import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy } from '@angular/router';
-/**
- * Provides a way to customize when activated routes get reused.
- */
-export declare class IonicRouteStrategy implements RouteReuseStrategy {
-    /**
-     * Whether the given route should detach for later reuse.
-     */
-    shouldDetach(_route: ActivatedRouteSnapshot): boolean;
-    /**
-     * Returns `false`, meaning the route (and its subtree) is never reattached
-     */
-    shouldAttach(_route: ActivatedRouteSnapshot): boolean;
-    /**
-     * A no-op; the route is never stored since this strategy never detaches routes for later re-use.
-     */
-    store(_route: ActivatedRouteSnapshot, _detachedTree: DetachedRouteHandle): void;
-    /**
-     * Returns `null` because this strategy does not store routes for later re-use.
-     */
-    retrieve(_route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
-    /**
-     * Determines if a route should be reused.
-     * This strategy returns `true` when the future route config and
-     * current route config are identical and all route parameters are identical.
-     */
-    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
-}

package/common/utils/util.d.ts

@@ -1 +0,0 @@
-export declare const raf: (h: any) => any;