298 lines
8.9 KiB
JavaScript
298 lines
8.9 KiB
JavaScript
/*TRANSPILED*/goog.loadModule(function(exports) {'use strict';/**
|
|
* @license
|
|
* Copyright The Closure Library Authors.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview Closure user agent platform detection.
|
|
* @see <a href="http://www.useragentstring.com/">User agent strings</a>
|
|
* For more information on browser brand, rendering engine, or device see the
|
|
* other sub-namespaces in goog.labs.userAgent (browser, engine, and device
|
|
* respectively).
|
|
*/
|
|
|
|
goog.module('goog.labs.userAgent.platform');
|
|
goog.module.declareLegacyNamespace();
|
|
|
|
const googString = goog.require('goog.string.internal');
|
|
const util = goog.require('goog.labs.userAgent.util');
|
|
const {AsyncValue, Version} = goog.require('goog.labs.userAgent.highEntropy.highEntropyValue');
|
|
const {platformVersion} = goog.require('goog.labs.userAgent.highEntropy.highEntropyData');
|
|
const {useClientHints} = goog.require('goog.labs.userAgent');
|
|
|
|
/**
|
|
* @param {boolean=} ignoreClientHintsFlag Iff truthy, the `useClientHints`
|
|
* function will not be called when evaluating if User-Agent Client Hints
|
|
* Brand data can be used. For existing labs.userAgent API surfaces with
|
|
* widespread use, this should be a falsy value so that usage of the Client
|
|
* Hints APIs can be gated behind flags / experiment rollouts.
|
|
* @return {boolean} Whether to use navigator.userAgentData to determine
|
|
* the current platform.
|
|
* userAgentData.platform was enabled by default in Chrome 93:
|
|
* https://www.chromestatus.com/feature/5733498725859328
|
|
* TODO(user): Skip this check with FEATURESET_YEAR once userAgentData is
|
|
* present in all major browsers (may not be until 2024).
|
|
* See https://caniuse.com/mdn-api_navigator_useragentdata.
|
|
*/
|
|
function useUserAgentDataPlatform(ignoreClientHintsFlag = false) {
|
|
if (util.ASSUME_CLIENT_HINTS_SUPPORT) return true;
|
|
// High-entropy API surfaces should not be gated behind the useClientHints
|
|
// check (as in production it is gated behind a define).
|
|
if (!ignoreClientHintsFlag && !useClientHints()) return false;
|
|
const userAgentData = util.getUserAgentData();
|
|
return !!userAgentData && !!userAgentData.platform;
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is Android.
|
|
*/
|
|
function isAndroid() {
|
|
if (useUserAgentDataPlatform()) {
|
|
return util.getUserAgentData().platform === 'Android';
|
|
}
|
|
return util.matchUserAgent('Android');
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is iPod.
|
|
* TODO(user): Combine iPod/iPhone detection since they may become
|
|
* indistinguishable if we begin relying on userAgentdata in iOS.
|
|
*/
|
|
function isIpod() {
|
|
// navigator.userAgentData is currently not supported on any iOS browser, so
|
|
// rely only on navigator.userAgent.
|
|
return util.matchUserAgent('iPod');
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is iPhone.
|
|
*/
|
|
function isIphone() {
|
|
// navigator.userAgentData is currently not supported on any iOS browser, so
|
|
// rely only on navigator.userAgent.
|
|
return util.matchUserAgent('iPhone') && !util.matchUserAgent('iPod') &&
|
|
!util.matchUserAgent('iPad');
|
|
}
|
|
|
|
/**
|
|
* Returns whether the platform is iPad.
|
|
* Note that iPadOS 13+ spoofs macOS Safari by default in its user agent, and in
|
|
* this scenario the platform will not be recognized as iPad. If you must have
|
|
* iPad-specific behavior, use
|
|
* {@link goog.labs.userAgent.extra.isSafariDesktopOnMobile}.
|
|
* @return {boolean} Whether the platform is iPad.
|
|
*/
|
|
function isIpad() {
|
|
// navigator.userAgentData is currently not supported on any iOS browser, so
|
|
// rely only on navigator.userAgent.
|
|
return util.matchUserAgent('iPad');
|
|
}
|
|
|
|
/**
|
|
* Returns whether the platform is iOS.
|
|
* Note that iPadOS 13+ spoofs macOS Safari by default in its user agent, and in
|
|
* this scenario the platform will not be recognized as iOS. If you must have
|
|
* iPad-specific behavior, use
|
|
* {@link goog.labs.userAgent.extra.isSafariDesktopOnMobile}.
|
|
* @return {boolean} Whether the platform is iOS.
|
|
*/
|
|
function isIos() {
|
|
return isIphone() || isIpad() || isIpod();
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is Mac.
|
|
*/
|
|
function isMacintosh() {
|
|
if (useUserAgentDataPlatform()) {
|
|
return util.getUserAgentData().platform === 'macOS';
|
|
}
|
|
return util.matchUserAgent('Macintosh');
|
|
}
|
|
|
|
/**
|
|
* Note: ChromeOS is not considered to be Linux as it does not report itself
|
|
* as Linux in the user agent string.
|
|
* @return {boolean} Whether the platform is Linux.
|
|
*/
|
|
function isLinux() {
|
|
if (useUserAgentDataPlatform()) {
|
|
return util.getUserAgentData().platform === 'Linux';
|
|
}
|
|
return util.matchUserAgent('Linux');
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is Windows.
|
|
*/
|
|
function isWindows() {
|
|
if (useUserAgentDataPlatform()) {
|
|
return util.getUserAgentData().platform === 'Windows';
|
|
}
|
|
return util.matchUserAgent('Windows');
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is ChromeOS.
|
|
*/
|
|
function isChromeOS() {
|
|
if (useUserAgentDataPlatform()) {
|
|
return util.getUserAgentData().platform === 'Chrome OS';
|
|
}
|
|
return util.matchUserAgent('CrOS');
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is Chromecast.
|
|
*/
|
|
function isChromecast() {
|
|
// TODO(user): Check against util.getUserAgentData().platform once the
|
|
// OS string for Chromecast is known.
|
|
return util.matchUserAgent('CrKey');
|
|
}
|
|
|
|
/**
|
|
* @return {boolean} Whether the platform is KaiOS.
|
|
*/
|
|
function isKaiOS() {
|
|
// navigator.userAgentData is currently not supported on any KaiOS browser, so
|
|
// rely only on navigator.userAgent.
|
|
return util.matchUserAgentIgnoreCase('KaiOS');
|
|
}
|
|
|
|
/**
|
|
* The version of the platform. We only determine the version for Windows,
|
|
* Mac, and Chrome OS. It doesn't make much sense on Linux. For Windows, we only
|
|
* look at the NT version. Non-NT-based versions (e.g. 95, 98, etc.) are given
|
|
* version 0.0.
|
|
*
|
|
* @return {string} The platform version or empty string if version cannot be
|
|
* determined.
|
|
*/
|
|
function getVersion() {
|
|
const userAgentString = util.getUserAgent();
|
|
let version = '', re;
|
|
if (isWindows()) {
|
|
re = /Windows (?:NT|Phone) ([0-9.]+)/;
|
|
const match = re.exec(userAgentString);
|
|
if (match) {
|
|
version = match[1];
|
|
} else {
|
|
version = '0.0';
|
|
}
|
|
} else if (isIos()) {
|
|
re = /(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/;
|
|
const match = re.exec(userAgentString);
|
|
// Report the version as x.y.z and not x_y_z
|
|
version = match && match[1].replace(/_/g, '.');
|
|
} else if (isMacintosh()) {
|
|
re = /Mac OS X ([0-9_.]+)/;
|
|
const match = re.exec(userAgentString);
|
|
// Note: some old versions of Camino do not report an OSX version.
|
|
// Default to 10.
|
|
version = match ? match[1].replace(/_/g, '.') : '10';
|
|
} else if (isKaiOS()) {
|
|
re = /(?:KaiOS)\/(\S+)/i;
|
|
const match = re.exec(userAgentString);
|
|
version = match && match[1];
|
|
} else if (isAndroid()) {
|
|
re = /Android\s+([^\);]+)(\)|;)/;
|
|
const match = re.exec(userAgentString);
|
|
version = match && match[1];
|
|
} else if (isChromeOS()) {
|
|
re = /(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/;
|
|
const match = re.exec(userAgentString);
|
|
version = match && match[1];
|
|
}
|
|
return version || '';
|
|
}
|
|
|
|
/**
|
|
* @param {string|number} version The version to check.
|
|
* @return {boolean} Whether the browser version is higher or the same as the
|
|
* given version.
|
|
*/
|
|
function isVersionOrHigher(version) {
|
|
return googString.compareVersions(getVersion(), version) >= 0;
|
|
}
|
|
|
|
/**
|
|
* Represents a high-entropy version string.
|
|
* @implements {AsyncValue<!Version>}
|
|
*/
|
|
class PlatformVersion {
|
|
constructor() {
|
|
/** @private {boolean} */
|
|
this.preUachHasLoaded_ = false;
|
|
}
|
|
|
|
/**
|
|
* @return {!Version|undefined}
|
|
* @override
|
|
*/
|
|
getIfLoaded() {
|
|
if (useUserAgentDataPlatform(true)) {
|
|
const loadedPlatformVersion = platformVersion.getIfLoaded();
|
|
if (loadedPlatformVersion === undefined) {
|
|
// No platform data has been cached
|
|
return undefined;
|
|
}
|
|
return new Version(loadedPlatformVersion);
|
|
} else if (!this.preUachHasLoaded_) {
|
|
// Nobody ever called `load` on this class instance, so we should return
|
|
// nothing to match the semantics of the class when using the Client Hint
|
|
// APIs.
|
|
return undefined;
|
|
} else {
|
|
// `load` has been called, so we can return a Version derived from the
|
|
// useragent string.
|
|
return new Version(getVersion());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return {!Promise<!Version>}
|
|
* @override
|
|
*/
|
|
async load() {
|
|
if (useUserAgentDataPlatform(true)) {
|
|
return new Version(await platformVersion.load());
|
|
} else {
|
|
this.preUachHasLoaded_ = true;
|
|
return new Version(getVersion());
|
|
}
|
|
}
|
|
|
|
/** @package */
|
|
resetForTesting() {
|
|
platformVersion.resetForTesting();
|
|
this.preUachHasLoaded_ = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The platform version, a high-entropy value.
|
|
* @type {!PlatformVersion}
|
|
*/
|
|
const version = new PlatformVersion();
|
|
|
|
exports = {
|
|
getVersion,
|
|
isAndroid,
|
|
isChromeOS,
|
|
isChromecast,
|
|
isIos,
|
|
isIpad,
|
|
isIphone,
|
|
isIpod,
|
|
isKaiOS,
|
|
isLinux,
|
|
isMacintosh,
|
|
isVersionOrHigher,
|
|
isWindows,
|
|
version,
|
|
};
|
|
|
|
;return exports;});
|