@leanbase.com/js 0.1.1 → 0.1.2

package/src/utils/index.ts

@@ -0,0 +1,222 @@
+import { isFormData, isNull, isNullish, hasOwnProperty, isArray, isString, isNumber } from '@posthog/core'
+import { Properties } from '../types'
+
+const breaker: Breaker = {}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export type Breaker = {}
+
+export const ArrayProto = Array.prototype
+export const nativeForEach = ArrayProto.forEach
+export const nativeIndexOf = ArrayProto.indexOf
+
+const win: (Window & typeof globalThis) | undefined = typeof window !== 'undefined' ? window : undefined
+const global: typeof globalThis | undefined = typeof globalThis !== 'undefined' ? globalThis : win
+export const navigator = global?.navigator
+export const document = global?.document
+export const location = global?.location
+export const fetch = global?.fetch
+export const XMLHttpRequest =
+    global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined
+export const AbortController = global?.AbortController
+export const userAgent = navigator?.userAgent
+export { win as window }
+
+export function eachArray<E = any>(
+    obj: E[] | null | undefined,
+    iterator: (value: E, key: number) => void | Breaker,
+    thisArg?: any
+): void {
+    if (isArray(obj)) {
+        if (nativeForEach && obj.forEach === nativeForEach) {
+            obj.forEach(iterator, thisArg)
+        } else if ('length' in obj && obj.length === +obj.length) {
+            for (let i = 0, l = obj.length; i < l; i++) {
+                if (i in obj && iterator.call(thisArg, obj[i], i) === breaker) {
+                    return
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @param {*=} obj
+ * @param {function(...*)=} iterator
+ * @param {Object=} thisArg
+ */
+export function each(obj: any, iterator: (value: any, key: any) => void | Breaker, thisArg?: any): void {
+    if (isNullish(obj)) {
+        return
+    }
+    if (isArray(obj)) {
+        return eachArray(obj, iterator, thisArg)
+    }
+    if (isFormData(obj)) {
+        for (const pair of obj.entries()) {
+            if (iterator.call(thisArg, pair[1], pair[0]) === breaker) {
+                return
+            }
+        }
+        return
+    }
+    for (const key in obj) {
+        if (hasOwnProperty.call(obj, key)) {
+            if (iterator.call(thisArg, obj[key], key) === breaker) {
+                return
+            }
+        }
+    }
+}
+
+export const extend = function (obj: Record<string, any>, ...args: Record<string, any>[]): Record<string, any> {
+    eachArray(args, function (source) {
+        for (const prop in source) {
+            if (source[prop] !== void 0) {
+                obj[prop] = source[prop]
+            }
+        }
+    })
+    return obj
+}
+
+export const extendArray = function <T>(obj: T[], ...args: T[][]): T[] {
+    eachArray(args, function (source) {
+        eachArray(source, function (item) {
+            obj.push(item)
+        })
+    })
+    return obj
+}
+
+export const include = function (
+    obj: null | string | Array<any> | Record<string, any>,
+    target: any
+): boolean | Breaker {
+    let found = false
+    if (isNull(obj)) {
+        return found
+    }
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) {
+        return obj.indexOf(target) != -1
+    }
+    each(obj, function (value) {
+        if (found || (found = value === target)) {
+            return breaker
+        }
+        return
+    })
+    return found
+}
+
+/**
+ * Object.entries() polyfill
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+ */
+export function entries<T = any>(obj: Record<string, T>): [string, T][] {
+    const ownProps = Object.keys(obj)
+    let i = ownProps.length
+    const resArray = new Array(i) // preallocate the Array
+
+    while (i--) {
+        resArray[i] = [ownProps[i], obj[ownProps[i]]]
+    }
+    return resArray
+}
+
+export function addEventListener(
+    element: Window | Document | Element | undefined,
+    event: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions
+): void {
+    const { capture = false, passive = true } = options ?? {}
+
+    // This is the only place where we are allowed to call this function
+    // because the whole idea is that we should be calling this instead of the built-in one
+    // eslint-disable-next-line posthog-js/no-add-event-listener
+    element?.addEventListener(event, callback, { capture, passive })
+}
+
+export const stripEmptyProperties = function (p: Properties): Properties {
+    const ret: Properties = {}
+    each(p, function (v, k) {
+        if ((isString(v) && v.length > 0) || isNumber(v)) {
+            ret[k] = v
+        }
+    })
+    return ret
+}
+
+const EXCLUDED_FROM_CROSS_SUBDOMAIN_COOKIE = ['herokuapp.com', 'vercel.app', 'netlify.app']
+export function isCrossDomainCookie(documentLocation: Location | undefined) {
+    const hostname = documentLocation?.hostname
+
+    if (!isString(hostname)) {
+        return false
+    }
+    // split and slice isn't a great way to match arbitrary domains,
+    // but it's good enough for ensuring we only match herokuapp.com when it is the TLD
+    // for the hostname
+    const lastTwoParts = hostname.split('.').slice(-2).join('.')
+
+    for (const excluded of EXCLUDED_FROM_CROSS_SUBDOMAIN_COOKIE) {
+        if (lastTwoParts === excluded) {
+            return false
+        }
+    }
+
+    return true
+}
+
+/**
+ * Deep copies an object.
+ * It handles cycles by replacing all references to them with `undefined`
+ * Also supports customizing native values
+ *
+ * @param value
+ * @param customizer
+ * @returns {{}|undefined|*}
+ */
+function deepCircularCopy<T extends Record<string, any> = Record<string, any>>(
+    value: T,
+    customizer?: <K extends keyof T = keyof T>(value: T[K], key?: K) => T[K]
+): T | undefined {
+    const COPY_IN_PROGRESS_SET = new Set()
+
+    function internalDeepCircularCopy(value: T, key?: string): T | undefined {
+        if (value !== Object(value)) return customizer ? customizer(value as any, key) : value // primitive value
+
+        if (COPY_IN_PROGRESS_SET.has(value)) return undefined
+        COPY_IN_PROGRESS_SET.add(value)
+        let result: T
+
+        if (isArray(value)) {
+            result = [] as any as T
+            eachArray(value, (it) => {
+                result.push(internalDeepCircularCopy(it))
+            })
+        } else {
+            result = {} as T
+            each(value, (val, key) => {
+                if (!COPY_IN_PROGRESS_SET.has(val)) {
+                    ;(result as any)[key] = internalDeepCircularCopy(val, key)
+                }
+            })
+        }
+        return result
+    }
+    return internalDeepCircularCopy(value)
+}
+
+export function copyAndTruncateStrings<T extends Record<string, any> = Record<string, any>>(
+    object: T,
+    maxStringLength: number | null
+): T {
+    return deepCircularCopy(object, (value: any) => {
+        if (isString(value) && !isNull(maxStringLength)) {
+            return (value as string).slice(0, maxStringLength)
+        }
+        return value
+    }) as T
+}

package/src/utils/request-utils.ts

@@ -0,0 +1,128 @@
+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

@@ -0,0 +1,27 @@
+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)
+        }
+    }
+}