@leanbase.com/js 0.1.3 → 0.2.0-alpha.0

package/src/utils/request-utils.ts

@@ -1,128 +0,0 @@
-import { logger } from '../leanbase-logger'
-import { each, document } from './'
-
-import { isArray, isFile, isUndefined } from '@posthog/core'
-
-const localDomains = ['localhost', '127.0.0.1']
-
-/**
- * IE11 doesn't support `new URL`
- * so we can create an anchor element and use that to parse the URL
- * there's a lot of overlap between HTMLHyperlinkElementUtils and URL
- * meaning useful properties like `pathname` are available on both
- */
-export const convertToURL = (url: string): HTMLAnchorElement | null => {
-    const location = document?.createElement('a')
-    if (isUndefined(location)) {
-        return null
-    }
-
-    location.href = url
-    return location
-}
-
-export const formDataToQuery = function (formdata: Record<string, any> | FormData, arg_separator = '&'): string {
-    let use_val: string
-    let use_key: string
-    const tph_arr: string[] = []
-
-    each(formdata, function (val: File | string | undefined, key: string | undefined) {
-        // the key might be literally the string undefined for e.g. if {undefined: 'something'}
-        if (isUndefined(val) || isUndefined(key) || key === 'undefined') {
-            return
-        }
-
-        use_val = encodeURIComponent(isFile(val) ? val.name : val.toString())
-        use_key = encodeURIComponent(key)
-        tph_arr[tph_arr.length] = use_key + '=' + use_val
-    })
-
-    return tph_arr.join(arg_separator)
-}
-
-// NOTE: Once we get rid of IE11/op_mini we can start using URLSearchParams
-export const getQueryParam = function (url: string, param: string): string {
-    const withoutHash: string = url.split('#')[0] || ''
-
-    // Split only on the first ? to sort problem out for those with multiple ?s
-    // and then remove them
-    const queryParams: string = withoutHash.split(/\?(.*)/)[1] || ''
-    const cleanedQueryParams = queryParams.replace(/^\?+/g, '')
-
-    const queryParts = cleanedQueryParams.split('&')
-    let keyValuePair
-
-    for (let i = 0; i < queryParts.length; i++) {
-        const parts = queryParts[i].split('=')
-        if (parts[0] === param) {
-            keyValuePair = parts
-            break
-        }
-    }
-
-    if (!isArray(keyValuePair) || keyValuePair.length < 2) {
-        return ''
-    } else {
-        let result = keyValuePair[1]
-        try {
-            result = decodeURIComponent(result)
-        } catch {
-            logger.error('Skipping decoding for malformed query param: ' + result)
-        }
-        return result.replace(/\+/g, ' ')
-    }
-}
-
-// replace any query params in the url with the provided mask value. Tries to keep the URL as instant as possible,
-// including preserving malformed text in most cases
-export const maskQueryParams = function <T extends string | undefined>(
-    url: T,
-    maskedParams: string[] | undefined,
-    mask: string
-): T extends string ? string : undefined {
-    if (!url || !maskedParams || !maskedParams.length) {
-        return url as any
-    }
-
-    const splitHash = url.split('#')
-    const withoutHash: string = splitHash[0] || ''
-    const hash = splitHash[1]
-
-    const splitQuery: string[] = withoutHash.split('?')
-    const queryString: string = splitQuery[1]
-    const urlWithoutQueryAndHash: string = splitQuery[0]
-    const queryParts = (queryString || '').split('&')
-
-    // use an array of strings rather than an object to preserve ordering and duplicates
-    const paramStrings: string[] = []
-
-    for (let i = 0; i < queryParts.length; i++) {
-        const keyValuePair = queryParts[i].split('=')
-        if (!isArray(keyValuePair)) {
-            continue
-        } else if (maskedParams.includes(keyValuePair[0])) {
-            paramStrings.push(keyValuePair[0] + '=' + mask)
-        } else {
-            paramStrings.push(queryParts[i])
-        }
-    }
-
-    let result = urlWithoutQueryAndHash
-    if (queryString != null) {
-        result += '?' + paramStrings.join('&')
-    }
-    if (hash != null) {
-        result += '#' + hash
-    }
-
-    return result as any
-}
-
-export const _getHashParam = function (hash: string, param: string): string | null {
-    const matches = hash.match(new RegExp(param + '=([^&]*)'))
-    return matches ? matches[1] : null
-}
-
-export const isLocalhost = (): boolean => {
-    return localDomains.includes(location.hostname)
-}

package/src/utils/simple-event-emitter.ts

@@ -1,27 +0,0 @@
-export class SimpleEventEmitter {
-    private _events: { [key: string]: ((...args: any[]) => void)[] } = {}
-
-    constructor() {
-        this._events = {}
-    }
-
-    on(event: string, listener: (...args: any[]) => void): () => void {
-        if (!this._events[event]) {
-            this._events[event] = []
-        }
-        this._events[event].push(listener)
-
-        return () => {
-            this._events[event] = this._events[event].filter((x) => x !== listener)
-        }
-    }
-
-    emit(event: string, payload: any): void {
-        for (const listener of this._events[event] || []) {
-            listener(payload)
-        }
-        for (const listener of this._events['*'] || []) {
-            listener(event, payload)
-        }
-    }
-}

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

@@ -1,357 +0,0 @@
-import { isFunction, isUndefined, includes } from '@posthog/core'
-
-/**
- * this device detection code is (at time of writing) about 3% of the size of the entire library
- * this is mostly because the identifiers user in regexes and results can't be minified away since
- * they have meaning
- *
- * so, there are some pre-uglifying choices in the code to help reduce the size
- * e.g. many repeated strings are stored as variables and then old-fashioned concatenated together
- *
- * TL;DR here be dragons
- */
-const FACEBOOK = 'Facebook'
-const MOBILE = 'Mobile'
-const IOS = 'iOS'
-const ANDROID = 'Android'
-const TABLET = 'Tablet'
-const ANDROID_TABLET = ANDROID + ' ' + TABLET
-const IPAD = 'iPad'
-const APPLE = 'Apple'
-const APPLE_WATCH = APPLE + ' Watch'
-const SAFARI = 'Safari'
-const BLACKBERRY = 'BlackBerry'
-const SAMSUNG = 'Samsung'
-const SAMSUNG_BROWSER = SAMSUNG + 'Browser'
-const SAMSUNG_INTERNET = SAMSUNG + ' Internet'
-const CHROME = 'Chrome'
-const CHROME_OS = CHROME + ' OS'
-const CHROME_IOS = CHROME + ' ' + IOS
-const INTERNET_EXPLORER = 'Internet Explorer'
-const INTERNET_EXPLORER_MOBILE = INTERNET_EXPLORER + ' ' + MOBILE
-const OPERA = 'Opera'
-const OPERA_MINI = OPERA + ' Mini'
-const EDGE = 'Edge'
-const MICROSOFT_EDGE = 'Microsoft ' + EDGE
-const FIREFOX = 'Firefox'
-const FIREFOX_IOS = FIREFOX + ' ' + IOS
-const NINTENDO = 'Nintendo'
-const PLAYSTATION = 'PlayStation'
-const XBOX = 'Xbox'
-const ANDROID_MOBILE = ANDROID + ' ' + MOBILE
-const MOBILE_SAFARI = MOBILE + ' ' + SAFARI
-const WINDOWS = 'Windows'
-const WINDOWS_PHONE = WINDOWS + ' Phone'
-const NOKIA = 'Nokia'
-const OUYA = 'Ouya'
-const GENERIC = 'Generic'
-const GENERIC_MOBILE = GENERIC + ' ' + MOBILE.toLowerCase()
-const GENERIC_TABLET = GENERIC + ' ' + TABLET.toLowerCase()
-const KONQUEROR = 'Konqueror'
-
-const BROWSER_VERSION_REGEX_SUFFIX = '(\\d+(\\.\\d+)?)'
-const DEFAULT_BROWSER_VERSION_REGEX = new RegExp('Version/' + BROWSER_VERSION_REGEX_SUFFIX)
-
-const XBOX_REGEX = new RegExp(XBOX, 'i')
-const PLAYSTATION_REGEX = new RegExp(PLAYSTATION + ' \\w+', 'i')
-const NINTENDO_REGEX = new RegExp(NINTENDO + ' \\w+', 'i')
-const BLACKBERRY_REGEX = new RegExp(BLACKBERRY + '|PlayBook|BB10', 'i')
-
-const windowsVersionMap: Record<string, string> = {
-    'NT3.51': 'NT 3.11',
-    'NT4.0': 'NT 4.0',
-    '5.0': '2000',
-    '5.1': 'XP',
-    '5.2': 'XP',
-    '6.0': 'Vista',
-    '6.1': '7',
-    '6.2': '8',
-    '6.3': '8.1',
-    '6.4': '10',
-    '10.0': '10',
-}
-
-/**
- * Safari detection turns out to be complicated. For e.g. https://stackoverflow.com/a/29696509
- * We can be slightly loose because some options have been ruled out (e.g. firefox on iOS)
- * before this check is made
- */
-function isSafari(userAgent: string): boolean {
-    return includes(userAgent, SAFARI) && !includes(userAgent, CHROME) && !includes(userAgent, ANDROID)
-}
-
-const safariCheck = (ua: string, vendor?: string) => (vendor && includes(vendor, APPLE)) || isSafari(ua)
-
-/**
- * This function detects which browser is running this script.
- * The order of the checks are important since many user agents
- * include keywords used in later checks.
- */
-export const detectBrowser = function (user_agent: string, vendor: string | undefined): string {
-    vendor = vendor || '' // vendor is undefined for at least IE9
-
-    if (includes(user_agent, ' OPR/') && includes(user_agent, 'Mini')) {
-        return OPERA_MINI
-    } else if (includes(user_agent, ' OPR/')) {
-        return OPERA
-    } else if (BLACKBERRY_REGEX.test(user_agent)) {
-        return BLACKBERRY
-    } else if (includes(user_agent, 'IE' + MOBILE) || includes(user_agent, 'WPDesktop')) {
-        return INTERNET_EXPLORER_MOBILE
-    }
-    // https://developer.samsung.com/internet/user-agent-string-format
-    else if (includes(user_agent, SAMSUNG_BROWSER)) {
-        return SAMSUNG_INTERNET
-    } else if (includes(user_agent, EDGE) || includes(user_agent, 'Edg/')) {
-        return MICROSOFT_EDGE
-    } else if (includes(user_agent, 'FBIOS')) {
-        return FACEBOOK + ' ' + MOBILE
-    } else if (includes(user_agent, 'UCWEB') || includes(user_agent, 'UCBrowser')) {
-        return 'UC Browser'
-    } else if (includes(user_agent, 'CriOS')) {
-        return CHROME_IOS // why not just Chrome?
-    } else if (includes(user_agent, 'CrMo')) {
-        return CHROME
-    } else if (includes(user_agent, CHROME)) {
-        return CHROME
-    } else if (includes(user_agent, ANDROID) && includes(user_agent, SAFARI)) {
-        return ANDROID_MOBILE
-    } else if (includes(user_agent, 'FxiOS')) {
-        return FIREFOX_IOS
-    } else if (includes(user_agent.toLowerCase(), KONQUEROR.toLowerCase())) {
-        return KONQUEROR
-    } else if (safariCheck(user_agent, vendor)) {
-        return includes(user_agent, MOBILE) ? MOBILE_SAFARI : SAFARI
-    } else if (includes(user_agent, FIREFOX)) {
-        return FIREFOX
-    } else if (includes(user_agent, 'MSIE') || includes(user_agent, 'Trident/')) {
-        return INTERNET_EXPLORER
-    } else if (includes(user_agent, 'Gecko')) {
-        return FIREFOX
-    }
-
-    return ''
-}
-
-const versionRegexes: Record<string, RegExp[]> = {
-    [INTERNET_EXPLORER_MOBILE]: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [MICROSOFT_EDGE]: [new RegExp(EDGE + '?\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [CHROME]: [new RegExp('(' + CHROME + '|CrMo)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [CHROME_IOS]: [new RegExp('CriOS\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    'UC Browser': [new RegExp('(UCBrowser|UCWEB)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],
-    [MOBILE_SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],
-    [OPERA]: [new RegExp('(' + OPERA + '|OPR)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [FIREFOX]: [new RegExp(FIREFOX + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [FIREFOX_IOS]: [new RegExp('FxiOS\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [KONQUEROR]: [new RegExp('Konqueror[:/]?' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],
-    // not every blackberry user agent has the version after the name
-    [BLACKBERRY]: [new RegExp(BLACKBERRY + ' ' + BROWSER_VERSION_REGEX_SUFFIX), DEFAULT_BROWSER_VERSION_REGEX],
-    [ANDROID_MOBILE]: [new RegExp('android\\s' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],
-    [SAMSUNG_INTERNET]: [new RegExp(SAMSUNG_BROWSER + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
-    [INTERNET_EXPLORER]: [new RegExp('(rv:|MSIE )' + BROWSER_VERSION_REGEX_SUFFIX)],
-    Mozilla: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],
-}
-
-/**
- * This function detects which browser version is running this script,
- * parsing major and minor version (e.g., 42.1). User agent strings from:
- * http://www.useragentstring.com/pages/useragentstring.php
- *
- * `navigator.vendor` is passed in and used to help with detecting certain browsers
- * NB `navigator.vendor` is deprecated and not present in every browser
- */
-export const detectBrowserVersion = function (userAgent: string, vendor: string | undefined): number | null {
-    const browser = detectBrowser(userAgent, vendor)
-    const regexes: RegExp[] | undefined = versionRegexes[browser as keyof typeof versionRegexes]
-    if (isUndefined(regexes)) {
-        return null
-    }
-
-    for (let i = 0; i < regexes.length; i++) {
-        const regex = regexes[i]
-        const matches = userAgent.match(regex)
-        if (matches) {
-            return parseFloat(matches[matches.length - 2])
-        }
-    }
-    return null
-}
-
-// to avoid repeating regexes or calling them twice, we have an array of matches
-// the first regex that matches uses its matcher function to return the result
-const osMatchers: [
-    RegExp,
-    [string, string] | ((match: RegExpMatchArray | null, user_agent: string) => [string, string]),
-][] = [
-    [
-        new RegExp(XBOX + '; ' + XBOX + ' (.*?)[);]', 'i'),
-        (match) => {
-            return [XBOX, (match && match[1]) || '']
-        },
-    ],
-    [new RegExp(NINTENDO, 'i'), [NINTENDO, '']],
-    [new RegExp(PLAYSTATION, 'i'), [PLAYSTATION, '']],
-    [BLACKBERRY_REGEX, [BLACKBERRY, '']],
-    [
-        new RegExp(WINDOWS, 'i'),
-        (_, user_agent) => {
-            if (/Phone/.test(user_agent) || /WPDesktop/.test(user_agent)) {
-                return [WINDOWS_PHONE, '']
-            }
-            // not all JS versions support negative lookbehind, so we need two checks here
-            if (new RegExp(MOBILE).test(user_agent) && !/IEMobile\b/.test(user_agent)) {
-                return [WINDOWS + ' ' + MOBILE, '']
-            }
-            const match = /Windows NT ([0-9.]+)/i.exec(user_agent)
-            if (match && match[1]) {
-                const version = match[1]
-                let osVersion = windowsVersionMap[version] || ''
-                if (/arm/i.test(user_agent)) {
-                    osVersion = 'RT'
-                }
-                return [WINDOWS, osVersion]
-            }
-            return [WINDOWS, '']
-        },
-    ],
-    [
-        /((iPhone|iPad|iPod).*?OS (\d+)_(\d+)_?(\d+)?|iPhone)/,
-        (match) => {
-            if (match && match[3]) {
-                const versionParts = [match[3], match[4], match[5] || '0']
-                return [IOS, versionParts.join('.')]
-            }
-            return [IOS, '']
-        },
-    ],
-    [
-        /(watch.*\/(\d+\.\d+\.\d+)|watch os,(\d+\.\d+),)/i,
-        (match) => {
-            // e.g. Watch4,3/5.3.8 (16U680)
-            let version = ''
-            if (match && match.length >= 3) {
-                version = isUndefined(match[2]) ? match[3] : match[2]
-            }
-            return ['watchOS', version]
-        },
-    ],
-    [
-        new RegExp('(' + ANDROID + ' (\\d+)\\.(\\d+)\\.?(\\d+)?|' + ANDROID + ')', 'i'),
-        (match) => {
-            if (match && match[2]) {
-                const versionParts = [match[2], match[3], match[4] || '0']
-                return [ANDROID, versionParts.join('.')]
-            }
-            return [ANDROID, '']
-        },
-    ],
-    [
-        /Mac OS X (\d+)[_.](\d+)[_.]?(\d+)?/i,
-        (match) => {
-            const result: [string, string] = ['Mac OS X', '']
-            if (match && match[1]) {
-                const versionParts = [match[1], match[2], match[3] || '0']
-                result[1] = versionParts.join('.')
-            }
-            return result
-        },
-    ],
-    [
-        /Mac/i,
-        // mop up a few non-standard UAs that should match mac
-        ['Mac OS X', ''],
-    ],
-    [/CrOS/, [CHROME_OS, '']],
-    [/Linux|debian/i, ['Linux', '']],
-]
-
-export const detectOS = function (user_agent: string): [string, string] {
-    for (let i = 0; i < osMatchers.length; i++) {
-        const [rgex, resultOrFn] = osMatchers[i]
-        const match = rgex.exec(user_agent)
-        const result = match && (isFunction(resultOrFn) ? resultOrFn(match, user_agent) : resultOrFn)
-        if (result) {
-            return result
-        }
-    }
-    return ['', '']
-}
-
-export const detectDevice = function (user_agent: string): string {
-    if (NINTENDO_REGEX.test(user_agent)) {
-        return NINTENDO
-    } else if (PLAYSTATION_REGEX.test(user_agent)) {
-        return PLAYSTATION
-    } else if (XBOX_REGEX.test(user_agent)) {
-        return XBOX
-    } else if (new RegExp(OUYA, 'i').test(user_agent)) {
-        return OUYA
-    } else if (new RegExp('(' + WINDOWS_PHONE + '|WPDesktop)', 'i').test(user_agent)) {
-        return WINDOWS_PHONE
-    } else if (/iPad/.test(user_agent)) {
-        return IPAD
-    } else if (/iPod/.test(user_agent)) {
-        return 'iPod Touch'
-    } else if (/iPhone/.test(user_agent)) {
-        return 'iPhone'
-    } else if (/(watch)(?: ?os[,/]|\d,\d\/)[\d.]+/i.test(user_agent)) {
-        return APPLE_WATCH
-    } else if (BLACKBERRY_REGEX.test(user_agent)) {
-        return BLACKBERRY
-    } else if (/(kobo)\s(ereader|touch)/i.test(user_agent)) {
-        return 'Kobo'
-    } else if (new RegExp(NOKIA, 'i').test(user_agent)) {
-        return NOKIA
-    } else if (
-        // Kindle Fire without Silk / Echo Show
-        /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\))/i.test(user_agent) ||
-        // Kindle Fire HD
-        /(kf[a-z]+)( bui|\)).+silk\//i.test(user_agent)
-    ) {
-        return 'Kindle Fire'
-    } else if (/(Android|ZTE)/i.test(user_agent)) {
-        if (
-            !new RegExp(MOBILE).test(user_agent) ||
-            /(9138B|TB782B|Nexus [97]|pixel c|HUAWEISHT|BTV|noble nook|smart ultra 6)/i.test(user_agent)
-        ) {
-            if (
-                (/pixel[\daxl ]{1,6}/i.test(user_agent) && !/pixel c/i.test(user_agent)) ||
-                /(huaweimed-al00|tah-|APA|SM-G92|i980|zte|U304AA)/i.test(user_agent) ||
-                (/lmy47v/i.test(user_agent) && !/QTAQZ3/i.test(user_agent))
-            ) {
-                return ANDROID
-            }
-            return ANDROID_TABLET
-        } else {
-            return ANDROID
-        }
-    } else if (new RegExp('(pda|' + MOBILE + ')', 'i').test(user_agent)) {
-        return GENERIC_MOBILE
-    } else if (new RegExp(TABLET, 'i').test(user_agent) && !new RegExp(TABLET + ' pc', 'i').test(user_agent)) {
-        return GENERIC_TABLET
-    } else {
-        return ''
-    }
-}
-
-export const detectDeviceType = function (user_agent: string): string {
-    const device = detectDevice(user_agent)
-    if (
-        device === IPAD ||
-        device === ANDROID_TABLET ||
-        device === 'Kobo' ||
-        device === 'Kindle Fire' ||
-        device === GENERIC_TABLET
-    ) {
-        return TABLET
-    } else if (device === NINTENDO || device === XBOX || device === PLAYSTATION || device === OUYA) {
-        return 'Console'
-    } else if (device === APPLE_WATCH) {
-        return 'Wearable'
-    } else if (device) {
-        return MOBILE
-    } else {
-        return 'Desktop'
-    }
-}

package/src/version.ts

@@ -1 +0,0 @@
-export const version = '0.1.3'