@bitfiber/utils 1.0.2 → 1.0.4

package/src/env/get-engine/get-engine.ts

@@ -0,0 +1,27 @@
+import {EngineData} from '../';
+import {EnvCondition} from '../types';
+import {getBot, getEnvData} from '../private/private';
+
+let engine: EngineData | null = null;
+
+const engineConditions: EnvCondition[] = [
+  ['gecko', 'firefox'], ['blink', 'chrome'], ['webkit', '(?:safari|AppleWebKit)'],
+];
+
+/**
+ * Returns information about the browser engine.
+ * Possible engine names: blink (Chrome like) | webkit (Safari like) | gecko (Firefox like) | unknown | BotNames
+ */
+export function getEngine(): EngineData {
+  const bot = getBot();
+  engine ??= bot.name !== 'unknown' ? {...bot} : <EngineData>getEnvData(engineConditions, true);
+  return engine;
+}
+
+/*
+ * @internal
+ * For internal use
+ */
+export function resetEngine(): void {
+  engine = null;
+}

package/src/env/get-os/get-os.ts

@@ -0,0 +1,31 @@
+import {OSData} from '../';
+import {EnvCondition} from '../types';
+import {getBot, getEnvData} from '../private/private';
+
+let os: OSData | null = null;
+
+const osConditions: EnvCondition[] = [
+  'xbox', ['windows', 'Windows (?:NT|XP)'], ['ios', '(?:iphone|ipad|FxiOS)', 'OS'], ['macOS', 'Macintosh', 'Mac OS X'],
+  ['webOS', '(?:web|hpw)[o0]s'], 'tizen', ['appleTV', 'apple[\\s_-]?TV', 'OS'], ['roku', 'Roku[\\w]{0,8}/DVP'],
+  ['chromeOS', 'CrOS(?: x86_64)?'], ['playstation4', 'PlayStation 4'], ['playstation5', 'PlayStation 5'],
+  ['nintendoSwitch', 'Nintendo Switch'], ['likeAndroid', 'like android'], 'android', ['linux', 'linux', 'rv:'],
+];
+
+/**
+ * Returns information about the OS
+ * Possible OS names: xbox | windows | ios | macOS | webOS | tizen | appleTV | roku | chromeOS
+ * | playstation4 | playstation5 | nintendoSwitch | likeAndroid | android | linux | unknown | BotNames
+ */
+export function getOS(): OSData {
+  const bot = getBot();
+  os ??= bot.name !== 'unknown' ? {...bot} : <OSData>getEnvData(osConditions, true);
+  return os;
+}
+
+/*
+ * @internal
+ * For internal use
+ */
+export function resetOS(): void {
+  os = null;
+}

package/src/env/get-platform/get-platform.ts

@@ -0,0 +1,34 @@
+import {getOS, PlatformNames} from '../';
+import {EnvCondition} from '../types';
+import {getBot, getEnvData} from '../private/private';
+
+let platform: PlatformNames | null = null;
+
+const platformConditions: EnvCondition[] = [
+  [
+    'tv', [
+      () => ['tizen', 'webOS', 'appleTV', 'roku', 'xbox', 'playstation4', 'playstation5'].includes(getOS().name),
+      '(?:smart|web|google|hbb)[\\s:_/-]?tv', 'bravia',
+    ],
+  ], ['desktop', [() => ['macOS', 'chromeOS', 'windows', 'linux'].includes(getOS().name)]],
+  ['tablet', [() => ['nintendoSwitch'].includes(getOS().name), 'ipad', 'silk', 'tablet']],
+  ['mobile', ['iphone', 'android.*?mobi(?:le)?']], ['tablet', 'android'],
+];
+
+/**
+ * Returns the name of the platform
+ * @returns tv | desktop | tablet | mobile | unknown | BotNames
+ */
+export function getPlatform(): PlatformNames {
+  const bot = getBot();
+  platform ??= bot.name !== 'unknown' ? bot.name : <PlatformNames>getEnvData(platformConditions).name;
+  return <PlatformNames>platform;
+}
+
+/*
+ * @internal
+ * For internal use
+ */
+export function resetPlatform(): void {
+  platform = null;
+}

package/src/env/index.ts

@@ -0,0 +1,24 @@
+export {
+  BotNames, PlatformNames, OSNames, EngineNames, BrowserNames, VersionData, OSData, EngineData, BrowserData,
+  EnginesCondition, BrowsersCondition, OSBrowsersCondition, OSCondition, PlatformsCondition,
+} from './types';
+export {getUserAgent, setUserAgent} from './user-agent/user-agent';
+export {getOS} from './get-os/get-os';
+export {getEngine} from './get-engine/get-engine';
+export {getPlatform} from './get-platform/get-platform';
+export {getBrowser} from './get-browser/get-browser';
+export {matchesWithVersion} from './matches-with-version/matches-with-version';
+export {isTV} from './is-tv/is-tv';
+export {isDesktop} from './is-desktop/is-desktop';
+export {isTablet} from './is-tablet/is-tablet';
+export {isMobile} from './is-mobile/is-mobile';
+export {isPortable} from './is-portable/is-portable';
+export {isStationary} from './is-stationary/is-stationary';
+export {isChromeLike} from './is-chrome-like/is-chrome-like';
+export {isFirefoxLike} from './is-firefox-like/is-firefox-like';
+export {isSafariLike} from './is-safari-like/is-safari-like';
+export {isOS} from './is-os/is-os';
+export {isEngine} from './is-engine/is-engine';
+export {isBrowser} from './is-browser/is-browser';
+export {matchesWithBrowsers} from './matches-with-browsers/matches-with-browsers';
+export {matches} from './matches/matches';

package/src/env/is-browser/is-browser.ts

@@ -0,0 +1,15 @@
+import {BrowserNames, getBrowser, matchesWithVersion} from '../';
+
+/**
+ * Returns true if the name matches the browser name and the version matches the browser version, otherwise false
+ * @param name - one of the browser names:
+ * opera | operaCoast | operaTouch | samsung | mz | yandex | uc | maxthon | kmeleon
+ * | wechat | qqLite | qq | edge | sailfish | webOS | tizen | miui | silk | phantomjs | slimerjs | qupzilla
+ * | electron | whale | focus | swing | epiphany | puffin | sleipnir | vivaldi | seamonkey | playstation4
+ * | playstation5 | googleSearch | firefox | chrome | android | safari | unknown | BotNames
+ * @param version - string condition in the format: x.x...x | [~ >= > <= <]x.x...x
+ */
+export function isBrowser(name: BrowserNames, version?: string): boolean {
+  const browser = getBrowser();
+  return browser.name === name && (!version || matchesWithVersion(browser.version, version));
+}

package/src/env/is-chrome-like/is-chrome-like.ts

@@ -0,0 +1,9 @@
+import {getEngine} from '../';
+
+/**
+ * Returns true if the browser uses the Blink engine like Chrome, false otherwise
+ */
+export function isChromeLike(): boolean {
+  const name = getEngine().name;
+  return name === 'blink';
+}

package/src/env/is-desktop/is-desktop.ts

@@ -0,0 +1,9 @@
+import {getPlatform} from '../';
+
+/**
+ * Returns true if the platform is desktop, otherwise false
+ */
+export function isDesktop(): boolean {
+  const name = getPlatform();
+  return name === 'desktop';
+}

package/src/env/is-engine/is-engine.ts

@@ -0,0 +1,12 @@
+import {EngineNames, getEngine, matchesWithVersion} from '../';
+
+/**
+ * Returns true if the name matches the engine name and the version matches the engine version, otherwise false
+ * @param name - one of the engine names:
+ * blink (Chrome like) | webkit (Safari like) | gecko (Firefox like) | unknown | BotNames
+ * @param version - string condition in the format: x.x...x | [~ >= > <= <]x.x...x
+ */
+export function isEngine(name: EngineNames, version?: string): boolean {
+  const engine = getEngine();
+  return engine.name === name && (!version || matchesWithVersion(engine.version, version));
+}

package/src/env/is-firefox-like/is-firefox-like.ts

@@ -0,0 +1,9 @@
+import {getEngine} from '../';
+
+/**
+ * Returns true if the browser uses the Gecko engine like FireFox, false otherwise
+ */
+export function isFirefoxLike(): boolean {
+  const name = getEngine().name;
+  return name === 'gecko';
+}

package/src/env/is-mobile/is-mobile.ts

@@ -0,0 +1,9 @@
+import {getPlatform} from '../';
+
+/**
+ * Returns true if the platform is mobile, otherwise false
+ */
+export function isMobile(): boolean {
+  const name = getPlatform();
+  return name === 'mobile';
+}

package/src/env/is-os/is-os.ts

@@ -0,0 +1,13 @@
+import {getOS, matchesWithVersion, OSNames} from '../';
+
+/**
+ * Returns true if the name matches the OS name and the version matches the OS version, otherwise false
+ * @param name - one of the OS names:
+ * xbox | windows | ios | macOS | webOS | tizen | appleTV | roku | chromeOS
+ * | playstation4 | playstation5 | nintendoSwitch | likeAndroid | android | linux | unknown | BotNames
+ * @param version - string condition in the format: x.x...x | [~ >= > <= <]x.x...x
+ */
+export function isOS(name: OSNames, version?: string): boolean {
+  const os = getOS();
+  return os.name === name && (!version || matchesWithVersion(os.version, version));
+}

package/src/env/is-portable/is-portable.ts

@@ -0,0 +1,8 @@
+import {isMobile, isTablet} from '../';
+
+/**
+ * Returns true if the platform is mobile or tablet, otherwise false
+ */
+export function isPortable(): boolean {
+  return isMobile() || isTablet();
+}

package/src/env/is-safari-like/is-safari-like.ts

@@ -0,0 +1,9 @@
+import {getEngine} from '../';
+
+/**
+ * Returns true if the browser uses the WebKit engine like Safari, false otherwise
+ */
+export function isSafariLike(): boolean {
+  const name = getEngine().name;
+  return name === 'webkit';
+}

package/src/env/is-stationary/is-stationary.ts

@@ -0,0 +1,8 @@
+import {isDesktop, isTV} from '../';
+
+/**
+ * Returns true if the platform is desktop or TV, otherwise false
+ */
+export function isStationary(): boolean {
+  return isTV() || isDesktop();
+}

package/src/env/is-tablet/is-tablet.ts

@@ -0,0 +1,9 @@
+import {getPlatform} from '../';
+
+/**
+ * Returns true if the platform is tablet, otherwise false
+ */
+export function isTablet(): boolean {
+  const name = getPlatform();
+  return name === 'tablet';
+}

package/src/env/is-tv/is-tv.ts

@@ -0,0 +1,9 @@
+import {getPlatform} from '../';
+
+/**
+ * Returns true if the platform is TV, otherwise false
+ */
+export function isTV(): boolean {
+  const name = getPlatform();
+  return name === 'tv';
+}

package/src/env/matches/matches.ts

@@ -0,0 +1,55 @@
+import {INTERRUPT} from '../../common';
+import {exclude, forEachObj} from '../../obj';
+import {getPlatform, isOS, matchesWithBrowsers, PlatformsCondition} from '../';
+
+/**
+ * Checks if a current browser matches a specific set of conditions
+ *
+ * Condition structure:
+ * {
+ *   [platformName | anyPlatform]: {
+ *     [osName | anyOS]: {
+ *       osVersion?: versionCondition(x.x...x | [~ >= > <= <]x.x...x),
+ *       browserName?: versionCondition(x.x...x | [~ >= > <= <]x.x...x),
+ *       engines?: engineName | {
+ *         engineName: versionCondition(x.x...x | [~ >= > <= <]x.x...x)
+ *         ...
+ *       }
+ *       ...
+ *     }
+ *     ...
+ *   }
+ *   ...
+ * }
+ *
+ * @example
+ * matches({anyPlatform: {anyOS: {chrome: ''}}});
+ * matches({desktop: {windows: {chrome: '96.0.4664.110'}}});
+ * matches({desktop: {windows: {osVersion: '~10', engines: 'blink'}}});
+ * matches({desktop: {anyOS: {engines: {blink: '>90.5', gecko: '<=100'}}}});
+ * matches({anyPlatform: {ios: {chrome: '~96.1', safari: '>80'}}});
+ *
+ * @param condition - an object that has keys corresponding to platform names
+ * and values corresponding to objects that have keys corresponding to OS names
+ * and values corresponding to objects that have keys corresponding to browser names
+ * and values corresponding to browser versions
+ */
+export function matches(condition: PlatformsCondition): boolean {
+  let result = false;
+
+  forEachObj(condition, (oss, platform) => {
+    if (oss && (platform === 'anyPlatform' || platform === getPlatform())) {
+      forEachObj(oss, (browsers, osName) => {
+        const osVersion = browsers?.osVersion;
+        if (browsers && (osName === 'anyOS' || isOS(osName, osVersion))) {
+          result = matchesWithBrowsers(exclude(browsers, 'osVersion'));
+        }
+        return result && INTERRUPT;
+      });
+    }
+
+    return result && INTERRUPT;
+  });
+
+  return result;
+}

package/src/env/matches-with-browsers/matches-with-browsers.ts

@@ -0,0 +1,55 @@
+import {INTERRUPT, isObject, isString} from '../../common';
+import {forEachObj} from '../../obj';
+import {BrowsersCondition, getEngine, isBrowser, isEngine} from '../';
+
+/**
+ * Checks if a current browser matches a specific set of browsers
+ *
+ * Condition structure:
+ * {
+ *   browserName?: versionCondition(x.x...x | [~ >= > <= <]x.x...x),
+ *   engines?: engineName | {
+ *     engineNane: versionCondition(x.x...x | [~ >= > <= <]x.x...x)
+ *     ...
+ *   }
+ *   ...
+ * }
+ *
+ * @example
+ * matchesWithBrowsers({firefox: '>=95.5', chrome: '~96.0.4664'});
+ * matchesWithBrowsers({engines: 'gecko', firefox: '>100.1'});
+ * matchesWithBrowsers({engines: {blink: '~96', gecko: '110.5.0'}, firefox: '>100.1'});
+ *
+ * @param condition - an object that has keys corresponding to browser names
+ * and values corresponding to browser version conditions
+ */
+export function matchesWithBrowsers(condition: BrowsersCondition): boolean {
+  let result = false;
+
+  forEachObj(condition, (enginesOrVer, browser) => {
+    if (browser === 'engines') {
+      const {name} = getEngine();
+      const engines = enginesOrVer;
+
+      if (isObject(engines)) {
+        forEachObj(engines, (version, engine) => {
+          if (isEngine(engine, version)) {
+            result = true;
+          }
+          return result && INTERRUPT;
+        });
+      } else if (isString(engines) && engines === name) {
+        result = true;
+      }
+    } else {
+      const version = <string>enginesOrVer;
+      if (isBrowser(browser, version)) {
+        result = true;
+      }
+    }
+
+    return result && INTERRUPT;
+  });
+
+  return result;
+}

package/src/env/matches-with-version/matches-with-version.ts

@@ -0,0 +1,44 @@
+import {INTERRUPT} from '../../common';
+import {forEachArr} from '../../arr';
+
+/**
+ * Checks if a specific version matches a version condition
+ * @param version - any browser or OS version, for example: x.x...x
+ * @param condition - version condition in the format: x.x...x | [~ >= > <= <]x.x...x
+ */
+export function matchesWithVersion(version: string, condition: string): boolean {
+  let result = 0;
+  const versionParts = version.split('.');
+  const conditionParts = condition.split('.');
+  const matches = conditionParts[0].match(/^([~><=]*)(\d+)$/i);
+  const operator = matches && matches.length ? matches[1] : '';
+  conditionParts[0] = matches && matches.length ? matches[2] : '0';
+
+  forEachArr(conditionParts, (part: string, index: number) => {
+    const a = Number(versionParts[index]);
+    const b = Number(part);
+
+    switch (operator) {
+      case '~':
+        result = a === b ? 1 : -1;
+        return result !== -1 || INTERRUPT;
+      case '>':
+        result = a === b ? 0 : (a > b ? 1 : -1);
+        return result === 0 || INTERRUPT;
+      case '>=':
+        result = a === b || a > b ? 1 : -1;
+        return (result !== -1 && !(a > b)) || INTERRUPT;
+      case '<':
+        result = a === b ? 0 : (a < b ? 1 : -1);
+        return result === 0 || INTERRUPT;
+      case '<=':
+        result = a === b || a < b ? 1 : -1;
+        return (result !== -1 && !(a < b)) || INTERRUPT;
+      default:
+        result = a === b && versionParts.length === conditionParts.length ? 1 : -1;
+        return result !== -1 || INTERRUPT;
+    }
+  });
+
+  return result === 1;
+}

package/src/env/private/private.ts

@@ -0,0 +1,82 @@
+import {isArray, isFunction, isRegExp, isString, isUndefined} from '../../common';
+import {getUserAgent} from '../';
+import {BotData, EnvCondition, EnvData} from '../types';
+
+/*
+ * Functions for internal use
+ */
+
+let bot: BotData | null = null;
+
+const botConditions: EnvCondition[] = ['googlebot', 'bingbot', 'yandexbot', 'slurp'];
+
+/*
+ * @internal
+ * For internal use
+ */
+export function getBot(): BotData {
+  return bot ??= <BotData>getEnvData(botConditions);
+}
+
+/*
+ * @internal
+ * For internal use
+ */
+export function resetBot(): void {
+  bot = null;
+}
+
+/*
+ * @internal
+ * For internal use
+ */
+export function getEnvData(conditions: EnvCondition[], needVersion = false): EnvData {
+  const agent = getUserAgent();
+  const result: EnvData = {
+    name: 'unknown',
+    version: '',
+    major: '',
+  };
+
+  for (const condition of conditions) {
+    // eslint-disable-next-line prefer-const
+    let [name, test, ver] = isString(condition) ? [condition] : condition;
+    const tests = isArray(test) ? test : (isUndefined(test) ? [name] : [test]);
+
+    if (needVersion) {
+      ver = isUndefined(ver) ? getVerRegExp(isString(test) ? test : name) : (isString(ver) ? getVerRegExp(ver) : ver);
+    }
+
+    for (let test of tests) {
+      if (isString(test)) {
+        test = getTestRegExp(test);
+      }
+      if ((isFunction(test) && test()) || (isRegExp(test) && agent.search(test) > -1)) {
+        result.name = <any>name;
+
+        if (needVersion && isRegExp(ver)) {
+          const matches = agent.match(ver);
+          result.version = (matches && matches.length > 1 && matches[1]) || '';
+          result.version = result.version.trim().replace(/[\s_-]+/g, '.');
+
+          if (result.version) {
+            result.major = result.version.split('.')[0];
+            return result;
+          }
+        }
+
+        return result;
+      }
+    }
+  }
+
+  return result;
+}
+
+function getTestRegExp(name: string): RegExp {
+  return new RegExp(name, 'i');
+}
+
+function getVerRegExp(name: string): RegExp {
+  return new RegExp(`${name}(?:[\\s:;/-]?ver(?:sion)?)?[\\s:/-]?(\\d+(?:[_.-]\\d+)*)`, 'i');
+}

package/src/env/types.ts

@@ -0,0 +1,146 @@
+/**
+ * Represents supported bot names
+ */
+export type BotNames = 'googlebot' | 'bingbot' | 'yandexbot' | 'slurp' | 'unknown';
+
+/**
+ * Represents supported platform names
+ */
+export type PlatformNames = 'tv' | 'desktop' | 'tablet' | 'mobile' | BotNames;
+
+/**
+ * Represents supported OS names
+ */
+export type OSNames = 'xbox' | 'windows' | 'ios' | 'macOS' | 'webOS' | 'tizen' | 'appleTV' | 'roku' | 'chromeOS'
+  | 'playstation4' | 'playstation5' | 'nintendoSwitch' | 'likeAndroid' | 'android' | 'linux' | BotNames;
+
+/**
+ * Represents supported engine names
+ */
+export type EngineNames = 'blink' | 'webkit' | 'gecko' | BotNames;
+
+/**
+ * Represents supported browser names
+ */
+export type BrowserNames = 'opera' | 'operaCoast' | 'operaTouch' | 'samsung' | 'mz' | 'yandex' | 'uc' | 'maxthon'
+  | 'kmeleon' | 'wechat' | 'qqLite' | 'qq' | 'edge' | 'sailfish' | 'webOS' | 'tizen' | 'miui' | 'silk' | 'phantomjs'
+  | 'slimerjs' | 'qupzilla' | 'electron' | 'whale' | 'focus' | 'swing' | 'epiphany' | 'puffin' | 'sleipnir' | 'vivaldi'
+  | 'seamonkey' | 'playstation4' | 'playstation5' | 'googleSearch' | 'firefox' | 'chrome' | 'android' | 'safari'
+  | BotNames;
+
+/**
+ * Represents a version data
+ */
+export interface VersionData {
+
+  /**
+   * Full version
+   */
+  version: string;
+
+  /**
+   * Major version (first number)
+   */
+  major: string;
+}
+
+/**
+ * Represents the returned data by the getOS function
+ */
+export interface OSData extends VersionData {
+
+  /**
+   * Unique name of the OS
+   */
+  name: OSNames;
+}
+
+/**
+ * Represents the returned data by the getEngine function
+ */
+export interface EngineData extends VersionData {
+
+  /**
+   * Unique name of the browser engine
+   */
+  name: EngineNames;
+}
+
+/**
+ * Represents the returned data by the getBrowser function
+ */
+export interface BrowserData extends VersionData {
+
+  /**
+   * Unique name of the browser
+   */
+  name: BrowserNames;
+}
+
+/**
+ * Represents an object that have keys corresponding to engine names and values corresponding to engine versions
+ */
+export type EnginesCondition = {[key in EngineNames]?: string};
+
+/**
+ * Represents an object that have keys corresponding to browser names and values corresponding to browser versions,
+ * and may have an engine property with the engines condition
+ */
+export type BrowsersCondition = {[key in BrowserNames]?: string} & {engines?: EngineNames | EnginesCondition};
+
+/**
+ * Represents the browsers condition with an optional osVersion property
+ */
+export type OSBrowsersCondition = BrowsersCondition & {osVersion?: string};
+
+/**
+ * Represents an object that have keys corresponding to OS names and values corresponding to the OS browsers conditions
+ */
+export type OSCondition = {[key in OSNames]?: OSBrowsersCondition} & {anyOS?: OSBrowsersCondition};
+
+/**
+ * Represents an object that have keys corresponding to platform names and values corresponding to the OS conditions
+ */
+export type PlatformsCondition = {[key in PlatformNames]?: OSCondition} & {anyPlatform?: OSCondition};
+
+/*
+ * @internal
+ * Represents the returned data by the getBot function
+ */
+export interface BotData extends VersionData {
+
+  /*
+   * Unique name of the bot
+   */
+  name: BotNames;
+}
+
+/*
+ * @internal
+ * Represents the returned data by the getEnvData function
+ */
+export interface EnvData extends VersionData {
+
+  /*
+   * Unique name of the platform, OS, browser or browser engine
+   */
+  name: PlatformNames | OSNames | EngineNames | BrowserNames;
+}
+
+/*
+ * @internal
+ * Represents the test type to test for compliance
+ */
+export type EnvTest = string | RegExp | (() => boolean);
+
+/*
+ * @internal
+ * Represents a group of tests
+ */
+export type EnvTestGroup = EnvTest | EnvTest[];
+
+/*
+ * @internal
+ * Represents a set of tests and template for retrieving a version
+ */
+export type EnvCondition = string | [string, EnvTestGroup] | [string, EnvTestGroup, string | RegExp];

package/src/env/user-agent/user-agent.ts

@@ -0,0 +1,29 @@
+import {resetBrowser} from '../get-browser/get-browser';
+import {resetEngine} from '../get-engine/get-engine';
+import {resetOS} from '../get-os/get-os';
+import {resetPlatform} from '../get-platform/get-platform';
+import {resetBot} from '../private/private';
+
+let agent = typeof navigator === 'object' ? navigator.userAgent : '';
+
+/**
+ * Returns user agent
+ */
+export function getUserAgent(): string {
+  return agent;
+}
+
+/**
+ * If the global object is not a window, you can use this function to set up a stub user agent
+ * @param userAgent - any string with user agent data
+ */
+export function setUserAgent(userAgent: string): void {
+  if (agent !== userAgent) {
+    resetBot();
+    resetOS();
+    resetEngine();
+    resetPlatform();
+    resetBrowser();
+    agent = userAgent;
+  }
+}