File Explorer

1import browserParsersList from './parser-browsers.js';2import osParsersList from './parser-os.js';3import platformParsersList from './parser-platforms.js';4import enginesParsersList from './parser-engines.js';5import Utils from './utils.js';6 7/**8 * @typedef {Object} ClientHints9 * @property {Array<{brand: string, version: string}>} [brands] Array of brand objects10 * @property {boolean} [mobile] Whether the device is mobile11 * @property {string} [platform] Platform name (e.g., "Windows", "macOS")12 * @property {string} [platformVersion] Platform version13 * @property {string} [architecture] CPU architecture14 * @property {string} [model] Device model15 * @property {boolean} [wow64] Whether running under WoW6416 */17 18/**19 * The main class that arranges the whole parsing process.20 */21class Parser {22  /**23   * Create instance of Parser24   *25   * @param {String} UA User-Agent string26   * @param {Boolean|ClientHints} [skipParsingOrHints=false] Either a boolean to skip parsing,27   * or a ClientHints object containing User-Agent Client Hints data28   * @param {ClientHints} [clientHints] User-Agent Client Hints data (navigator.userAgentData)29   *30   * @throw {Error} in case of empty UA String31   *32   * @constructor33   */34  constructor(UA, skipParsingOrHints = false, clientHints = null) {35    if (UA === void (0) || UA === null || UA === '') {36      throw new Error("UserAgent parameter can't be empty");37    }38 39    this._ua = UA;40 41    // Handle overloaded constructor: (UA, clientHints) or (UA, skipParsing, clientHints)42    let skipParsing = false;43    if (typeof skipParsingOrHints === 'boolean') {44      skipParsing = skipParsingOrHints;45      this._hints = clientHints;46    } else if (skipParsingOrHints != null && typeof skipParsingOrHints === 'object') {47      this._hints = skipParsingOrHints;48    } else {49      this._hints = null;50    }51 52    /**53     * @typedef ParsedResult54     * @property {Object} browser55     * @property {String|undefined} [browser.name]56     * Browser name, like `"Chrome"` or `"Internet Explorer"`57     * @property {String|undefined} [browser.version] Browser version as a String `"12.01.45334.10"`58     * @property {Object} os59     * @property {String|undefined} [os.name] OS name, like `"Windows"` or `"macOS"`60     * @property {String|undefined} [os.version] OS version, like `"NT 5.1"` or `"10.11.1"`61     * @property {String|undefined} [os.versionName] OS name, like `"XP"` or `"High Sierra"`62     * @property {Object} platform63     * @property {String|undefined} [platform.type]64     * platform type, can be either `"desktop"`, `"tablet"` or `"mobile"`65     * @property {String|undefined} [platform.vendor] Vendor of the device,66     * like `"Apple"` or `"Samsung"`67     * @property {String|undefined} [platform.model] Device model,68     * like `"iPhone"` or `"Kindle Fire HD 7"`69     * @property {Object} engine70     * @property {String|undefined} [engine.name]71     * Can be any of this: `WebKit`, `Blink`, `Gecko`, `Trident`, `Presto`, `EdgeHTML`72     * @property {String|undefined} [engine.version] String version of the engine73     */74    this.parsedResult = {};75 76    if (skipParsing !== true) {77      this.parse();78    }79  }80 81  /**82   * Get Client Hints data83   * @return {ClientHints|null}84   *85   * @public86   * @example87   * const parser = Bowser.getParser(UA, clientHints);88   * const hints = parser.getHints();89   * console.log(hints.platform); // 'Windows'90   * console.log(hints.mobile); // false91   */92  getHints() {93    return this._hints;94  }95 96  /**97   * Check if a brand exists in Client Hints brands array98   * @param {string} brandName The brand name to check for99   * @return {boolean}100   *101   * @public102   * @example103   * const parser = Bowser.getParser(UA, clientHints);104   * if (parser.hasBrand('Google Chrome')) {105   *   console.log('Chrome detected!');106   * }107   */108  hasBrand(brandName) {109    if (!this._hints || !Array.isArray(this._hints.brands)) {110      return false;111    }112    const brandLower = brandName.toLowerCase();113    return this._hints.brands.some(114      b => b.brand && b.brand.toLowerCase() === brandLower,115    );116  }117 118  /**119   * Get brand version from Client Hints120   * @param {string} brandName The brand name to get version for121   * @return {string|undefined}122   *123   * @public124   * @example125   * const parser = Bowser.getParser(UA, clientHints);126   * const version = parser.getBrandVersion('Google Chrome');127   * console.log(version); // '131'128   */129  getBrandVersion(brandName) {130    if (!this._hints || !Array.isArray(this._hints.brands)) {131      return undefined;132    }133    const brandLower = brandName.toLowerCase();134    const brand = this._hints.brands.find(135      b => b.brand && b.brand.toLowerCase() === brandLower,136    );137    return brand ? brand.version : undefined;138  }139 140  /**141   * Get UserAgent string of current Parser instance142   * @return {String} User-Agent String of the current <Parser> object143   *144   * @public145   */146  getUA() {147    return this._ua;148  }149 150  /**151   * Test a UA string for a regexp152   * @param {RegExp} regex153   * @return {Boolean}154   */155  test(regex) {156    return regex.test(this._ua);157  }158 159  /**160   * Get parsed browser object161   * @return {Object}162   */163  parseBrowser() {164    this.parsedResult.browser = {};165 166    const browserDescriptor = Utils.find(browserParsersList, (_browser) => {167      if (typeof _browser.test === 'function') {168        return _browser.test(this);169      }170 171      if (Array.isArray(_browser.test)) {172        return _browser.test.some(condition => this.test(condition));173      }174 175      throw new Error("Browser's test function is not valid");176    });177 178    if (browserDescriptor) {179      this.parsedResult.browser = browserDescriptor.describe(this.getUA(), this);180    }181 182    return this.parsedResult.browser;183  }184 185  /**186   * Get parsed browser object187   * @return {Object}188   *189   * @public190   */191  getBrowser() {192    if (this.parsedResult.browser) {193      return this.parsedResult.browser;194    }195 196    return this.parseBrowser();197  }198 199  /**200   * Get browser's name201   * @return {String} Browser's name or an empty string202   *203   * @public204   */205  getBrowserName(toLowerCase) {206    if (toLowerCase) {207      return String(this.getBrowser().name).toLowerCase() || '';208    }209    return this.getBrowser().name || '';210  }211 212 213  /**214   * Get browser's version215   * @return {String} version of browser216   *217   * @public218   */219  getBrowserVersion() {220    return this.getBrowser().version;221  }222 223  /**224   * Get OS225   * @return {Object}226   *227   * @example228   * this.getOS();229   * {230   *   name: 'macOS',231   *   version: '10.11.12'232   * }233   */234  getOS() {235    if (this.parsedResult.os) {236      return this.parsedResult.os;237    }238 239    return this.parseOS();240  }241 242  /**243   * Parse OS and save it to this.parsedResult.os244   * @return {*|{}}245   */246  parseOS() {247    this.parsedResult.os = {};248 249    const os = Utils.find(osParsersList, (_os) => {250      if (typeof _os.test === 'function') {251        return _os.test(this);252      }253 254      if (Array.isArray(_os.test)) {255        return _os.test.some(condition => this.test(condition));256      }257 258      throw new Error("Browser's test function is not valid");259    });260 261    if (os) {262      this.parsedResult.os = os.describe(this.getUA());263    }264 265    return this.parsedResult.os;266  }267 268  /**269   * Get OS name270   * @param {Boolean} [toLowerCase] return lower-cased value271   * @return {String} name of the OS — macOS, Windows, Linux, etc.272   */273  getOSName(toLowerCase) {274    const { name } = this.getOS();275 276    if (toLowerCase) {277      return String(name).toLowerCase() || '';278    }279 280    return name || '';281  }282 283  /**284   * Get OS version285   * @return {String} full version with dots ('10.11.12', '5.6', etc)286   */287  getOSVersion() {288    return this.getOS().version;289  }290 291  /**292   * Get parsed platform293   * @return {{}}294   */295  getPlatform() {296    if (this.parsedResult.platform) {297      return this.parsedResult.platform;298    }299 300    return this.parsePlatform();301  }302 303  /**304   * Get platform name305   * @param {Boolean} [toLowerCase=false]306   * @return {*}307   */308  getPlatformType(toLowerCase = false) {309    const { type } = this.getPlatform();310 311    if (toLowerCase) {312      return String(type).toLowerCase() || '';313    }314 315    return type || '';316  }317 318  /**319   * Get parsed platform320   * @return {{}}321   */322  parsePlatform() {323    this.parsedResult.platform = {};324 325    const platform = Utils.find(platformParsersList, (_platform) => {326      if (typeof _platform.test === 'function') {327        return _platform.test(this);328      }329 330      if (Array.isArray(_platform.test)) {331        return _platform.test.some(condition => this.test(condition));332      }333 334      throw new Error("Browser's test function is not valid");335    });336 337    if (platform) {338      this.parsedResult.platform = platform.describe(this.getUA());339    }340 341    return this.parsedResult.platform;342  }343 344  /**345   * Get parsed engine346   * @return {{}}347   */348  getEngine() {349    if (this.parsedResult.engine) {350      return this.parsedResult.engine;351    }352 353    return this.parseEngine();354  }355 356  /**357   * Get engines's name358   * @return {String} Engines's name or an empty string359   *360   * @public361   */362  getEngineName(toLowerCase) {363    if (toLowerCase) {364      return String(this.getEngine().name).toLowerCase() || '';365    }366    return this.getEngine().name || '';367  }368 369  /**370   * Get parsed platform371   * @return {{}}372   */373  parseEngine() {374    this.parsedResult.engine = {};375 376    const engine = Utils.find(enginesParsersList, (_engine) => {377      if (typeof _engine.test === 'function') {378        return _engine.test(this);379      }380 381      if (Array.isArray(_engine.test)) {382        return _engine.test.some(condition => this.test(condition));383      }384 385      throw new Error("Browser's test function is not valid");386    });387 388    if (engine) {389      this.parsedResult.engine = engine.describe(this.getUA());390    }391 392    return this.parsedResult.engine;393  }394 395  /**396   * Parse full information about the browser397   * @returns {Parser}398   */399  parse() {400    this.parseBrowser();401    this.parseOS();402    this.parsePlatform();403    this.parseEngine();404 405    return this;406  }407 408  /**409   * Get parsed result410   * @return {ParsedResult}411   */412  getResult() {413    return Utils.assign({}, this.parsedResult);414  }415 416  /**417   * Check if parsed browser matches certain conditions418   *419   * @param {Object} checkTree It's one or two layered object,420   * which can include a platform or an OS on the first layer421   * and should have browsers specs on the bottom-laying layer422   *423   * @returns {Boolean|undefined} Whether the browser satisfies the set conditions or not.424   * Returns `undefined` when the browser is no described in the checkTree object.425   *426   * @example427   * const browser = Bowser.getParser(window.navigator.userAgent);428   * if (browser.satisfies({chrome: '>118.01.1322' }))429   * // or with os430   * if (browser.satisfies({windows: { chrome: '>118.01.1322' } }))431   * // or with platforms432   * if (browser.satisfies({desktop: { chrome: '>118.01.1322' } }))433   */434  satisfies(checkTree) {435    const platformsAndOSes = {};436    let platformsAndOSCounter = 0;437    const browsers = {};438    let browsersCounter = 0;439 440    const allDefinitions = Object.keys(checkTree);441 442    allDefinitions.forEach((key) => {443      const currentDefinition = checkTree[key];444      if (typeof currentDefinition === 'string') {445        browsers[key] = currentDefinition;446        browsersCounter += 1;447      } else if (typeof currentDefinition === 'object') {448        platformsAndOSes[key] = currentDefinition;449        platformsAndOSCounter += 1;450      }451    });452 453    if (platformsAndOSCounter > 0) {454      const platformsAndOSNames = Object.keys(platformsAndOSes);455      const OSMatchingDefinition = Utils.find(platformsAndOSNames, name => (this.isOS(name)));456 457      if (OSMatchingDefinition) {458        const osResult = this.satisfies(platformsAndOSes[OSMatchingDefinition]);459 460        if (osResult !== void 0) {461          return osResult;462        }463      }464 465      const platformMatchingDefinition = Utils.find(466        platformsAndOSNames,467        name => (this.isPlatform(name)),468      );469      if (platformMatchingDefinition) {470        const platformResult = this.satisfies(platformsAndOSes[platformMatchingDefinition]);471 472        if (platformResult !== void 0) {473          return platformResult;474        }475      }476    }477 478    if (browsersCounter > 0) {479      const browserNames = Object.keys(browsers);480      const matchingDefinition = Utils.find(browserNames, name => (this.isBrowser(name, true)));481 482      if (matchingDefinition !== void 0) {483        return this.compareVersion(browsers[matchingDefinition]);484      }485    }486 487    return undefined;488  }489 490  /**491   * Check if the browser name equals the passed string492   * @param {string} browserName The string to compare with the browser name493   * @param [includingAlias=false] The flag showing whether alias will be included into comparison494   * @returns {boolean}495   */496  isBrowser(browserName, includingAlias = false) {497    const defaultBrowserName = this.getBrowserName().toLowerCase();498    let browserNameLower = browserName.toLowerCase();499    const alias = Utils.getBrowserTypeByAlias(browserNameLower);500 501    if (includingAlias && alias) {502      browserNameLower = alias.toLowerCase();503    }504    return browserNameLower === defaultBrowserName;505  }506 507  compareVersion(version) {508    let expectedResults = [0];509    let comparableVersion = version;510    let isLoose = false;511 512    const currentBrowserVersion = this.getBrowserVersion();513 514    if (typeof currentBrowserVersion !== 'string') {515      return void 0;516    }517 518    if (version[0] === '>' || version[0] === '<') {519      comparableVersion = version.substr(1);520      if (version[1] === '=') {521        isLoose = true;522        comparableVersion = version.substr(2);523      } else {524        expectedResults = [];525      }526      if (version[0] === '>') {527        expectedResults.push(1);528      } else {529        expectedResults.push(-1);530      }531    } else if (version[0] === '=') {532      comparableVersion = version.substr(1);533    } else if (version[0] === '~') {534      isLoose = true;535      comparableVersion = version.substr(1);536    }537 538    return expectedResults.indexOf(539      Utils.compareVersions(currentBrowserVersion, comparableVersion, isLoose),540    ) > -1;541  }542 543  /**544   * Check if the OS name equals the passed string545   * @param {string} osName The string to compare with the OS name546   * @returns {boolean}547   */548  isOS(osName) {549    return this.getOSName(true) === String(osName).toLowerCase();550  }551 552  /**553   * Check if the platform type equals the passed string554   * @param {string} platformType The string to compare with the platform type555   * @returns {boolean}556   */557  isPlatform(platformType) {558    return this.getPlatformType(true) === String(platformType).toLowerCase();559  }560 561  /**562   * Check if the engine name equals the passed string563   * @param {string} engineName The string to compare with the engine name564   * @returns {boolean}565   */566  isEngine(engineName) {567    return this.getEngineName(true) === String(engineName).toLowerCase();568  }569 570  /**571   * Is anything? Check if the browser is called "anything",572   * the OS called "anything" or the platform called "anything"573   * @param {String} anything574   * @param [includingAlias=false] The flag showing whether alias will be included into comparison575   * @returns {Boolean}576   */577  is(anything, includingAlias = false) {578    return this.isBrowser(anything, includingAlias) || this.isOS(anything)579      || this.isPlatform(anything);580  }581 582  /**583   * Check if any of the given values satisfies this.is(anything)584   * @param {String[]} anythings585   * @returns {Boolean}586   */587  some(anythings = []) {588    return anythings.some(anything => this.is(anything));589  }590}591 592export default Parser;593