254 lines
No EOL
27 KiB
JavaScript
Executable file
254 lines
No EOL
27 KiB
JavaScript
Executable file
import * as tslib_1 from "tslib";
|
|
import { DOCUMENT } from '@angular/common';
|
|
import { Inject, Injectable, NgZone } from '@angular/core';
|
|
import { getPlatforms, isPlatform } from '@ionic/core';
|
|
import { Subject } from 'rxjs';
|
|
import * as i0 from "@angular/core";
|
|
import * as i1 from "@angular/common";
|
|
var Platform = /** @class */ (function () {
|
|
function Platform(doc, zone) {
|
|
var _this = this;
|
|
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(function () {
|
|
_this.win = doc.defaultView;
|
|
_this.backButton.subscribeWithPriority = function (priority, callback) {
|
|
return this.subscribe(function (ev) {
|
|
return ev.register(priority, function (processNextHandler) { return zone.run(function () { return 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');
|
|
var readyResolve;
|
|
_this._readyPromise = new Promise(function (res) { readyResolve = res; });
|
|
if (_this.win && _this.win['cordova']) {
|
|
doc.addEventListener('deviceready', function () {
|
|
readyResolve('cordova');
|
|
}, { once: true });
|
|
}
|
|
else {
|
|
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. |
|
|
*
|
|
*/
|
|
Platform.prototype.is = function (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());
|
|
* }
|
|
* }
|
|
* ```
|
|
*/
|
|
Platform.prototype.platforms = function () {
|
|
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
|
|
* });
|
|
* }
|
|
* }
|
|
* ```
|
|
*/
|
|
Platform.prototype.ready = function () {
|
|
return this._readyPromise;
|
|
};
|
|
Object.defineProperty(Platform.prototype, "isRTL", {
|
|
/**
|
|
* 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: function () {
|
|
return this.doc.dir === 'rtl';
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* Get the query string parameter
|
|
*/
|
|
Platform.prototype.getQueryParam = function (key) {
|
|
return readQueryParam(this.win.location.href, key);
|
|
};
|
|
/**
|
|
* Returns `true` if the app is in landscape mode.
|
|
*/
|
|
Platform.prototype.isLandscape = function () {
|
|
return !this.isPortrait();
|
|
};
|
|
/**
|
|
* Returns `true` if the app is in portrait mode.
|
|
*/
|
|
Platform.prototype.isPortrait = function () {
|
|
return this.win.matchMedia && this.win.matchMedia('(orientation: portrait)').matches;
|
|
};
|
|
Platform.prototype.testUserAgent = function (expression) {
|
|
var nav = this.win.navigator;
|
|
return !!(nav && nav.userAgent && nav.userAgent.indexOf(expression) >= 0);
|
|
};
|
|
/**
|
|
* Get the current url.
|
|
*/
|
|
Platform.prototype.url = function () {
|
|
return this.win.location.href;
|
|
};
|
|
/**
|
|
* Gets the width of the platform's viewport using `window.innerWidth`.
|
|
*/
|
|
Platform.prototype.width = function () {
|
|
return this.win.innerWidth;
|
|
};
|
|
/**
|
|
* Gets the height of the platform's viewport using `window.innerHeight`.
|
|
*/
|
|
Platform.prototype.height = function () {
|
|
return this.win.innerHeight;
|
|
};
|
|
Platform.ctorParameters = function () { return [
|
|
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
|
|
{ type: NgZone }
|
|
]; };
|
|
Platform.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function Platform_Factory() { return new Platform(i0.ɵɵinject(i1.DOCUMENT), i0.ɵɵinject(i0.NgZone)); }, token: Platform, providedIn: "root" });
|
|
Platform = tslib_1.__decorate([
|
|
Injectable({
|
|
providedIn: 'root',
|
|
}),
|
|
tslib_1.__param(0, Inject(DOCUMENT))
|
|
], Platform);
|
|
return Platform;
|
|
}());
|
|
export { Platform };
|
|
var readQueryParam = function (url, key) {
|
|
key = key.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
|
|
var regex = new RegExp('[\\?&]' + key + '=([^&#]*)');
|
|
var results = regex.exec(url);
|
|
return results ? decodeURIComponent(results[1].replace(/\+/g, ' ')) : null;
|
|
};
|
|
var ɵ0 = readQueryParam;
|
|
var proxyEvent = function (emitter, el, eventName) {
|
|
if (el) {
|
|
el.addEventListener(eventName, function (ev) {
|
|
// ?? cordova might emit "null" events
|
|
emitter.next(ev != null ? ev.detail : undefined);
|
|
});
|
|
}
|
|
};
|
|
var ɵ1 = proxyEvent;
|
|
export { ɵ0, ɵ1 };
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform.js","sourceRoot":"ng://@ionic/angular/","sources":["providers/platform.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Inject, Injectable, NgZone } from '@angular/core';\nimport { BackButtonEventDetail, KeyboardEventDetail, Platforms, getPlatforms, isPlatform } from '@ionic/core';\nimport { Subject, Subscription } from 'rxjs';\n\nexport interface BackButtonEmitter extends Subject<BackButtonEventDetail> {\n  subscribeWithPriority(priority: number, callback: (processNextHandler: () => void) => Promise<any> | void): Subscription;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Platform {\n\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 => { readyResolve = res; });\n      if (this.win && this.win['cordova']) {\n        doc.addEventListener('deviceready', () => {\n          readyResolve('cordova');\n        }, { once: true });\n      } else {\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 && this.win.matchMedia('(orientation: portrait)').matches;\n  }\n\n  testUserAgent(expression: string): boolean {\n    const nav = this.win.navigator;\n    return !!(nav && nav.userAgent && nav.userAgent.indexOf(expression) >= 0);\n  }\n\n  /**\n   * Get the current url.\n   */\n  url() {\n    return this.win.location.href;\n  }\n\n  /**\n   * Gets the width of the platform's viewport using `window.innerWidth`.\n   */\n  width() {\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(/[\\[]/, '\\\\[').replace(/[\\]]/, '\\\\]');\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 as any)) {\n    el.addEventListener(eventName, (ev: Event | undefined | null) => {\n      // ?? cordova might emit \"null\" events\n      emitter.next(ev != null ? (ev as any).detail as T : undefined);\n    });\n  }\n};\n"]}
|