JavaScript Browser, OS, and Device Detection

/**
 * Detects operating system and version from a user agent string
 * @param {string} [userAgent] -
    Custom user agent string. If not provided, uses navigator.userAgent
 * @returns {Object} Object containing OS name and version
 * @throws {Error} If userAgent parameter is provided but not a string
 */
const getOS = (userAgent) => {
    // Input validation
    if (userAgent !== undefined && typeof userAgent !== 'string') {
        throw new Error('userAgent parameter must be a string');
    }

    // Use provided userAgent or fallback to navigator.userAgent
    const ua = userAgent || (typeof navigator !== 'undefined' ? navigator.userAgent : '');

    const versionFormatt = version => version.replace(/_/g, '.');

    // Enhanced OS detection patterns
    const osMatchers = [
        {
            name: 'Windows',
            regex: /Windows NT ([0-9.]+)/,
            versionMap: {
                '10.0': '10',
                '6.3': '8.1',
                '6.2': '8',
                '6.1': '7',
                '6.0': 'Vista',
                '5.2': 'Server 2003/XP x64',
                '5.1': 'XP',
                '5.0': '2000'
            }
        },
        {
            name: 'MacOS',
            regex: /Mac OS X ([0-9._]+)/,
            versionFormatter: versionFormatt
        },
        {
            name: 'iOS',
            regex: /OS ([\d._]+) like Mac OS X/,
            versionFormatter: versionFormatt
        },
        {
            name: 'iPadOS',
            regex: /iPad.*OS ([\d._]+)/,
            versionFormatter: versionFormatt
        },
        { name: 'Android', regex: /Android ([0-9.]+)/ },
        { name: 'FreeBSD', regex: /FreeBSD/ },
        { name: 'OpenBSD', regex: /OpenBSD/ },
        { name: 'NetBSD', regex: /NetBSD/ },
        { name: 'Solaris', regex: /SunOS/ },
        { name: 'BlackBerry', regex: /BB10|BlackBerry/ },
        { name: 'KaiOS', regex: /KaiOS ([0-9.]+)/ },
        { name: 'Windows Phone', regex: /Windows Phone ([0-9.]+)/ },
        {
            name: 'Linux',
            regex: /Linux/,
            distributions: [
                { name: 'Ubuntu', regex: /Ubuntu/ },
                { name: 'Fedora', regex: /Fedora/ },
                { name: 'Red Hat', regex: /Red Hat/ },
                { name: 'Debian', regex: /Debian/ }
            ]
        },
        {
            name: 'Chrome OS',
            regex: /CrOS/
        }
    ];

    for (const os of osMatchers) {
        const match = ua.match(os.regex);
        if (match) {
            let version = match[1] || 'Unknown Version';

            // Handle Windows version mapping
            if (os.name === 'Windows' && os.versionMap?.[version]) {
                version = os.versionMap[version];
            }

            // Handle version formatting (e.g., for MacOS and iOS)
            if (os.versionFormatter) {
                version = os.versionFormatter(version);
            }

            // Handle Linux distributions
            if (os.name === 'Linux' && os.distributions) {
                for (const dist of os.distributions) {
                    if (ua.match(dist.regex)) {
                        return {
                            name: `${dist.name} Linux`,
                            version: 'Unknown Version',
                            baseOS: 'Linux'
                        };
                    }
                }
            }

            return { name: os.name, version };
        }
    }

    return { name: 'Unknown OS', version: 'Unknown Version' };
};

// Example usage:
try {
    // Using browser default user agent
    const browserOS = getOS();
    console.log('name:', browserOS.name); // Windows
    console.log('version:', browserOS.version); // 10

    // Using a custom user agent string
    const customUA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) ... Safari/601.3.9';
    const customOS = getOS(customUA);
    console.log('Custom OS:', customOS);
    // {name: 'MacOS', version: '10.11.2'}
} catch (error) {
    console.error('Error detecting OS:', error.message);
}

const getDeviceType = () => {
    const userAgent = (typeof navigator !== 'undefined' ? navigator.userAgent : '').toLowerCase();
    const width = typeof window !== 'undefined' ? window.innerWidth : 0;

    const hasTouch = typeof window !== 'undefined' && (
        'ontouchstart' in window ||
        navigator.maxTouchPoints > 0 ||
        navigator.msMaxTouchPoints > 0
    );

    // Brand patterns
    const brandPatterns = {
        apple: /(iphone|ipad|ipod|mac)/i,
        samsung: /samsung|sm-|galaxy/i,
        huawei: /huawei|honor|nova|mate|p\d+/i,
        pixel: /pixel|google/i,
        xiaomi: /xiaomi|redmi|poco|mi\s|blackshark/i,
        surface: /surface/i,
        oppo: /oppo|realme|find\sx|reno/i,
        vivo: /vivo|iqoo|nex/i,
        lenovo: /lenovo/i,
        motorola: /motorola|moto\s|razr/i,
        asus: /asus|zenfone|rog\sphone/i,
        sony: /sony|xperia/i,
        lg: /lg|nexus|velvet|wing/i,
        nokia: /nokia|hmd/i,
        oneplus: /oneplus|nord/i,
        zte: /zte|nubia|axon/i,
        tcl: /tcl|alcatel/i,
        meizu: /meizu|mx\d/i,
        blackberry: /blackberry|bb|rim/i,
        htc: /htc|desire/i,
        nothing: /nothing\sphone/i,
        fairphone: /fairphone/i,
        cat: /cat phone|caterpillar/i,
        sharp: /sharp|aquos/i,
        tecno: /tecno|camon|spark/i,
        infinix: /infinix|hot|note/i,
        essential: /essential\sph/i
    };

    // Device type patterns
    const patterns = {
        tablet: /tablet|ipad|playbook|silk|(android(?!.*mobile))/i,
        mobile: /android|webos|iphone|ipod|blackberry|iemobile|opera mini|mobile|phone/i,
        gamingConsole: /playstation|nintendo|xbox/i,
        smartTv: /smart-tv|googletv|netcast|webos|tizen/i,
    };

    const detectBrand = () => {
        for (const [brand, pattern] of Object.entries(brandPatterns)) {
            if (pattern.test(userAgent)) return brand;
        }
        return 'unknown';
    };

    // Determine device type with additional categories
    let deviceType;
    if (patterns.tablet.test(userAgent) || (width >= 768 && hasTouch)) {
        deviceType = 'tablet';
    } else if (patterns.mobile.test(userAgent) || (width < 768 && hasTouch)) {
        deviceType = 'mobile';
    } else if (patterns.gamingConsole.test(userAgent)) {
        deviceType = 'gamingConsole';
    } else if (patterns.smartTv.test(userAgent)) {
        deviceType = 'smartTv';
    } else {
        deviceType = 'desktop';
    }

    return {
        type: deviceType,
        brand: detectBrand(),
        hasTouch,
        isApple: brandPatterns.apple.test(userAgent),
    };
};

// Call the function to detect device details
const deviceInfo = getDeviceType();

// Log the output
console.log("Device Information:", deviceInfo);

console.log("Type:", deviceInfo.type);
console.log("Brand:", deviceInfo.brand);
console.log("Has Touch:", deviceInfo.hasTouch);
console.log("Is Apple:", deviceInfo.isApple);

const isBraveBrowser = async () => {
  try {
    if (navigator.brave && typeof navigator.brave.isBrave === 'function') {
      return await navigator.brave.isBrave();
    }
    return false;
  } catch (error) {
    console.error('Error checking Brave browser:', error); // Optional logging
    return false;
  }
};

// Usage with then/catch
isBraveBrowser()
  .then(isBrave => {
    if (isBrave) {
      console.log('This is Brave browser');
    } else {
      console.log('This is not Brave browser');
    }
  })
  .catch(error => {
    console.error('Error checking browser:', error);
  });