@ionic/angular 7.4.2-dev.11695667578.1539f05b → 7.4.2-dev.11695737717.1804b7c2

package/esm2020/providers/platform.mjs

@@ -0,0 +1,246 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { getPlatforms, isPlatform } from '@ionic/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class Platform {
+    constructor(doc, zone) {
+        this.doc = doc;
+        /**
+         * @hidden
+         */
+        this.backButton = new Subject();
+        /**
+         * The keyboardDidShow event emits when the
+         * on-screen keyboard is presented.
+         */
+        this.keyboardDidShow = new Subject();
+        /**
+         * The keyboardDidHide event emits when the
+         * on-screen keyboard is hidden.
+         */
+        this.keyboardDidHide = new Subject();
+        /**
+         * 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.
+         */
+        this.pause = new Subject();
+        /**
+         * 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.
+         */
+        this.resume = new Subject();
+        /**
+         * 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.
+         */
+        this.resize = new Subject();
+        zone.run(() => {
+            this.win = doc.defaultView;
+            this.backButton.subscribeWithPriority = function (priority, callback) {
+                return this.subscribe((ev) => {
+                    return ev.register(priority, (processNextHandler) => zone.run(() => callback(processNextHandler)));
+                });
+            };
+            proxyEvent(this.pause, doc, 'pause');
+            proxyEvent(this.resume, doc, 'resume');
+            proxyEvent(this.backButton, doc, 'ionBackButton');
+            proxyEvent(this.resize, this.win, 'resize');
+            proxyEvent(this.keyboardDidShow, this.win, 'ionKeyboardDidShow');
+            proxyEvent(this.keyboardDidHide, this.win, 'ionKeyboardDidHide');
+            let readyResolve;
+            this._readyPromise = new Promise((res) => {
+                readyResolve = res;
+            });
+            if (this.win?.['cordova']) {
+                doc.addEventListener('deviceready', () => {
+                    readyResolve('cordova');
+                }, { once: true });
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                readyResolve('dom');
+            }
+        });
+    }
+    /**
+     * @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) {
+        return isPlatform(this.win, platformName);
+    }
+    /**
+     * @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() {
+        return getPlatforms(this.win);
+    }
+    /**
+     * 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() {
+        return this._readyPromise;
+    }
+    /**
+     * 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() {
+        return this.doc.dir === 'rtl';
+    }
+    /**
+     * Get the query string parameter
+     */
+    getQueryParam(key) {
+        return readQueryParam(this.win.location.href, key);
+    }
+    /**
+     * Returns `true` if the app is in landscape mode.
+     */
+    isLandscape() {
+        return !this.isPortrait();
+    }
+    /**
+     * Returns `true` if the app is in portrait mode.
+     */
+    isPortrait() {
+        return this.win.matchMedia?.('(orientation: portrait)').matches;
+    }
+    testUserAgent(expression) {
+        const nav = this.win.navigator;
+        return !!(nav?.userAgent && nav.userAgent.indexOf(expression) >= 0);
+    }
+    /**
+     * Get the current url.
+     */
+    url() {
+        return this.win.location.href;
+    }
+    /**
+     * Gets the width of the platform's viewport using `window.innerWidth`.
+     */
+    width() {
+        return this.win.innerWidth;
+    }
+    /**
+     * Gets the height of the platform's viewport using `window.innerHeight`.
+     */
+    height() {
+        return this.win.innerHeight;
+    }
+}
+/** @nocollapse */ Platform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: Platform, deps: [{ token: DOCUMENT }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ Platform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: Platform, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: Platform, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.NgZone }]; } });
+const readQueryParam = (url, key) => {
+    key = key.replace(/[[\]\\]/g, '\\$&');
+    const regex = new RegExp('[\\?&]' + key + '=([^&#]*)');
+    const results = regex.exec(url);
+    return results ? decodeURIComponent(results[1].replace(/\+/g, ' ')) : null;
+};
+const proxyEvent = (emitter, el, eventName) => {
+    if (el) {
+        el.addEventListener(eventName, (ev) => {
+            // ?? cordova might emit "null" events
+            const value = ev != null ? ev.detail : undefined;
+            emitter.next(value);
+        });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../../src/providers/platform.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { NgZone, Inject, Injectable } from '@angular/core';\nimport { BackButtonEventDetail, KeyboardEventDetail, Platforms, getPlatforms, isPlatform } from '@ionic/core';\nimport { Subscription, Subject } from 'rxjs';\n\n// TODO(FW-2827): types\n\nexport interface BackButtonEmitter extends Subject<BackButtonEventDetail> {\n  subscribeWithPriority(\n    priority: number,\n    callback: (processNextHandler: () => void) => Promise<any> | void\n  ): Subscription;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Platform {\n  private _readyPromise: Promise<string>;\n  private win: any;\n\n  /**\n   * @hidden\n   */\n  backButton: BackButtonEmitter = new Subject<BackButtonEventDetail>() as any;\n\n  /**\n   * The keyboardDidShow event emits when the\n   * on-screen keyboard is presented.\n   */\n  keyboardDidShow = new Subject<KeyboardEventDetail>() as any;\n\n  /**\n   * The keyboardDidHide event emits when the\n   * on-screen keyboard is hidden.\n   */\n  keyboardDidHide = new Subject<void>();\n\n  /**\n   * The pause event emits when the native platform puts the application\n   * into the background, typically when the user switches to a different\n   * application. This event would emit when a Cordova app is put into\n   * the background, however, it would not fire on a standard web browser.\n   */\n  pause = new Subject<void>();\n\n  /**\n   * The resume event emits when the native platform pulls the application\n   * out from the background. This event would emit when a Cordova app comes\n   * out from the background, however, it would not fire on a standard web browser.\n   */\n  resume = new Subject<void>();\n\n  /**\n   * The resize event emits when the browser window has changed dimensions. This\n   * could be from a browser window being physically resized, or from a device\n   * changing orientation.\n   */\n  resize = new Subject<void>();\n\n  constructor(@Inject(DOCUMENT) private doc: any, zone: NgZone) {\n    zone.run(() => {\n      this.win = doc.defaultView;\n      this.backButton.subscribeWithPriority = function (priority, callback) {\n        return this.subscribe((ev) => {\n          return ev.register(priority, (processNextHandler) => zone.run(() => callback(processNextHandler)));\n        });\n      };\n\n      proxyEvent(this.pause, doc, 'pause');\n      proxyEvent(this.resume, doc, 'resume');\n      proxyEvent(this.backButton, doc, 'ionBackButton');\n      proxyEvent(this.resize, this.win, 'resize');\n      proxyEvent(this.keyboardDidShow, this.win, 'ionKeyboardDidShow');\n      proxyEvent(this.keyboardDidHide, this.win, 'ionKeyboardDidHide');\n\n      let readyResolve: (value: string) => void;\n      this._readyPromise = new Promise((res) => {\n        readyResolve = res;\n      });\n      if (this.win?.['cordova']) {\n        doc.addEventListener(\n          'deviceready',\n          () => {\n            readyResolve('cordova');\n          },\n          { once: true }\n        );\n      } else {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        readyResolve!('dom');\n      }\n    });\n  }\n\n  /**\n   * @returns returns true/false based on platform.\n   * @description\n   * Depending on the platform the user is on, `is(platformName)` will\n   * return `true` or `false`. Note that the same app can return `true`\n   * for more than one platform name. For example, an app running from\n   * an iPad would return `true` for the platform names: `mobile`,\n   * `ios`, `ipad`, and `tablet`. Additionally, if the app was running\n   * from Cordova then `cordova` would be true, and if it was running\n   * from a web browser on the iPad then `mobileweb` would be `true`.\n   *\n   * ```\n   * import { Platform } from 'ionic-angular';\n   *\n   * @Component({...})\n   * export MyPage {\n   *   constructor(public platform: Platform) {\n   *     if (this.platform.is('ios')) {\n   *       // This will only print when on iOS\n   *       console.log('I am an iOS device!');\n   *     }\n   *   }\n   * }\n   * ```\n   *\n   * | Platform Name   | Description                        |\n   * |-----------------|------------------------------------|\n   * | android         | on a device running Android.       |\n   * | capacitor       | on a device running Capacitor.     |\n   * | cordova         | on a device running Cordova.       |\n   * | ios             | on a device running iOS.           |\n   * | ipad            | on an iPad device.                 |\n   * | iphone          | on an iPhone device.               |\n   * | phablet         | on a phablet device.               |\n   * | tablet          | on a tablet device.                |\n   * | electron        | in Electron on a desktop device.   |\n   * | pwa             | as a PWA app.                      |\n   * | mobile          | on a mobile device.                |\n   * | mobileweb       | on a mobile device in a browser.   |\n   * | desktop         | on a desktop device.               |\n   * | hybrid          | is a cordova or capacitor app.     |\n   *\n   */\n  is(platformName: Platforms): boolean {\n    return isPlatform(this.win, platformName);\n  }\n\n  /**\n   * @returns the array of platforms\n   * @description\n   * Depending on what device you are on, `platforms` can return multiple values.\n   * Each possible value is a hierarchy of platforms. For example, on an iPhone,\n   * it would return `mobile`, `ios`, and `iphone`.\n   *\n   * ```\n   * import { Platform } from 'ionic-angular';\n   *\n   * @Component({...})\n   * export MyPage {\n   *   constructor(public platform: Platform) {\n   *     // This will print an array of the current platforms\n   *     console.log(this.platform.platforms());\n   *   }\n   * }\n   * ```\n   */\n  platforms(): string[] {\n    return getPlatforms(this.win);\n  }\n\n  /**\n   * Returns a promise when the platform is ready and native functionality\n   * can be called. If the app is running from within a web browser, then\n   * the promise will resolve when the DOM is ready. When the app is running\n   * from an application engine such as Cordova, then the promise will\n   * resolve when Cordova triggers the `deviceready` event.\n   *\n   * The resolved value is the `readySource`, which states which platform\n   * ready was used. For example, when Cordova is ready, the resolved ready\n   * source is `cordova`. The default ready source value will be `dom`. The\n   * `readySource` is useful if different logic should run depending on the\n   * platform the app is running from. For example, only Cordova can execute\n   * the status bar plugin, so the web should not run status bar plugin logic.\n   *\n   * ```\n   * import { Component } from '@angular/core';\n   * import { Platform } from 'ionic-angular';\n   *\n   * @Component({...})\n   * export MyApp {\n   *   constructor(public platform: Platform) {\n   *     this.platform.ready().then((readySource) => {\n   *       console.log('Platform ready from', readySource);\n   *       // Platform now ready, execute any required native code\n   *     });\n   *   }\n   * }\n   * ```\n   */\n  ready(): Promise<string> {\n    return this._readyPromise;\n  }\n\n  /**\n   * Returns if this app is using right-to-left language direction or not.\n   * We recommend the app's `index.html` file already has the correct `dir`\n   * attribute value set, such as `<html dir=\"ltr\">` or `<html dir=\"rtl\">`.\n   * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir)\n   */\n  get isRTL(): boolean {\n    return this.doc.dir === 'rtl';\n  }\n\n  /**\n   * Get the query string parameter\n   */\n  getQueryParam(key: string): string | null {\n    return readQueryParam(this.win.location.href, key);\n  }\n\n  /**\n   * Returns `true` if the app is in landscape mode.\n   */\n  isLandscape(): boolean {\n    return !this.isPortrait();\n  }\n\n  /**\n   * Returns `true` if the app is in portrait mode.\n   */\n  isPortrait(): boolean {\n    return this.win.matchMedia?.('(orientation: portrait)').matches;\n  }\n\n  testUserAgent(expression: string): boolean {\n    const nav = this.win.navigator;\n    return !!(nav?.userAgent && nav.userAgent.indexOf(expression) >= 0);\n  }\n\n  /**\n   * Get the current url.\n   */\n  url(): string {\n    return this.win.location.href;\n  }\n\n  /**\n   * Gets the width of the platform's viewport using `window.innerWidth`.\n   */\n  width(): number {\n    return this.win.innerWidth;\n  }\n\n  /**\n   * Gets the height of the platform's viewport using `window.innerHeight`.\n   */\n  height(): number {\n    return this.win.innerHeight;\n  }\n}\n\nconst readQueryParam = (url: string, key: string) => {\n  key = key.replace(/[[\\]\\\\]/g, '\\\\$&');\n  const regex = new RegExp('[\\\\?&]' + key + '=([^&#]*)');\n  const results = regex.exec(url);\n  return results ? decodeURIComponent(results[1].replace(/\\+/g, ' ')) : null;\n};\n\nconst proxyEvent = <T>(emitter: Subject<T>, el: EventTarget, eventName: string) => {\n  if (el) {\n    el.addEventListener(eventName, (ev) => {\n      // ?? cordova might emit \"null\" events\n      const value = ev != null ? (ev as any).detail : undefined;\n      emitter.next(value);\n    });\n  }\n};\n"]}

package/esm2020/providers/popover-controller.mjs

@@ -0,0 +1,25 @@
+import { Injector, Injectable, inject, EnvironmentInjector } from '@angular/core';
+import { popoverController } from '@ionic/core';
+import { OverlayBaseController } from '../util/overlay';
+import { AngularDelegate } from './angular-delegate';
+import * as i0 from "@angular/core";
+export class PopoverController extends OverlayBaseController {
+    constructor() {
+        super(popoverController);
+        this.angularDelegate = inject(AngularDelegate);
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+    }
+    create(opts) {
+        return super.create({
+            ...opts,
+            delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'popover'),
+        });
+    }
+}
+/** @nocollapse */ PopoverController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PopoverController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ PopoverController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PopoverController });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PopoverController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/toast-controller.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { toastController } from '@ionic/core';
+import { OverlayBaseController } from '../util/overlay';
+import * as i0 from "@angular/core";
+export class ToastController extends OverlayBaseController {
+    constructor() {
+        super(toastController);
+    }
+}
+/** @nocollapse */ ToastController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ToastController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ ToastController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ToastController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ToastController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3QtY29udHJvbGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdG9hc3QtY29udHJvbGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBZ0IsZUFBZSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRTVELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQUt4RCxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxxQkFBd0Q7SUFDM0Y7UUFDRSxLQUFLLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDekIsQ0FBQzs7Z0lBSFUsZUFBZTtvSUFBZixlQUFlLGNBRmQsTUFBTTs0RkFFUCxlQUFlO2tCQUgzQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFRvYXN0T3B0aW9ucywgdG9hc3RDb250cm9sbGVyIH0gZnJvbSAnQGlvbmljL2NvcmUnO1xuXG5pbXBvcnQgeyBPdmVybGF5QmFzZUNvbnRyb2xsZXIgfSBmcm9tICcuLi91dGlsL292ZXJsYXknO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgVG9hc3RDb250cm9sbGVyIGV4dGVuZHMgT3ZlcmxheUJhc2VDb250cm9sbGVyPFRvYXN0T3B0aW9ucywgSFRNTElvblRvYXN0RWxlbWVudD4ge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcih0b2FzdENvbnRyb2xsZXIpO1xuICB9XG59XG4iXX0=

package/esm2020/types/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90eXBlcy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElvbmljR2xvYmFsIHtcbiAgY29uZmlnPzogYW55OyAvLyBUT0RPKEZXLTI4MjcpOiB0eXBlXG4gIGFzeW5jUXVldWU/OiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElvbmljV2luZG93IGV4dGVuZHMgV2luZG93IHtcbiAgSW9uaWM6IElvbmljR2xvYmFsO1xuICBfX3pvbmVfc3ltYm9sX19yZXF1ZXN0QW5pbWF0aW9uRnJhbWU/OiAodHM6IEZyYW1lUmVxdWVzdENhbGxiYWNrKSA9PiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSFRNTFN0ZW5jaWxFbGVtZW50IGV4dGVuZHMgSFRNTEVsZW1lbnQge1xuICBjb21wb25lbnRPblJlYWR5PygpOiBQcm9taXNlPHRoaXM+O1xuICBmb3JjZVVwZGF0ZT8oKTogdm9pZDtcbn1cbiJdfQ==

package/esm2020/util/ionic-router-reuse-strategy.mjs

@@ -0,0 +1,55 @@
+/**
+ * Provides a way to customize when activated routes get reused.
+ */
+export class IonicRouteStrategy {
+    /**
+     * Whether the given route should detach for later reuse.
+     */
+    shouldDetach(_route) {
+        return false;
+    }
+    /**
+     * Returns `false`, meaning the route (and its subtree) is never reattached
+     */
+    shouldAttach(_route) {
+        return false;
+    }
+    /**
+     * A no-op; the route is never stored since this strategy never detaches routes for later re-use.
+     */
+    store(_route, _detachedTree) {
+        return;
+    }
+    /**
+     * Returns `null` because this strategy does not store routes for later re-use.
+     */
+    retrieve(_route) {
+        return 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, curr) {
+        if (future.routeConfig !== curr.routeConfig) {
+            return false;
+        }
+        // checking router params
+        const futureParams = future.params;
+        const currentParams = curr.params;
+        const keysA = Object.keys(futureParams);
+        const keysB = Object.keys(currentParams);
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        // Test for A's keys different from B.
+        for (const key of keysA) {
+            if (currentParams[key] !== futureParams[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/util/overlay.mjs

@@ -0,0 +1,25 @@
+// TODO(FW-2827): types
+export class OverlayBaseController {
+    constructor(ctrl) {
+        this.ctrl = ctrl;
+    }
+    /**
+     * Creates a new overlay
+     */
+    create(opts) {
+        return this.ctrl.create((opts || {}));
+    }
+    /**
+     * When `id` is not provided, it dismisses the top overlay.
+     */
+    dismiss(data, role, id) {
+        return this.ctrl.dismiss(data, role, id);
+    }
+    /**
+     * Returns the top overlay.
+     */
+    getTop() {
+        return this.ctrl.getTop();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlsL292ZXJsYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBUXZCLE1BQU0sT0FBTyxxQkFBcUI7SUFDaEMsWUFBb0IsSUFBb0M7UUFBcEMsU0FBSSxHQUFKLElBQUksQ0FBZ0M7SUFBRyxDQUFDO0lBRTVEOztPQUVHO0lBQ0gsTUFBTSxDQUFDLElBQVc7UUFDaEIsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksSUFBSSxFQUFFLENBQVEsQ0FBQyxDQUFDO0lBQy9DLENBQUM7SUFFRDs7T0FFRztJQUNILE9BQU8sQ0FBQyxJQUFVLEVBQUUsSUFBYSxFQUFFLEVBQVc7UUFDNUMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQzNDLENBQUM7SUFFRDs7T0FFRztJQUNILE1BQU07UUFDSixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDNUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVE9ETyhGVy0yODI3KTogdHlwZXNcblxuaW50ZXJmYWNlIENvbnRyb2xsZXJTaGFwZTxPcHRzLCBIVE1MRWxtPiB7XG4gIGNyZWF0ZShvcHRpb25zOiBPcHRzKTogUHJvbWlzZTxIVE1MRWxtPjtcbiAgZGlzbWlzcyhkYXRhPzogYW55LCByb2xlPzogc3RyaW5nLCBpZD86IHN0cmluZyk6IFByb21pc2U8Ym9vbGVhbj47XG4gIGdldFRvcCgpOiBQcm9taXNlPEhUTUxFbG0gfCB1bmRlZmluZWQ+O1xufVxuXG5leHBvcnQgY2xhc3MgT3ZlcmxheUJhc2VDb250cm9sbGVyPE9wdHMsIE92ZXJsYXk+IGltcGxlbWVudHMgQ29udHJvbGxlclNoYXBlPE9wdHMsIE92ZXJsYXk+IHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBjdHJsOiBDb250cm9sbGVyU2hhcGU8T3B0cywgT3ZlcmxheT4pIHt9XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgb3ZlcmxheVxuICAgKi9cbiAgY3JlYXRlKG9wdHM/OiBPcHRzKTogUHJvbWlzZTxPdmVybGF5PiB7XG4gICAgcmV0dXJuIHRoaXMuY3RybC5jcmVhdGUoKG9wdHMgfHwge30pIGFzIGFueSk7XG4gIH1cblxuICAvKipcbiAgICogV2hlbiBgaWRgIGlzIG5vdCBwcm92aWRlZCwgaXQgZGlzbWlzc2VzIHRoZSB0b3Agb3ZlcmxheS5cbiAgICovXG4gIGRpc21pc3MoZGF0YT86IGFueSwgcm9sZT86IHN0cmluZywgaWQ/OiBzdHJpbmcpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICByZXR1cm4gdGhpcy5jdHJsLmRpc21pc3MoZGF0YSwgcm9sZSwgaWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgdGhlIHRvcCBvdmVybGF5LlxuICAgKi9cbiAgZ2V0VG9wKCk6IFByb21pc2U8T3ZlcmxheSB8IHVuZGVmaW5lZD4ge1xuICAgIHJldHVybiB0aGlzLmN0cmwuZ2V0VG9wKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/util/util.mjs

@@ -0,0 +1,10 @@
+export const raf = (h) => {
+    if (typeof __zone_symbol__requestAnimationFrame === 'function') {
+        return __zone_symbol__requestAnimationFrame(h);
+    }
+    if (typeof requestAnimationFrame === 'function') {
+        return requestAnimationFrame(h);
+    }
+    return setTimeout(h);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlsL3V0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUFHLENBQUMsQ0FBTSxFQUFPLEVBQUU7SUFDakMsSUFBSSxPQUFPLG9DQUFvQyxLQUFLLFVBQVUsRUFBRTtRQUM5RCxPQUFPLG9DQUFvQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ2hEO0lBQ0QsSUFBSSxPQUFPLHFCQUFxQixLQUFLLFVBQVUsRUFBRTtRQUMvQyxPQUFPLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ2pDO0lBQ0QsT0FBTyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDdkIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZGVjbGFyZSBjb25zdCBfX3pvbmVfc3ltYm9sX19yZXF1ZXN0QW5pbWF0aW9uRnJhbWU6IGFueTtcbmRlY2xhcmUgY29uc3QgcmVxdWVzdEFuaW1hdGlvbkZyYW1lOiBhbnk7XG5cbmV4cG9ydCBjb25zdCByYWYgPSAoaDogYW55KTogYW55ID0+IHtcbiAgaWYgKHR5cGVvZiBfX3pvbmVfc3ltYm9sX19yZXF1ZXN0QW5pbWF0aW9uRnJhbWUgPT09ICdmdW5jdGlvbicpIHtcbiAgICByZXR1cm4gX196b25lX3N5bWJvbF9fcmVxdWVzdEFuaW1hdGlvbkZyYW1lKGgpO1xuICB9XG4gIGlmICh0eXBlb2YgcmVxdWVzdEFuaW1hdGlvbkZyYW1lID09PSAnZnVuY3Rpb24nKSB7XG4gICAgcmV0dXJuIHJlcXVlc3RBbmltYXRpb25GcmFtZShoKTtcbiAgfVxuICByZXR1cm4gc2V0VGltZW91dChoKTtcbn07XG4iXX0=