@tinkoff/user-agent 0.7.116 → 0.8.102

package/lib/satisfies/is-browser-satisfies-requirements.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isString = require('@tinkoff/utils/is/string');
+var browserslistTinkoffConfig = require('@tinkoff/browserslist-config');
+var browserslistFileConfig = require('@tramvai/cli/lib/external/browserslist-normalized-file-config');
+var parseUserAgentHeader = require('../parse-user-agent-header/parseUserAgentHeader.js');
+var constants = require('./constants.js');
+var normalizeBrowserslist = require('./utils/normalizeBrowserslist.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
+var browserslistTinkoffConfig__default = /*#__PURE__*/_interopDefaultLegacy(browserslistTinkoffConfig);
+var browserslistFileConfig__default = /*#__PURE__*/_interopDefaultLegacy(browserslistFileConfig);
+
+/*
+  The function isBrowserSatisfiesRequirements checks if a given user agent satisfies the specified
+  browser requirements based on a browserslist configuration. It parses the user agent to determine
+  the browser and its version, normalizes the browserslist configuration, and compares the browser
+  version against the specified requirements. The function returns true if the browser meets the requirements,
+  false if it does not, and null if the browser is not found in the browserslist.
+  It also handles special cases for Chromium-based browsers and allows forcing the use of minimum requested
+  versions for browsers with incomplete statistics.
+*/
+const isBrowserSatisfiesRequirements = (userAgent, browserslistConfig, { env = 'defaults', forceMinimumUnknownVersions = false } = {}) => {
+    const ua = isString__default["default"](userAgent) ? parseUserAgentHeader.parseUserAgentHeader(userAgent) : userAgent;
+    const { engine: { name: engineName = '', version: engineVersion }, device: { type = '' } = {}, } = ua;
+    let { browser: { name: browserName = '', version: browserVersion = '' } = {} } = ua;
+    /*
+      Chromium based browsers (yandex, samsung, opera, vivaldi, edge) specify the engine version as `Chrome/*'.
+      And the engine version (blink) will be converted to the chromium version one-to-one.
+      https://github.com/faisalman/ua-parser-js/pull/390
+      https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#Rendering_engine
+    */
+    if (engineName === 'chromium' ||
+        (engineName.toLowerCase() === 'blink' &&
+            constants.CHROMIUM_BASED_BROWSERS.indexOf(browserName.toLowerCase()) !== -1)) {
+        browserName = 'chrome';
+        browserVersion = engineVersion || '';
+    }
+    // parseFloat - it will take away the major + minor versions, discard the rest.
+    const checkVersion = parseFloat(browserVersion);
+    const deviceType = constants.DEVICE_TYPES[type] || type || constants.DEVICE_TYPES.desktop; // по умолчанию считаем устройство десктопом
+    if (!browserName) {
+        return null;
+    }
+    const targets = browserslistConfig ?? browserslistFileConfig__default["default"][env] ?? browserslistTinkoffConfig__default["default"][env];
+    const browsers = normalizeBrowserslist.normalizeBrowserslist(targets);
+    // Browsers from query may not be present in https://caniuse.com/usage-table, and browserslist will return higher versions than requested.
+    // Example of this problem - https://github.com/babel/babel/issues/8545
+    // It is mean, that for this unknown versions babel will not add specific transforms, but still, transpiled code has a chance to work in required old browsers.
+    // And if `satisfies` will be used for example for old browser detection, we can force use minimum requested versions instead of minimum from caniuse data.
+    if (forceMinimumUnknownVersions) {
+        Object.keys(constants.BROWSERS_WITHOUT_COMPLETE_STAT).forEach((browser) => {
+            const target = targets.find((query) => query.startsWith(browser));
+            // @todo - respect other browserslist query patterns
+            if (target && target.includes('>=')) {
+                const [targetBrowser, targetMinVersion] = target.split(' >= ');
+                // @ts-expect-error
+                const browserKey = constants.BROWSERS_WITHOUT_COMPLETE_STAT[targetBrowser];
+                const mappedBrowser = constants.BROWSERS_LIST_MAP[browserKey];
+                if (mappedBrowser && browsers[mappedBrowser.name]) {
+                    if (Number(targetMinVersion) < Number(browsers[mappedBrowser.name][mappedBrowser.type])) {
+                        browsers[mappedBrowser.name][mappedBrowser.type] = Number(targetMinVersion);
+                    }
+                }
+            }
+        });
+    }
+    let hasEntry = false;
+    if (browserName in browsers) {
+        const browserInfo = browsers[browserName];
+        const browserInfoVersion = browserInfo.any ?? browserInfo[deviceType];
+        hasEntry = !!browserInfoVersion;
+        if (checkVersion >= browserInfoVersion) {
+            return true;
+        }
+    }
+    return hasEntry ? false : null; // null means that we did not find a browser match in the browserslist.
+};
+
+exports.isBrowserSatisfiesRequirements = isBrowserSatisfiesRequirements;

package/lib/satisfies/types.d.ts

@@ -0,0 +1,6 @@
+export type BrowserMap = Record<string, Record<string, number>>;
+export type SatisfiesOptions = {
+    env?: 'defaults';
+    forceMinimumUnknownVersions?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/satisfies/utils/normalizeBrowserslist.d.ts

@@ -0,0 +1,3 @@
+import { BrowserMap } from '../types';
+export declare const normalizeBrowserslist: (query: string[]) => BrowserMap;
+//# sourceMappingURL=normalizeBrowserslist.d.ts.map

package/lib/satisfies/utils/normalizeBrowserslist.es.js

@@ -0,0 +1,42 @@
+import browserslist from 'browserslist';
+import { BROWSERS_LIST_MAP } from '../constants.es.js';
+
+const normalizeBrowserslist = (query) => {
+    const resolved = browserslist(query, {
+        /*
+            We set it to true so that the browserslist returns the full list for mobile browsers,
+            because by default, due to the fact that `Can I use` stores only the latest version of mobile browsers,
+            the browserslist returns only the latest version for mobile devices,
+            and so it will map compliance to the desktop version.
+          */
+        mobileToDesktop: true,
+    })
+        /*
+            Since ie was removed from the @tinkoff/browserslist-config config, in order to cut off ie,
+            we add a dummy version so that the entire function returns false for any version of ie,
+            and if the regular ie version was set in the custom config or in the config passed as an argument,
+            this dummy version will not affect anything and the custom version will be used.
+          */
+        .concat(['ie 999']);
+    const result = {};
+    for (let i = 0; i < resolved.length; i++) {
+        const [name, version] = resolved[i].split(' ');
+        if (BROWSERS_LIST_MAP[name]) {
+            const { type: mapType, name: mapName } = BROWSERS_LIST_MAP[name];
+            const mapVersion = parseFloat(version);
+            if (result[mapName]) {
+                if (!result[mapName][mapType] || result[mapName][mapType] > mapVersion) {
+                    result[mapName][mapType] = mapVersion;
+                }
+            }
+            else {
+                result[mapName] = {
+                    [mapType]: mapVersion,
+                };
+            }
+        }
+    }
+    return result;
+};
+
+export { normalizeBrowserslist };

package/lib/satisfies/utils/normalizeBrowserslist.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var browserslist = require('browserslist');
+var constants = require('../constants.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var browserslist__default = /*#__PURE__*/_interopDefaultLegacy(browserslist);
+
+const normalizeBrowserslist = (query) => {
+    const resolved = browserslist__default["default"](query, {
+        /*
+            We set it to true so that the browserslist returns the full list for mobile browsers,
+            because by default, due to the fact that `Can I use` stores only the latest version of mobile browsers,
+            the browserslist returns only the latest version for mobile devices,
+            and so it will map compliance to the desktop version.
+          */
+        mobileToDesktop: true,
+    })
+        /*
+            Since ie was removed from the @tinkoff/browserslist-config config, in order to cut off ie,
+            we add a dummy version so that the entire function returns false for any version of ie,
+            and if the regular ie version was set in the custom config or in the config passed as an argument,
+            this dummy version will not affect anything and the custom version will be used.
+          */
+        .concat(['ie 999']);
+    const result = {};
+    for (let i = 0; i < resolved.length; i++) {
+        const [name, version] = resolved[i].split(' ');
+        if (constants.BROWSERS_LIST_MAP[name]) {
+            const { type: mapType, name: mapName } = constants.BROWSERS_LIST_MAP[name];
+            const mapVersion = parseFloat(version);
+            if (result[mapName]) {
+                if (!result[mapName][mapType] || result[mapName][mapType] > mapVersion) {
+                    result[mapName][mapType] = mapVersion;
+                }
+            }
+            else {
+                result[mapName] = {
+                    [mapType]: mapVersion,
+                };
+            }
+        }
+    }
+    return result;
+};
+
+exports.normalizeBrowserslist = normalizeBrowserslist;

package/lib/types.d.ts

@@ -1,3 +1,5 @@
+import { BrowserEngine, DeviceType, MobileOs } from './constants';
+export type BrowserEngineType = (typeof BrowserEngine)[keyof typeof BrowserEngine];
 export interface Browser {
     name: string | undefined;
     /**
@@ -18,6 +20,7 @@ export interface Engine {
     name: string | undefined;
     version: string | undefined;
 }
+export type DeviceType = (typeof DeviceType)[keyof typeof DeviceType];
 export interface Device {
     /**
      * Device type may be undefined in various cases.
@@ -37,6 +40,7 @@ export interface OS {
 export interface Cpu {
     architecture: string | undefined;
 }
+export type MobileOs = (typeof MobileOs)[keyof typeof MobileOs];
 export interface UserAgent {
     browser: Browser;
     engine: Engine;

package/lib/utils/getBrowserEngine.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Possible values :
+ * firefox, safari, chrome, other
+ *
+ * The return type here should be BrowserEngine, not string,
+ * but we are not changing it to maintain backward compatibility.
+ */
+export declare const getBrowserEngine: (browserName?: string, engineName?: string) => string;
+//# sourceMappingURL=getBrowserEngine.d.ts.map

package/lib/{utils.es.js → utils/getBrowserEngine.es.js}

@@ -1,32 +1,28 @@
-const getMobileOs = (osName) => {
-    switch (osName) {
-        case 'Windows Phone':
-            return 'winphone';
-        case 'Android':
-            return 'android';
-        case 'iOS':
-            return 'ios';
-        case 'BlackBerry':
-        case 'RIM Tablet OS':
-            return 'blackberry';
-    }
-};
+import { BrowserEngine } from '../constants.es.js';
+
+/**
+ * Possible values :
+ * firefox, safari, chrome, other
+ *
+ * The return type here should be BrowserEngine, not string,
+ * but we are not changing it to maintain backward compatibility.
+ */
 const getBrowserEngine = (browserName, engineName) => {
     switch (true) {
         case browserName === 'firefox':
-            return 'firefox';
+            return BrowserEngine.firefox;
         // If an `engineName` is webkit, and it's not Safari,
         // then define the `browserName` as `safari`, because all browsers
         // on iOS use webkit. Also, we are not handling mobile Safari separately,
         // as it webkit too. See https://en.wikipedia.org/wiki/WebKit
         case browserName === 'safari' || browserName === 'mobile safari' || engineName === 'webkit':
-            return 'safari';
+            return BrowserEngine.safari;
         // We aren't using something like `browserName === 'chrome'` here,
         // because there are a lot of browsers based on chromium.
         case engineName === 'blink' || engineName === 'chromium':
-            return 'chrome';
+            return BrowserEngine.chrome;
     }
-    return 'other';
+    return BrowserEngine.other;
 };
 
-export { getBrowserEngine, getMobileOs };
+export { getBrowserEngine };

package/lib/{utils.js → utils/getBrowserEngine.js}

@@ -2,36 +2,31 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const getMobileOs = (osName) => {
-    switch (osName) {
-        case 'Windows Phone':
-            return 'winphone';
-        case 'Android':
-            return 'android';
-        case 'iOS':
-            return 'ios';
-        case 'BlackBerry':
-        case 'RIM Tablet OS':
-            return 'blackberry';
-    }
-};
+var constants = require('../constants.js');
+
+/**
+ * Possible values :
+ * firefox, safari, chrome, other
+ *
+ * The return type here should be BrowserEngine, not string,
+ * but we are not changing it to maintain backward compatibility.
+ */
 const getBrowserEngine = (browserName, engineName) => {
     switch (true) {
         case browserName === 'firefox':
-            return 'firefox';
+            return constants.BrowserEngine.firefox;
         // If an `engineName` is webkit, and it's not Safari,
         // then define the `browserName` as `safari`, because all browsers
         // on iOS use webkit. Also, we are not handling mobile Safari separately,
         // as it webkit too. See https://en.wikipedia.org/wiki/WebKit
         case browserName === 'safari' || browserName === 'mobile safari' || engineName === 'webkit':
-            return 'safari';
+            return constants.BrowserEngine.safari;
         // We aren't using something like `browserName === 'chrome'` here,
         // because there are a lot of browsers based on chromium.
         case engineName === 'blink' || engineName === 'chromium':
-            return 'chrome';
+            return constants.BrowserEngine.chrome;
     }
-    return 'other';
+    return constants.BrowserEngine.other;
 };
 
 exports.getBrowserEngine = getBrowserEngine;
-exports.getMobileOs = getMobileOs;

package/lib/utils/getMobileOs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Possible values:
+ * winphone, android, ios, blackberry
+ *
+ * The return type here should be MobileOs, not string | undefined,
+ * but we are not changing it to maintain backward compatibility.
+ */
+export declare const getMobileOs: (osName?: string) => string | undefined;
+//# sourceMappingURL=getMobileOs.d.ts.map

package/lib/utils/getMobileOs.es.js

@@ -0,0 +1,24 @@
+import { MobileOs } from '../constants.es.js';
+
+/**
+ * Possible values:
+ * winphone, android, ios, blackberry
+ *
+ * The return type here should be MobileOs, not string | undefined,
+ * but we are not changing it to maintain backward compatibility.
+ */
+const getMobileOs = (osName) => {
+    switch (osName) {
+        case 'Windows Phone':
+            return MobileOs.winphone;
+        case 'Android':
+            return MobileOs.android;
+        case 'iOS':
+            return MobileOs.ios;
+        case 'BlackBerry':
+        case 'RIM Tablet OS':
+            return MobileOs.blackberry;
+    }
+};
+
+export { getMobileOs };

package/lib/utils/getMobileOs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+
+/**
+ * Possible values:
+ * winphone, android, ios, blackberry
+ *
+ * The return type here should be MobileOs, not string | undefined,
+ * but we are not changing it to maintain backward compatibility.
+ */
+const getMobileOs = (osName) => {
+    switch (osName) {
+        case 'Windows Phone':
+            return constants.MobileOs.winphone;
+        case 'Android':
+            return constants.MobileOs.android;
+        case 'iOS':
+            return constants.MobileOs.ios;
+        case 'BlackBerry':
+        case 'RIM Tablet OS':
+            return constants.MobileOs.blackberry;
+    }
+};
+
+exports.getMobileOs = getMobileOs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinkoff/user-agent",
-  "version": "0.7.116",
+  "version": "0.8.102",
   "description": "",
   "main": "lib/index.js",
   "module": "lib/index.es.js",
@@ -18,7 +18,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@tinkoff/browserslist-config": "0.5.3",
+    "@tinkoff/browserslist-config": "0.6.2",
     "@tinkoff/utils": "^2.1.2",
     "browserslist": "^4.16.7",
     "tslib": "^2.4.0",
@@ -29,7 +29,7 @@
     "user-agent-data-types": "^0.3.1"
   },
   "peerDependencies": {
-    "@tramvai/cli": "5.50.0",
+    "@tramvai/cli": "6.59.0",
     "@types/ua-parser-js": "^0.7.33"
   },
   "license": "Apache-2.0"

package/lib/client-hints.d.ts

@@ -1,33 +0,0 @@
-import type { UserAgent } from './types';
-/**
- *
- * @description
- *
- * Some of the data are available only when additional headers for client-hints were sent from server:
- * - full browser version (only major version is available by default)
- * - OS version
- * - CPU architecture
- * - device model
- *
- * To be able to use data you should first provide header `Accept-CH` with the list of headers that client should send.
- *
- * @param headers
- * @returns
- */
-export declare const parseClientHintsHeaders: (headers: Record<string, string | string[] | undefined>) => UserAgent;
-/**
- *
- * @description
- * Some of the data will be available if `UADataValues` were gotten from
- * `getHighEntropyValues` async method, but it's not suitable for all cases.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/User-Agent_Client_Hints_API
- * @see https://wicg.github.io/ua-client-hints/#http-ua-hints
- *
- * @param payload
- *
- * @example
- * const clientHints = parseClientHintsUserAgentData(window.navigator.userAgentData)
- */
-export declare const parseClientHintsUserAgentData: (payload: UADataValues) => UserAgent;
-//# sourceMappingURL=client-hints.d.ts.map

package/lib/client-hints.es.js

@@ -1,177 +0,0 @@
-import { getMobileOs, getBrowserEngine } from './utils.es.js';
-
-const KNOWN_VENDORS = new Set(['Opera', 'Google Chrome', 'Microsoft Edge', 'Firefox', 'Safari']);
-const KNOWN_ENGINES = new Set(['Chromium']);
-const BACKWARD_COMPATIBILITY_BROWSER_NAME = {
-    'Google Chrome': 'chrome',
-    'Microsoft Edge': 'edge',
-};
-const BACKWARD_COMPATIBILITY_ENGINE_NAME = {
-    Chromium: 'Blink',
-};
-const BACKWARD_COMPATIBILITY_ARCH = {
-    x86: 'amd64',
-};
-const BACKWARD_COMPATIBILITY_OS_NAME = {
-    macOS: 'Mac OS',
-};
-const parseQuotedString = (str) => {
-    if (!str) {
-        return str;
-    }
-    try {
-        return JSON.parse(str)?.trim();
-    }
-    catch (err) {
-        return str;
-    }
-};
-const parseBrowserFromString = (brandsList) => {
-    const browser = {
-        name: undefined,
-        version: undefined,
-        major: undefined,
-        browserEngine: '',
-    };
-    const engine = {
-        name: undefined,
-        version: undefined,
-    };
-    brandsList.split(',').forEach((entry) => {
-        const [name, version] = entry.split(/;\s*v=/).map(parseQuotedString);
-        if (name && KNOWN_VENDORS.has(name)) {
-            browser.name = BACKWARD_COMPATIBILITY_BROWSER_NAME[name] ?? name.toLowerCase();
-            browser.version = version;
-            browser.major = version;
-        }
-        if (name && KNOWN_ENGINES.has(name)) {
-            engine.name = BACKWARD_COMPATIBILITY_ENGINE_NAME[name] ?? name.toLowerCase();
-            engine.version = version;
-        }
-    });
-    if (!browser.name && engine.name) {
-        browser.name = engine.name;
-        browser.version = engine.version;
-    }
-    browser.browserEngine = getBrowserEngine(browser.name?.toLowerCase(), engine.name?.toLowerCase());
-    return { browser, engine };
-};
-const parseBrowserFromUserAgentData = (brands) => {
-    const browser = {
-        name: undefined,
-        version: undefined,
-        major: undefined,
-        browserEngine: '',
-    };
-    const engine = {
-        name: undefined,
-        version: undefined,
-    };
-    brands.forEach(({ brand, version }) => {
-        if (KNOWN_VENDORS.has(brand)) {
-            browser.name = BACKWARD_COMPATIBILITY_BROWSER_NAME[brand] ?? brand.toLowerCase();
-            browser.version = version;
-            [browser.major] = version.split('.');
-        }
-        if (KNOWN_ENGINES.has(brand)) {
-            engine.name = BACKWARD_COMPATIBILITY_ENGINE_NAME[brand] ?? brand.toLowerCase();
-            engine.version = version;
-        }
-    });
-    if (!browser.name && engine.name) {
-        browser.name = engine.name;
-        browser.version = engine.version;
-    }
-    browser.browserEngine = getBrowserEngine(browser.name?.toLowerCase(), engine.name?.toLowerCase());
-    return { browser, engine };
-};
-const getBackwardCompatibleOsName = (payload) => {
-    if (payload === undefined) {
-        return undefined;
-    }
-    return BACKWARD_COMPATIBILITY_OS_NAME[payload] ?? payload;
-};
-/**
- *
- * @description
- *
- * Some of the data are available only when additional headers for client-hints were sent from server:
- * - full browser version (only major version is available by default)
- * - OS version
- * - CPU architecture
- * - device model
- *
- * To be able to use data you should first provide header `Accept-CH` with the list of headers that client should send.
- *
- * @param headers
- * @returns
- */
-const parseClientHintsHeaders = (headers) => {
-    const { browser, engine } = parseBrowserFromString(headers['sec-ch-ua-full-version-list'] || headers['sec-ch-ua']);
-    const osName = parseQuotedString(headers['sec-ch-ua-platform']);
-    const mobileOS = getMobileOs(osName);
-    const architecture = parseQuotedString(headers['sec-ch-ua-arch']);
-    return {
-        browser,
-        engine,
-        os: {
-            name: getBackwardCompatibleOsName(osName),
-            version: parseQuotedString(headers['sec-ch-ua-platform-version']),
-        },
-        cpu: {
-            architecture: architecture
-                ? (BACKWARD_COMPATIBILITY_ARCH[architecture] ?? architecture)
-                : architecture,
-        },
-        mobileOS,
-        device: {
-            model: parseQuotedString(headers['sec-ch-ua-model']),
-            type: headers['sec-ch-ua-mobile'] === '?1' ? 'mobile' : 'desktop',
-            vendor: undefined,
-        },
-        // basically all the browsers with client-hints support
-        // also compatible with SameSite=None
-        sameSiteNoneCompatible: true,
-    };
-};
-/**
- *
- * @description
- * Some of the data will be available if `UADataValues` were gotten from
- * `getHighEntropyValues` async method, but it's not suitable for all cases.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/User-Agent_Client_Hints_API
- * @see https://wicg.github.io/ua-client-hints/#http-ua-hints
- *
- * @param payload
- *
- * @example
- * const clientHints = parseClientHintsUserAgentData(window.navigator.userAgentData)
- */
-const parseClientHintsUserAgentData = (payload) => {
-    const { browser, engine } = parseBrowserFromUserAgentData(payload.fullVersionList || payload.brands || []);
-    return {
-        browser,
-        engine,
-        os: {
-            name: getBackwardCompatibleOsName(payload.platform),
-            version: payload.platformVersion,
-        },
-        cpu: {
-            architecture: payload.architecture
-                ? (BACKWARD_COMPATIBILITY_ARCH[payload.architecture] ?? payload.architecture)
-                : payload.architecture,
-        },
-        mobileOS: getMobileOs(payload.platform),
-        device: {
-            model: payload.model,
-            type: payload.mobile ? 'mobile' : 'desktop',
-            vendor: undefined,
-        },
-        // basically all the browsers with client-hints support
-        // also compatible with SameSite=None
-        sameSiteNoneCompatible: true,
-    };
-};
-
-export { parseClientHintsHeaders, parseClientHintsUserAgentData };